2007-09-26 00:54:57 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
2010-01-15 21:43:41 +00:00
|
|
|
* Copyright(c) 2003 - 2010 Intel Corporation. All rights reserved.
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of version 2 of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
|
|
|
|
*
|
|
|
|
* The full GNU General Public License is included in this distribution in the
|
|
|
|
* file called LICENSE.
|
|
|
|
*
|
|
|
|
* Contact Information:
|
2008-12-09 19:28:58 +00:00
|
|
|
* Intel Linux Wireless <ilw@linux.intel.com>
|
2007-09-26 00:54:57 +00:00
|
|
|
* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2007-09-26 00:54:57 +00:00
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/delay.h>
|
2009-10-07 13:09:06 +00:00
|
|
|
#include <linux/sched.h>
|
2007-09-26 00:54:57 +00:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/wireless.h>
|
|
|
|
#include <linux/firmware.h>
|
|
|
|
#include <linux/etherdevice.h>
|
2007-12-20 03:27:32 +00:00
|
|
|
#include <asm/unaligned.h>
|
|
|
|
#include <net/mac80211.h>
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-12-22 03:31:14 +00:00
|
|
|
#include "iwl-fh.h"
|
2008-12-19 02:37:01 +00:00
|
|
|
#include "iwl-3945-fh.h"
|
2008-12-19 02:37:04 +00:00
|
|
|
#include "iwl-commands.h"
|
2009-01-23 21:45:20 +00:00
|
|
|
#include "iwl-sta.h"
|
2007-09-26 00:54:57 +00:00
|
|
|
#include "iwl-3945.h"
|
2009-01-23 21:45:15 +00:00
|
|
|
#include "iwl-eeprom.h"
|
2008-12-19 02:37:18 +00:00
|
|
|
#include "iwl-core.h"
|
2010-02-19 06:03:02 +00:00
|
|
|
#include "iwl-helpers.h"
|
2009-10-02 20:44:03 +00:00
|
|
|
#include "iwl-led.h"
|
|
|
|
#include "iwl-3945-led.h"
|
2010-04-16 17:03:54 +00:00
|
|
|
#include "iwl-3945-debugfs.h"
|
2010-11-10 17:56:39 +00:00
|
|
|
#include "iwl-legacy.h"
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
#define IWL_DECLARE_RATE_INFO(r, ip, in, rp, rn, pp, np) \
|
|
|
|
[IWL_RATE_##r##M_INDEX] = { IWL_RATE_##r##M_PLCP, \
|
|
|
|
IWL_RATE_##r##M_IEEE, \
|
|
|
|
IWL_RATE_##ip##M_INDEX, \
|
|
|
|
IWL_RATE_##in##M_INDEX, \
|
|
|
|
IWL_RATE_##rp##M_INDEX, \
|
|
|
|
IWL_RATE_##rn##M_INDEX, \
|
|
|
|
IWL_RATE_##pp##M_INDEX, \
|
2007-11-12 03:37:42 +00:00
|
|
|
IWL_RATE_##np##M_INDEX, \
|
|
|
|
IWL_RATE_##r##M_INDEX_TABLE, \
|
|
|
|
IWL_RATE_##ip##M_INDEX_TABLE }
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Parameter order:
|
|
|
|
* rate, prev rate, next rate, prev tgg rate, next tgg rate
|
|
|
|
*
|
|
|
|
* If there isn't a valid next or previous rate then INV is used which
|
|
|
|
* maps to IWL_RATE_INVALID
|
|
|
|
*
|
|
|
|
*/
|
2008-12-19 02:37:12 +00:00
|
|
|
const struct iwl3945_rate_info iwl3945_rates[IWL_RATE_COUNT_3945] = {
|
2007-11-12 03:37:42 +00:00
|
|
|
IWL_DECLARE_RATE_INFO(1, INV, 2, INV, 2, INV, 2), /* 1mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(2, 1, 5, 1, 5, 1, 5), /* 2mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(5, 2, 6, 2, 11, 2, 11), /*5.5mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(11, 9, 12, 5, 12, 5, 18), /* 11mbps */
|
2007-09-26 00:54:57 +00:00
|
|
|
IWL_DECLARE_RATE_INFO(6, 5, 9, 5, 11, 5, 11), /* 6mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(9, 6, 11, 5, 11, 5, 11), /* 9mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(12, 11, 18, 11, 18, 11, 18), /* 12mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(18, 12, 24, 12, 24, 11, 24), /* 18mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(24, 18, 36, 18, 36, 18, 36), /* 24mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(36, 24, 48, 24, 48, 24, 48), /* 36mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(48, 36, 54, 36, 54, 36, 54), /* 48mbps */
|
|
|
|
IWL_DECLARE_RATE_INFO(54, 48, INV, 48, INV, 48, INV),/* 54mbps */
|
|
|
|
};
|
|
|
|
|
2010-09-22 16:02:04 +00:00
|
|
|
static inline u8 iwl3945_get_prev_ieee_rate(u8 rate_index)
|
|
|
|
{
|
|
|
|
u8 rate = iwl3945_rates[rate_index].prev_ieee;
|
|
|
|
|
|
|
|
if (rate == IWL_RATE_INVALID)
|
|
|
|
rate = rate_index;
|
|
|
|
return rate;
|
|
|
|
}
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
/* 1 = enable the iwl3945_disable_events() function */
|
2007-09-26 00:54:57 +00:00
|
|
|
#define IWL_EVT_DISABLE (0)
|
|
|
|
#define IWL_EVT_DISABLE_SIZE (1532/32)
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_disable_events - Disable selected events in uCode event log
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Disable an event by writing "1"s into "disable"
|
|
|
|
* bitmap in SRAM. Bit position corresponds to Event # (id/type).
|
|
|
|
* Default values of 0 enable uCode events to be logged.
|
|
|
|
* Use for only special debugging. This function is just a placeholder as-is,
|
|
|
|
* you'll need to provide the special bits! ...
|
|
|
|
* ... and set IWL_EVT_DISABLE to 1. */
|
2008-12-19 02:37:28 +00:00
|
|
|
void iwl3945_disable_events(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
u32 base; /* SRAM address of event log header */
|
|
|
|
u32 disable_ptr; /* SRAM address of event-disable bitmap array */
|
|
|
|
u32 array_size; /* # of u32 entries in array */
|
|
|
|
u32 evt_disable[IWL_EVT_DISABLE_SIZE] = {
|
|
|
|
0x00000000, /* 31 - 0 Event id numbers */
|
|
|
|
0x00000000, /* 63 - 32 */
|
|
|
|
0x00000000, /* 95 - 64 */
|
|
|
|
0x00000000, /* 127 - 96 */
|
|
|
|
0x00000000, /* 159 - 128 */
|
|
|
|
0x00000000, /* 191 - 160 */
|
|
|
|
0x00000000, /* 223 - 192 */
|
|
|
|
0x00000000, /* 255 - 224 */
|
|
|
|
0x00000000, /* 287 - 256 */
|
|
|
|
0x00000000, /* 319 - 288 */
|
|
|
|
0x00000000, /* 351 - 320 */
|
|
|
|
0x00000000, /* 383 - 352 */
|
|
|
|
0x00000000, /* 415 - 384 */
|
|
|
|
0x00000000, /* 447 - 416 */
|
|
|
|
0x00000000, /* 479 - 448 */
|
|
|
|
0x00000000, /* 511 - 480 */
|
|
|
|
0x00000000, /* 543 - 512 */
|
|
|
|
0x00000000, /* 575 - 544 */
|
|
|
|
0x00000000, /* 607 - 576 */
|
|
|
|
0x00000000, /* 639 - 608 */
|
|
|
|
0x00000000, /* 671 - 640 */
|
|
|
|
0x00000000, /* 703 - 672 */
|
|
|
|
0x00000000, /* 735 - 704 */
|
|
|
|
0x00000000, /* 767 - 736 */
|
|
|
|
0x00000000, /* 799 - 768 */
|
|
|
|
0x00000000, /* 831 - 800 */
|
|
|
|
0x00000000, /* 863 - 832 */
|
|
|
|
0x00000000, /* 895 - 864 */
|
|
|
|
0x00000000, /* 927 - 896 */
|
|
|
|
0x00000000, /* 959 - 928 */
|
|
|
|
0x00000000, /* 991 - 960 */
|
|
|
|
0x00000000, /* 1023 - 992 */
|
|
|
|
0x00000000, /* 1055 - 1024 */
|
|
|
|
0x00000000, /* 1087 - 1056 */
|
|
|
|
0x00000000, /* 1119 - 1088 */
|
|
|
|
0x00000000, /* 1151 - 1120 */
|
|
|
|
0x00000000, /* 1183 - 1152 */
|
|
|
|
0x00000000, /* 1215 - 1184 */
|
|
|
|
0x00000000, /* 1247 - 1216 */
|
|
|
|
0x00000000, /* 1279 - 1248 */
|
|
|
|
0x00000000, /* 1311 - 1280 */
|
|
|
|
0x00000000, /* 1343 - 1312 */
|
|
|
|
0x00000000, /* 1375 - 1344 */
|
|
|
|
0x00000000, /* 1407 - 1376 */
|
|
|
|
0x00000000, /* 1439 - 1408 */
|
|
|
|
0x00000000, /* 1471 - 1440 */
|
|
|
|
0x00000000, /* 1503 - 1472 */
|
|
|
|
};
|
|
|
|
|
|
|
|
base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
|
2008-01-28 00:41:47 +00:00
|
|
|
if (!iwl3945_hw_valid_rtc_data_addr(base)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
disable_ptr = iwl_read_targ_mem(priv, base + (4 * sizeof(u32)));
|
|
|
|
array_size = iwl_read_targ_mem(priv, base + (5 * sizeof(u32)));
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (IWL_EVT_DISABLE && (array_size == IWL_EVT_DISABLE_SIZE)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Disabling selected uCode log events at 0x%x\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
disable_ptr);
|
|
|
|
for (i = 0; i < IWL_EVT_DISABLE_SIZE; i++)
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_targ_mem(priv,
|
2007-10-25 09:15:36 +00:00
|
|
|
disable_ptr + (i * sizeof(u32)),
|
|
|
|
evt_disable[i]);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
} else {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Selected uCode log events may be disabled\n");
|
|
|
|
IWL_DEBUG_INFO(priv, " by writing \"1\"s into disable bitmap\n");
|
|
|
|
IWL_DEBUG_INFO(priv, " in SRAM at 0x%x, size %d u32s\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
disable_ptr, array_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-03-01 23:52:00 +00:00
|
|
|
static int iwl3945_hwrate_to_plcp_idx(u8 plcp)
|
|
|
|
{
|
|
|
|
int idx;
|
|
|
|
|
2010-02-26 19:01:36 +00:00
|
|
|
for (idx = 0; idx < IWL_RATE_COUNT_3945; idx++)
|
2008-03-01 23:52:00 +00:00
|
|
|
if (iwl3945_rates[idx].plcp == plcp)
|
|
|
|
return idx;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-01-23 21:45:17 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2010-04-01 00:57:28 +00:00
|
|
|
#define TX_STATUS_ENTRY(x) case TX_3945_STATUS_FAIL_ ## x: return #x
|
2008-03-07 01:36:55 +00:00
|
|
|
|
|
|
|
static const char *iwl3945_get_tx_fail_reason(u32 status)
|
|
|
|
{
|
|
|
|
switch (status & TX_STATUS_MSK) {
|
2010-04-01 00:57:28 +00:00
|
|
|
case TX_3945_STATUS_SUCCESS:
|
2008-03-07 01:36:55 +00:00
|
|
|
return "SUCCESS";
|
|
|
|
TX_STATUS_ENTRY(SHORT_LIMIT);
|
|
|
|
TX_STATUS_ENTRY(LONG_LIMIT);
|
|
|
|
TX_STATUS_ENTRY(FIFO_UNDERRUN);
|
|
|
|
TX_STATUS_ENTRY(MGMNT_ABORT);
|
|
|
|
TX_STATUS_ENTRY(NEXT_FRAG);
|
|
|
|
TX_STATUS_ENTRY(LIFE_EXPIRE);
|
|
|
|
TX_STATUS_ENTRY(DEST_PS);
|
|
|
|
TX_STATUS_ENTRY(ABORTED);
|
|
|
|
TX_STATUS_ENTRY(BT_RETRY);
|
|
|
|
TX_STATUS_ENTRY(STA_INVALID);
|
|
|
|
TX_STATUS_ENTRY(FRAG_DROPPED);
|
|
|
|
TX_STATUS_ENTRY(TID_DISABLE);
|
|
|
|
TX_STATUS_ENTRY(FRAME_FLUSHED);
|
|
|
|
TX_STATUS_ENTRY(INSUFFICIENT_CF_POLL);
|
|
|
|
TX_STATUS_ENTRY(TX_LOCKED);
|
|
|
|
TX_STATUS_ENTRY(NO_BEACON_ON_RADAR);
|
|
|
|
}
|
|
|
|
|
|
|
|
return "UNKNOWN";
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline const char *iwl3945_get_tx_fail_reason(u32 status)
|
|
|
|
{
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-10-21 10:40:02 +00:00
|
|
|
/*
|
|
|
|
* get ieee prev rate from rate scale table.
|
|
|
|
* for A and B mode we need to overright prev
|
|
|
|
* value
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
int iwl3945_rs_next_rate(struct iwl_priv *priv, int rate)
|
2008-10-21 10:40:02 +00:00
|
|
|
{
|
|
|
|
int next_rate = iwl3945_get_prev_ieee_rate(rate);
|
|
|
|
|
|
|
|
switch (priv->band) {
|
|
|
|
case IEEE80211_BAND_5GHZ:
|
|
|
|
if (rate == IWL_RATE_12M_INDEX)
|
|
|
|
next_rate = IWL_RATE_9M_INDEX;
|
|
|
|
else if (rate == IWL_RATE_6M_INDEX)
|
|
|
|
next_rate = IWL_RATE_6M_INDEX;
|
|
|
|
break;
|
2008-12-05 15:58:37 +00:00
|
|
|
case IEEE80211_BAND_2GHZ:
|
2010-01-21 14:09:28 +00:00
|
|
|
if (!(priv->_3945.sta_supp_rates & IWL_OFDM_RATES_MASK) &&
|
2010-08-23 08:46:32 +00:00
|
|
|
iwl_is_associated(priv, IWL_RXON_CTX_BSS)) {
|
2008-12-05 15:58:37 +00:00
|
|
|
if (rate == IWL_RATE_11M_INDEX)
|
|
|
|
next_rate = IWL_RATE_5M_INDEX;
|
|
|
|
}
|
2008-10-21 10:40:02 +00:00
|
|
|
break;
|
2008-12-05 15:58:37 +00:00
|
|
|
|
2008-10-21 10:40:02 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return next_rate;
|
|
|
|
}
|
|
|
|
|
2008-03-07 01:36:55 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl3945_tx_queue_reclaim - Reclaim Tx queue entries already Tx'd
|
|
|
|
*
|
|
|
|
* When FW advances 'R' index, all entries between old and new 'R' index
|
|
|
|
* need to be reclaimed. As result, some free space forms. If there is
|
|
|
|
* enough free space (> low mark), wake the stack that feeds us.
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static void iwl3945_tx_queue_reclaim(struct iwl_priv *priv,
|
2008-03-07 01:36:55 +00:00
|
|
|
int txq_id, int index)
|
|
|
|
{
|
2008-12-22 03:31:16 +00:00
|
|
|
struct iwl_tx_queue *txq = &priv->txq[txq_id];
|
2008-12-19 02:37:15 +00:00
|
|
|
struct iwl_queue *q = &txq->q;
|
2008-12-22 03:31:14 +00:00
|
|
|
struct iwl_tx_info *tx_info;
|
2008-03-07 01:36:55 +00:00
|
|
|
|
2010-08-23 08:46:33 +00:00
|
|
|
BUG_ON(txq_id == IWL39_CMD_QUEUE_NUM);
|
2008-03-07 01:36:55 +00:00
|
|
|
|
|
|
|
for (index = iwl_queue_inc_wrap(index, q->n_bd); q->read_ptr != index;
|
|
|
|
q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd)) {
|
|
|
|
|
|
|
|
tx_info = &txq->txb[txq->q.read_ptr];
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
ieee80211_tx_status_irqsafe(priv->hw, tx_info->skb);
|
|
|
|
tx_info->skb = NULL;
|
2009-01-19 23:30:26 +00:00
|
|
|
priv->cfg->ops->lib->txq_free_tfd(priv, txq);
|
2008-03-07 01:36:55 +00:00
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:15 +00:00
|
|
|
if (iwl_queue_space(q) > q->low_mark && (txq_id >= 0) &&
|
2010-08-23 08:46:33 +00:00
|
|
|
(txq_id != IWL39_CMD_QUEUE_NUM) &&
|
2008-03-07 01:36:55 +00:00
|
|
|
priv->mac80211_registered)
|
2009-03-23 16:28:42 +00:00
|
|
|
iwl_wake_queue(priv, txq_id);
|
2008-03-07 01:36:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl3945_rx_reply_tx - Handle Tx response
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static void iwl3945_rx_reply_tx(struct iwl_priv *priv,
|
2010-04-16 17:03:54 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2008-03-07 01:36:55 +00:00
|
|
|
{
|
2009-10-09 09:19:45 +00:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-03-07 01:36:55 +00:00
|
|
|
u16 sequence = le16_to_cpu(pkt->hdr.sequence);
|
|
|
|
int txq_id = SEQ_TO_QUEUE(sequence);
|
|
|
|
int index = SEQ_TO_INDEX(sequence);
|
2008-12-22 03:31:16 +00:00
|
|
|
struct iwl_tx_queue *txq = &priv->txq[txq_id];
|
2008-05-15 10:55:29 +00:00
|
|
|
struct ieee80211_tx_info *info;
|
2008-03-07 01:36:55 +00:00
|
|
|
struct iwl3945_tx_resp *tx_resp = (void *)&pkt->u.raw[0];
|
|
|
|
u32 status = le32_to_cpu(tx_resp->status);
|
|
|
|
int rate_idx;
|
2008-12-02 20:14:03 +00:00
|
|
|
int fail;
|
2008-03-07 01:36:55 +00:00
|
|
|
|
2009-01-08 18:19:55 +00:00
|
|
|
if ((index >= txq->q.n_bd) || (iwl_queue_used(&txq->q, index) == 0)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Read index for DMA queue txq_id (%d) index %d "
|
2008-03-07 01:36:55 +00:00
|
|
|
"is out of range [0-%d] %d %d\n", txq_id,
|
|
|
|
index, txq->q.n_bd, txq->q.write_ptr,
|
|
|
|
txq->q.read_ptr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
info = IEEE80211_SKB_CB(txq->txb[txq->q.read_ptr].skb);
|
2008-10-21 10:40:02 +00:00
|
|
|
ieee80211_tx_info_clear_status(info);
|
|
|
|
|
|
|
|
/* Fill the MRR chain with some info about on-chip retransmissions */
|
|
|
|
rate_idx = iwl3945_hwrate_to_plcp_idx(tx_resp->rate);
|
|
|
|
if (info->band == IEEE80211_BAND_5GHZ)
|
|
|
|
rate_idx -= IWL_FIRST_OFDM_RATE;
|
|
|
|
|
|
|
|
fail = tx_resp->failure_frame;
|
2008-12-02 20:14:03 +00:00
|
|
|
|
|
|
|
info->status.rates[0].idx = rate_idx;
|
|
|
|
info->status.rates[0].count = fail + 1; /* add final attempt */
|
2008-03-07 01:36:55 +00:00
|
|
|
|
|
|
|
/* tx_status->rts_retry_count = tx_resp->failure_rts; */
|
2008-05-15 10:55:29 +00:00
|
|
|
info->flags |= ((status & TX_STATUS_MSK) == TX_STATUS_SUCCESS) ?
|
|
|
|
IEEE80211_TX_STAT_ACK : 0;
|
2008-03-07 01:36:55 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_TX(priv, "Tx queue %d Status %s (0x%08x) plcp rate %d retries %d\n",
|
2008-03-07 01:36:55 +00:00
|
|
|
txq_id, iwl3945_get_tx_fail_reason(status), status,
|
|
|
|
tx_resp->rate, tx_resp->failure_frame);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_TX_REPLY(priv, "Tx queue reclaim %d\n", index);
|
2008-03-07 01:36:55 +00:00
|
|
|
iwl3945_tx_queue_reclaim(priv, txq_id, index);
|
|
|
|
|
2010-09-22 16:02:12 +00:00
|
|
|
if (status & TX_ABORT_REQUIRED_MSK)
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "TODO: Implement Tx ABORT REQUIRED!!!\n");
|
2008-03-07 01:36:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* Intel PRO/Wireless 3945ABG/BG Network Connection
|
|
|
|
*
|
|
|
|
* RX handler implementations
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
2010-05-06 19:18:41 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUGFS
|
2010-04-16 17:03:54 +00:00
|
|
|
/*
|
|
|
|
* based on the assumption of all statistics counter are in DWORD
|
|
|
|
* FIXME: This function is for debugging, do not deal with
|
|
|
|
* the case of counters roll-over.
|
|
|
|
*/
|
|
|
|
static void iwl3945_accumulative_statistics(struct iwl_priv *priv,
|
|
|
|
__le32 *stats)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
__le32 *prev_stats;
|
|
|
|
u32 *accum_stats;
|
|
|
|
u32 *delta, *max_delta;
|
|
|
|
|
|
|
|
prev_stats = (__le32 *)&priv->_3945.statistics;
|
|
|
|
accum_stats = (u32 *)&priv->_3945.accum_statistics;
|
|
|
|
delta = (u32 *)&priv->_3945.delta_statistics;
|
|
|
|
max_delta = (u32 *)&priv->_3945.max_delta;
|
|
|
|
|
|
|
|
for (i = sizeof(__le32); i < sizeof(struct iwl3945_notif_statistics);
|
|
|
|
i += sizeof(__le32), stats++, prev_stats++, delta++,
|
|
|
|
max_delta++, accum_stats++) {
|
|
|
|
if (le32_to_cpu(*stats) > le32_to_cpu(*prev_stats)) {
|
|
|
|
*delta = (le32_to_cpu(*stats) -
|
|
|
|
le32_to_cpu(*prev_stats));
|
|
|
|
*accum_stats += *delta;
|
|
|
|
if (*delta > *max_delta)
|
|
|
|
*max_delta = *delta;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* reset accumulative statistics for "no-counter" type statistics */
|
|
|
|
priv->_3945.accum_statistics.general.temperature =
|
|
|
|
priv->_3945.statistics.general.temperature;
|
|
|
|
priv->_3945.accum_statistics.general.ttl_timestamp =
|
|
|
|
priv->_3945.statistics.general.ttl_timestamp;
|
|
|
|
}
|
|
|
|
#endif
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-04-28 22:47:04 +00:00
|
|
|
/**
|
|
|
|
* iwl3945_good_plcp_health - checks for plcp error.
|
|
|
|
*
|
|
|
|
* When the plcp error is exceeding the thresholds, reset the radio
|
|
|
|
* to improve the throughput.
|
|
|
|
*/
|
|
|
|
static bool iwl3945_good_plcp_health(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_packet *pkt)
|
|
|
|
{
|
|
|
|
bool rc = true;
|
|
|
|
struct iwl3945_notif_statistics current_stat;
|
|
|
|
int combined_plcp_delta;
|
|
|
|
unsigned int plcp_msec;
|
|
|
|
unsigned long plcp_received_jiffies;
|
|
|
|
|
2010-10-06 15:10:00 +00:00
|
|
|
if (priv->cfg->base_params->plcp_delta_threshold ==
|
2010-06-17 22:25:00 +00:00
|
|
|
IWL_MAX_PLCP_ERR_THRESHOLD_DISABLE) {
|
|
|
|
IWL_DEBUG_RADIO(priv, "plcp_err check disabled\n");
|
|
|
|
return rc;
|
|
|
|
}
|
2010-04-28 22:47:04 +00:00
|
|
|
memcpy(¤t_stat, pkt->u.raw, sizeof(struct
|
|
|
|
iwl3945_notif_statistics));
|
|
|
|
/*
|
|
|
|
* check for plcp_err and trigger radio reset if it exceeds
|
|
|
|
* the plcp error threshold plcp_delta.
|
|
|
|
*/
|
|
|
|
plcp_received_jiffies = jiffies;
|
|
|
|
plcp_msec = jiffies_to_msecs((long) plcp_received_jiffies -
|
|
|
|
(long) priv->plcp_jiffies);
|
|
|
|
priv->plcp_jiffies = plcp_received_jiffies;
|
|
|
|
/*
|
|
|
|
* check to make sure plcp_msec is not 0 to prevent division
|
|
|
|
* by zero.
|
|
|
|
*/
|
|
|
|
if (plcp_msec) {
|
|
|
|
combined_plcp_delta =
|
|
|
|
(le32_to_cpu(current_stat.rx.ofdm.plcp_err) -
|
|
|
|
le32_to_cpu(priv->_3945.statistics.rx.ofdm.plcp_err));
|
|
|
|
|
|
|
|
if ((combined_plcp_delta > 0) &&
|
|
|
|
((combined_plcp_delta * 100) / plcp_msec) >
|
2010-10-06 15:10:00 +00:00
|
|
|
priv->cfg->base_params->plcp_delta_threshold) {
|
2010-04-28 22:47:04 +00:00
|
|
|
/*
|
|
|
|
* if plcp_err exceed the threshold, the following
|
|
|
|
* data is printed in csv format:
|
|
|
|
* Text: plcp_err exceeded %d,
|
|
|
|
* Received ofdm.plcp_err,
|
|
|
|
* Current ofdm.plcp_err,
|
|
|
|
* combined_plcp_delta,
|
|
|
|
* plcp_msec
|
|
|
|
*/
|
|
|
|
IWL_DEBUG_RADIO(priv, "plcp_err exceeded %u, "
|
|
|
|
"%u, %d, %u mSecs\n",
|
2010-10-06 15:10:00 +00:00
|
|
|
priv->cfg->base_params->plcp_delta_threshold,
|
2010-04-28 22:47:04 +00:00
|
|
|
le32_to_cpu(current_stat.rx.ofdm.plcp_err),
|
|
|
|
combined_plcp_delta, plcp_msec);
|
|
|
|
/*
|
|
|
|
* Reset the RF radio due to the high plcp
|
|
|
|
* error rate
|
|
|
|
*/
|
|
|
|
rc = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
iwlwifi: fix erroneous use of iwl_rx_packet.len as a length
The field called 'len' in struct iwl_rx_packet is in fact not just a length
field but also includes some flags from the flow handler. In several places
throughout the driver, this causes incorrect values to be interpreted as
lengths when the field is improperly masked.
In most situations the improper use is for debugging output, and simply results
in an erroneous message, such as:
[551933.070224] ieee80211 phy0: I iwl_rx_statistics Statistics notification received (480 vs -1367342620).
which should read '(480 vs 484)'.
In at least one case this could case bad things to happen:
void iwl_rx_pm_debug_statistics_notif(struct iwl_priv *priv,
struct iwl_rx_mem_buffer *rxb)
{
struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
IWL_DEBUG_RADIO(priv, "Dumping %d bytes of unhandled "
"notification for %s:\n",
le32_to_cpu(pkt->len), get_cmd_string(pkt->hdr.cmd));
iwl_print_hex_dump(priv, IWL_DL_RADIO, pkt->u.raw, le32_to_cpu(pkt->len)
);
}
EXPORT_SYMBOL(iwl_rx_pm_debug_statistics_notif);
Given the rampant misuse of this field without proper masking throughout the
driver (every use but one), this patch renames the field from 'len' to
'len_n_flags' to reduce confusion. It also adds the proper masking when
this field is used as a length value.
Signed-off-by: Daniel C Halperin <daniel.c.halperin@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-08-13 20:31:01 +00:00
|
|
|
void iwl3945_hw_rx_statistics(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-10-09 09:19:45 +00:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2010-04-16 17:03:54 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv, "Statistics notification received (%d vs %d).\n",
|
2008-01-28 00:41:47 +00:00
|
|
|
(int)sizeof(struct iwl3945_notif_statistics),
|
iwlwifi: fix erroneous use of iwl_rx_packet.len as a length
The field called 'len' in struct iwl_rx_packet is in fact not just a length
field but also includes some flags from the flow handler. In several places
throughout the driver, this causes incorrect values to be interpreted as
lengths when the field is improperly masked.
In most situations the improper use is for debugging output, and simply results
in an erroneous message, such as:
[551933.070224] ieee80211 phy0: I iwl_rx_statistics Statistics notification received (480 vs -1367342620).
which should read '(480 vs 484)'.
In at least one case this could case bad things to happen:
void iwl_rx_pm_debug_statistics_notif(struct iwl_priv *priv,
struct iwl_rx_mem_buffer *rxb)
{
struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
IWL_DEBUG_RADIO(priv, "Dumping %d bytes of unhandled "
"notification for %s:\n",
le32_to_cpu(pkt->len), get_cmd_string(pkt->hdr.cmd));
iwl_print_hex_dump(priv, IWL_DL_RADIO, pkt->u.raw, le32_to_cpu(pkt->len)
);
}
EXPORT_SYMBOL(iwl_rx_pm_debug_statistics_notif);
Given the rampant misuse of this field without proper masking throughout the
driver (every use but one), this patch renames the field from 'len' to
'len_n_flags' to reduce confusion. It also adds the proper masking when
this field is used as a length value.
Signed-off-by: Daniel C Halperin <daniel.c.halperin@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-08-13 20:31:01 +00:00
|
|
|
le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK);
|
2010-05-06 19:18:41 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUGFS
|
2010-04-16 17:03:54 +00:00
|
|
|
iwl3945_accumulative_statistics(priv, (__le32 *)&pkt->u.raw);
|
|
|
|
#endif
|
2010-04-28 22:47:04 +00:00
|
|
|
iwl_recover_from_statistics(priv, pkt);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-01-21 14:09:28 +00:00
|
|
|
memcpy(&priv->_3945.statistics, pkt->u.raw, sizeof(priv->_3945.statistics));
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-04-16 17:03:54 +00:00
|
|
|
void iwl3945_reply_statistics(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
|
|
|
{
|
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
|
|
|
__le32 *flag = (__le32 *)&pkt->u.raw;
|
|
|
|
|
|
|
|
if (le32_to_cpu(*flag) & UCODE_STATISTICS_CLEAR_MSK) {
|
2010-05-06 19:18:41 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUGFS
|
2010-04-16 17:03:54 +00:00
|
|
|
memset(&priv->_3945.accum_statistics, 0,
|
|
|
|
sizeof(struct iwl3945_notif_statistics));
|
|
|
|
memset(&priv->_3945.delta_statistics, 0,
|
|
|
|
sizeof(struct iwl3945_notif_statistics));
|
|
|
|
memset(&priv->_3945.max_delta, 0,
|
|
|
|
sizeof(struct iwl3945_notif_statistics));
|
|
|
|
#endif
|
|
|
|
IWL_DEBUG_RX(priv, "Statistics have been cleared\n");
|
|
|
|
}
|
|
|
|
iwl3945_hw_rx_statistics(priv, rxb);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-03-01 23:52:00 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* Misc. internal state and helper functions
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2008-07-11 03:53:29 +00:00
|
|
|
/* This is necessary only for a number of statistics, see the caller. */
|
2008-12-19 02:37:28 +00:00
|
|
|
static int iwl3945_is_network_packet(struct iwl_priv *priv,
|
2008-07-11 03:53:29 +00:00
|
|
|
struct ieee80211_hdr *header)
|
|
|
|
{
|
|
|
|
/* Filter incoming packets to determine if they are targeted toward
|
|
|
|
* this network, discarding packets coming from ourselves */
|
|
|
|
switch (priv->iw_mode) {
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_ADHOC: /* Header: Dest. | Source | BSSID */
|
2008-07-11 03:53:29 +00:00
|
|
|
/* packets to our IBSS update information */
|
|
|
|
return !compare_ether_addr(header->addr3, priv->bssid);
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_STATION: /* Header: Dest. | AP{BSSID} | Source */
|
2008-07-11 03:53:29 +00:00
|
|
|
/* packets to our IBSS update information */
|
|
|
|
return !compare_ether_addr(header->addr2, priv->bssid);
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2008-03-01 23:52:00 +00:00
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
static void iwl3945_pass_packet_to_mac80211(struct iwl_priv *priv,
|
2008-12-19 02:37:24 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb,
|
2007-12-20 03:27:32 +00:00
|
|
|
struct ieee80211_rx_status *stats)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-10-09 09:19:45 +00:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-07-11 03:53:29 +00:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)IWL_RX_DATA(pkt);
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_rx_frame_hdr *rx_hdr = IWL_RX_HDR(pkt);
|
|
|
|
struct iwl3945_rx_frame_end *rx_end = IWL_RX_END(pkt);
|
2009-10-09 09:19:45 +00:00
|
|
|
u16 len = le16_to_cpu(rx_hdr->len);
|
|
|
|
struct sk_buff *skb;
|
2009-10-23 20:42:25 +00:00
|
|
|
__le16 fc = hdr->frame_control;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* We received data from the HW, so stop the watchdog */
|
2009-10-09 09:19:45 +00:00
|
|
|
if (unlikely(len + IWL39_RX_FRAME_SIZE >
|
|
|
|
PAGE_SIZE << priv->hw_params.rx_page_order)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_DROP(priv, "Corruption detected!\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We only process data packets if the interface is open */
|
|
|
|
if (unlikely(!priv->is_open)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_DROP_LIMIT(priv,
|
|
|
|
"Dropping packet while interface is not open.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-03-29 08:42:26 +00:00
|
|
|
skb = dev_alloc_skb(128);
|
2009-10-09 09:19:45 +00:00
|
|
|
if (!skb) {
|
2010-03-29 08:42:26 +00:00
|
|
|
IWL_ERR(priv, "dev_alloc_skb failed\n");
|
2009-10-09 09:19:45 +00:00
|
|
|
return;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-08 18:19:59 +00:00
|
|
|
if (!iwl3945_mod_params.sw_crypto)
|
2009-01-27 22:27:52 +00:00
|
|
|
iwl_set_decrypted_flag(priv,
|
2009-10-09 09:19:45 +00:00
|
|
|
(struct ieee80211_hdr *)rxb_addr(rxb),
|
2007-09-26 00:54:57 +00:00
|
|
|
le32_to_cpu(rx_end->status), stats);
|
|
|
|
|
2009-10-09 09:19:45 +00:00
|
|
|
skb_add_rx_frag(skb, 0, rxb->page,
|
|
|
|
(void *)rx_hdr->payload - (void *)pkt, len);
|
|
|
|
|
2009-10-23 20:42:25 +00:00
|
|
|
iwl_update_stats(priv, false, fc, len);
|
2009-10-09 09:19:45 +00:00
|
|
|
memcpy(IEEE80211_SKB_RXCB(skb), stats, sizeof(*stats));
|
|
|
|
|
2009-10-23 20:42:25 +00:00
|
|
|
ieee80211_rx(priv->hw, skb);
|
2009-10-09 09:19:45 +00:00
|
|
|
priv->alloc_rxb_page--;
|
|
|
|
rxb->page = NULL;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2007-11-29 03:10:13 +00:00
|
|
|
#define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
static void iwl3945_rx_reply_rx(struct iwl_priv *priv,
|
2008-12-19 02:37:24 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-01 23:52:00 +00:00
|
|
|
struct ieee80211_hdr *header;
|
|
|
|
struct ieee80211_rx_status rx_status;
|
2009-10-09 09:19:45 +00:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_rx_frame_stats *rx_stats = IWL_RX_STATS(pkt);
|
|
|
|
struct iwl3945_rx_frame_hdr *rx_hdr = IWL_RX_HDR(pkt);
|
|
|
|
struct iwl3945_rx_frame_end *rx_end = IWL_RX_END(pkt);
|
2010-04-05 17:43:10 +00:00
|
|
|
u16 rx_stats_sig_avg __maybe_unused = le16_to_cpu(rx_stats->sig_avg);
|
|
|
|
u16 rx_stats_noise_diff __maybe_unused = le16_to_cpu(rx_stats->noise_diff);
|
2007-09-26 00:54:57 +00:00
|
|
|
u8 network_packet;
|
2008-03-01 23:52:00 +00:00
|
|
|
|
|
|
|
rx_status.flag = 0;
|
|
|
|
rx_status.mactime = le64_to_cpu(rx_end->timestamp);
|
2008-04-03 23:05:22 +00:00
|
|
|
rx_status.freq =
|
2008-05-08 03:34:05 +00:00
|
|
|
ieee80211_channel_to_frequency(le16_to_cpu(rx_hdr->channel));
|
2008-03-01 23:52:00 +00:00
|
|
|
rx_status.band = (rx_hdr->phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ?
|
|
|
|
IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
|
|
|
|
|
|
|
|
rx_status.rate_idx = iwl3945_hwrate_to_plcp_idx(rx_hdr->rate);
|
|
|
|
if (rx_status.band == IEEE80211_BAND_5GHZ)
|
|
|
|
rx_status.rate_idx -= IWL_FIRST_OFDM_RATE;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-10-02 20:43:57 +00:00
|
|
|
rx_status.antenna = (le16_to_cpu(rx_hdr->phy_flags) &
|
2008-07-30 15:20:14 +00:00
|
|
|
RX_RES_PHY_FLAGS_ANTENNA_MSK) >> 4;
|
|
|
|
|
|
|
|
/* set the preamble flag if appropriate */
|
|
|
|
if (rx_hdr->phy_flags & RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK)
|
|
|
|
rx_status.flag |= RX_FLAG_SHORTPRE;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
if ((unlikely(rx_stats->phy_count > 20))) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_DROP(priv, "dsp size out of range [0,20]: %d/n",
|
|
|
|
rx_stats->phy_count);
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(rx_end->status & RX_RES_STATUS_NO_CRC32_ERROR)
|
|
|
|
|| !(rx_end->status & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv, "Bad CRC or FIFO: 0x%08X.\n", rx_end->status);
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-08-01 09:54:27 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Convert 3945's rssi indicator to dBm */
|
2008-12-19 02:37:11 +00:00
|
|
|
rx_status.signal = rx_stats->rssi - IWL39_RSSI_OFFSET;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-03-18 16:58:27 +00:00
|
|
|
IWL_DEBUG_STATS(priv, "Rssi %d sig_avg %d noise_diff %d\n",
|
|
|
|
rx_status.signal, rx_stats_sig_avg,
|
|
|
|
rx_stats_noise_diff);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
header = (struct ieee80211_hdr *)IWL_RX_DATA(pkt);
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
network_packet = iwl3945_is_network_packet(priv, header);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-03-18 16:58:27 +00:00
|
|
|
IWL_DEBUG_STATS_LIMIT(priv, "[%c] %d RSSI:%d Signal:%u, Rate:%u\n",
|
2008-03-01 23:52:00 +00:00
|
|
|
network_packet ? '*' : ' ',
|
|
|
|
le16_to_cpu(rx_hdr->channel),
|
2008-05-08 17:15:40 +00:00
|
|
|
rx_status.signal, rx_status.signal,
|
2010-03-18 16:58:27 +00:00
|
|
|
rx_status.rate_idx);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-08-07 22:41:39 +00:00
|
|
|
iwl_dbg_log_rx_data_frame(priv, le16_to_cpu(rx_hdr->len), header);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (network_packet) {
|
2010-01-19 18:04:28 +00:00
|
|
|
priv->_3945.last_beacon_time =
|
|
|
|
le32_to_cpu(rx_end->beacon_timestamp);
|
|
|
|
priv->_3945.last_tsf = le64_to_cpu(rx_end->timestamp);
|
|
|
|
priv->_3945.last_rx_rssi = rx_status.signal;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-09-09 02:54:52 +00:00
|
|
|
iwl3945_pass_packet_to_mac80211(priv, rxb, &rx_status);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-01-19 23:30:26 +00:00
|
|
|
int iwl3945_hw_txq_attach_buf_to_tfd(struct iwl_priv *priv,
|
|
|
|
struct iwl_tx_queue *txq,
|
|
|
|
dma_addr_t addr, u16 len, u8 reset, u8 pad)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
int count;
|
2009-01-19 23:30:26 +00:00
|
|
|
struct iwl_queue *q;
|
2009-01-23 21:45:13 +00:00
|
|
|
struct iwl3945_tfd *tfd, *tfd_tmp;
|
2009-01-19 23:30:26 +00:00
|
|
|
|
|
|
|
q = &txq->q;
|
2009-01-23 21:45:13 +00:00
|
|
|
tfd_tmp = (struct iwl3945_tfd *)txq->tfds;
|
|
|
|
tfd = &tfd_tmp[q->write_ptr];
|
2009-01-19 23:30:26 +00:00
|
|
|
|
|
|
|
if (reset)
|
|
|
|
memset(tfd, 0, sizeof(*tfd));
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
count = TFD_CTL_COUNT_GET(le32_to_cpu(tfd->control_flags));
|
|
|
|
|
|
|
|
if ((count >= NUM_TFD_CHUNKS) || (count < 0)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error can not send more than %d chunks\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
NUM_TFD_CHUNKS);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-12-22 03:31:14 +00:00
|
|
|
tfd->tbs[count].addr = cpu_to_le32(addr);
|
|
|
|
tfd->tbs[count].len = cpu_to_le32(len);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
count++;
|
|
|
|
|
|
|
|
tfd->control_flags = cpu_to_le32(TFD_CTL_COUNT_SET(count) |
|
|
|
|
TFD_CTL_PAD_SET(pad));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_txq_free_tfd - Free one TFD, those at index [txq->q.read_ptr]
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Does NOT advance any indexes
|
|
|
|
*/
|
2009-01-19 23:30:26 +00:00
|
|
|
void iwl3945_hw_txq_free_tfd(struct iwl_priv *priv, struct iwl_tx_queue *txq)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-01-23 21:45:13 +00:00
|
|
|
struct iwl3945_tfd *tfd_tmp = (struct iwl3945_tfd *)txq->tfds;
|
2009-03-11 18:17:58 +00:00
|
|
|
int index = txq->q.read_ptr;
|
|
|
|
struct iwl3945_tfd *tfd = &tfd_tmp[index];
|
2007-09-26 00:54:57 +00:00
|
|
|
struct pci_dev *dev = priv->pci_dev;
|
|
|
|
int i;
|
|
|
|
int counter;
|
|
|
|
|
|
|
|
/* sanity check */
|
2008-12-22 03:31:14 +00:00
|
|
|
counter = TFD_CTL_COUNT_GET(le32_to_cpu(tfd->control_flags));
|
2007-09-26 00:54:57 +00:00
|
|
|
if (counter > NUM_TFD_CHUNKS) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Too many chunks: %i\n", counter);
|
2007-09-26 00:54:57 +00:00
|
|
|
/* @todo issue fatal error, it is quite serious situation */
|
2009-01-19 23:30:26 +00:00
|
|
|
return;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-03-11 18:17:58 +00:00
|
|
|
/* Unmap tx_cmd */
|
|
|
|
if (counter)
|
|
|
|
pci_unmap_single(dev,
|
2010-06-03 05:19:20 +00:00
|
|
|
dma_unmap_addr(&txq->meta[index], mapping),
|
|
|
|
dma_unmap_len(&txq->meta[index], len),
|
2009-03-11 18:17:58 +00:00
|
|
|
PCI_DMA_TODEVICE);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* unmap chunks if any */
|
|
|
|
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
for (i = 1; i < counter; i++)
|
2008-12-22 03:31:14 +00:00
|
|
|
pci_unmap_single(dev, le32_to_cpu(tfd->tbs[i].addr),
|
|
|
|
le32_to_cpu(tfd->tbs[i].len), PCI_DMA_TODEVICE);
|
2010-05-17 09:37:31 +00:00
|
|
|
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
/* free SKB */
|
|
|
|
if (txq->txb) {
|
|
|
|
struct sk_buff *skb;
|
2010-05-17 09:37:31 +00:00
|
|
|
|
iwlwifi: reduce memory allocation
Currently, the driver allocates up to 19 skb pointers
for each TFD, of which we have 256 per queue. This
means that for each TX queue, we allocate 19k/38k
(an order 4 or 5 allocation on 32/64 bit respectively)
just for each queue's "txb" array, which contains only
the SKB pointers.
However, due to the way we use these pointers only the
first one can ever be assigned. When the driver was
initially written, the idea was that it could be
passed multiple SKBs for each TFD and attach all
those to implement gather DMA. However, due to
constraints in the userspace API and lack of TCP/IP
level checksumming in the device, this is in fact not
possible. And even if it were, the SKBs would be
chained, and we wouldn't need to keep pointers to
each anyway.
Change this to only keep track of one SKB per TFD,
and thereby reduce memory consumption to just one
pointer per TFD, which is an order 0 allocation per
transmit queue.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
2010-05-17 09:37:34 +00:00
|
|
|
skb = txq->txb[txq->q.read_ptr].skb;
|
|
|
|
|
|
|
|
/* can be called from irqs-disabled context */
|
|
|
|
if (skb) {
|
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
txq->txb[txq->q.read_ptr].skb = NULL;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_build_tx_cmd_rate - Add rate portion to TX_CMD:
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
*/
|
2009-07-24 18:13:05 +00:00
|
|
|
void iwl3945_hw_build_tx_cmd_rate(struct iwl_priv *priv,
|
|
|
|
struct iwl_device_cmd *cmd,
|
|
|
|
struct ieee80211_tx_info *info,
|
|
|
|
struct ieee80211_hdr *hdr,
|
|
|
|
int sta_id, int tx_id)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-15 10:55:29 +00:00
|
|
|
u16 hw_value = ieee80211_get_tx_rate(priv->hw, info)->hw_value;
|
2010-02-26 19:01:36 +00:00
|
|
|
u16 rate_index = min(hw_value & 0xffff, IWL_RATE_COUNT_3945);
|
2007-09-26 00:54:57 +00:00
|
|
|
u16 rate_mask;
|
|
|
|
int rate;
|
|
|
|
u8 rts_retry_limit;
|
|
|
|
u8 data_retry_limit;
|
|
|
|
__le32 tx_flags;
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-11 21:21:56 +00:00
|
|
|
__le16 fc = hdr->frame_control;
|
2009-10-09 20:20:31 +00:00
|
|
|
struct iwl3945_tx_cmd *tx_cmd = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
rate = iwl3945_rates[rate_index].plcp;
|
2009-10-09 20:20:31 +00:00
|
|
|
tx_flags = tx_cmd->tx_flags;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* We need to figure out how to get the sta->supp_rates while
|
2008-05-15 10:55:29 +00:00
|
|
|
* in this running context */
|
2007-09-26 00:54:57 +00:00
|
|
|
rate_mask = IWL_RATES_MASK;
|
|
|
|
|
2009-10-09 20:20:33 +00:00
|
|
|
|
|
|
|
/* Set retry limit on DATA packets and Probe Responses*/
|
|
|
|
if (ieee80211_is_probe_resp(fc))
|
|
|
|
data_retry_limit = 3;
|
|
|
|
else
|
|
|
|
data_retry_limit = IWL_DEFAULT_TX_RETRY;
|
|
|
|
tx_cmd->data_retry_limit = data_retry_limit;
|
|
|
|
|
2010-08-23 08:46:33 +00:00
|
|
|
if (tx_id >= IWL39_CMD_QUEUE_NUM)
|
2007-09-26 00:54:57 +00:00
|
|
|
rts_retry_limit = 3;
|
|
|
|
else
|
|
|
|
rts_retry_limit = 7;
|
|
|
|
|
2009-10-09 20:20:33 +00:00
|
|
|
if (data_retry_limit < rts_retry_limit)
|
|
|
|
rts_retry_limit = data_retry_limit;
|
|
|
|
tx_cmd->rts_retry_limit = rts_retry_limit;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-10-09 20:20:31 +00:00
|
|
|
tx_cmd->rate = rate;
|
|
|
|
tx_cmd->tx_flags = tx_flags;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* OFDM */
|
2009-10-09 20:20:31 +00:00
|
|
|
tx_cmd->supp_rates[0] =
|
2007-11-12 03:37:42 +00:00
|
|
|
((rate_mask & IWL_OFDM_RATES_MASK) >> IWL_FIRST_OFDM_RATE) & 0xFF;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* CCK */
|
2009-10-09 20:20:31 +00:00
|
|
|
tx_cmd->supp_rates[1] = (rate_mask & 0xF);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RATE(priv, "Tx sta id: %d, rate: %d (plcp), flags: 0x%4X "
|
2007-09-26 00:54:57 +00:00
|
|
|
"cck/ofdm mask: 0x%x/0x%x\n", sta_id,
|
2009-10-09 20:20:31 +00:00
|
|
|
tx_cmd->rate, le32_to_cpu(tx_cmd->tx_flags),
|
|
|
|
tx_cmd->supp_rates[1], tx_cmd->supp_rates[0]);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2010-05-05 09:26:06 +00:00
|
|
|
static u8 iwl3945_sync_sta(struct iwl_priv *priv, int sta_id, u16 tx_rate)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
unsigned long flags_spin;
|
2009-06-03 18:44:07 +00:00
|
|
|
struct iwl_station_entry *station;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (sta_id == IWL_INVALID_STATION)
|
|
|
|
return IWL_INVALID_STATION;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->sta_lock, flags_spin);
|
2009-06-03 18:44:07 +00:00
|
|
|
station = &priv->stations[sta_id];
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
station->sta.sta.modify_mask = STA_MODIFY_TX_RATE_MSK;
|
|
|
|
station->sta.rate_n_flags = cpu_to_le16(tx_rate);
|
|
|
|
station->sta.mode = STA_CONTROL_MODIFY_MSK;
|
2010-05-05 09:26:06 +00:00
|
|
|
iwl_send_add_sta(priv, &station->sta, CMD_ASYNC);
|
2007-09-26 00:54:57 +00:00
|
|
|
spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RATE(priv, "SCALE sync station %d to rate %d\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
sta_id, tx_rate);
|
|
|
|
return sta_id;
|
|
|
|
}
|
|
|
|
|
2010-09-22 16:02:09 +00:00
|
|
|
static void iwl3945_set_pwr_vmain(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-09-22 16:02:09 +00:00
|
|
|
/*
|
|
|
|
* (for documentation purposes)
|
|
|
|
* to set power to V_AUX, do
|
|
|
|
|
2009-02-10 23:19:02 +00:00
|
|
|
if (pci_pme_capable(priv->pci_dev, PCI_D3cold)) {
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
|
2007-09-26 00:54:57 +00:00
|
|
|
APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
|
|
|
|
~APMG_PS_CTRL_MSK_PWR_SRC);
|
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_poll_bit(priv, CSR_GPIO_IN,
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_GPIO_IN_VAL_VAUX_PWR_SRC,
|
|
|
|
CSR_GPIO_IN_BIT_AUX_POWER, 5000);
|
2009-02-10 23:19:02 +00:00
|
|
|
}
|
2010-09-22 16:02:09 +00:00
|
|
|
*/
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-09-22 16:02:09 +00:00
|
|
|
iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
|
|
|
|
APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
|
|
|
|
~APMG_PS_CTRL_MSK_PWR_SRC);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-09-22 16:02:09 +00:00
|
|
|
iwl_poll_bit(priv, CSR_GPIO_IN, CSR_GPIO_IN_VAL_VMAIN_PWR_SRC,
|
|
|
|
CSR_GPIO_IN_BIT_AUX_POWER, 5000); /* uS */
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
static int iwl3945_rx_init(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-06-07 20:21:46 +00:00
|
|
|
iwl_write_direct32(priv, FH39_RCSR_RBD_BASE(0), rxq->bd_dma);
|
2008-12-19 02:37:43 +00:00
|
|
|
iwl_write_direct32(priv, FH39_RCSR_RPTR_ADDR(0), rxq->rb_stts_dma);
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_direct32(priv, FH39_RCSR_WPTR(0), 0);
|
|
|
|
iwl_write_direct32(priv, FH39_RCSR_CONFIG(0),
|
2008-12-19 02:37:01 +00:00
|
|
|
FH39_RCSR_RX_CONFIG_REG_VAL_DMA_CHNL_EN_ENABLE |
|
|
|
|
FH39_RCSR_RX_CONFIG_REG_VAL_RDRBD_EN_ENABLE |
|
|
|
|
FH39_RCSR_RX_CONFIG_REG_BIT_WR_STTS_EN |
|
|
|
|
FH39_RCSR_RX_CONFIG_REG_VAL_MAX_FRAG_SIZE_128 |
|
|
|
|
(RX_QUEUE_SIZE_LOG << FH39_RCSR_RX_CONFIG_REG_POS_RBDC_SIZE) |
|
|
|
|
FH39_RCSR_RX_CONFIG_REG_VAL_IRQ_DEST_INT_HOST |
|
|
|
|
(1 << FH39_RCSR_RX_CONFIG_REG_POS_IRQ_RBTH) |
|
|
|
|
FH39_RCSR_RX_CONFIG_REG_VAL_MSG_MODE_FH);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* fake read to flush all prev I/O */
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_read_direct32(priv, FH39_RSSR_CTRL);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
static int iwl3945_tx_reset(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
/* bypass mode */
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_prph(priv, ALM_SCD_MODE_REG, 0x2);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* RA 0 is active */
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_prph(priv, ALM_SCD_ARASTAT_REG, 0x01);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* all 6 fifo are active */
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_prph(priv, ALM_SCD_TXFACT_REG, 0x3f);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_prph(priv, ALM_SCD_SBYP_MODE_1_REG, 0x010000);
|
|
|
|
iwl_write_prph(priv, ALM_SCD_SBYP_MODE_2_REG, 0x030002);
|
|
|
|
iwl_write_prph(priv, ALM_SCD_TXF4MF_REG, 0x000004);
|
|
|
|
iwl_write_prph(priv, ALM_SCD_TXF5MF_REG, 0x000005);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_direct32(priv, FH39_TSSR_CBB_BASE,
|
2010-01-21 14:09:28 +00:00
|
|
|
priv->_3945.shared_phys);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_direct32(priv, FH39_TSSR_MSG_CONFIG,
|
2008-12-19 02:37:01 +00:00
|
|
|
FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TXPD_ON |
|
|
|
|
FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_TXPD_ON |
|
|
|
|
FH39_TSSR_TX_MSG_CONFIG_REG_VAL_MAX_FRAG_SIZE_128B |
|
|
|
|
FH39_TSSR_TX_MSG_CONFIG_REG_VAL_SNOOP_RD_TFD_ON |
|
|
|
|
FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RD_CBB_ON |
|
|
|
|
FH39_TSSR_TX_MSG_CONFIG_REG_VAL_ORDER_RSP_WAIT_TH |
|
|
|
|
FH39_TSSR_TX_MSG_CONFIG_REG_VAL_RSP_WAIT_TH);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl3945_txq_ctx_reset - Reset TX queue context
|
|
|
|
*
|
|
|
|
* Destroys all DMA structures and initialize them again
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static int iwl3945_txq_ctx_reset(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
int txq_id, slots_num;
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_txq_ctx_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-10-09 20:20:28 +00:00
|
|
|
/* allocate tx queue structure */
|
|
|
|
rc = iwl_alloc_txq_mem(priv);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Tx CMD queue */
|
|
|
|
rc = iwl3945_tx_reset(priv);
|
|
|
|
if (rc)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* Tx queue(s) */
|
2009-07-09 17:33:40 +00:00
|
|
|
for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
|
2010-08-23 08:46:33 +00:00
|
|
|
slots_num = (txq_id == IWL39_CMD_QUEUE_NUM) ?
|
2007-09-26 00:54:57 +00:00
|
|
|
TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
|
2009-01-23 21:45:14 +00:00
|
|
|
rc = iwl_tx_queue_init(priv, &priv->txq[txq_id], slots_num,
|
|
|
|
txq_id);
|
2007-09-26 00:54:57 +00:00
|
|
|
if (rc) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Tx %d queue init failed\n", txq_id);
|
2007-09-26 00:54:57 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
error:
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_txq_ctx_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2009-10-23 20:42:21 +00:00
|
|
|
|
2009-10-09 20:20:19 +00:00
|
|
|
/*
|
2009-10-23 20:42:21 +00:00
|
|
|
* Start up 3945's basic functionality after it has been reset
|
|
|
|
* (e.g. after platform boot, or shutdown via iwl_apm_stop())
|
2009-10-09 20:20:19 +00:00
|
|
|
* NOTE: This does not load uCode nor start the embedded processor
|
|
|
|
*/
|
2008-12-19 02:37:38 +00:00
|
|
|
static int iwl3945_apm_init(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-10-23 20:42:21 +00:00
|
|
|
int ret = iwl_apm_init(priv);
|
2008-12-19 02:37:38 +00:00
|
|
|
|
2009-10-09 20:20:19 +00:00
|
|
|
/* Clear APMG (NIC's internal power management) interrupts */
|
|
|
|
iwl_write_prph(priv, APMG_RTC_INT_MSK_REG, 0x0);
|
|
|
|
iwl_write_prph(priv, APMG_RTC_INT_STT_REG, 0xFFFFFFFF);
|
|
|
|
|
|
|
|
/* Reset radio chip */
|
|
|
|
iwl_set_bits_prph(priv, APMG_PS_CTRL_REG, APMG_PS_CTRL_VAL_RESET_REQ);
|
|
|
|
udelay(5);
|
|
|
|
iwl_clear_bits_prph(priv, APMG_PS_CTRL_REG, APMG_PS_CTRL_VAL_RESET_REQ);
|
|
|
|
|
2008-12-19 02:37:38 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-12-19 02:37:38 +00:00
|
|
|
static void iwl3945_nic_config(struct iwl_priv *priv)
|
|
|
|
{
|
2009-01-23 21:45:15 +00:00
|
|
|
struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
|
2008-12-19 02:37:38 +00:00
|
|
|
unsigned long flags;
|
|
|
|
u8 rev_id = 0;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
2009-05-08 20:44:41 +00:00
|
|
|
/* Determine HW type */
|
|
|
|
pci_read_config_byte(priv->pci_dev, PCI_REVISION_ID, &rev_id);
|
|
|
|
|
|
|
|
IWL_DEBUG_INFO(priv, "HW Revision ID = 0x%X\n", rev_id);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
if (rev_id & PCI_CFG_REV_ID_BIT_RTP)
|
2010-03-24 21:19:58 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "RTP type\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
else if (rev_id & PCI_CFG_REV_ID_BIT_BASIC_SKU) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "3945 RADIO-MB type\n");
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
|
2008-03-05 02:09:28 +00:00
|
|
|
CSR39_HW_IF_CONFIG_REG_BIT_3945_MB);
|
2007-09-26 00:54:57 +00:00
|
|
|
} else {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "3945 RADIO-MM type\n");
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
|
2008-03-05 02:09:28 +00:00
|
|
|
CSR39_HW_IF_CONFIG_REG_BIT_3945_MM);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-01-23 21:45:15 +00:00
|
|
|
if (EEPROM_SKU_CAP_OP_MODE_MRC == eeprom->sku_cap) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "SKU OP mode is mrc\n");
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
|
2008-03-05 02:09:28 +00:00
|
|
|
CSR39_HW_IF_CONFIG_REG_BIT_SKU_MRC);
|
2007-09-26 00:54:57 +00:00
|
|
|
} else
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "SKU OP mode is basic\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-23 21:45:15 +00:00
|
|
|
if ((eeprom->board_revision & 0xF0) == 0xD0) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "3945ABG revision is 0x%X\n",
|
2009-01-23 21:45:15 +00:00
|
|
|
eeprom->board_revision);
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
|
2008-03-05 02:09:28 +00:00
|
|
|
CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE);
|
2007-09-26 00:54:57 +00:00
|
|
|
} else {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "3945ABG revision is 0x%X\n",
|
2009-01-23 21:45:15 +00:00
|
|
|
eeprom->board_revision);
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_clear_bit(priv, CSR_HW_IF_CONFIG_REG,
|
2008-03-05 02:09:28 +00:00
|
|
|
CSR39_HW_IF_CONFIG_REG_BIT_BOARD_TYPE);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-01-23 21:45:15 +00:00
|
|
|
if (eeprom->almgor_m_version <= 1) {
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
|
2008-03-05 02:09:28 +00:00
|
|
|
CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_A);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Card M type A version is 0x%X\n",
|
2009-01-23 21:45:15 +00:00
|
|
|
eeprom->almgor_m_version);
|
2007-09-26 00:54:57 +00:00
|
|
|
} else {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Card M type B version is 0x%X\n",
|
2009-01-23 21:45:15 +00:00
|
|
|
eeprom->almgor_m_version);
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
|
2008-03-05 02:09:28 +00:00
|
|
|
CSR39_HW_IF_CONFIG_REG_BITS_SILICON_TYPE_B);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2009-01-23 21:45:15 +00:00
|
|
|
if (eeprom->sku_cap & EEPROM_SKU_CAP_SW_RF_KILL_ENABLE)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RF_KILL(priv, "SW RF KILL supported in EEPROM.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-23 21:45:15 +00:00
|
|
|
if (eeprom->sku_cap & EEPROM_SKU_CAP_HW_RF_KILL_ENABLE)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RF_KILL(priv, "HW RF KILL supported in EEPROM.\n");
|
2008-12-19 02:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int iwl3945_hw_nic_init(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
unsigned long flags;
|
|
|
|
struct iwl_rx_queue *rxq = &priv->rxq;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
priv->cfg->ops->lib->apm_ops.init(priv);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2010-09-22 16:02:09 +00:00
|
|
|
iwl3945_set_pwr_vmain(priv);
|
2008-12-19 02:37:39 +00:00
|
|
|
|
2008-12-19 02:37:38 +00:00
|
|
|
priv->cfg->ops->lib->apm_ops.config(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Allocate the RX queue, or reset if it is already allocated */
|
|
|
|
if (!rxq->bd) {
|
2008-12-22 03:31:23 +00:00
|
|
|
rc = iwl_rx_queue_alloc(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
if (rc) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to initialize Rx queue\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
} else
|
2009-04-21 17:55:48 +00:00
|
|
|
iwl3945_rx_queue_reset(priv, rxq);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_rx_replenish(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
iwl3945_rx_init(priv, rxq);
|
|
|
|
|
|
|
|
|
|
|
|
/* Look at using this instead:
|
|
|
|
rxq->need_update = 1;
|
2009-01-08 18:19:53 +00:00
|
|
|
iwl_rx_queue_update_write_ptr(priv, rxq);
|
2007-09-26 00:54:57 +00:00
|
|
|
*/
|
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_direct32(priv, FH39_RCSR_WPTR(0), rxq->write & ~7);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
rc = iwl3945_txq_ctx_reset(priv);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
set_bit(STATUS_INIT, &priv->status);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_txq_ctx_free - Free TXQ Context
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Destroy all TX DMA queues and structures
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
void iwl3945_hw_txq_ctx_free(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
int txq_id;
|
|
|
|
|
|
|
|
/* Tx queues */
|
2009-10-09 20:20:28 +00:00
|
|
|
if (priv->txq)
|
|
|
|
for (txq_id = 0; txq_id < priv->hw_params.max_txq_num;
|
|
|
|
txq_id++)
|
2010-08-23 08:46:33 +00:00
|
|
|
if (txq_id == IWL39_CMD_QUEUE_NUM)
|
2009-10-09 20:20:28 +00:00
|
|
|
iwl_cmd_queue_free(priv);
|
|
|
|
else
|
|
|
|
iwl_tx_queue_free(priv, txq_id);
|
2009-03-18 04:51:49 +00:00
|
|
|
|
2009-10-09 20:20:28 +00:00
|
|
|
/* free tx queue structure */
|
|
|
|
iwl_free_txq_mem(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
void iwl3945_hw_txq_ctx_stop(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-12-19 02:37:01 +00:00
|
|
|
int txq_id;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* stop SCD */
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_prph(priv, ALM_SCD_MODE_REG, 0);
|
2009-10-16 21:25:49 +00:00
|
|
|
iwl_write_prph(priv, ALM_SCD_TXFACT_REG, 0);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* reset TFD queues */
|
2009-07-09 17:33:40 +00:00
|
|
|
for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_direct32(priv, FH39_TCSR_CONFIG(txq_id), 0x0);
|
|
|
|
iwl_poll_direct_bit(priv, FH39_TSSR_TX_STATUS,
|
2008-12-19 02:37:01 +00:00
|
|
|
FH39_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(txq_id),
|
2007-09-26 00:54:57 +00:00
|
|
|
1000);
|
|
|
|
}
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_txq_ctx_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_adjust_power_by_temp
|
2007-10-25 09:15:28 +00:00
|
|
|
* return index delta into power gain settings table
|
|
|
|
*/
|
2008-01-28 00:41:47 +00:00
|
|
|
static int iwl3945_hw_reg_adjust_power_by_temp(int new_reading, int old_reading)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
return (new_reading - old_reading) * (-11) / 100;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_temp_out_of_range - Keep temperature in sane range
|
2007-09-26 00:54:57 +00:00
|
|
|
*/
|
2008-01-28 00:41:47 +00:00
|
|
|
static inline int iwl3945_hw_reg_temp_out_of_range(int temperature)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-07-20 23:40:14 +00:00
|
|
|
return ((temperature < -260) || (temperature > 25)) ? 1 : 0;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
int iwl3945_hw_get_temperature(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-12-19 02:37:29 +00:00
|
|
|
return iwl_read32(priv, CSR_UCODE_DRV_GP2);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_txpower_get_temperature
|
2007-10-25 09:15:28 +00:00
|
|
|
* get the current temperature by reading from NIC
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static int iwl3945_hw_reg_txpower_get_temperature(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-01-23 21:45:15 +00:00
|
|
|
struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
|
2007-09-26 00:54:57 +00:00
|
|
|
int temperature;
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
temperature = iwl3945_hw_get_temperature(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* driver's okay range is -260 to +25.
|
|
|
|
* human readable okay range is 0 to +285 */
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Temperature: %d\n", temperature + IWL_TEMP_CONVERT);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* handle insane temp reading */
|
2008-01-28 00:41:47 +00:00
|
|
|
if (iwl3945_hw_reg_temp_out_of_range(temperature)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error bad temperature value %d\n", temperature);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* if really really hot(?),
|
|
|
|
* substitute the 3rd band/group's temp measured at factory */
|
|
|
|
if (priv->last_temperature > 100)
|
2009-01-23 21:45:15 +00:00
|
|
|
temperature = eeprom->groups[2].temperature;
|
2007-09-26 00:54:57 +00:00
|
|
|
else /* else use most recent "sane" value from driver */
|
|
|
|
temperature = priv->last_temperature;
|
|
|
|
}
|
|
|
|
|
|
|
|
return temperature; /* raw, not "human readable" */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Adjust Txpower only if temperature variance is greater than threshold.
|
|
|
|
*
|
|
|
|
* Both are lower than older versions' 9 degrees */
|
|
|
|
#define IWL_TEMPERATURE_LIMIT_TIMER 6
|
|
|
|
|
|
|
|
/**
|
|
|
|
* is_temp_calib_needed - determines if new calibration is needed
|
|
|
|
*
|
|
|
|
* records new temperature in tx_mgr->temperature.
|
|
|
|
* replaces tx_mgr->last_temperature *only* if calib needed
|
|
|
|
* (assumes caller will actually do the calibration!). */
|
2008-12-19 02:37:28 +00:00
|
|
|
static int is_temp_calib_needed(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
int temp_diff;
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
priv->temperature = iwl3945_hw_reg_txpower_get_temperature(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
temp_diff = priv->temperature - priv->last_temperature;
|
|
|
|
|
|
|
|
/* get absolute value */
|
|
|
|
if (temp_diff < 0) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Getting cooler, delta %d,\n", temp_diff);
|
2007-09-26 00:54:57 +00:00
|
|
|
temp_diff = -temp_diff;
|
|
|
|
} else if (temp_diff == 0)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Same temp,\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Getting warmer, delta %d,\n", temp_diff);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* if we don't need calibration, *don't* update last_temperature */
|
|
|
|
if (temp_diff < IWL_TEMPERATURE_LIMIT_TIMER) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Timed thermal calib not needed\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Timed thermal calib needed\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* assume that caller will actually do calib ...
|
|
|
|
* update the "last temperature" value */
|
|
|
|
priv->last_temperature = priv->temperature;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define IWL_MAX_GAIN_ENTRIES 78
|
|
|
|
#define IWL_CCK_FROM_OFDM_POWER_DIFF -5
|
|
|
|
#define IWL_CCK_FROM_OFDM_INDEX_DIFF (10)
|
|
|
|
|
|
|
|
/* radio and DSP power table, each step is 1/2 dB.
|
|
|
|
* 1st number is for RF analog gain, 2nd number is for DSP pre-DAC gain. */
|
2008-01-28 00:41:47 +00:00
|
|
|
static struct iwl3945_tx_power power_gain_table[2][IWL_MAX_GAIN_ENTRIES] = {
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
{251, 127}, /* 2.4 GHz, highest power */
|
|
|
|
{251, 127},
|
|
|
|
{251, 127},
|
|
|
|
{251, 127},
|
|
|
|
{251, 125},
|
|
|
|
{251, 110},
|
|
|
|
{251, 105},
|
|
|
|
{251, 98},
|
|
|
|
{187, 125},
|
|
|
|
{187, 115},
|
|
|
|
{187, 108},
|
|
|
|
{187, 99},
|
|
|
|
{243, 119},
|
|
|
|
{243, 111},
|
|
|
|
{243, 105},
|
|
|
|
{243, 97},
|
|
|
|
{243, 92},
|
|
|
|
{211, 106},
|
|
|
|
{211, 100},
|
|
|
|
{179, 120},
|
|
|
|
{179, 113},
|
|
|
|
{179, 107},
|
|
|
|
{147, 125},
|
|
|
|
{147, 119},
|
|
|
|
{147, 112},
|
|
|
|
{147, 106},
|
|
|
|
{147, 101},
|
|
|
|
{147, 97},
|
|
|
|
{147, 91},
|
|
|
|
{115, 107},
|
|
|
|
{235, 121},
|
|
|
|
{235, 115},
|
|
|
|
{235, 109},
|
|
|
|
{203, 127},
|
|
|
|
{203, 121},
|
|
|
|
{203, 115},
|
|
|
|
{203, 108},
|
|
|
|
{203, 102},
|
|
|
|
{203, 96},
|
|
|
|
{203, 92},
|
|
|
|
{171, 110},
|
|
|
|
{171, 104},
|
|
|
|
{171, 98},
|
|
|
|
{139, 116},
|
|
|
|
{227, 125},
|
|
|
|
{227, 119},
|
|
|
|
{227, 113},
|
|
|
|
{227, 107},
|
|
|
|
{227, 101},
|
|
|
|
{227, 96},
|
|
|
|
{195, 113},
|
|
|
|
{195, 106},
|
|
|
|
{195, 102},
|
|
|
|
{195, 95},
|
|
|
|
{163, 113},
|
|
|
|
{163, 106},
|
|
|
|
{163, 102},
|
|
|
|
{163, 95},
|
|
|
|
{131, 113},
|
|
|
|
{131, 106},
|
|
|
|
{131, 102},
|
|
|
|
{131, 95},
|
|
|
|
{99, 113},
|
|
|
|
{99, 106},
|
|
|
|
{99, 102},
|
|
|
|
{99, 95},
|
|
|
|
{67, 113},
|
|
|
|
{67, 106},
|
|
|
|
{67, 102},
|
|
|
|
{67, 95},
|
|
|
|
{35, 113},
|
|
|
|
{35, 106},
|
|
|
|
{35, 102},
|
|
|
|
{35, 95},
|
|
|
|
{3, 113},
|
|
|
|
{3, 106},
|
|
|
|
{3, 102},
|
|
|
|
{3, 95} }, /* 2.4 GHz, lowest power */
|
|
|
|
{
|
|
|
|
{251, 127}, /* 5.x GHz, highest power */
|
|
|
|
{251, 120},
|
|
|
|
{251, 114},
|
|
|
|
{219, 119},
|
|
|
|
{219, 101},
|
|
|
|
{187, 113},
|
|
|
|
{187, 102},
|
|
|
|
{155, 114},
|
|
|
|
{155, 103},
|
|
|
|
{123, 117},
|
|
|
|
{123, 107},
|
|
|
|
{123, 99},
|
|
|
|
{123, 92},
|
|
|
|
{91, 108},
|
|
|
|
{59, 125},
|
|
|
|
{59, 118},
|
|
|
|
{59, 109},
|
|
|
|
{59, 102},
|
|
|
|
{59, 96},
|
|
|
|
{59, 90},
|
|
|
|
{27, 104},
|
|
|
|
{27, 98},
|
|
|
|
{27, 92},
|
|
|
|
{115, 118},
|
|
|
|
{115, 111},
|
|
|
|
{115, 104},
|
|
|
|
{83, 126},
|
|
|
|
{83, 121},
|
|
|
|
{83, 113},
|
|
|
|
{83, 105},
|
|
|
|
{83, 99},
|
|
|
|
{51, 118},
|
|
|
|
{51, 111},
|
|
|
|
{51, 104},
|
|
|
|
{51, 98},
|
|
|
|
{19, 116},
|
|
|
|
{19, 109},
|
|
|
|
{19, 102},
|
|
|
|
{19, 98},
|
|
|
|
{19, 93},
|
|
|
|
{171, 113},
|
|
|
|
{171, 107},
|
|
|
|
{171, 99},
|
|
|
|
{139, 120},
|
|
|
|
{139, 113},
|
|
|
|
{139, 107},
|
|
|
|
{139, 99},
|
|
|
|
{107, 120},
|
|
|
|
{107, 113},
|
|
|
|
{107, 107},
|
|
|
|
{107, 99},
|
|
|
|
{75, 120},
|
|
|
|
{75, 113},
|
|
|
|
{75, 107},
|
|
|
|
{75, 99},
|
|
|
|
{43, 120},
|
|
|
|
{43, 113},
|
|
|
|
{43, 107},
|
|
|
|
{43, 99},
|
|
|
|
{11, 120},
|
|
|
|
{11, 113},
|
|
|
|
{11, 107},
|
|
|
|
{11, 99},
|
|
|
|
{131, 107},
|
|
|
|
{131, 99},
|
|
|
|
{99, 120},
|
|
|
|
{99, 113},
|
|
|
|
{99, 107},
|
|
|
|
{99, 99},
|
|
|
|
{67, 120},
|
|
|
|
{67, 113},
|
|
|
|
{67, 107},
|
|
|
|
{67, 99},
|
|
|
|
{35, 120},
|
|
|
|
{35, 113},
|
|
|
|
{35, 107},
|
|
|
|
{35, 99},
|
|
|
|
{3, 120} } /* 5.x GHz, lowest power */
|
|
|
|
};
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
static inline u8 iwl3945_hw_reg_fix_power_index(int index)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
if (index < 0)
|
|
|
|
return 0;
|
|
|
|
if (index >= IWL_MAX_GAIN_ENTRIES)
|
|
|
|
return IWL_MAX_GAIN_ENTRIES - 1;
|
|
|
|
return (u8) index;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Kick off thermal recalibration check every 60 seconds */
|
|
|
|
#define REG_RECALIB_PERIOD (60)
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_set_scan_power - Set Tx power for scan probe requests
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Set (in our channel info database) the direct scan Tx power for 1 Mbit (CCK)
|
|
|
|
* or 6 Mbit (OFDM) rates.
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static void iwl3945_hw_reg_set_scan_power(struct iwl_priv *priv, u32 scan_tbl_index,
|
2007-09-26 00:54:57 +00:00
|
|
|
s32 rate_index, const s8 *clip_pwrs,
|
2008-12-19 02:37:15 +00:00
|
|
|
struct iwl_channel_info *ch_info,
|
2007-09-26 00:54:57 +00:00
|
|
|
int band_index)
|
|
|
|
{
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_scan_power_info *scan_power_info;
|
2007-09-26 00:54:57 +00:00
|
|
|
s8 power;
|
|
|
|
u8 power_index;
|
|
|
|
|
|
|
|
scan_power_info = &ch_info->scan_pwr_info[scan_tbl_index];
|
|
|
|
|
|
|
|
/* use this channel group's 6Mbit clipping/saturation pwr,
|
|
|
|
* but cap at regulatory scan power restriction (set during init
|
|
|
|
* based on eeprom channel data) for this channel. */
|
2007-11-12 03:37:42 +00:00
|
|
|
power = min(ch_info->scan_power, clip_pwrs[IWL_RATE_6M_INDEX_TABLE]);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* further limit to user's max power preference.
|
|
|
|
* FIXME: Other spectrum management power limitations do not
|
|
|
|
* seem to apply?? */
|
2009-01-19 23:30:29 +00:00
|
|
|
power = min(power, priv->tx_power_user_lmt);
|
2007-09-26 00:54:57 +00:00
|
|
|
scan_power_info->requested_power = power;
|
|
|
|
|
|
|
|
/* find difference between new scan *power* and current "normal"
|
|
|
|
* Tx *power* for 6Mb. Use this difference (x2) to adjust the
|
|
|
|
* current "normal" temperature-compensated Tx power *index* for
|
|
|
|
* this rate (1Mb or 6Mb) to yield new temp-compensated scan power
|
|
|
|
* *index*. */
|
|
|
|
power_index = ch_info->power_info[rate_index].power_table_index
|
|
|
|
- (power - ch_info->power_info
|
2007-11-12 03:37:42 +00:00
|
|
|
[IWL_RATE_6M_INDEX_TABLE].requested_power) * 2;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* store reference index that we use when adjusting *all* scan
|
|
|
|
* powers. So we can accommodate user (all channel) or spectrum
|
|
|
|
* management (single channel) power changes "between" temperature
|
|
|
|
* feedback compensation procedures.
|
|
|
|
* don't force fit this reference index into gain table; it may be a
|
|
|
|
* negative number. This will help avoid errors when we're at
|
|
|
|
* the lower bounds (highest gains, for warmest temperatures)
|
|
|
|
* of the table. */
|
|
|
|
|
|
|
|
/* don't exceed table bounds for "real" setting */
|
2008-01-28 00:41:47 +00:00
|
|
|
power_index = iwl3945_hw_reg_fix_power_index(power_index);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
scan_power_info->power_table_index = power_index;
|
|
|
|
scan_power_info->tpc.tx_gain =
|
|
|
|
power_gain_table[band_index][power_index].tx_gain;
|
|
|
|
scan_power_info->tpc.dsp_atten =
|
|
|
|
power_gain_table[band_index][power_index].dsp_atten;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-01-23 21:45:11 +00:00
|
|
|
* iwl3945_send_tx_power - fill in Tx Power command with gain settings
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Configures power settings for all rates for the current channel,
|
|
|
|
* using values from channel info struct, and send to NIC
|
|
|
|
*/
|
2009-01-27 22:27:54 +00:00
|
|
|
static int iwl3945_send_tx_power(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2007-11-12 03:37:42 +00:00
|
|
|
int rate_idx, i;
|
2008-12-19 02:37:15 +00:00
|
|
|
const struct iwl_channel_info *ch_info = NULL;
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_txpowertable_cmd txpower = {
|
2010-08-23 08:46:32 +00:00
|
|
|
.channel = priv->contexts[IWL_RXON_CTX_BSS].active.channel,
|
2007-09-26 00:54:57 +00:00
|
|
|
};
|
2010-08-23 08:46:32 +00:00
|
|
|
u16 chan;
|
|
|
|
|
2010-10-25 08:34:50 +00:00
|
|
|
if (WARN_ONCE(test_bit(STATUS_SCAN_HW, &priv->status),
|
|
|
|
"TX Power requested while scanning!\n"))
|
|
|
|
return -EAGAIN;
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
chan = le16_to_cpu(priv->contexts[IWL_RXON_CTX_BSS].active.channel);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-24 18:38:38 +00:00
|
|
|
txpower.band = (priv->band == IEEE80211_BAND_5GHZ) ? 0 : 1;
|
2010-08-23 08:46:32 +00:00
|
|
|
ch_info = iwl_get_channel_info(priv, priv->band, chan);
|
2007-09-26 00:54:57 +00:00
|
|
|
if (!ch_info) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"Failed to get channel info for channel %d [%d]\n",
|
2010-08-23 08:46:32 +00:00
|
|
|
chan, priv->band);
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_channel_valid(ch_info)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Not calling TX_PWR_TABLE_CMD on "
|
2007-09-26 00:54:57 +00:00
|
|
|
"non-Tx channel.\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill cmd with power settings for all rates for current channel */
|
2007-11-12 03:37:42 +00:00
|
|
|
/* Fill OFDM rate */
|
|
|
|
for (rate_idx = IWL_FIRST_OFDM_RATE, i = 0;
|
2008-12-19 02:37:12 +00:00
|
|
|
rate_idx <= IWL39_LAST_OFDM_RATE; rate_idx++, i++) {
|
2007-11-12 03:37:42 +00:00
|
|
|
|
|
|
|
txpower.power[i].tpc = ch_info->power_info[i].tpc;
|
2008-01-28 00:41:47 +00:00
|
|
|
txpower.power[i].rate = iwl3945_rates[rate_idx].plcp;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
le16_to_cpu(txpower.channel),
|
|
|
|
txpower.band,
|
2007-11-12 03:37:42 +00:00
|
|
|
txpower.power[i].tpc.tx_gain,
|
|
|
|
txpower.power[i].tpc.dsp_atten,
|
|
|
|
txpower.power[i].rate);
|
|
|
|
}
|
|
|
|
/* Fill CCK rates */
|
|
|
|
for (rate_idx = IWL_FIRST_CCK_RATE;
|
|
|
|
rate_idx <= IWL_LAST_CCK_RATE; rate_idx++, i++) {
|
|
|
|
txpower.power[i].tpc = ch_info->power_info[i].tpc;
|
2008-01-28 00:41:47 +00:00
|
|
|
txpower.power[i].rate = iwl3945_rates[rate_idx].plcp;
|
2007-11-12 03:37:42 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "ch %d:%d rf %d dsp %3d rate code 0x%02x\n",
|
2007-11-12 03:37:42 +00:00
|
|
|
le16_to_cpu(txpower.channel),
|
|
|
|
txpower.band,
|
|
|
|
txpower.power[i].tpc.tx_gain,
|
|
|
|
txpower.power[i].tpc.dsp_atten,
|
|
|
|
txpower.power[i].rate);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-01-19 23:30:27 +00:00
|
|
|
return iwl_send_cmd_pdu(priv, REPLY_TX_PWR_TABLE_CMD,
|
|
|
|
sizeof(struct iwl3945_txpowertable_cmd),
|
|
|
|
&txpower);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_set_new_power - Configures power tables at new levels
|
2007-09-26 00:54:57 +00:00
|
|
|
* @ch_info: Channel to update. Uses power_info.requested_power.
|
|
|
|
*
|
|
|
|
* Replace requested_power and base_power_index ch_info fields for
|
|
|
|
* one channel.
|
|
|
|
*
|
|
|
|
* Called if user or spectrum management changes power preferences.
|
|
|
|
* Takes into account h/w and modulation limitations (clip power).
|
|
|
|
*
|
|
|
|
* This does *not* send anything to NIC, just sets up ch_info for one channel.
|
|
|
|
*
|
|
|
|
* NOTE: reg_compensate_for_temperature_dif() *must* be run after this to
|
|
|
|
* properly fill out the scan powers, and actual h/w gain settings,
|
|
|
|
* and send changes to NIC
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static int iwl3945_hw_reg_set_new_power(struct iwl_priv *priv,
|
2008-12-19 02:37:15 +00:00
|
|
|
struct iwl_channel_info *ch_info)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_channel_power_info *power_info;
|
2007-09-26 00:54:57 +00:00
|
|
|
int power_changed = 0;
|
|
|
|
int i;
|
|
|
|
const s8 *clip_pwrs;
|
|
|
|
int power;
|
|
|
|
|
|
|
|
/* Get this chnlgrp's rate-to-max/clip-powers table */
|
2010-02-17 10:39:19 +00:00
|
|
|
clip_pwrs = priv->_3945.clip_groups[ch_info->group_index].clip_powers;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Get this channel's rate-to-current-power settings table */
|
|
|
|
power_info = ch_info->power_info;
|
|
|
|
|
|
|
|
/* update OFDM Txpower settings */
|
2007-11-12 03:37:42 +00:00
|
|
|
for (i = IWL_RATE_6M_INDEX_TABLE; i <= IWL_RATE_54M_INDEX_TABLE;
|
2007-09-26 00:54:57 +00:00
|
|
|
i++, ++power_info) {
|
|
|
|
int delta_idx;
|
|
|
|
|
|
|
|
/* limit new power to be no more than h/w capability */
|
|
|
|
power = min(ch_info->curr_txpow, clip_pwrs[i]);
|
|
|
|
if (power == power_info->requested_power)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* find difference between old and new requested powers,
|
|
|
|
* update base (non-temp-compensated) power index */
|
|
|
|
delta_idx = (power - power_info->requested_power) * 2;
|
|
|
|
power_info->base_power_index -= delta_idx;
|
|
|
|
|
|
|
|
/* save new requested power value */
|
|
|
|
power_info->requested_power = power;
|
|
|
|
|
|
|
|
power_changed = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update CCK Txpower settings, based on OFDM 12M setting ...
|
|
|
|
* ... all CCK power settings for a given channel are the *same*. */
|
|
|
|
if (power_changed) {
|
|
|
|
power =
|
2007-11-12 03:37:42 +00:00
|
|
|
ch_info->power_info[IWL_RATE_12M_INDEX_TABLE].
|
2007-09-26 00:54:57 +00:00
|
|
|
requested_power + IWL_CCK_FROM_OFDM_POWER_DIFF;
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
/* do all CCK rates' iwl3945_channel_power_info structures */
|
2007-11-12 03:37:42 +00:00
|
|
|
for (i = IWL_RATE_1M_INDEX_TABLE; i <= IWL_RATE_11M_INDEX_TABLE; i++) {
|
2007-09-26 00:54:57 +00:00
|
|
|
power_info->requested_power = power;
|
|
|
|
power_info->base_power_index =
|
2007-11-12 03:37:42 +00:00
|
|
|
ch_info->power_info[IWL_RATE_12M_INDEX_TABLE].
|
2007-09-26 00:54:57 +00:00
|
|
|
base_power_index + IWL_CCK_FROM_OFDM_INDEX_DIFF;
|
|
|
|
++power_info;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_get_ch_txpower_limit - returns new power limit for channel
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* NOTE: Returned power limit may be less (but not more) than requested,
|
|
|
|
* based strictly on regulatory (eeprom and spectrum mgt) limitations
|
|
|
|
* (no consideration for h/w clipping limitations).
|
|
|
|
*/
|
2008-12-19 02:37:15 +00:00
|
|
|
static int iwl3945_hw_reg_get_ch_txpower_limit(struct iwl_channel_info *ch_info)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
s8 max_power;
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/* if we're using TGd limits, use lower of TGd or EEPROM */
|
|
|
|
if (ch_info->tgd_data.max_power != 0)
|
|
|
|
max_power = min(ch_info->tgd_data.max_power,
|
|
|
|
ch_info->eeprom.max_power_avg);
|
|
|
|
|
|
|
|
/* else just use EEPROM limits */
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
max_power = ch_info->eeprom.max_power_avg;
|
|
|
|
|
|
|
|
return min(max_power, ch_info->max_power_avg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_comp_txpower_temp - Compensate for temperature
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Compensate txpower settings of *all* channels for temperature.
|
|
|
|
* This only accounts for the difference between current temperature
|
|
|
|
* and the factory calibration temperatures, and bases the new settings
|
|
|
|
* on the channel's base_power_index.
|
|
|
|
*
|
|
|
|
* If RxOn is "associated", this sends the new Txpower to NIC!
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static int iwl3945_hw_reg_comp_txpower_temp(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-12-19 02:37:15 +00:00
|
|
|
struct iwl_channel_info *ch_info = NULL;
|
2009-01-23 21:45:15 +00:00
|
|
|
struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
|
2007-09-26 00:54:57 +00:00
|
|
|
int delta_index;
|
|
|
|
const s8 *clip_pwrs; /* array of h/w max power levels for each rate */
|
|
|
|
u8 a_band;
|
|
|
|
u8 rate_index;
|
|
|
|
u8 scan_tbl_index;
|
|
|
|
u8 i;
|
|
|
|
int ref_temp;
|
|
|
|
int temperature = priv->temperature;
|
|
|
|
|
2010-04-27 21:33:33 +00:00
|
|
|
if (priv->disable_tx_power_cal ||
|
|
|
|
test_bit(STATUS_SCANNING, &priv->status)) {
|
|
|
|
/* do not perform tx power calibration */
|
|
|
|
return 0;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
/* set up new Tx power info for each and every channel, 2.4 and 5.x */
|
|
|
|
for (i = 0; i < priv->channel_count; i++) {
|
|
|
|
ch_info = &priv->channel_info[i];
|
|
|
|
a_band = is_channel_a_band(ch_info);
|
|
|
|
|
|
|
|
/* Get this chnlgrp's factory calibration temperature */
|
2009-01-23 21:45:15 +00:00
|
|
|
ref_temp = (s16)eeprom->groups[ch_info->group_index].
|
2007-09-26 00:54:57 +00:00
|
|
|
temperature;
|
|
|
|
|
2008-10-24 06:48:56 +00:00
|
|
|
/* get power index adjustment based on current and factory
|
2007-09-26 00:54:57 +00:00
|
|
|
* temps */
|
2008-01-28 00:41:47 +00:00
|
|
|
delta_index = iwl3945_hw_reg_adjust_power_by_temp(temperature,
|
2007-09-26 00:54:57 +00:00
|
|
|
ref_temp);
|
|
|
|
|
|
|
|
/* set tx power value for all rates, OFDM and CCK */
|
|
|
|
for (rate_index = 0; rate_index < IWL_RATE_COUNT;
|
|
|
|
rate_index++) {
|
|
|
|
int power_idx =
|
|
|
|
ch_info->power_info[rate_index].base_power_index;
|
|
|
|
|
|
|
|
/* temperature compensate */
|
|
|
|
power_idx += delta_index;
|
|
|
|
|
|
|
|
/* stay within table range */
|
2008-01-28 00:41:47 +00:00
|
|
|
power_idx = iwl3945_hw_reg_fix_power_index(power_idx);
|
2007-09-26 00:54:57 +00:00
|
|
|
ch_info->power_info[rate_index].
|
|
|
|
power_table_index = (u8) power_idx;
|
|
|
|
ch_info->power_info[rate_index].tpc =
|
|
|
|
power_gain_table[a_band][power_idx];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get this chnlgrp's rate-to-max/clip-powers table */
|
2010-02-17 10:39:19 +00:00
|
|
|
clip_pwrs = priv->_3945.clip_groups[ch_info->group_index].clip_powers;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* set scan tx power, 1Mbit for CCK, 6Mbit for OFDM */
|
|
|
|
for (scan_tbl_index = 0;
|
|
|
|
scan_tbl_index < IWL_NUM_SCAN_RATES; scan_tbl_index++) {
|
|
|
|
s32 actual_index = (scan_tbl_index == 0) ?
|
2007-11-12 03:37:42 +00:00
|
|
|
IWL_RATE_1M_INDEX_TABLE : IWL_RATE_6M_INDEX_TABLE;
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_reg_set_scan_power(priv, scan_tbl_index,
|
2007-09-26 00:54:57 +00:00
|
|
|
actual_index, clip_pwrs,
|
|
|
|
ch_info, a_band);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* send Txpower command for current channel to ucode */
|
2009-01-23 21:45:11 +00:00
|
|
|
return priv->cfg->ops->lib->send_tx_power(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
int iwl3945_hw_reg_set_txpower(struct iwl_priv *priv, s8 power)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-12-19 02:37:15 +00:00
|
|
|
struct iwl_channel_info *ch_info;
|
2007-09-26 00:54:57 +00:00
|
|
|
s8 max_power;
|
|
|
|
u8 a_band;
|
|
|
|
u8 i;
|
|
|
|
|
2009-01-19 23:30:29 +00:00
|
|
|
if (priv->tx_power_user_lmt == power) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Requested Tx power same as current "
|
2007-09-26 00:54:57 +00:00
|
|
|
"limit: %ddBm.\n", power);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Setting upper limit clamp to %ddBm.\n", power);
|
2009-01-19 23:30:29 +00:00
|
|
|
priv->tx_power_user_lmt = power;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* set up new Tx powers for each and every channel, 2.4 and 5.x */
|
|
|
|
|
|
|
|
for (i = 0; i < priv->channel_count; i++) {
|
|
|
|
ch_info = &priv->channel_info[i];
|
|
|
|
a_band = is_channel_a_band(ch_info);
|
|
|
|
|
|
|
|
/* find minimum power of all user and regulatory constraints
|
|
|
|
* (does not consider h/w clipping limitations) */
|
2008-01-28 00:41:47 +00:00
|
|
|
max_power = iwl3945_hw_reg_get_ch_txpower_limit(ch_info);
|
2007-09-26 00:54:57 +00:00
|
|
|
max_power = min(power, max_power);
|
|
|
|
if (max_power != ch_info->curr_txpow) {
|
|
|
|
ch_info->curr_txpow = max_power;
|
|
|
|
|
|
|
|
/* this considers the h/w clipping limitations */
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_reg_set_new_power(priv, ch_info);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update txpower settings for all channels,
|
|
|
|
* send to NIC if associated. */
|
|
|
|
is_temp_calib_needed(priv);
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_reg_comp_txpower_temp(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
static int iwl3945_send_rxon_assoc(struct iwl_priv *priv,
|
|
|
|
struct iwl_rxon_context *ctx)
|
2009-04-08 18:26:35 +00:00
|
|
|
{
|
|
|
|
int rc = 0;
|
2009-10-09 09:19:45 +00:00
|
|
|
struct iwl_rx_packet *pkt;
|
2009-04-08 18:26:35 +00:00
|
|
|
struct iwl3945_rxon_assoc_cmd rxon_assoc;
|
|
|
|
struct iwl_host_cmd cmd = {
|
|
|
|
.id = REPLY_RXON_ASSOC,
|
|
|
|
.len = sizeof(rxon_assoc),
|
2009-07-24 18:13:05 +00:00
|
|
|
.flags = CMD_WANT_SKB,
|
2009-04-08 18:26:35 +00:00
|
|
|
.data = &rxon_assoc,
|
|
|
|
};
|
2010-08-23 08:46:32 +00:00
|
|
|
const struct iwl_rxon_cmd *rxon1 = &ctx->staging;
|
|
|
|
const struct iwl_rxon_cmd *rxon2 = &ctx->active;
|
2009-04-08 18:26:35 +00:00
|
|
|
|
|
|
|
if ((rxon1->flags == rxon2->flags) &&
|
|
|
|
(rxon1->filter_flags == rxon2->filter_flags) &&
|
|
|
|
(rxon1->cck_basic_rates == rxon2->cck_basic_rates) &&
|
|
|
|
(rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
|
|
|
|
IWL_DEBUG_INFO(priv, "Using current RXON_ASSOC. Not resending.\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
rxon_assoc.flags = ctx->staging.flags;
|
|
|
|
rxon_assoc.filter_flags = ctx->staging.filter_flags;
|
|
|
|
rxon_assoc.ofdm_basic_rates = ctx->staging.ofdm_basic_rates;
|
|
|
|
rxon_assoc.cck_basic_rates = ctx->staging.cck_basic_rates;
|
2009-04-08 18:26:35 +00:00
|
|
|
rxon_assoc.reserved = 0;
|
|
|
|
|
|
|
|
rc = iwl_send_cmd_sync(priv, &cmd);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2009-10-09 09:19:45 +00:00
|
|
|
pkt = (struct iwl_rx_packet *)cmd.reply_page;
|
|
|
|
if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
|
2009-04-08 18:26:35 +00:00
|
|
|
IWL_ERR(priv, "Bad return from REPLY_RXON_ASSOC command\n");
|
|
|
|
rc = -EIO;
|
|
|
|
}
|
|
|
|
|
2009-12-10 22:37:21 +00:00
|
|
|
iwl_free_pages(priv, cmd.reply_page);
|
2009-04-08 18:26:35 +00:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2009-04-08 18:26:37 +00:00
|
|
|
/**
|
|
|
|
* iwl3945_commit_rxon - commit staging_rxon to hardware
|
|
|
|
*
|
|
|
|
* The RXON command in staging_rxon is committed to the hardware and
|
|
|
|
* the active_rxon structure is updated with the new data. This
|
|
|
|
* function correctly transitions out of the RXON_ASSOC_MSK state if
|
|
|
|
* a HW tune is required based on the RXON structure changes.
|
|
|
|
*/
|
2010-09-22 16:01:57 +00:00
|
|
|
int iwl3945_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
|
2009-04-08 18:26:37 +00:00
|
|
|
{
|
|
|
|
/* cast away the const for active_rxon in this function */
|
2010-08-23 08:46:32 +00:00
|
|
|
struct iwl3945_rxon_cmd *active_rxon = (void *)&ctx->active;
|
|
|
|
struct iwl3945_rxon_cmd *staging_rxon = (void *)&ctx->staging;
|
2009-04-08 18:26:37 +00:00
|
|
|
int rc = 0;
|
2010-08-23 08:46:32 +00:00
|
|
|
bool new_assoc = !!(staging_rxon->filter_flags & RXON_FILTER_ASSOC_MSK);
|
2009-04-08 18:26:37 +00:00
|
|
|
|
|
|
|
if (!iwl_is_alive(priv))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* always get timestamp with Rx frame */
|
|
|
|
staging_rxon->flags |= RXON_FLG_TSF2HOST_MSK;
|
|
|
|
|
|
|
|
/* select antenna */
|
|
|
|
staging_rxon->flags &=
|
|
|
|
~(RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_SEL_MSK);
|
|
|
|
staging_rxon->flags |= iwl3945_get_antenna_flags(priv);
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
rc = iwl_check_rxon_cmd(priv, ctx);
|
2009-04-08 18:26:37 +00:00
|
|
|
if (rc) {
|
|
|
|
IWL_ERR(priv, "Invalid RXON configuration. Not committing.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we don't need to send a full RXON, we can use
|
|
|
|
* iwl3945_rxon_assoc_cmd which is used to reconfigure filter
|
|
|
|
* and other flags for the current radio configuration. */
|
2010-08-23 08:46:32 +00:00
|
|
|
if (!iwl_full_rxon_required(priv, &priv->contexts[IWL_RXON_CTX_BSS])) {
|
|
|
|
rc = iwl_send_rxon_assoc(priv,
|
|
|
|
&priv->contexts[IWL_RXON_CTX_BSS]);
|
2009-04-08 18:26:37 +00:00
|
|
|
if (rc) {
|
|
|
|
IWL_ERR(priv, "Error setting RXON_ASSOC "
|
|
|
|
"configuration (%d).\n", rc);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we are currently associated and the new config requires
|
|
|
|
* an RXON_ASSOC and the new config wants the associated mask enabled,
|
|
|
|
* we must clear the associated from the active configuration
|
|
|
|
* before we apply the new config */
|
2010-08-23 08:46:32 +00:00
|
|
|
if (iwl_is_associated(priv, IWL_RXON_CTX_BSS) && new_assoc) {
|
2009-04-08 18:26:37 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Toggling associated bit on current RXON\n");
|
|
|
|
active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* reserved4 and 5 could have been filled by the iwlcore code.
|
|
|
|
* Let's clear them before pushing to the 3945.
|
|
|
|
*/
|
|
|
|
active_rxon->reserved4 = 0;
|
|
|
|
active_rxon->reserved5 = 0;
|
|
|
|
rc = iwl_send_cmd_pdu(priv, REPLY_RXON,
|
|
|
|
sizeof(struct iwl3945_rxon_cmd),
|
2010-08-23 08:46:32 +00:00
|
|
|
&priv->contexts[IWL_RXON_CTX_BSS].active);
|
2009-04-08 18:26:37 +00:00
|
|
|
|
|
|
|
/* If the mask clearing failed then we set
|
|
|
|
* active_rxon back to what it was previously */
|
|
|
|
if (rc) {
|
|
|
|
active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
|
|
|
|
IWL_ERR(priv, "Error clearing ASSOC_MSK on current "
|
|
|
|
"configuration (%d).\n", rc);
|
|
|
|
return rc;
|
|
|
|
}
|
2010-08-27 15:55:52 +00:00
|
|
|
iwl_clear_ucode_stations(priv,
|
|
|
|
&priv->contexts[IWL_RXON_CTX_BSS]);
|
|
|
|
iwl_restore_stations(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
|
2009-04-08 18:26:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
IWL_DEBUG_INFO(priv, "Sending RXON\n"
|
|
|
|
"* with%s RXON_FILTER_ASSOC_MSK\n"
|
|
|
|
"* channel = %d\n"
|
|
|
|
"* bssid = %pM\n",
|
|
|
|
(new_assoc ? "" : "out"),
|
|
|
|
le16_to_cpu(staging_rxon->channel),
|
|
|
|
staging_rxon->bssid_addr);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* reserved4 and 5 could have been filled by the iwlcore code.
|
|
|
|
* Let's clear them before pushing to the 3945.
|
|
|
|
*/
|
|
|
|
staging_rxon->reserved4 = 0;
|
|
|
|
staging_rxon->reserved5 = 0;
|
|
|
|
|
2010-08-23 08:46:32 +00:00
|
|
|
iwl_set_rxon_hwcrypto(priv, ctx, !iwl3945_mod_params.sw_crypto);
|
2009-04-08 18:26:37 +00:00
|
|
|
|
|
|
|
/* Apply the new configuration */
|
|
|
|
rc = iwl_send_cmd_pdu(priv, REPLY_RXON,
|
|
|
|
sizeof(struct iwl3945_rxon_cmd),
|
|
|
|
staging_rxon);
|
|
|
|
if (rc) {
|
|
|
|
IWL_ERR(priv, "Error setting new configuration (%d).\n", rc);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
|
|
|
|
|
2010-02-19 06:58:32 +00:00
|
|
|
if (!new_assoc) {
|
2010-08-27 15:55:52 +00:00
|
|
|
iwl_clear_ucode_stations(priv,
|
|
|
|
&priv->contexts[IWL_RXON_CTX_BSS]);
|
|
|
|
iwl_restore_stations(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
|
2010-02-19 06:58:32 +00:00
|
|
|
}
|
2009-04-08 18:26:37 +00:00
|
|
|
|
|
|
|
/* If we issue a new RXON command which required a tune then we must
|
|
|
|
* send a new TXPOWER command or we won't be able to Tx any frames */
|
|
|
|
rc = priv->cfg->ops->lib->send_tx_power(priv);
|
|
|
|
if (rc) {
|
|
|
|
IWL_ERR(priv, "Error setting Tx power (%d).\n", rc);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Init the hardware's rate fallback order based on the band */
|
|
|
|
rc = iwl3945_init_hw_rate_table(priv);
|
|
|
|
if (rc) {
|
|
|
|
IWL_ERR(priv, "Error setting HW rate table: %02X\n", rc);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
|
|
|
* iwl3945_reg_txpower_periodic - called when time to check our temperature.
|
|
|
|
*
|
|
|
|
* -- reset periodic timer
|
|
|
|
* -- see if temp has changed enough to warrant re-calibration ... if so:
|
|
|
|
* -- correct coeffs for temp (can reset temp timer)
|
|
|
|
* -- save this temp as "last",
|
|
|
|
* -- send new set of gain settings to NIC
|
|
|
|
* NOTE: This should continue working, even when we're not associated,
|
|
|
|
* so we can keep our internal table of scan powers current. */
|
2008-12-19 02:37:28 +00:00
|
|
|
void iwl3945_reg_txpower_periodic(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
/* This will kick in the "brute force"
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_comp_txpower_temp() below */
|
2007-09-26 00:54:57 +00:00
|
|
|
if (!is_temp_calib_needed(priv))
|
|
|
|
goto reschedule;
|
|
|
|
|
|
|
|
/* Set up a new set of temp-adjusted TxPowers, send to NIC.
|
|
|
|
* This is based *only* on current temperature,
|
|
|
|
* ignoring any previous power measurements */
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_reg_comp_txpower_temp(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
reschedule:
|
|
|
|
queue_delayed_work(priv->workqueue,
|
2010-01-21 14:09:28 +00:00
|
|
|
&priv->_3945.thermal_periodic, REG_RECALIB_PERIOD * HZ);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2007-10-25 09:15:49 +00:00
|
|
|
static void iwl3945_bg_reg_txpower_periodic(struct work_struct *work)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-12-19 02:37:28 +00:00
|
|
|
struct iwl_priv *priv = container_of(work, struct iwl_priv,
|
2010-01-21 14:09:28 +00:00
|
|
|
_3945.thermal_periodic.work);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
iwl3945_reg_txpower_periodic(priv);
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_get_ch_grp_index - find the channel-group index (0-4)
|
2007-09-26 00:54:57 +00:00
|
|
|
* for the channel.
|
|
|
|
*
|
|
|
|
* This function is used when initializing channel-info structs.
|
|
|
|
*
|
|
|
|
* NOTE: These channel groups do *NOT* match the bands above!
|
|
|
|
* These channel groups are based on factory-tested channels;
|
|
|
|
* on A-band, EEPROM's "group frequency" entries represent the top
|
|
|
|
* channel in each group 1-4. Group 5 All B/G channels are in group 0.
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static u16 iwl3945_hw_reg_get_ch_grp_index(struct iwl_priv *priv,
|
2008-12-19 02:37:15 +00:00
|
|
|
const struct iwl_channel_info *ch_info)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-01-23 21:45:15 +00:00
|
|
|
struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
|
|
|
|
struct iwl3945_eeprom_txpower_group *ch_grp = &eeprom->groups[0];
|
2007-09-26 00:54:57 +00:00
|
|
|
u8 group;
|
|
|
|
u16 group_index = 0; /* based on factory calib frequencies */
|
|
|
|
u8 grp_channel;
|
|
|
|
|
|
|
|
/* Find the group index for the channel ... don't use index 1(?) */
|
|
|
|
if (is_channel_a_band(ch_info)) {
|
|
|
|
for (group = 1; group < 5; group++) {
|
|
|
|
grp_channel = ch_grp[group].group_channel;
|
|
|
|
if (ch_info->channel <= grp_channel) {
|
|
|
|
group_index = group;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* group 4 has a few channels *above* its factory cal freq */
|
|
|
|
if (group == 5)
|
|
|
|
group_index = 4;
|
|
|
|
} else
|
|
|
|
group_index = 0; /* 2.4 GHz, group 0 */
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Chnl %d mapped to grp %d\n", ch_info->channel,
|
2007-09-26 00:54:57 +00:00
|
|
|
group_index);
|
|
|
|
return group_index;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-01-28 00:41:47 +00:00
|
|
|
* iwl3945_hw_reg_get_matched_power_index - Interpolate to get nominal index
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Interpolate to get nominal (i.e. at factory calibration temperature) index
|
|
|
|
* into radio/DSP gain settings table for requested power.
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
static int iwl3945_hw_reg_get_matched_power_index(struct iwl_priv *priv,
|
2007-09-26 00:54:57 +00:00
|
|
|
s8 requested_power,
|
|
|
|
s32 setting_index, s32 *new_index)
|
|
|
|
{
|
2008-01-28 00:41:47 +00:00
|
|
|
const struct iwl3945_eeprom_txpower_group *chnl_grp = NULL;
|
2009-01-23 21:45:15 +00:00
|
|
|
struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
|
2007-09-26 00:54:57 +00:00
|
|
|
s32 index0, index1;
|
|
|
|
s32 power = 2 * requested_power;
|
|
|
|
s32 i;
|
2008-01-28 00:41:47 +00:00
|
|
|
const struct iwl3945_eeprom_txpower_sample *samples;
|
2007-09-26 00:54:57 +00:00
|
|
|
s32 gains0, gains1;
|
|
|
|
s32 res;
|
|
|
|
s32 denominator;
|
|
|
|
|
2009-01-23 21:45:15 +00:00
|
|
|
chnl_grp = &eeprom->groups[setting_index];
|
2007-09-26 00:54:57 +00:00
|
|
|
samples = chnl_grp->samples;
|
|
|
|
for (i = 0; i < 5; i++) {
|
|
|
|
if (power == samples[i].power) {
|
|
|
|
*new_index = samples[i].gain_index;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (power > samples[1].power) {
|
|
|
|
index0 = 0;
|
|
|
|
index1 = 1;
|
|
|
|
} else if (power > samples[2].power) {
|
|
|
|
index0 = 1;
|
|
|
|
index1 = 2;
|
|
|
|
} else if (power > samples[3].power) {
|
|
|
|
index0 = 2;
|
|
|
|
index1 = 3;
|
|
|
|
} else {
|
|
|
|
index0 = 3;
|
|
|
|
index1 = 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
denominator = (s32) samples[index1].power - (s32) samples[index0].power;
|
|
|
|
if (denominator == 0)
|
|
|
|
return -EINVAL;
|
|
|
|
gains0 = (s32) samples[index0].gain_index * (1 << 19);
|
|
|
|
gains1 = (s32) samples[index1].gain_index * (1 << 19);
|
|
|
|
res = gains0 + (gains1 - gains0) *
|
|
|
|
((s32) power - (s32) samples[index0].power) / denominator +
|
|
|
|
(1 << 18);
|
|
|
|
*new_index = res >> 19;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
static void iwl3945_hw_reg_init_channel_groups(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
u32 i;
|
|
|
|
s32 rate_index;
|
2009-01-23 21:45:15 +00:00
|
|
|
struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
|
2008-01-28 00:41:47 +00:00
|
|
|
const struct iwl3945_eeprom_txpower_group *group;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Initializing factory calib info from EEPROM\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
for (i = 0; i < IWL_NUM_TX_CALIB_GROUPS; i++) {
|
|
|
|
s8 *clip_pwrs; /* table of power levels for each rate */
|
|
|
|
s8 satur_pwr; /* saturation power for each chnl group */
|
2009-01-23 21:45:15 +00:00
|
|
|
group = &eeprom->groups[i];
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* sanity check on factory saturation power value */
|
|
|
|
if (group->saturation_power < 40) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Error: saturation power is %d, "
|
2007-09-26 00:54:57 +00:00
|
|
|
"less than minimum expected 40\n",
|
|
|
|
group->saturation_power);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Derive requested power levels for each rate, based on
|
|
|
|
* hardware capabilities (saturation power for band).
|
|
|
|
* Basic value is 3dB down from saturation, with further
|
|
|
|
* power reductions for highest 3 data rates. These
|
|
|
|
* backoffs provide headroom for high rate modulation
|
|
|
|
* power peaks, without too much distortion (clipping).
|
|
|
|
*/
|
|
|
|
/* we'll fill in this array with h/w max power levels */
|
2010-02-17 10:39:19 +00:00
|
|
|
clip_pwrs = (s8 *) priv->_3945.clip_groups[i].clip_powers;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* divide factory saturation power by 2 to find -3dB level */
|
|
|
|
satur_pwr = (s8) (group->saturation_power >> 1);
|
|
|
|
|
|
|
|
/* fill in channel group's nominal powers for each rate */
|
|
|
|
for (rate_index = 0;
|
2010-02-26 19:01:36 +00:00
|
|
|
rate_index < IWL_RATE_COUNT_3945; rate_index++, clip_pwrs++) {
|
2007-09-26 00:54:57 +00:00
|
|
|
switch (rate_index) {
|
2007-11-12 03:37:42 +00:00
|
|
|
case IWL_RATE_36M_INDEX_TABLE:
|
2007-09-26 00:54:57 +00:00
|
|
|
if (i == 0) /* B/G */
|
|
|
|
*clip_pwrs = satur_pwr;
|
|
|
|
else /* A */
|
|
|
|
*clip_pwrs = satur_pwr - 5;
|
|
|
|
break;
|
2007-11-12 03:37:42 +00:00
|
|
|
case IWL_RATE_48M_INDEX_TABLE:
|
2007-09-26 00:54:57 +00:00
|
|
|
if (i == 0)
|
|
|
|
*clip_pwrs = satur_pwr - 7;
|
|
|
|
else
|
|
|
|
*clip_pwrs = satur_pwr - 10;
|
|
|
|
break;
|
2007-11-12 03:37:42 +00:00
|
|
|
case IWL_RATE_54M_INDEX_TABLE:
|
2007-09-26 00:54:57 +00:00
|
|
|
if (i == 0)
|
|
|
|
*clip_pwrs = satur_pwr - 9;
|
|
|
|
else
|
|
|
|
*clip_pwrs = satur_pwr - 12;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*clip_pwrs = satur_pwr;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl3945_txpower_set_from_eeprom - Set channel power info based on EEPROM
|
|
|
|
*
|
|
|
|
* Second pass (during init) to set up priv->channel_info
|
|
|
|
*
|
|
|
|
* Set up Tx-power settings in our channel info database for each VALID
|
|
|
|
* (for this geo/SKU) channel, at all Tx data rates, based on eeprom values
|
|
|
|
* and current temperature.
|
|
|
|
*
|
|
|
|
* Since this is based on current temperature (at init time), these values may
|
|
|
|
* not be valid for very long, but it gives us a starting/default point,
|
|
|
|
* and allows us to active (i.e. using Tx) scan.
|
|
|
|
*
|
|
|
|
* This does *not* write values to NIC, just sets up our internal table.
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
int iwl3945_txpower_set_from_eeprom(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-12-19 02:37:15 +00:00
|
|
|
struct iwl_channel_info *ch_info = NULL;
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_channel_power_info *pwr_info;
|
2009-01-23 21:45:15 +00:00
|
|
|
struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
|
2007-09-26 00:54:57 +00:00
|
|
|
int delta_index;
|
|
|
|
u8 rate_index;
|
|
|
|
u8 scan_tbl_index;
|
|
|
|
const s8 *clip_pwrs; /* array of power levels for each rate */
|
|
|
|
u8 gain, dsp_atten;
|
|
|
|
s8 power;
|
|
|
|
u8 pwr_index, base_pwr_index, a_band;
|
|
|
|
u8 i;
|
|
|
|
int temperature;
|
|
|
|
|
|
|
|
/* save temperature reference,
|
|
|
|
* so we can determine next time to calibrate */
|
2008-01-28 00:41:47 +00:00
|
|
|
temperature = iwl3945_hw_reg_txpower_get_temperature(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->last_temperature = temperature;
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_reg_init_channel_groups(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* initialize Tx power info for each and every channel, 2.4 and 5.x */
|
|
|
|
for (i = 0, ch_info = priv->channel_info; i < priv->channel_count;
|
|
|
|
i++, ch_info++) {
|
|
|
|
a_band = is_channel_a_band(ch_info);
|
|
|
|
if (!is_channel_valid(ch_info))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* find this channel's channel group (*not* "band") index */
|
|
|
|
ch_info->group_index =
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_reg_get_ch_grp_index(priv, ch_info);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Get this chnlgrp's rate->max/clip-powers table */
|
2010-02-17 10:39:19 +00:00
|
|
|
clip_pwrs = priv->_3945.clip_groups[ch_info->group_index].clip_powers;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* calculate power index *adjustment* value according to
|
|
|
|
* diff between current temperature and factory temperature */
|
2008-01-28 00:41:47 +00:00
|
|
|
delta_index = iwl3945_hw_reg_adjust_power_by_temp(temperature,
|
2009-01-23 21:45:15 +00:00
|
|
|
eeprom->groups[ch_info->group_index].
|
2007-09-26 00:54:57 +00:00
|
|
|
temperature);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_POWER(priv, "Delta index for channel %d: %d [%d]\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
ch_info->channel, delta_index, temperature +
|
|
|
|
IWL_TEMP_CONVERT);
|
|
|
|
|
|
|
|
/* set tx power value for all OFDM rates */
|
|
|
|
for (rate_index = 0; rate_index < IWL_OFDM_RATES;
|
|
|
|
rate_index++) {
|
2009-01-12 19:44:52 +00:00
|
|
|
s32 uninitialized_var(power_idx);
|
2007-09-26 00:54:57 +00:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* use channel group's clip-power table,
|
|
|
|
* but don't exceed channel's max power */
|
|
|
|
s8 pwr = min(ch_info->max_power_avg,
|
|
|
|
clip_pwrs[rate_index]);
|
|
|
|
|
|
|
|
pwr_info = &ch_info->power_info[rate_index];
|
|
|
|
|
|
|
|
/* get base (i.e. at factory-measured temperature)
|
|
|
|
* power table index for this rate's power */
|
2008-01-28 00:41:47 +00:00
|
|
|
rc = iwl3945_hw_reg_get_matched_power_index(priv, pwr,
|
2007-09-26 00:54:57 +00:00
|
|
|
ch_info->group_index,
|
|
|
|
&power_idx);
|
|
|
|
if (rc) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Invalid power index\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
pwr_info->base_power_index = (u8) power_idx;
|
|
|
|
|
|
|
|
/* temperature compensate */
|
|
|
|
power_idx += delta_index;
|
|
|
|
|
|
|
|
/* stay within range of gain table */
|
2008-01-28 00:41:47 +00:00
|
|
|
power_idx = iwl3945_hw_reg_fix_power_index(power_idx);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
/* fill 1 OFDM rate's iwl3945_channel_power_info struct */
|
2007-09-26 00:54:57 +00:00
|
|
|
pwr_info->requested_power = pwr;
|
|
|
|
pwr_info->power_table_index = (u8) power_idx;
|
|
|
|
pwr_info->tpc.tx_gain =
|
|
|
|
power_gain_table[a_band][power_idx].tx_gain;
|
|
|
|
pwr_info->tpc.dsp_atten =
|
|
|
|
power_gain_table[a_band][power_idx].dsp_atten;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set tx power for CCK rates, based on OFDM 12 Mbit settings*/
|
2007-11-12 03:37:42 +00:00
|
|
|
pwr_info = &ch_info->power_info[IWL_RATE_12M_INDEX_TABLE];
|
2007-09-26 00:54:57 +00:00
|
|
|
power = pwr_info->requested_power +
|
|
|
|
IWL_CCK_FROM_OFDM_POWER_DIFF;
|
|
|
|
pwr_index = pwr_info->power_table_index +
|
|
|
|
IWL_CCK_FROM_OFDM_INDEX_DIFF;
|
|
|
|
base_pwr_index = pwr_info->base_power_index +
|
|
|
|
IWL_CCK_FROM_OFDM_INDEX_DIFF;
|
|
|
|
|
|
|
|
/* stay within table range */
|
2008-01-28 00:41:47 +00:00
|
|
|
pwr_index = iwl3945_hw_reg_fix_power_index(pwr_index);
|
2007-09-26 00:54:57 +00:00
|
|
|
gain = power_gain_table[a_band][pwr_index].tx_gain;
|
|
|
|
dsp_atten = power_gain_table[a_band][pwr_index].dsp_atten;
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
/* fill each CCK rate's iwl3945_channel_power_info structure
|
2007-09-26 00:54:57 +00:00
|
|
|
* NOTE: All CCK-rate Txpwrs are the same for a given chnl!
|
|
|
|
* NOTE: CCK rates start at end of OFDM rates! */
|
2007-11-12 03:37:42 +00:00
|
|
|
for (rate_index = 0;
|
|
|
|
rate_index < IWL_CCK_RATES; rate_index++) {
|
|
|
|
pwr_info = &ch_info->power_info[rate_index+IWL_OFDM_RATES];
|
2007-09-26 00:54:57 +00:00
|
|
|
pwr_info->requested_power = power;
|
|
|
|
pwr_info->power_table_index = pwr_index;
|
|
|
|
pwr_info->base_power_index = base_pwr_index;
|
|
|
|
pwr_info->tpc.tx_gain = gain;
|
|
|
|
pwr_info->tpc.dsp_atten = dsp_atten;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set scan tx power, 1Mbit for CCK, 6Mbit for OFDM */
|
|
|
|
for (scan_tbl_index = 0;
|
|
|
|
scan_tbl_index < IWL_NUM_SCAN_RATES; scan_tbl_index++) {
|
|
|
|
s32 actual_index = (scan_tbl_index == 0) ?
|
2007-11-12 03:37:42 +00:00
|
|
|
IWL_RATE_1M_INDEX_TABLE : IWL_RATE_6M_INDEX_TABLE;
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_reg_set_scan_power(priv, scan_tbl_index,
|
2007-09-26 00:54:57 +00:00
|
|
|
actual_index, clip_pwrs, ch_info, a_band);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
int iwl3945_hw_rxq_stop(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_direct32(priv, FH39_RCSR_CONFIG(0), 0);
|
|
|
|
rc = iwl_poll_direct_bit(priv, FH39_RSSR_STATUS,
|
2008-12-19 02:37:01 +00:00
|
|
|
FH39_RSSR_CHNL0_RX_STATUS_CHNL_IDLE, 1000);
|
2007-09-26 00:54:57 +00:00
|
|
|
if (rc < 0)
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Can't stop Rx DMA.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-22 03:31:16 +00:00
|
|
|
int iwl3945_hw_tx_queue_init(struct iwl_priv *priv, struct iwl_tx_queue *txq)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
int txq_id = txq->q.id;
|
|
|
|
|
2010-01-21 14:09:28 +00:00
|
|
|
struct iwl3945_shared *shared_data = priv->_3945.shared_virt;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
shared_data->tx_base_ptr[txq_id] = cpu_to_le32((u32)txq->q.dma_addr);
|
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_direct32(priv, FH39_CBCC_CTRL(txq_id), 0);
|
|
|
|
iwl_write_direct32(priv, FH39_CBCC_BASE(txq_id), 0);
|
2008-12-19 02:37:01 +00:00
|
|
|
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_write_direct32(priv, FH39_TCSR_CONFIG(txq_id),
|
2008-12-19 02:37:01 +00:00
|
|
|
FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_RTC_NOINT |
|
|
|
|
FH39_TCSR_TX_CONFIG_REG_VAL_MSG_MODE_TXF |
|
|
|
|
FH39_TCSR_TX_CONFIG_REG_VAL_CIRQ_HOST_IFTFD |
|
|
|
|
FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE_VAL |
|
|
|
|
FH39_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* fake read to flush all prev. writes */
|
2008-12-19 02:37:29 +00:00
|
|
|
iwl_read32(priv, FH39_TSSR_CBB_BASE);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-22 03:31:15 +00:00
|
|
|
/*
|
|
|
|
* HCMD utils
|
|
|
|
*/
|
|
|
|
static u16 iwl3945_get_hcmd_size(u8 cmd_id, u16 len)
|
|
|
|
{
|
|
|
|
switch (cmd_id) {
|
|
|
|
case REPLY_RXON:
|
2009-01-27 22:27:58 +00:00
|
|
|
return sizeof(struct iwl3945_rxon_cmd);
|
|
|
|
case POWER_TABLE_CMD:
|
|
|
|
return sizeof(struct iwl3945_powertable_cmd);
|
2008-12-22 03:31:15 +00:00
|
|
|
default:
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-03 18:44:07 +00:00
|
|
|
|
2009-01-23 21:45:20 +00:00
|
|
|
static u16 iwl3945_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data)
|
|
|
|
{
|
2009-06-03 18:44:07 +00:00
|
|
|
struct iwl3945_addsta_cmd *addsta = (struct iwl3945_addsta_cmd *)data;
|
|
|
|
addsta->mode = cmd->mode;
|
|
|
|
memcpy(&addsta->sta, &cmd->sta, sizeof(struct sta_id_modify));
|
|
|
|
memcpy(&addsta->key, &cmd->key, sizeof(struct iwl4965_keyinfo));
|
|
|
|
addsta->station_flags = cmd->station_flags;
|
|
|
|
addsta->station_flags_msk = cmd->station_flags_msk;
|
|
|
|
addsta->tid_disable_tx = cpu_to_le16(0);
|
|
|
|
addsta->rate_n_flags = cmd->rate_n_flags;
|
|
|
|
addsta->add_immediate_ba_tid = cmd->add_immediate_ba_tid;
|
|
|
|
addsta->remove_immediate_ba_tid = cmd->remove_immediate_ba_tid;
|
|
|
|
addsta->add_immediate_ba_ssn = cmd->add_immediate_ba_ssn;
|
|
|
|
|
|
|
|
return (u16)sizeof(struct iwl3945_addsta_cmd);
|
2009-01-23 21:45:20 +00:00
|
|
|
}
|
|
|
|
|
2010-09-22 16:02:01 +00:00
|
|
|
static int iwl3945_add_bssid_station(struct iwl_priv *priv,
|
|
|
|
const u8 *addr, u8 *sta_id_r)
|
|
|
|
{
|
|
|
|
struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
|
|
|
|
int ret;
|
|
|
|
u8 sta_id;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (sta_id_r)
|
|
|
|
*sta_id_r = IWL_INVALID_STATION;
|
|
|
|
|
|
|
|
ret = iwl_add_station_common(priv, ctx, addr, 0, NULL, &sta_id);
|
|
|
|
if (ret) {
|
|
|
|
IWL_ERR(priv, "Unable to add station %pM\n", addr);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sta_id_r)
|
|
|
|
*sta_id_r = sta_id;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->sta_lock, flags);
|
|
|
|
priv->stations[sta_id].used |= IWL_STA_LOCAL;
|
|
|
|
spin_unlock_irqrestore(&priv->sta_lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2010-04-28 15:44:52 +00:00
|
|
|
static int iwl3945_manage_ibss_station(struct iwl_priv *priv,
|
|
|
|
struct ieee80211_vif *vif, bool add)
|
|
|
|
{
|
2010-04-30 18:30:43 +00:00
|
|
|
struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
|
2010-04-28 15:44:52 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (add) {
|
2010-09-22 16:02:01 +00:00
|
|
|
ret = iwl3945_add_bssid_station(priv, vif->bss_conf.bssid,
|
|
|
|
&vif_priv->ibss_bssid_sta_id);
|
2010-04-28 15:44:52 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2010-04-30 18:30:43 +00:00
|
|
|
iwl3945_sync_sta(priv, vif_priv->ibss_bssid_sta_id,
|
2010-04-28 15:44:52 +00:00
|
|
|
(priv->band == IEEE80211_BAND_5GHZ) ?
|
2010-05-05 09:26:06 +00:00
|
|
|
IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP);
|
2010-04-30 18:30:43 +00:00
|
|
|
iwl3945_rate_scale_init(priv->hw, vif_priv->ibss_bssid_sta_id);
|
2010-04-28 15:44:52 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-30 18:30:43 +00:00
|
|
|
return iwl_remove_station(priv, vif_priv->ibss_bssid_sta_id,
|
|
|
|
vif->bss_conf.bssid);
|
2010-04-28 15:44:52 +00:00
|
|
|
}
|
2009-06-03 18:44:07 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
|
|
|
* iwl3945_init_hw_rate_table - Initialize the hardware rate fallback table
|
|
|
|
*/
|
2008-12-19 02:37:28 +00:00
|
|
|
int iwl3945_init_hw_rate_table(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2007-11-12 03:37:42 +00:00
|
|
|
int rc, i, index, prev_index;
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_rate_scaling_cmd rate_cmd = {
|
2007-09-26 00:54:57 +00:00
|
|
|
.reserved = {0, 0, 0},
|
|
|
|
};
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_rate_scaling_info *table = rate_cmd.table;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(iwl3945_rates); i++) {
|
|
|
|
index = iwl3945_rates[i].table_rs_index;
|
2007-11-12 03:37:42 +00:00
|
|
|
|
|
|
|
table[index].rate_n_flags =
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_hw_set_rate_n_flags(iwl3945_rates[i].plcp, 0);
|
2007-11-12 03:37:42 +00:00
|
|
|
table[index].try_cnt = priv->retry_rate;
|
2008-01-28 00:41:47 +00:00
|
|
|
prev_index = iwl3945_get_prev_ieee_rate(i);
|
2008-12-05 15:58:37 +00:00
|
|
|
table[index].next_rate_index =
|
|
|
|
iwl3945_rates[prev_index].table_rs_index;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-01-24 18:38:38 +00:00
|
|
|
switch (priv->band) {
|
|
|
|
case IEEE80211_BAND_5GHZ:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RATE(priv, "Select A mode rate scale\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
/* If one of the following CCK rates is used,
|
|
|
|
* have it fall back to the 6M OFDM rate */
|
2008-12-05 15:58:37 +00:00
|
|
|
for (i = IWL_RATE_1M_INDEX_TABLE;
|
|
|
|
i <= IWL_RATE_11M_INDEX_TABLE; i++)
|
|
|
|
table[i].next_rate_index =
|
|
|
|
iwl3945_rates[IWL_FIRST_OFDM_RATE].table_rs_index;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Don't fall back to CCK rates */
|
2008-12-05 15:58:37 +00:00
|
|
|
table[IWL_RATE_12M_INDEX_TABLE].next_rate_index =
|
|
|
|
IWL_RATE_9M_INDEX_TABLE;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Don't drop out of OFDM rates */
|
2007-11-12 03:37:42 +00:00
|
|
|
table[IWL_RATE_6M_INDEX_TABLE].next_rate_index =
|
2008-01-28 00:41:47 +00:00
|
|
|
iwl3945_rates[IWL_FIRST_OFDM_RATE].table_rs_index;
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
|
2008-01-24 18:38:38 +00:00
|
|
|
case IEEE80211_BAND_2GHZ:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RATE(priv, "Select B/G mode rate scale\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
/* If an OFDM rate is used, have it fall back to the
|
|
|
|
* 1M CCK rates */
|
|
|
|
|
2010-01-21 14:09:28 +00:00
|
|
|
if (!(priv->_3945.sta_supp_rates & IWL_OFDM_RATES_MASK) &&
|
2010-08-23 08:46:32 +00:00
|
|
|
iwl_is_associated(priv, IWL_RXON_CTX_BSS)) {
|
2008-12-05 15:58:37 +00:00
|
|
|
|
|
|
|
index = IWL_FIRST_CCK_RATE;
|
|
|
|
for (i = IWL_RATE_6M_INDEX_TABLE;
|
|
|
|
i <= IWL_RATE_54M_INDEX_TABLE; i++)
|
|
|
|
table[i].next_rate_index =
|
|
|
|
iwl3945_rates[index].table_rs_index;
|
|
|
|
|
|
|
|
index = IWL_RATE_11M_INDEX_TABLE;
|
|
|
|
/* CCK shouldn't fall back to OFDM... */
|
|
|
|
table[index].next_rate_index = IWL_RATE_5M_INDEX_TABLE;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2008-01-24 18:38:38 +00:00
|
|
|
WARN_ON(1);
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update the rate scaling for control frame Tx */
|
|
|
|
rate_cmd.table_id = 0;
|
2009-01-19 23:30:27 +00:00
|
|
|
rc = iwl_send_cmd_pdu(priv, REPLY_RATE_SCALE, sizeof(rate_cmd),
|
2007-09-26 00:54:57 +00:00
|
|
|
&rate_cmd);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* Update the rate scaling for data frame Tx */
|
|
|
|
rate_cmd.table_id = 1;
|
2009-01-19 23:30:27 +00:00
|
|
|
return iwl_send_cmd_pdu(priv, REPLY_RATE_SCALE, sizeof(rate_cmd),
|
2007-09-26 00:54:57 +00:00
|
|
|
&rate_cmd);
|
|
|
|
}
|
|
|
|
|
2007-11-29 03:09:45 +00:00
|
|
|
/* Called when initializing driver */
|
2008-12-19 02:37:28 +00:00
|
|
|
int iwl3945_hw_set_hw_params(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-12-19 02:37:26 +00:00
|
|
|
memset((void *)&priv->hw_params, 0,
|
|
|
|
sizeof(struct iwl_hw_params));
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2010-01-21 14:09:28 +00:00
|
|
|
priv->_3945.shared_virt =
|
|
|
|
dma_alloc_coherent(&priv->pci_dev->dev,
|
|
|
|
sizeof(struct iwl3945_shared),
|
|
|
|
&priv->_3945.shared_phys, GFP_KERNEL);
|
|
|
|
if (!priv->_3945.shared_virt) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "failed to allocate pci memory\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-03-18 04:51:48 +00:00
|
|
|
/* Assign number of Usable TX queues */
|
2010-10-06 15:10:00 +00:00
|
|
|
priv->hw_params.max_txq_num = priv->cfg->base_params->num_of_queues;
|
2009-03-18 04:51:48 +00:00
|
|
|
|
2009-01-23 21:45:14 +00:00
|
|
|
priv->hw_params.tfd_size = sizeof(struct iwl3945_tfd);
|
2009-10-09 09:19:45 +00:00
|
|
|
priv->hw_params.rx_page_order = get_order(IWL_RX_BUF_SIZE_3K);
|
2008-12-19 02:37:26 +00:00
|
|
|
priv->hw_params.max_rxq_size = RX_QUEUE_SIZE;
|
|
|
|
priv->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
|
|
|
|
priv->hw_params.max_stations = IWL3945_STATION_COUNT;
|
2010-08-27 15:53:46 +00:00
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].bcast_sta_id = IWL3945_BROADCAST_ID;
|
2008-02-13 19:32:31 +00:00
|
|
|
|
2010-08-23 08:46:43 +00:00
|
|
|
priv->sta_key_max_num = STA_KEY_MAX_NUM;
|
|
|
|
|
2009-01-08 18:19:53 +00:00
|
|
|
priv->hw_params.rx_wrt_ptr_reg = FH39_RSCSR_CHNL0_WPTR;
|
2009-06-19 20:52:45 +00:00
|
|
|
priv->hw_params.max_beacon_itrvl = IWL39_MAX_UCODE_BEACON_INTERVAL;
|
2010-05-06 15:54:10 +00:00
|
|
|
priv->hw_params.beacon_time_tsf_bits = IWL3945_EXT_BEACON_TIME_POS;
|
2009-01-08 18:19:53 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
unsigned int iwl3945_hw_get_beacon_cmd(struct iwl_priv *priv,
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_frame *frame, u8 rate)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-01-28 00:41:47 +00:00
|
|
|
struct iwl3945_tx_beacon_cmd *tx_beacon_cmd;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned int frame_size;
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
tx_beacon_cmd = (struct iwl3945_tx_beacon_cmd *)&frame->u;
|
2007-09-26 00:54:57 +00:00
|
|
|
memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
|
|
|
|
|
2010-08-27 15:53:46 +00:00
|
|
|
tx_beacon_cmd->tx.sta_id =
|
|
|
|
priv->contexts[IWL_RXON_CTX_BSS].bcast_sta_id;
|
2007-09-26 00:54:57 +00:00
|
|
|
tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
frame_size = iwl3945_fill_beacon_frame(priv,
|
2007-09-26 00:54:57 +00:00
|
|
|
tx_beacon_cmd->frame,
|
|
|
|
sizeof(frame->u) - sizeof(*tx_beacon_cmd));
|
|
|
|
|
|
|
|
BUG_ON(frame_size > MAX_MPDU_SIZE);
|
|
|
|
tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
|
|
|
|
|
|
|
|
tx_beacon_cmd->tx.rate = rate;
|
|
|
|
tx_beacon_cmd->tx.tx_flags = (TX_CMD_FLG_SEQ_CTL_MSK |
|
|
|
|
TX_CMD_FLG_TSF_MSK);
|
|
|
|
|
2007-11-12 03:37:42 +00:00
|
|
|
/* supp_rates[0] == OFDM start at IWL_FIRST_OFDM_RATE*/
|
|
|
|
tx_beacon_cmd->tx.supp_rates[0] =
|
|
|
|
(IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
tx_beacon_cmd->tx.supp_rates[1] =
|
2007-11-12 03:37:42 +00:00
|
|
|
(IWL_CCK_BASIC_RATES_MASK & 0xF);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-07-20 23:40:14 +00:00
|
|
|
return sizeof(struct iwl3945_tx_beacon_cmd) + frame_size;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
void iwl3945_hw_rx_handler_setup(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-07 01:36:55 +00:00
|
|
|
priv->rx_handlers[REPLY_TX] = iwl3945_rx_reply_tx;
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->rx_handlers[REPLY_3945_RX] = iwl3945_rx_reply_rx;
|
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
void iwl3945_hw_setup_deferred_work(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-01-21 14:09:28 +00:00
|
|
|
INIT_DELAYED_WORK(&priv->_3945.thermal_periodic,
|
2007-09-26 00:54:57 +00:00
|
|
|
iwl3945_bg_reg_txpower_periodic);
|
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:28 +00:00
|
|
|
void iwl3945_hw_cancel_deferred_work(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2010-01-21 14:09:28 +00:00
|
|
|
cancel_delayed_work(&priv->_3945.thermal_periodic);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:37 +00:00
|
|
|
/* check contents of special bootstrap uCode SRAM */
|
|
|
|
static int iwl3945_verify_bsm(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
__le32 *image = priv->ucode_boot.v_addr;
|
|
|
|
u32 len = priv->ucode_boot.len;
|
|
|
|
u32 reg;
|
|
|
|
u32 val;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Begin verify bsm\n");
|
2008-12-19 02:37:37 +00:00
|
|
|
|
|
|
|
/* verify BSM SRAM contents */
|
|
|
|
val = iwl_read_prph(priv, BSM_WR_DWCOUNT_REG);
|
|
|
|
for (reg = BSM_SRAM_LOWER_BOUND;
|
|
|
|
reg < BSM_SRAM_LOWER_BOUND + len;
|
|
|
|
reg += sizeof(u32), image++) {
|
|
|
|
val = iwl_read_prph(priv, reg);
|
|
|
|
if (val != le32_to_cpu(*image)) {
|
|
|
|
IWL_ERR(priv, "BSM uCode verification failed at "
|
|
|
|
"addr 0x%08X+%u (of %u), is 0x%x, s/b 0x%x\n",
|
|
|
|
BSM_SRAM_LOWER_BOUND,
|
|
|
|
reg - BSM_SRAM_LOWER_BOUND, len,
|
|
|
|
val, le32_to_cpu(*image));
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "BSM bootstrap uCode image OK\n");
|
2008-12-19 02:37:37 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-23 21:45:15 +00:00
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* EEPROM related functions
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear the OWNER_MSK, to establish driver (instead of uCode running on
|
|
|
|
* embedded controller) as EEPROM reader; each read is a series of pulses
|
|
|
|
* to/from the EEPROM chip, not a single event, so even reads could conflict
|
|
|
|
* if they weren't arbitrated by some ownership mechanism. Here, the driver
|
|
|
|
* simply claims ownership, which should be safe when this function is called
|
|
|
|
* (i.e. before loading uCode!).
|
|
|
|
*/
|
|
|
|
static int iwl3945_eeprom_acquire_semaphore(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
_iwl_clear_bit(priv, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void iwl3945_eeprom_release_semaphore(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-12-19 02:37:37 +00:00
|
|
|
/**
|
|
|
|
* iwl3945_load_bsm - Load bootstrap instructions
|
|
|
|
*
|
|
|
|
* BSM operation:
|
|
|
|
*
|
|
|
|
* The Bootstrap State Machine (BSM) stores a short bootstrap uCode program
|
|
|
|
* in special SRAM that does not power down during RFKILL. When powering back
|
|
|
|
* up after power-saving sleeps (or during initial uCode load), the BSM loads
|
|
|
|
* the bootstrap program into the on-board processor, and starts it.
|
|
|
|
*
|
|
|
|
* The bootstrap program loads (via DMA) instructions and data for a new
|
|
|
|
* program from host DRAM locations indicated by the host driver in the
|
|
|
|
* BSM_DRAM_* registers. Once the new program is loaded, it starts
|
|
|
|
* automatically.
|
|
|
|
*
|
|
|
|
* When initializing the NIC, the host driver points the BSM to the
|
|
|
|
* "initialize" uCode image. This uCode sets up some internal data, then
|
|
|
|
* notifies host via "initialize alive" that it is complete.
|
|
|
|
*
|
|
|
|
* The host then replaces the BSM_DRAM_* pointer values to point to the
|
|
|
|
* normal runtime uCode instructions and a backup uCode data cache buffer
|
|
|
|
* (filled initially with starting data values for the on-board processor),
|
|
|
|
* then triggers the "initialize" uCode to load and launch the runtime uCode,
|
|
|
|
* which begins normal operation.
|
|
|
|
*
|
|
|
|
* When doing a power-save shutdown, runtime uCode saves data SRAM into
|
|
|
|
* the backup data cache in DRAM before SRAM is powered down.
|
|
|
|
*
|
|
|
|
* When powering back up, the BSM loads the bootstrap program. This reloads
|
|
|
|
* the runtime uCode instructions and the backup data cache into SRAM,
|
|
|
|
* and re-launches the runtime uCode from where it left off.
|
|
|
|
*/
|
|
|
|
static int iwl3945_load_bsm(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
__le32 *image = priv->ucode_boot.v_addr;
|
|
|
|
u32 len = priv->ucode_boot.len;
|
|
|
|
dma_addr_t pinst;
|
|
|
|
dma_addr_t pdata;
|
|
|
|
u32 inst_len;
|
|
|
|
u32 data_len;
|
|
|
|
int rc;
|
|
|
|
int i;
|
|
|
|
u32 done;
|
|
|
|
u32 reg_offset;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Begin load bsm\n");
|
2008-12-19 02:37:37 +00:00
|
|
|
|
|
|
|
/* make sure bootstrap program is no larger than BSM's SRAM size */
|
|
|
|
if (len > IWL39_MAX_BSM_SIZE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Tell bootstrap uCode where to find the "Initialize" uCode
|
|
|
|
* in host DRAM ... host DRAM physical address bits 31:0 for 3945.
|
|
|
|
* NOTE: iwl3945_initialize_alive_start() will replace these values,
|
|
|
|
* after the "initialize" uCode has run, to point to
|
|
|
|
* runtime/protocol instructions and backup data cache. */
|
|
|
|
pinst = priv->ucode_init.p_addr;
|
|
|
|
pdata = priv->ucode_init_data.p_addr;
|
|
|
|
inst_len = priv->ucode_init.len;
|
|
|
|
data_len = priv->ucode_init_data.len;
|
|
|
|
|
|
|
|
iwl_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
|
|
|
|
iwl_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
|
|
|
|
iwl_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG, inst_len);
|
|
|
|
iwl_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG, data_len);
|
|
|
|
|
|
|
|
/* Fill BSM memory with bootstrap instructions */
|
|
|
|
for (reg_offset = BSM_SRAM_LOWER_BOUND;
|
|
|
|
reg_offset < BSM_SRAM_LOWER_BOUND + len;
|
|
|
|
reg_offset += sizeof(u32), image++)
|
|
|
|
_iwl_write_prph(priv, reg_offset,
|
|
|
|
le32_to_cpu(*image));
|
|
|
|
|
|
|
|
rc = iwl3945_verify_bsm(priv);
|
2009-05-22 18:01:47 +00:00
|
|
|
if (rc)
|
2008-12-19 02:37:37 +00:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
|
|
|
|
iwl_write_prph(priv, BSM_WR_MEM_SRC_REG, 0x0);
|
|
|
|
iwl_write_prph(priv, BSM_WR_MEM_DST_REG,
|
|
|
|
IWL39_RTC_INST_LOWER_BOUND);
|
|
|
|
iwl_write_prph(priv, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
|
|
|
|
|
|
|
|
/* Load bootstrap code into instruction SRAM now,
|
|
|
|
* to prepare to load "initialize" uCode */
|
|
|
|
iwl_write_prph(priv, BSM_WR_CTRL_REG,
|
|
|
|
BSM_WR_CTRL_REG_BIT_START);
|
|
|
|
|
|
|
|
/* Wait for load of bootstrap uCode to finish */
|
|
|
|
for (i = 0; i < 100; i++) {
|
|
|
|
done = iwl_read_prph(priv, BSM_WR_CTRL_REG);
|
|
|
|
if (!(done & BSM_WR_CTRL_REG_BIT_START))
|
|
|
|
break;
|
|
|
|
udelay(10);
|
|
|
|
}
|
|
|
|
if (i < 100)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "BSM write complete, poll %d iterations\n", i);
|
2008-12-19 02:37:37 +00:00
|
|
|
else {
|
|
|
|
IWL_ERR(priv, "BSM write did not complete!\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable future boot loads whenever power management unit triggers it
|
|
|
|
* (e.g. when powering back up after power-save shutdown) */
|
|
|
|
iwl_write_prph(priv, BSM_WR_CTRL_REG,
|
|
|
|
BSM_WR_CTRL_REG_BIT_START_EN);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-04-08 18:26:35 +00:00
|
|
|
static struct iwl_hcmd_ops iwl3945_hcmd = {
|
|
|
|
.rxon_assoc = iwl3945_send_rxon_assoc,
|
2009-04-08 18:26:37 +00:00
|
|
|
.commit_rxon = iwl3945_commit_rxon,
|
2010-04-13 08:04:31 +00:00
|
|
|
.send_bt_config = iwl_send_bt_config,
|
2009-04-08 18:26:35 +00:00
|
|
|
};
|
|
|
|
|
2008-12-19 02:37:37 +00:00
|
|
|
static struct iwl_lib_ops iwl3945_lib = {
|
2009-01-19 23:30:26 +00:00
|
|
|
.txq_attach_buf_to_tfd = iwl3945_hw_txq_attach_buf_to_tfd,
|
|
|
|
.txq_free_tfd = iwl3945_hw_txq_free_tfd,
|
2009-01-23 21:45:14 +00:00
|
|
|
.txq_init = iwl3945_hw_tx_queue_init,
|
2008-12-19 02:37:37 +00:00
|
|
|
.load_ucode = iwl3945_load_bsm,
|
2009-09-25 21:24:23 +00:00
|
|
|
.dump_nic_event_log = iwl3945_dump_nic_event_log,
|
|
|
|
.dump_nic_error_log = iwl3945_dump_nic_error_log,
|
2008-12-19 02:37:38 +00:00
|
|
|
.apm_ops = {
|
|
|
|
.init = iwl3945_apm_init,
|
|
|
|
.config = iwl3945_nic_config,
|
|
|
|
},
|
2009-01-23 21:45:15 +00:00
|
|
|
.eeprom_ops = {
|
|
|
|
.regulatory_bands = {
|
|
|
|
EEPROM_REGULATORY_BAND_1_CHANNELS,
|
|
|
|
EEPROM_REGULATORY_BAND_2_CHANNELS,
|
|
|
|
EEPROM_REGULATORY_BAND_3_CHANNELS,
|
|
|
|
EEPROM_REGULATORY_BAND_4_CHANNELS,
|
|
|
|
EEPROM_REGULATORY_BAND_5_CHANNELS,
|
2009-08-07 22:41:38 +00:00
|
|
|
EEPROM_REGULATORY_BAND_NO_HT40,
|
|
|
|
EEPROM_REGULATORY_BAND_NO_HT40,
|
2009-01-23 21:45:15 +00:00
|
|
|
},
|
|
|
|
.acquire_semaphore = iwl3945_eeprom_acquire_semaphore,
|
|
|
|
.release_semaphore = iwl3945_eeprom_release_semaphore,
|
|
|
|
.query_addr = iwlcore_eeprom_query_addr,
|
|
|
|
},
|
2009-01-23 21:45:11 +00:00
|
|
|
.send_tx_power = iwl3945_send_tx_power,
|
2009-02-24 02:43:30 +00:00
|
|
|
.is_valid_rtc_data_addr = iwl3945_hw_valid_rtc_data_addr,
|
2010-11-10 17:56:40 +00:00
|
|
|
.isr_ops = {
|
|
|
|
.isr = iwl_isr_legacy,
|
|
|
|
},
|
2010-05-20 17:54:40 +00:00
|
|
|
.recover_from_tx_stall = iwl_bg_monitor_recover,
|
2010-04-28 22:47:04 +00:00
|
|
|
.check_plcp_health = iwl3945_good_plcp_health,
|
2010-04-16 17:03:54 +00:00
|
|
|
|
|
|
|
.debugfs_ops = {
|
|
|
|
.rx_stats_read = iwl3945_ucode_rx_stats_read,
|
|
|
|
.tx_stats_read = iwl3945_ucode_tx_stats_read,
|
|
|
|
.general_stats_read = iwl3945_ucode_general_stats_read,
|
|
|
|
},
|
2008-12-19 02:37:37 +00:00
|
|
|
};
|
|
|
|
|
2010-10-23 16:15:41 +00:00
|
|
|
static const struct iwl_legacy_ops iwl3945_legacy_ops = {
|
|
|
|
.post_associate = iwl3945_post_associate,
|
|
|
|
.config_ap = iwl3945_config_ap,
|
|
|
|
.manage_ibss_station = iwl3945_manage_ibss_station,
|
|
|
|
};
|
|
|
|
|
2008-12-22 03:31:15 +00:00
|
|
|
static struct iwl_hcmd_utils_ops iwl3945_hcmd_utils = {
|
|
|
|
.get_hcmd_size = iwl3945_get_hcmd_size,
|
2009-01-23 21:45:20 +00:00
|
|
|
.build_addsta_hcmd = iwl3945_build_addsta_hcmd,
|
2010-11-10 17:56:41 +00:00
|
|
|
.tx_cmd_protection = iwl_legacy_tx_cmd_protection,
|
2010-04-06 11:12:42 +00:00
|
|
|
.request_scan = iwl3945_request_scan,
|
2010-09-22 16:01:56 +00:00
|
|
|
.post_scan = iwl3945_post_scan,
|
2008-12-22 03:31:15 +00:00
|
|
|
};
|
|
|
|
|
2009-12-13 23:59:53 +00:00
|
|
|
static const struct iwl_ops iwl3945_ops = {
|
2008-12-19 02:37:37 +00:00
|
|
|
.lib = &iwl3945_lib,
|
2009-04-08 18:26:35 +00:00
|
|
|
.hcmd = &iwl3945_hcmd,
|
2008-12-22 03:31:15 +00:00
|
|
|
.utils = &iwl3945_hcmd_utils,
|
2009-10-02 20:44:03 +00:00
|
|
|
.led = &iwl3945_led_ops,
|
2010-10-23 16:15:41 +00:00
|
|
|
.legacy = &iwl3945_legacy_ops,
|
2010-10-23 16:15:39 +00:00
|
|
|
.ieee80211_ops = &iwl3945_hw_ops,
|
2008-12-19 02:37:37 +00:00
|
|
|
};
|
|
|
|
|
2010-10-06 15:10:00 +00:00
|
|
|
static struct iwl_base_params iwl3945_base_params = {
|
2009-01-23 21:45:15 +00:00
|
|
|
.eeprom_size = IWL3945_EEPROM_IMG_SIZE,
|
2010-10-12 09:26:13 +00:00
|
|
|
.num_of_queues = IWL39_NUM_QUEUES,
|
2009-10-23 20:42:21 +00:00
|
|
|
.pll_cfg_val = CSR39_ANA_PLL_CFG_VAL,
|
|
|
|
.set_l0s = false,
|
|
|
|
.use_bsm = true,
|
2009-08-13 20:30:59 +00:00
|
|
|
.use_isr_legacy = true,
|
2009-09-11 17:38:14 +00:00
|
|
|
.led_compensation = 64,
|
2009-12-14 22:12:10 +00:00
|
|
|
.broken_powersave = true,
|
2010-04-28 22:47:04 +00:00
|
|
|
.plcp_delta_threshold = IWL_MAX_PLCP_ERR_LONG_THRESHOLD_DEF,
|
2010-07-23 20:19:39 +00:00
|
|
|
.monitor_recover_period = IWL_DEF_MONITORING_PERIOD,
|
2010-03-26 19:54:37 +00:00
|
|
|
.max_event_log_size = 512,
|
2010-04-27 21:33:33 +00:00
|
|
|
.tx_power_by_driver = true,
|
2008-03-05 02:09:30 +00:00
|
|
|
};
|
|
|
|
|
2010-10-06 15:10:00 +00:00
|
|
|
static struct iwl_cfg iwl3945_bg_cfg = {
|
|
|
|
.name = "3945BG",
|
|
|
|
.fw_name_pre = IWL3945_FW_PRE,
|
|
|
|
.ucode_api_max = IWL3945_UCODE_API_MAX,
|
|
|
|
.ucode_api_min = IWL3945_UCODE_API_MIN,
|
|
|
|
.sku = IWL_SKU_G,
|
|
|
|
.eeprom_ver = EEPROM_3945_EEPROM_VERSION,
|
|
|
|
.ops = &iwl3945_ops,
|
|
|
|
.mod_params = &iwl3945_mod_params,
|
|
|
|
.base_params = &iwl3945_base_params,
|
2010-11-09 17:21:34 +00:00
|
|
|
.led_mode = IWL_LED_BLINK,
|
2010-10-06 15:10:00 +00:00
|
|
|
};
|
|
|
|
|
2008-12-19 02:37:19 +00:00
|
|
|
static struct iwl_cfg iwl3945_abg_cfg = {
|
2008-03-05 02:09:30 +00:00
|
|
|
.name = "3945ABG",
|
2008-12-02 20:14:06 +00:00
|
|
|
.fw_name_pre = IWL3945_FW_PRE,
|
|
|
|
.ucode_api_max = IWL3945_UCODE_API_MAX,
|
|
|
|
.ucode_api_min = IWL3945_UCODE_API_MIN,
|
2008-03-05 02:09:30 +00:00
|
|
|
.sku = IWL_SKU_A|IWL_SKU_G,
|
2009-01-23 21:45:15 +00:00
|
|
|
.eeprom_ver = EEPROM_3945_EEPROM_VERSION,
|
2008-12-19 02:37:37 +00:00
|
|
|
.ops = &iwl3945_ops,
|
2009-05-22 18:01:50 +00:00
|
|
|
.mod_params = &iwl3945_mod_params,
|
2010-10-06 15:10:00 +00:00
|
|
|
.base_params = &iwl3945_base_params,
|
2010-11-09 17:21:34 +00:00
|
|
|
.led_mode = IWL_LED_BLINK,
|
2008-03-05 02:09:30 +00:00
|
|
|
};
|
|
|
|
|
2010-01-07 11:58:11 +00:00
|
|
|
DEFINE_PCI_DEVICE_TABLE(iwl3945_hw_card_ids) = {
|
2008-03-05 02:09:30 +00:00
|
|
|
{IWL_PCI_DEVICE(0x4222, 0x1005, iwl3945_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4222, 0x1034, iwl3945_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4222, 0x1044, iwl3945_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4227, 0x1014, iwl3945_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4222, PCI_ANY_ID, iwl3945_abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4227, PCI_ANY_ID, iwl3945_abg_cfg)},
|
2007-09-26 00:54:57 +00:00
|
|
|
{0}
|
|
|
|
};
|
|
|
|
|
2008-01-28 00:41:47 +00:00
|
|
|
MODULE_DEVICE_TABLE(pci, iwl3945_hw_card_ids);
|