2007-08-12 09:33:16 -06:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 2002-2005 Sam Leffler, Errno Consulting
|
|
|
|
* Copyright (c) 2004-2005 Atheros Communications, Inc.
|
|
|
|
* Copyright (c) 2006 Devicescape Software, Inc.
|
|
|
|
* Copyright (c) 2007 Jiri Slaby <jirislaby@gmail.com>
|
|
|
|
* Copyright (c) 2007 Luis R. Rodriguez <mcgrof@winlab.rutgers.edu>
|
|
|
|
*
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer,
|
|
|
|
* without modification.
|
|
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
|
|
* similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
|
|
|
|
* redistribution must be conditioned upon including a substantially
|
|
|
|
* similar Disclaimer requirement for further binary redistribution.
|
|
|
|
* 3. Neither the names of the above-listed copyright holders nor the names
|
|
|
|
* of any contributors may be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* Alternatively, this software may be distributed under the terms of the
|
|
|
|
* GNU General Public License ("GPL") version 2 as published by the Free
|
|
|
|
* Software Foundation.
|
|
|
|
*
|
|
|
|
* NO WARRANTY
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
|
|
|
|
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
|
|
* THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
|
|
|
|
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
|
|
|
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
|
|
* THE POSSIBILITY OF SUCH DAMAGES.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/delay.h>
|
2008-07-15 09:44:20 -06:00
|
|
|
#include <linux/hardirq.h>
|
2007-08-12 09:33:16 -06:00
|
|
|
#include <linux/if.h>
|
2008-07-15 09:44:20 -06:00
|
|
|
#include <linux/io.h>
|
2007-08-12 09:33:16 -06:00
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/cache.h>
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include <linux/uaccess.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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2010-09-30 13:22:58 -06:00
|
|
|
#include <linux/etherdevice.h>
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
#include <net/ieee80211_radiotap.h>
|
|
|
|
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
|
|
|
#include "base.h"
|
|
|
|
#include "reg.h"
|
|
|
|
#include "debug.h"
|
2010-04-02 03:44:08 -06:00
|
|
|
#include "ani.h"
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2011-01-24 21:32:55 -07:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include "trace.h"
|
|
|
|
|
2011-01-05 07:39:59 -07:00
|
|
|
int ath5k_modparam_nohwcrypt;
|
|
|
|
module_param_named(nohwcrypt, ath5k_modparam_nohwcrypt, bool, S_IRUGO);
|
2008-10-29 06:30:54 -06:00
|
|
|
MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2009-03-30 06:05:29 -06:00
|
|
|
static int modparam_all_channels;
|
2009-04-15 05:57:34 -06:00
|
|
|
module_param_named(all_channels, modparam_all_channels, bool, S_IRUGO);
|
2009-03-30 06:05:29 -06:00
|
|
|
MODULE_PARM_DESC(all_channels, "Expose all channels the device can use.");
|
|
|
|
|
2011-06-01 18:09:48 -06:00
|
|
|
static int modparam_fastchanswitch;
|
|
|
|
module_param_named(fastchanswitch, modparam_fastchanswitch, bool, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(fastchanswitch, "Enable fast channel switching for AR2413/AR5413 radios.");
|
|
|
|
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
/* Module info */
|
|
|
|
MODULE_AUTHOR("Jiri Slaby");
|
|
|
|
MODULE_AUTHOR("Nick Kossifidis");
|
|
|
|
MODULE_DESCRIPTION("Support for 5xxx series of Atheros 802.11 wireless LAN cards.");
|
|
|
|
MODULE_SUPPORTED_DEVICE("Atheros 5xxx WLAN cards");
|
|
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
|
|
|
2010-12-02 02:26:56 -07:00
|
|
|
static int ath5k_init(struct ieee80211_hw *hw);
|
2010-11-23 12:39:28 -07:00
|
|
|
static int ath5k_reset(struct ath5k_softc *sc, struct ieee80211_channel *chan,
|
|
|
|
bool skip_pcu);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
/* Known SREVs */
|
2009-03-07 02:26:41 -07:00
|
|
|
static const struct ath5k_srev_name srev_names[] = {
|
2010-12-02 02:27:16 -07:00
|
|
|
#ifdef CONFIG_ATHEROS_AR231X
|
|
|
|
{ "5312", AR5K_VERSION_MAC, AR5K_SREV_AR5312_R2 },
|
|
|
|
{ "5312", AR5K_VERSION_MAC, AR5K_SREV_AR5312_R7 },
|
|
|
|
{ "2313", AR5K_VERSION_MAC, AR5K_SREV_AR2313_R8 },
|
|
|
|
{ "2315", AR5K_VERSION_MAC, AR5K_SREV_AR2315_R6 },
|
|
|
|
{ "2315", AR5K_VERSION_MAC, AR5K_SREV_AR2315_R7 },
|
|
|
|
{ "2317", AR5K_VERSION_MAC, AR5K_SREV_AR2317_R1 },
|
|
|
|
{ "2317", AR5K_VERSION_MAC, AR5K_SREV_AR2317_R2 },
|
|
|
|
#else
|
2008-09-28 17:09:09 -06:00
|
|
|
{ "5210", AR5K_VERSION_MAC, AR5K_SREV_AR5210 },
|
|
|
|
{ "5311", AR5K_VERSION_MAC, AR5K_SREV_AR5311 },
|
|
|
|
{ "5311A", AR5K_VERSION_MAC, AR5K_SREV_AR5311A },
|
|
|
|
{ "5311B", AR5K_VERSION_MAC, AR5K_SREV_AR5311B },
|
|
|
|
{ "5211", AR5K_VERSION_MAC, AR5K_SREV_AR5211 },
|
|
|
|
{ "5212", AR5K_VERSION_MAC, AR5K_SREV_AR5212 },
|
|
|
|
{ "5213", AR5K_VERSION_MAC, AR5K_SREV_AR5213 },
|
|
|
|
{ "5213A", AR5K_VERSION_MAC, AR5K_SREV_AR5213A },
|
|
|
|
{ "2413", AR5K_VERSION_MAC, AR5K_SREV_AR2413 },
|
|
|
|
{ "2414", AR5K_VERSION_MAC, AR5K_SREV_AR2414 },
|
|
|
|
{ "5424", AR5K_VERSION_MAC, AR5K_SREV_AR5424 },
|
|
|
|
{ "5413", AR5K_VERSION_MAC, AR5K_SREV_AR5413 },
|
|
|
|
{ "5414", AR5K_VERSION_MAC, AR5K_SREV_AR5414 },
|
|
|
|
{ "2415", AR5K_VERSION_MAC, AR5K_SREV_AR2415 },
|
|
|
|
{ "5416", AR5K_VERSION_MAC, AR5K_SREV_AR5416 },
|
|
|
|
{ "5418", AR5K_VERSION_MAC, AR5K_SREV_AR5418 },
|
|
|
|
{ "2425", AR5K_VERSION_MAC, AR5K_SREV_AR2425 },
|
|
|
|
{ "2417", AR5K_VERSION_MAC, AR5K_SREV_AR2417 },
|
2010-12-02 02:27:16 -07:00
|
|
|
#endif
|
2008-09-28 17:09:09 -06:00
|
|
|
{ "xxxxx", AR5K_VERSION_MAC, AR5K_SREV_UNKNOWN },
|
2007-08-12 09:33:16 -06:00
|
|
|
{ "5110", AR5K_VERSION_RAD, AR5K_SREV_RAD_5110 },
|
|
|
|
{ "5111", AR5K_VERSION_RAD, AR5K_SREV_RAD_5111 },
|
2008-09-28 17:09:09 -06:00
|
|
|
{ "5111A", AR5K_VERSION_RAD, AR5K_SREV_RAD_5111A },
|
2007-08-12 09:33:16 -06:00
|
|
|
{ "2111", AR5K_VERSION_RAD, AR5K_SREV_RAD_2111 },
|
|
|
|
{ "5112", AR5K_VERSION_RAD, AR5K_SREV_RAD_5112 },
|
|
|
|
{ "5112A", AR5K_VERSION_RAD, AR5K_SREV_RAD_5112A },
|
2008-09-28 17:09:09 -06:00
|
|
|
{ "5112B", AR5K_VERSION_RAD, AR5K_SREV_RAD_5112B },
|
2007-08-12 09:33:16 -06:00
|
|
|
{ "2112", AR5K_VERSION_RAD, AR5K_SREV_RAD_2112 },
|
|
|
|
{ "2112A", AR5K_VERSION_RAD, AR5K_SREV_RAD_2112A },
|
2008-09-28 17:09:09 -06:00
|
|
|
{ "2112B", AR5K_VERSION_RAD, AR5K_SREV_RAD_2112B },
|
|
|
|
{ "2413", AR5K_VERSION_RAD, AR5K_SREV_RAD_2413 },
|
|
|
|
{ "5413", AR5K_VERSION_RAD, AR5K_SREV_RAD_5413 },
|
|
|
|
{ "5424", AR5K_VERSION_RAD, AR5K_SREV_RAD_5424 },
|
2007-08-12 09:33:16 -06:00
|
|
|
{ "5133", AR5K_VERSION_RAD, AR5K_SREV_RAD_5133 },
|
2010-12-02 02:27:16 -07:00
|
|
|
#ifdef CONFIG_ATHEROS_AR231X
|
|
|
|
{ "2316", AR5K_VERSION_RAD, AR5K_SREV_RAD_2316 },
|
|
|
|
{ "2317", AR5K_VERSION_RAD, AR5K_SREV_RAD_2317 },
|
|
|
|
#endif
|
2007-08-12 09:33:16 -06:00
|
|
|
{ "xxxxx", AR5K_VERSION_RAD, AR5K_SREV_UNKNOWN },
|
|
|
|
};
|
|
|
|
|
2009-03-07 02:26:41 -07:00
|
|
|
static const struct ieee80211_rate ath5k_rates[] = {
|
2008-07-30 09:12:58 -06:00
|
|
|
{ .bitrate = 10,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_1M, },
|
|
|
|
{ .bitrate = 20,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_2M,
|
|
|
|
.hw_value_short = ATH5K_RATE_CODE_2M | AR5K_SET_SHORT_PREAMBLE,
|
|
|
|
.flags = IEEE80211_RATE_SHORT_PREAMBLE },
|
|
|
|
{ .bitrate = 55,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_5_5M,
|
|
|
|
.hw_value_short = ATH5K_RATE_CODE_5_5M | AR5K_SET_SHORT_PREAMBLE,
|
|
|
|
.flags = IEEE80211_RATE_SHORT_PREAMBLE },
|
|
|
|
{ .bitrate = 110,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_11M,
|
|
|
|
.hw_value_short = ATH5K_RATE_CODE_11M | AR5K_SET_SHORT_PREAMBLE,
|
|
|
|
.flags = IEEE80211_RATE_SHORT_PREAMBLE },
|
|
|
|
{ .bitrate = 60,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_6M,
|
|
|
|
.flags = 0 },
|
|
|
|
{ .bitrate = 90,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_9M,
|
|
|
|
.flags = 0 },
|
|
|
|
{ .bitrate = 120,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_12M,
|
|
|
|
.flags = 0 },
|
|
|
|
{ .bitrate = 180,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_18M,
|
|
|
|
.flags = 0 },
|
|
|
|
{ .bitrate = 240,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_24M,
|
|
|
|
.flags = 0 },
|
|
|
|
{ .bitrate = 360,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_36M,
|
|
|
|
.flags = 0 },
|
|
|
|
{ .bitrate = 480,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_48M,
|
|
|
|
.flags = 0 },
|
|
|
|
{ .bitrate = 540,
|
|
|
|
.hw_value = ATH5K_RATE_CODE_54M,
|
|
|
|
.flags = 0 },
|
|
|
|
/* XR missing */
|
|
|
|
};
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
static inline u64 ath5k_extend_tsf(struct ath5k_hw *ah, u32 rstamp)
|
|
|
|
{
|
|
|
|
u64 tsf = ath5k_hw_get_tsf64(ah);
|
|
|
|
|
|
|
|
if ((tsf & 0x7fff) < rstamp)
|
|
|
|
tsf -= 0x8000;
|
|
|
|
|
|
|
|
return (tsf & ~0x7fff) | rstamp;
|
|
|
|
}
|
|
|
|
|
2010-12-02 02:27:01 -07:00
|
|
|
const char *
|
2007-08-12 09:33:16 -06:00
|
|
|
ath5k_chip_name(enum ath5k_srev_type type, u_int16_t val)
|
|
|
|
{
|
|
|
|
const char *name = "xxxxx";
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(srev_names); i++) {
|
|
|
|
if (srev_names[i].sr_type != type)
|
|
|
|
continue;
|
2008-09-28 16:24:44 -06:00
|
|
|
|
|
|
|
if ((val & 0xf0) == srev_names[i].sr_val)
|
|
|
|
name = srev_names[i].sr_name;
|
|
|
|
|
|
|
|
if ((val & 0xff) == srev_names[i].sr_val) {
|
2007-08-12 09:33:16 -06:00
|
|
|
name = srev_names[i].sr_name;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return name;
|
|
|
|
}
|
2009-09-10 17:55:11 -06:00
|
|
|
static unsigned int ath5k_ioread32(void *hw_priv, u32 reg_offset)
|
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = (struct ath5k_hw *) hw_priv;
|
|
|
|
return ath5k_hw_reg_read(ah, reg_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ath5k_iowrite32(void *hw_priv, u32 val, u32 reg_offset)
|
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = (struct ath5k_hw *) hw_priv;
|
|
|
|
ath5k_hw_reg_write(ah, val, reg_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct ath_ops ath5k_common_ops = {
|
|
|
|
.read = ath5k_ioread32,
|
|
|
|
.write = ath5k_iowrite32,
|
|
|
|
};
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/***********************\
|
|
|
|
* Driver Initialization *
|
|
|
|
\***********************/
|
|
|
|
|
|
|
|
static int ath5k_reg_notifier(struct wiphy *wiphy, struct regulatory_request *request)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
|
|
|
|
struct ath5k_softc *sc = hw->priv;
|
|
|
|
struct ath_regulatory *regulatory = ath5k_hw_regulatory(sc->ah);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
return ath_reg_notifier_apply(wiphy, request, regulatory);
|
|
|
|
}
|
2010-08-13 09:27:28 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/********************\
|
|
|
|
* Channel/mode setup *
|
|
|
|
\********************/
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Returns true for the channel numbers used without all_channels modparam.
|
|
|
|
*/
|
2011-01-19 02:20:57 -07:00
|
|
|
static bool ath5k_is_standard_channel(short chan, enum ieee80211_band band)
|
2010-09-16 21:45:07 -06:00
|
|
|
{
|
2011-01-19 02:20:57 -07:00
|
|
|
if (band == IEEE80211_BAND_2GHZ && chan <= 14)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return /* UNII 1,2 */
|
|
|
|
(((chan & 3) == 0 && chan >= 36 && chan <= 64) ||
|
2010-09-16 21:45:07 -06:00
|
|
|
/* midband */
|
|
|
|
((chan & 3) == 0 && chan >= 100 && chan <= 140) ||
|
|
|
|
/* UNII-3 */
|
2011-01-19 02:20:57 -07:00
|
|
|
((chan & 3) == 1 && chan >= 149 && chan <= 165) ||
|
|
|
|
/* 802.11j 5.030-5.080 GHz (20MHz) */
|
|
|
|
(chan == 8 || chan == 12 || chan == 16) ||
|
|
|
|
/* 802.11j 4.9GHz (20MHz) */
|
|
|
|
(chan == 184 || chan == 188 || chan == 192 || chan == 196));
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static unsigned int
|
2011-01-19 02:20:52 -07:00
|
|
|
ath5k_setup_channels(struct ath5k_hw *ah, struct ieee80211_channel *channels,
|
|
|
|
unsigned int mode, unsigned int max)
|
2010-09-16 21:45:07 -06:00
|
|
|
{
|
2011-01-20 20:19:52 -07:00
|
|
|
unsigned int count, size, chfreq, freq, ch;
|
2011-01-19 02:20:36 -07:00
|
|
|
enum ieee80211_band band;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
switch (mode) {
|
|
|
|
case AR5K_MODE_11A:
|
|
|
|
/* 1..220, but 2GHz frequencies are filtered by check_channel */
|
2011-01-19 02:20:52 -07:00
|
|
|
size = 220;
|
2010-09-16 21:45:07 -06:00
|
|
|
chfreq = CHANNEL_5GHZ;
|
2011-01-19 02:20:36 -07:00
|
|
|
band = IEEE80211_BAND_5GHZ;
|
2010-09-16 21:45:07 -06:00
|
|
|
break;
|
|
|
|
case AR5K_MODE_11B:
|
|
|
|
case AR5K_MODE_11G:
|
|
|
|
size = 26;
|
|
|
|
chfreq = CHANNEL_2GHZ;
|
2011-01-19 02:20:36 -07:00
|
|
|
band = IEEE80211_BAND_2GHZ;
|
2010-09-16 21:45:07 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ATH5K_WARN(ah->ah_sc, "bad mode, not copying channels\n");
|
|
|
|
return 0;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2011-01-20 20:19:52 -07:00
|
|
|
count = 0;
|
|
|
|
for (ch = 1; ch <= size && count < max; ch++) {
|
2011-01-19 02:20:36 -07:00
|
|
|
freq = ieee80211_channel_to_frequency(ch, band);
|
|
|
|
|
|
|
|
if (freq == 0) /* mapping failed - not a standard channel */
|
|
|
|
continue;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* Check if channel is supported by the chipset */
|
|
|
|
if (!ath5k_channel_ok(ah, freq, chfreq))
|
|
|
|
continue;
|
2008-08-29 17:26:43 -06:00
|
|
|
|
2011-01-19 02:20:57 -07:00
|
|
|
if (!modparam_all_channels &&
|
|
|
|
!ath5k_is_standard_channel(ch, band))
|
2010-09-16 21:45:07 -06:00
|
|
|
continue;
|
2008-08-29 17:26:43 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* Write channel info and increment counter */
|
|
|
|
channels[count].center_freq = freq;
|
2011-01-19 02:20:36 -07:00
|
|
|
channels[count].band = band;
|
2010-09-16 21:45:07 -06:00
|
|
|
switch (mode) {
|
|
|
|
case AR5K_MODE_11A:
|
|
|
|
case AR5K_MODE_11G:
|
|
|
|
channels[count].hw_value = chfreq | CHANNEL_OFDM;
|
|
|
|
break;
|
|
|
|
case AR5K_MODE_11B:
|
|
|
|
channels[count].hw_value = CHANNEL_B;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
count++;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
return count;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static void
|
|
|
|
ath5k_setup_rate_idx(struct ath5k_softc *sc, struct ieee80211_supported_band *b)
|
|
|
|
{
|
|
|
|
u8 i;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
for (i = 0; i < AR5K_MAX_RATES; i++)
|
|
|
|
sc->rate_idx[b->band][i] = -1;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
for (i = 0; i < b->n_bitrates; i++) {
|
|
|
|
sc->rate_idx[b->band][b->bitrates[i].hw_value] = i;
|
|
|
|
if (b->bitrates[i].hw_value_short)
|
|
|
|
sc->rate_idx[b->band][b->bitrates[i].hw_value_short] = i;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static int
|
|
|
|
ath5k_setup_bands(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = hw->priv;
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
int max_c, count_c = 0;
|
|
|
|
int i;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(sc->sbands) < IEEE80211_NUM_BANDS);
|
|
|
|
max_c = ARRAY_SIZE(sc->channels);
|
2009-09-10 12:20:57 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* 2GHz band */
|
|
|
|
sband = &sc->sbands[IEEE80211_BAND_2GHZ];
|
|
|
|
sband->band = IEEE80211_BAND_2GHZ;
|
|
|
|
sband->bitrates = &sc->rates[IEEE80211_BAND_2GHZ][0];
|
2009-09-10 19:04:47 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (test_bit(AR5K_MODE_11G, sc->ah->ah_capabilities.cap_mode)) {
|
|
|
|
/* G mode */
|
|
|
|
memcpy(sband->bitrates, &ath5k_rates[0],
|
|
|
|
sizeof(struct ieee80211_rate) * 12);
|
|
|
|
sband->n_bitrates = 12;
|
2008-10-05 10:05:48 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
sband->channels = sc->channels;
|
2011-01-19 02:20:47 -07:00
|
|
|
sband->n_channels = ath5k_setup_channels(ah, sband->channels,
|
2010-09-16 21:45:07 -06:00
|
|
|
AR5K_MODE_11G, max_c);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
|
|
|
|
count_c = sband->n_channels;
|
|
|
|
max_c -= count_c;
|
|
|
|
} else if (test_bit(AR5K_MODE_11B, sc->ah->ah_capabilities.cap_mode)) {
|
|
|
|
/* B mode */
|
|
|
|
memcpy(sband->bitrates, &ath5k_rates[0],
|
|
|
|
sizeof(struct ieee80211_rate) * 4);
|
|
|
|
sband->n_bitrates = 4;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* 5211 only supports B rates and uses 4bit rate codes
|
|
|
|
* (e.g normally we have 0x1B for 1M, but on 5211 we have 0x0B)
|
|
|
|
* fix them up here:
|
|
|
|
*/
|
|
|
|
if (ah->ah_version == AR5K_AR5211) {
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
sband->bitrates[i].hw_value =
|
|
|
|
sband->bitrates[i].hw_value & 0xF;
|
|
|
|
sband->bitrates[i].hw_value_short =
|
|
|
|
sband->bitrates[i].hw_value_short & 0xF;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
sband->channels = sc->channels;
|
2011-01-19 02:20:47 -07:00
|
|
|
sband->n_channels = ath5k_setup_channels(ah, sband->channels,
|
2010-09-16 21:45:07 -06:00
|
|
|
AR5K_MODE_11B, max_c);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
|
|
|
|
count_c = sband->n_channels;
|
|
|
|
max_c -= count_c;
|
|
|
|
}
|
|
|
|
ath5k_setup_rate_idx(sc, sband);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* 5GHz band, A mode */
|
|
|
|
if (test_bit(AR5K_MODE_11A, sc->ah->ah_capabilities.cap_mode)) {
|
|
|
|
sband = &sc->sbands[IEEE80211_BAND_5GHZ];
|
|
|
|
sband->band = IEEE80211_BAND_5GHZ;
|
|
|
|
sband->bitrates = &sc->rates[IEEE80211_BAND_5GHZ][0];
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
memcpy(sband->bitrates, &ath5k_rates[4],
|
|
|
|
sizeof(struct ieee80211_rate) * 8);
|
|
|
|
sband->n_bitrates = 8;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
sband->channels = &sc->channels[count_c];
|
2011-01-19 02:20:47 -07:00
|
|
|
sband->n_channels = ath5k_setup_channels(ah, sband->channels,
|
2010-09-16 21:45:07 -06:00
|
|
|
AR5K_MODE_11A, max_c);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
hw->wiphy->bands[IEEE80211_BAND_5GHZ] = sband;
|
|
|
|
}
|
|
|
|
ath5k_setup_rate_idx(sc, sband);
|
|
|
|
|
|
|
|
ath5k_debug_dump_bands(sc);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Set/change channels. We always reset the chip.
|
|
|
|
* To accomplish this we must first cleanup any pending DMA,
|
|
|
|
* then restart stuff after a la ath5k_init.
|
|
|
|
*
|
|
|
|
* Called with sc->lock.
|
|
|
|
*/
|
2010-12-22 03:20:32 -07:00
|
|
|
int
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_chan_set(struct ath5k_softc *sc, struct ieee80211_channel *chan)
|
|
|
|
{
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET,
|
|
|
|
"channel set, resetting (%u -> %u MHz)\n",
|
|
|
|
sc->curchan->center_freq, chan->center_freq);
|
|
|
|
|
2009-06-16 02:59:23 -06:00
|
|
|
/*
|
2010-09-16 21:45:07 -06:00
|
|
|
* To switch channels clear any pending DMA operations;
|
|
|
|
* wait long enough for the RX fifo to drain, reset the
|
|
|
|
* hardware at the new frequency, and then re-enable
|
|
|
|
* the relevant bits of the h/w.
|
2009-06-16 02:59:23 -06:00
|
|
|
*/
|
2010-11-23 12:39:28 -07:00
|
|
|
return ath5k_reset(sc, chan, true);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2011-03-03 15:39:05 -07:00
|
|
|
void ath5k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
|
2010-09-30 13:22:58 -06:00
|
|
|
{
|
2011-03-03 15:39:05 -07:00
|
|
|
struct ath5k_vif_iter_data *iter_data = data;
|
2010-09-30 13:22:58 -06:00
|
|
|
int i;
|
2010-10-08 13:01:15 -06:00
|
|
|
struct ath5k_vif *avf = (void *)vif->drv_priv;
|
2010-09-30 13:22:58 -06:00
|
|
|
|
|
|
|
if (iter_data->hw_macaddr)
|
|
|
|
for (i = 0; i < ETH_ALEN; i++)
|
|
|
|
iter_data->mask[i] &=
|
|
|
|
~(iter_data->hw_macaddr[i] ^ mac[i]);
|
|
|
|
|
|
|
|
if (!iter_data->found_active) {
|
|
|
|
iter_data->found_active = true;
|
|
|
|
memcpy(iter_data->active_mac, mac, ETH_ALEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (iter_data->need_set_hw_addr && iter_data->hw_macaddr)
|
|
|
|
if (compare_ether_addr(iter_data->hw_macaddr, mac) == 0)
|
|
|
|
iter_data->need_set_hw_addr = false;
|
|
|
|
|
|
|
|
if (!iter_data->any_assoc) {
|
|
|
|
if (avf->assoc)
|
|
|
|
iter_data->any_assoc = true;
|
|
|
|
}
|
2010-10-08 13:01:15 -06:00
|
|
|
|
|
|
|
/* Calculate combined mode - when APs are active, operate in AP mode.
|
|
|
|
* Otherwise use the mode of the new interface. This can currently
|
|
|
|
* only deal with combinations of APs and STAs. Only one ad-hoc
|
2010-11-10 12:43:51 -07:00
|
|
|
* interfaces is allowed.
|
2010-10-08 13:01:15 -06:00
|
|
|
*/
|
|
|
|
if (avf->opmode == NL80211_IFTYPE_AP)
|
|
|
|
iter_data->opmode = NL80211_IFTYPE_AP;
|
2011-03-03 15:39:05 -07:00
|
|
|
else {
|
|
|
|
if (avf->opmode == NL80211_IFTYPE_STATION)
|
|
|
|
iter_data->n_stas++;
|
2010-10-08 13:01:15 -06:00
|
|
|
if (iter_data->opmode == NL80211_IFTYPE_UNSPECIFIED)
|
|
|
|
iter_data->opmode = avf->opmode;
|
2011-03-03 15:39:05 -07:00
|
|
|
}
|
2010-09-30 13:22:58 -06:00
|
|
|
}
|
|
|
|
|
2010-12-22 03:20:32 -07:00
|
|
|
void
|
|
|
|
ath5k_update_bssid_mask_and_opmode(struct ath5k_softc *sc,
|
|
|
|
struct ieee80211_vif *vif)
|
2010-09-30 13:22:58 -06:00
|
|
|
{
|
|
|
|
struct ath_common *common = ath5k_hw_common(sc->ah);
|
2011-03-03 15:39:05 -07:00
|
|
|
struct ath5k_vif_iter_data iter_data;
|
|
|
|
u32 rfilt;
|
2010-09-30 13:22:58 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Use the hardware MAC address as reference, the hardware uses it
|
|
|
|
* together with the BSSID mask when matching addresses.
|
|
|
|
*/
|
|
|
|
iter_data.hw_macaddr = common->macaddr;
|
|
|
|
memset(&iter_data.mask, 0xff, ETH_ALEN);
|
|
|
|
iter_data.found_active = false;
|
|
|
|
iter_data.need_set_hw_addr = true;
|
2010-10-08 13:01:15 -06:00
|
|
|
iter_data.opmode = NL80211_IFTYPE_UNSPECIFIED;
|
2011-03-03 15:39:05 -07:00
|
|
|
iter_data.n_stas = 0;
|
2010-09-30 13:22:58 -06:00
|
|
|
|
|
|
|
if (vif)
|
2011-03-03 15:39:05 -07:00
|
|
|
ath5k_vif_iter(&iter_data, vif->addr, vif);
|
2010-09-30 13:22:58 -06:00
|
|
|
|
|
|
|
/* Get list of all active MAC addresses */
|
2011-03-03 15:39:05 -07:00
|
|
|
ieee80211_iterate_active_interfaces_atomic(sc->hw, ath5k_vif_iter,
|
2010-09-30 13:22:58 -06:00
|
|
|
&iter_data);
|
|
|
|
memcpy(sc->bssidmask, iter_data.mask, ETH_ALEN);
|
|
|
|
|
2010-10-08 13:01:15 -06:00
|
|
|
sc->opmode = iter_data.opmode;
|
|
|
|
if (sc->opmode == NL80211_IFTYPE_UNSPECIFIED)
|
|
|
|
/* Nothing active, default to station mode */
|
|
|
|
sc->opmode = NL80211_IFTYPE_STATION;
|
|
|
|
|
2010-11-10 12:43:51 -07:00
|
|
|
ath5k_hw_set_opmode(sc->ah, sc->opmode);
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_MODE, "mode setup opmode %d (%s)\n",
|
|
|
|
sc->opmode, ath_opmode_to_string(sc->opmode));
|
2010-10-08 13:01:15 -06:00
|
|
|
|
2010-09-30 13:22:58 -06:00
|
|
|
if (iter_data.need_set_hw_addr && iter_data.found_active)
|
|
|
|
ath5k_hw_set_lladdr(sc->ah, iter_data.active_mac);
|
|
|
|
|
2010-10-08 13:01:15 -06:00
|
|
|
if (ath5k_hw_hasbssidmask(sc->ah))
|
|
|
|
ath5k_hw_set_bssid_mask(sc->ah, sc->bssidmask);
|
2010-09-30 13:22:58 -06:00
|
|
|
|
2011-03-03 15:39:05 -07:00
|
|
|
/* Set up RX Filter */
|
|
|
|
if (iter_data.n_stas > 1) {
|
|
|
|
/* If you have multiple STA interfaces connected to
|
|
|
|
* different APs, ARPs are not received (most of the time?)
|
|
|
|
* Enabling PROMISC appears to fix that probem.
|
|
|
|
*/
|
|
|
|
sc->filter_flags |= AR5K_RX_FILTER_PROM;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
rfilt = sc->filter_flags;
|
2011-03-03 15:39:05 -07:00
|
|
|
ath5k_hw_set_rx_filter(sc->ah, rfilt);
|
2010-09-16 21:45:07 -06:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_MODE, "RX filter 0x%x\n", rfilt);
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static inline int
|
|
|
|
ath5k_hw_to_driver_rix(struct ath5k_softc *sc, int hw_rix)
|
|
|
|
{
|
|
|
|
int rix;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* return base rate on errors */
|
|
|
|
if (WARN(hw_rix < 0 || hw_rix >= AR5K_MAX_RATES,
|
|
|
|
"hw_rix out of bounds: %x\n", hw_rix))
|
|
|
|
return 0;
|
|
|
|
|
2011-01-19 02:21:13 -07:00
|
|
|
rix = sc->rate_idx[sc->curchan->band][hw_rix];
|
2010-09-16 21:45:07 -06:00
|
|
|
if (WARN(rix < 0, "invalid hw_rix: %x\n", hw_rix))
|
|
|
|
rix = 0;
|
|
|
|
|
|
|
|
return rix;
|
|
|
|
}
|
|
|
|
|
|
|
|
/***************\
|
|
|
|
* Buffers setup *
|
|
|
|
\***************/
|
|
|
|
|
|
|
|
static
|
|
|
|
struct sk_buff *ath5k_rx_skb_alloc(struct ath5k_softc *sc, dma_addr_t *skb_addr)
|
|
|
|
{
|
|
|
|
struct ath_common *common = ath5k_hw_common(sc->ah);
|
|
|
|
struct sk_buff *skb;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
/*
|
2010-09-16 21:45:07 -06:00
|
|
|
* Allocate buffer with headroom_needed space for the
|
|
|
|
* fake physical layer header at the start.
|
2007-08-12 09:33:16 -06:00
|
|
|
*/
|
2010-09-16 21:45:07 -06:00
|
|
|
skb = ath_rxbuf_alloc(common,
|
|
|
|
common->rx_bufsize,
|
|
|
|
GFP_ATOMIC);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (!skb) {
|
|
|
|
ATH5K_ERR(sc, "can't alloc skbuff of size %u\n",
|
|
|
|
common->rx_bufsize);
|
|
|
|
return NULL;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-12-02 02:26:51 -07:00
|
|
|
*skb_addr = dma_map_single(sc->dev,
|
2010-09-16 21:45:07 -06:00
|
|
|
skb->data, common->rx_bufsize,
|
2010-12-02 02:26:51 -07:00
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
|
|
|
|
if (unlikely(dma_mapping_error(sc->dev, *skb_addr))) {
|
2010-09-16 21:45:07 -06:00
|
|
|
ATH5K_ERR(sc, "%s: DMA mapping failed\n", __func__);
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return NULL;
|
2008-11-17 21:40:38 -07:00
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
return skb;
|
|
|
|
}
|
2008-11-17 21:40:38 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static int
|
|
|
|
ath5k_rxbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf)
|
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct sk_buff *skb = bf->skb;
|
|
|
|
struct ath5k_desc *ds;
|
|
|
|
int ret;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (!skb) {
|
|
|
|
skb = ath5k_rx_skb_alloc(sc, &bf->skbaddr);
|
|
|
|
if (!skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
bf->skb = skb;
|
2009-03-30 20:30:31 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Setup descriptors. For receive we always terminate
|
|
|
|
* the descriptor list with a self-linked entry so we'll
|
|
|
|
* not get overrun under high load (as can happen with a
|
|
|
|
* 5212 when ANI processing enables PHY error frames).
|
|
|
|
*
|
|
|
|
* To ensure the last descriptor is self-linked we create
|
|
|
|
* each descriptor as self-linked and add it to the end. As
|
|
|
|
* each additional descriptor is added the previous self-linked
|
|
|
|
* entry is "fixed" naturally. This should be safe even
|
|
|
|
* if DMA is happening. When processing RX interrupts we
|
|
|
|
* never remove/process the last, self-linked, entry on the
|
|
|
|
* descriptor list. This ensures the hardware always has
|
|
|
|
* someplace to write a new frame.
|
|
|
|
*/
|
|
|
|
ds = bf->desc;
|
|
|
|
ds->ds_link = bf->daddr; /* link to self */
|
|
|
|
ds->ds_data = bf->skbaddr;
|
|
|
|
ret = ath5k_hw_setup_rx_desc(ah, ds, ah->common.rx_bufsize, 0);
|
2007-08-12 09:33:16 -06:00
|
|
|
if (ret) {
|
2010-09-16 21:45:07 -06:00
|
|
|
ATH5K_ERR(sc, "%s: could not setup RX desc\n", __func__);
|
|
|
|
return ret;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (sc->rxlink != NULL)
|
|
|
|
*sc->rxlink = bf->daddr;
|
|
|
|
sc->rxlink = &ds->ds_link;
|
2007-08-12 09:33:16 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static enum ath5k_pkt_type get_hw_packet_type(struct sk_buff *skb)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
enum ath5k_pkt_type htype;
|
|
|
|
__le16 fc;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
hdr = (struct ieee80211_hdr *)skb->data;
|
|
|
|
fc = hdr->frame_control;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ieee80211_is_beacon(fc))
|
|
|
|
htype = AR5K_PKT_TYPE_BEACON;
|
|
|
|
else if (ieee80211_is_probe_resp(fc))
|
|
|
|
htype = AR5K_PKT_TYPE_PROBE_RESP;
|
|
|
|
else if (ieee80211_is_atim(fc))
|
|
|
|
htype = AR5K_PKT_TYPE_ATIM;
|
|
|
|
else if (ieee80211_is_pspoll(fc))
|
|
|
|
htype = AR5K_PKT_TYPE_PSPOLL;
|
2007-08-12 09:33:16 -06:00
|
|
|
else
|
2010-09-16 21:45:07 -06:00
|
|
|
htype = AR5K_PKT_TYPE_NORMAL;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
return htype;
|
2009-03-30 06:05:29 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static int
|
|
|
|
ath5k_txbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf,
|
|
|
|
struct ath5k_txq *txq, int padsize)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath5k_desc *ds = bf->desc;
|
|
|
|
struct sk_buff *skb = bf->skb;
|
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
unsigned int pktlen, flags, keyidx = AR5K_TXKEYIX_INVALID;
|
|
|
|
struct ieee80211_rate *rate;
|
|
|
|
unsigned int mrr_rate[3], mrr_tries[3];
|
|
|
|
int i, ret;
|
|
|
|
u16 hw_rate;
|
|
|
|
u16 cts_rate = 0;
|
|
|
|
u16 duration = 0;
|
|
|
|
u8 rc_flags;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
flags = AR5K_TXDESC_INTREQ | AR5K_TXDESC_CLRDMASK;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* XXX endianness */
|
2010-12-02 02:26:51 -07:00
|
|
|
bf->skbaddr = dma_map_single(sc->dev, skb->data, skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
rate = ieee80211_get_tx_rate(sc->hw, info);
|
2010-09-24 13:52:34 -06:00
|
|
|
if (!rate) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto err_unmap;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (info->flags & IEEE80211_TX_CTL_NO_ACK)
|
|
|
|
flags |= AR5K_TXDESC_NOACK;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
rc_flags = info->control.rates[0].flags;
|
|
|
|
hw_rate = (rc_flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE) ?
|
|
|
|
rate->hw_value_short : rate->hw_value;
|
2009-03-30 06:05:29 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
pktlen = skb->len;
|
|
|
|
|
|
|
|
/* FIXME: If we are in g mode and rate is a CCK rate
|
|
|
|
* subtract ah->ah_txpower.txp_cck_ofdm_pwr_delta
|
|
|
|
* from tx power (value is in dB units already) */
|
|
|
|
if (info->control.hw_key) {
|
|
|
|
keyidx = info->control.hw_key->hw_key_idx;
|
|
|
|
pktlen += info->control.hw_key->icv_len;
|
|
|
|
}
|
|
|
|
if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
|
|
|
|
flags |= AR5K_TXDESC_RTSENA;
|
|
|
|
cts_rate = ieee80211_get_rts_cts_rate(sc->hw, info)->hw_value;
|
|
|
|
duration = le16_to_cpu(ieee80211_rts_duration(sc->hw,
|
2010-09-30 13:22:58 -06:00
|
|
|
info->control.vif, pktlen, info));
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
|
|
|
if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
|
|
|
|
flags |= AR5K_TXDESC_CTSENA;
|
|
|
|
cts_rate = ieee80211_get_rts_cts_rate(sc->hw, info)->hw_value;
|
|
|
|
duration = le16_to_cpu(ieee80211_ctstoself_duration(sc->hw,
|
2010-09-30 13:22:58 -06:00
|
|
|
info->control.vif, pktlen, info));
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
|
|
|
ret = ah->ah_setup_tx_desc(ah, ds, pktlen,
|
|
|
|
ieee80211_get_hdrlen_from_skb(skb), padsize,
|
|
|
|
get_hw_packet_type(skb),
|
|
|
|
(sc->power_level * 2),
|
|
|
|
hw_rate,
|
|
|
|
info->control.rates[0].count, keyidx, ah->ah_tx_ant, flags,
|
|
|
|
cts_rate, duration);
|
|
|
|
if (ret)
|
|
|
|
goto err_unmap;
|
|
|
|
|
|
|
|
memset(mrr_rate, 0, sizeof(mrr_rate));
|
|
|
|
memset(mrr_tries, 0, sizeof(mrr_tries));
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
rate = ieee80211_get_alt_retry_rate(sc->hw, info, i);
|
|
|
|
if (!rate)
|
2008-02-03 19:51:49 -07:00
|
|
|
break;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
mrr_rate[i] = rate->hw_value;
|
|
|
|
mrr_tries[i] = info->control.rates[i + 1].count;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_hw_setup_mrr_tx_desc(ah, ds,
|
|
|
|
mrr_rate[0], mrr_tries[0],
|
|
|
|
mrr_rate[1], mrr_tries[1],
|
|
|
|
mrr_rate[2], mrr_tries[2]);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ds->ds_link = 0;
|
|
|
|
ds->ds_data = bf->skbaddr;
|
2008-07-30 09:12:58 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
spin_lock_bh(&txq->lock);
|
|
|
|
list_add_tail(&bf->list, &txq->q);
|
2010-09-16 20:36:35 -06:00
|
|
|
txq->txq_len++;
|
2010-09-16 21:45:07 -06:00
|
|
|
if (txq->link == NULL) /* is this first packet? */
|
|
|
|
ath5k_hw_set_txdp(ah, txq->qnum, bf->daddr);
|
|
|
|
else /* no, so only link it */
|
|
|
|
*txq->link = bf->daddr;
|
2008-07-30 09:12:58 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
txq->link = &ds->ds_link;
|
|
|
|
ath5k_hw_start_tx_dma(ah, txq->qnum);
|
|
|
|
mmiowb();
|
|
|
|
spin_unlock_bh(&txq->lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err_unmap:
|
2010-12-02 02:26:51 -07:00
|
|
|
dma_unmap_single(sc->dev, bf->skbaddr, skb->len, DMA_TO_DEVICE);
|
2010-09-16 21:45:07 -06:00
|
|
|
return ret;
|
2008-07-30 09:12:58 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*******************\
|
|
|
|
* Descriptors setup *
|
|
|
|
\*******************/
|
|
|
|
|
2008-02-03 19:51:04 -07:00
|
|
|
static int
|
2010-12-02 02:26:51 -07:00
|
|
|
ath5k_desc_alloc(struct ath5k_softc *sc)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_desc *ds;
|
|
|
|
struct ath5k_buf *bf;
|
|
|
|
dma_addr_t da;
|
|
|
|
unsigned int i;
|
|
|
|
int ret;
|
2008-02-03 19:51:04 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* allocate descriptors */
|
|
|
|
sc->desc_len = sizeof(struct ath5k_desc) *
|
|
|
|
(ATH_TXBUF + ATH_RXBUF + ATH_BCBUF + 1);
|
2010-12-02 02:26:51 -07:00
|
|
|
|
|
|
|
sc->desc = dma_alloc_coherent(sc->dev, sc->desc_len,
|
|
|
|
&sc->desc_daddr, GFP_KERNEL);
|
2010-09-16 21:45:07 -06:00
|
|
|
if (sc->desc == NULL) {
|
|
|
|
ATH5K_ERR(sc, "can't allocate descriptors\n");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
ds = sc->desc;
|
|
|
|
da = sc->desc_daddr;
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_ANY, "DMA map: %p (%zu) -> %llx\n",
|
|
|
|
ds, sc->desc_len, (unsigned long long)sc->desc_daddr);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
bf = kcalloc(1 + ATH_TXBUF + ATH_RXBUF + ATH_BCBUF,
|
|
|
|
sizeof(struct ath5k_buf), GFP_KERNEL);
|
|
|
|
if (bf == NULL) {
|
|
|
|
ATH5K_ERR(sc, "can't allocate bufptr\n");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_free;
|
|
|
|
}
|
|
|
|
sc->bufptr = bf;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
INIT_LIST_HEAD(&sc->rxbuf);
|
|
|
|
for (i = 0; i < ATH_RXBUF; i++, bf++, ds++, da += sizeof(*ds)) {
|
|
|
|
bf->desc = ds;
|
|
|
|
bf->daddr = da;
|
|
|
|
list_add_tail(&bf->list, &sc->rxbuf);
|
|
|
|
}
|
2008-02-03 19:51:04 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
INIT_LIST_HEAD(&sc->txbuf);
|
|
|
|
sc->txbuf_len = ATH_TXBUF;
|
|
|
|
for (i = 0; i < ATH_TXBUF; i++, bf++, ds++,
|
|
|
|
da += sizeof(*ds)) {
|
|
|
|
bf->desc = ds;
|
|
|
|
bf->daddr = da;
|
|
|
|
list_add_tail(&bf->list, &sc->txbuf);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-30 13:22:58 -06:00
|
|
|
/* beacon buffers */
|
|
|
|
INIT_LIST_HEAD(&sc->bcbuf);
|
|
|
|
for (i = 0; i < ATH_BCBUF; i++, bf++, ds++, da += sizeof(*ds)) {
|
|
|
|
bf->desc = ds;
|
|
|
|
bf->daddr = da;
|
|
|
|
list_add_tail(&bf->list, &sc->bcbuf);
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
return 0;
|
|
|
|
err_free:
|
2010-12-02 02:26:51 -07:00
|
|
|
dma_free_coherent(sc->dev, sc->desc_len, sc->desc, sc->desc_daddr);
|
2010-09-16 21:45:07 -06:00
|
|
|
err:
|
|
|
|
sc->desc = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-12-22 03:20:32 -07:00
|
|
|
void
|
|
|
|
ath5k_txbuf_free_skb(struct ath5k_softc *sc, struct ath5k_buf *bf)
|
|
|
|
{
|
|
|
|
BUG_ON(!bf);
|
|
|
|
if (!bf->skb)
|
|
|
|
return;
|
|
|
|
dma_unmap_single(sc->dev, bf->skbaddr, bf->skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
|
|
|
dev_kfree_skb_any(bf->skb);
|
|
|
|
bf->skb = NULL;
|
|
|
|
bf->skbaddr = 0;
|
|
|
|
bf->desc->ds_data = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ath5k_rxbuf_free_skb(struct ath5k_softc *sc, struct ath5k_buf *bf)
|
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath_common *common = ath5k_hw_common(ah);
|
|
|
|
|
|
|
|
BUG_ON(!bf);
|
|
|
|
if (!bf->skb)
|
|
|
|
return;
|
|
|
|
dma_unmap_single(sc->dev, bf->skbaddr, common->rx_bufsize,
|
|
|
|
DMA_FROM_DEVICE);
|
|
|
|
dev_kfree_skb_any(bf->skb);
|
|
|
|
bf->skb = NULL;
|
|
|
|
bf->skbaddr = 0;
|
|
|
|
bf->desc->ds_data = 0;
|
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static void
|
2010-12-02 02:26:51 -07:00
|
|
|
ath5k_desc_free(struct ath5k_softc *sc)
|
2010-09-16 21:45:07 -06:00
|
|
|
{
|
|
|
|
struct ath5k_buf *bf;
|
2008-02-03 19:51:04 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
list_for_each_entry(bf, &sc->txbuf, list)
|
|
|
|
ath5k_txbuf_free_skb(sc, bf);
|
|
|
|
list_for_each_entry(bf, &sc->rxbuf, list)
|
|
|
|
ath5k_rxbuf_free_skb(sc, bf);
|
2010-09-30 13:22:58 -06:00
|
|
|
list_for_each_entry(bf, &sc->bcbuf, list)
|
|
|
|
ath5k_txbuf_free_skb(sc, bf);
|
2008-02-03 19:51:04 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* Free memory associated with all descriptors */
|
2010-12-02 02:26:51 -07:00
|
|
|
dma_free_coherent(sc->dev, sc->desc_len, sc->desc, sc->desc_daddr);
|
2010-09-16 21:45:07 -06:00
|
|
|
sc->desc = NULL;
|
|
|
|
sc->desc_daddr = 0;
|
2008-02-03 19:51:04 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
kfree(sc->bufptr);
|
|
|
|
sc->bufptr = NULL;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
|
|
|
|
/**************\
|
|
|
|
* Queues setup *
|
|
|
|
\**************/
|
|
|
|
|
|
|
|
static struct ath5k_txq *
|
|
|
|
ath5k_txq_setup(struct ath5k_softc *sc,
|
|
|
|
int qtype, int subtype)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath5k_txq *txq;
|
|
|
|
struct ath5k_txq_info qi = {
|
|
|
|
.tqi_subtype = subtype,
|
2010-09-16 20:37:12 -06:00
|
|
|
/* XXX: default values not correct for B and XR channels,
|
|
|
|
* but who cares? */
|
|
|
|
.tqi_aifs = AR5K_TUNE_AIFS,
|
|
|
|
.tqi_cw_min = AR5K_TUNE_CWMIN,
|
|
|
|
.tqi_cw_max = AR5K_TUNE_CWMAX
|
2010-09-16 21:45:07 -06:00
|
|
|
};
|
|
|
|
int qnum;
|
2008-02-03 19:51:04 -07:00
|
|
|
|
2009-08-04 17:52:07 -06:00
|
|
|
/*
|
2010-09-16 21:45:07 -06:00
|
|
|
* Enable interrupts only for EOL and DESC conditions.
|
|
|
|
* We mark tx descriptors to receive a DESC interrupt
|
|
|
|
* when a tx queue gets deep; otherwise we wait for the
|
|
|
|
* EOL to reap descriptors. Note that this is done to
|
|
|
|
* reduce interrupt load and this only defers reaping
|
|
|
|
* descriptors, never transmitting frames. Aside from
|
|
|
|
* reducing interrupts this also permits more concurrency.
|
|
|
|
* The only potential downside is if the tx queue backs
|
|
|
|
* up in which case the top half of the kernel may backup
|
|
|
|
* due to a lack of tx descriptors.
|
2009-08-04 17:52:07 -06:00
|
|
|
*/
|
2010-09-16 21:45:07 -06:00
|
|
|
qi.tqi_flags = AR5K_TXQ_FLAG_TXEOLINT_ENABLE |
|
|
|
|
AR5K_TXQ_FLAG_TXDESCINT_ENABLE;
|
|
|
|
qnum = ath5k_hw_setup_tx_queue(ah, qtype, &qi);
|
|
|
|
if (qnum < 0) {
|
|
|
|
/*
|
|
|
|
* NB: don't print a message, this happens
|
|
|
|
* normally on parts with too few tx queues
|
|
|
|
*/
|
|
|
|
return ERR_PTR(qnum);
|
|
|
|
}
|
|
|
|
if (qnum >= ARRAY_SIZE(sc->txqs)) {
|
|
|
|
ATH5K_ERR(sc, "hw qnum %u out of range, max %tu!\n",
|
|
|
|
qnum, ARRAY_SIZE(sc->txqs));
|
|
|
|
ath5k_hw_release_tx_queue(ah, qnum);
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
txq = &sc->txqs[qnum];
|
|
|
|
if (!txq->setup) {
|
|
|
|
txq->qnum = qnum;
|
|
|
|
txq->link = NULL;
|
|
|
|
INIT_LIST_HEAD(&txq->q);
|
|
|
|
spin_lock_init(&txq->lock);
|
|
|
|
txq->setup = true;
|
2010-09-16 20:36:35 -06:00
|
|
|
txq->txq_len = 0;
|
2011-03-07 14:32:59 -07:00
|
|
|
txq->txq_max = ATH5K_TXQ_LEN_MAX;
|
2010-09-16 20:36:56 -06:00
|
|
|
txq->txq_poll_mark = false;
|
2010-09-16 20:37:02 -06:00
|
|
|
txq->txq_stuck = 0;
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
|
|
|
return &sc->txqs[qnum];
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static int
|
|
|
|
ath5k_beaconq_setup(struct ath5k_hw *ah)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_txq_info qi = {
|
2010-09-16 20:37:12 -06:00
|
|
|
/* XXX: default values not correct for B and XR channels,
|
|
|
|
* but who cares? */
|
|
|
|
.tqi_aifs = AR5K_TUNE_AIFS,
|
|
|
|
.tqi_cw_min = AR5K_TUNE_CWMIN,
|
|
|
|
.tqi_cw_max = AR5K_TUNE_CWMAX,
|
2010-09-16 21:45:07 -06:00
|
|
|
/* NB: for dynamic turbo, don't enable any other interrupts */
|
|
|
|
.tqi_flags = AR5K_TXQ_FLAG_TXDESCINT_ENABLE
|
|
|
|
};
|
2008-02-03 19:51:04 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
return ath5k_hw_setup_tx_queue(ah, AR5K_TX_QUEUE_BEACON, &qi);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static int
|
|
|
|
ath5k_beaconq_config(struct ath5k_softc *sc)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_txq_info qi;
|
|
|
|
int ret;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ret = ath5k_hw_get_tx_queueprops(ah, sc->bhalq, &qi);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (sc->opmode == NL80211_IFTYPE_AP ||
|
|
|
|
sc->opmode == NL80211_IFTYPE_MESH_POINT) {
|
|
|
|
/*
|
|
|
|
* Always burst out beacon and CAB traffic
|
|
|
|
* (aifs = cwmin = cwmax = 0)
|
|
|
|
*/
|
|
|
|
qi.tqi_aifs = 0;
|
|
|
|
qi.tqi_cw_min = 0;
|
|
|
|
qi.tqi_cw_max = 0;
|
|
|
|
} else if (sc->opmode == NL80211_IFTYPE_ADHOC) {
|
|
|
|
/*
|
|
|
|
* Adhoc mode; backoff between 0 and (2 * cw_min).
|
|
|
|
*/
|
|
|
|
qi.tqi_aifs = 0;
|
|
|
|
qi.tqi_cw_min = 0;
|
2010-09-16 20:37:12 -06:00
|
|
|
qi.tqi_cw_max = 2 * AR5K_TUNE_CWMIN;
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"beacon queueprops tqi_aifs:%d tqi_cw_min:%d tqi_cw_max:%d\n",
|
|
|
|
qi.tqi_aifs, qi.tqi_cw_min, qi.tqi_cw_max);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ret = ath5k_hw_set_tx_queueprops(ah, sc->bhalq, &qi);
|
|
|
|
if (ret) {
|
|
|
|
ATH5K_ERR(sc, "%s: unable to update parameters for beacon "
|
|
|
|
"hardware queue!\n", __func__);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
ret = ath5k_hw_reset_tx_queue(ah, sc->bhalq); /* push to h/w */
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
2009-03-02 19:55:18 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* reconfigure cabq with ready time to 80% of beacon_interval */
|
|
|
|
ret = ath5k_hw_get_tx_queueprops(ah, AR5K_TX_QUEUE_ID_CAB, &qi);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
2009-03-02 19:55:18 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
qi.tqi_ready_time = (sc->bintval * 80) / 100;
|
|
|
|
ret = ath5k_hw_set_tx_queueprops(ah, AR5K_TX_QUEUE_ID_CAB, &qi);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
2009-03-02 19:55:18 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ret = ath5k_hw_reset_tx_queue(ah, AR5K_TX_QUEUE_ID_CAB);
|
|
|
|
err:
|
|
|
|
return ret;
|
2008-02-03 19:51:04 -07:00
|
|
|
}
|
|
|
|
|
2010-11-23 11:45:38 -07:00
|
|
|
/**
|
|
|
|
* ath5k_drain_tx_buffs - Empty tx buffers
|
|
|
|
*
|
|
|
|
* @sc The &struct ath5k_softc
|
|
|
|
*
|
|
|
|
* Empty tx buffers from all queues in preparation
|
|
|
|
* of a reset or during shutdown.
|
|
|
|
*
|
|
|
|
* NB: this assumes output has been stopped and
|
|
|
|
* we do not need to block ath5k_tx_tasklet
|
|
|
|
*/
|
2010-09-16 21:45:07 -06:00
|
|
|
static void
|
2010-11-23 11:45:38 -07:00
|
|
|
ath5k_drain_tx_buffs(struct ath5k_softc *sc)
|
2010-09-16 21:45:07 -06:00
|
|
|
{
|
2010-11-23 11:45:38 -07:00
|
|
|
struct ath5k_txq *txq;
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_buf *bf, *bf0;
|
2010-11-23 11:45:38 -07:00
|
|
|
int i;
|
2009-01-10 12:42:54 -07:00
|
|
|
|
2010-11-23 11:45:38 -07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sc->txqs); i++) {
|
|
|
|
if (sc->txqs[i].setup) {
|
|
|
|
txq = &sc->txqs[i];
|
|
|
|
spin_lock_bh(&txq->lock);
|
|
|
|
list_for_each_entry_safe(bf, bf0, &txq->q, list) {
|
|
|
|
ath5k_debug_printtxbuf(sc, bf);
|
2009-01-10 12:42:54 -07:00
|
|
|
|
2010-11-23 11:45:38 -07:00
|
|
|
ath5k_txbuf_free_skb(sc, bf);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-11-23 11:45:38 -07:00
|
|
|
spin_lock_bh(&sc->txbuflock);
|
|
|
|
list_move_tail(&bf->list, &sc->txbuf);
|
|
|
|
sc->txbuf_len++;
|
|
|
|
txq->txq_len--;
|
|
|
|
spin_unlock_bh(&sc->txbuflock);
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
2010-11-23 11:45:38 -07:00
|
|
|
txq->link = NULL;
|
|
|
|
txq->txq_poll_mark = false;
|
|
|
|
spin_unlock_bh(&txq->lock);
|
|
|
|
}
|
2010-06-16 04:11:35 -06:00
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static void
|
|
|
|
ath5k_txq_release(struct ath5k_softc *sc)
|
2010-02-09 11:06:54 -07:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_txq *txq = sc->txqs;
|
|
|
|
unsigned int i;
|
2010-02-09 11:06:54 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sc->txqs); i++, txq++)
|
|
|
|
if (txq->setup) {
|
|
|
|
ath5k_hw_release_tx_queue(sc->ah, txq->qnum);
|
|
|
|
txq->setup = false;
|
|
|
|
}
|
|
|
|
}
|
2010-02-09 11:06:54 -07:00
|
|
|
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*************\
|
|
|
|
* RX Handling *
|
|
|
|
\*************/
|
2010-02-09 11:06:54 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Enable the receive h/w following a reset.
|
|
|
|
*/
|
2007-08-12 09:33:16 -06:00
|
|
|
static int
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_rx_start(struct ath5k_softc *sc)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath_common *common = ath5k_hw_common(ah);
|
|
|
|
struct ath5k_buf *bf;
|
|
|
|
int ret;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
common->rx_bufsize = roundup(IEEE80211_MAX_FRAME_LEN, common->cachelsz);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET, "cachelsz %u rx_bufsize %u\n",
|
|
|
|
common->cachelsz, common->rx_bufsize);
|
2008-10-05 10:05:48 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
spin_lock_bh(&sc->rxbuflock);
|
|
|
|
sc->rxlink = NULL;
|
|
|
|
list_for_each_entry(bf, &sc->rxbuf, list) {
|
|
|
|
ret = ath5k_rxbuf_setup(sc, bf);
|
|
|
|
if (ret != 0) {
|
|
|
|
spin_unlock_bh(&sc->rxbuflock);
|
|
|
|
goto err;
|
|
|
|
}
|
2008-10-05 10:05:48 -06:00
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
bf = list_first_entry(&sc->rxbuf, struct ath5k_buf, list);
|
|
|
|
ath5k_hw_set_rxdp(ah, bf->daddr);
|
|
|
|
spin_unlock_bh(&sc->rxbuflock);
|
2008-10-05 10:05:48 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_hw_start_rx_dma(ah); /* enable recv descriptors */
|
2011-03-03 15:39:05 -07:00
|
|
|
ath5k_update_bssid_mask_and_opmode(sc, NULL); /* set filters, etc. */
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_hw_start_rx_pcu(ah); /* re-enable PCU/DMA engine */
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
return 0;
|
2010-09-16 21:45:07 -06:00
|
|
|
err:
|
2007-08-12 09:33:16 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
2010-11-23 11:45:38 -07:00
|
|
|
* Disable the receive logic on PCU (DRU)
|
|
|
|
* In preparation for a shutdown.
|
|
|
|
*
|
|
|
|
* Note: Doesn't stop rx DMA, ath5k_hw_dma_stop
|
|
|
|
* does.
|
2010-09-16 21:45:07 -06:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ath5k_rx_stop(struct ath5k_softc *sc)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_hw *ah = sc->ah;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_hw_set_rx_filter(ah, 0); /* clear recv filter */
|
2010-11-23 11:45:38 -07:00
|
|
|
ath5k_hw_stop_rx_pcu(ah); /* disable PCU */
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_debug_printrxbuffs(sc, ah);
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static unsigned int
|
|
|
|
ath5k_rx_decrypted(struct ath5k_softc *sc, struct sk_buff *skb,
|
|
|
|
struct ath5k_rx_status *rs)
|
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath_common *common = ath5k_hw_common(ah);
|
|
|
|
struct ieee80211_hdr *hdr = (void *)skb->data;
|
|
|
|
unsigned int keyix, hlen;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (!(rs->rs_status & AR5K_RXERR_DECRYPT) &&
|
|
|
|
rs->rs_keyix != AR5K_RXKEYIX_INVALID)
|
|
|
|
return RX_FLAG_DECRYPTED;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* Apparently when a default key is used to decrypt the packet
|
|
|
|
the hw does not set the index used to decrypt. In such cases
|
|
|
|
get the index from the packet. */
|
|
|
|
hlen = ieee80211_hdrlen(hdr->frame_control);
|
|
|
|
if (ieee80211_has_protected(hdr->frame_control) &&
|
|
|
|
!(rs->rs_status & AR5K_RXERR_DECRYPT) &&
|
|
|
|
skb->len >= hlen + 4) {
|
|
|
|
keyix = skb->data[hlen + 3] >> 6;
|
|
|
|
|
|
|
|
if (test_bit(keyix, common->keymap))
|
|
|
|
return RX_FLAG_DECRYPTED;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
static void
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_check_ibss_tsf(struct ath5k_softc *sc, struct sk_buff *skb,
|
|
|
|
struct ieee80211_rx_status *rxs)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath_common *common = ath5k_hw_common(sc->ah);
|
|
|
|
u64 tsf, bc_tstamp;
|
|
|
|
u32 hw_tu;
|
|
|
|
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ieee80211_is_beacon(mgmt->frame_control) &&
|
|
|
|
le16_to_cpu(mgmt->u.beacon.capab_info) & WLAN_CAPABILITY_IBSS &&
|
|
|
|
memcmp(mgmt->bssid, common->curbssid, ETH_ALEN) == 0) {
|
|
|
|
/*
|
|
|
|
* Received an IBSS beacon with the same BSSID. Hardware *must*
|
|
|
|
* have updated the local TSF. We have to work around various
|
|
|
|
* hardware bugs, though...
|
|
|
|
*/
|
|
|
|
tsf = ath5k_hw_get_tsf64(sc->ah);
|
|
|
|
bc_tstamp = le64_to_cpu(mgmt->u.beacon.timestamp);
|
|
|
|
hw_tu = TSF_TO_TU(tsf);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"beacon %llx mactime %llx (diff %lld) tsf now %llx\n",
|
|
|
|
(unsigned long long)bc_tstamp,
|
|
|
|
(unsigned long long)rxs->mactime,
|
|
|
|
(unsigned long long)(rxs->mactime - bc_tstamp),
|
|
|
|
(unsigned long long)tsf);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Sometimes the HW will give us a wrong tstamp in the rx
|
|
|
|
* status, causing the timestamp extension to go wrong.
|
|
|
|
* (This seems to happen especially with beacon frames bigger
|
|
|
|
* than 78 byte (incl. FCS))
|
|
|
|
* But we know that the receive timestamp must be later than the
|
|
|
|
* timestamp of the beacon since HW must have synced to that.
|
|
|
|
*
|
|
|
|
* NOTE: here we assume mactime to be after the frame was
|
|
|
|
* received, not like mac80211 which defines it at the start.
|
|
|
|
*/
|
|
|
|
if (bc_tstamp > rxs->mactime) {
|
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"fixing mactime from %llx to %llx\n",
|
|
|
|
(unsigned long long)rxs->mactime,
|
|
|
|
(unsigned long long)tsf);
|
|
|
|
rxs->mactime = tsf;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Local TSF might have moved higher than our beacon timers,
|
|
|
|
* in that case we have to update them to continue sending
|
|
|
|
* beacons. This also takes care of synchronizing beacon sending
|
|
|
|
* times with other stations.
|
|
|
|
*/
|
|
|
|
if (hw_tu >= sc->nexttbtt)
|
|
|
|
ath5k_beacon_update_timers(sc, bc_tstamp);
|
2010-09-26 21:22:21 -06:00
|
|
|
|
|
|
|
/* Check if the beacon timers are still correct, because a TSF
|
|
|
|
* update might have created a window between them - for a
|
|
|
|
* longer description see the comment of this function: */
|
|
|
|
if (!ath5k_hw_check_beacon_timers(sc->ah, sc->bintval)) {
|
|
|
|
ath5k_beacon_update_timers(sc, bc_tstamp);
|
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"fixed beacon timers after beacon receive\n");
|
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
static void
|
|
|
|
ath5k_update_beacon_rssi(struct ath5k_softc *sc, struct sk_buff *skb, int rssi)
|
|
|
|
{
|
|
|
|
struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath_common *common = ath5k_hw_common(ah);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* only beacons from our BSSID */
|
|
|
|
if (!ieee80211_is_beacon(mgmt->frame_control) ||
|
|
|
|
memcmp(mgmt->bssid, common->curbssid, ETH_ALEN) != 0)
|
|
|
|
return;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-11-15 18:58:43 -07:00
|
|
|
ewma_add(&ah->ah_beacon_rssi_avg, rssi);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* in IBSS mode we should keep RSSI statistics per neighbour */
|
|
|
|
/* le16_to_cpu(mgmt->u.beacon.capab_info) & WLAN_CAPABILITY_IBSS */
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Compute padding position. skb must contain an IEEE 802.11 frame
|
|
|
|
*/
|
|
|
|
static int ath5k_common_padpos(struct sk_buff *skb)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ieee80211_hdr * hdr = (struct ieee80211_hdr *)skb->data;
|
|
|
|
__le16 frame_control = hdr->frame_control;
|
|
|
|
int padpos = 24;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ieee80211_has_a4(frame_control)) {
|
|
|
|
padpos += ETH_ALEN;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ieee80211_is_data_qos(frame_control)) {
|
|
|
|
padpos += IEEE80211_QOS_CTL_LEN;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
|
|
|
|
return padpos;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* This function expects an 802.11 frame and returns the number of
|
|
|
|
* bytes added, or -1 if we don't have enough header room.
|
|
|
|
*/
|
|
|
|
static int ath5k_add_padding(struct sk_buff *skb)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
int padpos = ath5k_common_padpos(skb);
|
|
|
|
int padsize = padpos & 3;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (padsize && skb->len>padpos) {
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (skb_headroom(skb) < padsize)
|
|
|
|
return -1;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
skb_push(skb, padsize);
|
|
|
|
memmove(skb->data, skb->data+padsize, padpos);
|
|
|
|
return padsize;
|
|
|
|
}
|
2010-01-20 21:51:04 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* The MAC header is padded to have 32-bit boundary if the
|
|
|
|
* packet payload is non-zero. The general calculation for
|
|
|
|
* padsize would take into account odd header lengths:
|
|
|
|
* padsize = 4 - (hdrlen & 3); however, since only
|
|
|
|
* even-length headers are used, padding can only be 0 or 2
|
|
|
|
* bytes and we can optimize this a bit. We must not try to
|
|
|
|
* remove padding from short control frames that do not have a
|
|
|
|
* payload.
|
|
|
|
*
|
|
|
|
* This function expects an 802.11 frame and returns the number of
|
|
|
|
* bytes removed.
|
|
|
|
*/
|
|
|
|
static int ath5k_remove_padding(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
int padpos = ath5k_common_padpos(skb);
|
|
|
|
int padsize = padpos & 3;
|
2008-01-19 02:18:41 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (padsize && skb->len>=padpos+padsize) {
|
|
|
|
memmove(skb->data + padsize, skb->data, padpos);
|
|
|
|
skb_pull(skb, padsize);
|
|
|
|
return padsize;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
2010-01-20 21:51:04 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
return 0;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_receive_frame(struct ath5k_softc *sc, struct sk_buff *skb,
|
|
|
|
struct ath5k_rx_status *rs)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ieee80211_rx_status *rxs;
|
|
|
|
|
|
|
|
ath5k_remove_padding(skb);
|
|
|
|
|
|
|
|
rxs = IEEE80211_SKB_RXCB(skb);
|
|
|
|
|
|
|
|
rxs->flag = 0;
|
|
|
|
if (unlikely(rs->rs_status & AR5K_RXERR_MIC))
|
|
|
|
rxs->flag |= RX_FLAG_MMIC_ERROR;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
/*
|
2010-09-16 21:45:07 -06:00
|
|
|
* always extend the mac timestamp, since this information is
|
|
|
|
* also needed for proper IBSS merging.
|
|
|
|
*
|
|
|
|
* XXX: it might be too late to do it here, since rs_tstamp is
|
|
|
|
* 15bit only. that means TSF extension has to be done within
|
|
|
|
* 32768usec (about 32ms). it might be necessary to move this to
|
|
|
|
* the interrupt handler, like it is done in madwifi.
|
|
|
|
*
|
|
|
|
* Unfortunately we don't know when the hardware takes the rx
|
|
|
|
* timestamp (beginning of phy frame, data frame, end of rx?).
|
|
|
|
* The only thing we know is that it is hardware specific...
|
|
|
|
* On AR5213 it seems the rx timestamp is at the end of the
|
|
|
|
* frame, but i'm not sure.
|
|
|
|
*
|
|
|
|
* NOTE: mac80211 defines mactime at the beginning of the first
|
|
|
|
* data symbol. Since we don't have any time references it's
|
|
|
|
* impossible to comply to that. This affects IBSS merge only
|
|
|
|
* right now, so it's not too bad...
|
2007-08-12 09:33:16 -06:00
|
|
|
*/
|
2010-09-16 21:45:07 -06:00
|
|
|
rxs->mactime = ath5k_extend_tsf(sc->ah, rs->rs_tstamp);
|
2011-02-23 07:06:08 -07:00
|
|
|
rxs->flag |= RX_FLAG_MACTIME_MPDU;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
rxs->freq = sc->curchan->center_freq;
|
2011-01-19 02:21:13 -07:00
|
|
|
rxs->band = sc->curchan->band;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
rxs->signal = sc->ah->ah_noise_floor + rs->rs_rssi;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
rxs->antenna = rs->rs_antenna;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (rs->rs_antenna > 0 && rs->rs_antenna < 5)
|
|
|
|
sc->stats.antenna_rx[rs->rs_antenna]++;
|
|
|
|
else
|
|
|
|
sc->stats.antenna_rx[0]++; /* invalid */
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
rxs->rate_idx = ath5k_hw_to_driver_rix(sc, rs->rs_rate);
|
|
|
|
rxs->flag |= ath5k_rx_decrypted(sc, skb, rs);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (rxs->rate_idx >= 0 && rs->rs_rate ==
|
2011-01-19 02:21:13 -07:00
|
|
|
sc->sbands[sc->curchan->band].bitrates[rxs->rate_idx].hw_value_short)
|
2010-09-16 21:45:07 -06:00
|
|
|
rxs->flag |= RX_FLAG_SHORTPRE;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2011-01-24 21:32:55 -07:00
|
|
|
trace_ath5k_rx(sc, skb);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_update_beacon_rssi(sc, skb, rs->rs_rssi);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* check beacons in IBSS mode */
|
|
|
|
if (sc->opmode == NL80211_IFTYPE_ADHOC)
|
|
|
|
ath5k_check_ibss_tsf(sc, skb, rxs);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ieee80211_rx(sc->hw, skb);
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/** ath5k_frame_receive_ok() - Do we want to receive this frame or not?
|
|
|
|
*
|
|
|
|
* Check if we want to further process this frame or not. Also update
|
|
|
|
* statistics. Return true if we want this frame, false if not.
|
2007-08-12 09:33:16 -06:00
|
|
|
*/
|
2010-09-16 21:45:07 -06:00
|
|
|
static bool
|
|
|
|
ath5k_receive_frame_ok(struct ath5k_softc *sc, struct ath5k_rx_status *rs)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
sc->stats.rx_all_count++;
|
2010-10-01 11:54:04 -06:00
|
|
|
sc->stats.rx_bytes_count += rs->rs_datalen;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (unlikely(rs->rs_status)) {
|
|
|
|
if (rs->rs_status & AR5K_RXERR_CRC)
|
|
|
|
sc->stats.rxerr_crc++;
|
|
|
|
if (rs->rs_status & AR5K_RXERR_FIFO)
|
|
|
|
sc->stats.rxerr_fifo++;
|
|
|
|
if (rs->rs_status & AR5K_RXERR_PHY) {
|
|
|
|
sc->stats.rxerr_phy++;
|
|
|
|
if (rs->rs_phyerr > 0 && rs->rs_phyerr < 32)
|
|
|
|
sc->stats.rxerr_phy_code[rs->rs_phyerr]++;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (rs->rs_status & AR5K_RXERR_DECRYPT) {
|
|
|
|
/*
|
|
|
|
* Decrypt error. If the error occurred
|
|
|
|
* because there was no hardware key, then
|
|
|
|
* let the frame through so the upper layers
|
|
|
|
* can process it. This is necessary for 5210
|
|
|
|
* parts which have no way to setup a ``clear''
|
|
|
|
* key cache entry.
|
|
|
|
*
|
|
|
|
* XXX do key cache faulting
|
|
|
|
*/
|
|
|
|
sc->stats.rxerr_decrypt++;
|
|
|
|
if (rs->rs_keyix == AR5K_RXKEYIX_INVALID &&
|
|
|
|
!(rs->rs_status & AR5K_RXERR_CRC))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (rs->rs_status & AR5K_RXERR_MIC) {
|
|
|
|
sc->stats.rxerr_mic++;
|
|
|
|
return true;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* reject any frames with non-crypto errors */
|
|
|
|
if (rs->rs_status & ~(AR5K_RXERR_DECRYPT))
|
|
|
|
return false;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (unlikely(rs->rs_more)) {
|
|
|
|
sc->stats.rxerr_jumbo++;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2011-04-10 10:32:19 -06:00
|
|
|
static void
|
|
|
|
ath5k_set_current_imask(struct ath5k_softc *sc)
|
|
|
|
{
|
|
|
|
enum ath5k_int imask = sc->imask;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&sc->irqlock, flags);
|
|
|
|
if (sc->rx_pending)
|
|
|
|
imask &= ~AR5K_INT_RX_ALL;
|
|
|
|
if (sc->tx_pending)
|
|
|
|
imask &= ~AR5K_INT_TX_ALL;
|
|
|
|
ath5k_hw_set_imr(sc->ah, imask);
|
|
|
|
spin_unlock_irqrestore(&sc->irqlock, flags);
|
|
|
|
}
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
static void
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_tasklet_rx(unsigned long data)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_rx_status rs = {};
|
|
|
|
struct sk_buff *skb, *next_skb;
|
|
|
|
dma_addr_t next_skb_addr;
|
|
|
|
struct ath5k_softc *sc = (void *)data;
|
2009-11-04 18:47:31 -07:00
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath_common *common = ath5k_hw_common(ah);
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_buf *bf;
|
|
|
|
struct ath5k_desc *ds;
|
|
|
|
int ret;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
spin_lock(&sc->rxbuflock);
|
|
|
|
if (list_empty(&sc->rxbuf)) {
|
|
|
|
ATH5K_WARN(sc, "empty rx buf pool\n");
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
do {
|
|
|
|
bf = list_first_entry(&sc->rxbuf, struct ath5k_buf, list);
|
|
|
|
BUG_ON(bf->skb == NULL);
|
|
|
|
skb = bf->skb;
|
|
|
|
ds = bf->desc;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/* bail if HW is still using self-linked descriptor */
|
|
|
|
if (ath5k_hw_get_rxdp(sc->ah) == bf->daddr)
|
|
|
|
break;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ret = sc->ah->ah_proc_rx_desc(sc->ah, ds, &rs);
|
|
|
|
if (unlikely(ret == -EINPROGRESS))
|
|
|
|
break;
|
|
|
|
else if (unlikely(ret)) {
|
|
|
|
ATH5K_ERR(sc, "error in processing rx descriptor\n");
|
|
|
|
sc->stats.rxerr_proc++;
|
|
|
|
break;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ath5k_receive_frame_ok(sc, &rs)) {
|
|
|
|
next_skb = ath5k_rx_skb_alloc(sc, &next_skb_addr);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* If we can't replace bf->skb with a new skb under
|
|
|
|
* memory pressure, just skip this packet
|
|
|
|
*/
|
|
|
|
if (!next_skb)
|
|
|
|
goto next;
|
2008-01-19 02:18:21 -07:00
|
|
|
|
2010-12-02 02:26:51 -07:00
|
|
|
dma_unmap_single(sc->dev, bf->skbaddr,
|
2010-09-16 21:45:07 -06:00
|
|
|
common->rx_bufsize,
|
2010-12-02 02:26:51 -07:00
|
|
|
DMA_FROM_DEVICE);
|
2008-01-19 02:18:21 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
skb_put(skb, rs.rs_datalen);
|
2008-03-05 02:36:26 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_receive_frame(sc, skb, &rs);
|
2008-03-05 02:36:26 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
bf->skb = next_skb;
|
|
|
|
bf->skbaddr = next_skb_addr;
|
2008-01-19 02:18:21 -07:00
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
next:
|
|
|
|
list_move_tail(&bf->list, &sc->rxbuf);
|
|
|
|
} while (ath5k_rxbuf_setup(sc, bf) == 0);
|
|
|
|
unlock:
|
|
|
|
spin_unlock(&sc->rxbuflock);
|
2011-04-10 10:32:19 -06:00
|
|
|
sc->rx_pending = false;
|
|
|
|
ath5k_set_current_imask(sc);
|
2008-01-19 02:18:21 -07:00
|
|
|
}
|
|
|
|
|
2010-03-24 23:49:25 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*************\
|
|
|
|
* TX Handling *
|
|
|
|
\*************/
|
2010-03-24 23:49:25 -06:00
|
|
|
|
2011-02-24 06:42:06 -07:00
|
|
|
void
|
2010-12-22 03:20:32 -07:00
|
|
|
ath5k_tx_queue(struct ieee80211_hw *hw, struct sk_buff *skb,
|
|
|
|
struct ath5k_txq *txq)
|
2010-09-16 21:45:07 -06:00
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = hw->priv;
|
|
|
|
struct ath5k_buf *bf;
|
|
|
|
unsigned long flags;
|
|
|
|
int padsize;
|
2010-03-24 23:49:25 -06:00
|
|
|
|
2011-01-24 21:32:55 -07:00
|
|
|
trace_ath5k_tx(sc, skb, txq);
|
2010-03-24 23:49:25 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* The hardware expects the header padded to 4 byte boundaries.
|
|
|
|
* If this is not the case, we add the padding after the header.
|
|
|
|
*/
|
|
|
|
padsize = ath5k_add_padding(skb);
|
|
|
|
if (padsize < 0) {
|
|
|
|
ATH5K_ERR(sc, "tx hdrlen not %%4: not enough"
|
|
|
|
" headroom to pad");
|
|
|
|
goto drop_packet;
|
|
|
|
}
|
2010-02-27 15:05:26 -07:00
|
|
|
|
2011-03-07 14:32:59 -07:00
|
|
|
if (txq->txq_len >= txq->txq_max)
|
2010-09-16 20:36:35 -06:00
|
|
|
ieee80211_stop_queue(hw, txq->qnum);
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
spin_lock_irqsave(&sc->txbuflock, flags);
|
|
|
|
if (list_empty(&sc->txbuf)) {
|
|
|
|
ATH5K_ERR(sc, "no further txbuf available, dropping packet\n");
|
|
|
|
spin_unlock_irqrestore(&sc->txbuflock, flags);
|
2010-09-16 20:36:46 -06:00
|
|
|
ieee80211_stop_queues(hw);
|
2010-09-16 21:45:07 -06:00
|
|
|
goto drop_packet;
|
2010-02-27 15:05:26 -07:00
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
bf = list_first_entry(&sc->txbuf, struct ath5k_buf, list);
|
|
|
|
list_del(&bf->list);
|
|
|
|
sc->txbuf_len--;
|
|
|
|
if (list_empty(&sc->txbuf))
|
|
|
|
ieee80211_stop_queues(hw);
|
|
|
|
spin_unlock_irqrestore(&sc->txbuflock, flags);
|
|
|
|
|
|
|
|
bf->skb = skb;
|
|
|
|
|
|
|
|
if (ath5k_txbuf_setup(sc, bf, txq, padsize)) {
|
|
|
|
bf->skb = NULL;
|
|
|
|
spin_lock_irqsave(&sc->txbuflock, flags);
|
|
|
|
list_add_tail(&bf->list, &sc->txbuf);
|
|
|
|
sc->txbuf_len++;
|
|
|
|
spin_unlock_irqrestore(&sc->txbuflock, flags);
|
|
|
|
goto drop_packet;
|
2010-02-27 15:05:26 -07:00
|
|
|
}
|
2011-02-24 06:42:06 -07:00
|
|
|
return;
|
2010-02-27 15:05:26 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
drop_packet:
|
|
|
|
dev_kfree_skb_any(skb);
|
2010-02-27 15:05:26 -07:00
|
|
|
}
|
|
|
|
|
2010-09-16 20:36:51 -06:00
|
|
|
static void
|
|
|
|
ath5k_tx_frame_completed(struct ath5k_softc *sc, struct sk_buff *skb,
|
2011-01-24 21:32:55 -07:00
|
|
|
struct ath5k_txq *txq, struct ath5k_tx_status *ts)
|
2010-09-16 20:36:51 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_tx_info *info;
|
2011-04-10 10:32:17 -06:00
|
|
|
u8 tries[3];
|
2010-09-16 20:36:51 -06:00
|
|
|
int i;
|
|
|
|
|
|
|
|
sc->stats.tx_all_count++;
|
2010-10-01 11:54:04 -06:00
|
|
|
sc->stats.tx_bytes_count += skb->len;
|
2010-09-16 20:36:51 -06:00
|
|
|
info = IEEE80211_SKB_CB(skb);
|
|
|
|
|
2011-04-10 10:32:17 -06:00
|
|
|
tries[0] = info->status.rates[0].count;
|
|
|
|
tries[1] = info->status.rates[1].count;
|
|
|
|
tries[2] = info->status.rates[2].count;
|
|
|
|
|
2010-09-16 20:36:51 -06:00
|
|
|
ieee80211_tx_info_clear_status(info);
|
2011-04-10 10:32:17 -06:00
|
|
|
|
|
|
|
for (i = 0; i < ts->ts_final_idx; i++) {
|
2010-09-16 20:36:51 -06:00
|
|
|
struct ieee80211_tx_rate *r =
|
|
|
|
&info->status.rates[i];
|
|
|
|
|
2011-04-10 10:32:17 -06:00
|
|
|
r->count = tries[i];
|
2010-09-16 20:36:51 -06:00
|
|
|
}
|
|
|
|
|
2011-04-10 10:32:17 -06:00
|
|
|
info->status.rates[ts->ts_final_idx].count = ts->ts_final_retry;
|
2011-04-09 13:37:14 -06:00
|
|
|
info->status.rates[ts->ts_final_idx + 1].idx = -1;
|
2010-09-16 20:36:51 -06:00
|
|
|
|
|
|
|
if (unlikely(ts->ts_status)) {
|
|
|
|
sc->stats.ack_fail++;
|
|
|
|
if (ts->ts_status & AR5K_TXERR_FILT) {
|
|
|
|
info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
|
|
|
|
sc->stats.txerr_filt++;
|
|
|
|
}
|
|
|
|
if (ts->ts_status & AR5K_TXERR_XRETRY)
|
|
|
|
sc->stats.txerr_retry++;
|
|
|
|
if (ts->ts_status & AR5K_TXERR_FIFO)
|
|
|
|
sc->stats.txerr_fifo++;
|
|
|
|
} else {
|
|
|
|
info->flags |= IEEE80211_TX_STAT_ACK;
|
|
|
|
info->status.ack_signal = ts->ts_rssi;
|
2011-04-09 13:37:14 -06:00
|
|
|
|
|
|
|
/* count the successful attempt as well */
|
|
|
|
info->status.rates[ts->ts_final_idx].count++;
|
2010-09-16 20:36:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove MAC header padding before giving the frame
|
|
|
|
* back to mac80211.
|
|
|
|
*/
|
|
|
|
ath5k_remove_padding(skb);
|
|
|
|
|
|
|
|
if (ts->ts_antenna > 0 && ts->ts_antenna < 5)
|
|
|
|
sc->stats.antenna_tx[ts->ts_antenna]++;
|
|
|
|
else
|
|
|
|
sc->stats.antenna_tx[0]++; /* invalid */
|
|
|
|
|
2011-01-24 21:32:55 -07:00
|
|
|
trace_ath5k_tx_complete(sc, skb, txq, ts);
|
2010-09-16 20:36:51 -06:00
|
|
|
ieee80211_tx_status(sc->hw, skb);
|
|
|
|
}
|
2010-09-16 21:45:07 -06:00
|
|
|
|
|
|
|
static void
|
|
|
|
ath5k_tx_processq(struct ath5k_softc *sc, struct ath5k_txq *txq)
|
2010-02-27 15:05:26 -07:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_tx_status ts = {};
|
|
|
|
struct ath5k_buf *bf, *bf0;
|
|
|
|
struct ath5k_desc *ds;
|
|
|
|
struct sk_buff *skb;
|
2010-09-16 20:36:51 -06:00
|
|
|
int ret;
|
2010-02-27 15:05:26 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
spin_lock(&txq->lock);
|
|
|
|
list_for_each_entry_safe(bf, bf0, &txq->q, list) {
|
2010-09-16 20:37:07 -06:00
|
|
|
|
|
|
|
txq->txq_poll_mark = false;
|
|
|
|
|
|
|
|
/* skb might already have been processed last time. */
|
|
|
|
if (bf->skb != NULL) {
|
|
|
|
ds = bf->desc;
|
|
|
|
|
|
|
|
ret = sc->ah->ah_proc_tx_desc(sc->ah, ds, &ts);
|
|
|
|
if (unlikely(ret == -EINPROGRESS))
|
|
|
|
break;
|
|
|
|
else if (unlikely(ret)) {
|
|
|
|
ATH5K_ERR(sc,
|
|
|
|
"error %d while processing "
|
|
|
|
"queue %u\n", ret, txq->qnum);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb = bf->skb;
|
|
|
|
bf->skb = NULL;
|
2010-12-02 02:26:51 -07:00
|
|
|
|
|
|
|
dma_unmap_single(sc->dev, bf->skbaddr, skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
2011-01-24 21:32:55 -07:00
|
|
|
ath5k_tx_frame_completed(sc, skb, txq, &ts);
|
2010-09-16 20:37:07 -06:00
|
|
|
}
|
2010-02-27 15:05:26 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* It's possible that the hardware can say the buffer is
|
|
|
|
* completed when it hasn't yet loaded the ds_link from
|
2010-09-16 20:37:07 -06:00
|
|
|
* host memory and moved on.
|
|
|
|
* Always keep the last descriptor to avoid HW races...
|
2010-09-16 21:45:07 -06:00
|
|
|
*/
|
2010-09-16 20:37:07 -06:00
|
|
|
if (ath5k_hw_get_txdp(sc->ah, txq->qnum) != bf->daddr) {
|
|
|
|
spin_lock(&sc->txbuflock);
|
|
|
|
list_move_tail(&bf->list, &sc->txbuf);
|
|
|
|
sc->txbuf_len++;
|
|
|
|
txq->txq_len--;
|
|
|
|
spin_unlock(&sc->txbuflock);
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
spin_unlock(&txq->lock);
|
2010-10-04 22:27:17 -06:00
|
|
|
if (txq->txq_len < ATH5K_TXQ_LEN_LOW && txq->qnum < 4)
|
2010-09-16 20:36:35 -06:00
|
|
|
ieee80211_wake_queue(sc->hw, txq->qnum);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ath5k_tasklet_tx(unsigned long data)
|
|
|
|
{
|
2009-07-29 15:32:28 -06:00
|
|
|
int i;
|
2007-08-12 09:33:16 -06:00
|
|
|
struct ath5k_softc *sc = (void *)data;
|
|
|
|
|
2009-07-29 15:32:28 -06:00
|
|
|
for (i=0; i < AR5K_NUM_TX_QUEUES; i++)
|
|
|
|
if (sc->txqs[i].setup && (sc->ah->ah_txq_isr & BIT(i)))
|
|
|
|
ath5k_tx_processq(sc, &sc->txqs[i]);
|
2011-04-10 10:32:19 -06:00
|
|
|
|
|
|
|
sc->tx_pending = false;
|
|
|
|
ath5k_set_current_imask(sc);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************\
|
|
|
|
* Beacon handling *
|
|
|
|
\*****************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup the beacon frame for transmit.
|
|
|
|
*/
|
|
|
|
static int
|
2008-05-15 04:55:29 -06:00
|
|
|
ath5k_beacon_setup(struct ath5k_softc *sc, struct ath5k_buf *bf)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
|
|
|
struct sk_buff *skb = bf->skb;
|
2008-05-26 08:43:39 -06:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
2007-08-12 09:33:16 -06:00
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath5k_desc *ds;
|
2009-04-30 13:55:49 -06:00
|
|
|
int ret = 0;
|
|
|
|
u8 antenna;
|
2007-08-12 09:33:16 -06:00
|
|
|
u32 flags;
|
2010-02-27 15:05:26 -07:00
|
|
|
const int padsize = 0;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-12-02 02:26:51 -07:00
|
|
|
bf->skbaddr = dma_map_single(sc->dev, skb->data, skb->len,
|
|
|
|
DMA_TO_DEVICE);
|
2007-08-12 09:33:16 -06:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_BEACON, "skb %p [data %p len %u] "
|
|
|
|
"skbaddr %llx\n", skb, skb->data, skb->len,
|
|
|
|
(unsigned long long)bf->skbaddr);
|
2010-12-02 02:26:51 -07:00
|
|
|
|
|
|
|
if (dma_mapping_error(sc->dev, bf->skbaddr)) {
|
2007-08-12 09:33:16 -06:00
|
|
|
ATH5K_ERR(sc, "beacon DMA mapping failed\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
ds = bf->desc;
|
2009-04-30 13:55:49 -06:00
|
|
|
antenna = ah->ah_tx_ant;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
flags = AR5K_TXDESC_NOACK;
|
2008-09-10 16:01:58 -06:00
|
|
|
if (sc->opmode == NL80211_IFTYPE_ADHOC && ath5k_hw_hasveol(ah)) {
|
2007-08-12 09:33:16 -06:00
|
|
|
ds->ds_link = bf->daddr; /* self-linked */
|
|
|
|
flags |= AR5K_TXDESC_VEOL;
|
2009-04-30 13:55:49 -06:00
|
|
|
} else
|
2007-08-12 09:33:16 -06:00
|
|
|
ds->ds_link = 0;
|
2009-04-30 13:55:49 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we use multiple antennas on AP and use
|
|
|
|
* the Sectored AP scenario, switch antenna every
|
|
|
|
* 4 beacons to make sure everybody hears our AP.
|
|
|
|
* When a client tries to associate, hw will keep
|
|
|
|
* track of the tx antenna to be used for this client
|
|
|
|
* automaticaly, based on ACKed packets.
|
|
|
|
*
|
|
|
|
* Note: AP still listens and transmits RTS on the
|
|
|
|
* default antenna which is supposed to be an omni.
|
|
|
|
*
|
|
|
|
* Note2: On sectored scenarios it's possible to have
|
2010-08-15 11:03:12 -06:00
|
|
|
* multiple antennas (1 omni -- the default -- and 14
|
|
|
|
* sectors), so if we choose to actually support this
|
|
|
|
* mode, we need to allow the user to set how many antennas
|
|
|
|
* we have and tweak the code below to send beacons
|
|
|
|
* on all of them.
|
2009-04-30 13:55:49 -06:00
|
|
|
*/
|
|
|
|
if (ah->ah_ant_mode == AR5K_ANTMODE_SECTOR_AP)
|
|
|
|
antenna = sc->bsent & 4 ? 2 : 1;
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2009-03-15 14:20:35 -06:00
|
|
|
/* FIXME: If we are in g mode and rate is a CCK rate
|
|
|
|
* subtract ah->ah_txpower.txp_cck_ofdm_pwr_delta
|
|
|
|
* from tx power (value is in dB units already) */
|
2007-08-12 09:33:16 -06:00
|
|
|
ds->ds_data = bf->skbaddr;
|
2008-02-05 02:44:55 -07:00
|
|
|
ret = ah->ah_setup_tx_desc(ah, ds, skb->len,
|
2010-02-27 15:05:26 -07:00
|
|
|
ieee80211_get_hdrlen_from_skb(skb), padsize,
|
2008-02-03 19:51:49 -07:00
|
|
|
AR5K_PKT_TYPE_BEACON, (sc->power_level * 2),
|
2008-05-15 04:55:29 -06:00
|
|
|
ieee80211_get_tx_rate(sc->hw, info)->hw_value,
|
2008-05-15 04:55:27 -06:00
|
|
|
1, AR5K_TXKEYIX_INVALID,
|
2008-02-03 19:51:49 -07:00
|
|
|
antenna, flags, 0, 0);
|
2007-08-12 09:33:16 -06:00
|
|
|
if (ret)
|
|
|
|
goto err_unmap;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err_unmap:
|
2010-12-02 02:26:51 -07:00
|
|
|
dma_unmap_single(sc->dev, bf->skbaddr, skb->len, DMA_TO_DEVICE);
|
2007-08-12 09:33:16 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Updates the beacon that is sent by ath5k_beacon_send. For adhoc,
|
|
|
|
* this is called only once at config_bss time, for AP we do it every
|
|
|
|
* SWBA interrupt so that the TIM will reflect buffered frames.
|
|
|
|
*
|
|
|
|
* Called with the beacon lock.
|
|
|
|
*/
|
2010-12-22 03:20:32 -07:00
|
|
|
int
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_beacon_update(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct ath5k_softc *sc = hw->priv;
|
2010-09-30 13:22:58 -06:00
|
|
|
struct ath5k_vif *avf = (void *)vif->drv_priv;
|
2010-09-16 21:45:07 -06:00
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
if (WARN_ON(!vif)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb = ieee80211_beacon_get(hw, vif);
|
|
|
|
|
|
|
|
if (!skb) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-09-30 13:22:58 -06:00
|
|
|
ath5k_txbuf_free_skb(sc, avf->bbuf);
|
|
|
|
avf->bbuf->skb = skb;
|
|
|
|
ret = ath5k_beacon_setup(sc, avf->bbuf);
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ret)
|
2010-09-30 13:22:58 -06:00
|
|
|
avf->bbuf->skb = NULL;
|
2010-09-16 21:45:07 -06:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
/*
|
|
|
|
* Transmit a beacon frame at SWBA. Dynamic updates to the
|
|
|
|
* frame contents are done as needed and the slot time is
|
|
|
|
* also adjusted based on current state.
|
|
|
|
*
|
2010-07-13 09:32:40 -06:00
|
|
|
* This is called from software irq context (beacontq tasklets)
|
|
|
|
* or user context from ath5k_beacon_config.
|
2007-08-12 09:33:16 -06:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ath5k_beacon_send(struct ath5k_softc *sc)
|
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
2010-09-30 13:22:58 -06:00
|
|
|
struct ieee80211_vif *vif;
|
|
|
|
struct ath5k_vif *avf;
|
|
|
|
struct ath5k_buf *bf;
|
2009-07-04 10:59:51 -06:00
|
|
|
struct sk_buff *skb;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2008-01-22 18:27:51 -07:00
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON, "in beacon_send\n");
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if the previous beacon has gone out. If
|
2010-08-15 11:03:12 -06:00
|
|
|
* not, don't don't try to post another: skip this
|
2007-08-12 09:33:16 -06:00
|
|
|
* period and wait for the next. Missed beacons
|
|
|
|
* indicate a problem and should not occur. If we
|
|
|
|
* miss too many consecutive beacons reset the device.
|
|
|
|
*/
|
|
|
|
if (unlikely(ath5k_hw_num_tx_pending(ah, sc->bhalq) != 0)) {
|
|
|
|
sc->bmisscount++;
|
2008-01-22 18:27:51 -07:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_BEACON,
|
2007-08-12 09:33:16 -06:00
|
|
|
"missed %u consecutive beacons\n", sc->bmisscount);
|
2009-04-30 13:55:47 -06:00
|
|
|
if (sc->bmisscount > 10) { /* NB: 10 is a guess */
|
2008-01-22 18:27:51 -07:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_BEACON,
|
2007-08-12 09:33:16 -06:00
|
|
|
"stuck beacon time (%u missed)\n",
|
|
|
|
sc->bmisscount);
|
2010-06-16 04:11:12 -06:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET,
|
|
|
|
"stuck beacon, resetting\n");
|
2010-07-13 09:32:40 -06:00
|
|
|
ieee80211_queue_work(sc->hw, &sc->reset_work);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (unlikely(sc->bmisscount != 0)) {
|
2008-01-22 18:27:51 -07:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_BEACON,
|
2007-08-12 09:33:16 -06:00
|
|
|
"resume beacon xmit after %u misses\n",
|
|
|
|
sc->bmisscount);
|
|
|
|
sc->bmisscount = 0;
|
|
|
|
}
|
|
|
|
|
2010-12-07 14:37:56 -07:00
|
|
|
if ((sc->opmode == NL80211_IFTYPE_AP && sc->num_ap_vifs > 1) ||
|
|
|
|
sc->opmode == NL80211_IFTYPE_MESH_POINT) {
|
2010-09-30 13:22:58 -06:00
|
|
|
u64 tsf = ath5k_hw_get_tsf64(ah);
|
|
|
|
u32 tsftu = TSF_TO_TU(tsf);
|
|
|
|
int slot = ((tsftu % sc->bintval) * ATH_BCBUF) / sc->bintval;
|
|
|
|
vif = sc->bslot[(slot + 1) % ATH_BCBUF];
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"tsf %llx tsftu %x intval %u slot %u vif %p\n",
|
|
|
|
(unsigned long long)tsf, tsftu, sc->bintval, slot, vif);
|
|
|
|
} else /* only one interface */
|
|
|
|
vif = sc->bslot[0];
|
|
|
|
|
|
|
|
if (!vif)
|
|
|
|
return;
|
|
|
|
|
|
|
|
avf = (void *)vif->drv_priv;
|
|
|
|
bf = avf->bbuf;
|
|
|
|
if (unlikely(bf->skb == NULL || sc->opmode == NL80211_IFTYPE_STATION ||
|
|
|
|
sc->opmode == NL80211_IFTYPE_MONITOR)) {
|
|
|
|
ATH5K_WARN(sc, "bf=%p bf_skb=%p\n", bf, bf ? bf->skb : NULL);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
/*
|
|
|
|
* Stop any current dma and put the new frame on the queue.
|
|
|
|
* This should never fail since we check above that no frames
|
|
|
|
* are still pending on the queue.
|
|
|
|
*/
|
2010-11-23 11:55:17 -07:00
|
|
|
if (unlikely(ath5k_hw_stop_beacon_queue(ah, sc->bhalq))) {
|
2009-04-30 13:55:47 -06:00
|
|
|
ATH5K_WARN(sc, "beacon queue %u didn't start/stop ?\n", sc->bhalq);
|
2007-08-12 09:33:16 -06:00
|
|
|
/* NB: hw still stops DMA, so proceed */
|
|
|
|
}
|
|
|
|
|
2010-12-07 14:35:55 -07:00
|
|
|
/* refresh the beacon for AP or MESH mode */
|
|
|
|
if (sc->opmode == NL80211_IFTYPE_AP ||
|
|
|
|
sc->opmode == NL80211_IFTYPE_MESH_POINT)
|
2010-09-30 13:22:58 -06:00
|
|
|
ath5k_beacon_update(sc->hw, vif);
|
2009-05-18 08:59:52 -06:00
|
|
|
|
2011-01-24 21:32:55 -07:00
|
|
|
trace_ath5k_tx(sc, bf->skb, &sc->txqs[sc->bhalq]);
|
|
|
|
|
2008-08-29 13:45:39 -06:00
|
|
|
ath5k_hw_set_txdp(ah, sc->bhalq, bf->daddr);
|
|
|
|
ath5k_hw_start_tx_dma(ah, sc->bhalq);
|
2008-01-22 18:27:51 -07:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_BEACON, "TXDP[%u] = %llx (%p)\n",
|
2007-08-12 09:33:16 -06:00
|
|
|
sc->bhalq, (unsigned long long)bf->daddr, bf->desc);
|
|
|
|
|
2010-09-30 13:22:58 -06:00
|
|
|
skb = ieee80211_get_buffered_bc(sc->hw, vif);
|
2009-07-04 10:59:51 -06:00
|
|
|
while (skb) {
|
|
|
|
ath5k_tx_queue(sc->hw, skb, sc->cabq);
|
2010-09-30 13:22:58 -06:00
|
|
|
skb = ieee80211_get_buffered_bc(sc->hw, vif);
|
2009-07-04 10:59:51 -06:00
|
|
|
}
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
sc->bsent++;
|
|
|
|
}
|
|
|
|
|
2008-01-19 02:17:59 -07:00
|
|
|
/**
|
|
|
|
* ath5k_beacon_update_timers - update beacon timers
|
|
|
|
*
|
|
|
|
* @sc: struct ath5k_softc pointer we are operating on
|
|
|
|
* @bc_tsf: the timestamp of the beacon. 0 to reset the TSF. -1 to perform a
|
|
|
|
* beacon timer update based on the current HW TSF.
|
|
|
|
*
|
|
|
|
* Calculate the next target beacon transmit time (TBTT) based on the timestamp
|
|
|
|
* of a received beacon or the current local hardware TSF and write it to the
|
|
|
|
* beacon timer registers.
|
|
|
|
*
|
|
|
|
* This is called in a variety of situations, e.g. when a beacon is received,
|
2008-03-05 02:36:26 -07:00
|
|
|
* when a TSF update has been detected, but also when an new IBSS is created or
|
2008-01-19 02:17:59 -07:00
|
|
|
* when we otherwise know we have to update the timers, but we keep it in this
|
|
|
|
* function to have it all together in one place.
|
|
|
|
*/
|
2010-12-22 03:20:32 -07:00
|
|
|
void
|
2008-01-19 02:17:59 -07:00
|
|
|
ath5k_beacon_update_timers(struct ath5k_softc *sc, u64 bc_tsf)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
2008-01-19 02:17:59 -07:00
|
|
|
u32 nexttbtt, intval, hw_tu, bc_tu;
|
|
|
|
u64 hw_tsf;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
intval = sc->bintval & AR5K_BEACON_PERIOD;
|
2010-09-30 13:22:58 -06:00
|
|
|
if (sc->opmode == NL80211_IFTYPE_AP && sc->num_ap_vifs > 1) {
|
|
|
|
intval /= ATH_BCBUF; /* staggered multi-bss beacons */
|
|
|
|
if (intval < 15)
|
|
|
|
ATH5K_WARN(sc, "intval %u is too low, min 15\n",
|
|
|
|
intval);
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
if (WARN_ON(!intval))
|
|
|
|
return;
|
|
|
|
|
2008-01-19 02:17:59 -07:00
|
|
|
/* beacon TSF converted to TU */
|
|
|
|
bc_tu = TSF_TO_TU(bc_tsf);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2008-01-19 02:17:59 -07:00
|
|
|
/* current TSF converted to TU */
|
|
|
|
hw_tsf = ath5k_hw_get_tsf64(ah);
|
|
|
|
hw_tu = TSF_TO_TU(hw_tsf);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2011-07-07 16:14:01 -06:00
|
|
|
#define FUDGE (AR5K_TUNE_SW_BEACON_RESP + 3)
|
2010-09-26 21:22:26 -06:00
|
|
|
/* We use FUDGE to make sure the next TBTT is ahead of the current TU.
|
2011-03-30 19:57:33 -06:00
|
|
|
* Since we later subtract AR5K_TUNE_SW_BEACON_RESP (10) in the timer
|
2010-09-26 21:22:26 -06:00
|
|
|
* configuration we need to make sure it is bigger than that. */
|
|
|
|
|
2008-01-19 02:17:59 -07:00
|
|
|
if (bc_tsf == -1) {
|
|
|
|
/*
|
|
|
|
* no beacons received, called internally.
|
|
|
|
* just need to refresh timers based on HW TSF.
|
|
|
|
*/
|
|
|
|
nexttbtt = roundup(hw_tu + FUDGE, intval);
|
|
|
|
} else if (bc_tsf == 0) {
|
|
|
|
/*
|
|
|
|
* no beacon received, probably called by ath5k_reset_tsf().
|
|
|
|
* reset TSF to start with 0.
|
|
|
|
*/
|
|
|
|
nexttbtt = intval;
|
|
|
|
intval |= AR5K_BEACON_RESET_TSF;
|
|
|
|
} else if (bc_tsf > hw_tsf) {
|
|
|
|
/*
|
2011-03-30 19:57:33 -06:00
|
|
|
* beacon received, SW merge happened but HW TSF not yet updated.
|
2008-01-19 02:17:59 -07:00
|
|
|
* not possible to reconfigure timers yet, but next time we
|
|
|
|
* receive a beacon with the same BSSID, the hardware will
|
|
|
|
* automatically update the TSF and then we need to reconfigure
|
|
|
|
* the timers.
|
|
|
|
*/
|
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"need to wait for HW TSF sync\n");
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* most important case for beacon synchronization between STA.
|
|
|
|
*
|
|
|
|
* beacon received and HW TSF has been already updated by HW.
|
|
|
|
* update next TBTT based on the TSF of the beacon, but make
|
|
|
|
* sure it is ahead of our local TSF timer.
|
|
|
|
*/
|
|
|
|
nexttbtt = bc_tu + roundup(hw_tu + FUDGE - bc_tu, intval);
|
|
|
|
}
|
|
|
|
#undef FUDGE
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2008-01-19 02:18:21 -07:00
|
|
|
sc->nexttbtt = nexttbtt;
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
intval |= AR5K_BEACON_ENA;
|
|
|
|
ath5k_hw_init_beacon(ah, nexttbtt, intval);
|
2008-01-19 02:17:59 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* debugging output last in order to preserve the time critical aspect
|
|
|
|
* of this function
|
|
|
|
*/
|
|
|
|
if (bc_tsf == -1)
|
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"reconfigured timers based on HW TSF\n");
|
|
|
|
else if (bc_tsf == 0)
|
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"reset HW TSF and timers\n");
|
|
|
|
else
|
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"updated timers based on beacon TSF\n");
|
|
|
|
|
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON,
|
2008-02-15 17:08:59 -07:00
|
|
|
"bc_tsf %llx hw_tsf %llx bc_tu %u hw_tu %u nexttbtt %u\n",
|
|
|
|
(unsigned long long) bc_tsf,
|
|
|
|
(unsigned long long) hw_tsf, bc_tu, hw_tu, nexttbtt);
|
2008-01-19 02:17:59 -07:00
|
|
|
ATH5K_DBG_UNLIMIT(sc, ATH5K_DEBUG_BEACON, "intval %u %s %s\n",
|
|
|
|
intval & AR5K_BEACON_PERIOD,
|
|
|
|
intval & AR5K_BEACON_ENA ? "AR5K_BEACON_ENA" : "",
|
|
|
|
intval & AR5K_BEACON_RESET_TSF ? "AR5K_BEACON_RESET_TSF" : "");
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2008-01-19 02:18:21 -07:00
|
|
|
/**
|
|
|
|
* ath5k_beacon_config - Configure the beacon queues and interrupts
|
|
|
|
*
|
|
|
|
* @sc: struct ath5k_softc pointer we are operating on
|
2007-08-12 09:33:16 -06:00
|
|
|
*
|
2008-01-19 02:18:21 -07:00
|
|
|
* In IBSS mode we use a self-linked tx descriptor if possible. We enable SWBA
|
2008-03-05 02:36:26 -07:00
|
|
|
* interrupts to detect TSF updates only.
|
2007-08-12 09:33:16 -06:00
|
|
|
*/
|
2010-12-22 03:20:32 -07:00
|
|
|
void
|
2007-08-12 09:33:16 -06:00
|
|
|
ath5k_beacon_config(struct ath5k_softc *sc)
|
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
2009-02-15 10:06:10 -07:00
|
|
|
unsigned long flags;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2009-07-04 10:59:52 -06:00
|
|
|
spin_lock_irqsave(&sc->block, flags);
|
2007-08-12 09:33:16 -06:00
|
|
|
sc->bmisscount = 0;
|
2008-07-23 05:17:34 -06:00
|
|
|
sc->imask &= ~(AR5K_INT_BMISS | AR5K_INT_SWBA);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2009-07-04 10:59:52 -06:00
|
|
|
if (sc->enable_beacon) {
|
2007-08-12 09:33:16 -06:00
|
|
|
/*
|
2008-01-19 02:18:21 -07:00
|
|
|
* In IBSS mode we use a self-linked tx descriptor and let the
|
|
|
|
* hardware send the beacons automatically. We have to load it
|
2007-08-12 09:33:16 -06:00
|
|
|
* only once here.
|
2008-01-19 02:18:21 -07:00
|
|
|
* We use the SWBA interrupt only to keep track of the beacon
|
2008-03-05 02:36:26 -07:00
|
|
|
* timers in order to detect automatic TSF updates.
|
2007-08-12 09:33:16 -06:00
|
|
|
*/
|
|
|
|
ath5k_beaconq_config(sc);
|
|
|
|
|
2008-01-19 02:18:21 -07:00
|
|
|
sc->imask |= AR5K_INT_SWBA;
|
|
|
|
|
2008-10-12 14:54:10 -06:00
|
|
|
if (sc->opmode == NL80211_IFTYPE_ADHOC) {
|
2009-07-04 10:59:52 -06:00
|
|
|
if (ath5k_hw_hasveol(ah))
|
2008-10-12 14:54:10 -06:00
|
|
|
ath5k_beacon_send(sc);
|
|
|
|
} else
|
|
|
|
ath5k_beacon_update_timers(sc, -1);
|
2009-07-04 10:59:52 -06:00
|
|
|
} else {
|
2010-11-23 11:55:17 -07:00
|
|
|
ath5k_hw_stop_beacon_queue(sc->ah, sc->bhalq);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2008-08-29 13:45:39 -06:00
|
|
|
ath5k_hw_set_imr(ah, sc->imask);
|
2009-07-04 10:59:52 -06:00
|
|
|
mmiowb();
|
|
|
|
spin_unlock_irqrestore(&sc->block, flags);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2009-04-30 13:55:47 -06:00
|
|
|
static void ath5k_tasklet_beacon(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = (struct ath5k_softc *) data;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Software beacon alert--time to send a beacon.
|
|
|
|
*
|
|
|
|
* In IBSS mode we use this interrupt just to
|
|
|
|
* keep track of the next TBTT (target beacon
|
|
|
|
* transmission time) in order to detect wether
|
|
|
|
* automatic TSF updates happened.
|
|
|
|
*/
|
|
|
|
if (sc->opmode == NL80211_IFTYPE_ADHOC) {
|
|
|
|
/* XXX: only if VEOL suppported */
|
|
|
|
u64 tsf = ath5k_hw_get_tsf64(sc->ah);
|
|
|
|
sc->nexttbtt += sc->bintval;
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_BEACON,
|
|
|
|
"SWBA nexttbtt: %x hw_tu: %x "
|
|
|
|
"TSF: %llx\n",
|
|
|
|
sc->nexttbtt,
|
|
|
|
TSF_TO_TU(tsf),
|
|
|
|
(unsigned long long) tsf);
|
|
|
|
} else {
|
|
|
|
spin_lock(&sc->block);
|
|
|
|
ath5k_beacon_send(sc);
|
|
|
|
spin_unlock(&sc->block);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
/********************\
|
|
|
|
* Interrupt handling *
|
|
|
|
\********************/
|
|
|
|
|
2010-03-24 23:49:19 -06:00
|
|
|
static void
|
|
|
|
ath5k_intr_calibration_poll(struct ath5k_hw *ah)
|
|
|
|
{
|
2010-04-02 03:44:08 -06:00
|
|
|
if (time_is_before_eq_jiffies(ah->ah_cal_next_ani) &&
|
|
|
|
!(ah->ah_cal_mask & AR5K_CALIBRATION_FULL)) {
|
|
|
|
/* run ANI only when full calibration is not active */
|
|
|
|
ah->ah_cal_next_ani = jiffies +
|
|
|
|
msecs_to_jiffies(ATH5K_TUNE_CALIBRATION_INTERVAL_ANI);
|
|
|
|
tasklet_schedule(&ah->ah_sc->ani_tasklet);
|
|
|
|
|
|
|
|
} else if (time_is_before_eq_jiffies(ah->ah_cal_next_full)) {
|
2010-03-24 23:49:19 -06:00
|
|
|
ah->ah_cal_next_full = jiffies +
|
|
|
|
msecs_to_jiffies(ATH5K_TUNE_CALIBRATION_INTERVAL_FULL);
|
|
|
|
tasklet_schedule(&ah->ah_sc->calib);
|
|
|
|
}
|
|
|
|
/* we could use SWI to generate enough interrupts to meet our
|
|
|
|
* calibration interval requirements, if necessary:
|
|
|
|
* AR5K_REG_ENABLE_BITS(ah, AR5K_CR, AR5K_CR_SWI); */
|
|
|
|
}
|
|
|
|
|
2011-04-10 10:32:19 -06:00
|
|
|
static void
|
|
|
|
ath5k_schedule_rx(struct ath5k_softc *sc)
|
|
|
|
{
|
|
|
|
sc->rx_pending = true;
|
|
|
|
tasklet_schedule(&sc->rxtq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ath5k_schedule_tx(struct ath5k_softc *sc)
|
|
|
|
{
|
|
|
|
sc->tx_pending = true;
|
|
|
|
tasklet_schedule(&sc->txtq);
|
|
|
|
}
|
|
|
|
|
2011-06-15 16:03:22 -06:00
|
|
|
static irqreturn_t
|
2007-08-12 09:33:16 -06:00
|
|
|
ath5k_intr(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = dev_id;
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
enum ath5k_int status;
|
|
|
|
unsigned int counter = 1000;
|
|
|
|
|
|
|
|
if (unlikely(test_bit(ATH_STAT_INVALID, sc->status) ||
|
2010-12-02 02:27:21 -07:00
|
|
|
((ath5k_get_bus_type(ah) != ATH_AHB) &&
|
|
|
|
!ath5k_hw_is_intr_pending(ah))))
|
2007-08-12 09:33:16 -06:00
|
|
|
return IRQ_NONE;
|
|
|
|
|
|
|
|
do {
|
|
|
|
ath5k_hw_get_isr(ah, &status); /* NB: clears IRQ too */
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_INTR, "status 0x%x/0x%x\n",
|
|
|
|
status, sc->imask);
|
|
|
|
if (unlikely(status & AR5K_INT_FATAL)) {
|
|
|
|
/*
|
|
|
|
* Fatal errors are unrecoverable.
|
|
|
|
* Typically these are caused by DMA errors.
|
|
|
|
*/
|
2010-06-16 04:11:12 -06:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET,
|
|
|
|
"fatal int, resetting\n");
|
2010-07-13 09:32:40 -06:00
|
|
|
ieee80211_queue_work(sc->hw, &sc->reset_work);
|
2007-08-12 09:33:16 -06:00
|
|
|
} else if (unlikely(status & AR5K_INT_RXORN)) {
|
2010-04-12 01:38:52 -06:00
|
|
|
/*
|
|
|
|
* Receive buffers are full. Either the bus is busy or
|
|
|
|
* the CPU is not fast enough to process all received
|
|
|
|
* frames.
|
|
|
|
* Older chipsets need a reset to come out of this
|
|
|
|
* condition, but we treat it as RX for newer chips.
|
|
|
|
* We don't know exactly which versions need a reset -
|
|
|
|
* this guess is copied from the HAL.
|
|
|
|
*/
|
|
|
|
sc->stats.rxorn_intr++;
|
2010-06-16 04:11:12 -06:00
|
|
|
if (ah->ah_mac_srev < AR5K_SREV_AR5212) {
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET,
|
|
|
|
"rx overrun, resetting\n");
|
2010-07-13 09:32:40 -06:00
|
|
|
ieee80211_queue_work(sc->hw, &sc->reset_work);
|
2010-06-16 04:11:12 -06:00
|
|
|
}
|
2010-04-12 01:38:52 -06:00
|
|
|
else
|
2011-04-10 10:32:19 -06:00
|
|
|
ath5k_schedule_rx(sc);
|
2007-08-12 09:33:16 -06:00
|
|
|
} else {
|
|
|
|
if (status & AR5K_INT_SWBA) {
|
2009-04-15 05:57:33 -06:00
|
|
|
tasklet_hi_schedule(&sc->beacontq);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
if (status & AR5K_INT_RXEOL) {
|
|
|
|
/*
|
|
|
|
* NB: the hardware should re-read the link when
|
|
|
|
* RXE bit is written, but it doesn't work at
|
|
|
|
* least on older hardware revs.
|
|
|
|
*/
|
2010-07-13 19:53:29 -06:00
|
|
|
sc->stats.rxeol_intr++;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
if (status & AR5K_INT_TXURN) {
|
|
|
|
/* bump tx trigger level */
|
|
|
|
ath5k_hw_update_tx_triglevel(ah, true);
|
|
|
|
}
|
2008-10-26 12:40:25 -06:00
|
|
|
if (status & (AR5K_INT_RXOK | AR5K_INT_RXERR))
|
2011-04-10 10:32:19 -06:00
|
|
|
ath5k_schedule_rx(sc);
|
2008-10-26 12:40:25 -06:00
|
|
|
if (status & (AR5K_INT_TXOK | AR5K_INT_TXDESC
|
|
|
|
| AR5K_INT_TXERR | AR5K_INT_TXEOL))
|
2011-04-10 10:32:19 -06:00
|
|
|
ath5k_schedule_tx(sc);
|
2007-08-12 09:33:16 -06:00
|
|
|
if (status & AR5K_INT_BMISS) {
|
2009-02-08 21:15:42 -07:00
|
|
|
/* TODO */
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
if (status & AR5K_INT_MIB) {
|
2010-04-02 03:44:08 -06:00
|
|
|
sc->stats.mib_intr++;
|
2010-03-24 23:49:36 -06:00
|
|
|
ath5k_hw_update_mib_counters(ah);
|
2010-04-02 03:44:08 -06:00
|
|
|
ath5k_ani_mib_intr(ah);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
2009-06-09 09:33:27 -06:00
|
|
|
if (status & AR5K_INT_GPIO)
|
|
|
|
tasklet_schedule(&sc->rf_kill.toggleq);
|
2009-06-09 21:43:11 -06:00
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
2010-12-02 02:27:21 -07:00
|
|
|
|
|
|
|
if (ath5k_get_bus_type(ah) == ATH_AHB)
|
|
|
|
break;
|
|
|
|
|
2009-04-27 20:18:10 -06:00
|
|
|
} while (ath5k_hw_is_intr_pending(ah) && --counter > 0);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2011-04-10 10:32:19 -06:00
|
|
|
if (sc->rx_pending || sc->tx_pending)
|
|
|
|
ath5k_set_current_imask(sc);
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
if (unlikely(!counter))
|
|
|
|
ATH5K_WARN(sc, "too many interrupts, giving up for now\n");
|
|
|
|
|
2010-03-24 23:49:19 -06:00
|
|
|
ath5k_intr_calibration_poll(ah);
|
2009-08-09 18:31:31 -06:00
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Periodically recalibrate the PHY to account
|
|
|
|
* for temperature/environment changes.
|
|
|
|
*/
|
|
|
|
static void
|
2009-08-09 18:31:31 -06:00
|
|
|
ath5k_tasklet_calibrate(unsigned long data)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = (void *)data;
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
|
2009-08-09 18:31:31 -06:00
|
|
|
/* Only full calibration for now */
|
2010-03-24 23:49:09 -06:00
|
|
|
ah->ah_cal_mask |= AR5K_CALIBRATION_FULL;
|
2009-08-09 18:31:31 -06:00
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_CALIBRATE, "channel %u/%x\n",
|
2008-02-03 19:51:49 -07:00
|
|
|
ieee80211_frequency_to_channel(sc->curchan->center_freq),
|
|
|
|
sc->curchan->hw_value);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2009-02-08 21:03:41 -07:00
|
|
|
if (ath5k_hw_gainf_calibrate(ah) == AR5K_RFGAIN_NEED_CHANGE) {
|
2007-08-12 09:33:16 -06:00
|
|
|
/*
|
|
|
|
* Rfgain is out of bounds, reset the chip
|
|
|
|
* to load new gain values.
|
|
|
|
*/
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET, "calibration, resetting\n");
|
2010-07-13 09:32:40 -06:00
|
|
|
ieee80211_queue_work(sc->hw, &sc->reset_work);
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
if (ath5k_hw_phy_calibrate(ah, sc->curchan))
|
|
|
|
ATH5K_ERR(sc, "calibration of channel %u failed\n",
|
2008-02-03 19:51:49 -07:00
|
|
|
ieee80211_frequency_to_channel(
|
|
|
|
sc->curchan->center_freq));
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-05-18 19:31:05 -06:00
|
|
|
/* Noise floor calibration interrupts rx/tx path while I/Q calibration
|
2010-09-16 20:36:46 -06:00
|
|
|
* doesn't.
|
|
|
|
* TODO: We should stop TX here, so that it doesn't interfere.
|
|
|
|
* Note that stopping the queues is not enough to stop TX! */
|
2010-05-18 19:31:10 -06:00
|
|
|
if (time_is_before_eq_jiffies(ah->ah_cal_next_nf)) {
|
|
|
|
ah->ah_cal_next_nf = jiffies +
|
|
|
|
msecs_to_jiffies(ATH5K_TUNE_CALIBRATION_INTERVAL_NF);
|
|
|
|
ath5k_hw_update_noise_floor(ah);
|
|
|
|
}
|
2009-08-09 18:31:31 -06:00
|
|
|
|
2010-03-24 23:49:09 -06:00
|
|
|
ah->ah_cal_mask &= ~AR5K_CALIBRATION_FULL;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-02 03:44:08 -06:00
|
|
|
static void
|
|
|
|
ath5k_tasklet_ani(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = (void *)data;
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
|
|
|
|
ah->ah_cal_mask |= AR5K_CALIBRATION_ANI;
|
|
|
|
ath5k_ani_calibration(ah);
|
|
|
|
ah->ah_cal_mask &= ~AR5K_CALIBRATION_ANI;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-16 20:36:56 -06:00
|
|
|
static void
|
|
|
|
ath5k_tx_complete_poll_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = container_of(work, struct ath5k_softc,
|
|
|
|
tx_complete_work.work);
|
|
|
|
struct ath5k_txq *txq;
|
|
|
|
int i;
|
|
|
|
bool needreset = false;
|
|
|
|
|
2011-01-18 06:06:43 -07:00
|
|
|
mutex_lock(&sc->lock);
|
|
|
|
|
2010-09-16 20:36:56 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sc->txqs); i++) {
|
|
|
|
if (sc->txqs[i].setup) {
|
|
|
|
txq = &sc->txqs[i];
|
|
|
|
spin_lock_bh(&txq->lock);
|
2010-09-16 20:37:07 -06:00
|
|
|
if (txq->txq_len > 1) {
|
2010-09-16 20:36:56 -06:00
|
|
|
if (txq->txq_poll_mark) {
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_XMIT,
|
|
|
|
"TX queue stuck %d\n",
|
|
|
|
txq->qnum);
|
|
|
|
needreset = true;
|
2010-09-16 20:37:02 -06:00
|
|
|
txq->txq_stuck++;
|
2010-09-16 20:36:56 -06:00
|
|
|
spin_unlock_bh(&txq->lock);
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
txq->txq_poll_mark = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&txq->lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (needreset) {
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET,
|
|
|
|
"TX queues stuck, resetting\n");
|
2010-11-23 12:39:28 -07:00
|
|
|
ath5k_reset(sc, NULL, true);
|
2010-09-16 20:36:56 -06:00
|
|
|
}
|
|
|
|
|
2011-01-18 06:06:43 -07:00
|
|
|
mutex_unlock(&sc->lock);
|
|
|
|
|
2010-09-16 20:36:56 -06:00
|
|
|
ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work,
|
|
|
|
msecs_to_jiffies(ATH5K_TX_COMPLETE_POLL_INT));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*************************\
|
|
|
|
* Initialization routines *
|
|
|
|
\*************************/
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2011-07-07 16:13:42 -06:00
|
|
|
int __devinit
|
2010-12-02 02:26:56 -07:00
|
|
|
ath5k_init_softc(struct ath5k_softc *sc, const struct ath_bus_ops *bus_ops)
|
|
|
|
{
|
|
|
|
struct ieee80211_hw *hw = sc->hw;
|
|
|
|
struct ath_common *common;
|
|
|
|
int ret;
|
|
|
|
int csz;
|
|
|
|
|
|
|
|
/* Initialize driver private data */
|
|
|
|
SET_IEEE80211_DEV(hw, sc->dev);
|
|
|
|
hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
|
2010-12-02 21:12:39 -07:00
|
|
|
IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
|
|
|
|
IEEE80211_HW_SIGNAL_DBM |
|
|
|
|
IEEE80211_HW_REPORTS_TX_ACK_STATUS;
|
2010-12-02 02:26:56 -07:00
|
|
|
|
|
|
|
hw->wiphy->interface_modes =
|
|
|
|
BIT(NL80211_IFTYPE_AP) |
|
|
|
|
BIT(NL80211_IFTYPE_STATION) |
|
|
|
|
BIT(NL80211_IFTYPE_ADHOC) |
|
|
|
|
BIT(NL80211_IFTYPE_MESH_POINT);
|
|
|
|
|
2010-12-15 19:30:33 -07:00
|
|
|
/* both antennas can be configured as RX or TX */
|
|
|
|
hw->wiphy->available_antennas_tx = 0x3;
|
|
|
|
hw->wiphy->available_antennas_rx = 0x3;
|
|
|
|
|
2010-12-02 02:26:56 -07:00
|
|
|
hw->extra_tx_headroom = 2;
|
|
|
|
hw->channel_change_time = 5000;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark the device as detached to avoid processing
|
|
|
|
* interrupts until setup is complete.
|
|
|
|
*/
|
|
|
|
__set_bit(ATH_STAT_INVALID, sc->status);
|
|
|
|
|
|
|
|
sc->opmode = NL80211_IFTYPE_STATION;
|
|
|
|
sc->bintval = 1000;
|
|
|
|
mutex_init(&sc->lock);
|
|
|
|
spin_lock_init(&sc->rxbuflock);
|
|
|
|
spin_lock_init(&sc->txbuflock);
|
|
|
|
spin_lock_init(&sc->block);
|
2011-05-06 16:24:34 -06:00
|
|
|
spin_lock_init(&sc->irqlock);
|
2010-12-02 02:26:56 -07:00
|
|
|
|
|
|
|
/* Setup interrupt handler */
|
|
|
|
ret = request_irq(sc->irq, ath5k_intr, IRQF_SHARED, "ath", sc);
|
|
|
|
if (ret) {
|
|
|
|
ATH5K_ERR(sc, "request_irq failed\n");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we passed the test, malloc an ath5k_hw struct */
|
|
|
|
sc->ah = kzalloc(sizeof(struct ath5k_hw), GFP_KERNEL);
|
|
|
|
if (!sc->ah) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
ATH5K_ERR(sc, "out of memory\n");
|
|
|
|
goto err_irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->ah->ah_sc = sc;
|
|
|
|
sc->ah->ah_iobase = sc->iobase;
|
|
|
|
common = ath5k_hw_common(sc->ah);
|
|
|
|
common->ops = &ath5k_common_ops;
|
|
|
|
common->bus_ops = bus_ops;
|
|
|
|
common->ah = sc->ah;
|
|
|
|
common->hw = hw;
|
|
|
|
common->priv = sc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cache line size is used to size and align various
|
|
|
|
* structures used to communicate with the hardware.
|
|
|
|
*/
|
|
|
|
ath5k_read_cachesize(common, &csz);
|
|
|
|
common->cachelsz = csz << 2; /* convert to bytes */
|
|
|
|
|
|
|
|
spin_lock_init(&common->cc_lock);
|
|
|
|
|
|
|
|
/* Initialize device */
|
|
|
|
ret = ath5k_hw_init(sc);
|
|
|
|
if (ret)
|
|
|
|
goto err_free_ah;
|
|
|
|
|
|
|
|
/* set up multi-rate retry capabilities */
|
|
|
|
if (sc->ah->ah_version == AR5K_AR5212) {
|
|
|
|
hw->max_rates = 4;
|
2011-01-28 00:52:11 -07:00
|
|
|
hw->max_rate_tries = max(AR5K_INIT_RETRY_SHORT,
|
|
|
|
AR5K_INIT_RETRY_LONG);
|
2010-12-02 02:26:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
hw->vif_data_size = sizeof(struct ath5k_vif);
|
|
|
|
|
|
|
|
/* Finish private driver data initialization */
|
|
|
|
ret = ath5k_init(hw);
|
|
|
|
if (ret)
|
|
|
|
goto err_ah;
|
|
|
|
|
|
|
|
ATH5K_INFO(sc, "Atheros AR%s chip found (MAC: 0x%x, PHY: 0x%x)\n",
|
|
|
|
ath5k_chip_name(AR5K_VERSION_MAC, sc->ah->ah_mac_srev),
|
|
|
|
sc->ah->ah_mac_srev,
|
|
|
|
sc->ah->ah_phy_revision);
|
|
|
|
|
|
|
|
if (!sc->ah->ah_single_chip) {
|
|
|
|
/* Single chip radio (!RF5111) */
|
|
|
|
if (sc->ah->ah_radio_5ghz_revision &&
|
|
|
|
!sc->ah->ah_radio_2ghz_revision) {
|
|
|
|
/* No 5GHz support -> report 2GHz radio */
|
|
|
|
if (!test_bit(AR5K_MODE_11A,
|
|
|
|
sc->ah->ah_capabilities.cap_mode)) {
|
|
|
|
ATH5K_INFO(sc, "RF%s 2GHz radio found (0x%x)\n",
|
|
|
|
ath5k_chip_name(AR5K_VERSION_RAD,
|
|
|
|
sc->ah->ah_radio_5ghz_revision),
|
|
|
|
sc->ah->ah_radio_5ghz_revision);
|
|
|
|
/* No 2GHz support (5110 and some
|
|
|
|
* 5Ghz only cards) -> report 5Ghz radio */
|
|
|
|
} else if (!test_bit(AR5K_MODE_11B,
|
|
|
|
sc->ah->ah_capabilities.cap_mode)) {
|
|
|
|
ATH5K_INFO(sc, "RF%s 5GHz radio found (0x%x)\n",
|
|
|
|
ath5k_chip_name(AR5K_VERSION_RAD,
|
|
|
|
sc->ah->ah_radio_5ghz_revision),
|
|
|
|
sc->ah->ah_radio_5ghz_revision);
|
|
|
|
/* Multiband radio */
|
|
|
|
} else {
|
|
|
|
ATH5K_INFO(sc, "RF%s multiband radio found"
|
|
|
|
" (0x%x)\n",
|
|
|
|
ath5k_chip_name(AR5K_VERSION_RAD,
|
|
|
|
sc->ah->ah_radio_5ghz_revision),
|
|
|
|
sc->ah->ah_radio_5ghz_revision);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Multi chip radio (RF5111 - RF2111) ->
|
|
|
|
* report both 2GHz/5GHz radios */
|
|
|
|
else if (sc->ah->ah_radio_5ghz_revision &&
|
|
|
|
sc->ah->ah_radio_2ghz_revision){
|
|
|
|
ATH5K_INFO(sc, "RF%s 5GHz radio found (0x%x)\n",
|
|
|
|
ath5k_chip_name(AR5K_VERSION_RAD,
|
|
|
|
sc->ah->ah_radio_5ghz_revision),
|
|
|
|
sc->ah->ah_radio_5ghz_revision);
|
|
|
|
ATH5K_INFO(sc, "RF%s 2GHz radio found (0x%x)\n",
|
|
|
|
ath5k_chip_name(AR5K_VERSION_RAD,
|
|
|
|
sc->ah->ah_radio_2ghz_revision),
|
|
|
|
sc->ah->ah_radio_2ghz_revision);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ath5k_debug_init_device(sc);
|
|
|
|
|
|
|
|
/* ready to process interrupts */
|
|
|
|
__clear_bit(ATH_STAT_INVALID, sc->status);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err_ah:
|
|
|
|
ath5k_hw_deinit(sc->ah);
|
|
|
|
err_free_ah:
|
|
|
|
kfree(sc->ah);
|
|
|
|
err_irq:
|
|
|
|
free_irq(sc->irq, sc);
|
|
|
|
err:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
static int
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_stop_locked(struct ath5k_softc *sc)
|
2009-07-04 10:59:51 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_hw *ah = sc->ah;
|
2009-07-04 10:59:51 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET, "invalid %u\n",
|
|
|
|
test_bit(ATH_STAT_INVALID, sc->status));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shutdown the hardware and driver:
|
|
|
|
* stop output from above
|
|
|
|
* disable interrupts
|
|
|
|
* turn off timers
|
|
|
|
* turn off the radio
|
|
|
|
* clear transmit machinery
|
|
|
|
* clear receive machinery
|
|
|
|
* drain and release tx queues
|
|
|
|
* reclaim beacon resources
|
|
|
|
* power down hardware
|
|
|
|
*
|
|
|
|
* Note that some of this work is not possible if the
|
|
|
|
* hardware is gone (invalid).
|
|
|
|
*/
|
|
|
|
ieee80211_stop_queues(sc->hw);
|
|
|
|
|
|
|
|
if (!test_bit(ATH_STAT_INVALID, sc->status)) {
|
|
|
|
ath5k_led_off(sc);
|
|
|
|
ath5k_hw_set_imr(ah, 0);
|
2010-12-02 02:26:51 -07:00
|
|
|
synchronize_irq(sc->irq);
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_rx_stop(sc);
|
2010-11-23 11:45:38 -07:00
|
|
|
ath5k_hw_dma_stop(ah);
|
|
|
|
ath5k_drain_tx_buffs(sc);
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_hw_phy_disable(ah);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2009-07-04 10:59:51 -06:00
|
|
|
}
|
|
|
|
|
2010-12-22 03:20:32 -07:00
|
|
|
int
|
2010-12-02 02:26:56 -07:00
|
|
|
ath5k_init_hw(struct ath5k_softc *sc)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath_common *common = ath5k_hw_common(ah);
|
|
|
|
int ret, i;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
mutex_lock(&sc->lock);
|
|
|
|
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET, "mode %d\n", sc->opmode);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
/*
|
2010-09-16 21:45:07 -06:00
|
|
|
* Stop anything previously setup. This is safe
|
|
|
|
* no matter this is the first time through or not.
|
2007-08-12 09:33:16 -06:00
|
|
|
*/
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_stop_locked(sc);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* The basic interface to setting the hardware in a good
|
|
|
|
* state is ``reset''. On return the hardware is known to
|
|
|
|
* be powered up and with interrupts disabled. This must
|
|
|
|
* be followed by initialization of the appropriate bits
|
|
|
|
* and then setup of the interrupt mask.
|
|
|
|
*/
|
|
|
|
sc->curchan = sc->hw->conf.channel;
|
|
|
|
sc->imask = AR5K_INT_RXOK | AR5K_INT_RXERR | AR5K_INT_RXEOL |
|
|
|
|
AR5K_INT_RXORN | AR5K_INT_TXDESC | AR5K_INT_TXEOL |
|
|
|
|
AR5K_INT_FATAL | AR5K_INT_GLOBAL | AR5K_INT_MIB;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-11-23 12:39:28 -07:00
|
|
|
ret = ath5k_reset(sc, NULL, false);
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ret)
|
|
|
|
goto done;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_rfkill_hw_start(ah);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reset the key cache since some parts do not reset the
|
|
|
|
* contents on initial power up or resume from suspend.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < common->keymax; i++)
|
|
|
|
ath_hw_keyreset(common, (u16) i);
|
|
|
|
|
2010-11-23 12:12:23 -07:00
|
|
|
/* Use higher rates for acks instead of base
|
|
|
|
* rate */
|
|
|
|
ah->ah_ack_bitrate_high = true;
|
2010-09-30 13:22:58 -06:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sc->bslot); i++)
|
|
|
|
sc->bslot[i] = NULL;
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ret = 0;
|
|
|
|
done:
|
|
|
|
mmiowb();
|
|
|
|
mutex_unlock(&sc->lock);
|
2010-09-16 20:36:56 -06:00
|
|
|
|
|
|
|
ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work,
|
|
|
|
msecs_to_jiffies(ATH5K_TX_COMPLETE_POLL_INT));
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-06-15 16:03:22 -06:00
|
|
|
static void ath5k_stop_tasklets(struct ath5k_softc *sc)
|
2010-09-16 21:45:07 -06:00
|
|
|
{
|
2011-04-10 10:32:19 -06:00
|
|
|
sc->rx_pending = false;
|
|
|
|
sc->tx_pending = false;
|
2010-09-16 21:45:07 -06:00
|
|
|
tasklet_kill(&sc->rxtq);
|
|
|
|
tasklet_kill(&sc->txtq);
|
|
|
|
tasklet_kill(&sc->calib);
|
|
|
|
tasklet_kill(&sc->beacontq);
|
|
|
|
tasklet_kill(&sc->ani_tasklet);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop the device, grabbing the top-level lock to protect
|
|
|
|
* against concurrent entry through ath5k_init (which can happen
|
|
|
|
* if another thread does a system call and the thread doing the
|
|
|
|
* stop is preempted).
|
|
|
|
*/
|
2010-12-22 03:20:32 -07:00
|
|
|
int
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_stop_hw(struct ath5k_softc *sc)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&sc->lock);
|
|
|
|
ret = ath5k_stop_locked(sc);
|
|
|
|
if (ret == 0 && !test_bit(ATH_STAT_INVALID, sc->status)) {
|
|
|
|
/*
|
|
|
|
* Don't set the card in full sleep mode!
|
|
|
|
*
|
|
|
|
* a) When the device is in this state it must be carefully
|
|
|
|
* woken up or references to registers in the PCI clock
|
|
|
|
* domain may freeze the bus (and system). This varies
|
|
|
|
* by chip and is mostly an issue with newer parts
|
|
|
|
* (madwifi sources mentioned srev >= 0x78) that go to
|
|
|
|
* sleep more quickly.
|
|
|
|
*
|
|
|
|
* b) On older chips full sleep results a weird behaviour
|
|
|
|
* during wakeup. I tested various cards with srev < 0x78
|
|
|
|
* and they don't wake up after module reload, a second
|
|
|
|
* module reload is needed to bring the card up again.
|
|
|
|
*
|
|
|
|
* Until we figure out what's going on don't enable
|
|
|
|
* full chip reset on any chip (this is what Legacy HAL
|
|
|
|
* and Sam's HAL do anyway). Instead Perform a full reset
|
|
|
|
* on the device (same as initial state after attach) and
|
|
|
|
* leave it idle (keep MAC/BB on warm reset) */
|
|
|
|
ret = ath5k_hw_on_hold(sc->ah);
|
|
|
|
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET,
|
|
|
|
"putting device to sleep\n");
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
mmiowb();
|
|
|
|
mutex_unlock(&sc->lock);
|
|
|
|
|
2011-06-15 16:03:22 -06:00
|
|
|
ath5k_stop_tasklets(sc);
|
2010-09-16 21:45:07 -06:00
|
|
|
|
2010-09-16 20:36:56 -06:00
|
|
|
cancel_delayed_work_sync(&sc->tx_complete_work);
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_rfkill_hw_stop(sc->ah);
|
|
|
|
|
|
|
|
return ret;
|
2007-08-12 09:33:16 -06:00
|
|
|
}
|
|
|
|
|
2009-05-07 06:09:08 -06:00
|
|
|
/*
|
|
|
|
* Reset the hardware. If chan is not NULL, then also pause rx/tx
|
|
|
|
* and change to the given channel.
|
2010-07-13 09:32:40 -06:00
|
|
|
*
|
|
|
|
* This should be called with sc->lock.
|
2009-05-07 06:09:08 -06:00
|
|
|
*/
|
2007-08-12 09:33:16 -06:00
|
|
|
static int
|
2010-11-23 12:39:28 -07:00
|
|
|
ath5k_reset(struct ath5k_softc *sc, struct ieee80211_channel *chan,
|
|
|
|
bool skip_pcu)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
2010-12-16 00:22:20 -07:00
|
|
|
struct ath_common *common = ath5k_hw_common(ah);
|
2010-12-02 21:07:13 -07:00
|
|
|
int ret, ani_mode;
|
2011-06-01 18:09:48 -06:00
|
|
|
bool fast;
|
2007-08-12 09:33:16 -06:00
|
|
|
|
|
|
|
ATH5K_DBG(sc, ATH5K_DEBUG_RESET, "resetting\n");
|
|
|
|
|
2010-07-13 09:32:41 -06:00
|
|
|
ath5k_hw_set_imr(ah, 0);
|
2010-12-02 02:26:51 -07:00
|
|
|
synchronize_irq(sc->irq);
|
2011-06-15 16:03:22 -06:00
|
|
|
ath5k_stop_tasklets(sc);
|
2010-07-13 09:32:41 -06:00
|
|
|
|
2011-03-30 19:57:33 -06:00
|
|
|
/* Save ani mode and disable ANI during
|
2010-12-02 21:07:13 -07:00
|
|
|
* reset. If we don't we might get false
|
|
|
|
* PHY error interrupts. */
|
|
|
|
ani_mode = ah->ah_sc->ani_state.ani_mode;
|
|
|
|
ath5k_ani_init(ah, ATH5K_ANI_MODE_OFF);
|
|
|
|
|
2010-12-02 21:05:19 -07:00
|
|
|
/* We are going to empty hw queues
|
|
|
|
* so we should also free any remaining
|
|
|
|
* tx buffers */
|
|
|
|
ath5k_drain_tx_buffs(sc);
|
2011-01-19 02:21:13 -07:00
|
|
|
if (chan)
|
2009-05-07 06:09:08 -06:00
|
|
|
sc->curchan = chan;
|
2011-06-01 18:09:48 -06:00
|
|
|
|
|
|
|
fast = ((chan != NULL) && modparam_fastchanswitch) ? 1 : 0;
|
|
|
|
|
|
|
|
ret = ath5k_hw_reset(ah, sc->opmode, sc->curchan, fast,
|
2010-11-23 12:39:28 -07:00
|
|
|
skip_pcu);
|
2008-07-23 05:17:35 -06:00
|
|
|
if (ret) {
|
2007-08-12 09:33:16 -06:00
|
|
|
ATH5K_ERR(sc, "can't reset hardware (%d)\n", ret);
|
|
|
|
goto err;
|
|
|
|
}
|
2008-07-23 05:17:35 -06:00
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
ret = ath5k_rx_start(sc);
|
2008-07-23 05:17:35 -06:00
|
|
|
if (ret) {
|
2007-08-12 09:33:16 -06:00
|
|
|
ATH5K_ERR(sc, "can't start recv logic\n");
|
|
|
|
goto err;
|
|
|
|
}
|
2008-07-23 05:17:35 -06:00
|
|
|
|
2010-12-02 21:07:13 -07:00
|
|
|
ath5k_ani_init(ah, ani_mode);
|
2010-04-02 03:44:08 -06:00
|
|
|
|
2010-05-18 19:30:55 -06:00
|
|
|
ah->ah_cal_next_full = jiffies;
|
|
|
|
ah->ah_cal_next_ani = jiffies;
|
2010-05-18 19:31:10 -06:00
|
|
|
ah->ah_cal_next_nf = jiffies;
|
2010-12-02 03:12:31 -07:00
|
|
|
ewma_init(&ah->ah_beacon_rssi_avg, 1024, 8);
|
2010-05-18 19:31:10 -06:00
|
|
|
|
2010-12-16 00:22:20 -07:00
|
|
|
/* clear survey data and cycle counters */
|
|
|
|
memset(&sc->survey, 0, sizeof(sc->survey));
|
2010-12-26 10:10:05 -07:00
|
|
|
spin_lock_bh(&common->cc_lock);
|
2010-12-16 00:22:20 -07:00
|
|
|
ath_hw_cycle_counters_update(common);
|
|
|
|
memset(&common->cc_survey, 0, sizeof(common->cc_survey));
|
|
|
|
memset(&common->cc_ani, 0, sizeof(common->cc_ani));
|
2010-12-26 10:10:05 -07:00
|
|
|
spin_unlock_bh(&common->cc_lock);
|
2010-12-16 00:22:20 -07:00
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
/*
|
2008-07-23 05:17:35 -06:00
|
|
|
* Change channels and update the h/w rate map if we're switching;
|
|
|
|
* e.g. 11a to 11b/g.
|
|
|
|
*
|
|
|
|
* We may be doing a reset in response to an ioctl that changes the
|
|
|
|
* channel so update any state that might change as a result.
|
2007-08-12 09:33:16 -06:00
|
|
|
*
|
|
|
|
* XXX needed?
|
|
|
|
*/
|
|
|
|
/* ath5k_chan_change(sc, c); */
|
|
|
|
|
2008-07-23 05:17:35 -06:00
|
|
|
ath5k_beacon_config(sc);
|
|
|
|
/* intrs are enabled by ath5k_beacon_config */
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-05-18 19:30:49 -06:00
|
|
|
ieee80211_wake_queues(sc->hw);
|
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
return 0;
|
|
|
|
err:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-07-13 09:32:40 -06:00
|
|
|
static void ath5k_reset_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = container_of(work, struct ath5k_softc,
|
|
|
|
reset_work);
|
|
|
|
|
|
|
|
mutex_lock(&sc->lock);
|
2010-11-23 12:39:28 -07:00
|
|
|
ath5k_reset(sc, NULL, true);
|
2010-07-13 09:32:40 -06:00
|
|
|
mutex_unlock(&sc->lock);
|
|
|
|
}
|
|
|
|
|
2011-07-07 16:13:42 -06:00
|
|
|
static int __devinit
|
2010-12-02 02:26:56 -07:00
|
|
|
ath5k_init(struct ieee80211_hw *hw)
|
2007-08-12 09:33:16 -06:00
|
|
|
{
|
2010-12-02 02:26:56 -07:00
|
|
|
|
2007-08-12 09:33:16 -06:00
|
|
|
struct ath5k_softc *sc = hw->priv;
|
2010-09-16 21:45:07 -06:00
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
struct ath_regulatory *regulatory = ath5k_hw_regulatory(ah);
|
2010-09-16 20:36:35 -06:00
|
|
|
struct ath5k_txq *txq;
|
2010-09-16 21:45:07 -06:00
|
|
|
u8 mac[ETH_ALEN] = {};
|
2007-08-12 09:33:16 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Check if the MAC has multi-rate retry support.
|
|
|
|
* We do this by trying to setup a fake extended
|
|
|
|
* descriptor. MACs that don't have support will
|
|
|
|
* return false w/o doing anything. MACs that do
|
|
|
|
* support it will return true w/o doing anything.
|
|
|
|
*/
|
|
|
|
ret = ath5k_hw_setup_mrr_tx_desc(ah, NULL, 0, 0, 0, 0, 0, 0);
|
2008-08-18 13:45:28 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
|
|
|
if (ret > 0)
|
|
|
|
__set_bit(ATH_STAT_MRRETRY, sc->status);
|
2010-03-09 00:55:38 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Collect the channel list. The 802.11 layer
|
|
|
|
* is resposible for filtering this list based
|
|
|
|
* on settings like the phy mode and regulatory
|
|
|
|
* domain restrictions.
|
|
|
|
*/
|
|
|
|
ret = ath5k_setup_bands(hw);
|
|
|
|
if (ret) {
|
|
|
|
ATH5K_ERR(sc, "can't get channels\n");
|
|
|
|
goto err;
|
|
|
|
}
|
2008-08-18 13:45:28 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Allocate tx+rx descriptors and populate the lists.
|
|
|
|
*/
|
2010-12-02 02:26:51 -07:00
|
|
|
ret = ath5k_desc_alloc(sc);
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ret) {
|
|
|
|
ATH5K_ERR(sc, "can't allocate descriptors\n");
|
|
|
|
goto err;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
/*
|
|
|
|
* Allocate hardware transmit queues: one queue for
|
|
|
|
* beacon frames and one data queue for each QoS
|
|
|
|
* priority. Note that hw functions handle resetting
|
|
|
|
* these queues at the needed time.
|
|
|
|
*/
|
|
|
|
ret = ath5k_beaconq_setup(ah);
|
|
|
|
if (ret < 0) {
|
|
|
|
ATH5K_ERR(sc, "can't setup a beacon xmit queue\n");
|
|
|
|
goto err_desc;
|
|
|
|
}
|
|
|
|
sc->bhalq = ret;
|
|
|
|
sc->cabq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_CAB, 0);
|
|
|
|
if (IS_ERR(sc->cabq)) {
|
|
|
|
ATH5K_ERR(sc, "can't setup cab queue\n");
|
|
|
|
ret = PTR_ERR(sc->cabq);
|
|
|
|
goto err_bhal;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-12-06 19:08:12 -07:00
|
|
|
/* 5211 and 5212 usually support 10 queues but we better rely on the
|
|
|
|
* capability information */
|
|
|
|
if (ah->ah_capabilities.cap_queues.q_tx_num >= 6) {
|
|
|
|
/* This order matches mac80211's queue priority, so we can
|
|
|
|
* directly use the mac80211 queue number without any mapping */
|
|
|
|
txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_VO);
|
|
|
|
if (IS_ERR(txq)) {
|
|
|
|
ATH5K_ERR(sc, "can't setup xmit queue\n");
|
|
|
|
ret = PTR_ERR(txq);
|
|
|
|
goto err_queues;
|
|
|
|
}
|
|
|
|
txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_VI);
|
|
|
|
if (IS_ERR(txq)) {
|
|
|
|
ATH5K_ERR(sc, "can't setup xmit queue\n");
|
|
|
|
ret = PTR_ERR(txq);
|
|
|
|
goto err_queues;
|
|
|
|
}
|
|
|
|
txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BE);
|
|
|
|
if (IS_ERR(txq)) {
|
|
|
|
ATH5K_ERR(sc, "can't setup xmit queue\n");
|
|
|
|
ret = PTR_ERR(txq);
|
|
|
|
goto err_queues;
|
|
|
|
}
|
|
|
|
txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BK);
|
|
|
|
if (IS_ERR(txq)) {
|
|
|
|
ATH5K_ERR(sc, "can't setup xmit queue\n");
|
|
|
|
ret = PTR_ERR(txq);
|
|
|
|
goto err_queues;
|
|
|
|
}
|
|
|
|
hw->queues = 4;
|
|
|
|
} else {
|
|
|
|
/* older hardware (5210) can only support one data queue */
|
|
|
|
txq = ath5k_txq_setup(sc, AR5K_TX_QUEUE_DATA, AR5K_WME_AC_BE);
|
|
|
|
if (IS_ERR(txq)) {
|
|
|
|
ATH5K_ERR(sc, "can't setup xmit queue\n");
|
|
|
|
ret = PTR_ERR(txq);
|
|
|
|
goto err_queues;
|
|
|
|
}
|
|
|
|
hw->queues = 1;
|
|
|
|
}
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
tasklet_init(&sc->rxtq, ath5k_tasklet_rx, (unsigned long)sc);
|
|
|
|
tasklet_init(&sc->txtq, ath5k_tasklet_tx, (unsigned long)sc);
|
|
|
|
tasklet_init(&sc->calib, ath5k_tasklet_calibrate, (unsigned long)sc);
|
|
|
|
tasklet_init(&sc->beacontq, ath5k_tasklet_beacon, (unsigned long)sc);
|
|
|
|
tasklet_init(&sc->ani_tasklet, ath5k_tasklet_ani, (unsigned long)sc);
|
2009-01-22 06:44:16 -07:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
INIT_WORK(&sc->reset_work, ath5k_reset_work);
|
2010-09-16 20:36:56 -06:00
|
|
|
INIT_DELAYED_WORK(&sc->tx_complete_work, ath5k_tx_complete_poll_work);
|
2007-08-12 09:33:16 -06:00
|
|
|
|
2011-04-13 13:56:44 -06:00
|
|
|
ret = ath5k_hw_common(ah)->bus_ops->eeprom_read_mac(ah, mac);
|
2010-09-16 21:45:07 -06:00
|
|
|
if (ret) {
|
2010-12-02 02:26:51 -07:00
|
|
|
ATH5K_ERR(sc, "unable to read address from EEPROM\n");
|
2010-09-16 21:45:07 -06:00
|
|
|
goto err_queues;
|
2009-08-04 17:52:07 -06:00
|
|
|
}
|
2009-04-30 13:55:49 -06:00
|
|
|
|
2010-09-16 21:45:07 -06:00
|
|
|
SET_IEEE80211_PERM_ADDR(hw, mac);
|
2010-09-30 13:22:58 -06:00
|
|
|
memcpy(&sc->lladdr, mac, ETH_ALEN);
|
2010-09-16 21:45:07 -06:00
|
|
|
/* All MAC address bits matter for ACKs */
|
2010-10-08 13:01:15 -06:00
|
|
|
ath5k_update_bssid_mask_and_opmode(sc, NULL);
|
2010-09-16 21:45:07 -06:00
|
|
|
|
|
|
|
regulatory->current_rd = ah->ah_capabilities.cap_eeprom.ee_regdomain;
|
|
|
|
ret = ath_regd_init(regulatory, hw->wiphy, ath5k_reg_notifier);
|
|
|
|
if (ret) {
|
|
|
|
ATH5K_ERR(sc, "can't initialize regulatory system\n");
|
|
|
|
goto err_queues;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ieee80211_register_hw(hw);
|
|
|
|
if (ret) {
|
|
|
|
ATH5K_ERR(sc, "can't register ieee80211 hw\n");
|
|
|
|
goto err_queues;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ath_is_world_regd(regulatory))
|
|
|
|
regulatory_hint(hw->wiphy, regulatory->alpha2);
|
|
|
|
|
|
|
|
ath5k_init_leds(sc);
|
|
|
|
|
|
|
|
ath5k_sysfs_register(sc);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err_queues:
|
|
|
|
ath5k_txq_release(sc);
|
|
|
|
err_bhal:
|
|
|
|
ath5k_hw_release_tx_queue(ah, sc->bhalq);
|
|
|
|
err_desc:
|
2010-12-02 02:26:51 -07:00
|
|
|
ath5k_desc_free(sc);
|
2010-09-16 21:45:07 -06:00
|
|
|
err:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-12-02 02:26:56 -07:00
|
|
|
void
|
|
|
|
ath5k_deinit_softc(struct ath5k_softc *sc)
|
2010-09-16 21:45:07 -06:00
|
|
|
{
|
2010-12-02 02:26:56 -07:00
|
|
|
struct ieee80211_hw *hw = sc->hw;
|
2010-09-16 21:45:07 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* NB: the order of these is important:
|
|
|
|
* o call the 802.11 layer before detaching ath5k_hw to
|
|
|
|
* ensure callbacks into the driver to delete global
|
|
|
|
* key cache entries can be handled
|
|
|
|
* o reclaim the tx queue data structures after calling
|
|
|
|
* the 802.11 layer as we'll get called back to reclaim
|
|
|
|
* node state and potentially want to use them
|
|
|
|
* o to cleanup the tx queues the hal is called, so detach
|
|
|
|
* it last
|
|
|
|
* XXX: ??? detach ath5k_hw ???
|
|
|
|
* Other than that, it's straightforward...
|
|
|
|
*/
|
|
|
|
ieee80211_unregister_hw(hw);
|
2010-12-02 02:26:51 -07:00
|
|
|
ath5k_desc_free(sc);
|
2010-09-16 21:45:07 -06:00
|
|
|
ath5k_txq_release(sc);
|
|
|
|
ath5k_hw_release_tx_queue(sc->ah, sc->bhalq);
|
|
|
|
ath5k_unregister_leds(sc);
|
|
|
|
|
|
|
|
ath5k_sysfs_unregister(sc);
|
|
|
|
/*
|
|
|
|
* NB: can't reclaim these until after ieee80211_ifdetach
|
|
|
|
* returns because we'll get called back to reclaim node
|
|
|
|
* state and potentially want to use them.
|
|
|
|
*/
|
2010-12-02 02:26:56 -07:00
|
|
|
ath5k_hw_deinit(sc->ah);
|
2011-06-17 14:41:30 -06:00
|
|
|
kfree(sc->ah);
|
2010-12-02 02:26:56 -07:00
|
|
|
free_irq(sc->irq, sc);
|
2010-09-16 21:45:07 -06:00
|
|
|
}
|
|
|
|
|
2010-12-22 03:20:32 -07:00
|
|
|
bool
|
2011-06-15 16:03:22 -06:00
|
|
|
ath5k_any_vif_assoc(struct ath5k_softc *sc)
|
2010-09-30 13:22:58 -06:00
|
|
|
{
|
2011-03-03 15:39:05 -07:00
|
|
|
struct ath5k_vif_iter_data iter_data;
|
2010-09-30 13:22:58 -06:00
|
|
|
iter_data.hw_macaddr = NULL;
|
|
|
|
iter_data.any_assoc = false;
|
|
|
|
iter_data.need_set_hw_addr = false;
|
|
|
|
iter_data.found_active = true;
|
|
|
|
|
2011-03-03 15:39:05 -07:00
|
|
|
ieee80211_iterate_active_interfaces_atomic(sc->hw, ath5k_vif_iter,
|
2010-09-30 13:22:58 -06:00
|
|
|
&iter_data);
|
|
|
|
return iter_data.any_assoc;
|
|
|
|
}
|
|
|
|
|
2010-12-22 03:20:32 -07:00
|
|
|
void
|
2011-06-15 16:03:22 -06:00
|
|
|
ath5k_set_beacon_filter(struct ieee80211_hw *hw, bool enable)
|
2010-09-16 21:45:07 -06:00
|
|
|
{
|
|
|
|
struct ath5k_softc *sc = hw->priv;
|
|
|
|
struct ath5k_hw *ah = sc->ah;
|
|
|
|
u32 rfilt;
|
|
|
|
rfilt = ath5k_hw_get_rx_filter(ah);
|
|
|
|
if (enable)
|
|
|
|
rfilt |= AR5K_RX_FILTER_BEACON;
|
|
|
|
else
|
|
|
|
rfilt &= ~AR5K_RX_FILTER_BEACON;
|
|
|
|
ath5k_hw_set_rx_filter(ah, rfilt);
|
|
|
|
sc->filter_flags = rfilt;
|
|
|
|
}
|