projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] ipw2200: wireless extension sensitivity threshold support
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / wireless / ipw2200.c
CommitLineData
43f66a6c 1/******************************************************************************
bf79451e 2
afbf30a2 3 Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
43f66a6c
JK		 4
5 802.11 status code portion of this file from ethereal-0.10.6:
6 Copyright 2000, Axis Communications AB
7 Ethereal - Network traffic analyzer
8 By Gerald Combs <gerald@ethereal.com>
9 Copyright 1998 Gerald Combs
10
bf79451e
JG		 11 This program is free software; you can redistribute it and/or modify it
12 under the terms of version 2 of the GNU General Public License as
43f66a6c 13 published by the Free Software Foundation.
bf79451e
JG		 14
15 This program is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
43f66a6c 18 more details.
bf79451e 19
43f66a6c 20 You should have received a copy of the GNU General Public License along with
bf79451e 21 this program; if not, write to the Free Software Foundation, Inc., 59
43f66a6c 22 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
bf79451e 23
43f66a6c
JK		 24 The full GNU General Public License is included in this distribution in the
25 file called LICENSE.
bf79451e 26
43f66a6c
JK		 27 Contact Information:
28 James P. Ketrenos <ipw2100-admin@linux.intel.com>
29 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30
31******************************************************************************/
32
33#include "ipw2200.h"
733482e4 34#include <linux/version.h>
43f66a6c 35
7c97eb3f 36#define IPW2200_VERSION "git-1.0.10"
43f66a6c 37#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
2b184d5b 38#define DRV_COPYRIGHT "Copyright(c) 2003-2005 Intel Corporation"
43f66a6c
JK		 39#define DRV_VERSION IPW2200_VERSION
40
b095c381
JK		 41#define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
42
43f66a6c
JK		 43MODULE_DESCRIPTION(DRV_DESCRIPTION);
44MODULE_VERSION(DRV_VERSION);
45MODULE_AUTHOR(DRV_COPYRIGHT);
46MODULE_LICENSE("GPL");
47
f6c5cb7c 48static int cmdlog = 0;
43f66a6c
JK		 49static int debug = 0;
50static int channel = 0;
43f66a6c
JK		 51static int mode = 0;
52
53static u32 ipw_debug_level;
54static int associate = 1;
55static int auto_create = 1;
a613bffd 56static int led = 0;
43f66a6c 57static int disable = 0;
810dabd4 58static int bt_coexist = 0;
bde37d03 59static int hwcrypto = 0;
4bfdb91d 60static int roaming = 1;
43f66a6c
JK		 61static const char ipw_modes[] = {
62 'a', 'b', 'g', '?'
63};
64
b095c381
JK		 65#ifdef CONFIG_IPW_QOS
66static int qos_enable = 0;
67static int qos_burst_enable = 0;
68static int qos_no_ack_mask = 0;
69static int burst_duration_CCK = 0;
70static int burst_duration_OFDM = 0;
71
72static struct ieee80211_qos_parameters def_qos_parameters_OFDM = {
73 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
74 QOS_TX3_CW_MIN_OFDM},
75 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
76 QOS_TX3_CW_MAX_OFDM},
77 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
78 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
79 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
80 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
81};
82
83static struct ieee80211_qos_parameters def_qos_parameters_CCK = {
84 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
85 QOS_TX3_CW_MIN_CCK},
86 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
87 QOS_TX3_CW_MAX_CCK},
88 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
89 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
90 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
91 QOS_TX3_TXOP_LIMIT_CCK}
92};
93
94static struct ieee80211_qos_parameters def_parameters_OFDM = {
95 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
96 DEF_TX3_CW_MIN_OFDM},
97 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
98 DEF_TX3_CW_MAX_OFDM},
99 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
100 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
101 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
102 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
103};
104
105static struct ieee80211_qos_parameters def_parameters_CCK = {
106 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
107 DEF_TX3_CW_MIN_CCK},
108 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
109 DEF_TX3_CW_MAX_CCK},
110 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
111 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
112 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
113 DEF_TX3_TXOP_LIMIT_CCK}
114};
115
116static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
117
118static int from_priority_to_tx_queue[] = {
119 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
120 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
121};
122
123static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
124
125static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
126 *qos_param);
127static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
128 *qos_param);
129#endif /* CONFIG_IPW_QOS */
130
97a78ca9 131static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
b095c381 132static void ipw_remove_current_network(struct ipw_priv *priv);
43f66a6c 133static void ipw_rx(struct ipw_priv *priv);
bf79451e 134static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
43f66a6c
JK		 135 struct clx2_tx_queue *txq, int qindex);
136static int ipw_queue_reset(struct ipw_priv *priv);
137
138static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
139 int len, int sync);
140
141static void ipw_tx_queue_free(struct ipw_priv *);
142
143static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
144static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
145static void ipw_rx_queue_replenish(void *);
43f66a6c 146static int ipw_up(struct ipw_priv *);
c848d0af 147static void ipw_bg_up(void *);
43f66a6c 148static void ipw_down(struct ipw_priv *);
c848d0af 149static void ipw_bg_down(void *);
43f66a6c 150static int ipw_config(struct ipw_priv *);
0edd5b44
JG		 151static int init_supported_rates(struct ipw_priv *priv,
152 struct ipw_supported_rates *prates);
b095c381
JK		 153static void ipw_set_hwcrypto_keys(struct ipw_priv *);
154static void ipw_send_wep_keys(struct ipw_priv *, int);
43f66a6c 155
f6c5cb7c
JK		 156static int snprint_line(char *buf, size_t count,
157 const u8 * data, u32 len, u32 ofs)
43f66a6c
JK		 158{
159 int out, i, j, l;
160 char c;
bf79451e 161
43f66a6c
JK		 162 out = snprintf(buf, count, "%08X", ofs);
163
164 for (l = 0, i = 0; i < 2; i++) {
165 out += snprintf(buf + out, count - out, " ");
bf79451e
JG		 166 for (j = 0; j < 8 && l < len; j++, l++)
167 out += snprintf(buf + out, count - out, "%02X ",
43f66a6c
JK		 168 data[(i * 8 + j)]);
169 for (; j < 8; j++)
170 out += snprintf(buf + out, count - out, " ");
171 }
bf79451e 172
43f66a6c
JK		 173 out += snprintf(buf + out, count - out, " ");
174 for (l = 0, i = 0; i < 2; i++) {
175 out += snprintf(buf + out, count - out, " ");
176 for (j = 0; j < 8 && l < len; j++, l++) {
177 c = data[(i * 8 + j)];
178 if (!isascii(c) || !isprint(c))
179 c = '.';
bf79451e 180
43f66a6c
JK		 181 out += snprintf(buf + out, count - out, "%c", c);
182 }
183
184 for (; j < 8; j++)
185 out += snprintf(buf + out, count - out, " ");
186 }
bf79451e 187
f6c5cb7c 188 return out;
43f66a6c
JK		 189}
190
0edd5b44 191static void printk_buf(int level, const u8 * data, u32 len)
43f66a6c
JK		 192{
193 char line[81];
194 u32 ofs = 0;
195 if (!(ipw_debug_level & level))
196 return;
197
198 while (len) {
f6c5cb7c
JK		 199 snprint_line(line, sizeof(line), &data[ofs],
200 min(len, 16U), ofs);
201 printk(KERN_DEBUG "%s\n", line);
43f66a6c
JK		 202 ofs += 16;
203 len -= min(len, 16U);
204 }
205}
206
f6c5cb7c
JK		 207static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
208{
209 size_t out = size;
210 u32 ofs = 0;
211 int total = 0;
212
213 while (size && len) {
214 out = snprint_line(output, size, &data[ofs],
215 min_t(size_t, len, 16U), ofs);
216
217 ofs += 16;
218 output += out;
219 size -= out;
220 len -= min_t(size_t, len, 16U);
221 total += out;
222 }
223 return total;
224}
225
c8fe6679 226/* alias for 32-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 227static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
228#define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
229
c8fe6679 230/* alias for 8-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 231static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
232#define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
233
c8fe6679 234/* 8-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 235static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
236static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
237{
0edd5b44
JG		 238 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
239 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 240 _ipw_write_reg8(a, b, c);
241}
242
c8fe6679 243/* 16-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 244static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
245static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
246{
0edd5b44
JG		 247 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
248 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 249 _ipw_write_reg16(a, b, c);
250}
251
c8fe6679 252/* 32-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 253static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
254static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
255{
0edd5b44
JG		 256 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
257 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 258 _ipw_write_reg32(a, b, c);
259}
260
c8fe6679 261/* 8-bit direct write (low 4K) */
43f66a6c 262#define _ipw_write8(ipw, ofs, val) writeb((val), (ipw)->hw_base + (ofs))
c8fe6679
ZY		 263
264/* 8-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
43f66a6c
JK		 265#define ipw_write8(ipw, ofs, val) \
266 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
267 _ipw_write8(ipw, ofs, val)
268
c8fe6679 269/* 16-bit direct write (low 4K) */
43f66a6c 270#define _ipw_write16(ipw, ofs, val) writew((val), (ipw)->hw_base + (ofs))
c8fe6679
ZY		 271
272/* 16-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
43f66a6c
JK		 273#define ipw_write16(ipw, ofs, val) \
274 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
275 _ipw_write16(ipw, ofs, val)
276
c8fe6679 277/* 32-bit direct write (low 4K) */
43f66a6c 278#define _ipw_write32(ipw, ofs, val) writel((val), (ipw)->hw_base + (ofs))
c8fe6679
ZY		 279
280/* 32-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
43f66a6c
JK		 281#define ipw_write32(ipw, ofs, val) \
282 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
283 _ipw_write32(ipw, ofs, val)
284
c8fe6679 285/* 8-bit direct read (low 4K) */
43f66a6c 286#define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
c8fe6679
ZY		 287
288/* 8-bit direct read (low 4K), with debug wrapper */
0edd5b44
JG		 289static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
290{
291 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
43f66a6c
JK		 292 return _ipw_read8(ipw, ofs);
293}
0edd5b44 294
c8fe6679 295/* alias to 8-bit direct read (low 4K of SRAM/regs), with debug wrapper */
43f66a6c
JK		 296#define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)
297
c8fe6679 298/* 16-bit direct read (low 4K) */
43f66a6c 299#define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
c8fe6679
ZY		 300
301/* 16-bit direct read (low 4K), with debug wrapper */
0edd5b44
JG		 302static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
303{
304 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
43f66a6c
JK		 305 return _ipw_read16(ipw, ofs);
306}
0edd5b44 307
c8fe6679 308/* alias to 16-bit direct read (low 4K of SRAM/regs), with debug wrapper */
43f66a6c
JK		 309#define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)
310
c8fe6679 311/* 32-bit direct read (low 4K) */
43f66a6c 312#define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
c8fe6679
ZY		 313
314/* 32-bit direct read (low 4K), with debug wrapper */
0edd5b44
JG		 315static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
316{
317 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
43f66a6c
JK		 318 return _ipw_read32(ipw, ofs);
319}
0edd5b44 320
c8fe6679 321/* alias to 32-bit direct read (low 4K of SRAM/regs), with debug wrapper */
43f66a6c
JK		 322#define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
323
c8fe6679 324/* multi-byte read (above 4K), with debug wrapper */
43f66a6c 325static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
f6c5cb7c
JK		 326static inline void __ipw_read_indirect(const char *f, int l,
327 struct ipw_priv *a, u32 b, u8 * c, int d)
328{
329 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
330 d);
331 _ipw_read_indirect(a, b, c, d);
332}
333
c8fe6679 334/* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
f6c5cb7c 335#define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
43f66a6c 336
c8fe6679 337/* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
0edd5b44
JG		 338static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
339 int num);
43f66a6c
JK		 340#define ipw_write_indirect(a, b, c, d) \
341 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
afbf30a2 342 _ipw_write_indirect(a, b, c, d)
43f66a6c 343
c8fe6679 344/* 32-bit indirect write (above 4K) */
0edd5b44 345static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
43f66a6c 346{
0edd5b44 347 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
b095c381
JK		 348 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
349 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
43f66a6c
JK		 350}
351
c8fe6679 352/* 8-bit indirect write (above 4K) */
43f66a6c
JK		 353static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
354{
2638bc39 355 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
c8fe6679
ZY		 356 u32 dif_len = reg - aligned_addr;
357
43f66a6c 358 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
c8fe6679
ZY		 359 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
360 _ipw_write8(priv, IPW_INDIRECT_DATA + dif_len, value);
43f66a6c
JK		 361}
362
c8fe6679 363/* 16-bit indirect write (above 4K) */
0edd5b44 364static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
43f66a6c 365{
2638bc39 366 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
c8fe6679
ZY		 367 u32 dif_len = (reg - aligned_addr) & (~0x1ul);
368
43f66a6c 369 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
c8fe6679
ZY		 370 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
371 _ipw_write16(priv, IPW_INDIRECT_DATA + dif_len, value);
43f66a6c
JK		 372}
373
c8fe6679 374/* 8-bit indirect read (above 4K) */
43f66a6c
JK		 375static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
376{
377 u32 word;
b095c381 378 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
43f66a6c 379 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
b095c381 380 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
0edd5b44 381 return (word >> ((reg & 0x3) * 8)) & 0xff;
43f66a6c
JK		 382}
383
c8fe6679 384/* 32-bit indirect read (above 4K) */
43f66a6c
JK		 385static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
386{
387 u32 value;
388
389 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
390
b095c381
JK		 391 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
392 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
43f66a6c
JK		 393 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
394 return value;
395}
396
c8fe6679
ZY		 397/* General purpose, no alignment requirement, iterative (multi-byte) read, */
398/* for area above 1st 4K of SRAM/reg space */
43f66a6c
JK		 399static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
400 int num)
401{
2638bc39 402 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
43f66a6c 403 u32 dif_len = addr - aligned_addr;
43f66a6c 404 u32 i;
bf79451e 405
43f66a6c
JK		 406 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
407
ea2b26e0
JK		 408 if (num <= 0) {
409 return;
410 }
411
c8fe6679 412 /* Read the first dword (or portion) byte by byte */
43f66a6c 413 if (unlikely(dif_len)) {
b095c381 414 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
43f66a6c 415 /* Start reading at aligned_addr + dif_len */
ea2b26e0 416 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
b095c381 417 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
43f66a6c
JK		 418 aligned_addr += 4;
419 }
420
c8fe6679 421 /* Read all of the middle dwords as dwords, with auto-increment */
b095c381 422 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
ea2b26e0 423 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
b095c381 424 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
bf79451e 425
c8fe6679 426 /* Read the last dword (or portion) byte by byte */
ea2b26e0 427 if (unlikely(num)) {
b095c381 428 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0 429 for (i = 0; num > 0; i++, num--)
b095c381 430 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
ea2b26e0 431 }
43f66a6c
JK		 432}
433
c8fe6679
ZY		 434/* General purpose, no alignment requirement, iterative (multi-byte) write, */
435/* for area above 1st 4K of SRAM/reg space */
0edd5b44 436static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
43f66a6c
JK		 437 int num)
438{
2638bc39 439 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
43f66a6c 440 u32 dif_len = addr - aligned_addr;
43f66a6c 441 u32 i;
bf79451e 442
43f66a6c 443 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
bf79451e 444
ea2b26e0
JK		 445 if (num <= 0) {
446 return;
447 }
448
c8fe6679 449 /* Write the first dword (or portion) byte by byte */
43f66a6c 450 if (unlikely(dif_len)) {
b095c381 451 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
c8fe6679 452 /* Start writing at aligned_addr + dif_len */
ea2b26e0 453 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
b095c381 454 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
43f66a6c
JK		 455 aligned_addr += 4;
456 }
bf79451e 457
c8fe6679 458 /* Write all of the middle dwords as dwords, with auto-increment */
b095c381 459 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
ea2b26e0 460 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
b095c381 461 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
bf79451e 462
c8fe6679 463 /* Write the last dword (or portion) byte by byte */
ea2b26e0 464 if (unlikely(num)) {
b095c381 465 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0 466 for (i = 0; num > 0; i++, num--, buf++)
b095c381 467 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
ea2b26e0 468 }
43f66a6c
JK		 469}
470
c8fe6679
ZY		 471/* General purpose, no alignment requirement, iterative (multi-byte) write, */
472/* for 1st 4K of SRAM/regs space */
bf79451e 473static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
43f66a6c
JK		 474 int num)
475{
476 memcpy_toio((priv->hw_base + addr), buf, num);
477}
478
c8fe6679 479/* Set bit(s) in low 4K of SRAM/regs */
43f66a6c
JK		 480static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
481{
482 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
483}
484
c8fe6679 485/* Clear bit(s) in low 4K of SRAM/regs */
43f66a6c
JK		 486static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
487{
488 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
489}
490
491static inline void ipw_enable_interrupts(struct ipw_priv *priv)
492{
493 if (priv->status & STATUS_INT_ENABLED)
494 return;
495 priv->status |= STATUS_INT_ENABLED;
b095c381 496 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
43f66a6c
JK		 497}
498
499static inline void ipw_disable_interrupts(struct ipw_priv *priv)
500{
501 if (!(priv->status & STATUS_INT_ENABLED))
502 return;
503 priv->status &= ~STATUS_INT_ENABLED;
b095c381 504 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
43f66a6c
JK		 505}
506
0f52bf90 507#ifdef CONFIG_IPW2200_DEBUG
43f66a6c
JK		 508static char *ipw_error_desc(u32 val)
509{
510 switch (val) {
bf79451e 511 case IPW_FW_ERROR_OK:
43f66a6c 512 return "ERROR_OK";
bf79451e 513 case IPW_FW_ERROR_FAIL:
43f66a6c 514 return "ERROR_FAIL";
bf79451e 515 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
43f66a6c 516 return "MEMORY_UNDERFLOW";
bf79451e 517 case IPW_FW_ERROR_MEMORY_OVERFLOW:
43f66a6c 518 return "MEMORY_OVERFLOW";
bf79451e 519 case IPW_FW_ERROR_BAD_PARAM:
b095c381 520 return "BAD_PARAM";
bf79451e 521 case IPW_FW_ERROR_BAD_CHECKSUM:
b095c381 522 return "BAD_CHECKSUM";
bf79451e 523 case IPW_FW_ERROR_NMI_INTERRUPT:
b095c381 524 return "NMI_INTERRUPT";
bf79451e 525 case IPW_FW_ERROR_BAD_DATABASE:
b095c381 526 return "BAD_DATABASE";
bf79451e 527 case IPW_FW_ERROR_ALLOC_FAIL:
b095c381 528 return "ALLOC_FAIL";
bf79451e 529 case IPW_FW_ERROR_DMA_UNDERRUN:
b095c381 530 return "DMA_UNDERRUN";
bf79451e 531 case IPW_FW_ERROR_DMA_STATUS:
b095c381
JK		 532 return "DMA_STATUS";
533 case IPW_FW_ERROR_DINO_ERROR:
534 return "DINO_ERROR";
535 case IPW_FW_ERROR_EEPROM_ERROR:
536 return "EEPROM_ERROR";
bf79451e 537 case IPW_FW_ERROR_SYSASSERT:
b095c381 538 return "SYSASSERT";
bf79451e 539 case IPW_FW_ERROR_FATAL_ERROR:
b095c381 540 return "FATAL_ERROR";
bf79451e 541 default:
b095c381 542 return "UNKNOWN_ERROR";
43f66a6c
JK		 543 }
544}
545
b39860c6
JK		 546static void ipw_dump_error_log(struct ipw_priv *priv,
547 struct ipw_fw_error *error)
43f66a6c 548{
b39860c6 549 u32 i;
bf79451e 550
b39860c6
JK		 551 if (!error) {
552 IPW_ERROR("Error allocating and capturing error log. "
553 "Nothing to dump.\n");
554 return;
43f66a6c
JK		 555 }
556
b39860c6
JK		 557 IPW_ERROR("Start IPW Error Log Dump:\n");
558 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
559 error->status, error->config);
43f66a6c 560
b39860c6 561 for (i = 0; i < error->elem_len; i++)
0edd5b44 562 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
b39860c6
JK		 563 ipw_error_desc(error->elem[i].desc),
564 error->elem[i].time,
565 error->elem[i].blink1,
566 error->elem[i].blink2,
567 error->elem[i].link1,
568 error->elem[i].link2, error->elem[i].data);
569 for (i = 0; i < error->log_len; i++)
570 IPW_ERROR("%i\t0x%08x\t%i\n",
571 error->log[i].time,
286568ab 572 error->log[i].data, error->log[i].event);
43f66a6c 573}
43f66a6c 574#endif
43f66a6c 575
c848d0af 576static inline int ipw_is_init(struct ipw_priv *priv)
43f66a6c 577{
c848d0af 578 return (priv->status & STATUS_INIT) ? 1 : 0;
43f66a6c
JK		 579}
580
0edd5b44 581static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
43f66a6c
JK		 582{
583 u32 addr, field_info, field_len, field_count, total_len;
584
585 IPW_DEBUG_ORD("ordinal = %i\n", ord);
586
587 if (!priv || !val || !len) {
588 IPW_DEBUG_ORD("Invalid argument\n");
589 return -EINVAL;
590 }
bf79451e 591
43f66a6c
JK		 592 /* verify device ordinal tables have been initialized */
593 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
594 IPW_DEBUG_ORD("Access ordinals before initialization\n");
595 return -EINVAL;
596 }
597
598 switch (IPW_ORD_TABLE_ID_MASK & ord) {
599 case IPW_ORD_TABLE_0_MASK:
600 /*
601 * TABLE 0: Direct access to a table of 32 bit values
602 *
bf79451e 603 * This is a very simple table with the data directly
43f66a6c
JK		 604 * read from the table
605 */
606
607 /* remove the table id from the ordinal */
608 ord &= IPW_ORD_TABLE_VALUE_MASK;
609
610 /* boundary check */
611 if (ord > priv->table0_len) {
612 IPW_DEBUG_ORD("ordinal value (%i) longer then "
613 "max (%i)\n", ord, priv->table0_len);
614 return -EINVAL;
615 }
616
617 /* verify we have enough room to store the value */
618 if (*len < sizeof(u32)) {
619 IPW_DEBUG_ORD("ordinal buffer length too small, "
aaa4d308 620 "need %zd\n", sizeof(u32));
43f66a6c
JK		 621 return -EINVAL;
622 }
623
624 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
0edd5b44 625 ord, priv->table0_addr + (ord << 2));
43f66a6c
JK		 626
627 *len = sizeof(u32);
628 ord <<= 2;
0edd5b44 629 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
43f66a6c
JK		 630 break;
631
632 case IPW_ORD_TABLE_1_MASK:
633 /*
634 * TABLE 1: Indirect access to a table of 32 bit values
bf79451e
JG		 635 *
636 * This is a fairly large table of u32 values each
43f66a6c
JK		 637 * representing starting addr for the data (which is
638 * also a u32)
639 */
640
641 /* remove the table id from the ordinal */
642 ord &= IPW_ORD_TABLE_VALUE_MASK;
bf79451e 643
43f66a6c
JK		 644 /* boundary check */
645 if (ord > priv->table1_len) {
646 IPW_DEBUG_ORD("ordinal value too long\n");
647 return -EINVAL;
648 }
649
650 /* verify we have enough room to store the value */
651 if (*len < sizeof(u32)) {
652 IPW_DEBUG_ORD("ordinal buffer length too small, "
aaa4d308 653 "need %zd\n", sizeof(u32));
43f66a6c
JK		 654 return -EINVAL;
655 }
656
0edd5b44
JG		 657 *((u32 *) val) =
658 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
43f66a6c
JK		 659 *len = sizeof(u32);
660 break;
661
662 case IPW_ORD_TABLE_2_MASK:
663 /*
664 * TABLE 2: Indirect access to a table of variable sized values
665 *
666 * This table consist of six values, each containing
667 * - dword containing the starting offset of the data
668 * - dword containing the lengh in the first 16bits
669 * and the count in the second 16bits
670 */
671
672 /* remove the table id from the ordinal */
673 ord &= IPW_ORD_TABLE_VALUE_MASK;
674
675 /* boundary check */
676 if (ord > priv->table2_len) {
677 IPW_DEBUG_ORD("ordinal value too long\n");
678 return -EINVAL;
679 }
680
681 /* get the address of statistic */
682 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
bf79451e
JG		 683
684 /* get the second DW of statistics ;
43f66a6c 685 * two 16-bit words - first is length, second is count */
0edd5b44
JG		 686 field_info =
687 ipw_read_reg32(priv,
688 priv->table2_addr + (ord << 3) +
689 sizeof(u32));
bf79451e 690
43f66a6c 691 /* get each entry length */
0edd5b44 692 field_len = *((u16 *) & field_info);
bf79451e 693
43f66a6c 694 /* get number of entries */
0edd5b44 695 field_count = *(((u16 *) & field_info) + 1);
bf79451e 696
43f66a6c
JK		 697 /* abort if not enought memory */
698 total_len = field_len * field_count;
699 if (total_len > *len) {
700 *len = total_len;
701 return -EINVAL;
702 }
bf79451e 703
43f66a6c
JK		 704 *len = total_len;
705 if (!total_len)
706 return 0;
707
708 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
bf79451e 709 "field_info = 0x%08x\n",
43f66a6c
JK		 710 addr, total_len, field_info);
711 ipw_read_indirect(priv, addr, val, total_len);
712 break;
713
714 default:
715 IPW_DEBUG_ORD("Invalid ordinal!\n");
716 return -EINVAL;
717
718 }
719
43f66a6c
JK		 720 return 0;
721}
722
723static void ipw_init_ordinals(struct ipw_priv *priv)
724{
725 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
bf79451e 726 priv->table0_len = ipw_read32(priv, priv->table0_addr);
43f66a6c
JK		 727
728 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
729 priv->table0_addr, priv->table0_len);
730
731 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
732 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
733
734 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
735 priv->table1_addr, priv->table1_len);
736
737 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
738 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
0edd5b44 739 priv->table2_len &= 0x0000ffff; /* use first two bytes */
43f66a6c
JK		 740
741 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
742 priv->table2_addr, priv->table2_len);
743
744}
745
a73e22b2 746static u32 ipw_register_toggle(u32 reg)
a613bffd 747{
b095c381
JK		 748 reg &= ~IPW_START_STANDBY;
749 if (reg & IPW_GATE_ODMA)
750 reg &= ~IPW_GATE_ODMA;
751 if (reg & IPW_GATE_IDMA)
752 reg &= ~IPW_GATE_IDMA;
753 if (reg & IPW_GATE_ADMA)
754 reg &= ~IPW_GATE_ADMA;
a613bffd
JK		 755 return reg;
756}
757
758/*
759 * LED behavior:
760 * - On radio ON, turn on any LEDs that require to be on during start
761 * - On initialization, start unassociated blink
762 * - On association, disable unassociated blink
763 * - On disassociation, start unassociated blink
764 * - On radio OFF, turn off any LEDs started during radio on
765 *
766 */
ede6111c
ZY		 767#define LD_TIME_LINK_ON msecs_to_jiffies(300)
768#define LD_TIME_LINK_OFF msecs_to_jiffies(2700)
769#define LD_TIME_ACT_ON msecs_to_jiffies(250)
a613bffd 770
a73e22b2 771static void ipw_led_link_on(struct ipw_priv *priv)
a613bffd
JK		 772{
773 unsigned long flags;
774 u32 led;
775
776 /* If configured to not use LEDs, or nic_type is 1,
777 * then we don't toggle a LINK led */
778 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
779 return;
780
781 spin_lock_irqsave(&priv->lock, flags);
782
783 if (!(priv->status & STATUS_RF_KILL_MASK) &&
784 !(priv->status & STATUS_LED_LINK_ON)) {
785 IPW_DEBUG_LED("Link LED On\n");
b095c381 786 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 787 led |= priv->led_association_on;
788
789 led = ipw_register_toggle(led);
790
791 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 792 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 793
794 priv->status |= STATUS_LED_LINK_ON;
795
796 /* If we aren't associated, schedule turning the LED off */
797 if (!(priv->status & STATUS_ASSOCIATED))
798 queue_delayed_work(priv->workqueue,
799 &priv->led_link_off,
800 LD_TIME_LINK_ON);
801 }
802
803 spin_unlock_irqrestore(&priv->lock, flags);
804}
805
c848d0af
JK		 806static void ipw_bg_led_link_on(void *data)
807{
808 struct ipw_priv *priv = data;
4644151b 809 mutex_lock(&priv->mutex);
c848d0af 810 ipw_led_link_on(data);
4644151b 811 mutex_unlock(&priv->mutex);
c848d0af
JK		 812}
813
a73e22b2 814static void ipw_led_link_off(struct ipw_priv *priv)
a613bffd
JK		 815{
816 unsigned long flags;
817 u32 led;
818
819 /* If configured not to use LEDs, or nic type is 1,
820 * then we don't goggle the LINK led. */
821 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
822 return;
823
824 spin_lock_irqsave(&priv->lock, flags);
825
826 if (priv->status & STATUS_LED_LINK_ON) {
b095c381 827 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 828 led &= priv->led_association_off;
829 led = ipw_register_toggle(led);
830
831 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 832 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 833
834 IPW_DEBUG_LED("Link LED Off\n");
835
836 priv->status &= ~STATUS_LED_LINK_ON;
837
838 /* If we aren't associated and the radio is on, schedule
839 * turning the LED on (blink while unassociated) */
840 if (!(priv->status & STATUS_RF_KILL_MASK) &&
841 !(priv->status & STATUS_ASSOCIATED))
842 queue_delayed_work(priv->workqueue, &priv->led_link_on,
843 LD_TIME_LINK_OFF);
844
845 }
846
847 spin_unlock_irqrestore(&priv->lock, flags);
848}
849
c848d0af
JK		 850static void ipw_bg_led_link_off(void *data)
851{
852 struct ipw_priv *priv = data;
4644151b 853 mutex_lock(&priv->mutex);
c848d0af 854 ipw_led_link_off(data);
4644151b 855 mutex_unlock(&priv->mutex);
c848d0af
JK		 856}
857
858119e1 858static void __ipw_led_activity_on(struct ipw_priv *priv)
a613bffd 859{
a613bffd
JK		 860 u32 led;
861
862 if (priv->config & CFG_NO_LED)
863 return;
864
b095c381 865 if (priv->status & STATUS_RF_KILL_MASK)
a613bffd 866 return;
a613bffd
JK		 867
868 if (!(priv->status & STATUS_LED_ACT_ON)) {
b095c381 869 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 870 led |= priv->led_activity_on;
871
872 led = ipw_register_toggle(led);
873
874 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 875 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 876
877 IPW_DEBUG_LED("Activity LED On\n");
878
879 priv->status |= STATUS_LED_ACT_ON;
880
c848d0af 881 cancel_delayed_work(&priv->led_act_off);
a613bffd
JK		 882 queue_delayed_work(priv->workqueue, &priv->led_act_off,
883 LD_TIME_ACT_ON);
884 } else {
885 /* Reschedule LED off for full time period */
886 cancel_delayed_work(&priv->led_act_off);
887 queue_delayed_work(priv->workqueue, &priv->led_act_off,
888 LD_TIME_ACT_ON);
889 }
b095c381 890}
a613bffd 891
a73e22b2 892#if 0
b095c381
JK		 893void ipw_led_activity_on(struct ipw_priv *priv)
894{
895 unsigned long flags;
896 spin_lock_irqsave(&priv->lock, flags);
897 __ipw_led_activity_on(priv);
a613bffd
JK		 898 spin_unlock_irqrestore(&priv->lock, flags);
899}
a73e22b2 900#endif /* 0 */
a613bffd 901
a73e22b2 902static void ipw_led_activity_off(struct ipw_priv *priv)
a613bffd
JK		 903{
904 unsigned long flags;
905 u32 led;
906
907 if (priv->config & CFG_NO_LED)
908 return;
909
910 spin_lock_irqsave(&priv->lock, flags);
911
912 if (priv->status & STATUS_LED_ACT_ON) {
b095c381 913 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 914 led &= priv->led_activity_off;
915
916 led = ipw_register_toggle(led);
917
918 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 919 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 920
921 IPW_DEBUG_LED("Activity LED Off\n");
922
923 priv->status &= ~STATUS_LED_ACT_ON;
924 }
925
926 spin_unlock_irqrestore(&priv->lock, flags);
927}
928
c848d0af
JK		 929static void ipw_bg_led_activity_off(void *data)
930{
931 struct ipw_priv *priv = data;
4644151b 932 mutex_lock(&priv->mutex);
c848d0af 933 ipw_led_activity_off(data);
4644151b 934 mutex_unlock(&priv->mutex);
c848d0af
JK		 935}
936
a73e22b2 937static void ipw_led_band_on(struct ipw_priv *priv)
a613bffd
JK		 938{
939 unsigned long flags;
940 u32 led;
941
942 /* Only nic type 1 supports mode LEDs */
c848d0af
JK		 943 if (priv->config & CFG_NO_LED ||
944 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
a613bffd
JK		 945 return;
946
947 spin_lock_irqsave(&priv->lock, flags);
948
b095c381 949 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 950 if (priv->assoc_network->mode == IEEE_A) {
951 led |= priv->led_ofdm_on;
952 led &= priv->led_association_off;
953 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
954 } else if (priv->assoc_network->mode == IEEE_G) {
955 led |= priv->led_ofdm_on;
956 led |= priv->led_association_on;
957 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
958 } else {
959 led &= priv->led_ofdm_off;
960 led |= priv->led_association_on;
961 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
962 }
963
964 led = ipw_register_toggle(led);
965
966 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 967 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 968
969 spin_unlock_irqrestore(&priv->lock, flags);
970}
971
a73e22b2 972static void ipw_led_band_off(struct ipw_priv *priv)
a613bffd
JK		 973{
974 unsigned long flags;
975 u32 led;
976
977 /* Only nic type 1 supports mode LEDs */
978 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
979 return;
980
981 spin_lock_irqsave(&priv->lock, flags);
982
b095c381 983 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 984 led &= priv->led_ofdm_off;
985 led &= priv->led_association_off;
986
987 led = ipw_register_toggle(led);
988
989 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 990 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 991
992 spin_unlock_irqrestore(&priv->lock, flags);
993}
994
a73e22b2 995static void ipw_led_radio_on(struct ipw_priv *priv)
a613bffd
JK		 996{
997 ipw_led_link_on(priv);
998}
999
a73e22b2 1000static void ipw_led_radio_off(struct ipw_priv *priv)
a613bffd
JK		 1001{
1002 ipw_led_activity_off(priv);
1003 ipw_led_link_off(priv);
1004}
1005
a73e22b2 1006static void ipw_led_link_up(struct ipw_priv *priv)
a613bffd
JK		 1007{
1008 /* Set the Link Led on for all nic types */
1009 ipw_led_link_on(priv);
1010}
1011
a73e22b2 1012static void ipw_led_link_down(struct ipw_priv *priv)
a613bffd
JK		 1013{
1014 ipw_led_activity_off(priv);
1015 ipw_led_link_off(priv);
1016
1017 if (priv->status & STATUS_RF_KILL_MASK)
1018 ipw_led_radio_off(priv);
1019}
1020
a73e22b2 1021static void ipw_led_init(struct ipw_priv *priv)
a613bffd
JK		 1022{
1023 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1024
1025 /* Set the default PINs for the link and activity leds */
b095c381
JK		 1026 priv->led_activity_on = IPW_ACTIVITY_LED;
1027 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
a613bffd 1028
b095c381
JK		 1029 priv->led_association_on = IPW_ASSOCIATED_LED;
1030 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
a613bffd
JK		 1031
1032 /* Set the default PINs for the OFDM leds */
b095c381
JK		 1033 priv->led_ofdm_on = IPW_OFDM_LED;
1034 priv->led_ofdm_off = ~(IPW_OFDM_LED);
a613bffd
JK		 1035
1036 switch (priv->nic_type) {
1037 case EEPROM_NIC_TYPE_1:
1038 /* In this NIC type, the LEDs are reversed.... */
b095c381
JK		 1039 priv->led_activity_on = IPW_ASSOCIATED_LED;
1040 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1041 priv->led_association_on = IPW_ACTIVITY_LED;
1042 priv->led_association_off = ~(IPW_ACTIVITY_LED);
a613bffd
JK		 1043
1044 if (!(priv->config & CFG_NO_LED))
1045 ipw_led_band_on(priv);
1046
1047 /* And we don't blink link LEDs for this nic, so
1048 * just return here */
1049 return;
1050
1051 case EEPROM_NIC_TYPE_3:
1052 case EEPROM_NIC_TYPE_2:
1053 case EEPROM_NIC_TYPE_4:
1054 case EEPROM_NIC_TYPE_0:
1055 break;
1056
1057 default:
1058 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1059 priv->nic_type);
1060 priv->nic_type = EEPROM_NIC_TYPE_0;
1061 break;
1062 }
1063
1064 if (!(priv->config & CFG_NO_LED)) {
1065 if (priv->status & STATUS_ASSOCIATED)
1066 ipw_led_link_on(priv);
1067 else
1068 ipw_led_link_off(priv);
1069 }
1070}
1071
a73e22b2 1072static void ipw_led_shutdown(struct ipw_priv *priv)
a613bffd 1073{
a613bffd
JK		 1074 ipw_led_activity_off(priv);
1075 ipw_led_link_off(priv);
1076 ipw_led_band_off(priv);
afbf30a2
JK		 1077 cancel_delayed_work(&priv->led_link_on);
1078 cancel_delayed_work(&priv->led_link_off);
1079 cancel_delayed_work(&priv->led_act_off);
a613bffd
JK		 1080}
1081
43f66a6c
JK		 1082/*
1083 * The following adds a new attribute to the sysfs representation
1084 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1085 * used for controling the debug level.
bf79451e 1086 *
43f66a6c
JK		 1087 * See the level definitions in ipw for details.
1088 */
1089static ssize_t show_debug_level(struct device_driver *d, char *buf)
1090{
1091 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1092}
a613bffd
JK		 1093
1094static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1095 size_t count)
43f66a6c
JK		 1096{
1097 char *p = (char *)buf;
1098 u32 val;
1099
1100 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1101 p++;
1102 if (p[0] == 'x' || p[0] == 'X')
1103 p++;
1104 val = simple_strtoul(p, &p, 16);
1105 } else
1106 val = simple_strtoul(p, &p, 10);
bf79451e
JG		 1107 if (p == buf)
1108 printk(KERN_INFO DRV_NAME
43f66a6c
JK		 1109 ": %s is not in hex or decimal form.\n", buf);
1110 else
1111 ipw_debug_level = val;
1112
1113 return strnlen(buf, count);
1114}
1115
bf79451e 1116static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
43f66a6c
JK		 1117 show_debug_level, store_debug_level);
1118
b39860c6 1119static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
43f66a6c 1120{
c8fe6679 1121 /* length = 1st dword in log */
b39860c6 1122 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
43f66a6c 1123}
0edd5b44 1124
b39860c6
JK		 1125static void ipw_capture_event_log(struct ipw_priv *priv,
1126 u32 log_len, struct ipw_event *log)
43f66a6c 1127{
b39860c6 1128 u32 base;
0edd5b44 1129
b39860c6
JK		 1130 if (log_len) {
1131 base = ipw_read32(priv, IPW_EVENT_LOG);
1132 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1133 (u8 *) log, sizeof(*log) * log_len);
1134 }
1135}
43f66a6c 1136
b39860c6 1137static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
43f66a6c 1138{
b39860c6
JK		 1139 struct ipw_fw_error *error;
1140 u32 log_len = ipw_get_event_log_len(priv);
1141 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1142 u32 elem_len = ipw_read_reg32(priv, base);
43f66a6c 1143
b39860c6
JK		 1144 error = kmalloc(sizeof(*error) +
1145 sizeof(*error->elem) * elem_len +
1146 sizeof(*error->log) * log_len, GFP_ATOMIC);
1147 if (!error) {
1148 IPW_ERROR("Memory allocation for firmware error log "
1149 "failed.\n");
1150 return NULL;
43f66a6c 1151 }
f6c5cb7c 1152 error->jiffies = jiffies;
b39860c6
JK		 1153 error->status = priv->status;
1154 error->config = priv->config;
1155 error->elem_len = elem_len;
1156 error->log_len = log_len;
1157 error->elem = (struct ipw_error_elem *)error->payload;
3b26b110 1158 error->log = (struct ipw_event *)(error->elem + elem_len);
b39860c6
JK		 1159
1160 ipw_capture_event_log(priv, log_len, error->log);
bf79451e 1161
b39860c6
JK		 1162 if (elem_len)
1163 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1164 sizeof(*error->elem) * elem_len);
1165
1166 return error;
43f66a6c 1167}
0edd5b44 1168
b39860c6
JK		 1169static void ipw_free_error_log(struct ipw_fw_error *error)
1170{
1171 if (error)
1172 kfree(error);
1173}
43f66a6c 1174
b39860c6
JK		 1175static ssize_t show_event_log(struct device *d,
1176 struct device_attribute *attr, char *buf)
43f66a6c 1177{
b39860c6
JK		 1178 struct ipw_priv *priv = dev_get_drvdata(d);
1179 u32 log_len = ipw_get_event_log_len(priv);
1180 struct ipw_event log[log_len];
1181 u32 len = 0, i;
43f66a6c 1182
b39860c6 1183 ipw_capture_event_log(priv, log_len, log);
43f66a6c 1184
b39860c6
JK		 1185 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1186 for (i = 0; i < log_len; i++)
1187 len += snprintf(buf + len, PAGE_SIZE - len,
1188 "\n%08X%08X%08X",
1189 log[i].time, log[i].event, log[i].data);
1190 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1191 return len;
43f66a6c 1192}
0edd5b44 1193
b39860c6 1194static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
43f66a6c 1195
b39860c6
JK		 1196static ssize_t show_error(struct device *d,
1197 struct device_attribute *attr, char *buf)
43f66a6c 1198{
b39860c6
JK		 1199 struct ipw_priv *priv = dev_get_drvdata(d);
1200 u32 len = 0, i;
1201 if (!priv->error)
1202 return 0;
1203 len += snprintf(buf + len, PAGE_SIZE - len,
f6c5cb7c
JK		 1204 "%08lX%08X%08X%08X",
1205 priv->error->jiffies,
b39860c6
JK		 1206 priv->error->status,
1207 priv->error->config, priv->error->elem_len);
1208 for (i = 0; i < priv->error->elem_len; i++)
1209 len += snprintf(buf + len, PAGE_SIZE - len,
1210 "\n%08X%08X%08X%08X%08X%08X%08X",
1211 priv->error->elem[i].time,
1212 priv->error->elem[i].desc,
1213 priv->error->elem[i].blink1,
1214 priv->error->elem[i].blink2,
1215 priv->error->elem[i].link1,
1216 priv->error->elem[i].link2,
1217 priv->error->elem[i].data);
1218
1219 len += snprintf(buf + len, PAGE_SIZE - len,
1220 "\n%08X", priv->error->log_len);
1221 for (i = 0; i < priv->error->log_len; i++)
1222 len += snprintf(buf + len, PAGE_SIZE - len,
1223 "\n%08X%08X%08X",
1224 priv->error->log[i].time,
1225 priv->error->log[i].event,
1226 priv->error->log[i].data);
1227 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1228 return len;
1229}
1230
1231static ssize_t clear_error(struct device *d,
1232 struct device_attribute *attr,
1233 const char *buf, size_t count)
1234{
1235 struct ipw_priv *priv = dev_get_drvdata(d);
1236 if (priv->error) {
1237 ipw_free_error_log(priv->error);
1238 priv->error = NULL;
1239 }
1240 return count;
1241}
43f66a6c 1242
b39860c6 1243static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
43f66a6c 1244
f6c5cb7c
JK		 1245static ssize_t show_cmd_log(struct device *d,
1246 struct device_attribute *attr, char *buf)
1247{
1248 struct ipw_priv *priv = dev_get_drvdata(d);
1249 u32 len = 0, i;
1250 if (!priv->cmdlog)
1251 return 0;
1252 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1253 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1254 i = (i + 1) % priv->cmdlog_len) {
1255 len +=
1256 snprintf(buf + len, PAGE_SIZE - len,
1257 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1258 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1259 priv->cmdlog[i].cmd.len);
1260 len +=
1261 snprintk_buf(buf + len, PAGE_SIZE - len,
1262 (u8 *) priv->cmdlog[i].cmd.param,
1263 priv->cmdlog[i].cmd.len);
1264 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1265 }
1266 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1267 return len;
43f66a6c 1268}
0edd5b44 1269
f6c5cb7c 1270static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
43f66a6c 1271
a613bffd
JK		 1272static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1273 char *buf)
43f66a6c 1274{
a613bffd
JK		 1275 struct ipw_priv *priv = dev_get_drvdata(d);
1276 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1277}
1278
1279static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1280 const char *buf, size_t count)
1281{
1282 struct ipw_priv *priv = dev_get_drvdata(d);
0f52bf90 1283#ifdef CONFIG_IPW2200_DEBUG
a613bffd 1284 struct net_device *dev = priv->net_dev;
c848d0af 1285#endif
a613bffd
JK		 1286 char buffer[] = "00000000";
1287 unsigned long len =
1288 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1289 unsigned long val;
1290 char *p = buffer;
1291
1292 IPW_DEBUG_INFO("enter\n");
1293
1294 strncpy(buffer, buf, len);
1295 buffer[len] = 0;
1296
1297 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1298 p++;
1299 if (p[0] == 'x' || p[0] == 'X')
1300 p++;
1301 val = simple_strtoul(p, &p, 16);
1302 } else
1303 val = simple_strtoul(p, &p, 10);
1304 if (p == buffer) {
1305 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1306 } else {
1307 priv->ieee->scan_age = val;
1308 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1309 }
1310
1311 IPW_DEBUG_INFO("exit\n");
1312 return len;
1313}
1314
1315static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1316
1317static ssize_t show_led(struct device *d, struct device_attribute *attr,
1318 char *buf)
1319{
1320 struct ipw_priv *priv = dev_get_drvdata(d);
1321 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1322}
1323
1324static ssize_t store_led(struct device *d, struct device_attribute *attr,
1325 const char *buf, size_t count)
1326{
1327 struct ipw_priv *priv = dev_get_drvdata(d);
1328
1329 IPW_DEBUG_INFO("enter\n");
1330
1331 if (count == 0)
1332 return 0;
1333
1334 if (*buf == 0) {
1335 IPW_DEBUG_LED("Disabling LED control.\n");
1336 priv->config |= CFG_NO_LED;
1337 ipw_led_shutdown(priv);
1338 } else {
1339 IPW_DEBUG_LED("Enabling LED control.\n");
1340 priv->config &= ~CFG_NO_LED;
1341 ipw_led_init(priv);
1342 }
1343
1344 IPW_DEBUG_INFO("exit\n");
1345 return count;
1346}
1347
1348static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1349
ad3fee56 1350static ssize_t show_status(struct device *d,
0edd5b44 1351 struct device_attribute *attr, char *buf)
43f66a6c 1352{
ad3fee56 1353 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1354 return sprintf(buf, "0x%08x\n", (int)p->status);
1355}
0edd5b44 1356
43f66a6c
JK		 1357static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1358
ad3fee56
AM		 1359static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1360 char *buf)
43f66a6c 1361{
ad3fee56 1362 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1363 return sprintf(buf, "0x%08x\n", (int)p->config);
1364}
0edd5b44 1365
43f66a6c
JK		 1366static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1367
ad3fee56 1368static ssize_t show_nic_type(struct device *d,
0edd5b44 1369 struct device_attribute *attr, char *buf)
43f66a6c 1370{
a613bffd
JK		 1371 struct ipw_priv *priv = d->driver_data;
1372 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
43f66a6c 1373}
0edd5b44 1374
43f66a6c
JK		 1375static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1376
ad3fee56 1377static ssize_t show_ucode_version(struct device *d,
0edd5b44 1378 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1379{
1380 u32 len = sizeof(u32), tmp = 0;
ad3fee56 1381 struct ipw_priv *p = d->driver_data;
43f66a6c 1382
0edd5b44 1383 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
43f66a6c
JK		 1384 return 0;
1385
1386 return sprintf(buf, "0x%08x\n", tmp);
1387}
0edd5b44
JG		 1388
1389static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
43f66a6c 1390
ad3fee56
AM		 1391static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1392 char *buf)
43f66a6c
JK		 1393{
1394 u32 len = sizeof(u32), tmp = 0;
ad3fee56 1395 struct ipw_priv *p = d->driver_data;
43f66a6c 1396
0edd5b44 1397 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
43f66a6c
JK		 1398 return 0;
1399
1400 return sprintf(buf, "0x%08x\n", tmp);
1401}
0edd5b44
JG		 1402
1403static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
43f66a6c
JK		 1404
1405/*
1406 * Add a device attribute to view/control the delay between eeprom
1407 * operations.
1408 */
ad3fee56 1409static ssize_t show_eeprom_delay(struct device *d,
0edd5b44 1410 struct device_attribute *attr, char *buf)
43f66a6c 1411{
0edd5b44 1412 int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
43f66a6c
JK		 1413 return sprintf(buf, "%i\n", n);
1414}
ad3fee56 1415static ssize_t store_eeprom_delay(struct device *d,
0edd5b44
JG		 1416 struct device_attribute *attr,
1417 const char *buf, size_t count)
43f66a6c 1418{
ad3fee56 1419 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1420 sscanf(buf, "%i", &p->eeprom_delay);
1421 return strnlen(buf, count);
1422}
0edd5b44
JG		 1423
1424static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1425 show_eeprom_delay, store_eeprom_delay);
43f66a6c 1426
ad3fee56 1427static ssize_t show_command_event_reg(struct device *d,
0edd5b44 1428 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1429{
1430 u32 reg = 0;
ad3fee56 1431 struct ipw_priv *p = d->driver_data;
43f66a6c 1432
b095c381 1433 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
43f66a6c
JK		 1434 return sprintf(buf, "0x%08x\n", reg);
1435}
ad3fee56 1436static ssize_t store_command_event_reg(struct device *d,
0edd5b44
JG		 1437 struct device_attribute *attr,
1438 const char *buf, size_t count)
43f66a6c
JK		 1439{
1440 u32 reg;
ad3fee56 1441 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1442
1443 sscanf(buf, "%x", &reg);
b095c381 1444 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
43f66a6c
JK		 1445 return strnlen(buf, count);
1446}
0edd5b44
JG		 1447
1448static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1449 show_command_event_reg, store_command_event_reg);
43f66a6c 1450
ad3fee56 1451static ssize_t show_mem_gpio_reg(struct device *d,
0edd5b44 1452 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1453{
1454 u32 reg = 0;
ad3fee56 1455 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1456
1457 reg = ipw_read_reg32(p, 0x301100);
1458 return sprintf(buf, "0x%08x\n", reg);
1459}
ad3fee56 1460static ssize_t store_mem_gpio_reg(struct device *d,
0edd5b44
JG		 1461 struct device_attribute *attr,
1462 const char *buf, size_t count)
43f66a6c
JK		 1463{
1464 u32 reg;
ad3fee56 1465 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1466
1467 sscanf(buf, "%x", &reg);
1468 ipw_write_reg32(p, 0x301100, reg);
1469 return strnlen(buf, count);
1470}
0edd5b44
JG		 1471
1472static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1473 show_mem_gpio_reg, store_mem_gpio_reg);
43f66a6c 1474
ad3fee56 1475static ssize_t show_indirect_dword(struct device *d,
0edd5b44 1476 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1477{
1478 u32 reg = 0;
ad3fee56 1479 struct ipw_priv *priv = d->driver_data;
afbf30a2 1480
bf79451e 1481 if (priv->status & STATUS_INDIRECT_DWORD)
43f66a6c 1482 reg = ipw_read_reg32(priv, priv->indirect_dword);
bf79451e 1483 else
43f66a6c 1484 reg = 0;
bf79451e 1485
43f66a6c
JK		 1486 return sprintf(buf, "0x%08x\n", reg);
1487}
ad3fee56 1488static ssize_t store_indirect_dword(struct device *d,
0edd5b44
JG		 1489 struct device_attribute *attr,
1490 const char *buf, size_t count)
43f66a6c 1491{
ad3fee56 1492 struct ipw_priv *priv = d->driver_data;
43f66a6c
JK		 1493
1494 sscanf(buf, "%x", &priv->indirect_dword);
1495 priv->status |= STATUS_INDIRECT_DWORD;
1496 return strnlen(buf, count);
1497}
0edd5b44
JG		 1498
1499static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1500 show_indirect_dword, store_indirect_dword);
43f66a6c 1501
ad3fee56 1502static ssize_t show_indirect_byte(struct device *d,
0edd5b44 1503 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1504{
1505 u8 reg = 0;
ad3fee56 1506 struct ipw_priv *priv = d->driver_data;
afbf30a2 1507
bf79451e 1508 if (priv->status & STATUS_INDIRECT_BYTE)
43f66a6c 1509 reg = ipw_read_reg8(priv, priv->indirect_byte);
bf79451e 1510 else
43f66a6c
JK		 1511 reg = 0;
1512
1513 return sprintf(buf, "0x%02x\n", reg);
1514}
ad3fee56 1515static ssize_t store_indirect_byte(struct device *d,
0edd5b44
JG		 1516 struct device_attribute *attr,
1517 const char *buf, size_t count)
43f66a6c 1518{
ad3fee56 1519 struct ipw_priv *priv = d->driver_data;
43f66a6c
JK		 1520
1521 sscanf(buf, "%x", &priv->indirect_byte);
1522 priv->status |= STATUS_INDIRECT_BYTE;
1523 return strnlen(buf, count);
1524}
0edd5b44
JG		 1525
1526static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
43f66a6c
JK		 1527 show_indirect_byte, store_indirect_byte);
1528
ad3fee56 1529static ssize_t show_direct_dword(struct device *d,
0edd5b44 1530 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1531{
1532 u32 reg = 0;
ad3fee56 1533 struct ipw_priv *priv = d->driver_data;
43f66a6c 1534
bf79451e 1535 if (priv->status & STATUS_DIRECT_DWORD)
43f66a6c 1536 reg = ipw_read32(priv, priv->direct_dword);
bf79451e 1537 else
43f66a6c
JK		 1538 reg = 0;
1539
1540 return sprintf(buf, "0x%08x\n", reg);
1541}
ad3fee56 1542static ssize_t store_direct_dword(struct device *d,
0edd5b44
JG		 1543 struct device_attribute *attr,
1544 const char *buf, size_t count)
43f66a6c 1545{
ad3fee56 1546 struct ipw_priv *priv = d->driver_data;
43f66a6c
JK		 1547
1548 sscanf(buf, "%x", &priv->direct_dword);
1549 priv->status |= STATUS_DIRECT_DWORD;
1550 return strnlen(buf, count);
1551}
43f66a6c 1552
0edd5b44
JG		 1553static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1554 show_direct_dword, store_direct_dword);
43f66a6c 1555
858119e1 1556static int rf_kill_active(struct ipw_priv *priv)
43f66a6c
JK		 1557{
1558 if (0 == (ipw_read32(priv, 0x30) & 0x10000))
1559 priv->status |= STATUS_RF_KILL_HW;
1560 else
1561 priv->status &= ~STATUS_RF_KILL_HW;
1562
1563 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1564}
1565
ad3fee56 1566static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
0edd5b44 1567 char *buf)
43f66a6c
JK		 1568{
1569 /* 0 - RF kill not enabled
bf79451e 1570 1 - SW based RF kill active (sysfs)
43f66a6c
JK		 1571 2 - HW based RF kill active
1572 3 - Both HW and SW baed RF kill active */
ad3fee56 1573 struct ipw_priv *priv = d->driver_data;
43f66a6c 1574 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
0edd5b44 1575 (rf_kill_active(priv) ? 0x2 : 0x0);
43f66a6c
JK		 1576 return sprintf(buf, "%i\n", val);
1577}
1578
1579static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1580{
bf79451e 1581 if ((disable_radio ? 1 : 0) ==
ea2b26e0 1582 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
0edd5b44 1583 return 0;
43f66a6c
JK		 1584
1585 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1586 disable_radio ? "OFF" : "ON");
1587
1588 if (disable_radio) {
1589 priv->status |= STATUS_RF_KILL_SW;
1590
a613bffd 1591 if (priv->workqueue)
43f66a6c 1592 cancel_delayed_work(&priv->request_scan);
43f66a6c
JK		 1593 queue_work(priv->workqueue, &priv->down);
1594 } else {
1595 priv->status &= ~STATUS_RF_KILL_SW;
1596 if (rf_kill_active(priv)) {
1597 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1598 "disabled by HW switch\n");
1599 /* Make sure the RF_KILL check timer is running */
1600 cancel_delayed_work(&priv->rf_kill);
bf79451e 1601 queue_delayed_work(priv->workqueue, &priv->rf_kill,
43f66a6c 1602 2 * HZ);
bf79451e 1603 } else
43f66a6c
JK		 1604 queue_work(priv->workqueue, &priv->up);
1605 }
1606
1607 return 1;
1608}
1609
0edd5b44
JG		 1610static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1611 const char *buf, size_t count)
43f66a6c 1612{
ad3fee56 1613 struct ipw_priv *priv = d->driver_data;
bf79451e 1614
43f66a6c
JK		 1615 ipw_radio_kill_sw(priv, buf[0] == '1');
1616
1617 return count;
1618}
0edd5b44
JG		 1619
1620static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
43f66a6c 1621
b095c381
JK		 1622static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1623 char *buf)
1624{
1625 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1626 int pos = 0, len = 0;
1627 if (priv->config & CFG_SPEED_SCAN) {
1628 while (priv->speed_scan[pos] != 0)
1629 len += sprintf(&buf[len], "%d ",
1630 priv->speed_scan[pos++]);
1631 return len + sprintf(&buf[len], "\n");
1632 }
1633
1634 return sprintf(buf, "0\n");
1635}
1636
1637static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1638 const char *buf, size_t count)
1639{
1640 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1641 int channel, pos = 0;
1642 const char *p = buf;
1643
1644 /* list of space separated channels to scan, optionally ending with 0 */
1645 while ((channel = simple_strtol(p, NULL, 0))) {
1646 if (pos == MAX_SPEED_SCAN - 1) {
1647 priv->speed_scan[pos] = 0;
1648 break;
1649 }
1650
1867b117 1651 if (ieee80211_is_valid_channel(priv->ieee, channel))
b095c381
JK		 1652 priv->speed_scan[pos++] = channel;
1653 else
1654 IPW_WARNING("Skipping invalid channel request: %d\n",
1655 channel);
1656 p = strchr(p, ' ');
1657 if (!p)
1658 break;
1659 while (*p == ' ' || *p == '\t')
1660 p++;
1661 }
1662
1663 if (pos == 0)
1664 priv->config &= ~CFG_SPEED_SCAN;
1665 else {
1666 priv->speed_scan_pos = 0;
1667 priv->config |= CFG_SPEED_SCAN;
1668 }
1669
1670 return count;
1671}
1672
1673static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1674 store_speed_scan);
1675
1676static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1677 char *buf)
1678{
1679 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1680 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1681}
1682
1683static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1684 const char *buf, size_t count)
1685{
1686 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1687 if (buf[0] == '1')
1688 priv->config |= CFG_NET_STATS;
1689 else
1690 priv->config &= ~CFG_NET_STATS;
1691
1692 return count;
1693}
1694
afbf30a2
JK		 1695static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1696 show_net_stats, store_net_stats);
b095c381 1697
ea2b26e0
JK		 1698static void notify_wx_assoc_event(struct ipw_priv *priv)
1699{
1700 union iwreq_data wrqu;
1701 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1702 if (priv->status & STATUS_ASSOCIATED)
1703 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1704 else
1705 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1706 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1707}
1708
43f66a6c
JK		 1709static void ipw_irq_tasklet(struct ipw_priv *priv)
1710{
1711 u32 inta, inta_mask, handled = 0;
1712 unsigned long flags;
1713 int rc = 0;
1714
1715 spin_lock_irqsave(&priv->lock, flags);
1716
b095c381
JK		 1717 inta = ipw_read32(priv, IPW_INTA_RW);
1718 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1719 inta &= (IPW_INTA_MASK_ALL & inta_mask);
43f66a6c
JK		 1720
1721 /* Add any cached INTA values that need to be handled */
1722 inta |= priv->isr_inta;
1723
1724 /* handle all the justifications for the interrupt */
b095c381 1725 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
43f66a6c 1726 ipw_rx(priv);
b095c381 1727 handled |= IPW_INTA_BIT_RX_TRANSFER;
43f66a6c
JK		 1728 }
1729
b095c381 1730 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
43f66a6c 1731 IPW_DEBUG_HC("Command completed.\n");
0edd5b44 1732 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
43f66a6c
JK		 1733 priv->status &= ~STATUS_HCMD_ACTIVE;
1734 wake_up_interruptible(&priv->wait_command_queue);
b095c381 1735 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
43f66a6c
JK		 1736 }
1737
b095c381 1738 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
43f66a6c 1739 IPW_DEBUG_TX("TX_QUEUE_1\n");
0edd5b44 1740 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
b095c381 1741 handled |= IPW_INTA_BIT_TX_QUEUE_1;
43f66a6c
JK		 1742 }
1743
b095c381 1744 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
43f66a6c 1745 IPW_DEBUG_TX("TX_QUEUE_2\n");
0edd5b44 1746 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
b095c381 1747 handled |= IPW_INTA_BIT_TX_QUEUE_2;
43f66a6c
JK		 1748 }
1749
b095c381 1750 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
43f66a6c 1751 IPW_DEBUG_TX("TX_QUEUE_3\n");
0edd5b44 1752 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
b095c381 1753 handled |= IPW_INTA_BIT_TX_QUEUE_3;
43f66a6c
JK		 1754 }
1755
b095c381 1756 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
43f66a6c 1757 IPW_DEBUG_TX("TX_QUEUE_4\n");
0edd5b44 1758 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
b095c381 1759 handled |= IPW_INTA_BIT_TX_QUEUE_4;
43f66a6c
JK		 1760 }
1761
b095c381 1762 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
43f66a6c 1763 IPW_WARNING("STATUS_CHANGE\n");
b095c381 1764 handled |= IPW_INTA_BIT_STATUS_CHANGE;
43f66a6c
JK		 1765 }
1766
b095c381 1767 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
43f66a6c 1768 IPW_WARNING("TX_PERIOD_EXPIRED\n");
b095c381 1769 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
43f66a6c
JK		 1770 }
1771
b095c381 1772 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
43f66a6c 1773 IPW_WARNING("HOST_CMD_DONE\n");
b095c381 1774 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
43f66a6c
JK		 1775 }
1776
b095c381 1777 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
43f66a6c 1778 IPW_WARNING("FW_INITIALIZATION_DONE\n");
b095c381 1779 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
43f66a6c
JK		 1780 }
1781
b095c381 1782 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
43f66a6c 1783 IPW_WARNING("PHY_OFF_DONE\n");
b095c381 1784 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
43f66a6c
JK		 1785 }
1786
b095c381 1787 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
43f66a6c
JK		 1788 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1789 priv->status |= STATUS_RF_KILL_HW;
1790 wake_up_interruptible(&priv->wait_command_queue);
ea2b26e0 1791 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
43f66a6c 1792 cancel_delayed_work(&priv->request_scan);
a613bffd 1793 schedule_work(&priv->link_down);
43f66a6c 1794 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
b095c381 1795 handled |= IPW_INTA_BIT_RF_KILL_DONE;
43f66a6c 1796 }
bf79451e 1797
b095c381 1798 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1d1b09eb 1799 IPW_WARNING("Firmware error detected. Restarting.\n");
b39860c6 1800 if (priv->error) {
1d1b09eb 1801 IPW_DEBUG_FW("Sysfs 'error' log already exists.\n");
0f52bf90 1802#ifdef CONFIG_IPW2200_DEBUG
b39860c6
JK		 1803 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1804 struct ipw_fw_error *error =
1805 ipw_alloc_error_log(priv);
1806 ipw_dump_error_log(priv, error);
1807 if (error)
1808 ipw_free_error_log(error);
1809 }
1810#endif
1811 } else {
1812 priv->error = ipw_alloc_error_log(priv);
1813 if (priv->error)
1d1b09eb 1814 IPW_DEBUG_FW("Sysfs 'error' log captured.\n");
b39860c6 1815 else
1d1b09eb
ZY		 1816 IPW_DEBUG_FW("Error allocating sysfs 'error' "
1817 "log.\n");
0f52bf90 1818#ifdef CONFIG_IPW2200_DEBUG
b39860c6
JK		 1819 if (ipw_debug_level & IPW_DL_FW_ERRORS)
1820 ipw_dump_error_log(priv, priv->error);
43f66a6c 1821#endif
b39860c6
JK		 1822 }
1823
b095c381
JK		 1824 /* XXX: If hardware encryption is for WPA/WPA2,
1825 * we have to notify the supplicant. */
1826 if (priv->ieee->sec.encrypt) {
1827 priv->status &= ~STATUS_ASSOCIATED;
1828 notify_wx_assoc_event(priv);
1829 }
1830
1831 /* Keep the restart process from trying to send host
1832 * commands by clearing the INIT status bit */
1833 priv->status &= ~STATUS_INIT;
afbf30a2
JK		 1834
1835 /* Cancel currently queued command. */
1836 priv->status &= ~STATUS_HCMD_ACTIVE;
1837 wake_up_interruptible(&priv->wait_command_queue);
1838
43f66a6c 1839 queue_work(priv->workqueue, &priv->adapter_restart);
b095c381 1840 handled |= IPW_INTA_BIT_FATAL_ERROR;
43f66a6c
JK		 1841 }
1842
b095c381 1843 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
43f66a6c 1844 IPW_ERROR("Parity error\n");
b095c381 1845 handled |= IPW_INTA_BIT_PARITY_ERROR;
43f66a6c
JK		 1846 }
1847
1848 if (handled != inta) {
0edd5b44 1849 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
43f66a6c
JK		 1850 }
1851
1852 /* enable all interrupts */
1853 ipw_enable_interrupts(priv);
1854
1855 spin_unlock_irqrestore(&priv->lock, flags);
1856}
bf79451e 1857
43f66a6c
JK		 1858#define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1859static char *get_cmd_string(u8 cmd)
1860{
1861 switch (cmd) {
1862 IPW_CMD(HOST_COMPLETE);
bf79451e
JG		 1863 IPW_CMD(POWER_DOWN);
1864 IPW_CMD(SYSTEM_CONFIG);
1865 IPW_CMD(MULTICAST_ADDRESS);
1866 IPW_CMD(SSID);
1867 IPW_CMD(ADAPTER_ADDRESS);
1868 IPW_CMD(PORT_TYPE);
1869 IPW_CMD(RTS_THRESHOLD);
1870 IPW_CMD(FRAG_THRESHOLD);
1871 IPW_CMD(POWER_MODE);
1872 IPW_CMD(WEP_KEY);
1873 IPW_CMD(TGI_TX_KEY);
1874 IPW_CMD(SCAN_REQUEST);
1875 IPW_CMD(SCAN_REQUEST_EXT);
1876 IPW_CMD(ASSOCIATE);
1877 IPW_CMD(SUPPORTED_RATES);
1878 IPW_CMD(SCAN_ABORT);
1879 IPW_CMD(TX_FLUSH);
1880 IPW_CMD(QOS_PARAMETERS);
1881 IPW_CMD(DINO_CONFIG);
1882 IPW_CMD(RSN_CAPABILITIES);
1883 IPW_CMD(RX_KEY);
1884 IPW_CMD(CARD_DISABLE);
1885 IPW_CMD(SEED_NUMBER);
1886 IPW_CMD(TX_POWER);
1887 IPW_CMD(COUNTRY_INFO);
1888 IPW_CMD(AIRONET_INFO);
1889 IPW_CMD(AP_TX_POWER);
1890 IPW_CMD(CCKM_INFO);
1891 IPW_CMD(CCX_VER_INFO);
1892 IPW_CMD(SET_CALIBRATION);
1893 IPW_CMD(SENSITIVITY_CALIB);
1894 IPW_CMD(RETRY_LIMIT);
1895 IPW_CMD(IPW_PRE_POWER_DOWN);
1896 IPW_CMD(VAP_BEACON_TEMPLATE);
1897 IPW_CMD(VAP_DTIM_PERIOD);
1898 IPW_CMD(EXT_SUPPORTED_RATES);
1899 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1900 IPW_CMD(VAP_QUIET_INTERVALS);
1901 IPW_CMD(VAP_CHANNEL_SWITCH);
1902 IPW_CMD(VAP_MANDATORY_CHANNELS);
1903 IPW_CMD(VAP_CELL_PWR_LIMIT);
1904 IPW_CMD(VAP_CF_PARAM_SET);
1905 IPW_CMD(VAP_SET_BEACONING_STATE);
1906 IPW_CMD(MEASUREMENT);
1907 IPW_CMD(POWER_CAPABILITY);
1908 IPW_CMD(SUPPORTED_CHANNELS);
1909 IPW_CMD(TPC_REPORT);
1910 IPW_CMD(WME_INFO);
1911 IPW_CMD(PRODUCTION_COMMAND);
1912 default:
43f66a6c
JK		 1913 return "UNKNOWN";
1914 }
1915}
43f66a6c
JK		 1916
1917#define HOST_COMPLETE_TIMEOUT HZ
0a7bcf26
ZY		 1918
1919static int __ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
43f66a6c
JK		 1920{
1921 int rc = 0;
a613bffd 1922 unsigned long flags;
43f66a6c 1923
a613bffd 1924 spin_lock_irqsave(&priv->lock, flags);
43f66a6c 1925 if (priv->status & STATUS_HCMD_ACTIVE) {
9ddf84f6
JK		 1926 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1927 get_cmd_string(cmd->cmd));
a613bffd 1928 spin_unlock_irqrestore(&priv->lock, flags);
9ddf84f6 1929 return -EAGAIN;
43f66a6c
JK		 1930 }
1931
1932 priv->status |= STATUS_HCMD_ACTIVE;
bf79451e 1933
f6c5cb7c
JK		 1934 if (priv->cmdlog) {
1935 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1936 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1937 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1938 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1939 cmd->len);
1940 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1941 }
1942
b095c381
JK		 1943 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1944 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1945 priv->status);
f516dbcd
ZY		 1946
1947#ifndef DEBUG_CMD_WEP_KEY
1948 if (cmd->cmd == IPW_CMD_WEP_KEY)
1949 IPW_DEBUG_HC("WEP_KEY command masked out for secure.\n");
1950 else
1951#endif
1952 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1953
0a7bcf26 1954 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
a613bffd
JK		 1955 if (rc) {
1956 priv->status &= ~STATUS_HCMD_ACTIVE;
9ddf84f6
JK		 1957 IPW_ERROR("Failed to send %s: Reason %d\n",
1958 get_cmd_string(cmd->cmd), rc);
a613bffd 1959 spin_unlock_irqrestore(&priv->lock, flags);
f6c5cb7c 1960 goto exit;
a613bffd
JK		 1961 }
1962 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 1963
0edd5b44
JG		 1964 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1965 !(priv->
1966 status & STATUS_HCMD_ACTIVE),
1967 HOST_COMPLETE_TIMEOUT);
43f66a6c 1968 if (rc == 0) {
a613bffd
JK		 1969 spin_lock_irqsave(&priv->lock, flags);
1970 if (priv->status & STATUS_HCMD_ACTIVE) {
9ddf84f6
JK		 1971 IPW_ERROR("Failed to send %s: Command timed out.\n",
1972 get_cmd_string(cmd->cmd));
a613bffd
JK		 1973 priv->status &= ~STATUS_HCMD_ACTIVE;
1974 spin_unlock_irqrestore(&priv->lock, flags);
f6c5cb7c
JK		 1975 rc = -EIO;
1976 goto exit;
a613bffd
JK		 1977 }
1978 spin_unlock_irqrestore(&priv->lock, flags);
3b9990cb
JK		 1979 } else
1980 rc = 0;
a613bffd 1981
b095c381 1982 if (priv->status & STATUS_RF_KILL_HW) {
9ddf84f6
JK		 1983 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1984 get_cmd_string(cmd->cmd));
f6c5cb7c
JK		 1985 rc = -EIO;
1986 goto exit;
43f66a6c
JK		 1987 }
1988
2638bc39 1989 exit:
f6c5cb7c
JK		 1990 if (priv->cmdlog) {
1991 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1992 priv->cmdlog_pos %= priv->cmdlog_len;
1993 }
1994 return rc;
43f66a6c
JK		 1995}
1996
0a7bcf26
ZY		 1997static int ipw_send_cmd_simple(struct ipw_priv *priv, u8 command)
1998{
1999 struct host_cmd cmd = {
2000 .cmd = command,
2001 };
2002
2003 return __ipw_send_cmd(priv, &cmd);
2004}
2005
2006static int ipw_send_cmd_pdu(struct ipw_priv *priv, u8 command, u8 len,
2007 void *data)
43f66a6c
JK		 2008{
2009 struct host_cmd cmd = {
0a7bcf26
ZY		 2010 .cmd = command,
2011 .len = len,
2012 .param = data,
43f66a6c
JK		 2013 };
2014
0a7bcf26
ZY		 2015 return __ipw_send_cmd(priv, &cmd);
2016}
2017
2018static int ipw_send_host_complete(struct ipw_priv *priv)
2019{
43f66a6c
JK		 2020 if (!priv) {
2021 IPW_ERROR("Invalid args\n");
2022 return -1;
2023 }
2024
0a7bcf26 2025 return ipw_send_cmd_simple(priv, IPW_CMD_HOST_COMPLETE);
43f66a6c
JK		 2026}
2027
bf79451e 2028static int ipw_send_system_config(struct ipw_priv *priv,
43f66a6c
JK		 2029 struct ipw_sys_config *config)
2030{
43f66a6c
JK		 2031 if (!priv || !config) {
2032 IPW_ERROR("Invalid args\n");
2033 return -1;
2034 }
2035
0a7bcf26 2036 return ipw_send_cmd_pdu(priv, IPW_CMD_SYSTEM_CONFIG, sizeof(*config),
2638bc39 2037 config);
43f66a6c
JK		 2038}
2039
0edd5b44 2040static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
43f66a6c 2041{
43f66a6c
JK		 2042 if (!priv || !ssid) {
2043 IPW_ERROR("Invalid args\n");
2044 return -1;
2045 }
2046
0a7bcf26 2047 return ipw_send_cmd_pdu(priv, IPW_CMD_SSID, min(len, IW_ESSID_MAX_SIZE),
2638bc39 2048 ssid);
43f66a6c
JK		 2049}
2050
0edd5b44 2051static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
43f66a6c 2052{
43f66a6c
JK		 2053 if (!priv || !mac) {
2054 IPW_ERROR("Invalid args\n");
2055 return -1;
2056 }
2057
2058 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2059 priv->net_dev->name, MAC_ARG(mac));
2060
2638bc39 2061 return ipw_send_cmd_pdu(priv, IPW_CMD_ADAPTER_ADDRESS, ETH_ALEN, mac);
43f66a6c
JK		 2062}
2063
a613bffd
JK		 2064/*
2065 * NOTE: This must be executed from our workqueue as it results in udelay
2066 * being called which may corrupt the keyboard if executed on default
2067 * workqueue
2068 */
43f66a6c
JK		 2069static void ipw_adapter_restart(void *adapter)
2070{
2071 struct ipw_priv *priv = adapter;
2072
2073 if (priv->status & STATUS_RF_KILL_MASK)
2074 return;
2075
2076 ipw_down(priv);
b095c381
JK		 2077
2078 if (priv->assoc_network &&
2079 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2080 ipw_remove_current_network(priv);
2081
43f66a6c
JK		 2082 if (ipw_up(priv)) {
2083 IPW_ERROR("Failed to up device\n");
2084 return;
2085 }
2086}
2087
c848d0af
JK		 2088static void ipw_bg_adapter_restart(void *data)
2089{
2090 struct ipw_priv *priv = data;
4644151b 2091 mutex_lock(&priv->mutex);
c848d0af 2092 ipw_adapter_restart(data);
4644151b 2093 mutex_unlock(&priv->mutex);
c848d0af
JK		 2094}
2095
43f66a6c
JK		 2096#define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2097
2098static void ipw_scan_check(void *data)
2099{
2100 struct ipw_priv *priv = data;
2101 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2102 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
c7b6a674
ZY		 2103 "adapter after (%dms).\n",
2104 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
a613bffd 2105 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c
JK		 2106 }
2107}
2108
c848d0af
JK		 2109static void ipw_bg_scan_check(void *data)
2110{
2111 struct ipw_priv *priv = data;
4644151b 2112 mutex_lock(&priv->mutex);
c848d0af 2113 ipw_scan_check(data);
4644151b 2114 mutex_unlock(&priv->mutex);
c848d0af
JK		 2115}
2116
43f66a6c
JK		 2117static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2118 struct ipw_scan_request_ext *request)
2119{
0a7bcf26 2120 return ipw_send_cmd_pdu(priv, IPW_CMD_SCAN_REQUEST_EXT,
2638bc39 2121 sizeof(*request), request);
43f66a6c
JK		 2122}
2123
2124static int ipw_send_scan_abort(struct ipw_priv *priv)
2125{
43f66a6c
JK		 2126 if (!priv) {
2127 IPW_ERROR("Invalid args\n");
2128 return -1;
2129 }
2130
0a7bcf26 2131 return ipw_send_cmd_simple(priv, IPW_CMD_SCAN_ABORT);
43f66a6c
JK		 2132}
2133
2134static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2135{
0a7bcf26
ZY		 2136 struct ipw_sensitivity_calib calib = {
2137 .beacon_rssi_raw = sens,
43f66a6c 2138 };
0a7bcf26
ZY		 2139
2140 return ipw_send_cmd_pdu(priv, IPW_CMD_SENSITIVITY_CALIB, sizeof(calib),
2638bc39 2141 &calib);
43f66a6c
JK		 2142}
2143
2144static int ipw_send_associate(struct ipw_priv *priv,
2145 struct ipw_associate *associate)
2146{
a613bffd 2147 struct ipw_associate tmp_associate;
0a7bcf26
ZY		 2148
2149 if (!priv || !associate) {
2150 IPW_ERROR("Invalid args\n");
2151 return -1;
2152 }
2153
a613bffd
JK		 2154 memcpy(&tmp_associate, associate, sizeof(*associate));
2155 tmp_associate.policy_support =
2156 cpu_to_le16(tmp_associate.policy_support);
2157 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2158 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2159 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2160 tmp_associate.listen_interval =
2161 cpu_to_le16(tmp_associate.listen_interval);
2162 tmp_associate.beacon_interval =
2163 cpu_to_le16(tmp_associate.beacon_interval);
2164 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2165
0a7bcf26 2166 return ipw_send_cmd_pdu(priv, IPW_CMD_ASSOCIATE, sizeof(tmp_associate),
2638bc39 2167 &tmp_associate);
43f66a6c
JK		 2168}
2169
2170static int ipw_send_supported_rates(struct ipw_priv *priv,
2171 struct ipw_supported_rates *rates)
2172{
43f66a6c
JK		 2173 if (!priv || !rates) {
2174 IPW_ERROR("Invalid args\n");
2175 return -1;
2176 }
2177
0a7bcf26 2178 return ipw_send_cmd_pdu(priv, IPW_CMD_SUPPORTED_RATES, sizeof(*rates),
2638bc39 2179 rates);
43f66a6c
JK		 2180}
2181
2182static int ipw_set_random_seed(struct ipw_priv *priv)
2183{
0a7bcf26 2184 u32 val;
43f66a6c
JK		 2185
2186 if (!priv) {
2187 IPW_ERROR("Invalid args\n");
2188 return -1;
2189 }
2190
0a7bcf26 2191 get_random_bytes(&val, sizeof(val));
43f66a6c 2192
0a7bcf26 2193 return ipw_send_cmd_pdu(priv, IPW_CMD_SEED_NUMBER, sizeof(val), &val);
43f66a6c
JK		 2194}
2195
43f66a6c
JK		 2196static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2197{
43f66a6c
JK		 2198 if (!priv) {
2199 IPW_ERROR("Invalid args\n");
2200 return -1;
2201 }
2202
0a7bcf26 2203 return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(phy_off),
2638bc39 2204 &phy_off);
43f66a6c 2205}
43f66a6c 2206
0edd5b44 2207static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
43f66a6c 2208{
43f66a6c
JK		 2209 if (!priv || !power) {
2210 IPW_ERROR("Invalid args\n");
2211 return -1;
2212 }
2213
2638bc39 2214 return ipw_send_cmd_pdu(priv, IPW_CMD_TX_POWER, sizeof(*power), power);
43f66a6c
JK		 2215}
2216
6de9f7f2
ZY		 2217static int ipw_set_tx_power(struct ipw_priv *priv)
2218{
1867b117 2219 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
6de9f7f2
ZY		 2220 struct ipw_tx_power tx_power;
2221 s8 max_power;
2222 int i;
2223
2224 memset(&tx_power, 0, sizeof(tx_power));
2225
2226 /* configure device for 'G' band */
2227 tx_power.ieee_mode = IPW_G_MODE;
2228 tx_power.num_channels = geo->bg_channels;
2229 for (i = 0; i < geo->bg_channels; i++) {
2230 max_power = geo->bg[i].max_power;
2231 tx_power.channels_tx_power[i].channel_number =
2232 geo->bg[i].channel;
2233 tx_power.channels_tx_power[i].tx_power = max_power ?
2234 min(max_power, priv->tx_power) : priv->tx_power;
43f66a6c 2235 }
6de9f7f2
ZY		 2236 if (ipw_send_tx_power(priv, &tx_power))
2237 return -EIO;
2238
2239 /* configure device to also handle 'B' band */
2240 tx_power.ieee_mode = IPW_B_MODE;
2241 if (ipw_send_tx_power(priv, &tx_power))
2242 return -EIO;
bf79451e 2243
6de9f7f2
ZY		 2244 /* configure device to also handle 'A' band */
2245 if (priv->ieee->abg_true) {
2246 tx_power.ieee_mode = IPW_A_MODE;
2247 tx_power.num_channels = geo->a_channels;
2248 for (i = 0; i < tx_power.num_channels; i++) {
2249 max_power = geo->a[i].max_power;
2250 tx_power.channels_tx_power[i].channel_number =
2251 geo->a[i].channel;
2252 tx_power.channels_tx_power[i].tx_power = max_power ?
2253 min(max_power, priv->tx_power) : priv->tx_power;
2254 }
2255 if (ipw_send_tx_power(priv, &tx_power))
2256 return -EIO;
2257 }
43f66a6c
JK		 2258 return 0;
2259}
2260
2261static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2262{
2263 struct ipw_rts_threshold rts_threshold = {
2264 .rts_threshold = rts,
2265 };
43f66a6c
JK		 2266
2267 if (!priv) {
2268 IPW_ERROR("Invalid args\n");
2269 return -1;
2270 }
2271
0a7bcf26
ZY		 2272 return ipw_send_cmd_pdu(priv, IPW_CMD_RTS_THRESHOLD,
2273 sizeof(rts_threshold), &rts_threshold);
43f66a6c
JK		 2274}
2275
2276static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2277{
2278 struct ipw_frag_threshold frag_threshold = {
2279 .frag_threshold = frag,
2280 };
43f66a6c
JK		 2281
2282 if (!priv) {
2283 IPW_ERROR("Invalid args\n");
2284 return -1;
2285 }
2286
0a7bcf26
ZY		 2287 return ipw_send_cmd_pdu(priv, IPW_CMD_FRAG_THRESHOLD,
2288 sizeof(frag_threshold), &frag_threshold);
43f66a6c
JK		 2289}
2290
2291static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2292{
0a7bcf26 2293 u32 param;
43f66a6c
JK		 2294
2295 if (!priv) {
2296 IPW_ERROR("Invalid args\n");
2297 return -1;
2298 }
bf79451e 2299
43f66a6c
JK		 2300 /* If on battery, set to 3, if AC set to CAM, else user
2301 * level */
2302 switch (mode) {
2303 case IPW_POWER_BATTERY:
0a7bcf26 2304 param = IPW_POWER_INDEX_3;
43f66a6c
JK		 2305 break;
2306 case IPW_POWER_AC:
0a7bcf26 2307 param = IPW_POWER_MODE_CAM;
43f66a6c
JK		 2308 break;
2309 default:
0a7bcf26 2310 param = mode;
43f66a6c
JK		 2311 break;
2312 }
2313
0a7bcf26 2314 return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
2638bc39 2315 &param);
43f66a6c
JK		 2316}
2317
afbf30a2
JK		 2318static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2319{
2320 struct ipw_retry_limit retry_limit = {
2321 .short_retry_limit = slimit,
2322 .long_retry_limit = llimit
2323 };
afbf30a2
JK		 2324
2325 if (!priv) {
2326 IPW_ERROR("Invalid args\n");
2327 return -1;
2328 }
2329
0a7bcf26 2330 return ipw_send_cmd_pdu(priv, IPW_CMD_RETRY_LIMIT, sizeof(retry_limit),
2638bc39 2331 &retry_limit);
afbf30a2
JK		 2332}
2333
43f66a6c
JK		 2334/*
2335 * The IPW device contains a Microwire compatible EEPROM that stores
2336 * various data like the MAC address. Usually the firmware has exclusive
2337 * access to the eeprom, but during device initialization (before the
2338 * device driver has sent the HostComplete command to the firmware) the
2339 * device driver has read access to the EEPROM by way of indirect addressing
2340 * through a couple of memory mapped registers.
2341 *
2342 * The following is a simplified implementation for pulling data out of the
2343 * the eeprom, along with some helper functions to find information in
2344 * the per device private data's copy of the eeprom.
2345 *
2346 * NOTE: To better understand how these functions work (i.e what is a chip
2347 * select and why do have to keep driving the eeprom clock?), read
2348 * just about any data sheet for a Microwire compatible EEPROM.
2349 */
2350
2351/* write a 32 bit value into the indirect accessor register */
2352static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2353{
2354 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
bf79451e 2355
43f66a6c
JK		 2356 /* the eeprom requires some time to complete the operation */
2357 udelay(p->eeprom_delay);
2358
2359 return;
2360}
2361
2362/* perform a chip select operation */
858119e1 2363static void eeprom_cs(struct ipw_priv *priv)
43f66a6c 2364{
0edd5b44
JG		 2365 eeprom_write_reg(priv, 0);
2366 eeprom_write_reg(priv, EEPROM_BIT_CS);
2367 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2368 eeprom_write_reg(priv, EEPROM_BIT_CS);
43f66a6c
JK		 2369}
2370
2371/* perform a chip select operation */
858119e1 2372static void eeprom_disable_cs(struct ipw_priv *priv)
43f66a6c 2373{
0edd5b44
JG		 2374 eeprom_write_reg(priv, EEPROM_BIT_CS);
2375 eeprom_write_reg(priv, 0);
2376 eeprom_write_reg(priv, EEPROM_BIT_SK);
43f66a6c
JK		 2377}
2378
2379/* push a single bit down to the eeprom */
0edd5b44 2380static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
43f66a6c 2381{
0edd5b44
JG		 2382 int d = (bit ? EEPROM_BIT_DI : 0);
2383 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2384 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
43f66a6c
JK		 2385}
2386
2387/* push an opcode followed by an address down to the eeprom */
0edd5b44 2388static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
43f66a6c
JK		 2389{
2390 int i;
2391
2392 eeprom_cs(priv);
0edd5b44
JG		 2393 eeprom_write_bit(priv, 1);
2394 eeprom_write_bit(priv, op & 2);
2395 eeprom_write_bit(priv, op & 1);
2396 for (i = 7; i >= 0; i--) {
2397 eeprom_write_bit(priv, addr & (1 << i));
43f66a6c
JK		 2398 }
2399}
2400
2401/* pull 16 bits off the eeprom, one bit at a time */
0edd5b44 2402static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
43f66a6c
JK		 2403{
2404 int i;
0edd5b44 2405 u16 r = 0;
bf79451e 2406
43f66a6c 2407 /* Send READ Opcode */
0edd5b44 2408 eeprom_op(priv, EEPROM_CMD_READ, addr);
43f66a6c
JK		 2409
2410 /* Send dummy bit */
0edd5b44 2411 eeprom_write_reg(priv, EEPROM_BIT_CS);
43f66a6c
JK		 2412
2413 /* Read the byte off the eeprom one bit at a time */
0edd5b44 2414 for (i = 0; i < 16; i++) {
43f66a6c 2415 u32 data = 0;
0edd5b44
JG		 2416 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2417 eeprom_write_reg(priv, EEPROM_BIT_CS);
2418 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2419 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
43f66a6c 2420 }
bf79451e 2421
43f66a6c 2422 /* Send another dummy bit */
0edd5b44 2423 eeprom_write_reg(priv, 0);
43f66a6c 2424 eeprom_disable_cs(priv);
bf79451e 2425
43f66a6c
JK		 2426 return r;
2427}
2428
2429/* helper function for pulling the mac address out of the private */
2430/* data's copy of the eeprom data */
0edd5b44 2431static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
43f66a6c 2432{
afbf30a2 2433 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
43f66a6c
JK		 2434}
2435
2436/*
2437 * Either the device driver (i.e. the host) or the firmware can
2438 * load eeprom data into the designated region in SRAM. If neither
2439 * happens then the FW will shutdown with a fatal error.
2440 *
2441 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2442 * bit needs region of shared SRAM needs to be non-zero.
2443 */
2444static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2445{
2446 int i;
0edd5b44 2447 u16 *eeprom = (u16 *) priv->eeprom;
bf79451e 2448
43f66a6c
JK		 2449 IPW_DEBUG_TRACE(">>\n");
2450
2451 /* read entire contents of eeprom into private buffer */
0edd5b44 2452 for (i = 0; i < 128; i++)
a613bffd 2453 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
43f66a6c 2454
bf79451e
JG		 2455 /*
2456 If the data looks correct, then copy it to our private
43f66a6c 2457 copy. Otherwise let the firmware know to perform the operation
c7b6a674 2458 on its own.
0edd5b44 2459 */
386093ef 2460 if (priv->eeprom[EEPROM_VERSION] != 0) {
43f66a6c
JK		 2461 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2462
2463 /* write the eeprom data to sram */
b095c381 2464 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
0edd5b44 2465 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
43f66a6c
JK		 2466
2467 /* Do not load eeprom data on fatal error or suspend */
2468 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2469 } else {
2470 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2471
2472 /* Load eeprom data on fatal error or suspend */
2473 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2474 }
2475
2476 IPW_DEBUG_TRACE("<<\n");
2477}
2478
858119e1 2479static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
43f66a6c
JK		 2480{
2481 count >>= 2;
0edd5b44
JG		 2482 if (!count)
2483 return;
b095c381 2484 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
bf79451e 2485 while (count--)
b095c381 2486 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
43f66a6c
JK		 2487}
2488
2489static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2490{
b095c381 2491 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
bf79451e 2492 CB_NUMBER_OF_ELEMENTS_SMALL *
43f66a6c
JK		 2493 sizeof(struct command_block));
2494}
2495
2496static int ipw_fw_dma_enable(struct ipw_priv *priv)
0edd5b44 2497{ /* start dma engine but no transfers yet */
43f66a6c
JK		 2498
2499 IPW_DEBUG_FW(">> : \n");
bf79451e 2500
43f66a6c
JK		 2501 /* Start the dma */
2502 ipw_fw_dma_reset_command_blocks(priv);
bf79451e 2503
43f66a6c 2504 /* Write CB base address */
b095c381 2505 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
43f66a6c
JK		 2506
2507 IPW_DEBUG_FW("<< : \n");
2508 return 0;
2509}
2510
2511static void ipw_fw_dma_abort(struct ipw_priv *priv)
2512{
2513 u32 control = 0;
2514
2515 IPW_DEBUG_FW(">> :\n");
bf79451e
JG		 2516
2517 //set the Stop and Abort bit
43f66a6c 2518 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
b095c381 2519 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
43f66a6c 2520 priv->sram_desc.last_cb_index = 0;
bf79451e 2521
43f66a6c
JK		 2522 IPW_DEBUG_FW("<< \n");
2523}
2524
0edd5b44
JG		 2525static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2526 struct command_block *cb)
43f66a6c 2527{
0edd5b44 2528 u32 address =
b095c381 2529 IPW_SHARED_SRAM_DMA_CONTROL +
0edd5b44 2530 (sizeof(struct command_block) * index);
43f66a6c
JK		 2531 IPW_DEBUG_FW(">> :\n");
2532
0edd5b44
JG		 2533 ipw_write_indirect(priv, address, (u8 *) cb,
2534 (int)sizeof(struct command_block));
43f66a6c
JK		 2535
2536 IPW_DEBUG_FW("<< :\n");
2537 return 0;
2538
2539}
2540
2541static int ipw_fw_dma_kick(struct ipw_priv *priv)
2542{
2543 u32 control = 0;
0edd5b44 2544 u32 index = 0;
43f66a6c
JK		 2545
2546 IPW_DEBUG_FW(">> :\n");
bf79451e 2547
43f66a6c 2548 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
0edd5b44
JG		 2549 ipw_fw_dma_write_command_block(priv, index,
2550 &priv->sram_desc.cb_list[index]);
43f66a6c
JK		 2551
2552 /* Enable the DMA in the CSR register */
b095c381
JK		 2553 ipw_clear_bit(priv, IPW_RESET_REG,
2554 IPW_RESET_REG_MASTER_DISABLED |
2555 IPW_RESET_REG_STOP_MASTER);
bf79451e 2556
0edd5b44 2557 /* Set the Start bit. */
43f66a6c 2558 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
b095c381 2559 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
43f66a6c
JK		 2560
2561 IPW_DEBUG_FW("<< :\n");
2562 return 0;
2563}
2564
2565static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2566{
2567 u32 address;
0edd5b44
JG		 2568 u32 register_value = 0;
2569 u32 cb_fields_address = 0;
43f66a6c
JK		 2570
2571 IPW_DEBUG_FW(">> :\n");
b095c381 2572 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
0edd5b44 2573 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
43f66a6c
JK		 2574
2575 /* Read the DMA Controlor register */
b095c381
JK		 2576 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2577 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
43f66a6c 2578
0edd5b44 2579 /* Print the CB values */
43f66a6c
JK		 2580 cb_fields_address = address;
2581 register_value = ipw_read_reg32(priv, cb_fields_address);
0edd5b44 2582 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
43f66a6c
JK		 2583
2584 cb_fields_address += sizeof(u32);
2585 register_value = ipw_read_reg32(priv, cb_fields_address);
0edd5b44 2586 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
43f66a6c
JK		 2587
2588 cb_fields_address += sizeof(u32);
2589 register_value = ipw_read_reg32(priv, cb_fields_address);
2590 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2591 register_value);
2592
2593 cb_fields_address += sizeof(u32);
2594 register_value = ipw_read_reg32(priv, cb_fields_address);
0edd5b44 2595 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
43f66a6c
JK		 2596
2597 IPW_DEBUG_FW(">> :\n");
2598}
2599
2600static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2601{
2602 u32 current_cb_address = 0;
2603 u32 current_cb_index = 0;
2604
2605 IPW_DEBUG_FW("<< :\n");
b095c381 2606 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
bf79451e 2607
b095c381 2608 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
0edd5b44 2609 sizeof(struct command_block);
bf79451e 2610
43f66a6c 2611 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
0edd5b44 2612 current_cb_index, current_cb_address);
43f66a6c
JK		 2613
2614 IPW_DEBUG_FW(">> :\n");
2615 return current_cb_index;
2616
2617}
2618
2619static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2620 u32 src_address,
2621 u32 dest_address,
2622 u32 length,
0edd5b44 2623 int interrupt_enabled, int is_last)
43f66a6c
JK		 2624{
2625
bf79451e 2626 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
0edd5b44
JG		 2627 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2628 CB_DEST_SIZE_LONG;
43f66a6c 2629 struct command_block *cb;
0edd5b44 2630 u32 last_cb_element = 0;
43f66a6c
JK		 2631
2632 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2633 src_address, dest_address, length);
2634
2635 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2636 return -1;
2637
2638 last_cb_element = priv->sram_desc.last_cb_index;
2639 cb = &priv->sram_desc.cb_list[last_cb_element];
2640 priv->sram_desc.last_cb_index++;
2641
2642 /* Calculate the new CB control word */
0edd5b44 2643 if (interrupt_enabled)
43f66a6c
JK		 2644 control |= CB_INT_ENABLED;
2645
2646 if (is_last)
2647 control |= CB_LAST_VALID;
bf79451e 2648
43f66a6c
JK		 2649 control |= length;
2650
2651 /* Calculate the CB Element's checksum value */
0edd5b44 2652 cb->status = control ^ src_address ^ dest_address;
43f66a6c
JK		 2653
2654 /* Copy the Source and Destination addresses */
2655 cb->dest_addr = dest_address;
2656 cb->source_addr = src_address;
2657
2658 /* Copy the Control Word last */
2659 cb->control = control;
2660
2661 return 0;
2662}
2663
2664static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
0edd5b44 2665 u32 src_phys, u32 dest_address, u32 length)
43f66a6c
JK		 2666{
2667 u32 bytes_left = length;
0edd5b44
JG		 2668 u32 src_offset = 0;
2669 u32 dest_offset = 0;
43f66a6c
JK		 2670 int status = 0;
2671 IPW_DEBUG_FW(">> \n");
2672 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2673 src_phys, dest_address, length);
2674 while (bytes_left > CB_MAX_LENGTH) {
0edd5b44
JG		 2675 status = ipw_fw_dma_add_command_block(priv,
2676 src_phys + src_offset,
2677 dest_address +
2678 dest_offset,
2679 CB_MAX_LENGTH, 0, 0);
43f66a6c
JK		 2680 if (status) {
2681 IPW_DEBUG_FW_INFO(": Failed\n");
2682 return -1;
bf79451e 2683 } else
43f66a6c
JK		 2684 IPW_DEBUG_FW_INFO(": Added new cb\n");
2685
2686 src_offset += CB_MAX_LENGTH;
2687 dest_offset += CB_MAX_LENGTH;
2688 bytes_left -= CB_MAX_LENGTH;
2689 }
2690
2691 /* add the buffer tail */
2692 if (bytes_left > 0) {
0edd5b44
JG		 2693 status =
2694 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2695 dest_address + dest_offset,
2696 bytes_left, 0, 0);
43f66a6c
JK		 2697 if (status) {
2698 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2699 return -1;
bf79451e 2700 } else
0edd5b44
JG		 2701 IPW_DEBUG_FW_INFO
2702 (": Adding new cb - the buffer tail\n");
43f66a6c 2703 }
bf79451e 2704
43f66a6c
JK		 2705 IPW_DEBUG_FW("<< \n");
2706 return 0;
2707}
2708
2709static int ipw_fw_dma_wait(struct ipw_priv *priv)
2710{
397ae121 2711 u32 current_index = 0, previous_index;
43f66a6c
JK		 2712 u32 watchdog = 0;
2713
2714 IPW_DEBUG_FW(">> : \n");
2715
2716 current_index = ipw_fw_dma_command_block_index(priv);
397ae121 2717 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%08X\n",
0edd5b44 2718 (int)priv->sram_desc.last_cb_index);
43f66a6c
JK		 2719
2720 while (current_index < priv->sram_desc.last_cb_index) {
2721 udelay(50);
397ae121 2722 previous_index = current_index;
43f66a6c
JK		 2723 current_index = ipw_fw_dma_command_block_index(priv);
2724
397ae121
ZY		 2725 if (previous_index < current_index) {
2726 watchdog = 0;
2727 continue;
2728 }
2729 if (++watchdog > 400) {
43f66a6c
JK		 2730 IPW_DEBUG_FW_INFO("Timeout\n");
2731 ipw_fw_dma_dump_command_block(priv);
2732 ipw_fw_dma_abort(priv);
2733 return -1;
2734 }
2735 }
2736
2737 ipw_fw_dma_abort(priv);
2738
0edd5b44 2739 /*Disable the DMA in the CSR register */
b095c381
JK		 2740 ipw_set_bit(priv, IPW_RESET_REG,
2741 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
43f66a6c
JK		 2742
2743 IPW_DEBUG_FW("<< dmaWaitSync \n");
2744 return 0;
2745}
2746
bf79451e 2747static void ipw_remove_current_network(struct ipw_priv *priv)
43f66a6c
JK		 2748{
2749 struct list_head *element, *safe;
bf79451e 2750 struct ieee80211_network *network = NULL;
a613bffd
JK		 2751 unsigned long flags;
2752
2753 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c
JK		 2754 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2755 network = list_entry(element, struct ieee80211_network, list);
2756 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2757 list_del(element);
bf79451e 2758 list_add_tail(&network->list,
43f66a6c
JK		 2759 &priv->ieee->network_free_list);
2760 }
2761 }
a613bffd 2762 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c
JK		 2763}
2764
2765/**
bf79451e 2766 * Check that card is still alive.
43f66a6c
JK		 2767 * Reads debug register from domain0.
2768 * If card is present, pre-defined value should
2769 * be found there.
bf79451e 2770 *
43f66a6c
JK		 2771 * @param priv
2772 * @return 1 if card is present, 0 otherwise
2773 */
2774static inline int ipw_alive(struct ipw_priv *priv)
2775{
2776 return ipw_read32(priv, 0x90) == 0xd55555d5;
2777}
2778
c7b6a674 2779/* timeout in msec, attempted in 10-msec quanta */
858119e1 2780static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
43f66a6c
JK		 2781 int timeout)
2782{
2783 int i = 0;
2784
2785 do {
bf79451e 2786 if ((ipw_read32(priv, addr) & mask) == mask)
43f66a6c
JK		 2787 return i;
2788 mdelay(10);
2789 i += 10;
2790 } while (i < timeout);
bf79451e 2791
43f66a6c
JK		 2792 return -ETIME;
2793}
2794
bf79451e 2795/* These functions load the firmware and micro code for the operation of
43f66a6c
JK		 2796 * the ipw hardware. It assumes the buffer has all the bits for the
2797 * image and the caller is handling the memory allocation and clean up.
2798 */
2799
0edd5b44 2800static int ipw_stop_master(struct ipw_priv *priv)
43f66a6c
JK		 2801{
2802 int rc;
bf79451e 2803
43f66a6c
JK		 2804 IPW_DEBUG_TRACE(">> \n");
2805 /* stop master. typical delay - 0 */
b095c381 2806 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
43f66a6c 2807
c7b6a674 2808 /* timeout is in msec, polled in 10-msec quanta */
b095c381
JK		 2809 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2810 IPW_RESET_REG_MASTER_DISABLED, 100);
43f66a6c 2811 if (rc < 0) {
c7b6a674 2812 IPW_ERROR("wait for stop master failed after 100ms\n");
43f66a6c
JK		 2813 return -1;
2814 }
2815
2816 IPW_DEBUG_INFO("stop master %dms\n", rc);
2817
2818 return rc;
2819}
2820
2821static void ipw_arc_release(struct ipw_priv *priv)
2822{
2823 IPW_DEBUG_TRACE(">> \n");
2824 mdelay(5);
2825
b095c381 2826 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
43f66a6c
JK		 2827
2828 /* no one knows timing, for safety add some delay */
2829 mdelay(5);
2830}
2831
2832struct fw_header {
2833 u32 version;
2834 u32 mode;
2835};
2836
2837struct fw_chunk {
2838 u32 address;
2839 u32 length;
2840};
2841
2842#define IPW_FW_MAJOR_VERSION 2
81715376 2843#define IPW_FW_MINOR_VERSION 4
43f66a6c
JK		 2844
2845#define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2846#define IPW_FW_MAJOR(x) (x & 0xff)
2847
afbf30a2 2848#define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
43f66a6c
JK		 2849
2850#define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2851"." __stringify(IPW_FW_MINOR_VERSION) "-"
2852
2853#if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2854#define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2855#else
2856#define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2857#endif
2858
0edd5b44 2859static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
43f66a6c
JK		 2860{
2861 int rc = 0, i, addr;
2862 u8 cr = 0;
2863 u16 *image;
2864
0edd5b44 2865 image = (u16 *) data;
bf79451e 2866
43f66a6c
JK		 2867 IPW_DEBUG_TRACE(">> \n");
2868
2869 rc = ipw_stop_master(priv);
2870
2871 if (rc < 0)
2872 return rc;
bf79451e 2873
0edd5b44 2874// spin_lock_irqsave(&priv->lock, flags);
bf79451e 2875
b095c381
JK		 2876 for (addr = IPW_SHARED_LOWER_BOUND;
2877 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
43f66a6c
JK		 2878 ipw_write32(priv, addr, 0);
2879 }
2880
2881 /* no ucode (yet) */
2882 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2883 /* destroy DMA queues */
2884 /* reset sequence */
2885
b095c381 2886 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
43f66a6c 2887 ipw_arc_release(priv);
b095c381 2888 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
43f66a6c
JK		 2889 mdelay(1);
2890
2891 /* reset PHY */
b095c381 2892 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
43f66a6c 2893 mdelay(1);
bf79451e 2894
b095c381 2895 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
43f66a6c 2896 mdelay(1);
bf79451e 2897
43f66a6c 2898 /* enable ucode store */
c8fe6679
ZY		 2899 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
2900 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
43f66a6c
JK		 2901 mdelay(1);
2902
2903 /* write ucode */
2904 /**
2905 * @bug
2906 * Do NOT set indirect address register once and then
2907 * store data to indirect data register in the loop.
2908 * It seems very reasonable, but in this case DINO do not
2909 * accept ucode. It is essential to set address each time.
2910 */
2911 /* load new ipw uCode */
2912 for (i = 0; i < len / 2; i++)
b095c381 2913 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
a613bffd 2914 cpu_to_le16(image[i]));
43f66a6c 2915
43f66a6c 2916 /* enable DINO */
b095c381
JK		 2917 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2918 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
43f66a6c 2919
0edd5b44 2920 /* this is where the igx / win driver deveates from the VAP driver. */
43f66a6c
JK		 2921
2922 /* wait for alive response */
2923 for (i = 0; i < 100; i++) {
2924 /* poll for incoming data */
b095c381 2925 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
43f66a6c
JK		 2926 if (cr & DINO_RXFIFO_DATA)
2927 break;
2928 mdelay(1);
2929 }
2930
2931 if (cr & DINO_RXFIFO_DATA) {
2932 /* alive_command_responce size is NOT multiple of 4 */
2933 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
bf79451e
JG		 2934
2935 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
43f66a6c 2936 response_buffer[i] =
a613bffd 2937 le32_to_cpu(ipw_read_reg32(priv,
b095c381 2938 IPW_BASEBAND_RX_FIFO_READ));
43f66a6c
JK		 2939 memcpy(&priv->dino_alive, response_buffer,
2940 sizeof(priv->dino_alive));
2941 if (priv->dino_alive.alive_command == 1
2942 && priv->dino_alive.ucode_valid == 1) {
2943 rc = 0;
0edd5b44
JG		 2944 IPW_DEBUG_INFO
2945 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2946 "of %02d/%02d/%02d %02d:%02d\n",
2947 priv->dino_alive.software_revision,
2948 priv->dino_alive.software_revision,
2949 priv->dino_alive.device_identifier,
2950 priv->dino_alive.device_identifier,
2951 priv->dino_alive.time_stamp[0],
2952 priv->dino_alive.time_stamp[1],
2953 priv->dino_alive.time_stamp[2],
2954 priv->dino_alive.time_stamp[3],
2955 priv->dino_alive.time_stamp[4]);
43f66a6c
JK		 2956 } else {
2957 IPW_DEBUG_INFO("Microcode is not alive\n");
2958 rc = -EINVAL;
2959 }
2960 } else {
2961 IPW_DEBUG_INFO("No alive response from DINO\n");
2962 rc = -ETIME;
2963 }
2964
2965 /* disable DINO, otherwise for some reason
2966 firmware have problem getting alive resp. */
b095c381 2967 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
43f66a6c 2968
0edd5b44 2969// spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c
JK		 2970
2971 return rc;
2972}
2973
0edd5b44 2974static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
43f66a6c
JK		 2975{
2976 int rc = -1;
2977 int offset = 0;
2978 struct fw_chunk *chunk;
2979 dma_addr_t shared_phys;
2980 u8 *shared_virt;
2981
2982 IPW_DEBUG_TRACE("<< : \n");
2983 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2984
2985 if (!shared_virt)
2986 return -ENOMEM;
2987
2988 memmove(shared_virt, data, len);
2989
2990 /* Start the Dma */
2991 rc = ipw_fw_dma_enable(priv);
2992
2993 if (priv->sram_desc.last_cb_index > 0) {
2994 /* the DMA is already ready this would be a bug. */
2995 BUG();
2996 goto out;
2997 }
2998
2999 do {
3000 chunk = (struct fw_chunk *)(data + offset);
3001 offset += sizeof(struct fw_chunk);
3002 /* build DMA packet and queue up for sending */
bf79451e 3003 /* dma to chunk->address, the chunk->length bytes from data +
43f66a6c
JK		 3004 * offeset*/
3005 /* Dma loading */
3006 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
a613bffd
JK		 3007 le32_to_cpu(chunk->address),
3008 le32_to_cpu(chunk->length));
43f66a6c
JK		 3009 if (rc) {
3010 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3011 goto out;
3012 }
bf79451e 3013
a613bffd 3014 offset += le32_to_cpu(chunk->length);
43f66a6c
JK		 3015 } while (offset < len);
3016
0edd5b44 3017 /* Run the DMA and wait for the answer */
43f66a6c
JK		 3018 rc = ipw_fw_dma_kick(priv);
3019 if (rc) {
3020 IPW_ERROR("dmaKick Failed\n");
3021 goto out;
3022 }
3023
3024 rc = ipw_fw_dma_wait(priv);
3025 if (rc) {
3026 IPW_ERROR("dmaWaitSync Failed\n");
3027 goto out;
3028 }
0edd5b44
JG		 3029 out:
3030 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
43f66a6c
JK		 3031 return rc;
3032}
3033
3034/* stop nic */
3035static int ipw_stop_nic(struct ipw_priv *priv)
3036{
3037 int rc = 0;
3038
0edd5b44 3039 /* stop */
b095c381 3040 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
bf79451e 3041
b095c381
JK		 3042 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3043 IPW_RESET_REG_MASTER_DISABLED, 500);
43f66a6c 3044 if (rc < 0) {
c7b6a674 3045 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
43f66a6c 3046 return rc;
bf79451e 3047 }
43f66a6c 3048
b095c381 3049 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
bf79451e 3050
43f66a6c
JK		 3051 return rc;
3052}
3053
3054static void ipw_start_nic(struct ipw_priv *priv)
3055{
3056 IPW_DEBUG_TRACE(">>\n");
3057
0edd5b44 3058 /* prvHwStartNic release ARC */
b095c381
JK		 3059 ipw_clear_bit(priv, IPW_RESET_REG,
3060 IPW_RESET_REG_MASTER_DISABLED |
3061 IPW_RESET_REG_STOP_MASTER |
43f66a6c 3062 CBD_RESET_REG_PRINCETON_RESET);
bf79451e 3063
43f66a6c 3064 /* enable power management */
b095c381
JK		 3065 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3066 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
43f66a6c
JK		 3067
3068 IPW_DEBUG_TRACE("<<\n");
3069}
bf79451e 3070
43f66a6c
JK		 3071static int ipw_init_nic(struct ipw_priv *priv)
3072{
3073 int rc;
3074
3075 IPW_DEBUG_TRACE(">>\n");
bf79451e 3076 /* reset */
43f66a6c
JK		 3077 /*prvHwInitNic */
3078 /* set "initialization complete" bit to move adapter to D0 state */
b095c381 3079 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
43f66a6c
JK		 3080
3081 /* low-level PLL activation */
b095c381
JK		 3082 ipw_write32(priv, IPW_READ_INT_REGISTER,
3083 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
43f66a6c
JK		 3084
3085 /* wait for clock stabilization */
b095c381
JK		 3086 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3087 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
0edd5b44 3088 if (rc < 0)
43f66a6c
JK		 3089 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3090
3091 /* assert SW reset */
b095c381 3092 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
43f66a6c
JK		 3093
3094 udelay(10);
3095
3096 /* set "initialization complete" bit to move adapter to D0 state */
b095c381 3097 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
43f66a6c
JK		 3098
3099 IPW_DEBUG_TRACE(">>\n");
3100 return 0;
3101}
3102
bf79451e 3103/* Call this function from process context, it will sleep in request_firmware.
43f66a6c
JK		 3104 * Probe is an ok place to call this from.
3105 */
3106static int ipw_reset_nic(struct ipw_priv *priv)
3107{
3108 int rc = 0;
a613bffd 3109 unsigned long flags;
43f66a6c
JK		 3110
3111 IPW_DEBUG_TRACE(">>\n");
bf79451e 3112
43f66a6c 3113 rc = ipw_init_nic(priv);
bf79451e 3114
a613bffd 3115 spin_lock_irqsave(&priv->lock, flags);
43f66a6c
JK		 3116 /* Clear the 'host command active' bit... */
3117 priv->status &= ~STATUS_HCMD_ACTIVE;
3118 wake_up_interruptible(&priv->wait_command_queue);
afbf30a2
JK		 3119 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3120 wake_up_interruptible(&priv->wait_state);
a613bffd 3121 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c
JK		 3122
3123 IPW_DEBUG_TRACE("<<\n");
3124 return rc;
bf79451e 3125}
43f66a6c 3126
bf79451e 3127static int ipw_get_fw(struct ipw_priv *priv,
43f66a6c
JK		 3128 const struct firmware **fw, const char *name)
3129{
3130 struct fw_header *header;
3131 int rc;
3132
3133 /* ask firmware_class module to get the boot firmware off disk */
3134 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3135 if (rc < 0) {
3136 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3137 return rc;
bf79451e 3138 }
43f66a6c
JK		 3139
3140 header = (struct fw_header *)(*fw)->data;
a613bffd 3141 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
43f66a6c
JK		 3142 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3143 name,
a613bffd
JK		 3144 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3145 IPW_FW_MAJOR_VERSION);
43f66a6c
JK		 3146 return -EINVAL;
3147 }
3148
aaa4d308 3149 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
43f66a6c 3150 name,
a613bffd
JK		 3151 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3152 IPW_FW_MINOR(le32_to_cpu(header->version)),
43f66a6c
JK		 3153 (*fw)->size - sizeof(struct fw_header));
3154 return 0;
3155}
3156
b095c381 3157#define IPW_RX_BUF_SIZE (3000)
43f66a6c 3158
858119e1 3159static void ipw_rx_queue_reset(struct ipw_priv *priv,
43f66a6c
JK		 3160 struct ipw_rx_queue *rxq)
3161{
3162 unsigned long flags;
3163 int i;
3164
3165 spin_lock_irqsave(&rxq->lock, flags);
3166
3167 INIT_LIST_HEAD(&rxq->rx_free);
3168 INIT_LIST_HEAD(&rxq->rx_used);
3169
3170 /* Fill the rx_used queue with _all_ of the Rx buffers */
3171 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3172 /* In the reset function, these buffers may have been allocated
3173 * to an SKB, so we need to unmap and free potential storage */
3174 if (rxq->pool[i].skb != NULL) {
3175 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
b095c381 3176 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 3177 dev_kfree_skb(rxq->pool[i].skb);
a613bffd 3178 rxq->pool[i].skb = NULL;
43f66a6c
JK		 3179 }
3180 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3181 }
bf79451e 3182
43f66a6c
JK		 3183 /* Set us so that we have processed and used all buffers, but have
3184 * not restocked the Rx queue with fresh buffers */
3185 rxq->read = rxq->write = 0;
3186 rxq->processed = RX_QUEUE_SIZE - 1;
3187 rxq->free_count = 0;
3188 spin_unlock_irqrestore(&rxq->lock, flags);
3189}
3190
3191#ifdef CONFIG_PM
3192static int fw_loaded = 0;
3193static const struct firmware *bootfw = NULL;
3194static const struct firmware *firmware = NULL;
3195static const struct firmware *ucode = NULL;
afbf30a2
JK		 3196
3197static void free_firmware(void)
3198{
3199 if (fw_loaded) {
3200 release_firmware(bootfw);
3201 release_firmware(ucode);
3202 release_firmware(firmware);
3203 bootfw = ucode = firmware = NULL;
3204 fw_loaded = 0;
3205 }
3206}
3207#else
3208#define free_firmware() do {} while (0)
43f66a6c
JK		 3209#endif
3210
3211static int ipw_load(struct ipw_priv *priv)
3212{
3213#ifndef CONFIG_PM
3214 const struct firmware *bootfw = NULL;
3215 const struct firmware *firmware = NULL;
3216 const struct firmware *ucode = NULL;
3217#endif
397ae121
ZY		 3218 char *ucode_name;
3219 char *fw_name;
43f66a6c
JK		 3220 int rc = 0, retries = 3;
3221
397ae121
ZY		 3222 switch (priv->ieee->iw_mode) {
3223 case IW_MODE_ADHOC:
3224 ucode_name = IPW_FW_NAME("ibss_ucode");
3225 fw_name = IPW_FW_NAME("ibss");
3226 break;
b095c381 3227#ifdef CONFIG_IPW2200_MONITOR
397ae121
ZY		 3228 case IW_MODE_MONITOR:
3229 ucode_name = IPW_FW_NAME("sniffer_ucode");
3230 fw_name = IPW_FW_NAME("sniffer");
3231 break;
43f66a6c 3232#endif
397ae121
ZY		 3233 case IW_MODE_INFRA:
3234 ucode_name = IPW_FW_NAME("bss_ucode");
3235 fw_name = IPW_FW_NAME("bss");
3236 break;
3237 default:
3238 rc = -EINVAL;
43f66a6c 3239 }
397ae121
ZY		 3240
3241 if (rc < 0)
3242 goto error;
43f66a6c
JK		 3243
3244 if (!priv->rxq)
3245 priv->rxq = ipw_rx_queue_alloc(priv);
3246 else
3247 ipw_rx_queue_reset(priv, priv->rxq);
3248 if (!priv->rxq) {
3249 IPW_ERROR("Unable to initialize Rx queue\n");
3250 goto error;
3251 }
3252
0edd5b44 3253 retry:
43f66a6c 3254 /* Ensure interrupts are disabled */
b095c381 3255 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
43f66a6c
JK		 3256 priv->status &= ~STATUS_INT_ENABLED;
3257
3258 /* ack pending interrupts */
b095c381 3259 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
bf79451e 3260
43f66a6c
JK		 3261 ipw_stop_nic(priv);
3262
3263 rc = ipw_reset_nic(priv);
397ae121 3264 if (rc < 0) {
43f66a6c
JK		 3265 IPW_ERROR("Unable to reset NIC\n");
3266 goto error;
3267 }
3268
b095c381
JK		 3269 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3270 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
43f66a6c 3271
397ae121
ZY		 3272#ifdef CONFIG_PM
3273 if (!fw_loaded) {
3274#endif
3275 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3276 if (rc < 0)
3277 goto error;
3278#ifdef CONFIG_PM
3279 }
3280#endif
43f66a6c 3281 /* DMA the initial boot firmware into the device */
bf79451e 3282 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
43f66a6c
JK		 3283 bootfw->size - sizeof(struct fw_header));
3284 if (rc < 0) {
a4f6bbb3 3285 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
43f66a6c
JK		 3286 goto error;
3287 }
3288
3289 /* kick start the device */
3290 ipw_start_nic(priv);
3291
c7b6a674 3292 /* wait for the device to finish its initial startup sequence */
b095c381
JK		 3293 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3294 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
43f66a6c
JK		 3295 if (rc < 0) {
3296 IPW_ERROR("device failed to boot initial fw image\n");
3297 goto error;
3298 }
3299 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3300
bf79451e 3301 /* ack fw init done interrupt */
b095c381 3302 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
43f66a6c 3303
397ae121
ZY		 3304#ifdef CONFIG_PM
3305 if (!fw_loaded) {
3306#endif
3307 rc = ipw_get_fw(priv, &ucode, ucode_name);
3308 if (rc < 0)
3309 goto error;
3310#ifdef CONFIG_PM
3311 }
3312#endif
2638bc39 3313
43f66a6c 3314 /* DMA the ucode into the device */
bf79451e 3315 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
43f66a6c
JK		 3316 ucode->size - sizeof(struct fw_header));
3317 if (rc < 0) {
a4f6bbb3 3318 IPW_ERROR("Unable to load ucode: %d\n", rc);
43f66a6c
JK		 3319 goto error;
3320 }
bf79451e 3321
43f66a6c
JK		 3322 /* stop nic */
3323 ipw_stop_nic(priv);
3324
397ae121
ZY		 3325#ifdef CONFIG_PM
3326 if (!fw_loaded) {
3327#endif
3328 rc = ipw_get_fw(priv, &firmware, fw_name);
3329 if (rc < 0)
3330 goto error;
3331#ifdef CONFIG_PM
3332 }
3333#endif
3334
43f66a6c 3335 /* DMA bss firmware into the device */
bf79451e
JG		 3336 rc = ipw_load_firmware(priv, firmware->data +
3337 sizeof(struct fw_header),
43f66a6c 3338 firmware->size - sizeof(struct fw_header));
0edd5b44 3339 if (rc < 0) {
a4f6bbb3 3340 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 3341 goto error;
3342 }
397ae121
ZY		 3343#ifdef CONFIG_PM
3344 fw_loaded = 1;
3345#endif
3346
43f66a6c
JK		 3347 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3348
3349 rc = ipw_queue_reset(priv);
397ae121 3350 if (rc < 0) {
43f66a6c
JK		 3351 IPW_ERROR("Unable to initialize queues\n");
3352 goto error;
3353 }
3354
3355 /* Ensure interrupts are disabled */
b095c381 3356 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
c848d0af 3357 /* ack pending interrupts */
b095c381 3358 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
bf79451e 3359
43f66a6c
JK		 3360 /* kick start the device */
3361 ipw_start_nic(priv);
3362
b095c381 3363 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
43f66a6c
JK		 3364 if (retries > 0) {
3365 IPW_WARNING("Parity error. Retrying init.\n");
3366 retries--;
3367 goto retry;
3368 }
3369
3370 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3371 rc = -EIO;
3372 goto error;
3373 }
3374
3375 /* wait for the device */
b095c381
JK		 3376 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3377 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
43f66a6c 3378 if (rc < 0) {
c7b6a674 3379 IPW_ERROR("device failed to start within 500ms\n");
43f66a6c
JK		 3380 goto error;
3381 }
3382 IPW_DEBUG_INFO("device response after %dms\n", rc);
3383
3384 /* ack fw init done interrupt */
b095c381 3385 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
43f66a6c
JK		 3386
3387 /* read eeprom data and initialize the eeprom region of sram */
3388 priv->eeprom_delay = 1;
bf79451e 3389 ipw_eeprom_init_sram(priv);
43f66a6c
JK		 3390
3391 /* enable interrupts */
3392 ipw_enable_interrupts(priv);
3393
3394 /* Ensure our queue has valid packets */
3395 ipw_rx_queue_replenish(priv);
3396
b095c381 3397 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
43f66a6c
JK		 3398
3399 /* ack pending interrupts */
b095c381 3400 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
43f66a6c
JK		 3401
3402#ifndef CONFIG_PM
3403 release_firmware(bootfw);
3404 release_firmware(ucode);
3405 release_firmware(firmware);
3406#endif
3407 return 0;
3408
0edd5b44 3409 error:
43f66a6c
JK		 3410 if (priv->rxq) {
3411 ipw_rx_queue_free(priv, priv->rxq);
3412 priv->rxq = NULL;
3413 }
3414 ipw_tx_queue_free(priv);
3415 if (bootfw)
3416 release_firmware(bootfw);
3417 if (ucode)
3418 release_firmware(ucode);
3419 if (firmware)
3420 release_firmware(firmware);
3421#ifdef CONFIG_PM
3422 fw_loaded = 0;
3423 bootfw = ucode = firmware = NULL;
3424#endif
3425
3426 return rc;
3427}
3428
bf79451e 3429/**
43f66a6c
JK		 3430 * DMA services
3431 *
3432 * Theory of operation
3433 *
3434 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3435 * 2 empty entries always kept in the buffer to protect from overflow.
3436 *
3437 * For Tx queue, there are low mark and high mark limits. If, after queuing
bf79451e
JG		 3438 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3439 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
43f66a6c
JK		 3440 * Tx queue resumed.
3441 *
3442 * The IPW operates with six queues, one receive queue in the device's
3443 * sram, one transmit queue for sending commands to the device firmware,
bf79451e 3444 * and four transmit queues for data.
43f66a6c 3445 *
bf79451e 3446 * The four transmit queues allow for performing quality of service (qos)
43f66a6c 3447 * transmissions as per the 802.11 protocol. Currently Linux does not
bf79451e 3448 * provide a mechanism to the user for utilizing prioritized queues, so
43f66a6c
JK		 3449 * we only utilize the first data transmit queue (queue1).
3450 */
3451
3452/**
3453 * Driver allocates buffers of this size for Rx
3454 */
3455
3456static inline int ipw_queue_space(const struct clx2_queue *q)
3457{
3458 int s = q->last_used - q->first_empty;
3459 if (s <= 0)
3460 s += q->n_bd;
3461 s -= 2; /* keep some reserve to not confuse empty and full situations */
3462 if (s < 0)
3463 s = 0;
3464 return s;
3465}
3466
3467static inline int ipw_queue_inc_wrap(int index, int n_bd)
3468{
3469 return (++index == n_bd) ? 0 : index;
3470}
3471
3472/**
3473 * Initialize common DMA queue structure
bf79451e 3474 *
43f66a6c
JK		 3475 * @param q queue to init
3476 * @param count Number of BD's to allocate. Should be power of 2
3477 * @param read_register Address for 'read' register
3478 * (not offset within BAR, full address)
3479 * @param write_register Address for 'write' register
3480 * (not offset within BAR, full address)
3481 * @param base_register Address for 'base' register
3482 * (not offset within BAR, full address)
3483 * @param size Address for 'size' register
3484 * (not offset within BAR, full address)
3485 */
bf79451e 3486static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
0edd5b44 3487 int count, u32 read, u32 write, u32 base, u32 size)
43f66a6c
JK		 3488{
3489 q->n_bd = count;
3490
3491 q->low_mark = q->n_bd / 4;
3492 if (q->low_mark < 4)
3493 q->low_mark = 4;
3494
3495 q->high_mark = q->n_bd / 8;
3496 if (q->high_mark < 2)
3497 q->high_mark = 2;
3498
3499 q->first_empty = q->last_used = 0;
3500 q->reg_r = read;
3501 q->reg_w = write;
3502
3503 ipw_write32(priv, base, q->dma_addr);
3504 ipw_write32(priv, size, count);
3505 ipw_write32(priv, read, 0);
3506 ipw_write32(priv, write, 0);
3507
3508 _ipw_read32(priv, 0x90);
3509}
3510
bf79451e 3511static int ipw_queue_tx_init(struct ipw_priv *priv,
43f66a6c 3512 struct clx2_tx_queue *q,
0edd5b44 3513 int count, u32 read, u32 write, u32 base, u32 size)
43f66a6c
JK		 3514{
3515 struct pci_dev *dev = priv->pci_dev;
3516
3517 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3518 if (!q->txb) {
3519 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3520 return -ENOMEM;
3521 }
3522
0edd5b44
JG		 3523 q->bd =
3524 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
43f66a6c 3525 if (!q->bd) {
aaa4d308 3526 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
0edd5b44 3527 sizeof(q->bd[0]) * count);
43f66a6c
JK		 3528 kfree(q->txb);
3529 q->txb = NULL;
3530 return -ENOMEM;
3531 }
3532
3533 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3534 return 0;
3535}
3536
3537/**
3538 * Free one TFD, those at index [txq->q.last_used].
3539 * Do NOT advance any indexes
bf79451e 3540 *
43f66a6c
JK		 3541 * @param dev
3542 * @param txq
3543 */
3544static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3545 struct clx2_tx_queue *txq)
3546{
3547 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3548 struct pci_dev *dev = priv->pci_dev;
3549 int i;
bf79451e 3550
43f66a6c
JK		 3551 /* classify bd */
3552 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3553 /* nothing to cleanup after for host commands */
3554 return;
3555
3556 /* sanity check */
a613bffd
JK		 3557 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3558 IPW_ERROR("Too many chunks: %i\n",
3559 le32_to_cpu(bd->u.data.num_chunks));
43f66a6c
JK		 3560 /** @todo issue fatal error, it is quite serious situation */
3561 return;
3562 }
3563
3564 /* unmap chunks if any */
a613bffd
JK		 3565 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3566 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3567 le16_to_cpu(bd->u.data.chunk_len[i]),
3568 PCI_DMA_TODEVICE);
43f66a6c
JK		 3569 if (txq->txb[txq->q.last_used]) {
3570 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3571 txq->txb[txq->q.last_used] = NULL;
3572 }
3573 }
3574}
3575
3576/**
3577 * Deallocate DMA queue.
bf79451e 3578 *
43f66a6c
JK		 3579 * Empty queue by removing and destroying all BD's.
3580 * Free all buffers.
bf79451e 3581 *
43f66a6c
JK		 3582 * @param dev
3583 * @param q
3584 */
0edd5b44 3585static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
43f66a6c
JK		 3586{
3587 struct clx2_queue *q = &txq->q;
3588 struct pci_dev *dev = priv->pci_dev;
3589
bf79451e
JG		 3590 if (q->n_bd == 0)
3591 return;
43f66a6c
JK		 3592
3593 /* first, empty all BD's */
3594 for (; q->first_empty != q->last_used;
3595 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3596 ipw_queue_tx_free_tfd(priv, txq);
3597 }
bf79451e 3598
43f66a6c 3599 /* free buffers belonging to queue itself */
0edd5b44 3600 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
43f66a6c
JK		 3601 q->dma_addr);
3602 kfree(txq->txb);
3603
3604 /* 0 fill whole structure */
3605 memset(txq, 0, sizeof(*txq));
3606}
3607
43f66a6c
JK		 3608/**
3609 * Destroy all DMA queues and structures
bf79451e 3610 *
43f66a6c
JK		 3611 * @param priv
3612 */
3613static void ipw_tx_queue_free(struct ipw_priv *priv)
3614{
3615 /* Tx CMD queue */
3616 ipw_queue_tx_free(priv, &priv->txq_cmd);
3617
3618 /* Tx queues */
3619 ipw_queue_tx_free(priv, &priv->txq[0]);
3620 ipw_queue_tx_free(priv, &priv->txq[1]);
3621 ipw_queue_tx_free(priv, &priv->txq[2]);
3622 ipw_queue_tx_free(priv, &priv->txq[3]);
3623}
3624
858119e1 3625static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3626{
3627 /* First 3 bytes are manufacturer */
3628 bssid[0] = priv->mac_addr[0];
3629 bssid[1] = priv->mac_addr[1];
3630 bssid[2] = priv->mac_addr[2];
3631
3632 /* Last bytes are random */
0edd5b44 3633 get_random_bytes(&bssid[3], ETH_ALEN - 3);
43f66a6c 3634
0edd5b44
JG		 3635 bssid[0] &= 0xfe; /* clear multicast bit */
3636 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
43f66a6c
JK		 3637}
3638
858119e1 3639static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3640{
3641 struct ipw_station_entry entry;
3642 int i;
3643
3644 for (i = 0; i < priv->num_stations; i++) {
3645 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3646 /* Another node is active in network */
3647 priv->missed_adhoc_beacons = 0;
3648 if (!(priv->config & CFG_STATIC_CHANNEL))
3649 /* when other nodes drop out, we drop out */
3650 priv->config &= ~CFG_ADHOC_PERSIST;
3651
3652 return i;
3653 }
3654 }
3655
3656 if (i == MAX_STATIONS)
3657 return IPW_INVALID_STATION;
3658
3659 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3660
3661 entry.reserved = 0;
3662 entry.support_mode = 0;
3663 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3664 memcpy(priv->stations[i], bssid, ETH_ALEN);
3665 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
0edd5b44 3666 &entry, sizeof(entry));
43f66a6c
JK		 3667 priv->num_stations++;
3668
3669 return i;
3670}
3671
858119e1 3672static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3673{
3674 int i;
3675
bf79451e
JG		 3676 for (i = 0; i < priv->num_stations; i++)
3677 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
43f66a6c
JK		 3678 return i;
3679
3680 return IPW_INVALID_STATION;
3681}
3682
3683static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3684{
3685 int err;
3686
7b99659f
HL		 3687 if (priv->status & STATUS_ASSOCIATING) {
3688 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3689 queue_work(priv->workqueue, &priv->disassociate);
3690 return;
3691 }
3692
3693 if (!(priv->status & STATUS_ASSOCIATED)) {
43f66a6c
JK		 3694 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3695 return;
3696 }
3697
3698 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3699 "on channel %d.\n",
bf79451e 3700 MAC_ARG(priv->assoc_request.bssid),
43f66a6c
JK		 3701 priv->assoc_request.channel);
3702
3703 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3704 priv->status |= STATUS_DISASSOCIATING;
3705
3706 if (quiet)
3707 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3708 else
3709 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
e6324726 3710
43f66a6c
JK		 3711 err = ipw_send_associate(priv, &priv->assoc_request);
3712 if (err) {
3713 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3714 "failed.\n");
3715 return;
3716 }
3717
3718}
3719
c848d0af 3720static int ipw_disassociate(void *data)
43f66a6c 3721{
c848d0af
JK		 3722 struct ipw_priv *priv = data;
3723 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3724 return 0;
43f66a6c 3725 ipw_send_disassociate(data, 0);
c848d0af 3726 return 1;
43f66a6c
JK		 3727}
3728
c848d0af 3729static void ipw_bg_disassociate(void *data)
43f66a6c 3730{
c848d0af 3731 struct ipw_priv *priv = data;
4644151b 3732 mutex_lock(&priv->mutex);
c848d0af 3733 ipw_disassociate(data);
4644151b 3734 mutex_unlock(&priv->mutex);
43f66a6c
JK		 3735}
3736
d8bad6df
ZY		 3737static void ipw_system_config(void *data)
3738{
3739 struct ipw_priv *priv = data;
3740 ipw_send_system_config(priv, &priv->sys_config);
43f66a6c
JK		 3741}
3742
3743struct ipw_status_code {
3744 u16 status;
3745 const char *reason;
3746};
3747
3748static const struct ipw_status_code ipw_status_codes[] = {
3749 {0x00, "Successful"},
3750 {0x01, "Unspecified failure"},
3751 {0x0A, "Cannot support all requested capabilities in the "
3752 "Capability information field"},
3753 {0x0B, "Reassociation denied due to inability to confirm that "
3754 "association exists"},
3755 {0x0C, "Association denied due to reason outside the scope of this "
3756 "standard"},
0edd5b44
JG		 3757 {0x0D,
3758 "Responding station does not support the specified authentication "
43f66a6c 3759 "algorithm"},
0edd5b44
JG		 3760 {0x0E,
3761 "Received an Authentication frame with authentication sequence "
43f66a6c
JK		 3762 "transaction sequence number out of expected sequence"},
3763 {0x0F, "Authentication rejected because of challenge failure"},
3764 {0x10, "Authentication rejected due to timeout waiting for next "
3765 "frame in sequence"},
3766 {0x11, "Association denied because AP is unable to handle additional "
3767 "associated stations"},
0edd5b44
JG		 3768 {0x12,
3769 "Association denied due to requesting station not supporting all "
43f66a6c 3770 "of the datarates in the BSSBasicServiceSet Parameter"},
0edd5b44
JG		 3771 {0x13,
3772 "Association denied due to requesting station not supporting "
43f66a6c 3773 "short preamble operation"},
0edd5b44
JG		 3774 {0x14,
3775 "Association denied due to requesting station not supporting "
43f66a6c 3776 "PBCC encoding"},
0edd5b44
JG		 3777 {0x15,
3778 "Association denied due to requesting station not supporting "
43f66a6c 3779 "channel agility"},
0edd5b44
JG		 3780 {0x19,
3781 "Association denied due to requesting station not supporting "
43f66a6c 3782 "short slot operation"},
0edd5b44
JG		 3783 {0x1A,
3784 "Association denied due to requesting station not supporting "
43f66a6c
JK		 3785 "DSSS-OFDM operation"},
3786 {0x28, "Invalid Information Element"},
3787 {0x29, "Group Cipher is not valid"},
3788 {0x2A, "Pairwise Cipher is not valid"},
3789 {0x2B, "AKMP is not valid"},
3790 {0x2C, "Unsupported RSN IE version"},
3791 {0x2D, "Invalid RSN IE Capabilities"},
3792 {0x2E, "Cipher suite is rejected per security policy"},
3793};
3794
0f52bf90 3795#ifdef CONFIG_IPW2200_DEBUG
bf79451e 3796static const char *ipw_get_status_code(u16 status)
43f66a6c
JK		 3797{
3798 int i;
bf79451e 3799 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
ea2b26e0 3800 if (ipw_status_codes[i].status == (status & 0xff))
43f66a6c
JK		 3801 return ipw_status_codes[i].reason;
3802 return "Unknown status value.";
3803}
3804#endif
3805
3806static void inline average_init(struct average *avg)
3807{
3808 memset(avg, 0, sizeof(*avg));
3809}
3810
858119e1 3811static void average_add(struct average *avg, s16 val)
43f66a6c
JK		 3812{
3813 avg->sum -= avg->entries[avg->pos];
3814 avg->sum += val;
3815 avg->entries[avg->pos++] = val;
3816 if (unlikely(avg->pos == AVG_ENTRIES)) {
3817 avg->init = 1;
3818 avg->pos = 0;
3819 }
3820}
3821
858119e1 3822static s16 average_value(struct average *avg)
43f66a6c
JK		 3823{
3824 if (!unlikely(avg->init)) {
3825 if (avg->pos)
3826 return avg->sum / avg->pos;
3827 return 0;
3828 }
3829
3830 return avg->sum / AVG_ENTRIES;
3831}
3832
3833static void ipw_reset_stats(struct ipw_priv *priv)
3834{
3835 u32 len = sizeof(u32);
3836
3837 priv->quality = 0;
3838
3839 average_init(&priv->average_missed_beacons);
3840 average_init(&priv->average_rssi);
3841 average_init(&priv->average_noise);
3842
3843 priv->last_rate = 0;
3844 priv->last_missed_beacons = 0;
3845 priv->last_rx_packets = 0;
3846 priv->last_tx_packets = 0;
3847 priv->last_tx_failures = 0;
bf79451e 3848
43f66a6c
JK		 3849 /* Firmware managed, reset only when NIC is restarted, so we have to
3850 * normalize on the current value */
bf79451e 3851 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
43f66a6c 3852 &priv->last_rx_err, &len);
bf79451e 3853 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
43f66a6c
JK		 3854 &priv->last_tx_failures, &len);
3855
3856 /* Driver managed, reset with each association */
3857 priv->missed_adhoc_beacons = 0;
3858 priv->missed_beacons = 0;
3859 priv->tx_packets = 0;
3860 priv->rx_packets = 0;
3861
3862}
3863
858119e1 3864static u32 ipw_get_max_rate(struct ipw_priv *priv)
43f66a6c
JK		 3865{
3866 u32 i = 0x80000000;
3867 u32 mask = priv->rates_mask;
3868 /* If currently associated in B mode, restrict the maximum
3869 * rate match to B rates */
3870 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3871 mask &= IEEE80211_CCK_RATES_MASK;
3872
3873 /* TODO: Verify that the rate is supported by the current rates
3874 * list. */
3875
0edd5b44
JG		 3876 while (i && !(mask & i))
3877 i >>= 1;
43f66a6c 3878 switch (i) {
ea2b26e0
JK		 3879 case IEEE80211_CCK_RATE_1MB_MASK:
3880 return 1000000;
3881 case IEEE80211_CCK_RATE_2MB_MASK:
3882 return 2000000;
3883 case IEEE80211_CCK_RATE_5MB_MASK:
3884 return 5500000;
3885 case IEEE80211_OFDM_RATE_6MB_MASK:
3886 return 6000000;
3887 case IEEE80211_OFDM_RATE_9MB_MASK:
3888 return 9000000;
3889 case IEEE80211_CCK_RATE_11MB_MASK:
3890 return 11000000;
3891 case IEEE80211_OFDM_RATE_12MB_MASK:
3892 return 12000000;
3893 case IEEE80211_OFDM_RATE_18MB_MASK:
3894 return 18000000;
3895 case IEEE80211_OFDM_RATE_24MB_MASK:
3896 return 24000000;
3897 case IEEE80211_OFDM_RATE_36MB_MASK:
3898 return 36000000;
3899 case IEEE80211_OFDM_RATE_48MB_MASK:
3900 return 48000000;
3901 case IEEE80211_OFDM_RATE_54MB_MASK:
3902 return 54000000;
43f66a6c
JK		 3903 }
3904
bf79451e 3905 if (priv->ieee->mode == IEEE_B)
43f66a6c
JK		 3906 return 11000000;
3907 else
3908 return 54000000;
3909}
3910
3911static u32 ipw_get_current_rate(struct ipw_priv *priv)
3912{
3913 u32 rate, len = sizeof(rate);
3914 int err;
3915
bf79451e 3916 if (!(priv->status & STATUS_ASSOCIATED))
43f66a6c
JK		 3917 return 0;
3918
3919 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
bf79451e 3920 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
43f66a6c
JK		 3921 &len);
3922 if (err) {
3923 IPW_DEBUG_INFO("failed querying ordinals.\n");
3924 return 0;
3925 }
bf79451e 3926 } else
43f66a6c
JK		 3927 return ipw_get_max_rate(priv);
3928
3929 switch (rate) {
ea2b26e0
JK		 3930 case IPW_TX_RATE_1MB:
3931 return 1000000;
3932 case IPW_TX_RATE_2MB:
3933 return 2000000;
3934 case IPW_TX_RATE_5MB:
3935 return 5500000;
3936 case IPW_TX_RATE_6MB:
3937 return 6000000;
3938 case IPW_TX_RATE_9MB:
3939 return 9000000;
3940 case IPW_TX_RATE_11MB:
3941 return 11000000;
3942 case IPW_TX_RATE_12MB:
3943 return 12000000;
3944 case IPW_TX_RATE_18MB:
3945 return 18000000;
3946 case IPW_TX_RATE_24MB:
3947 return 24000000;
3948 case IPW_TX_RATE_36MB:
3949 return 36000000;
3950 case IPW_TX_RATE_48MB:
3951 return 48000000;
3952 case IPW_TX_RATE_54MB:
3953 return 54000000;
43f66a6c
JK		 3954 }
3955
3956 return 0;
3957}
3958
43f66a6c
JK		 3959#define IPW_STATS_INTERVAL (2 * HZ)
3960static void ipw_gather_stats(struct ipw_priv *priv)
3961{
3962 u32 rx_err, rx_err_delta, rx_packets_delta;
3963 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3964 u32 missed_beacons_percent, missed_beacons_delta;
3965 u32 quality = 0;
3966 u32 len = sizeof(u32);
3967 s16 rssi;
bf79451e 3968 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
0edd5b44 3969 rate_quality;
ea2b26e0 3970 u32 max_rate;
43f66a6c
JK		 3971
3972 if (!(priv->status & STATUS_ASSOCIATED)) {
3973 priv->quality = 0;
3974 return;
3975 }
3976
3977 /* Update the statistics */
bf79451e 3978 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
43f66a6c 3979 &priv->missed_beacons, &len);
0edd5b44 3980 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
43f66a6c
JK		 3981 priv->last_missed_beacons = priv->missed_beacons;
3982 if (priv->assoc_request.beacon_interval) {
3983 missed_beacons_percent = missed_beacons_delta *
0edd5b44
JG		 3984 (HZ * priv->assoc_request.beacon_interval) /
3985 (IPW_STATS_INTERVAL * 10);
43f66a6c
JK		 3986 } else {
3987 missed_beacons_percent = 0;
3988 }
3989 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3990
3991 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3992 rx_err_delta = rx_err - priv->last_rx_err;
3993 priv->last_rx_err = rx_err;
3994
3995 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3996 tx_failures_delta = tx_failures - priv->last_tx_failures;
3997 priv->last_tx_failures = tx_failures;
3998
3999 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4000 priv->last_rx_packets = priv->rx_packets;
4001
4002 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4003 priv->last_tx_packets = priv->tx_packets;
4004
4005 /* Calculate quality based on the following:
bf79451e 4006 *
43f66a6c
JK		 4007 * Missed beacon: 100% = 0, 0% = 70% missed
4008 * Rate: 60% = 1Mbs, 100% = Max
4009 * Rx and Tx errors represent a straight % of total Rx/Tx
4010 * RSSI: 100% = > -50, 0% = < -80
4011 * Rx errors: 100% = 0, 0% = 50% missed
bf79451e 4012 *
43f66a6c
JK		 4013 * The lowest computed quality is used.
4014 *
4015 */
4016#define BEACON_THRESHOLD 5
4017 beacon_quality = 100 - missed_beacons_percent;
4018 if (beacon_quality < BEACON_THRESHOLD)
4019 beacon_quality = 0;
4020 else
bf79451e 4021 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
0edd5b44 4022 (100 - BEACON_THRESHOLD);
bf79451e 4023 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
43f66a6c 4024 beacon_quality, missed_beacons_percent);
bf79451e 4025
43f66a6c 4026 priv->last_rate = ipw_get_current_rate(priv);
ea2b26e0
JK		 4027 max_rate = ipw_get_max_rate(priv);
4028 rate_quality = priv->last_rate * 40 / max_rate + 60;
43f66a6c
JK		 4029 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4030 rate_quality, priv->last_rate / 1000000);
bf79451e 4031
0edd5b44 4032 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
bf79451e 4033 rx_quality = 100 - (rx_err_delta * 100) /
0edd5b44 4034 (rx_packets_delta + rx_err_delta);
43f66a6c
JK		 4035 else
4036 rx_quality = 100;
4037 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4038 rx_quality, rx_err_delta, rx_packets_delta);
bf79451e 4039
0edd5b44 4040 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
bf79451e 4041 tx_quality = 100 - (tx_failures_delta * 100) /
0edd5b44 4042 (tx_packets_delta + tx_failures_delta);
43f66a6c
JK		 4043 else
4044 tx_quality = 100;
4045 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4046 tx_quality, tx_failures_delta, tx_packets_delta);
bf79451e 4047
43f66a6c 4048 rssi = average_value(&priv->average_rssi);
c848d0af
JK		 4049 signal_quality =
4050 (100 *
4051 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4052 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4053 (priv->ieee->perfect_rssi - rssi) *
4054 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4055 62 * (priv->ieee->perfect_rssi - rssi))) /
4056 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4057 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4058 if (signal_quality > 100)
43f66a6c 4059 signal_quality = 100;
c848d0af 4060 else if (signal_quality < 1)
43f66a6c 4061 signal_quality = 0;
ea2b26e0 4062
43f66a6c
JK		 4063 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4064 signal_quality, rssi);
bf79451e
JG		 4065
4066 quality = min(beacon_quality,
43f66a6c
JK		 4067 min(rate_quality,
4068 min(tx_quality, min(rx_quality, signal_quality))));
4069 if (quality == beacon_quality)
0edd5b44
JG		 4070 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4071 quality);
43f66a6c 4072 if (quality == rate_quality)
0edd5b44
JG		 4073 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4074 quality);
43f66a6c 4075 if (quality == tx_quality)
0edd5b44
JG		 4076 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4077 quality);
43f66a6c 4078 if (quality == rx_quality)
0edd5b44
JG		 4079 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4080 quality);
43f66a6c 4081 if (quality == signal_quality)
0edd5b44
JG		 4082 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4083 quality);
43f66a6c
JK		 4084
4085 priv->quality = quality;
bf79451e
JG		 4086
4087 queue_delayed_work(priv->workqueue, &priv->gather_stats,
43f66a6c
JK		 4088 IPW_STATS_INTERVAL);
4089}
4090
c848d0af
JK		 4091static void ipw_bg_gather_stats(void *data)
4092{
4093 struct ipw_priv *priv = data;
4644151b 4094 mutex_lock(&priv->mutex);
c848d0af 4095 ipw_gather_stats(data);
4644151b 4096 mutex_unlock(&priv->mutex);
c848d0af
JK		 4097}
4098
e7582561
BC		 4099/* Missed beacon behavior:
4100 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4101 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4102 * Above disassociate threshold, give up and stop scanning.
4103 * Roaming is disabled if disassociate_threshold <= roaming_threshold */
858119e1 4104static void ipw_handle_missed_beacon(struct ipw_priv *priv,
ea2b26e0
JK		 4105 int missed_count)
4106{
4107 priv->notif_missed_beacons = missed_count;
4108
afbf30a2 4109 if (missed_count > priv->disassociate_threshold &&
ea2b26e0
JK		 4110 priv->status & STATUS_ASSOCIATED) {
4111 /* If associated and we've hit the missed
4112 * beacon threshold, disassociate, turn
4113 * off roaming, and abort any active scans */
4114 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
afbf30a2 4115 IPW_DL_STATE | IPW_DL_ASSOC,
ea2b26e0
JK		 4116 "Missed beacon: %d - disassociate\n", missed_count);
4117 priv->status &= ~STATUS_ROAMING;
a613bffd
JK		 4118 if (priv->status & STATUS_SCANNING) {
4119 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4120 IPW_DL_STATE,
4121 "Aborting scan with missed beacon.\n");
ea2b26e0 4122 queue_work(priv->workqueue, &priv->abort_scan);
a613bffd
JK		 4123 }
4124
ea2b26e0
JK		 4125 queue_work(priv->workqueue, &priv->disassociate);
4126 return;
4127 }
4128
4129 if (priv->status & STATUS_ROAMING) {
4130 /* If we are currently roaming, then just
4131 * print a debug statement... */
4132 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4133 "Missed beacon: %d - roam in progress\n",
4134 missed_count);
4135 return;
4136 }
4137
4bfdb91d
ZY		 4138 if (roaming &&
4139 (missed_count > priv->roaming_threshold &&
4140 missed_count <= priv->disassociate_threshold)) {
ea2b26e0 4141 /* If we are not already roaming, set the ROAM
e7582561
BC		 4142 * bit in the status and kick off a scan.
4143 * This can happen several times before we reach
4144 * disassociate_threshold. */
ea2b26e0
JK		 4145 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4146 "Missed beacon: %d - initiate "
4147 "roaming\n", missed_count);
4148 if (!(priv->status & STATUS_ROAMING)) {
4149 priv->status |= STATUS_ROAMING;
4150 if (!(priv->status & STATUS_SCANNING))
4151 queue_work(priv->workqueue,
4152 &priv->request_scan);
4153 }
4154 return;
4155 }
4156
4157 if (priv->status & STATUS_SCANNING) {
4158 /* Stop scan to keep fw from getting
4159 * stuck (only if we aren't roaming --
4160 * otherwise we'll never scan more than 2 or 3
4161 * channels..) */
b095c381
JK		 4162 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4163 "Aborting scan with missed beacon.\n");
ea2b26e0
JK		 4164 queue_work(priv->workqueue, &priv->abort_scan);
4165 }
4166
4167 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
ea2b26e0
JK		 4168}
4169
43f66a6c
JK		 4170/**
4171 * Handle host notification packet.
4172 * Called from interrupt routine
4173 */
858119e1 4174static void ipw_rx_notification(struct ipw_priv *priv,
43f66a6c
JK		 4175 struct ipw_rx_notification *notif)
4176{
a613bffd
JK		 4177 notif->size = le16_to_cpu(notif->size);
4178
0edd5b44 4179 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
bf79451e 4180
43f66a6c 4181 switch (notif->subtype) {
0edd5b44
JG		 4182 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4183 struct notif_association *assoc = &notif->u.assoc;
4184
4185 switch (assoc->state) {
4186 case CMAS_ASSOCIATED:{
4187 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4188 IPW_DL_ASSOC,
4189 "associated: '%s' " MAC_FMT
4190 " \n",
4191 escape_essid(priv->essid,
4192 priv->essid_len),
4193 MAC_ARG(priv->bssid));
4194
4195 switch (priv->ieee->iw_mode) {
4196 case IW_MODE_INFRA:
4197 memcpy(priv->ieee->bssid,
4198 priv->bssid, ETH_ALEN);
4199 break;
4200
4201 case IW_MODE_ADHOC:
4202 memcpy(priv->ieee->bssid,
4203 priv->bssid, ETH_ALEN);
4204
4205 /* clear out the station table */
4206 priv->num_stations = 0;
4207
4208 IPW_DEBUG_ASSOC
4209 ("queueing adhoc check\n");
4210 queue_delayed_work(priv->
4211 workqueue,
4212 &priv->
4213 adhoc_check,
4214 priv->
4215 assoc_request.
4216 beacon_interval);
4217 break;
4218 }
4219
4220 priv->status &= ~STATUS_ASSOCIATING;
4221 priv->status |= STATUS_ASSOCIATED;
d8bad6df
ZY		 4222 queue_work(priv->workqueue,
4223 &priv->system_config);
0edd5b44 4224
b095c381 4225#ifdef CONFIG_IPW_QOS
afbf30a2
JK		 4226#define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4227 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4228 if ((priv->status & STATUS_AUTH) &&
4229 (IPW_GET_PACKET_STYPE(&notif->u.raw)
4230 == IEEE80211_STYPE_ASSOC_RESP)) {
b095c381
JK		 4231 if ((sizeof
4232 (struct
2b184d5b 4233 ieee80211_assoc_response)
b095c381
JK		 4234 <= notif->size)
4235 && (notif->size <= 2314)) {
4236 struct
4237 ieee80211_rx_stats
4238 stats = {
4239 .len =
4240 notif->
4241 size - 1,
4242 };
4243
4244 IPW_DEBUG_QOS
4245 ("QoS Associate "
4246 "size %d\n",
4247 notif->size);
4248 ieee80211_rx_mgt(priv->
4249 ieee,
4250 (struct
2b184d5b 4251 ieee80211_hdr_4addr
b095c381
JK		 4252 *)
4253 &notif->u.raw, &stats);
4254 }
0edd5b44 4255 }
b095c381 4256#endif
0edd5b44 4257
a613bffd 4258 schedule_work(&priv->link_up);
43f66a6c 4259
0edd5b44
JG		 4260 break;
4261 }
bf79451e 4262
0edd5b44
JG		 4263 case CMAS_AUTHENTICATED:{
4264 if (priv->
4265 status & (STATUS_ASSOCIATED |
4266 STATUS_AUTH)) {
0f52bf90 4267#ifdef CONFIG_IPW2200_DEBUG
0edd5b44
JG		 4268 struct notif_authenticate *auth
4269 = &notif->u.auth;
4270 IPW_DEBUG(IPW_DL_NOTIF |
4271 IPW_DL_STATE |
4272 IPW_DL_ASSOC,
4273 "deauthenticated: '%s' "
4274 MAC_FMT
4275 ": (0x%04X) - %s \n",
4276 escape_essid(priv->
4277 essid,
4278 priv->
4279 essid_len),
4280 MAC_ARG(priv->bssid),
4281 ntohs(auth->status),
4282 ipw_get_status_code
4283 (ntohs
4284 (auth->status)));
43f66a6c
JK		 4285#endif
4286
0edd5b44
JG		 4287 priv->status &=
4288 ~(STATUS_ASSOCIATING |
4289 STATUS_AUTH |
4290 STATUS_ASSOCIATED);
4291
a613bffd 4292 schedule_work(&priv->link_down);
0edd5b44
JG		 4293 break;
4294 }
4295
4296 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4297 IPW_DL_ASSOC,
4298 "authenticated: '%s' " MAC_FMT
4299 "\n",
4300 escape_essid(priv->essid,
4301 priv->essid_len),
4302 MAC_ARG(priv->bssid));
4303 break;
4304 }
4305
4306 case CMAS_INIT:{
ea2b26e0
JK		 4307 if (priv->status & STATUS_AUTH) {
4308 struct
4309 ieee80211_assoc_response
4310 *resp;
4311 resp =
4312 (struct
4313 ieee80211_assoc_response
4314 *)&notif->u.raw;
4315 IPW_DEBUG(IPW_DL_NOTIF |
4316 IPW_DL_STATE |
4317 IPW_DL_ASSOC,
4318 "association failed (0x%04X): %s\n",
4319 ntohs(resp->status),
4320 ipw_get_status_code
4321 (ntohs
4322 (resp->status)));
4323 }
4324
0edd5b44
JG		 4325 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4326 IPW_DL_ASSOC,
4327 "disassociated: '%s' " MAC_FMT
4328 " \n",
4329 escape_essid(priv->essid,
4330 priv->essid_len),
4331 MAC_ARG(priv->bssid));
4332
4333 priv->status &=
4334 ~(STATUS_DISASSOCIATING |
4335 STATUS_ASSOCIATING |
4336 STATUS_ASSOCIATED | STATUS_AUTH);
b095c381
JK		 4337 if (priv->assoc_network
4338 && (priv->assoc_network->
4339 capability &
4340 WLAN_CAPABILITY_IBSS))
4341 ipw_remove_current_network
4342 (priv);
0edd5b44 4343
a613bffd 4344 schedule_work(&priv->link_down);
0edd5b44 4345
0edd5b44
JG		 4346 break;
4347 }
43f66a6c 4348
b095c381
JK		 4349 case CMAS_RX_ASSOC_RESP:
4350 break;
4351
0edd5b44
JG		 4352 default:
4353 IPW_ERROR("assoc: unknown (%d)\n",
4354 assoc->state);
43f66a6c 4355 break;
bf79451e 4356 }
43f66a6c 4357
43f66a6c
JK		 4358 break;
4359 }
bf79451e 4360
0edd5b44
JG		 4361 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4362 struct notif_authenticate *auth = &notif->u.auth;
4363 switch (auth->state) {
4364 case CMAS_AUTHENTICATED:
4365 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4366 "authenticated: '%s' " MAC_FMT " \n",
4367 escape_essid(priv->essid,
4368 priv->essid_len),
4369 MAC_ARG(priv->bssid));
4370 priv->status |= STATUS_AUTH;
4371 break;
43f66a6c 4372
0edd5b44
JG		 4373 case CMAS_INIT:
4374 if (priv->status & STATUS_AUTH) {
4375 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4376 IPW_DL_ASSOC,
4377 "authentication failed (0x%04X): %s\n",
4378 ntohs(auth->status),
4379 ipw_get_status_code(ntohs
4380 (auth->
4381 status)));
4382 }
4383 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4384 IPW_DL_ASSOC,
4385 "deauthenticated: '%s' " MAC_FMT "\n",
4386 escape_essid(priv->essid,
4387 priv->essid_len),
4388 MAC_ARG(priv->bssid));
bf79451e 4389
0edd5b44
JG		 4390 priv->status &= ~(STATUS_ASSOCIATING |
4391 STATUS_AUTH |
4392 STATUS_ASSOCIATED);
43f66a6c 4393
a613bffd 4394 schedule_work(&priv->link_down);
0edd5b44 4395 break;
43f66a6c 4396
0edd5b44
JG		 4397 case CMAS_TX_AUTH_SEQ_1:
4398 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4399 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4400 break;
4401 case CMAS_RX_AUTH_SEQ_2:
4402 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4403 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4404 break;
4405 case CMAS_AUTH_SEQ_1_PASS:
4406 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4407 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4408 break;
4409 case CMAS_AUTH_SEQ_1_FAIL:
4410 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4411 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4412 break;
4413 case CMAS_TX_AUTH_SEQ_3:
4414 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4415 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4416 break;
4417 case CMAS_RX_AUTH_SEQ_4:
4418 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4419 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4420 break;
4421 case CMAS_AUTH_SEQ_2_PASS:
4422 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4423 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4424 break;
4425 case CMAS_AUTH_SEQ_2_FAIL:
4426 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4427 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4428 break;
4429 case CMAS_TX_ASSOC:
4430 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4431 IPW_DL_ASSOC, "TX_ASSOC\n");
4432 break;
4433 case CMAS_RX_ASSOC_RESP:
4434 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4435 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
b095c381 4436
0edd5b44
JG		 4437 break;
4438 case CMAS_ASSOCIATED:
4439 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4440 IPW_DL_ASSOC, "ASSOCIATED\n");
4441 break;
4442 default:
4443 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4444 auth->state);
4445 break;
43f66a6c 4446 }
43f66a6c
JK		 4447 break;
4448 }
4449
0edd5b44
JG		 4450 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4451 struct notif_channel_result *x =
4452 &notif->u.channel_result;
43f66a6c 4453
0edd5b44
JG		 4454 if (notif->size == sizeof(*x)) {
4455 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4456 x->channel_num);
4457 } else {
4458 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4459 "(should be %zd)\n",
4460 notif->size, sizeof(*x));
bf79451e 4461 }
43f66a6c
JK		 4462 break;
4463 }
43f66a6c 4464
0edd5b44
JG		 4465 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4466 struct notif_scan_complete *x = &notif->u.scan_complete;
4467 if (notif->size == sizeof(*x)) {
4468 IPW_DEBUG_SCAN
4469 ("Scan completed: type %d, %d channels, "
4470 "%d status\n", x->scan_type,
4471 x->num_channels, x->status);
4472 } else {
4473 IPW_ERROR("Scan completed of wrong size %d "
4474 "(should be %zd)\n",
4475 notif->size, sizeof(*x));
4476 }
43f66a6c 4477
0edd5b44
JG		 4478 priv->status &=
4479 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4480
a0e04ab3 4481 wake_up_interruptible(&priv->wait_state);
0edd5b44
JG		 4482 cancel_delayed_work(&priv->scan_check);
4483
b095c381
JK		 4484 if (priv->status & STATUS_EXIT_PENDING)
4485 break;
4486
4487 priv->ieee->scans++;
4488
4489#ifdef CONFIG_IPW2200_MONITOR
4490 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 4491 priv->status |= STATUS_SCAN_FORCED;
b095c381
JK		 4492 queue_work(priv->workqueue,
4493 &priv->request_scan);
4494 break;
4495 }
afbf30a2 4496 priv->status &= ~STATUS_SCAN_FORCED;
b095c381
JK		 4497#endif /* CONFIG_IPW2200_MONITOR */
4498
0edd5b44
JG		 4499 if (!(priv->status & (STATUS_ASSOCIATED |
4500 STATUS_ASSOCIATING |
4501 STATUS_ROAMING |
4502 STATUS_DISASSOCIATING)))
4503 queue_work(priv->workqueue, &priv->associate);
4504 else if (priv->status & STATUS_ROAMING) {
e7582561
BC		 4505 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4506 /* If a scan completed and we are in roam mode, then
4507 * the scan that completed was the one requested as a
4508 * result of entering roam... so, schedule the
4509 * roam work */
4510 queue_work(priv->workqueue,
4511 &priv->roam);
4512 else
4513 /* Don't schedule if we aborted the scan */
4514 priv->status &= ~STATUS_ROAMING;
0edd5b44
JG		 4515 } else if (priv->status & STATUS_SCAN_PENDING)
4516 queue_work(priv->workqueue,
4517 &priv->request_scan);
a613bffd
JK		 4518 else if (priv->config & CFG_BACKGROUND_SCAN
4519 && priv->status & STATUS_ASSOCIATED)
4520 queue_delayed_work(priv->workqueue,
4521 &priv->request_scan, HZ);
0edd5b44 4522 break;
43f66a6c 4523 }
43f66a6c 4524
0edd5b44
JG		 4525 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4526 struct notif_frag_length *x = &notif->u.frag_len;
43f66a6c 4527
a613bffd
JK		 4528 if (notif->size == sizeof(*x))
4529 IPW_ERROR("Frag length: %d\n",
4530 le16_to_cpu(x->frag_length));
4531 else
0edd5b44
JG		 4532 IPW_ERROR("Frag length of wrong size %d "
4533 "(should be %zd)\n",
4534 notif->size, sizeof(*x));
0edd5b44 4535 break;
43f66a6c 4536 }
43f66a6c 4537
0edd5b44
JG		 4538 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4539 struct notif_link_deterioration *x =
4540 &notif->u.link_deterioration;
afbf30a2 4541
0edd5b44
JG		 4542 if (notif->size == sizeof(*x)) {
4543 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
12977154
BC		 4544 "link deterioration: type %d, cnt %d\n",
4545 x->silence_notification_type,
4546 x->silence_count);
0edd5b44
JG		 4547 memcpy(&priv->last_link_deterioration, x,
4548 sizeof(*x));
4549 } else {
4550 IPW_ERROR("Link Deterioration of wrong size %d "
4551 "(should be %zd)\n",
4552 notif->size, sizeof(*x));
4553 }
43f66a6c
JK		 4554 break;
4555 }
4556
0edd5b44
JG		 4557 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4558 IPW_ERROR("Dino config\n");
4559 if (priv->hcmd
a613bffd 4560 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
0edd5b44 4561 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
a613bffd 4562
0edd5b44
JG		 4563 break;
4564 }
43f66a6c 4565
0edd5b44
JG		 4566 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4567 struct notif_beacon_state *x = &notif->u.beacon_state;
4568 if (notif->size != sizeof(*x)) {
4569 IPW_ERROR
4570 ("Beacon state of wrong size %d (should "
4571 "be %zd)\n", notif->size, sizeof(*x));
4572 break;
43f66a6c
JK		 4573 }
4574
a613bffd
JK		 4575 if (le32_to_cpu(x->state) ==
4576 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4577 ipw_handle_missed_beacon(priv,
4578 le32_to_cpu(x->
4579 number));
43f66a6c 4580
0edd5b44
JG		 4581 break;
4582 }
43f66a6c 4583
0edd5b44
JG		 4584 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4585 struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
4586 if (notif->size == sizeof(*x)) {
4587 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4588 "0x%02x station %d\n",
4589 x->key_state, x->security_type,
4590 x->station_index);
4591 break;
4592 }
43f66a6c 4593
0edd5b44
JG		 4594 IPW_ERROR
4595 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4596 notif->size, sizeof(*x));
43f66a6c 4597 break;
bf79451e 4598 }
43f66a6c 4599
0edd5b44
JG		 4600 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4601 struct notif_calibration *x = &notif->u.calibration;
43f66a6c 4602
0edd5b44
JG		 4603 if (notif->size == sizeof(*x)) {
4604 memcpy(&priv->calib, x, sizeof(*x));
4605 IPW_DEBUG_INFO("TODO: Calibration\n");
4606 break;
4607 }
43f66a6c 4608
0edd5b44
JG		 4609 IPW_ERROR
4610 ("Calibration of wrong size %d (should be %zd)\n",
4611 notif->size, sizeof(*x));
43f66a6c 4612 break;
bf79451e
JG		 4613 }
4614
0edd5b44
JG		 4615 case HOST_NOTIFICATION_NOISE_STATS:{
4616 if (notif->size == sizeof(u32)) {
4617 priv->last_noise =
a613bffd
JK		 4618 (u8) (le32_to_cpu(notif->u.noise.value) &
4619 0xff);
0edd5b44
JG		 4620 average_add(&priv->average_noise,
4621 priv->last_noise);
4622 break;
4623 }
43f66a6c 4624
0edd5b44
JG		 4625 IPW_ERROR
4626 ("Noise stat is wrong size %d (should be %zd)\n",
4627 notif->size, sizeof(u32));
43f66a6c
JK		 4628 break;
4629 }
4630
43f66a6c 4631 default:
1dd31b6c
ZY		 4632 IPW_DEBUG_NOTIF("Unknown notification: "
4633 "subtype=%d,flags=0x%2x,size=%d\n",
4634 notif->subtype, notif->flags, notif->size);
43f66a6c
JK		 4635 }
4636}
4637
4638/**
4639 * Destroys all DMA structures and initialise them again
bf79451e 4640 *
43f66a6c
JK		 4641 * @param priv
4642 * @return error code
4643 */
4644static int ipw_queue_reset(struct ipw_priv *priv)
4645{
4646 int rc = 0;
4647 /** @todo customize queue sizes */
4648 int nTx = 64, nTxCmd = 8;
4649 ipw_tx_queue_free(priv);
4650 /* Tx CMD queue */
4651 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
b095c381
JK		 4652 IPW_TX_CMD_QUEUE_READ_INDEX,
4653 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4654 IPW_TX_CMD_QUEUE_BD_BASE,
4655 IPW_TX_CMD_QUEUE_BD_SIZE);
43f66a6c
JK		 4656 if (rc) {
4657 IPW_ERROR("Tx Cmd queue init failed\n");
4658 goto error;
4659 }
4660 /* Tx queue(s) */
4661 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
b095c381
JK		 4662 IPW_TX_QUEUE_0_READ_INDEX,
4663 IPW_TX_QUEUE_0_WRITE_INDEX,
4664 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
43f66a6c
JK		 4665 if (rc) {
4666 IPW_ERROR("Tx 0 queue init failed\n");
4667 goto error;
4668 }
4669 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
b095c381
JK		 4670 IPW_TX_QUEUE_1_READ_INDEX,
4671 IPW_TX_QUEUE_1_WRITE_INDEX,
4672 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
43f66a6c
JK		 4673 if (rc) {
4674 IPW_ERROR("Tx 1 queue init failed\n");
4675 goto error;
4676 }
4677 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
b095c381
JK		 4678 IPW_TX_QUEUE_2_READ_INDEX,
4679 IPW_TX_QUEUE_2_WRITE_INDEX,
4680 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
43f66a6c
JK		 4681 if (rc) {
4682 IPW_ERROR("Tx 2 queue init failed\n");
4683 goto error;
4684 }
4685 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
b095c381
JK		 4686 IPW_TX_QUEUE_3_READ_INDEX,
4687 IPW_TX_QUEUE_3_WRITE_INDEX,
4688 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
43f66a6c
JK		 4689 if (rc) {
4690 IPW_ERROR("Tx 3 queue init failed\n");
4691 goto error;
4692 }
4693 /* statistics */
4694 priv->rx_bufs_min = 0;
4695 priv->rx_pend_max = 0;
4696 return rc;
4697
0edd5b44 4698 error:
43f66a6c
JK		 4699 ipw_tx_queue_free(priv);
4700 return rc;
4701}
4702
4703/**
4704 * Reclaim Tx queue entries no more used by NIC.
bf79451e 4705 *
43f66a6c
JK		 4706 * When FW adwances 'R' index, all entries between old and
4707 * new 'R' index need to be reclaimed. As result, some free space
4708 * forms. If there is enough free space (> low mark), wake Tx queue.
bf79451e 4709 *
43f66a6c
JK		 4710 * @note Need to protect against garbage in 'R' index
4711 * @param priv
4712 * @param txq
4713 * @param qindex
4714 * @return Number of used entries remains in the queue
4715 */
bf79451e 4716static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
43f66a6c
JK		 4717 struct clx2_tx_queue *txq, int qindex)
4718{
4719 u32 hw_tail;
4720 int used;
4721 struct clx2_queue *q = &txq->q;
4722
4723 hw_tail = ipw_read32(priv, q->reg_r);
4724 if (hw_tail >= q->n_bd) {
4725 IPW_ERROR
0edd5b44
JG		 4726 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4727 hw_tail, q->n_bd);
43f66a6c
JK		 4728 goto done;
4729 }
4730 for (; q->last_used != hw_tail;
4731 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4732 ipw_queue_tx_free_tfd(priv, txq);
4733 priv->tx_packets++;
4734 }
0edd5b44 4735 done:
9ddf84f6
JK		 4736 if ((ipw_queue_space(q) > q->low_mark) &&
4737 (qindex >= 0) &&
4738 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4739 netif_wake_queue(priv->net_dev);
43f66a6c
JK		 4740 used = q->first_empty - q->last_used;
4741 if (used < 0)
4742 used += q->n_bd;
4743
4744 return used;
4745}
4746
4747static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4748 int len, int sync)
4749{
4750 struct clx2_tx_queue *txq = &priv->txq_cmd;
4751 struct clx2_queue *q = &txq->q;
4752 struct tfd_frame *tfd;
4753
4754 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4755 IPW_ERROR("No space for Tx\n");
4756 return -EBUSY;
4757 }
4758
4759 tfd = &txq->bd[q->first_empty];
4760 txq->txb[q->first_empty] = NULL;
4761
4762 memset(tfd, 0, sizeof(*tfd));
4763 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4764 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4765 priv->hcmd_seq++;
4766 tfd->u.cmd.index = hcmd;
4767 tfd->u.cmd.length = len;
4768 memcpy(tfd->u.cmd.payload, buf, len);
4769 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4770 ipw_write32(priv, q->reg_w, q->first_empty);
4771 _ipw_read32(priv, 0x90);
4772
4773 return 0;
4774}
4775
bf79451e 4776/*
43f66a6c
JK		 4777 * Rx theory of operation
4778 *
4779 * The host allocates 32 DMA target addresses and passes the host address
b095c381 4780 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
43f66a6c
JK		 4781 * 0 to 31
4782 *
4783 * Rx Queue Indexes
4784 * The host/firmware share two index registers for managing the Rx buffers.
4785 *
bf79451e
JG		 4786 * The READ index maps to the first position that the firmware may be writing
4787 * to -- the driver can read up to (but not including) this position and get
4788 * good data.
43f66a6c
JK		 4789 * The READ index is managed by the firmware once the card is enabled.
4790 *
4791 * The WRITE index maps to the last position the driver has read from -- the
4792 * position preceding WRITE is the last slot the firmware can place a packet.
4793 *
4794 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
bf79451e 4795 * WRITE = READ.
43f66a6c 4796 *
bf79451e 4797 * During initialization the host sets up the READ queue position to the first
43f66a6c
JK		 4798 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4799 *
4800 * When the firmware places a packet in a buffer it will advance the READ index
4801 * and fire the RX interrupt. The driver can then query the READ index and
4802 * process as many packets as possible, moving the WRITE index forward as it
4803 * resets the Rx queue buffers with new memory.
bf79451e 4804 *
43f66a6c 4805 * The management in the driver is as follows:
bf79451e 4806 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
43f66a6c 4807 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
bf79451e 4808 * to replensish the ipw->rxq->rx_free.
43f66a6c
JK		 4809 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4810 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4811 * 'processed' and 'read' driver indexes as well)
4812 * + A received packet is processed and handed to the kernel network stack,
4813 * detached from the ipw->rxq. The driver 'processed' index is updated.
4814 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
bf79451e
JG		 4815 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4816 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
43f66a6c
JK		 4817 * were enough free buffers and RX_STALLED is set it is cleared.
4818 *
4819 *
4820 * Driver sequence:
4821 *
bf79451e 4822 * ipw_rx_queue_alloc() Allocates rx_free
43f66a6c
JK		 4823 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4824 * ipw_rx_queue_restock
4825 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4826 * queue, updates firmware pointers, and updates
4827 * the WRITE index. If insufficient rx_free buffers
4828 * are available, schedules ipw_rx_queue_replenish
4829 *
4830 * -- enable interrupts --
4831 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
bf79451e 4832 * READ INDEX, detaching the SKB from the pool.
43f66a6c
JK		 4833 * Moves the packet buffer from queue to rx_used.
4834 * Calls ipw_rx_queue_restock to refill any empty
4835 * slots.
4836 * ...
4837 *
4838 */
4839
bf79451e 4840/*
43f66a6c
JK		 4841 * If there are slots in the RX queue that need to be restocked,
4842 * and we have free pre-allocated buffers, fill the ranks as much
4843 * as we can pulling from rx_free.
4844 *
4845 * This moves the 'write' index forward to catch up with 'processed', and
4846 * also updates the memory address in the firmware to reference the new
4847 * target buffer.
4848 */
4849static void ipw_rx_queue_restock(struct ipw_priv *priv)
4850{
4851 struct ipw_rx_queue *rxq = priv->rxq;
4852 struct list_head *element;
4853 struct ipw_rx_mem_buffer *rxb;
4854 unsigned long flags;
4855 int write;
4856
4857 spin_lock_irqsave(&rxq->lock, flags);
4858 write = rxq->write;
4859 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4860 element = rxq->rx_free.next;
4861 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4862 list_del(element);
4863
b095c381 4864 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
43f66a6c
JK		 4865 rxb->dma_addr);
4866 rxq->queue[rxq->write] = rxb;
4867 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4868 rxq->free_count--;
4869 }
4870 spin_unlock_irqrestore(&rxq->lock, flags);
4871
bf79451e 4872 /* If the pre-allocated buffer pool is dropping low, schedule to
43f66a6c
JK		 4873 * refill it */
4874 if (rxq->free_count <= RX_LOW_WATERMARK)
4875 queue_work(priv->workqueue, &priv->rx_replenish);
4876
4877 /* If we've added more space for the firmware to place data, tell it */
bf79451e 4878 if (write != rxq->write)
b095c381 4879 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
43f66a6c
JK		 4880}
4881
4882/*
4883 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
bf79451e
JG		 4884 * Also restock the Rx queue via ipw_rx_queue_restock.
4885 *
43f66a6c
JK		 4886 * This is called as a scheduled work item (except for during intialization)
4887 */
4888static void ipw_rx_queue_replenish(void *data)
4889{
4890 struct ipw_priv *priv = data;
4891 struct ipw_rx_queue *rxq = priv->rxq;
4892 struct list_head *element;
4893 struct ipw_rx_mem_buffer *rxb;
4894 unsigned long flags;
4895
4896 spin_lock_irqsave(&rxq->lock, flags);
4897 while (!list_empty(&rxq->rx_used)) {
4898 element = rxq->rx_used.next;
4899 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
b095c381 4900 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
43f66a6c
JK		 4901 if (!rxb->skb) {
4902 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4903 priv->net_dev->name);
4904 /* We don't reschedule replenish work here -- we will
4905 * call the restock method and if it still needs
4906 * more buffers it will schedule replenish */
4907 break;
4908 }
4909 list_del(element);
bf79451e 4910
43f66a6c 4911 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
0edd5b44
JG		 4912 rxb->dma_addr =
4913 pci_map_single(priv->pci_dev, rxb->skb->data,
b095c381 4914 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
bf79451e 4915
43f66a6c
JK		 4916 list_add_tail(&rxb->list, &rxq->rx_free);
4917 rxq->free_count++;
4918 }
4919 spin_unlock_irqrestore(&rxq->lock, flags);
4920
4921 ipw_rx_queue_restock(priv);
4922}
4923
c848d0af
JK		 4924static void ipw_bg_rx_queue_replenish(void *data)
4925{
4926 struct ipw_priv *priv = data;
4644151b 4927 mutex_lock(&priv->mutex);
c848d0af 4928 ipw_rx_queue_replenish(data);
4644151b 4929 mutex_unlock(&priv->mutex);
c848d0af
JK		 4930}
4931
43f66a6c 4932/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
c7b6a674 4933 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
bf79451e 4934 * This free routine walks the list of POOL entries and if SKB is set to
43f66a6c
JK		 4935 * non NULL it is unmapped and freed
4936 */
0edd5b44 4937static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
43f66a6c
JK		 4938{
4939 int i;
4940
4941 if (!rxq)
4942 return;
bf79451e 4943
43f66a6c
JK		 4944 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4945 if (rxq->pool[i].skb != NULL) {
4946 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
b095c381 4947 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c
JK		 4948 dev_kfree_skb(rxq->pool[i].skb);
4949 }
4950 }
4951
4952 kfree(rxq);
4953}
4954
4955static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4956{
4957 struct ipw_rx_queue *rxq;
4958 int i;
4959
c75f4742 4960 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
ad18b0ea
PI		 4961 if (unlikely(!rxq)) {
4962 IPW_ERROR("memory allocation failed\n");
4963 return NULL;
4964 }
43f66a6c
JK		 4965 spin_lock_init(&rxq->lock);
4966 INIT_LIST_HEAD(&rxq->rx_free);
4967 INIT_LIST_HEAD(&rxq->rx_used);
4968
4969 /* Fill the rx_used queue with _all_ of the Rx buffers */
bf79451e 4970 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
43f66a6c
JK		 4971 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4972
4973 /* Set us so that we have processed and used all buffers, but have
4974 * not restocked the Rx queue with fresh buffers */
4975 rxq->read = rxq->write = 0;
4976 rxq->processed = RX_QUEUE_SIZE - 1;
4977 rxq->free_count = 0;
4978
4979 return rxq;
4980}
4981
4982static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4983{
4984 rate &= ~IEEE80211_BASIC_RATE_MASK;
4985 if (ieee_mode == IEEE_A) {
4986 switch (rate) {
bf79451e
JG		 4987 case IEEE80211_OFDM_RATE_6MB:
4988 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
0edd5b44 4989 1 : 0;
bf79451e
JG		 4990 case IEEE80211_OFDM_RATE_9MB:
4991 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
0edd5b44 4992 1 : 0;
bf79451e 4993 case IEEE80211_OFDM_RATE_12MB:
0edd5b44
JG		 4994 return priv->
4995 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
bf79451e 4996 case IEEE80211_OFDM_RATE_18MB:
0edd5b44
JG		 4997 return priv->
4998 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
bf79451e 4999 case IEEE80211_OFDM_RATE_24MB:
0edd5b44
JG		 5000 return priv->
5001 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
bf79451e 5002 case IEEE80211_OFDM_RATE_36MB:
0edd5b44
JG		 5003 return priv->
5004 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
bf79451e 5005 case IEEE80211_OFDM_RATE_48MB:
0edd5b44
JG		 5006 return priv->
5007 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
bf79451e 5008 case IEEE80211_OFDM_RATE_54MB:
0edd5b44
JG		 5009 return priv->
5010 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
43f66a6c
JK		 5011 default:
5012 return 0;
5013 }
5014 }
bf79451e 5015
43f66a6c
JK		 5016 /* B and G mixed */
5017 switch (rate) {
bf79451e 5018 case IEEE80211_CCK_RATE_1MB:
43f66a6c 5019 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
bf79451e 5020 case IEEE80211_CCK_RATE_2MB:
43f66a6c 5021 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
bf79451e 5022 case IEEE80211_CCK_RATE_5MB:
43f66a6c 5023 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
bf79451e 5024 case IEEE80211_CCK_RATE_11MB:
43f66a6c
JK		 5025 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5026 }
5027
5028 /* If we are limited to B modulations, bail at this point */
5029 if (ieee_mode == IEEE_B)
5030 return 0;
5031
5032 /* G */
5033 switch (rate) {
bf79451e 5034 case IEEE80211_OFDM_RATE_6MB:
43f66a6c 5035 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
bf79451e 5036 case IEEE80211_OFDM_RATE_9MB:
43f66a6c 5037 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
bf79451e 5038 case IEEE80211_OFDM_RATE_12MB:
43f66a6c 5039 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
bf79451e 5040 case IEEE80211_OFDM_RATE_18MB:
43f66a6c 5041 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
bf79451e 5042 case IEEE80211_OFDM_RATE_24MB:
43f66a6c 5043 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
bf79451e 5044 case IEEE80211_OFDM_RATE_36MB:
43f66a6c 5045 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
bf79451e 5046 case IEEE80211_OFDM_RATE_48MB:
43f66a6c 5047 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
bf79451e 5048 case IEEE80211_OFDM_RATE_54MB:
43f66a6c
JK		 5049 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5050 }
5051
5052 return 0;
5053}
5054
bf79451e 5055static int ipw_compatible_rates(struct ipw_priv *priv,
43f66a6c
JK		 5056 const struct ieee80211_network *network,
5057 struct ipw_supported_rates *rates)
5058{
5059 int num_rates, i;
5060
5061 memset(rates, 0, sizeof(*rates));
0edd5b44 5062 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
43f66a6c
JK		 5063 rates->num_rates = 0;
5064 for (i = 0; i < num_rates; i++) {
a613bffd
JK		 5065 if (!ipw_is_rate_in_mask(priv, network->mode,
5066 network->rates[i])) {
5067
ea2b26e0 5068 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
a613bffd
JK		 5069 IPW_DEBUG_SCAN("Adding masked mandatory "
5070 "rate %02X\n",
5071 network->rates[i]);
5072 rates->supported_rates[rates->num_rates++] =
5073 network->rates[i];
5074 continue;
ea2b26e0
JK		 5075 }
5076
43f66a6c
JK		 5077 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5078 network->rates[i], priv->rates_mask);
5079 continue;
5080 }
bf79451e 5081
43f66a6c
JK		 5082 rates->supported_rates[rates->num_rates++] = network->rates[i];
5083 }
5084
a613bffd
JK		 5085 num_rates = min(network->rates_ex_len,
5086 (u8) (IPW_MAX_RATES - num_rates));
43f66a6c 5087 for (i = 0; i < num_rates; i++) {
a613bffd
JK		 5088 if (!ipw_is_rate_in_mask(priv, network->mode,
5089 network->rates_ex[i])) {
ea2b26e0 5090 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
a613bffd
JK		 5091 IPW_DEBUG_SCAN("Adding masked mandatory "
5092 "rate %02X\n",
5093 network->rates_ex[i]);
5094 rates->supported_rates[rates->num_rates++] =
5095 network->rates[i];
5096 continue;
ea2b26e0
JK		 5097 }
5098
43f66a6c
JK		 5099 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5100 network->rates_ex[i], priv->rates_mask);
5101 continue;
5102 }
bf79451e 5103
0edd5b44
JG		 5104 rates->supported_rates[rates->num_rates++] =
5105 network->rates_ex[i];
43f66a6c
JK		 5106 }
5107
ea2b26e0 5108 return 1;
43f66a6c
JK		 5109}
5110
858119e1 5111static void ipw_copy_rates(struct ipw_supported_rates *dest,
43f66a6c
JK		 5112 const struct ipw_supported_rates *src)
5113{
5114 u8 i;
5115 for (i = 0; i < src->num_rates; i++)
5116 dest->supported_rates[i] = src->supported_rates[i];
5117 dest->num_rates = src->num_rates;
5118}
5119
5120/* TODO: Look at sniffed packets in the air to determine if the basic rate
5121 * mask should ever be used -- right now all callers to add the scan rates are
5122 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5123static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
0edd5b44 5124 u8 modulation, u32 rate_mask)
43f66a6c 5125{
bf79451e 5126 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
0edd5b44 5127 IEEE80211_BASIC_RATE_MASK : 0;
bf79451e 5128
43f66a6c 5129 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
bf79451e 5130 rates->supported_rates[rates->num_rates++] =
0edd5b44 5131 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
43f66a6c
JK		 5132
5133 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
bf79451e 5134 rates->supported_rates[rates->num_rates++] =
0edd5b44 5135 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
43f66a6c
JK		 5136
5137 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
bf79451e 5138 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5139 IEEE80211_CCK_RATE_5MB;
43f66a6c
JK		 5140
5141 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
bf79451e 5142 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5143 IEEE80211_CCK_RATE_11MB;
43f66a6c
JK		 5144}
5145
5146static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
0edd5b44 5147 u8 modulation, u32 rate_mask)
43f66a6c 5148{
bf79451e 5149 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
0edd5b44 5150 IEEE80211_BASIC_RATE_MASK : 0;
43f66a6c
JK		 5151
5152 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
bf79451e 5153 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5154 IEEE80211_OFDM_RATE_6MB;
43f66a6c
JK		 5155
5156 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
bf79451e 5157 rates->supported_rates[rates->num_rates++] =
0edd5b44 5158 IEEE80211_OFDM_RATE_9MB;
43f66a6c
JK		 5159
5160 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
bf79451e 5161 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5162 IEEE80211_OFDM_RATE_12MB;
43f66a6c
JK		 5163
5164 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
bf79451e 5165 rates->supported_rates[rates->num_rates++] =
0edd5b44 5166 IEEE80211_OFDM_RATE_18MB;
43f66a6c
JK		 5167
5168 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
bf79451e 5169 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5170 IEEE80211_OFDM_RATE_24MB;
43f66a6c
JK		 5171
5172 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
bf79451e 5173 rates->supported_rates[rates->num_rates++] =
0edd5b44 5174 IEEE80211_OFDM_RATE_36MB;
43f66a6c
JK		 5175
5176 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
bf79451e 5177 rates->supported_rates[rates->num_rates++] =
0edd5b44 5178 IEEE80211_OFDM_RATE_48MB;
43f66a6c
JK		 5179
5180 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
bf79451e 5181 rates->supported_rates[rates->num_rates++] =
0edd5b44 5182 IEEE80211_OFDM_RATE_54MB;
43f66a6c
JK		 5183}
5184
5185struct ipw_network_match {
5186 struct ieee80211_network *network;
5187 struct ipw_supported_rates rates;
5188};
5189
c848d0af
JK		 5190static int ipw_find_adhoc_network(struct ipw_priv *priv,
5191 struct ipw_network_match *match,
5192 struct ieee80211_network *network,
5193 int roaming)
43f66a6c
JK		 5194{
5195 struct ipw_supported_rates rates;
5196
5197 /* Verify that this network's capability is compatible with the
5198 * current mode (AdHoc or Infrastructure) */
c848d0af 5199 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
43f66a6c 5200 !(network->capability & WLAN_CAPABILITY_IBSS))) {
c848d0af 5201 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
bf79451e 5202 "capability mismatch.\n",
43f66a6c
JK		 5203 escape_essid(network->ssid, network->ssid_len),
5204 MAC_ARG(network->bssid));
5205 return 0;
5206 }
5207
5208 /* If we do not have an ESSID for this AP, we can not associate with
5209 * it */
5210 if (network->flags & NETWORK_EMPTY_ESSID) {
c848d0af 5211 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5212 "because of hidden ESSID.\n",
5213 escape_essid(network->ssid, network->ssid_len),
5214 MAC_ARG(network->bssid));
5215 return 0;
5216 }
bf79451e 5217
43f66a6c
JK		 5218 if (unlikely(roaming)) {
5219 /* If we are roaming, then ensure check if this is a valid
5220 * network to try and roam to */
5221 if ((network->ssid_len != match->network->ssid_len) ||
bf79451e 5222 memcmp(network->ssid, match->network->ssid,
43f66a6c 5223 network->ssid_len)) {
c848d0af 5224 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
43f66a6c 5225 "because of non-network ESSID.\n",
bf79451e 5226 escape_essid(network->ssid,
43f66a6c
JK		 5227 network->ssid_len),
5228 MAC_ARG(network->bssid));
5229 return 0;
5230 }
5231 } else {
bf79451e
JG		 5232 /* If an ESSID has been configured then compare the broadcast
5233 * ESSID to ours */
5234 if ((priv->config & CFG_STATIC_ESSID) &&
43f66a6c 5235 ((network->ssid_len != priv->essid_len) ||
bf79451e 5236 memcmp(network->ssid, priv->essid,
43f66a6c
JK		 5237 min(network->ssid_len, priv->essid_len)))) {
5238 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
afbf30a2 5239
0edd5b44
JG		 5240 strncpy(escaped,
5241 escape_essid(network->ssid, network->ssid_len),
43f66a6c 5242 sizeof(escaped));
c848d0af 5243 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
bf79451e 5244 "because of ESSID mismatch: '%s'.\n",
43f66a6c 5245 escaped, MAC_ARG(network->bssid),
0edd5b44
JG		 5246 escape_essid(priv->essid,
5247 priv->essid_len));
43f66a6c
JK		 5248 return 0;
5249 }
5250 }
5251
5252 /* If the old network rate is better than this one, don't bother
5253 * testing everything else. */
c848d0af
JK		 5254
5255 if (network->time_stamp[0] < match->network->time_stamp[0]) {
afbf30a2
JK		 5256 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5257 "current network.\n",
43f66a6c 5258 escape_essid(match->network->ssid,
afbf30a2 5259 match->network->ssid_len));
43f66a6c 5260 return 0;
c848d0af 5261 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
afbf30a2
JK		 5262 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5263 "current network.\n",
5264 escape_essid(match->network->ssid,
5265 match->network->ssid_len));
43f66a6c
JK		 5266 return 0;
5267 }
5268
5269 /* Now go through and see if the requested network is valid... */
bf79451e 5270 if (priv->ieee->scan_age != 0 &&
c848d0af
JK		 5271 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5272 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
c7b6a674 5273 "because of age: %ums.\n",
43f66a6c
JK		 5274 escape_essid(network->ssid, network->ssid_len),
5275 MAC_ARG(network->bssid),
2638bc39
ZY		 5276 jiffies_to_msecs(jiffies -
5277 network->last_scanned));
43f66a6c 5278 return 0;
bf79451e 5279 }
43f66a6c 5280
bf79451e 5281 if ((priv->config & CFG_STATIC_CHANNEL) &&
43f66a6c 5282 (network->channel != priv->channel)) {
c848d0af 5283 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5284 "because of channel mismatch: %d != %d.\n",
5285 escape_essid(network->ssid, network->ssid_len),
5286 MAC_ARG(network->bssid),
5287 network->channel, priv->channel);
5288 return 0;
5289 }
bf79451e 5290
43f66a6c 5291 /* Verify privacy compatability */
bf79451e 5292 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
43f66a6c 5293 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
c848d0af 5294 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5295 "because of privacy mismatch: %s != %s.\n",
5296 escape_essid(network->ssid, network->ssid_len),
5297 MAC_ARG(network->bssid),
afbf30a2
JK		 5298 priv->
5299 capability & CAP_PRIVACY_ON ? "on" : "off",
5300 network->
5301 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5302 "off");
43f66a6c
JK		 5303 return 0;
5304 }
bf79451e 5305
c848d0af
JK		 5306 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5307 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5308 "because of the same BSSID match: " MAC_FMT
5309 ".\n", escape_essid(network->ssid,
5310 network->ssid_len),
0edd5b44 5311 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
43f66a6c
JK		 5312 return 0;
5313 }
bf79451e 5314
43f66a6c
JK		 5315 /* Filter out any incompatible freq / mode combinations */
5316 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
c848d0af 5317 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5318 "because of invalid frequency/mode "
5319 "combination.\n",
5320 escape_essid(network->ssid, network->ssid_len),
5321 MAC_ARG(network->bssid));
5322 return 0;
5323 }
bf79451e 5324
c848d0af
JK		 5325 /* Ensure that the rates supported by the driver are compatible with
5326 * this AP, including verification of basic rates (mandatory) */
5327 if (!ipw_compatible_rates(priv, network, &rates)) {
5328 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5329 "because configured rate mask excludes "
5330 "AP mandatory rate.\n",
5331 escape_essid(network->ssid, network->ssid_len),
5332 MAC_ARG(network->bssid));
5333 return 0;
5334 }
5335
43f66a6c 5336 if (rates.num_rates == 0) {
c848d0af 5337 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5338 "because of no compatible rates.\n",
5339 escape_essid(network->ssid, network->ssid_len),
5340 MAC_ARG(network->bssid));
5341 return 0;
5342 }
bf79451e 5343
43f66a6c
JK		 5344 /* TODO: Perform any further minimal comparititive tests. We do not
5345 * want to put too much policy logic here; intelligent scan selection
5346 * should occur within a generic IEEE 802.11 user space tool. */
5347
5348 /* Set up 'new' AP to this network */
5349 ipw_copy_rates(&match->rates, &rates);
5350 match->network = network;
c848d0af 5351 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
43f66a6c
JK		 5352 escape_essid(network->ssid, network->ssid_len),
5353 MAC_ARG(network->bssid));
5354
5355 return 1;
5356}
5357
c848d0af 5358static void ipw_merge_adhoc_network(void *data)
43f66a6c 5359{
c848d0af
JK		 5360 struct ipw_priv *priv = data;
5361 struct ieee80211_network *network = NULL;
5362 struct ipw_network_match match = {
5363 .network = priv->assoc_network
5364 };
5365
afbf30a2
JK		 5366 if ((priv->status & STATUS_ASSOCIATED) &&
5367 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
c848d0af
JK		 5368 /* First pass through ROAM process -- look for a better
5369 * network */
5370 unsigned long flags;
5371
5372 spin_lock_irqsave(&priv->ieee->lock, flags);
5373 list_for_each_entry(network, &priv->ieee->network_list, list) {
5374 if (network != priv->assoc_network)
5375 ipw_find_adhoc_network(priv, &match, network,
5376 1);
5377 }
5378 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5379
5380 if (match.network == priv->assoc_network) {
5381 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5382 "merge to.\n");
5383 return;
5384 }
5385
4644151b 5386 mutex_lock(&priv->mutex);
c848d0af
JK		 5387 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5388 IPW_DEBUG_MERGE("remove network %s\n",
5389 escape_essid(priv->essid,
5390 priv->essid_len));
5391 ipw_remove_current_network(priv);
43f66a6c 5392 }
c848d0af
JK		 5393
5394 ipw_disassociate(priv);
5395 priv->assoc_network = match.network;
4644151b 5396 mutex_unlock(&priv->mutex);
c848d0af 5397 return;
43f66a6c 5398 }
c848d0af 5399}
43f66a6c 5400
0edd5b44
JG		 5401static int ipw_best_network(struct ipw_priv *priv,
5402 struct ipw_network_match *match,
5403 struct ieee80211_network *network, int roaming)
43f66a6c
JK		 5404{
5405 struct ipw_supported_rates rates;
5406
5407 /* Verify that this network's capability is compatible with the
5408 * current mode (AdHoc or Infrastructure) */
5409 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
2474385e 5410 !(network->capability & WLAN_CAPABILITY_ESS)) ||
43f66a6c
JK		 5411 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5412 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5413 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
bf79451e 5414 "capability mismatch.\n",
43f66a6c
JK		 5415 escape_essid(network->ssid, network->ssid_len),
5416 MAC_ARG(network->bssid));
5417 return 0;
5418 }
5419
5420 /* If we do not have an ESSID for this AP, we can not associate with
5421 * it */
5422 if (network->flags & NETWORK_EMPTY_ESSID) {
5423 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5424 "because of hidden ESSID.\n",
5425 escape_essid(network->ssid, network->ssid_len),
5426 MAC_ARG(network->bssid));
5427 return 0;
5428 }
bf79451e 5429
43f66a6c
JK		 5430 if (unlikely(roaming)) {
5431 /* If we are roaming, then ensure check if this is a valid
5432 * network to try and roam to */
5433 if ((network->ssid_len != match->network->ssid_len) ||
bf79451e 5434 memcmp(network->ssid, match->network->ssid,
43f66a6c
JK		 5435 network->ssid_len)) {
5436 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5437 "because of non-network ESSID.\n",
bf79451e 5438 escape_essid(network->ssid,
43f66a6c
JK		 5439 network->ssid_len),
5440 MAC_ARG(network->bssid));
5441 return 0;
5442 }
5443 } else {
bf79451e
JG		 5444 /* If an ESSID has been configured then compare the broadcast
5445 * ESSID to ours */
5446 if ((priv->config & CFG_STATIC_ESSID) &&
43f66a6c 5447 ((network->ssid_len != priv->essid_len) ||
bf79451e 5448 memcmp(network->ssid, priv->essid,
43f66a6c
JK		 5449 min(network->ssid_len, priv->essid_len)))) {
5450 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
0edd5b44
JG		 5451 strncpy(escaped,
5452 escape_essid(network->ssid, network->ssid_len),
43f66a6c
JK		 5453 sizeof(escaped));
5454 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
bf79451e 5455 "because of ESSID mismatch: '%s'.\n",
43f66a6c 5456 escaped, MAC_ARG(network->bssid),
0edd5b44
JG		 5457 escape_essid(priv->essid,
5458 priv->essid_len));
43f66a6c
JK		 5459 return 0;
5460 }
5461 }
5462
5463 /* If the old network rate is better than this one, don't bother
5464 * testing everything else. */
0edd5b44 5465 if (match->network && match->network->stats.rssi > network->stats.rssi) {
43f66a6c 5466 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
bf79451e
JG		 5467 strncpy(escaped,
5468 escape_essid(network->ssid, network->ssid_len),
43f66a6c
JK		 5469 sizeof(escaped));
5470 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5471 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5472 escaped, MAC_ARG(network->bssid),
5473 escape_essid(match->network->ssid,
5474 match->network->ssid_len),
5475 MAC_ARG(match->network->bssid));
5476 return 0;
5477 }
bf79451e 5478
43f66a6c
JK		 5479 /* If this network has already had an association attempt within the
5480 * last 3 seconds, do not try and associate again... */
5481 if (network->last_associate &&
ea2b26e0 5482 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
43f66a6c 5483 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
c7b6a674 5484 "because of storming (%ums since last "
43f66a6c
JK		 5485 "assoc attempt).\n",
5486 escape_essid(network->ssid, network->ssid_len),
5487 MAC_ARG(network->bssid),
2638bc39
ZY		 5488 jiffies_to_msecs(jiffies -
5489 network->last_associate));
43f66a6c
JK		 5490 return 0;
5491 }
5492
5493 /* Now go through and see if the requested network is valid... */
bf79451e 5494 if (priv->ieee->scan_age != 0 &&
ea2b26e0 5495 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
43f66a6c 5496 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
c7b6a674 5497 "because of age: %ums.\n",
43f66a6c
JK		 5498 escape_essid(network->ssid, network->ssid_len),
5499 MAC_ARG(network->bssid),
2638bc39
ZY		 5500 jiffies_to_msecs(jiffies -
5501 network->last_scanned));
43f66a6c 5502 return 0;
bf79451e 5503 }
43f66a6c 5504
bf79451e 5505 if ((priv->config & CFG_STATIC_CHANNEL) &&
43f66a6c
JK		 5506 (network->channel != priv->channel)) {
5507 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5508 "because of channel mismatch: %d != %d.\n",
5509 escape_essid(network->ssid, network->ssid_len),
5510 MAC_ARG(network->bssid),
5511 network->channel, priv->channel);
5512 return 0;
5513 }
bf79451e 5514
43f66a6c 5515 /* Verify privacy compatability */
bf79451e 5516 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
43f66a6c
JK		 5517 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5518 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5519 "because of privacy mismatch: %s != %s.\n",
5520 escape_essid(network->ssid, network->ssid_len),
5521 MAC_ARG(network->bssid),
bf79451e 5522 priv->capability & CAP_PRIVACY_ON ? "on" :
43f66a6c 5523 "off",
bf79451e 5524 network->capability &
0edd5b44 5525 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
43f66a6c
JK		 5526 return 0;
5527 }
bf79451e
JG		 5528
5529 if ((priv->config & CFG_STATIC_BSSID) &&
43f66a6c
JK		 5530 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5531 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5532 "because of BSSID mismatch: " MAC_FMT ".\n",
5533 escape_essid(network->ssid, network->ssid_len),
0edd5b44 5534 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
43f66a6c
JK		 5535 return 0;
5536 }
bf79451e 5537
43f66a6c
JK		 5538 /* Filter out any incompatible freq / mode combinations */
5539 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5540 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5541 "because of invalid frequency/mode "
5542 "combination.\n",
5543 escape_essid(network->ssid, network->ssid_len),
5544 MAC_ARG(network->bssid));
5545 return 0;
5546 }
bf79451e 5547
1fe0adb4 5548 /* Filter out invalid channel in current GEO */
1867b117 5549 if (!ieee80211_is_valid_channel(priv->ieee, network->channel)) {
1fe0adb4
LH		 5550 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5551 "because of invalid channel in current GEO\n",
5552 escape_essid(network->ssid, network->ssid_len),
5553 MAC_ARG(network->bssid));
5554 return 0;
5555 }
5556
ea2b26e0
JK		 5557 /* Ensure that the rates supported by the driver are compatible with
5558 * this AP, including verification of basic rates (mandatory) */
5559 if (!ipw_compatible_rates(priv, network, &rates)) {
5560 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5561 "because configured rate mask excludes "
5562 "AP mandatory rate.\n",
5563 escape_essid(network->ssid, network->ssid_len),
5564 MAC_ARG(network->bssid));
5565 return 0;
5566 }
5567
43f66a6c
JK		 5568 if (rates.num_rates == 0) {
5569 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5570 "because of no compatible rates.\n",
5571 escape_essid(network->ssid, network->ssid_len),
5572 MAC_ARG(network->bssid));
5573 return 0;
5574 }
bf79451e 5575
43f66a6c
JK		 5576 /* TODO: Perform any further minimal comparititive tests. We do not
5577 * want to put too much policy logic here; intelligent scan selection
5578 * should occur within a generic IEEE 802.11 user space tool. */
5579
5580 /* Set up 'new' AP to this network */
5581 ipw_copy_rates(&match->rates, &rates);
5582 match->network = network;
5583
5584 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5585 escape_essid(network->ssid, network->ssid_len),
5586 MAC_ARG(network->bssid));
5587
5588 return 1;
5589}
5590
bf79451e 5591static void ipw_adhoc_create(struct ipw_priv *priv,
0edd5b44 5592 struct ieee80211_network *network)
43f66a6c 5593{
1867b117 5594 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
afbf30a2
JK		 5595 int i;
5596
43f66a6c
JK		 5597 /*
5598 * For the purposes of scanning, we can set our wireless mode
5599 * to trigger scans across combinations of bands, but when it
5600 * comes to creating a new ad-hoc network, we have tell the FW
5601 * exactly which band to use.
5602 *
bf79451e 5603 * We also have the possibility of an invalid channel for the
43f66a6c
JK		 5604 * chossen band. Attempting to create a new ad-hoc network
5605 * with an invalid channel for wireless mode will trigger a
5606 * FW fatal error.
afbf30a2 5607 *
43f66a6c 5608 */
1867b117 5609 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
afbf30a2
JK		 5610 case IEEE80211_52GHZ_BAND:
5611 network->mode = IEEE_A;
1867b117 5612 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
afbf30a2
JK		 5613 if (i == -1)
5614 BUG();
5615 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5616 IPW_WARNING("Overriding invalid channel\n");
5617 priv->channel = geo->a[0].channel;
5618 }
5619 break;
5620
5621 case IEEE80211_24GHZ_BAND:
5622 if (priv->ieee->mode & IEEE_G)
5623 network->mode = IEEE_G;
5624 else
5625 network->mode = IEEE_B;
1867b117 5626 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
1fe0adb4
LH		 5627 if (i == -1)
5628 BUG();
5629 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5630 IPW_WARNING("Overriding invalid channel\n");
5631 priv->channel = geo->bg[0].channel;
5632 }
afbf30a2
JK		 5633 break;
5634
5635 default:
43f66a6c
JK		 5636 IPW_WARNING("Overriding invalid channel\n");
5637 if (priv->ieee->mode & IEEE_A) {
5638 network->mode = IEEE_A;
b095c381 5639 priv->channel = geo->a[0].channel;
43f66a6c
JK		 5640 } else if (priv->ieee->mode & IEEE_G) {
5641 network->mode = IEEE_G;
b095c381 5642 priv->channel = geo->bg[0].channel;
43f66a6c
JK		 5643 } else {
5644 network->mode = IEEE_B;
b095c381 5645 priv->channel = geo->bg[0].channel;
43f66a6c 5646 }
afbf30a2
JK		 5647 break;
5648 }
43f66a6c
JK		 5649
5650 network->channel = priv->channel;
5651 priv->config |= CFG_ADHOC_PERSIST;
5652 ipw_create_bssid(priv, network->bssid);
5653 network->ssid_len = priv->essid_len;
5654 memcpy(network->ssid, priv->essid, priv->essid_len);
5655 memset(&network->stats, 0, sizeof(network->stats));
5656 network->capability = WLAN_CAPABILITY_IBSS;
ea2b26e0
JK		 5657 if (!(priv->config & CFG_PREAMBLE_LONG))
5658 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
43f66a6c
JK		 5659 if (priv->capability & CAP_PRIVACY_ON)
5660 network->capability |= WLAN_CAPABILITY_PRIVACY;
5661 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
0edd5b44 5662 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
43f66a6c 5663 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
bf79451e 5664 memcpy(network->rates_ex,
43f66a6c
JK		 5665 &priv->rates.supported_rates[network->rates_len],
5666 network->rates_ex_len);
5667 network->last_scanned = 0;
5668 network->flags = 0;
5669 network->last_associate = 0;
5670 network->time_stamp[0] = 0;
5671 network->time_stamp[1] = 0;
0edd5b44
JG		 5672 network->beacon_interval = 100; /* Default */
5673 network->listen_interval = 10; /* Default */
5674 network->atim_window = 0; /* Default */
43f66a6c
JK		 5675 network->wpa_ie_len = 0;
5676 network->rsn_ie_len = 0;
43f66a6c
JK		 5677}
5678
b095c381
JK		 5679static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5680{
0a7bcf26 5681 struct ipw_tgi_tx_key key;
b095c381
JK		 5682
5683 if (!(priv->ieee->sec.flags & (1 << index)))
5684 return;
5685
0a7bcf26
ZY		 5686 key.key_id = index;
5687 memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5688 key.security_type = type;
5689 key.station_index = 0; /* always 0 for BSS */
5690 key.flags = 0;
b095c381 5691 /* 0 for new key; previous value of counter (after fatal error) */
0a7bcf26
ZY		 5692 key.tx_counter[0] = 0;
5693 key.tx_counter[1] = 0;
b095c381 5694
0a7bcf26 5695 ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
b095c381
JK		 5696}
5697
5698static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
43f66a6c 5699{
0a7bcf26 5700 struct ipw_wep_key key;
43f66a6c 5701 int i;
43f66a6c 5702
0a7bcf26
ZY		 5703 key.cmd_id = DINO_CMD_WEP_KEY;
5704 key.seq_num = 0;
43f66a6c 5705
b095c381
JK		 5706 /* Note: AES keys cannot be set for multiple times.
5707 * Only set it at the first time. */
bf79451e 5708 for (i = 0; i < 4; i++) {
0a7bcf26 5709 key.key_index = i | type;
b095c381 5710 if (!(priv->ieee->sec.flags & (1 << i))) {
0a7bcf26 5711 key.key_size = 0;
b095c381 5712 continue;
43f66a6c
JK		 5713 }
5714
0a7bcf26
ZY		 5715 key.key_size = priv->ieee->sec.key_sizes[i];
5716 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
b095c381 5717
0a7bcf26 5718 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
bf79451e 5719 }
43f66a6c
JK		 5720}
5721
1fbfea54 5722static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
43f66a6c 5723{
1fbfea54 5724 if (priv->ieee->host_encrypt)
43f66a6c 5725 return;
43f66a6c 5726
1fbfea54
ZY		 5727 switch (level) {
5728 case SEC_LEVEL_3:
5729 priv->sys_config.disable_unicast_decryption = 0;
5730 priv->ieee->host_decrypt = 0;
5731 break;
5732 case SEC_LEVEL_2:
5733 priv->sys_config.disable_unicast_decryption = 1;
5734 priv->ieee->host_decrypt = 1;
5735 break;
5736 case SEC_LEVEL_1:
5737 priv->sys_config.disable_unicast_decryption = 0;
5738 priv->ieee->host_decrypt = 0;
5739 break;
5740 case SEC_LEVEL_0:
5741 priv->sys_config.disable_unicast_decryption = 1;
5742 break;
5743 default:
5744 break;
5745 }
5746}
5747
5748static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5749{
5750 if (priv->ieee->host_encrypt)
5751 return;
5752
5753 switch (level) {
5754 case SEC_LEVEL_3:
5755 priv->sys_config.disable_multicast_decryption = 0;
5756 break;
5757 case SEC_LEVEL_2:
5758 priv->sys_config.disable_multicast_decryption = 1;
5759 break;
5760 case SEC_LEVEL_1:
5761 priv->sys_config.disable_multicast_decryption = 0;
5762 break;
5763 case SEC_LEVEL_0:
5764 priv->sys_config.disable_multicast_decryption = 1;
5765 break;
5766 default:
5767 break;
5768 }
5769}
5770
b095c381
JK		 5771static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5772{
5773 switch (priv->ieee->sec.level) {
5774 case SEC_LEVEL_3:
d8bad6df
ZY		 5775 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5776 ipw_send_tgi_tx_key(priv,
5777 DCT_FLAG_EXT_SECURITY_CCM,
5778 priv->ieee->sec.active_key);
afbf30a2 5779
567deaf6
HL		 5780 if (!priv->ieee->host_mc_decrypt)
5781 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
b095c381
JK		 5782 break;
5783 case SEC_LEVEL_2:
d8bad6df
ZY		 5784 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5785 ipw_send_tgi_tx_key(priv,
5786 DCT_FLAG_EXT_SECURITY_TKIP,
5787 priv->ieee->sec.active_key);
b095c381
JK		 5788 break;
5789 case SEC_LEVEL_1:
5790 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
29cb843e
HL		 5791 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5792 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
b095c381
JK		 5793 break;
5794 case SEC_LEVEL_0:
5795 default:
5796 break;
5797 }
5798}
5799
43f66a6c
JK		 5800static void ipw_adhoc_check(void *data)
5801{
5802 struct ipw_priv *priv = data;
bf79451e 5803
afbf30a2 5804 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
43f66a6c 5805 !(priv->config & CFG_ADHOC_PERSIST)) {
afbf30a2
JK		 5806 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5807 IPW_DL_STATE | IPW_DL_ASSOC,
5808 "Missed beacon: %d - disassociate\n",
5809 priv->missed_adhoc_beacons);
43f66a6c
JK		 5810 ipw_remove_current_network(priv);
5811 ipw_disassociate(priv);
5812 return;
5813 }
5814
bf79451e 5815 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
43f66a6c
JK		 5816 priv->assoc_request.beacon_interval);
5817}
5818
c848d0af
JK		 5819static void ipw_bg_adhoc_check(void *data)
5820{
5821 struct ipw_priv *priv = data;
4644151b 5822 mutex_lock(&priv->mutex);
c848d0af 5823 ipw_adhoc_check(data);
4644151b 5824 mutex_unlock(&priv->mutex);
c848d0af
JK		 5825}
5826
0f52bf90 5827#ifdef CONFIG_IPW2200_DEBUG
43f66a6c
JK		 5828static void ipw_debug_config(struct ipw_priv *priv)
5829{
5830 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5831 "[CFG 0x%08X]\n", priv->config);
5832 if (priv->config & CFG_STATIC_CHANNEL)
0edd5b44 5833 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
43f66a6c
JK		 5834 else
5835 IPW_DEBUG_INFO("Channel unlocked.\n");
5836 if (priv->config & CFG_STATIC_ESSID)
bf79451e 5837 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
0edd5b44 5838 escape_essid(priv->essid, priv->essid_len));
43f66a6c
JK		 5839 else
5840 IPW_DEBUG_INFO("ESSID unlocked.\n");
5841 if (priv->config & CFG_STATIC_BSSID)
ea2b26e0
JK		 5842 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5843 MAC_ARG(priv->bssid));
43f66a6c
JK		 5844 else
5845 IPW_DEBUG_INFO("BSSID unlocked.\n");
5846 if (priv->capability & CAP_PRIVACY_ON)
5847 IPW_DEBUG_INFO("PRIVACY on\n");
5848 else
5849 IPW_DEBUG_INFO("PRIVACY off\n");
5850 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5851}
5852#else
8d45ff7d 5853#define ipw_debug_config(x) do {} while (0)
43f66a6c
JK		 5854#endif
5855
858119e1 5856static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
43f66a6c
JK		 5857{
5858 /* TODO: Verify that this works... */
5859 struct ipw_fixed_rate fr = {
5860 .tx_rates = priv->rates_mask
5861 };
5862 u32 reg;
5863 u16 mask = 0;
5864
bf79451e 5865 /* Identify 'current FW band' and match it with the fixed
43f66a6c 5866 * Tx rates */
bf79451e 5867
43f66a6c 5868 switch (priv->ieee->freq_band) {
0edd5b44 5869 case IEEE80211_52GHZ_BAND: /* A only */
43f66a6c
JK		 5870 /* IEEE_A */
5871 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5872 /* Invalid fixed rate mask */
ea2b26e0
JK		 5873 IPW_DEBUG_WX
5874 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
43f66a6c
JK		 5875 fr.tx_rates = 0;
5876 break;
5877 }
bf79451e 5878
43f66a6c
JK		 5879 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5880 break;
5881
0edd5b44 5882 default: /* 2.4Ghz or Mixed */
43f66a6c 5883 /* IEEE_B */
b095c381 5884 if (mode == IEEE_B) {
43f66a6c
JK		 5885 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5886 /* Invalid fixed rate mask */
ea2b26e0
JK		 5887 IPW_DEBUG_WX
5888 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
43f66a6c
JK		 5889 fr.tx_rates = 0;
5890 }
5891 break;
bf79451e 5892 }
43f66a6c
JK		 5893
5894 /* IEEE_G */
5895 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5896 IEEE80211_OFDM_RATES_MASK)) {
5897 /* Invalid fixed rate mask */
ea2b26e0
JK		 5898 IPW_DEBUG_WX
5899 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
43f66a6c
JK		 5900 fr.tx_rates = 0;
5901 break;
5902 }
bf79451e 5903
43f66a6c
JK		 5904 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5905 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5906 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5907 }
bf79451e 5908
43f66a6c
JK		 5909 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5910 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5911 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5912 }
bf79451e 5913
43f66a6c
JK		 5914 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5915 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5916 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5917 }
bf79451e 5918
43f66a6c
JK		 5919 fr.tx_rates |= mask;
5920 break;
5921 }
5922
5923 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
0edd5b44 5924 ipw_write_reg32(priv, reg, *(u32 *) & fr);
43f66a6c
JK		 5925}
5926
ea2b26e0 5927static void ipw_abort_scan(struct ipw_priv *priv)
43f66a6c
JK		 5928{
5929 int err;
5930
ea2b26e0
JK		 5931 if (priv->status & STATUS_SCAN_ABORTING) {
5932 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5933 return;
5934 }
5935 priv->status |= STATUS_SCAN_ABORTING;
43f66a6c 5936
ea2b26e0
JK		 5937 err = ipw_send_scan_abort(priv);
5938 if (err)
5939 IPW_DEBUG_HC("Request to abort scan failed.\n");
5940}
5941
afbf30a2
JK		 5942static void ipw_add_scan_channels(struct ipw_priv *priv,
5943 struct ipw_scan_request_ext *scan,
5944 int scan_type)
ea2b26e0 5945{
ea2b26e0 5946 int channel_index = 0;
b095c381 5947 const struct ieee80211_geo *geo;
afbf30a2 5948 int i;
b095c381 5949
1867b117 5950 geo = ieee80211_get_geo(priv->ieee);
43f66a6c 5951
afbf30a2
JK		 5952 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5953 int start = channel_index;
5954 for (i = 0; i < geo->a_channels; i++) {
5955 if ((priv->status & STATUS_ASSOCIATED) &&
5956 geo->a[i].channel == priv->channel)
5957 continue;
5958 channel_index++;
5959 scan->channels_list[channel_index] = geo->a[i].channel;
1fe0adb4
LH		 5960 ipw_set_scan_type(scan, channel_index,
5961 geo->a[i].
5962 flags & IEEE80211_CH_PASSIVE_ONLY ?
5963 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5964 scan_type);
afbf30a2
JK		 5965 }
5966
5967 if (start != channel_index) {
5968 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5969 (channel_index - start);
5970 channel_index++;
5971 }
5972 }
5973
5974 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5975 int start = channel_index;
5976 if (priv->config & CFG_SPEED_SCAN) {
1fe0adb4 5977 int index;
afbf30a2
JK		 5978 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5979 /* nop out the list */
5980 [0] = 0
5981 };
5982
5983 u8 channel;
5984 while (channel_index < IPW_SCAN_CHANNELS) {
5985 channel =
5986 priv->speed_scan[priv->speed_scan_pos];
5987 if (channel == 0) {
5988 priv->speed_scan_pos = 0;
5989 channel = priv->speed_scan[0];
5990 }
5991 if ((priv->status & STATUS_ASSOCIATED) &&
5992 channel == priv->channel) {
5993 priv->speed_scan_pos++;
5994 continue;
5995 }
5996
5997 /* If this channel has already been
5998 * added in scan, break from loop
5999 * and this will be the first channel
6000 * in the next scan.
6001 */
6002 if (channels[channel - 1] != 0)
6003 break;
6004
6005 channels[channel - 1] = 1;
6006 priv->speed_scan_pos++;
6007 channel_index++;
6008 scan->channels_list[channel_index] = channel;
1fe0adb4 6009 index =
1867b117 6010 ieee80211_channel_to_index(priv->ieee, channel);
afbf30a2 6011 ipw_set_scan_type(scan, channel_index,
1fe0adb4
LH		 6012 geo->bg[index].
6013 flags &
6014 IEEE80211_CH_PASSIVE_ONLY ?
6015 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6016 : scan_type);
afbf30a2
JK		 6017 }
6018 } else {
6019 for (i = 0; i < geo->bg_channels; i++) {
6020 if ((priv->status & STATUS_ASSOCIATED) &&
6021 geo->bg[i].channel == priv->channel)
6022 continue;
6023 channel_index++;
6024 scan->channels_list[channel_index] =
6025 geo->bg[i].channel;
6026 ipw_set_scan_type(scan, channel_index,
1fe0adb4
LH		 6027 geo->bg[i].
6028 flags &
6029 IEEE80211_CH_PASSIVE_ONLY ?
6030 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6031 : scan_type);
afbf30a2
JK		 6032 }
6033 }
6034
6035 if (start != channel_index) {
6036 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6037 (channel_index - start);
6038 }
6039 }
6040}
6041
6042static int ipw_request_scan(struct ipw_priv *priv)
6043{
6044 struct ipw_scan_request_ext scan;
6045 int err = 0, scan_type;
6046
6047 if (!(priv->status & STATUS_INIT) ||
6048 (priv->status & STATUS_EXIT_PENDING))
6049 return 0;
6050
4644151b 6051 mutex_lock(&priv->mutex);
afbf30a2 6052
ea2b26e0 6053 if (priv->status & STATUS_SCANNING) {
a613bffd 6054 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
ea2b26e0 6055 priv->status |= STATUS_SCAN_PENDING;
b095c381 6056 goto done;
ea2b26e0 6057 }
43f66a6c 6058
afbf30a2
JK		 6059 if (!(priv->status & STATUS_SCAN_FORCED) &&
6060 priv->status & STATUS_SCAN_ABORTING) {
ea2b26e0
JK		 6061 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6062 priv->status |= STATUS_SCAN_PENDING;
b095c381 6063 goto done;
43f66a6c
JK		 6064 }
6065
ea2b26e0
JK		 6066 if (priv->status & STATUS_RF_KILL_MASK) {
6067 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6068 priv->status |= STATUS_SCAN_PENDING;
b095c381 6069 goto done;
ea2b26e0 6070 }
43f66a6c 6071
ea2b26e0 6072 memset(&scan, 0, sizeof(scan));
43f66a6c 6073
b095c381
JK		 6074 if (priv->config & CFG_SPEED_SCAN)
6075 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6076 cpu_to_le16(30);
6077 else
6078 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6079 cpu_to_le16(20);
6080
a613bffd
JK		 6081 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6082 cpu_to_le16(20);
1fe0adb4 6083 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
43f66a6c 6084
a613bffd 6085 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
43f66a6c 6086
b095c381 6087#ifdef CONFIG_IPW2200_MONITOR
ea2b26e0 6088 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 6089 u8 channel;
b095c381 6090 u8 band = 0;
43f66a6c 6091
1867b117 6092 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
b095c381 6093 case IEEE80211_52GHZ_BAND:
ea2b26e0 6094 band = (u8) (IPW_A_MODE << 6) | 1;
b095c381
JK		 6095 channel = priv->channel;
6096 break;
ea2b26e0 6097
b095c381 6098 case IEEE80211_24GHZ_BAND:
ea2b26e0 6099 band = (u8) (IPW_B_MODE << 6) | 1;
b095c381
JK		 6100 channel = priv->channel;
6101 break;
ea2b26e0 6102
b095c381 6103 default:
ea2b26e0
JK		 6104 band = (u8) (IPW_B_MODE << 6) | 1;
6105 channel = 9;
b095c381 6106 break;
ea2b26e0
JK		 6107 }
6108
b095c381
JK		 6109 scan.channels_list[0] = band;
6110 scan.channels_list[1] = channel;
6111 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
ea2b26e0 6112
b095c381
JK		 6113 /* NOTE: The card will sit on this channel for this time
6114 * period. Scan aborts are timing sensitive and frequently
6115 * result in firmware restarts. As such, it is best to
6116 * set a small dwell_time here and just keep re-issuing
6117 * scans. Otherwise fast channel hopping will not actually
6118 * hop channels.
6119 *
6120 * TODO: Move SPEED SCAN support to all modes and bands */
a613bffd
JK		 6121 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6122 cpu_to_le16(2000);
43f66a6c 6123 } else {
b095c381
JK		 6124#endif /* CONFIG_IPW2200_MONITOR */
6125 /* If we are roaming, then make this a directed scan for the
6126 * current network. Otherwise, ensure that every other scan
6127 * is a fast channel hop scan */
6128 if ((priv->status & STATUS_ROAMING)
6129 || (!(priv->status & STATUS_ASSOCIATED)
6130 && (priv->config & CFG_STATIC_ESSID)
6131 && (le32_to_cpu(scan.full_scan_index) % 2))) {
ea2b26e0
JK		 6132 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6133 if (err) {
b095c381
JK		 6134 IPW_DEBUG_HC("Attempt to send SSID command "
6135 "failed.\n");
6136 goto done;
ea2b26e0 6137 }
43f66a6c 6138
ea2b26e0 6139 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
afbf30a2 6140 } else
ea2b26e0 6141 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
ea2b26e0 6142
afbf30a2 6143 ipw_add_scan_channels(priv, &scan, scan_type);
b095c381 6144#ifdef CONFIG_IPW2200_MONITOR
43f66a6c 6145 }
ea2b26e0 6146#endif
bf79451e 6147
ea2b26e0 6148 err = ipw_send_scan_request_ext(priv, &scan);
43f66a6c 6149 if (err) {
ea2b26e0 6150 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
b095c381 6151 goto done;
43f66a6c
JK		 6152 }
6153
ea2b26e0
JK		 6154 priv->status |= STATUS_SCANNING;
6155 priv->status &= ~STATUS_SCAN_PENDING;
afbf30a2
JK		 6156 queue_delayed_work(priv->workqueue, &priv->scan_check,
6157 IPW_SCAN_CHECK_WATCHDOG);
b095c381 6158 done:
4644151b 6159 mutex_unlock(&priv->mutex);
b095c381 6160 return err;
c848d0af
JK		 6161}
6162
6163static void ipw_bg_abort_scan(void *data)
6164{
6165 struct ipw_priv *priv = data;
4644151b 6166 mutex_lock(&priv->mutex);
c848d0af 6167 ipw_abort_scan(data);
4644151b 6168 mutex_unlock(&priv->mutex);
c848d0af
JK		 6169}
6170
ea2b26e0
JK		 6171static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6172{
b095c381
JK		 6173 /* This is called when wpa_supplicant loads and closes the driver
6174 * interface. */
cdd1fa1e 6175 priv->ieee->wpa_enabled = value;
b095c381 6176 return 0;
ea2b26e0
JK		 6177}
6178
ea2b26e0
JK		 6179static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6180{
6181 struct ieee80211_device *ieee = priv->ieee;
6182 struct ieee80211_security sec = {
6183 .flags = SEC_AUTH_MODE,
6184 };
6185 int ret = 0;
6186
afbf30a2 6187 if (value & IW_AUTH_ALG_SHARED_KEY) {
ea2b26e0
JK		 6188 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6189 ieee->open_wep = 0;
afbf30a2 6190 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
ea2b26e0
JK		 6191 sec.auth_mode = WLAN_AUTH_OPEN;
6192 ieee->open_wep = 1;
3e234b4e
ZY		 6193 } else if (value & IW_AUTH_ALG_LEAP) {
6194 sec.auth_mode = WLAN_AUTH_LEAP;
6195 ieee->open_wep = 1;
afbf30a2
JK		 6196 } else
6197 return -EINVAL;
ea2b26e0
JK		 6198
6199 if (ieee->set_security)
6200 ieee->set_security(ieee->dev, &sec);
6201 else
6202 ret = -EOPNOTSUPP;
6203
6204 return ret;
6205}
6206
a73e22b2
AB		 6207static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6208 int wpa_ie_len)
afbf30a2
JK		 6209{
6210 /* make sure WPA is enabled */
6211 ipw_wpa_enable(priv, 1);
6212
6213 ipw_disassociate(priv);
6214}
6215
6216static int ipw_set_rsn_capa(struct ipw_priv *priv,
6217 char *capabilities, int length)
6218{
afbf30a2
JK		 6219 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6220
0a7bcf26 6221 return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
2638bc39 6222 capabilities);
afbf30a2
JK		 6223}
6224
b095c381 6225/*
afbf30a2
JK		 6226 * WE-18 support
6227 */
6228
6229/* SIOCSIWGENIE */
6230static int ipw_wx_set_genie(struct net_device *dev,
6231 struct iw_request_info *info,
6232 union iwreq_data *wrqu, char *extra)
ea2b26e0 6233{
afbf30a2
JK		 6234 struct ipw_priv *priv = ieee80211_priv(dev);
6235 struct ieee80211_device *ieee = priv->ieee;
6236 u8 *buf;
6237 int err = 0;
ea2b26e0 6238
afbf30a2
JK		 6239 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6240 (wrqu->data.length && extra == NULL))
6241 return -EINVAL;
ea2b26e0 6242
4644151b 6243 //mutex_lock(&priv->mutex);
afbf30a2
JK		 6244
6245 //if (!ieee->wpa_enabled) {
6246 // err = -EOPNOTSUPP;
6247 // goto out;
6248 //}
6249
6250 if (wrqu->data.length) {
6251 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6252 if (buf == NULL) {
6253 err = -ENOMEM;
6254 goto out;
6255 }
6256
6257 memcpy(buf, extra, wrqu->data.length);
6258 kfree(ieee->wpa_ie);
6259 ieee->wpa_ie = buf;
6260 ieee->wpa_ie_len = wrqu->data.length;
b095c381 6261 } else {
afbf30a2
JK		 6262 kfree(ieee->wpa_ie);
6263 ieee->wpa_ie = NULL;
6264 ieee->wpa_ie_len = 0;
ea2b26e0 6265 }
afbf30a2
JK		 6266
6267 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6268 out:
4644151b 6269 //mutex_unlock(&priv->mutex);
afbf30a2
JK		 6270 return err;
6271}
6272
6273/* SIOCGIWGENIE */
6274static int ipw_wx_get_genie(struct net_device *dev,
6275 struct iw_request_info *info,
6276 union iwreq_data *wrqu, char *extra)
6277{
6278 struct ipw_priv *priv = ieee80211_priv(dev);
6279 struct ieee80211_device *ieee = priv->ieee;
6280 int err = 0;
6281
4644151b 6282 //mutex_lock(&priv->mutex);
afbf30a2
JK		 6283
6284 //if (!ieee->wpa_enabled) {
6285 // err = -EOPNOTSUPP;
6286 // goto out;
6287 //}
6288
6289 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6290 wrqu->data.length = 0;
6291 goto out;
6292 }
6293
6294 if (wrqu->data.length < ieee->wpa_ie_len) {
6295 err = -E2BIG;
6296 goto out;
6297 }
6298
6299 wrqu->data.length = ieee->wpa_ie_len;
6300 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6301
6302 out:
4644151b 6303 //mutex_unlock(&priv->mutex);
afbf30a2
JK		 6304 return err;
6305}
6306
1fbfea54
ZY		 6307static int wext_cipher2level(int cipher)
6308{
6309 switch (cipher) {
6310 case IW_AUTH_CIPHER_NONE:
6311 return SEC_LEVEL_0;
6312 case IW_AUTH_CIPHER_WEP40:
6313 case IW_AUTH_CIPHER_WEP104:
6314 return SEC_LEVEL_1;
6315 case IW_AUTH_CIPHER_TKIP:
6316 return SEC_LEVEL_2;
6317 case IW_AUTH_CIPHER_CCMP:
6318 return SEC_LEVEL_3;
6319 default:
6320 return -1;
6321 }
6322}
6323
afbf30a2
JK		 6324/* SIOCSIWAUTH */
6325static int ipw_wx_set_auth(struct net_device *dev,
6326 struct iw_request_info *info,
6327 union iwreq_data *wrqu, char *extra)
6328{
6329 struct ipw_priv *priv = ieee80211_priv(dev);
6330 struct ieee80211_device *ieee = priv->ieee;
6331 struct iw_param *param = &wrqu->param;
6332 struct ieee80211_crypt_data *crypt;
6333 unsigned long flags;
6334 int ret = 0;
6335
6336 switch (param->flags & IW_AUTH_INDEX) {
6337 case IW_AUTH_WPA_VERSION:
1fbfea54 6338 break;
afbf30a2 6339 case IW_AUTH_CIPHER_PAIRWISE:
1fbfea54
ZY		 6340 ipw_set_hw_decrypt_unicast(priv,
6341 wext_cipher2level(param->value));
6342 break;
afbf30a2 6343 case IW_AUTH_CIPHER_GROUP:
1fbfea54
ZY		 6344 ipw_set_hw_decrypt_multicast(priv,
6345 wext_cipher2level(param->value));
6346 break;
afbf30a2
JK		 6347 case IW_AUTH_KEY_MGMT:
6348 /*
6349 * ipw2200 does not use these parameters
6350 */
6351 break;
6352
6353 case IW_AUTH_TKIP_COUNTERMEASURES:
6354 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
991d1cc5 6355 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
afbf30a2 6356 break;
afbf30a2
JK		 6357
6358 flags = crypt->ops->get_flags(crypt->priv);
6359
6360 if (param->value)
6361 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6362 else
6363 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6364
6365 crypt->ops->set_flags(flags, crypt->priv);
6366
6367 break;
6368
6369 case IW_AUTH_DROP_UNENCRYPTED:{
6370 /* HACK:
6371 *
6372 * wpa_supplicant calls set_wpa_enabled when the driver
6373 * is loaded and unloaded, regardless of if WPA is being
6374 * used. No other calls are made which can be used to
6375 * determine if encryption will be used or not prior to
6376 * association being expected. If encryption is not being
6377 * used, drop_unencrypted is set to false, else true -- we
6378 * can use this to determine if the CAP_PRIVACY_ON bit should
6379 * be set.
6380 */
6381 struct ieee80211_security sec = {
6382 .flags = SEC_ENABLED,
6383 .enabled = param->value,
6384 };
6385 priv->ieee->drop_unencrypted = param->value;
6386 /* We only change SEC_LEVEL for open mode. Others
6387 * are set by ipw_wpa_set_encryption.
6388 */
6389 if (!param->value) {
6390 sec.flags |= SEC_LEVEL;
6391 sec.level = SEC_LEVEL_0;
6392 } else {
6393 sec.flags |= SEC_LEVEL;
6394 sec.level = SEC_LEVEL_1;
6395 }
6396 if (priv->ieee->set_security)
6397 priv->ieee->set_security(priv->ieee->dev, &sec);
6398 break;
6399 }
6400
6401 case IW_AUTH_80211_AUTH_ALG:
6402 ret = ipw_wpa_set_auth_algs(priv, param->value);
6403 break;
6404
6405 case IW_AUTH_WPA_ENABLED:
6406 ret = ipw_wpa_enable(priv, param->value);
6407 break;
6408
6409 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6410 ieee->ieee802_1x = param->value;
6411 break;
6412
6413 //case IW_AUTH_ROAMING_CONTROL:
6414 case IW_AUTH_PRIVACY_INVOKED:
6415 ieee->privacy_invoked = param->value;
6416 break;
6417
6418 default:
6419 return -EOPNOTSUPP;
6420 }
6421 return ret;
6422}
6423
6424/* SIOCGIWAUTH */
6425static int ipw_wx_get_auth(struct net_device *dev,
6426 struct iw_request_info *info,
6427 union iwreq_data *wrqu, char *extra)
6428{
6429 struct ipw_priv *priv = ieee80211_priv(dev);
6430 struct ieee80211_device *ieee = priv->ieee;
6431 struct ieee80211_crypt_data *crypt;
6432 struct iw_param *param = &wrqu->param;
6433 int ret = 0;
6434
6435 switch (param->flags & IW_AUTH_INDEX) {
6436 case IW_AUTH_WPA_VERSION:
6437 case IW_AUTH_CIPHER_PAIRWISE:
6438 case IW_AUTH_CIPHER_GROUP:
6439 case IW_AUTH_KEY_MGMT:
6440 /*
6441 * wpa_supplicant will control these internally
6442 */
6443 ret = -EOPNOTSUPP;
6444 break;
6445
6446 case IW_AUTH_TKIP_COUNTERMEASURES:
6447 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
991d1cc5 6448 if (!crypt || !crypt->ops->get_flags)
afbf30a2 6449 break;
afbf30a2
JK		 6450
6451 param->value = (crypt->ops->get_flags(crypt->priv) &
6452 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6453
6454 break;
6455
6456 case IW_AUTH_DROP_UNENCRYPTED:
6457 param->value = ieee->drop_unencrypted;
6458 break;
6459
6460 case IW_AUTH_80211_AUTH_ALG:
6461 param->value = ieee->sec.auth_mode;
6462 break;
6463
6464 case IW_AUTH_WPA_ENABLED:
6465 param->value = ieee->wpa_enabled;
6466 break;
6467
6468 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6469 param->value = ieee->ieee802_1x;
6470 break;
6471
6472 case IW_AUTH_ROAMING_CONTROL:
6473 case IW_AUTH_PRIVACY_INVOKED:
6474 param->value = ieee->privacy_invoked;
6475 break;
6476
6477 default:
6478 return -EOPNOTSUPP;
6479 }
6480 return 0;
6481}
6482
6483/* SIOCSIWENCODEEXT */
6484static int ipw_wx_set_encodeext(struct net_device *dev,
6485 struct iw_request_info *info,
6486 union iwreq_data *wrqu, char *extra)
6487{
6488 struct ipw_priv *priv = ieee80211_priv(dev);
6489 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6490
6491 if (hwcrypto) {
afbf30a2 6492 if (ext->alg == IW_ENCODE_ALG_TKIP) {
567deaf6
HL		 6493 /* IPW HW can't build TKIP MIC,
6494 host decryption still needed */
6495 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6496 priv->ieee->host_mc_decrypt = 1;
6497 else {
6498 priv->ieee->host_encrypt = 0;
6499 priv->ieee->host_encrypt_msdu = 1;
6500 priv->ieee->host_decrypt = 1;
6501 }
afbf30a2
JK		 6502 } else {
6503 priv->ieee->host_encrypt = 0;
6504 priv->ieee->host_encrypt_msdu = 0;
6505 priv->ieee->host_decrypt = 0;
567deaf6 6506 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 6507 }
6508 }
6509
6510 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6511}
6512
6513/* SIOCGIWENCODEEXT */
6514static int ipw_wx_get_encodeext(struct net_device *dev,
6515 struct iw_request_info *info,
6516 union iwreq_data *wrqu, char *extra)
6517{
6518 struct ipw_priv *priv = ieee80211_priv(dev);
6519 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6520}
6521
6522/* SIOCSIWMLME */
6523static int ipw_wx_set_mlme(struct net_device *dev,
6524 struct iw_request_info *info,
6525 union iwreq_data *wrqu, char *extra)
6526{
6527 struct ipw_priv *priv = ieee80211_priv(dev);
6528 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6529 u16 reason;
6530
6531 reason = cpu_to_le16(mlme->reason_code);
6532
6533 switch (mlme->cmd) {
6534 case IW_MLME_DEAUTH:
6535 // silently ignore
6536 break;
6537
6538 case IW_MLME_DISASSOC:
6539 ipw_disassociate(priv);
6540 break;
6541
6542 default:
6543 return -EOPNOTSUPP;
6544 }
6545 return 0;
6546}
afbf30a2
JK		 6547
6548#ifdef CONFIG_IPW_QOS
6549
6550/* QoS */
6551/*
6552* get the modulation type of the current network or
6553* the card current mode
6554*/
53d0bcf8 6555static u8 ipw_qos_current_mode(struct ipw_priv * priv)
afbf30a2
JK		 6556{
6557 u8 mode = 0;
6558
6559 if (priv->status & STATUS_ASSOCIATED) {
6560 unsigned long flags;
6561
6562 spin_lock_irqsave(&priv->ieee->lock, flags);
6563 mode = priv->assoc_network->mode;
6564 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6565 } else {
6566 mode = priv->ieee->mode;
6567 }
6568 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6569 return mode;
b095c381 6570}
ea2b26e0 6571
b095c381
JK		 6572/*
6573* Handle management frame beacon and probe response
6574*/
3b9990cb
JK		 6575static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6576 int active_network,
6577 struct ieee80211_network *network)
b095c381
JK		 6578{
6579 u32 size = sizeof(struct ieee80211_qos_parameters);
6580
afbf30a2 6581 if (network->capability & WLAN_CAPABILITY_IBSS)
b095c381
JK		 6582 network->qos_data.active = network->qos_data.supported;
6583
6584 if (network->flags & NETWORK_HAS_QOS_MASK) {
afbf30a2
JK		 6585 if (active_network &&
6586 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
b095c381
JK		 6587 network->qos_data.active = network->qos_data.supported;
6588
6589 if ((network->qos_data.active == 1) && (active_network == 1) &&
6590 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6591 (network->qos_data.old_param_count !=
6592 network->qos_data.param_count)) {
6593 network->qos_data.old_param_count =
6594 network->qos_data.param_count;
6595 schedule_work(&priv->qos_activate);
afbf30a2
JK		 6596 IPW_DEBUG_QOS("QoS parameters change call "
6597 "qos_activate\n");
b095c381 6598 }
ea2b26e0 6599 } else {
afbf30a2
JK		 6600 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6601 memcpy(&network->qos_data.parameters,
b095c381 6602 &def_parameters_CCK, size);
afbf30a2
JK		 6603 else
6604 memcpy(&network->qos_data.parameters,
b095c381 6605 &def_parameters_OFDM, size);
afbf30a2 6606
b095c381
JK		 6607 if ((network->qos_data.active == 1) && (active_network == 1)) {
6608 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6609 schedule_work(&priv->qos_activate);
6610 }
6611
6612 network->qos_data.active = 0;
6613 network->qos_data.supported = 0;
ea2b26e0 6614 }
afbf30a2
JK		 6615 if ((priv->status & STATUS_ASSOCIATED) &&
6616 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6617 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6618 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6619 !(network->flags & NETWORK_EMPTY_ESSID))
b095c381 6620 if ((network->ssid_len ==
afbf30a2
JK		 6621 priv->assoc_network->ssid_len) &&
6622 !memcmp(network->ssid,
6623 priv->assoc_network->ssid,
6624 network->ssid_len)) {
b095c381
JK		 6625 queue_work(priv->workqueue,
6626 &priv->merge_networks);
6627 }
b095c381 6628 }
ea2b26e0 6629
b095c381
JK		 6630 return 0;
6631}
6632
6633/*
6634* This function set up the firmware to support QoS. It sends
6635* IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6636*/
6637static int ipw_qos_activate(struct ipw_priv *priv,
6638 struct ieee80211_qos_data *qos_network_data)
6639{
6640 int err;
6641 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6642 struct ieee80211_qos_parameters *active_one = NULL;
6643 u32 size = sizeof(struct ieee80211_qos_parameters);
6644 u32 burst_duration;
6645 int i;
6646 u8 type;
6647
6648 type = ipw_qos_current_mode(priv);
6649
6650 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6651 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6652 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6653 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6654
6655 if (qos_network_data == NULL) {
6656 if (type == IEEE_B) {
6657 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6658 active_one = &def_parameters_CCK;
6659 } else
6660 active_one = &def_parameters_OFDM;
6661
afbf30a2 6662 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 6663 burst_duration = ipw_qos_get_burst_duration(priv);
6664 for (i = 0; i < QOS_QUEUE_NUM; i++)
afbf30a2
JK		 6665 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6666 (u16) burst_duration;
6667 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
b095c381
JK		 6668 if (type == IEEE_B) {
6669 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6670 type);
6671 if (priv->qos_data.qos_enable == 0)
6672 active_one = &def_parameters_CCK;
6673 else
6674 active_one = priv->qos_data.def_qos_parm_CCK;
6675 } else {
6676 if (priv->qos_data.qos_enable == 0)
6677 active_one = &def_parameters_OFDM;
6678 else
6679 active_one = priv->qos_data.def_qos_parm_OFDM;
6680 }
afbf30a2 6681 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 6682 } else {
6683 unsigned long flags;
6684 int active;
6685
6686 spin_lock_irqsave(&priv->ieee->lock, flags);
6687 active_one = &(qos_network_data->parameters);
6688 qos_network_data->old_param_count =
6689 qos_network_data->param_count;
afbf30a2 6690 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 6691 active = qos_network_data->supported;
6692 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6693
6694 if (active == 0) {
6695 burst_duration = ipw_qos_get_burst_duration(priv);
6696 for (i = 0; i < QOS_QUEUE_NUM; i++)
6697 qos_parameters[QOS_PARAM_SET_ACTIVE].
6698 tx_op_limit[i] = (u16) burst_duration;
6699 }
6700 }
6701
6702 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
afbf30a2
JK		 6703 err = ipw_send_qos_params_command(priv,
6704 (struct ieee80211_qos_parameters *)
6705 &(qos_parameters[0]));
b095c381
JK		 6706 if (err)
6707 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6708
6709 return err;
6710}
6711
6712/*
6713* send IPW_CMD_WME_INFO to the firmware
6714*/
6715static int ipw_qos_set_info_element(struct ipw_priv *priv)
6716{
6717 int ret = 0;
6718 struct ieee80211_qos_information_element qos_info;
6719
6720 if (priv == NULL)
6721 return -1;
6722
6723 qos_info.elementID = QOS_ELEMENT_ID;
6724 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6725
6726 qos_info.version = QOS_VERSION_1;
6727 qos_info.ac_info = 0;
6728
6729 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6730 qos_info.qui_type = QOS_OUI_TYPE;
6731 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6732
6733 ret = ipw_send_qos_info_command(priv, &qos_info);
6734 if (ret != 0) {
6735 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6736 }
6737 return ret;
6738}
6739
6740/*
6741* Set the QoS parameter with the association request structure
6742*/
6743static int ipw_qos_association(struct ipw_priv *priv,
6744 struct ieee80211_network *network)
6745{
6746 int err = 0;
6747 struct ieee80211_qos_data *qos_data = NULL;
6748 struct ieee80211_qos_data ibss_data = {
6749 .supported = 1,
6750 .active = 1,
6751 };
6752
6753 switch (priv->ieee->iw_mode) {
6754 case IW_MODE_ADHOC:
6755 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6756 BUG();
6757
6758 qos_data = &ibss_data;
6759 break;
6760
6761 case IW_MODE_INFRA:
6762 qos_data = &network->qos_data;
6763 break;
6764
6765 default:
6766 BUG();
6767 break;
6768 }
6769
6770 err = ipw_qos_activate(priv, qos_data);
6771 if (err) {
6772 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6773 return err;
6774 }
6775
6776 if (priv->qos_data.qos_enable && qos_data->supported) {
6777 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6778 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6779 return ipw_qos_set_info_element(priv);
6780 }
6781
6782 return 0;
6783}
6784
6785/*
6786* handling the beaconing responces. if we get different QoS setting
6787* of the network from the the associated setting adjust the QoS
6788* setting
6789*/
6790static int ipw_qos_association_resp(struct ipw_priv *priv,
6791 struct ieee80211_network *network)
6792{
6793 int ret = 0;
6794 unsigned long flags;
6795 u32 size = sizeof(struct ieee80211_qos_parameters);
6796 int set_qos_param = 0;
6797
afbf30a2
JK		 6798 if ((priv == NULL) || (network == NULL) ||
6799 (priv->assoc_network == NULL))
b095c381
JK		 6800 return ret;
6801
6802 if (!(priv->status & STATUS_ASSOCIATED))
6803 return ret;
6804
afbf30a2 6805 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
b095c381 6806 return ret;
b095c381
JK		 6807
6808 spin_lock_irqsave(&priv->ieee->lock, flags);
6809 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
afbf30a2 6810 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
b095c381
JK		 6811 sizeof(struct ieee80211_qos_data));
6812 priv->assoc_network->qos_data.active = 1;
6813 if ((network->qos_data.old_param_count !=
6814 network->qos_data.param_count)) {
6815 set_qos_param = 1;
6816 network->qos_data.old_param_count =
6817 network->qos_data.param_count;
6818 }
6819
6820 } else {
afbf30a2
JK		 6821 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6822 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 6823 &def_parameters_CCK, size);
afbf30a2
JK		 6824 else
6825 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 6826 &def_parameters_OFDM, size);
b095c381
JK		 6827 priv->assoc_network->qos_data.active = 0;
6828 priv->assoc_network->qos_data.supported = 0;
6829 set_qos_param = 1;
6830 }
6831
6832 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6833
6834 if (set_qos_param == 1)
6835 schedule_work(&priv->qos_activate);
6836
6837 return ret;
6838}
6839
6840static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6841{
6842 u32 ret = 0;
6843
6844 if ((priv == NULL))
6845 return 0;
6846
afbf30a2 6847 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
b095c381 6848 ret = priv->qos_data.burst_duration_CCK;
afbf30a2 6849 else
b095c381 6850 ret = priv->qos_data.burst_duration_OFDM;
afbf30a2 6851
b095c381
JK		 6852 return ret;
6853}
6854
6855/*
6856* Initialize the setting of QoS global
6857*/
6858static void ipw_qos_init(struct ipw_priv *priv, int enable,
6859 int burst_enable, u32 burst_duration_CCK,
6860 u32 burst_duration_OFDM)
6861{
6862 priv->qos_data.qos_enable = enable;
6863
6864 if (priv->qos_data.qos_enable) {
6865 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6866 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6867 IPW_DEBUG_QOS("QoS is enabled\n");
6868 } else {
6869 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6870 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6871 IPW_DEBUG_QOS("QoS is not enabled\n");
6872 }
6873
6874 priv->qos_data.burst_enable = burst_enable;
6875
6876 if (burst_enable) {
6877 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6878 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6879 } else {
6880 priv->qos_data.burst_duration_CCK = 0;
6881 priv->qos_data.burst_duration_OFDM = 0;
6882 }
6883}
6884
6885/*
6886* map the packet priority to the right TX Queue
6887*/
6888static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6889{
6890 if (priority > 7 || !priv->qos_data.qos_enable)
6891 priority = 0;
6892
6893 return from_priority_to_tx_queue[priority] - 1;
6894}
6895
6896/*
6897* add QoS parameter to the TX command
6898*/
6899static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6900 u16 priority,
6901 struct tfd_data *tfd, u8 unicast)
6902{
6903 int ret = 0;
6904 int tx_queue_id = 0;
6905 struct ieee80211_qos_data *qos_data = NULL;
6906 int active, supported;
6907 unsigned long flags;
6908
6909 if (!(priv->status & STATUS_ASSOCIATED))
6910 return 0;
6911
6912 qos_data = &priv->assoc_network->qos_data;
6913
6914 spin_lock_irqsave(&priv->ieee->lock, flags);
6915
6916 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6917 if (unicast == 0)
6918 qos_data->active = 0;
6919 else
6920 qos_data->active = qos_data->supported;
6921 }
6922
6923 active = qos_data->active;
6924 supported = qos_data->supported;
6925
6926 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6927
afbf30a2
JK		 6928 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
6929 "unicast %d\n",
6930 priv->qos_data.qos_enable, active, supported, unicast);
b095c381
JK		 6931 if (active && priv->qos_data.qos_enable) {
6932 ret = from_priority_to_tx_queue[priority];
6933 tx_queue_id = ret - 1;
6934 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6935 if (priority <= 7) {
6936 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6937 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6938 tfd->tfd.tfd_26.mchdr.frame_ctl |=
6939 IEEE80211_STYPE_QOS_DATA;
6940
6941 if (priv->qos_data.qos_no_ack_mask &
6942 (1UL << tx_queue_id)) {
6943 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6944 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6945 CTRL_QOS_NO_ACK;
6946 }
6947 }
6948 }
6949
6950 return ret;
6951}
6952
6953/*
6954* background support to run QoS activate functionality
6955*/
6956static void ipw_bg_qos_activate(void *data)
6957{
6958 struct ipw_priv *priv = data;
6959
6960 if (priv == NULL)
6961 return;
6962
4644151b 6963 mutex_lock(&priv->mutex);
b095c381
JK		 6964
6965 if (priv->status & STATUS_ASSOCIATED)
6966 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6967
4644151b 6968 mutex_unlock(&priv->mutex);
b095c381
JK		 6969}
6970
3b9990cb
JK		 6971static int ipw_handle_probe_response(struct net_device *dev,
6972 struct ieee80211_probe_response *resp,
6973 struct ieee80211_network *network)
b095c381
JK		 6974{
6975 struct ipw_priv *priv = ieee80211_priv(dev);
3b9990cb
JK		 6976 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6977 (network == priv->assoc_network));
43f66a6c 6978
3b9990cb 6979 ipw_qos_handle_probe_response(priv, active_network, network);
43f66a6c 6980
3b9990cb
JK		 6981 return 0;
6982}
43f66a6c 6983
3b9990cb
JK		 6984static int ipw_handle_beacon(struct net_device *dev,
6985 struct ieee80211_beacon *resp,
6986 struct ieee80211_network *network)
6987{
6988 struct ipw_priv *priv = ieee80211_priv(dev);
6989 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6990 (network == priv->assoc_network));
bf79451e 6991
3b9990cb 6992 ipw_qos_handle_probe_response(priv, active_network, network);
bf79451e 6993
b095c381
JK		 6994 return 0;
6995}
bf79451e 6996
3b9990cb
JK		 6997static int ipw_handle_assoc_response(struct net_device *dev,
6998 struct ieee80211_assoc_response *resp,
6999 struct ieee80211_network *network)
7000{
7001 struct ipw_priv *priv = ieee80211_priv(dev);
7002 ipw_qos_association_resp(priv, network);
7003 return 0;
7004}
43f66a6c 7005
b095c381
JK		 7006static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7007 *qos_param)
7008{
4e22699f
ZY		 7009 return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7010 sizeof(*qos_param) * 3, qos_param);
b095c381
JK		 7011}
7012
7013static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7014 *qos_param)
7015{
4e22699f
ZY		 7016 return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7017 qos_param);
43f66a6c
JK		 7018}
7019
b095c381
JK		 7020#endif /* CONFIG_IPW_QOS */
7021
43f66a6c
JK		 7022static int ipw_associate_network(struct ipw_priv *priv,
7023 struct ieee80211_network *network,
0edd5b44 7024 struct ipw_supported_rates *rates, int roaming)
43f66a6c
JK		 7025{
7026 int err;
7027
7028 if (priv->config & CFG_FIXED_RATE)
b095c381 7029 ipw_set_fixed_rate(priv, network->mode);
43f66a6c
JK		 7030
7031 if (!(priv->config & CFG_STATIC_ESSID)) {
bf79451e 7032 priv->essid_len = min(network->ssid_len,
0edd5b44 7033 (u8) IW_ESSID_MAX_SIZE);
43f66a6c
JK		 7034 memcpy(priv->essid, network->ssid, priv->essid_len);
7035 }
7036
7037 network->last_associate = jiffies;
7038
7039 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7040 priv->assoc_request.channel = network->channel;
3e234b4e
ZY		 7041 priv->assoc_request.auth_key = 0;
7042
43f66a6c 7043 if ((priv->capability & CAP_PRIVACY_ON) &&
3e234b4e 7044 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
43f66a6c 7045 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
b095c381
JK		 7046 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7047
1ba61e05 7048 if (priv->ieee->sec.level == SEC_LEVEL_1)
b095c381 7049 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
3e234b4e
ZY		 7050
7051 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7052 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7053 priv->assoc_request.auth_type = AUTH_LEAP;
7054 else
43f66a6c 7055 priv->assoc_request.auth_type = AUTH_OPEN;
43f66a6c 7056
b095c381 7057 if (priv->ieee->wpa_ie_len) {
ea2b26e0
JK		 7058 priv->assoc_request.policy_support = 0x02; /* RSN active */
7059 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7060 priv->ieee->wpa_ie_len);
7061 }
43f66a6c 7062
bf79451e
JG		 7063 /*
7064 * It is valid for our ieee device to support multiple modes, but
7065 * when it comes to associating to a given network we have to choose
43f66a6c
JK		 7066 * just one mode.
7067 */
7068 if (network->mode & priv->ieee->mode & IEEE_A)
7069 priv->assoc_request.ieee_mode = IPW_A_MODE;
7070 else if (network->mode & priv->ieee->mode & IEEE_G)
7071 priv->assoc_request.ieee_mode = IPW_G_MODE;
7072 else if (network->mode & priv->ieee->mode & IEEE_B)
7073 priv->assoc_request.ieee_mode = IPW_B_MODE;
7074
ea2b26e0
JK		 7075 priv->assoc_request.capability = network->capability;
7076 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7077 && !(priv->config & CFG_PREAMBLE_LONG)) {
7078 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7079 } else {
7080 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7081
7082 /* Clear the short preamble if we won't be supporting it */
7083 priv->assoc_request.capability &=
7084 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7085 }
7086
afbf30a2
JK		 7087 /* Clear capability bits that aren't used in Ad Hoc */
7088 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7089 priv->assoc_request.capability &=
7090 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7091
43f66a6c 7092 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
ea2b26e0 7093 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
43f66a6c 7094 roaming ? "Rea" : "A",
bf79451e
JG		 7095 escape_essid(priv->essid, priv->essid_len),
7096 network->channel,
7097 ipw_modes[priv->assoc_request.ieee_mode],
7098 rates->num_rates,
ea2b26e0
JK		 7099 (priv->assoc_request.preamble_length ==
7100 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7101 network->capability &
7102 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
43f66a6c 7103 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
bf79451e
JG		 7104 priv->capability & CAP_PRIVACY_ON ?
7105 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
43f66a6c
JK		 7106 "(open)") : "",
7107 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
bf79451e 7108 priv->capability & CAP_PRIVACY_ON ?
b095c381 7109 '1' + priv->ieee->sec.active_key : '.',
0edd5b44 7110 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
43f66a6c
JK		 7111
7112 priv->assoc_request.beacon_interval = network->beacon_interval;
7113 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
0edd5b44 7114 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
43f66a6c
JK		 7115 priv->assoc_request.assoc_type = HC_IBSS_START;
7116 priv->assoc_request.assoc_tsf_msw = 0;
7117 priv->assoc_request.assoc_tsf_lsw = 0;
7118 } else {
7119 if (unlikely(roaming))
7120 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7121 else
7122 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7123 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7124 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7125 }
7126
afbf30a2 7127 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
43f66a6c
JK		 7128
7129 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7130 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7131 priv->assoc_request.atim_window = network->atim_window;
7132 } else {
afbf30a2 7133 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
43f66a6c
JK		 7134 priv->assoc_request.atim_window = 0;
7135 }
7136
43f66a6c 7137 priv->assoc_request.listen_interval = network->listen_interval;
bf79451e 7138
43f66a6c
JK		 7139 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7140 if (err) {
7141 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7142 return err;
7143 }
7144
7145 rates->ieee_mode = priv->assoc_request.ieee_mode;
7146 rates->purpose = IPW_RATE_CONNECT;
7147 ipw_send_supported_rates(priv, rates);
bf79451e 7148
43f66a6c
JK		 7149 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7150 priv->sys_config.dot11g_auto_detection = 1;
7151 else
7152 priv->sys_config.dot11g_auto_detection = 0;
c848d0af
JK		 7153
7154 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7155 priv->sys_config.answer_broadcast_ssid_probe = 1;
7156 else
7157 priv->sys_config.answer_broadcast_ssid_probe = 0;
7158
43f66a6c
JK		 7159 err = ipw_send_system_config(priv, &priv->sys_config);
7160 if (err) {
7161 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7162 return err;
7163 }
bf79451e 7164
43f66a6c 7165 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
ea2b26e0 7166 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
43f66a6c
JK		 7167 if (err) {
7168 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7169 return err;
7170 }
7171
7172 /*
7173 * If preemption is enabled, it is possible for the association
7174 * to complete before we return from ipw_send_associate. Therefore
7175 * we have to be sure and update our priviate data first.
7176 */
7177 priv->channel = network->channel;
7178 memcpy(priv->bssid, network->bssid, ETH_ALEN);
bf79451e 7179 priv->status |= STATUS_ASSOCIATING;
43f66a6c
JK		 7180 priv->status &= ~STATUS_SECURITY_UPDATED;
7181
7182 priv->assoc_network = network;
7183
b095c381
JK		 7184#ifdef CONFIG_IPW_QOS
7185 ipw_qos_association(priv, network);
7186#endif
7187
43f66a6c
JK		 7188 err = ipw_send_associate(priv, &priv->assoc_request);
7189 if (err) {
7190 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7191 return err;
7192 }
bf79451e
JG		 7193
7194 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
43f66a6c
JK		 7195 escape_essid(priv->essid, priv->essid_len),
7196 MAC_ARG(priv->bssid));
7197
7198 return 0;
7199}
7200
7201static void ipw_roam(void *data)
7202{
7203 struct ipw_priv *priv = data;
7204 struct ieee80211_network *network = NULL;
7205 struct ipw_network_match match = {
7206 .network = priv->assoc_network
7207 };
7208
7209 /* The roaming process is as follows:
bf79451e
JG		 7210 *
7211 * 1. Missed beacon threshold triggers the roaming process by
43f66a6c
JK		 7212 * setting the status ROAM bit and requesting a scan.
7213 * 2. When the scan completes, it schedules the ROAM work
7214 * 3. The ROAM work looks at all of the known networks for one that
7215 * is a better network than the currently associated. If none
7216 * found, the ROAM process is over (ROAM bit cleared)
7217 * 4. If a better network is found, a disassociation request is
7218 * sent.
7219 * 5. When the disassociation completes, the roam work is again
7220 * scheduled. The second time through, the driver is no longer
7221 * associated, and the newly selected network is sent an
bf79451e 7222 * association request.
43f66a6c
JK		 7223 * 6. At this point ,the roaming process is complete and the ROAM
7224 * status bit is cleared.
7225 */
7226
7227 /* If we are no longer associated, and the roaming bit is no longer
7228 * set, then we are not actively roaming, so just return */
7229 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7230 return;
bf79451e 7231
43f66a6c 7232 if (priv->status & STATUS_ASSOCIATED) {
bf79451e 7233 /* First pass through ROAM process -- look for a better
43f66a6c 7234 * network */
a613bffd 7235 unsigned long flags;
43f66a6c
JK		 7236 u8 rssi = priv->assoc_network->stats.rssi;
7237 priv->assoc_network->stats.rssi = -128;
a613bffd 7238 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c
JK		 7239 list_for_each_entry(network, &priv->ieee->network_list, list) {
7240 if (network != priv->assoc_network)
7241 ipw_best_network(priv, &match, network, 1);
7242 }
a613bffd 7243 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c 7244 priv->assoc_network->stats.rssi = rssi;
bf79451e 7245
43f66a6c
JK		 7246 if (match.network == priv->assoc_network) {
7247 IPW_DEBUG_ASSOC("No better APs in this network to "
7248 "roam to.\n");
7249 priv->status &= ~STATUS_ROAMING;
7250 ipw_debug_config(priv);
7251 return;
7252 }
bf79451e 7253
43f66a6c
JK		 7254 ipw_send_disassociate(priv, 1);
7255 priv->assoc_network = match.network;
7256
7257 return;
bf79451e 7258 }
43f66a6c
JK		 7259
7260 /* Second pass through ROAM process -- request association */
7261 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7262 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7263 priv->status &= ~STATUS_ROAMING;
7264}
7265
c848d0af
JK		 7266static void ipw_bg_roam(void *data)
7267{
7268 struct ipw_priv *priv = data;
4644151b 7269 mutex_lock(&priv->mutex);
c848d0af 7270 ipw_roam(data);
4644151b 7271 mutex_unlock(&priv->mutex);
c848d0af
JK		 7272}
7273
7274static int ipw_associate(void *data)
43f66a6c
JK		 7275{
7276 struct ipw_priv *priv = data;
7277
7278 struct ieee80211_network *network = NULL;
7279 struct ipw_network_match match = {
7280 .network = NULL
7281 };
7282 struct ipw_supported_rates *rates;
7283 struct list_head *element;
a613bffd 7284 unsigned long flags;
43f66a6c 7285
b095c381
JK		 7286 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7287 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7288 return 0;
7289 }
7290
c848d0af 7291 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
afbf30a2
JK		 7292 IPW_DEBUG_ASSOC("Not attempting association (already in "
7293 "progress)\n");
c848d0af
JK		 7294 return 0;
7295 }
7296
e6324726
HL		 7297 if (priv->status & STATUS_DISASSOCIATING) {
7298 IPW_DEBUG_ASSOC("Not attempting association (in "
7299 "disassociating)\n ");
7300 queue_work(priv->workqueue, &priv->associate);
7301 return 0;
7302 }
7303
c848d0af 7304 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
afbf30a2
JK		 7305 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7306 "initialized)\n");
c848d0af
JK		 7307 return 0;
7308 }
43f66a6c
JK		 7309
7310 if (!(priv->config & CFG_ASSOCIATE) &&
7311 !(priv->config & (CFG_STATIC_ESSID |
0edd5b44 7312 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
43f66a6c 7313 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
c848d0af 7314 return 0;
43f66a6c
JK		 7315 }
7316
a613bffd
JK		 7317 /* Protect our use of the network_list */
7318 spin_lock_irqsave(&priv->ieee->lock, flags);
bf79451e 7319 list_for_each_entry(network, &priv->ieee->network_list, list)
0edd5b44 7320 ipw_best_network(priv, &match, network, 0);
43f66a6c
JK		 7321
7322 network = match.network;
7323 rates = &match.rates;
7324
7325 if (network == NULL &&
7326 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7327 priv->config & CFG_ADHOC_CREATE &&
7328 priv->config & CFG_STATIC_ESSID &&
a613bffd 7329 priv->config & CFG_STATIC_CHANNEL &&
43f66a6c
JK		 7330 !list_empty(&priv->ieee->network_free_list)) {
7331 element = priv->ieee->network_free_list.next;
0edd5b44 7332 network = list_entry(element, struct ieee80211_network, list);
43f66a6c
JK		 7333 ipw_adhoc_create(priv, network);
7334 rates = &priv->rates;
7335 list_del(element);
7336 list_add_tail(&network->list, &priv->ieee->network_list);
7337 }
a613bffd 7338 spin_unlock_irqrestore(&priv->ieee->lock, flags);
bf79451e 7339
43f66a6c
JK		 7340 /* If we reached the end of the list, then we don't have any valid
7341 * matching APs */
7342 if (!network) {
7343 ipw_debug_config(priv);
7344
b095c381
JK		 7345 if (!(priv->status & STATUS_SCANNING)) {
7346 if (!(priv->config & CFG_SPEED_SCAN))
7347 queue_delayed_work(priv->workqueue,
7348 &priv->request_scan,
7349 SCAN_INTERVAL);
7350 else
7351 queue_work(priv->workqueue,
7352 &priv->request_scan);
7353 }
bf79451e 7354
c848d0af 7355 return 0;
43f66a6c
JK		 7356 }
7357
7358 ipw_associate_network(priv, network, rates, 0);
c848d0af
JK		 7359
7360 return 1;
7361}
7362
7363static void ipw_bg_associate(void *data)
7364{
7365 struct ipw_priv *priv = data;
4644151b 7366 mutex_lock(&priv->mutex);
c848d0af 7367 ipw_associate(data);
4644151b 7368 mutex_unlock(&priv->mutex);
43f66a6c 7369}
bf79451e 7370
b095c381
JK		 7371static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7372 struct sk_buff *skb)
7373{
7374 struct ieee80211_hdr *hdr;
7375 u16 fc;
7376
7377 hdr = (struct ieee80211_hdr *)skb->data;
7378 fc = le16_to_cpu(hdr->frame_ctl);
7379 if (!(fc & IEEE80211_FCTL_PROTECTED))
7380 return;
7381
7382 fc &= ~IEEE80211_FCTL_PROTECTED;
7383 hdr->frame_ctl = cpu_to_le16(fc);
7384 switch (priv->ieee->sec.level) {
7385 case SEC_LEVEL_3:
7386 /* Remove CCMP HDR */
7387 memmove(skb->data + IEEE80211_3ADDR_LEN,
7388 skb->data + IEEE80211_3ADDR_LEN + 8,
7389 skb->len - IEEE80211_3ADDR_LEN - 8);
f4ff497d 7390 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
b095c381
JK		 7391 break;
7392 case SEC_LEVEL_2:
7393 break;
7394 case SEC_LEVEL_1:
7395 /* Remove IV */
7396 memmove(skb->data + IEEE80211_3ADDR_LEN,
7397 skb->data + IEEE80211_3ADDR_LEN + 4,
7398 skb->len - IEEE80211_3ADDR_LEN - 4);
f4ff497d 7399 skb_trim(skb, skb->len - 8); /* IV + ICV */
b095c381
JK		 7400 break;
7401 case SEC_LEVEL_0:
7402 break;
7403 default:
7404 printk(KERN_ERR "Unknow security level %d\n",
7405 priv->ieee->sec.level);
7406 break;
7407 }
43f66a6c 7408}
bf79451e 7409
b095c381
JK		 7410static void ipw_handle_data_packet(struct ipw_priv *priv,
7411 struct ipw_rx_mem_buffer *rxb,
7412 struct ieee80211_rx_stats *stats)
43f66a6c 7413{
567deaf6 7414 struct ieee80211_hdr_4addr *hdr;
43f66a6c
JK		 7415 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7416
7417 /* We received data from the HW, so stop the watchdog */
7418 priv->net_dev->trans_start = jiffies;
7419
bf79451e 7420 /* We only process data packets if the
43f66a6c 7421 * interface is open */
a613bffd 7422 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
43f66a6c
JK		 7423 skb_tailroom(rxb->skb))) {
7424 priv->ieee->stats.rx_errors++;
7425 priv->wstats.discard.misc++;
7426 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7427 return;
7428 } else if (unlikely(!netif_running(priv->net_dev))) {
7429 priv->ieee->stats.rx_dropped++;
7430 priv->wstats.discard.misc++;
7431 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7432 return;
7433 }
7434
7435 /* Advance skb->data to the start of the actual payload */
aaa4d308 7436 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
43f66a6c
JK		 7437
7438 /* Set the size of the skb to the size of the frame */
a613bffd 7439 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
43f66a6c
JK		 7440
7441 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7442
b095c381 7443 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
567deaf6
HL		 7444 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7445 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
3c19065a 7446 (is_multicast_ether_addr(hdr->addr1) ?
567deaf6 7447 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
b095c381
JK		 7448 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7449
bf79451e 7450 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
43f66a6c 7451 priv->ieee->stats.rx_errors++;
a613bffd 7452 else { /* ieee80211_rx succeeded, so it now owns the SKB */
43f66a6c 7453 rxb->skb = NULL;
b095c381 7454 __ipw_led_activity_on(priv);
a613bffd 7455 }
43f66a6c
JK		 7456}
7457
24a47dbd
MK		 7458#ifdef CONFIG_IEEE80211_RADIOTAP
7459static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7460 struct ipw_rx_mem_buffer *rxb,
7461 struct ieee80211_rx_stats *stats)
7462{
7463 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7464 struct ipw_rx_frame *frame = &pkt->u.frame;
7465
7466 /* initial pull of some data */
7467 u16 received_channel = frame->received_channel;
7468 u8 antennaAndPhy = frame->antennaAndPhy;
7469 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7470 u16 pktrate = frame->rate;
7471
7472 /* Magic struct that slots into the radiotap header -- no reason
7473 * to build this manually element by element, we can write it much
7474 * more efficiently than we can parse it. ORDER MATTERS HERE */
7475 struct ipw_rt_hdr {
7476 struct ieee80211_radiotap_header rt_hdr;
7477 u8 rt_flags; /* radiotap packet flags */
7478 u8 rt_rate; /* rate in 500kb/s */
7479 u16 rt_channel; /* channel in mhz */
7480 u16 rt_chbitmask; /* channel bitfield */
7481 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7482 u8 rt_antenna; /* antenna number */
7483 } *ipw_rt;
7484
7485 short len = le16_to_cpu(pkt->u.frame.length);
7486
7487 /* We received data from the HW, so stop the watchdog */
7488 priv->net_dev->trans_start = jiffies;
7489
7490 /* We only process data packets if the
7491 * interface is open */
7492 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7493 skb_tailroom(rxb->skb))) {
7494 priv->ieee->stats.rx_errors++;
7495 priv->wstats.discard.misc++;
7496 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7497 return;
7498 } else if (unlikely(!netif_running(priv->net_dev))) {
7499 priv->ieee->stats.rx_dropped++;
7500 priv->wstats.discard.misc++;
7501 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7502 return;
7503 }
7504
7505 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7506 * that now */
7507 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7508 /* FIXME: Should alloc bigger skb instead */
7509 priv->ieee->stats.rx_dropped++;
7510 priv->wstats.discard.misc++;
7511 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7512 return;
7513 }
7514
7515 /* copy the frame itself */
7516 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7517 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7518
7519 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7520 * part of our real header, saves a little time.
7521 *
7522 * No longer necessary since we fill in all our data. Purge before merging
7523 * patch officially.
7524 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7525 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7526 */
7527
7528 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7529
7530 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7531 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7532 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7533
7534 /* Big bitfield of all the fields we provide in radiotap */
7535 ipw_rt->rt_hdr.it_present =
7536 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7537 (1 << IEEE80211_RADIOTAP_RATE) |
7538 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7539 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7540 (1 << IEEE80211_RADIOTAP_ANTENNA));
7541
7542 /* Zero the flags, we'll add to them as we go */
7543 ipw_rt->rt_flags = 0;
7544
7545 /* Convert signal to DBM */
7546 ipw_rt->rt_dbmsignal = antsignal;
7547
7548 /* Convert the channel data and set the flags */
7549 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7550 if (received_channel > 14) { /* 802.11a */
7551 ipw_rt->rt_chbitmask =
7552 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7553 } else if (antennaAndPhy & 32) { /* 802.11b */
7554 ipw_rt->rt_chbitmask =
7555 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7556 } else { /* 802.11g */
7557 ipw_rt->rt_chbitmask =
7558 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7559 }
7560
7561 /* set the rate in multiples of 500k/s */
7562 switch (pktrate) {
7563 case IPW_TX_RATE_1MB:
7564 ipw_rt->rt_rate = 2;
7565 break;
7566 case IPW_TX_RATE_2MB:
7567 ipw_rt->rt_rate = 4;
7568 break;
7569 case IPW_TX_RATE_5MB:
7570 ipw_rt->rt_rate = 10;
7571 break;
7572 case IPW_TX_RATE_6MB:
7573 ipw_rt->rt_rate = 12;
7574 break;
7575 case IPW_TX_RATE_9MB:
7576 ipw_rt->rt_rate = 18;
7577 break;
7578 case IPW_TX_RATE_11MB:
7579 ipw_rt->rt_rate = 22;
7580 break;
7581 case IPW_TX_RATE_12MB:
7582 ipw_rt->rt_rate = 24;
7583 break;
7584 case IPW_TX_RATE_18MB:
7585 ipw_rt->rt_rate = 36;
7586 break;
7587 case IPW_TX_RATE_24MB:
7588 ipw_rt->rt_rate = 48;
7589 break;
7590 case IPW_TX_RATE_36MB:
7591 ipw_rt->rt_rate = 72;
7592 break;
7593 case IPW_TX_RATE_48MB:
7594 ipw_rt->rt_rate = 96;
7595 break;
7596 case IPW_TX_RATE_54MB:
7597 ipw_rt->rt_rate = 108;
7598 break;
7599 default:
7600 ipw_rt->rt_rate = 0;
7601 break;
7602 }
7603
7604 /* antenna number */
7605 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7606
7607 /* set the preamble flag if we have it */
7608 if ((antennaAndPhy & 64))
7609 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7610
7611 /* Set the size of the skb to the size of the frame */
7612 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
43f66a6c
JK		 7613
7614 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7615
bf79451e 7616 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
43f66a6c 7617 priv->ieee->stats.rx_errors++;
24a47dbd
MK		 7618 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7619 rxb->skb = NULL;
7620 /* no LED during capture */
7621 }
7622}
7623#endif
7624
858119e1 7625static int is_network_packet(struct ipw_priv *priv,
ea2b26e0
JK		 7626 struct ieee80211_hdr_4addr *header)
7627{
7628 /* Filter incoming packets to determine if they are targetted toward
7629 * this network, discarding packets coming from ourselves */
7630 switch (priv->ieee->iw_mode) {
a613bffd 7631 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
c848d0af
JK		 7632 /* packets from our adapter are dropped (echo) */
7633 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7634 return 0;
7635
90700fd9 7636 /* {broad,multi}cast packets to our BSSID go through */
3c19065a 7637 if (is_multicast_ether_addr(header->addr1))
ea2b26e0 7638 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
a613bffd
JK		 7639
7640 /* packets to our adapter go through */
7641 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7642 ETH_ALEN);
a613bffd 7643
90700fd9 7644 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
c848d0af
JK		 7645 /* packets from our adapter are dropped (echo) */
7646 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7647 return 0;
7648
90700fd9 7649 /* {broad,multi}cast packets to our BSS go through */
3c19065a 7650 if (is_multicast_ether_addr(header->addr1))
a613bffd
JK		 7651 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7652
7653 /* packets to our adapter go through */
7654 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7655 ETH_ALEN);
ea2b26e0 7656 }
a613bffd 7657
ea2b26e0
JK		 7658 return 1;
7659}
7660
afbf30a2
JK		 7661#define IPW_PACKET_RETRY_TIME HZ
7662
858119e1 7663static int is_duplicate_packet(struct ipw_priv *priv,
afbf30a2
JK		 7664 struct ieee80211_hdr_4addr *header)
7665{
afbf30a2
JK		 7666 u16 sc = le16_to_cpu(header->seq_ctl);
7667 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7668 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7669 u16 *last_seq, *last_frag;
7670 unsigned long *last_time;
7671
7672 switch (priv->ieee->iw_mode) {
7673 case IW_MODE_ADHOC:
7674 {
7675 struct list_head *p;
7676 struct ipw_ibss_seq *entry = NULL;
7677 u8 *mac = header->addr2;
7678 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7679
7680 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7681 entry =
7682 list_entry(p, struct ipw_ibss_seq, list);
7683 if (!memcmp(entry->mac, mac, ETH_ALEN))
7684 break;
7685 }
7686 if (p == &priv->ibss_mac_hash[index]) {
7687 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7688 if (!entry) {
7689 IPW_ERROR
7690 ("Cannot malloc new mac entry\n");
7691 return 0;
7692 }
7693 memcpy(entry->mac, mac, ETH_ALEN);
7694 entry->seq_num = seq;
7695 entry->frag_num = frag;
7696 entry->packet_time = jiffies;
7697 list_add(&entry->list,
7698 &priv->ibss_mac_hash[index]);
7699 return 0;
7700 }
7701 last_seq = &entry->seq_num;
7702 last_frag = &entry->frag_num;
7703 last_time = &entry->packet_time;
7704 break;
7705 }
7706 case IW_MODE_INFRA:
7707 last_seq = &priv->last_seq_num;
7708 last_frag = &priv->last_frag_num;
7709 last_time = &priv->last_packet_time;
7710 break;
7711 default:
7712 return 0;
7713 }
7714 if ((*last_seq == seq) &&
7715 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7716 if (*last_frag == frag)
7717 goto drop;
7718 if (*last_frag + 1 != frag)
7719 /* out-of-order fragment */
7720 goto drop;
afbf30a2
JK		 7721 } else
7722 *last_seq = seq;
7723
f57ce7ce 7724 *last_frag = frag;
afbf30a2
JK		 7725 *last_time = jiffies;
7726 return 0;
7727
7728 drop:
87b016cb
ZY		 7729 /* Comment this line now since we observed the card receives
7730 * duplicate packets but the FCTL_RETRY bit is not set in the
7731 * IBSS mode with fragmentation enabled.
7732 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
afbf30a2
JK		 7733 return 1;
7734}
7735
b095c381
JK		 7736static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7737 struct ipw_rx_mem_buffer *rxb,
7738 struct ieee80211_rx_stats *stats)
7739{
7740 struct sk_buff *skb = rxb->skb;
7741 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7742 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7743 (skb->data + IPW_RX_FRAME_SIZE);
7744
7745 ieee80211_rx_mgt(priv->ieee, header, stats);
7746
7747 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7748 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7749 IEEE80211_STYPE_PROBE_RESP) ||
7750 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7751 IEEE80211_STYPE_BEACON))) {
7752 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7753 ipw_add_station(priv, header->addr2);
7754 }
7755
7756 if (priv->config & CFG_NET_STATS) {
7757 IPW_DEBUG_HC("sending stat packet\n");
7758
7759 /* Set the size of the skb to the size of the full
7760 * ipw header and 802.11 frame */
7761 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7762 IPW_RX_FRAME_SIZE);
7763
7764 /* Advance past the ipw packet header to the 802.11 frame */
7765 skb_pull(skb, IPW_RX_FRAME_SIZE);
7766
7767 /* Push the ieee80211_rx_stats before the 802.11 frame */
7768 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7769
7770 skb->dev = priv->ieee->dev;
7771
7772 /* Point raw at the ieee80211_stats */
7773 skb->mac.raw = skb->data;
7774
7775 skb->pkt_type = PACKET_OTHERHOST;
7776 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7777 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7778 netif_rx(skb);
43f66a6c 7779 rxb->skb = NULL;
b095c381 7780 }
43f66a6c
JK		 7781}
7782
43f66a6c
JK		 7783/*
7784 * Main entry function for recieving a packet with 80211 headers. This
7785 * should be called when ever the FW has notified us that there is a new
7786 * skb in the recieve queue.
7787 */
7788static void ipw_rx(struct ipw_priv *priv)
7789{
7790 struct ipw_rx_mem_buffer *rxb;
7791 struct ipw_rx_packet *pkt;
0dacca1f 7792 struct ieee80211_hdr_4addr *header;
43f66a6c
JK		 7793 u32 r, w, i;
7794 u8 network_packet;
7795
b095c381
JK		 7796 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7797 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
43f66a6c
JK		 7798 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7799
7800 while (i != r) {
7801 rxb = priv->rxq->queue[i];
43f66a6c
JK		 7802 if (unlikely(rxb == NULL)) {
7803 printk(KERN_CRIT "Queue not allocated!\n");
7804 break;
7805 }
43f66a6c
JK		 7806 priv->rxq->queue[i] = NULL;
7807
7808 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
b095c381 7809 IPW_RX_BUF_SIZE,
43f66a6c
JK		 7810 PCI_DMA_FROMDEVICE);
7811
7812 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7813 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7814 pkt->header.message_type,
0edd5b44 7815 pkt->header.rx_seq_num, pkt->header.control_bits);
43f66a6c
JK		 7816
7817 switch (pkt->header.message_type) {
0edd5b44
JG		 7818 case RX_FRAME_TYPE: /* 802.11 frame */ {
7819 struct ieee80211_rx_stats stats = {
c848d0af
JK		 7820 .rssi =
7821 le16_to_cpu(pkt->u.frame.rssi_dbm) -
0edd5b44 7822 IPW_RSSI_TO_DBM,
c848d0af 7823 .signal =
b191608a
BM		 7824 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7825 IPW_RSSI_TO_DBM + 0x100,
c848d0af
JK		 7826 .noise =
7827 le16_to_cpu(pkt->u.frame.noise),
0edd5b44
JG		 7828 .rate = pkt->u.frame.rate,
7829 .mac_time = jiffies,
7830 .received_channel =
7831 pkt->u.frame.received_channel,
7832 .freq =
7833 (pkt->u.frame.
7834 control & (1 << 0)) ?
7835 IEEE80211_24GHZ_BAND :
7836 IEEE80211_52GHZ_BAND,
a613bffd 7837 .len = le16_to_cpu(pkt->u.frame.length),
0edd5b44
JG		 7838 };
7839
7840 if (stats.rssi != 0)
7841 stats.mask |= IEEE80211_STATMASK_RSSI;
7842 if (stats.signal != 0)
7843 stats.mask |= IEEE80211_STATMASK_SIGNAL;
c848d0af
JK		 7844 if (stats.noise != 0)
7845 stats.mask |= IEEE80211_STATMASK_NOISE;
0edd5b44
JG		 7846 if (stats.rate != 0)
7847 stats.mask |= IEEE80211_STATMASK_RATE;
7848
7849 priv->rx_packets++;
43f66a6c 7850
b095c381 7851#ifdef CONFIG_IPW2200_MONITOR
0edd5b44 7852 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
24a47dbd
MK		 7853#ifdef CONFIG_IEEE80211_RADIOTAP
7854 ipw_handle_data_packet_monitor(priv,
7855 rxb,
7856 &stats);
7857#else
0edd5b44
JG		 7858 ipw_handle_data_packet(priv, rxb,
7859 &stats);
24a47dbd 7860#endif
0edd5b44
JG		 7861 break;
7862 }
43f66a6c 7863#endif
bf79451e 7864
0edd5b44 7865 header =
0dacca1f
JK		 7866 (struct ieee80211_hdr_4addr *)(rxb->skb->
7867 data +
7868 IPW_RX_FRAME_SIZE);
43f66a6c
JK		 7869 /* TODO: Check Ad-Hoc dest/source and make sure
7870 * that we are actually parsing these packets
bf79451e 7871 * correctly -- we should probably use the
43f66a6c
JK		 7872 * frame control of the packet and disregard
7873 * the current iw_mode */
0edd5b44 7874
ea2b26e0
JK		 7875 network_packet =
7876 is_network_packet(priv, header);
0edd5b44
JG		 7877 if (network_packet && priv->assoc_network) {
7878 priv->assoc_network->stats.rssi =
7879 stats.rssi;
7880 average_add(&priv->average_rssi,
7881 stats.rssi);
7882 priv->last_rx_rssi = stats.rssi;
7883 }
7884
7885 IPW_DEBUG_RX("Frame: len=%u\n",
a613bffd 7886 le16_to_cpu(pkt->u.frame.length));
0edd5b44 7887
a613bffd 7888 if (le16_to_cpu(pkt->u.frame.length) <
9d0be03a
ZY		 7889 ieee80211_get_hdrlen(le16_to_cpu(
7890 header->frame_ctl))) {
0edd5b44
JG		 7891 IPW_DEBUG_DROP
7892 ("Received packet is too small. "
7893 "Dropping.\n");
7894 priv->ieee->stats.rx_errors++;
7895 priv->wstats.discard.misc++;
7896 break;
7897 }
7898
a613bffd
JK		 7899 switch (WLAN_FC_GET_TYPE
7900 (le16_to_cpu(header->frame_ctl))) {
b095c381 7901
0edd5b44 7902 case IEEE80211_FTYPE_MGMT:
b095c381
JK		 7903 ipw_handle_mgmt_packet(priv, rxb,
7904 &stats);
0edd5b44
JG		 7905 break;
7906
7907 case IEEE80211_FTYPE_CTL:
7908 break;
7909
7910 case IEEE80211_FTYPE_DATA:
afbf30a2
JK		 7911 if (unlikely(!network_packet ||
7912 is_duplicate_packet(priv,
7913 header)))
7914 {
0edd5b44
JG		 7915 IPW_DEBUG_DROP("Dropping: "
7916 MAC_FMT ", "
7917 MAC_FMT ", "
7918 MAC_FMT "\n",
7919 MAC_ARG(header->
7920 addr1),
7921 MAC_ARG(header->
7922 addr2),
7923 MAC_ARG(header->
7924 addr3));
b095c381
JK		 7925 break;
7926 }
7927
7928 ipw_handle_data_packet(priv, rxb,
7929 &stats);
7930
0edd5b44
JG		 7931 break;
7932 }
43f66a6c
JK		 7933 break;
7934 }
bf79451e 7935
0edd5b44
JG		 7936 case RX_HOST_NOTIFICATION_TYPE:{
7937 IPW_DEBUG_RX
7938 ("Notification: subtype=%02X flags=%02X size=%d\n",
43f66a6c
JK		 7939 pkt->u.notification.subtype,
7940 pkt->u.notification.flags,
7941 pkt->u.notification.size);
0edd5b44
JG		 7942 ipw_rx_notification(priv, &pkt->u.notification);
7943 break;
7944 }
43f66a6c
JK		 7945
7946 default:
7947 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7948 pkt->header.message_type);
7949 break;
7950 }
bf79451e
JG		 7951
7952 /* For now we just don't re-use anything. We can tweak this
7953 * later to try and re-use notification packets and SKBs that
43f66a6c
JK		 7954 * fail to Rx correctly */
7955 if (rxb->skb != NULL) {
7956 dev_kfree_skb_any(rxb->skb);
7957 rxb->skb = NULL;
7958 }
bf79451e 7959
43f66a6c 7960 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
b095c381 7961 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 7962 list_add_tail(&rxb->list, &priv->rxq->rx_used);
bf79451e 7963
43f66a6c
JK		 7964 i = (i + 1) % RX_QUEUE_SIZE;
7965 }
7966
7967 /* Backtrack one entry */
7968 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7969
7970 ipw_rx_queue_restock(priv);
7971}
7972
afbf30a2
JK		 7973#define DEFAULT_RTS_THRESHOLD 2304U
7974#define MIN_RTS_THRESHOLD 1U
7975#define MAX_RTS_THRESHOLD 2304U
7976#define DEFAULT_BEACON_INTERVAL 100U
7977#define DEFAULT_SHORT_RETRY_LIMIT 7U
7978#define DEFAULT_LONG_RETRY_LIMIT 4U
7979
d6d5b5c1
ZY		 7980/**
7981 * ipw_sw_reset
7982 * @option: options to control different reset behaviour
7983 * 0 = reset everything except the 'disable' module_param
7984 * 1 = reset everything and print out driver info (for probe only)
7985 * 2 = reset everything
7986 */
7987static int ipw_sw_reset(struct ipw_priv *priv, int option)
43f66a6c 7988{
afbf30a2
JK		 7989 int band, modulation;
7990 int old_mode = priv->ieee->iw_mode;
43f66a6c 7991
afbf30a2
JK		 7992 /* Initialize module parameter values here */
7993 priv->config = 0;
43f66a6c 7994
afbf30a2
JK		 7995 /* We default to disabling the LED code as right now it causes
7996 * too many systems to lock up... */
7997 if (!led)
7998 priv->config |= CFG_NO_LED;
43f66a6c 7999
afbf30a2
JK		 8000 if (associate)
8001 priv->config |= CFG_ASSOCIATE;
8002 else
8003 IPW_DEBUG_INFO("Auto associate disabled.\n");
bf79451e 8004
afbf30a2
JK		 8005 if (auto_create)
8006 priv->config |= CFG_ADHOC_CREATE;
8007 else
8008 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
43f66a6c 8009
17ed081d
ZY		 8010 priv->config &= ~CFG_STATIC_ESSID;
8011 priv->essid_len = 0;
8012 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8013
d6d5b5c1 8014 if (disable && option) {
afbf30a2
JK		 8015 priv->status |= STATUS_RF_KILL_SW;
8016 IPW_DEBUG_INFO("Radio disabled.\n");
43f66a6c 8017 }
bf79451e 8018
afbf30a2
JK		 8019 if (channel != 0) {
8020 priv->config |= CFG_STATIC_CHANNEL;
8021 priv->channel = channel;
8022 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8023 /* TODO: Validate that provided channel is in range */
43f66a6c 8024 }
afbf30a2
JK		 8025#ifdef CONFIG_IPW_QOS
8026 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8027 burst_duration_CCK, burst_duration_OFDM);
8028#endif /* CONFIG_IPW_QOS */
43f66a6c 8029
afbf30a2
JK		 8030 switch (mode) {
8031 case 1:
8032 priv->ieee->iw_mode = IW_MODE_ADHOC;
8033 priv->net_dev->type = ARPHRD_ETHER;
8034
8035 break;
8036#ifdef CONFIG_IPW2200_MONITOR
8037 case 2:
8038 priv->ieee->iw_mode = IW_MODE_MONITOR;
24a47dbd
MK		 8039#ifdef CONFIG_IEEE80211_RADIOTAP
8040 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8041#else
afbf30a2 8042 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8043#endif
afbf30a2
JK		 8044 break;
8045#endif
8046 default:
8047 case 0:
8048 priv->net_dev->type = ARPHRD_ETHER;
8049 priv->ieee->iw_mode = IW_MODE_INFRA;
8050 break;
43f66a6c
JK		 8051 }
8052
afbf30a2
JK		 8053 if (hwcrypto) {
8054 priv->ieee->host_encrypt = 0;
8055 priv->ieee->host_encrypt_msdu = 0;
8056 priv->ieee->host_decrypt = 0;
567deaf6 8057 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 8058 }
8059 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
43f66a6c 8060
e402c937
ZY		 8061 /* IPW2200/2915 is abled to do hardware fragmentation. */
8062 priv->ieee->host_open_frag = 0;
bf79451e 8063
afbf30a2
JK		 8064 if ((priv->pci_dev->device == 0x4223) ||
8065 (priv->pci_dev->device == 0x4224)) {
e8c69e27 8066 if (option == 1)
afbf30a2
JK		 8067 printk(KERN_INFO DRV_NAME
8068 ": Detected Intel PRO/Wireless 2915ABG Network "
8069 "Connection\n");
8070 priv->ieee->abg_true = 1;
8071 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8072 modulation = IEEE80211_OFDM_MODULATION |
8073 IEEE80211_CCK_MODULATION;
8074 priv->adapter = IPW_2915ABG;
8075 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
43f66a6c 8076 } else {
e8c69e27 8077 if (option == 1)
afbf30a2
JK		 8078 printk(KERN_INFO DRV_NAME
8079 ": Detected Intel PRO/Wireless 2200BG Network "
8080 "Connection\n");
bf79451e 8081
afbf30a2
JK		 8082 priv->ieee->abg_true = 0;
8083 band = IEEE80211_24GHZ_BAND;
8084 modulation = IEEE80211_OFDM_MODULATION |
8085 IEEE80211_CCK_MODULATION;
8086 priv->adapter = IPW_2200BG;
8087 priv->ieee->mode = IEEE_G | IEEE_B;
43f66a6c
JK		 8088 }
8089
afbf30a2
JK		 8090 priv->ieee->freq_band = band;
8091 priv->ieee->modulation = modulation;
43f66a6c 8092
afbf30a2 8093 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
bf79451e 8094
afbf30a2
JK		 8095 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8096 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
43f66a6c 8097
afbf30a2
JK		 8098 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8099 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8100 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
43f66a6c 8101
afbf30a2
JK		 8102 /* If power management is turned on, default to AC mode */
8103 priv->power_mode = IPW_POWER_AC;
8104 priv->tx_power = IPW_TX_POWER_DEFAULT;
8105
0ece35b5 8106 return old_mode == priv->ieee->iw_mode;
43f66a6c
JK		 8107}
8108
8109/*
8110 * This file defines the Wireless Extension handlers. It does not
8111 * define any methods of hardware manipulation and relies on the
8112 * functions defined in ipw_main to provide the HW interaction.
bf79451e
JG		 8113 *
8114 * The exception to this is the use of the ipw_get_ordinal()
43f66a6c
JK		 8115 * function used to poll the hardware vs. making unecessary calls.
8116 *
8117 */
8118
bf79451e
JG		 8119static int ipw_wx_get_name(struct net_device *dev,
8120 struct iw_request_info *info,
43f66a6c
JK		 8121 union iwreq_data *wrqu, char *extra)
8122{
8123 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 8124 mutex_lock(&priv->mutex);
c848d0af 8125 if (priv->status & STATUS_RF_KILL_MASK)
a613bffd 8126 strcpy(wrqu->name, "radio off");
c848d0af 8127 else if (!(priv->status & STATUS_ASSOCIATED))
43f66a6c 8128 strcpy(wrqu->name, "unassociated");
bf79451e 8129 else
43f66a6c
JK		 8130 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8131 ipw_modes[priv->assoc_request.ieee_mode]);
8132 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
4644151b 8133 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8134 return 0;
8135}
8136
8137static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8138{
8139 if (channel == 0) {
8140 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8141 priv->config &= ~CFG_STATIC_CHANNEL;
c848d0af
JK		 8142 IPW_DEBUG_ASSOC("Attempting to associate with new "
8143 "parameters.\n");
8144 ipw_associate(priv);
43f66a6c
JK		 8145 return 0;
8146 }
8147
8148 priv->config |= CFG_STATIC_CHANNEL;
8149
8150 if (priv->channel == channel) {
0edd5b44
JG		 8151 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8152 channel);
43f66a6c
JK		 8153 return 0;
8154 }
8155
8156 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8157 priv->channel = channel;
8158
b095c381
JK		 8159#ifdef CONFIG_IPW2200_MONITOR
8160 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 8161 int i;
b095c381 8162 if (priv->status & STATUS_SCANNING) {
afbf30a2 8163 IPW_DEBUG_SCAN("Scan abort triggered due to "
b095c381 8164 "channel change.\n");
afbf30a2 8165 ipw_abort_scan(priv);
b095c381
JK		 8166 }
8167
8168 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8169 udelay(10);
8170
8171 if (priv->status & STATUS_SCANNING)
8172 IPW_DEBUG_SCAN("Still scanning...\n");
8173 else
8174 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8175 1000 - i);
8176
8177 return 0;
43f66a6c 8178 }
b095c381
JK		 8179#endif /* CONFIG_IPW2200_MONITOR */
8180
c848d0af
JK		 8181 /* Network configuration changed -- force [re]association */
8182 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8183 if (!ipw_disassociate(priv))
43f66a6c 8184 ipw_associate(priv);
43f66a6c
JK		 8185
8186 return 0;
8187}
8188
bf79451e
JG		 8189static int ipw_wx_set_freq(struct net_device *dev,
8190 struct iw_request_info *info,
8191 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 8192{
8193 struct ipw_priv *priv = ieee80211_priv(dev);
1867b117 8194 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
43f66a6c 8195 struct iw_freq *fwrq = &wrqu->freq;
afbf30a2 8196 int ret = 0, i;
1fe0adb4
LH		 8197 u8 channel, flags;
8198 int band;
b095c381
JK		 8199
8200 if (fwrq->m == 0) {
8201 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
4644151b 8202 mutex_lock(&priv->mutex);
b095c381 8203 ret = ipw_set_channel(priv, 0);
4644151b 8204 mutex_unlock(&priv->mutex);
b095c381
JK		 8205 return ret;
8206 }
43f66a6c
JK		 8207 /* if setting by freq convert to channel */
8208 if (fwrq->e == 1) {
1867b117 8209 channel = ieee80211_freq_to_channel(priv->ieee, fwrq->m);
b095c381
JK		 8210 if (channel == 0)
8211 return -EINVAL;
8212 } else
8213 channel = fwrq->m;
bf79451e 8214
1867b117 8215 if (!(band = ieee80211_is_valid_channel(priv->ieee, channel)))
b095c381 8216 return -EINVAL;
43f66a6c 8217
1fe0adb4 8218 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
1867b117 8219 i = ieee80211_channel_to_index(priv->ieee, channel);
afbf30a2
JK		 8220 if (i == -1)
8221 return -EINVAL;
bf79451e 8222
1fe0adb4
LH		 8223 flags = (band == IEEE80211_24GHZ_BAND) ?
8224 geo->bg[i].flags : geo->a[i].flags;
8225 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
afbf30a2
JK		 8226 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8227 return -EINVAL;
43f66a6c
JK		 8228 }
8229 }
bf79451e 8230
43f66a6c 8231 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
4644151b 8232 mutex_lock(&priv->mutex);
b095c381 8233 ret = ipw_set_channel(priv, channel);
4644151b 8234 mutex_unlock(&priv->mutex);
c848d0af 8235 return ret;
43f66a6c
JK		 8236}
8237
bf79451e
JG		 8238static int ipw_wx_get_freq(struct net_device *dev,
8239 struct iw_request_info *info,
43f66a6c
JK		 8240 union iwreq_data *wrqu, char *extra)
8241{
8242 struct ipw_priv *priv = ieee80211_priv(dev);
8243
8244 wrqu->freq.e = 0;
8245
8246 /* If we are associated, trying to associate, or have a statically
8247 * configured CHANNEL then return that; otherwise return ANY */
4644151b 8248 mutex_lock(&priv->mutex);
43f66a6c
JK		 8249 if (priv->config & CFG_STATIC_CHANNEL ||
8250 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8251 wrqu->freq.m = priv->channel;
bf79451e 8252 else
43f66a6c
JK		 8253 wrqu->freq.m = 0;
8254
4644151b 8255 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8256 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8257 return 0;
8258}
8259
bf79451e
JG		 8260static int ipw_wx_set_mode(struct net_device *dev,
8261 struct iw_request_info *info,
43f66a6c
JK		 8262 union iwreq_data *wrqu, char *extra)
8263{
8264 struct ipw_priv *priv = ieee80211_priv(dev);
8265 int err = 0;
8266
8267 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8268
43f66a6c 8269 switch (wrqu->mode) {
b095c381 8270#ifdef CONFIG_IPW2200_MONITOR
43f66a6c
JK		 8271 case IW_MODE_MONITOR:
8272#endif
8273 case IW_MODE_ADHOC:
8274 case IW_MODE_INFRA:
8275 break;
8276 case IW_MODE_AUTO:
8277 wrqu->mode = IW_MODE_INFRA;
8278 break;
8279 default:
8280 return -EINVAL;
8281 }
b095c381
JK		 8282 if (wrqu->mode == priv->ieee->iw_mode)
8283 return 0;
43f66a6c 8284
4644151b 8285 mutex_lock(&priv->mutex);
43f66a6c 8286
afbf30a2
JK		 8287 ipw_sw_reset(priv, 0);
8288
b095c381 8289#ifdef CONFIG_IPW2200_MONITOR
bf79451e 8290 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
43f66a6c 8291 priv->net_dev->type = ARPHRD_ETHER;
bf79451e
JG		 8292
8293 if (wrqu->mode == IW_MODE_MONITOR)
24a47dbd
MK		 8294#ifdef CONFIG_IEEE80211_RADIOTAP
8295 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8296#else
43f66a6c 8297 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8298#endif
b095c381 8299#endif /* CONFIG_IPW2200_MONITOR */
bf79451e 8300
bf79451e 8301 /* Free the existing firmware and reset the fw_loaded
43f66a6c 8302 * flag so ipw_load() will bring in the new firmawre */
afbf30a2 8303 free_firmware();
43f66a6c
JK		 8304
8305 priv->ieee->iw_mode = wrqu->mode;
bf79451e 8306
c848d0af 8307 queue_work(priv->workqueue, &priv->adapter_restart);
4644151b 8308 mutex_unlock(&priv->mutex);
0edd5b44 8309 return err;
43f66a6c
JK		 8310}
8311
bf79451e 8312static int ipw_wx_get_mode(struct net_device *dev,
0edd5b44
JG		 8313 struct iw_request_info *info,
8314 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 8315{
8316 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 8317 mutex_lock(&priv->mutex);
43f66a6c
JK		 8318 wrqu->mode = priv->ieee->iw_mode;
8319 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
4644151b 8320 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8321 return 0;
8322}
8323
43f66a6c
JK		 8324/* Values are in microsecond */
8325static const s32 timeout_duration[] = {
8326 350000,
8327 250000,
8328 75000,
8329 37000,
8330 25000,
8331};
8332
8333static const s32 period_duration[] = {
8334 400000,
8335 700000,
8336 1000000,
8337 1000000,
8338 1000000
8339};
8340
bf79451e
JG		 8341static int ipw_wx_get_range(struct net_device *dev,
8342 struct iw_request_info *info,
43f66a6c
JK		 8343 union iwreq_data *wrqu, char *extra)
8344{
8345 struct ipw_priv *priv = ieee80211_priv(dev);
8346 struct iw_range *range = (struct iw_range *)extra;
1867b117 8347 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
b095c381 8348 int i = 0, j;
43f66a6c
JK		 8349
8350 wrqu->data.length = sizeof(*range);
8351 memset(range, 0, sizeof(*range));
8352
8353 /* 54Mbs == ~27 Mb/s real (802.11g) */
bf79451e 8354 range->throughput = 27 * 1000 * 1000;
43f66a6c
JK		 8355
8356 range->max_qual.qual = 100;
8357 /* TODO: Find real max RSSI and stick here */
8358 range->max_qual.level = 0;
b191608a 8359 range->max_qual.noise = 0;
0edd5b44 8360 range->max_qual.updated = 7; /* Updated all three */
43f66a6c
JK		 8361
8362 range->avg_qual.qual = 70;
8363 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
0edd5b44 8364 range->avg_qual.level = 0; /* FIXME to real average level */
43f66a6c 8365 range->avg_qual.noise = 0;
0edd5b44 8366 range->avg_qual.updated = 7; /* Updated all three */
4644151b 8367 mutex_lock(&priv->mutex);
0edd5b44 8368 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
43f66a6c 8369
bf79451e
JG		 8370 for (i = 0; i < range->num_bitrates; i++)
8371 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
0edd5b44 8372 500000;
bf79451e 8373
43f66a6c
JK		 8374 range->max_rts = DEFAULT_RTS_THRESHOLD;
8375 range->min_frag = MIN_FRAG_THRESHOLD;
8376 range->max_frag = MAX_FRAG_THRESHOLD;
8377
8378 range->encoding_size[0] = 5;
bf79451e 8379 range->encoding_size[1] = 13;
43f66a6c
JK		 8380 range->num_encoding_sizes = 2;
8381 range->max_encoding_tokens = WEP_KEYS;
8382
8383 /* Set the Wireless Extension versions */
8384 range->we_version_compiled = WIRELESS_EXT;
f1b50863 8385 range->we_version_source = 18;
43f66a6c 8386
b095c381
JK		 8387 i = 0;
8388 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
e815de42
ZY		 8389 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8390 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8391 (geo->bg[j].flags & IEEE80211_CH_PASSIVE_ONLY))
8392 continue;
8393
b095c381
JK		 8394 range->freq[i].i = geo->bg[j].channel;
8395 range->freq[i].m = geo->bg[j].freq * 100000;
8396 range->freq[i].e = 1;
e815de42 8397 i++;
b095c381
JK		 8398 }
8399 }
43f66a6c 8400
b095c381 8401 if (priv->ieee->mode & IEEE_A) {
e815de42
ZY		 8402 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8403 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8404 (geo->a[j].flags & IEEE80211_CH_PASSIVE_ONLY))
8405 continue;
8406
b095c381
JK		 8407 range->freq[i].i = geo->a[j].channel;
8408 range->freq[i].m = geo->a[j].freq * 100000;
8409 range->freq[i].e = 1;
e815de42 8410 i++;
b095c381 8411 }
43f66a6c 8412 }
b095c381
JK		 8413
8414 range->num_channels = i;
8415 range->num_frequency = i;
8416
4644151b 8417 mutex_unlock(&priv->mutex);
97a78ca9
BB		 8418
8419 /* Event capability (kernel + driver) */
8420 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8421 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8422 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8423 range->event_capa[1] = IW_EVENT_CAPA_K_1;
43f66a6c 8424
f1b50863
DW		 8425 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8426 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8427
43f66a6c
JK		 8428 IPW_DEBUG_WX("GET Range\n");
8429 return 0;
8430}
8431
bf79451e
JG		 8432static int ipw_wx_set_wap(struct net_device *dev,
8433 struct iw_request_info *info,
43f66a6c
JK		 8434 union iwreq_data *wrqu, char *extra)
8435{
8436 struct ipw_priv *priv = ieee80211_priv(dev);
8437
8438 static const unsigned char any[] = {
8439 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8440 };
8441 static const unsigned char off[] = {
8442 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8443 };
8444
bf79451e 8445 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
43f66a6c 8446 return -EINVAL;
4644151b 8447 mutex_lock(&priv->mutex);
43f66a6c
JK		 8448 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8449 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8450 /* we disable mandatory BSSID association */
8451 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8452 priv->config &= ~CFG_STATIC_BSSID;
c848d0af
JK		 8453 IPW_DEBUG_ASSOC("Attempting to associate with new "
8454 "parameters.\n");
8455 ipw_associate(priv);
4644151b 8456 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8457 return 0;
8458 }
8459
8460 priv->config |= CFG_STATIC_BSSID;
8461 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8462 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
4644151b 8463 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8464 return 0;
8465 }
8466
8467 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8468 MAC_ARG(wrqu->ap_addr.sa_data));
8469
8470 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8471
c848d0af
JK		 8472 /* Network configuration changed -- force [re]association */
8473 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8474 if (!ipw_disassociate(priv))
43f66a6c 8475 ipw_associate(priv);
43f66a6c 8476
4644151b 8477 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8478 return 0;
8479}
8480
bf79451e
JG		 8481static int ipw_wx_get_wap(struct net_device *dev,
8482 struct iw_request_info *info,
43f66a6c
JK		 8483 union iwreq_data *wrqu, char *extra)
8484{
8485 struct ipw_priv *priv = ieee80211_priv(dev);
8486 /* If we are associated, trying to associate, or have a statically
8487 * configured BSSID then return that; otherwise return ANY */
4644151b 8488 mutex_lock(&priv->mutex);
bf79451e 8489 if (priv->config & CFG_STATIC_BSSID ||
43f66a6c
JK		 8490 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8491 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
afbf30a2 8492 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
43f66a6c
JK		 8493 } else
8494 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8495
8496 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8497 MAC_ARG(wrqu->ap_addr.sa_data));
4644151b 8498 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8499 return 0;
8500}
8501
bf79451e
JG		 8502static int ipw_wx_set_essid(struct net_device *dev,
8503 struct iw_request_info *info,
43f66a6c
JK		 8504 union iwreq_data *wrqu, char *extra)
8505{
8506 struct ipw_priv *priv = ieee80211_priv(dev);
0edd5b44 8507 char *essid = ""; /* ANY */
43f66a6c 8508 int length = 0;
4644151b 8509 mutex_lock(&priv->mutex);
43f66a6c
JK		 8510 if (wrqu->essid.flags && wrqu->essid.length) {
8511 length = wrqu->essid.length - 1;
8512 essid = extra;
8513 }
8514 if (length == 0) {
8515 IPW_DEBUG_WX("Setting ESSID to ANY\n");
afbf30a2
JK		 8516 if ((priv->config & CFG_STATIC_ESSID) &&
8517 !(priv->status & (STATUS_ASSOCIATED |
43f66a6c
JK		 8518 STATUS_ASSOCIATING))) {
8519 IPW_DEBUG_ASSOC("Attempting to associate with new "
8520 "parameters.\n");
afbf30a2 8521 priv->config &= ~CFG_STATIC_ESSID;
43f66a6c
JK		 8522 ipw_associate(priv);
8523 }
4644151b 8524 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8525 return 0;
8526 }
8527
8528 length = min(length, IW_ESSID_MAX_SIZE);
8529
8530 priv->config |= CFG_STATIC_ESSID;
8531
8532 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8533 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
4644151b 8534 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8535 return 0;
8536 }
8537
8538 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8539 length);
8540
8541 priv->essid_len = length;
8542 memcpy(priv->essid, essid, priv->essid_len);
bf79451e 8543
c848d0af
JK		 8544 /* Network configuration changed -- force [re]association */
8545 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8546 if (!ipw_disassociate(priv))
43f66a6c 8547 ipw_associate(priv);
43f66a6c 8548
4644151b 8549 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8550 return 0;
8551}
8552
bf79451e
JG		 8553static int ipw_wx_get_essid(struct net_device *dev,
8554 struct iw_request_info *info,
43f66a6c
JK		 8555 union iwreq_data *wrqu, char *extra)
8556{
8557 struct ipw_priv *priv = ieee80211_priv(dev);
8558
8559 /* If we are associated, trying to associate, or have a statically
8560 * configured ESSID then return that; otherwise return ANY */
4644151b 8561 mutex_lock(&priv->mutex);
43f66a6c 8562 if (priv->config & CFG_STATIC_ESSID ||
bf79451e
JG		 8563 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8564 IPW_DEBUG_WX("Getting essid: '%s'\n",
43f66a6c 8565 escape_essid(priv->essid, priv->essid_len));
bf79451e 8566 memcpy(extra, priv->essid, priv->essid_len);
43f66a6c 8567 wrqu->essid.length = priv->essid_len;
0edd5b44 8568 wrqu->essid.flags = 1; /* active */
43f66a6c
JK		 8569 } else {
8570 IPW_DEBUG_WX("Getting essid: ANY\n");
8571 wrqu->essid.length = 0;
0edd5b44 8572 wrqu->essid.flags = 0; /* active */
43f66a6c 8573 }
4644151b 8574 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8575 return 0;
8576}
8577
bf79451e
JG		 8578static int ipw_wx_set_nick(struct net_device *dev,
8579 struct iw_request_info *info,
43f66a6c 8580 union iwreq_data *wrqu, char *extra)
bf79451e 8581{
43f66a6c
JK		 8582 struct ipw_priv *priv = ieee80211_priv(dev);
8583
8584 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8585 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8586 return -E2BIG;
4644151b 8587 mutex_lock(&priv->mutex);
0edd5b44 8588 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
43f66a6c 8589 memset(priv->nick, 0, sizeof(priv->nick));
0edd5b44 8590 memcpy(priv->nick, extra, wrqu->data.length);
43f66a6c 8591 IPW_DEBUG_TRACE("<<\n");
4644151b 8592 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8593 return 0;
8594
8595}
8596
bf79451e
JG		 8597static int ipw_wx_get_nick(struct net_device *dev,
8598 struct iw_request_info *info,
43f66a6c 8599 union iwreq_data *wrqu, char *extra)
bf79451e 8600{
43f66a6c
JK		 8601 struct ipw_priv *priv = ieee80211_priv(dev);
8602 IPW_DEBUG_WX("Getting nick\n");
4644151b 8603 mutex_lock(&priv->mutex);
43f66a6c
JK		 8604 wrqu->data.length = strlen(priv->nick) + 1;
8605 memcpy(extra, priv->nick, wrqu->data.length);
0edd5b44 8606 wrqu->data.flags = 1; /* active */
4644151b 8607 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8608 return 0;
8609}
8610
651be26f
OH		 8611static int ipw_wx_set_sens(struct net_device *dev,
8612 struct iw_request_info *info,
8613 union iwreq_data *wrqu, char *extra)
8614{
8615 struct ipw_priv *priv = ieee80211_priv(dev);
8616 int err = 0;
8617
8618 IPW_DEBUG_WX("Setting roaming threshold to %d\n", wrqu->sens.value);
8619 IPW_DEBUG_WX("Setting disassociate threshold to %d\n", 3*wrqu->sens.value);
8620 mutex_lock(&priv->mutex);
8621
8622 if (wrqu->sens.fixed == 0)
8623 {
8624 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8625 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8626 goto out;
8627 }
8628 if ((wrqu->sens.value > IPW_MB_ROAMING_THRESHOLD_MAX) ||
8629 (wrqu->sens.value < IPW_MB_ROAMING_THRESHOLD_MIN)) {
8630 err = -EINVAL;
8631 goto out;
8632 }
8633
8634 priv->roaming_threshold = wrqu->sens.value;
8635 priv->disassociate_threshold = 3*wrqu->sens.value;
8636 out:
8637 mutex_unlock(&priv->mutex);
8638 return err;
8639}
8640
8641static int ipw_wx_get_sens(struct net_device *dev,
8642 struct iw_request_info *info,
8643 union iwreq_data *wrqu, char *extra)
8644{
8645 struct ipw_priv *priv = ieee80211_priv(dev);
8646 mutex_lock(&priv->mutex);
8647 wrqu->sens.fixed = 1;
8648 wrqu->sens.value = priv->roaming_threshold;
8649 mutex_unlock(&priv->mutex);
8650
8651 IPW_DEBUG_WX("GET roaming threshold -> %s %d \n",
8652 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
8653
8654 return 0;
8655}
8656
43f66a6c
JK		 8657static int ipw_wx_set_rate(struct net_device *dev,
8658 struct iw_request_info *info,
8659 union iwreq_data *wrqu, char *extra)
bf79451e 8660{
ea2b26e0
JK		 8661 /* TODO: We should use semaphores or locks for access to priv */
8662 struct ipw_priv *priv = ieee80211_priv(dev);
8663 u32 target_rate = wrqu->bitrate.value;
8664 u32 fixed, mask;
8665
8666 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8667 /* value = X, fixed = 1 means only rate X */
8668 /* value = X, fixed = 0 means all rates lower equal X */
8669
8670 if (target_rate == -1) {
8671 fixed = 0;
8672 mask = IEEE80211_DEFAULT_RATES_MASK;
8673 /* Now we should reassociate */
8674 goto apply;
8675 }
8676
8677 mask = 0;
8678 fixed = wrqu->bitrate.fixed;
8679
8680 if (target_rate == 1000000 || !fixed)
8681 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8682 if (target_rate == 1000000)
8683 goto apply;
8684
8685 if (target_rate == 2000000 || !fixed)
8686 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8687 if (target_rate == 2000000)
8688 goto apply;
8689
8690 if (target_rate == 5500000 || !fixed)
8691 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8692 if (target_rate == 5500000)
8693 goto apply;
8694
8695 if (target_rate == 6000000 || !fixed)
8696 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8697 if (target_rate == 6000000)
8698 goto apply;
8699
8700 if (target_rate == 9000000 || !fixed)
8701 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8702 if (target_rate == 9000000)
8703 goto apply;
8704
8705 if (target_rate == 11000000 || !fixed)
8706 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8707 if (target_rate == 11000000)
8708 goto apply;
8709
8710 if (target_rate == 12000000 || !fixed)
8711 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8712 if (target_rate == 12000000)
8713 goto apply;
8714
8715 if (target_rate == 18000000 || !fixed)
8716 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8717 if (target_rate == 18000000)
8718 goto apply;
8719
8720 if (target_rate == 24000000 || !fixed)
8721 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8722 if (target_rate == 24000000)
8723 goto apply;
8724
8725 if (target_rate == 36000000 || !fixed)
8726 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8727 if (target_rate == 36000000)
8728 goto apply;
8729
8730 if (target_rate == 48000000 || !fixed)
8731 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8732 if (target_rate == 48000000)
8733 goto apply;
8734
8735 if (target_rate == 54000000 || !fixed)
8736 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8737 if (target_rate == 54000000)
8738 goto apply;
8739
8740 IPW_DEBUG_WX("invalid rate specified, returning error\n");
8741 return -EINVAL;
8742
8743 apply:
8744 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8745 mask, fixed ? "fixed" : "sub-rates");
4644151b 8746 mutex_lock(&priv->mutex);
b095c381 8747 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
ea2b26e0 8748 priv->config &= ~CFG_FIXED_RATE;
b095c381
JK		 8749 ipw_set_fixed_rate(priv, priv->ieee->mode);
8750 } else
ea2b26e0
JK		 8751 priv->config |= CFG_FIXED_RATE;
8752
c848d0af
JK		 8753 if (priv->rates_mask == mask) {
8754 IPW_DEBUG_WX("Mask set to current mask.\n");
4644151b 8755 mutex_unlock(&priv->mutex);
c848d0af 8756 return 0;
ea2b26e0
JK		 8757 }
8758
c848d0af
JK		 8759 priv->rates_mask = mask;
8760
8761 /* Network configuration changed -- force [re]association */
8762 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8763 if (!ipw_disassociate(priv))
8764 ipw_associate(priv);
8765
4644151b 8766 mutex_unlock(&priv->mutex);
ea2b26e0 8767 return 0;
43f66a6c
JK		 8768}
8769
bf79451e
JG		 8770static int ipw_wx_get_rate(struct net_device *dev,
8771 struct iw_request_info *info,
43f66a6c 8772 union iwreq_data *wrqu, char *extra)
bf79451e 8773{
0edd5b44 8774 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 8775 mutex_lock(&priv->mutex);
43f66a6c 8776 wrqu->bitrate.value = priv->last_rate;
4644151b 8777 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8778 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8779 return 0;
8780}
8781
bf79451e
JG		 8782static int ipw_wx_set_rts(struct net_device *dev,
8783 struct iw_request_info *info,
43f66a6c 8784 union iwreq_data *wrqu, char *extra)
bf79451e 8785{
43f66a6c 8786 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 8787 mutex_lock(&priv->mutex);
43f66a6c
JK		 8788 if (wrqu->rts.disabled)
8789 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8790 else {
8791 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
c848d0af 8792 wrqu->rts.value > MAX_RTS_THRESHOLD) {
4644151b 8793 mutex_unlock(&priv->mutex);
43f66a6c 8794 return -EINVAL;
c848d0af 8795 }
43f66a6c
JK		 8796 priv->rts_threshold = wrqu->rts.value;
8797 }
8798
8799 ipw_send_rts_threshold(priv, priv->rts_threshold);
4644151b 8800 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8801 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8802 return 0;
8803}
8804
bf79451e
JG		 8805static int ipw_wx_get_rts(struct net_device *dev,
8806 struct iw_request_info *info,
43f66a6c 8807 union iwreq_data *wrqu, char *extra)
bf79451e 8808{
43f66a6c 8809 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 8810 mutex_lock(&priv->mutex);
43f66a6c
JK		 8811 wrqu->rts.value = priv->rts_threshold;
8812 wrqu->rts.fixed = 0; /* no auto select */
0edd5b44 8813 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
4644151b 8814 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8815 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8816 return 0;
8817}
8818
bf79451e
JG		 8819static int ipw_wx_set_txpow(struct net_device *dev,
8820 struct iw_request_info *info,
43f66a6c 8821 union iwreq_data *wrqu, char *extra)
bf79451e 8822{
43f66a6c 8823 struct ipw_priv *priv = ieee80211_priv(dev);
6de9f7f2 8824 int err = 0;
43f66a6c 8825
4644151b 8826 mutex_lock(&priv->mutex);
c848d0af 8827 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
6de9f7f2
ZY		 8828 err = -EINPROGRESS;
8829 goto out;
43f66a6c 8830 }
43f66a6c 8831
b095c381
JK		 8832 if (!wrqu->power.fixed)
8833 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8834
c848d0af 8835 if (wrqu->power.flags != IW_TXPOW_DBM) {
6de9f7f2
ZY		 8836 err = -EINVAL;
8837 goto out;
c848d0af 8838 }
43f66a6c 8839
b095c381 8840 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
afbf30a2 8841 (wrqu->power.value < IPW_TX_POWER_MIN)) {
6de9f7f2
ZY		 8842 err = -EINVAL;
8843 goto out;
c848d0af 8844 }
43f66a6c 8845
43f66a6c 8846 priv->tx_power = wrqu->power.value;
6de9f7f2
ZY		 8847 err = ipw_set_tx_power(priv);
8848 out:
4644151b 8849 mutex_unlock(&priv->mutex);
6de9f7f2 8850 return err;
43f66a6c
JK		 8851}
8852
bf79451e
JG		 8853static int ipw_wx_get_txpow(struct net_device *dev,
8854 struct iw_request_info *info,
43f66a6c 8855 union iwreq_data *wrqu, char *extra)
bf79451e 8856{
43f66a6c 8857 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 8858 mutex_lock(&priv->mutex);
43f66a6c
JK		 8859 wrqu->power.value = priv->tx_power;
8860 wrqu->power.fixed = 1;
8861 wrqu->power.flags = IW_TXPOW_DBM;
8862 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
4644151b 8863 mutex_unlock(&priv->mutex);
43f66a6c 8864
bf79451e 8865 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
22501c8e 8866 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
43f66a6c
JK		 8867
8868 return 0;
8869}
8870
bf79451e 8871static int ipw_wx_set_frag(struct net_device *dev,
0edd5b44
JG		 8872 struct iw_request_info *info,
8873 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 8874{
8875 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 8876 mutex_lock(&priv->mutex);
43f66a6c
JK		 8877 if (wrqu->frag.disabled)
8878 priv->ieee->fts = DEFAULT_FTS;
8879 else {
8880 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
b095c381 8881 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
4644151b 8882 mutex_unlock(&priv->mutex);
43f66a6c 8883 return -EINVAL;
b095c381 8884 }
bf79451e 8885
43f66a6c
JK		 8886 priv->ieee->fts = wrqu->frag.value & ~0x1;
8887 }
8888
8889 ipw_send_frag_threshold(priv, wrqu->frag.value);
4644151b 8890 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8891 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8892 return 0;
8893}
8894
bf79451e 8895static int ipw_wx_get_frag(struct net_device *dev,
0edd5b44
JG		 8896 struct iw_request_info *info,
8897 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 8898{
8899 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 8900 mutex_lock(&priv->mutex);
43f66a6c
JK		 8901 wrqu->frag.value = priv->ieee->fts;
8902 wrqu->frag.fixed = 0; /* no auto select */
0edd5b44 8903 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
4644151b 8904 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8905 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8906
8907 return 0;
8908}
8909
bf79451e
JG		 8910static int ipw_wx_set_retry(struct net_device *dev,
8911 struct iw_request_info *info,
43f66a6c 8912 union iwreq_data *wrqu, char *extra)
bf79451e 8913{
afbf30a2
JK		 8914 struct ipw_priv *priv = ieee80211_priv(dev);
8915
8916 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8917 return -EINVAL;
8918
8919 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8920 return 0;
8921
8922 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8923 return -EINVAL;
8924
4644151b 8925 mutex_lock(&priv->mutex);
afbf30a2
JK		 8926 if (wrqu->retry.flags & IW_RETRY_MIN)
8927 priv->short_retry_limit = (u8) wrqu->retry.value;
8928 else if (wrqu->retry.flags & IW_RETRY_MAX)
8929 priv->long_retry_limit = (u8) wrqu->retry.value;
8930 else {
8931 priv->short_retry_limit = (u8) wrqu->retry.value;
8932 priv->long_retry_limit = (u8) wrqu->retry.value;
8933 }
8934
8935 ipw_send_retry_limit(priv, priv->short_retry_limit,
8936 priv->long_retry_limit);
4644151b 8937 mutex_unlock(&priv->mutex);
afbf30a2
JK		 8938 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8939 priv->short_retry_limit, priv->long_retry_limit);
8940 return 0;
43f66a6c
JK		 8941}
8942
bf79451e
JG		 8943static int ipw_wx_get_retry(struct net_device *dev,
8944 struct iw_request_info *info,
43f66a6c 8945 union iwreq_data *wrqu, char *extra)
bf79451e 8946{
afbf30a2
JK		 8947 struct ipw_priv *priv = ieee80211_priv(dev);
8948
4644151b 8949 mutex_lock(&priv->mutex);
afbf30a2
JK		 8950 wrqu->retry.disabled = 0;
8951
8952 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
4644151b 8953 mutex_unlock(&priv->mutex);
afbf30a2
JK		 8954 return -EINVAL;
8955 }
8956
8957 if (wrqu->retry.flags & IW_RETRY_MAX) {
8958 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8959 wrqu->retry.value = priv->long_retry_limit;
8960 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8961 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8962 wrqu->retry.value = priv->short_retry_limit;
8963 } else {
8964 wrqu->retry.flags = IW_RETRY_LIMIT;
8965 wrqu->retry.value = priv->short_retry_limit;
8966 }
4644151b 8967 mutex_unlock(&priv->mutex);
afbf30a2
JK		 8968
8969 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8970
8971 return 0;
8972}
8973
afbf30a2
JK		 8974static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8975 int essid_len)
8976{
8977 struct ipw_scan_request_ext scan;
8978 int err = 0, scan_type;
8979
efb3442c
PE		 8980 if (!(priv->status & STATUS_INIT) ||
8981 (priv->status & STATUS_EXIT_PENDING))
8982 return 0;
8983
4644151b 8984 mutex_lock(&priv->mutex);
afbf30a2
JK		 8985
8986 if (priv->status & STATUS_RF_KILL_MASK) {
8987 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8988 priv->status |= STATUS_SCAN_PENDING;
8989 goto done;
8990 }
8991
8992 IPW_DEBUG_HC("starting request direct scan!\n");
8993
8994 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
d834a41c
OK		 8995 /* We should not sleep here; otherwise we will block most
8996 * of the system (for instance, we hold rtnl_lock when we
8997 * get here).
8998 */
8999 err = -EAGAIN;
9000 goto done;
afbf30a2
JK		 9001 }
9002 memset(&scan, 0, sizeof(scan));
9003
9004 if (priv->config & CFG_SPEED_SCAN)
9005 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
9006 cpu_to_le16(30);
9007 else
9008 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
9009 cpu_to_le16(20);
9010
9011 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
9012 cpu_to_le16(20);
1fe0adb4 9013 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
afbf30a2
JK		 9014 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
9015
9016 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
9017
9018 err = ipw_send_ssid(priv, essid, essid_len);
9019 if (err) {
9020 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
9021 goto done;
9022 }
9023 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
9024
9025 ipw_add_scan_channels(priv, &scan, scan_type);
9026
9027 err = ipw_send_scan_request_ext(priv, &scan);
9028 if (err) {
9029 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
9030 goto done;
9031 }
9032
9033 priv->status |= STATUS_SCANNING;
9034
9035 done:
4644151b 9036 mutex_unlock(&priv->mutex);
afbf30a2 9037 return err;
43f66a6c
JK		 9038}
9039
bf79451e
JG		 9040static int ipw_wx_set_scan(struct net_device *dev,
9041 struct iw_request_info *info,
43f66a6c
JK		 9042 union iwreq_data *wrqu, char *extra)
9043{
9044 struct ipw_priv *priv = ieee80211_priv(dev);
afbf30a2
JK		 9045 struct iw_scan_req *req = NULL;
9046 if (wrqu->data.length
9047 && wrqu->data.length == sizeof(struct iw_scan_req)) {
9048 req = (struct iw_scan_req *)extra;
9049 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9050 ipw_request_direct_scan(priv, req->essid,
9051 req->essid_len);
9052 return 0;
9053 }
9054 }
8935f39e 9055
43f66a6c 9056 IPW_DEBUG_WX("Start scan\n");
b095c381
JK		 9057
9058 queue_work(priv->workqueue, &priv->request_scan);
9059
43f66a6c
JK		 9060 return 0;
9061}
9062
bf79451e
JG		 9063static int ipw_wx_get_scan(struct net_device *dev,
9064 struct iw_request_info *info,
43f66a6c 9065 union iwreq_data *wrqu, char *extra)
bf79451e 9066{
43f66a6c
JK		 9067 struct ipw_priv *priv = ieee80211_priv(dev);
9068 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9069}
9070
bf79451e 9071static int ipw_wx_set_encode(struct net_device *dev,
0edd5b44
JG		 9072 struct iw_request_info *info,
9073 union iwreq_data *wrqu, char *key)
43f66a6c
JK		 9074{
9075 struct ipw_priv *priv = ieee80211_priv(dev);
afbf30a2 9076 int ret;
caeff81b 9077 u32 cap = priv->capability;
afbf30a2 9078
4644151b 9079 mutex_lock(&priv->mutex);
afbf30a2 9080 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
afbf30a2 9081
caeff81b
HL		 9082 /* In IBSS mode, we need to notify the firmware to update
9083 * the beacon info after we changed the capability. */
9084 if (cap != priv->capability &&
9085 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9086 priv->status & STATUS_ASSOCIATED)
9087 ipw_disassociate(priv);
9088
4644151b 9089 mutex_unlock(&priv->mutex);
afbf30a2 9090 return ret;
43f66a6c
JK		 9091}
9092
bf79451e 9093static int ipw_wx_get_encode(struct net_device *dev,
0edd5b44
JG		 9094 struct iw_request_info *info,
9095 union iwreq_data *wrqu, char *key)
43f66a6c
JK		 9096{
9097 struct ipw_priv *priv = ieee80211_priv(dev);
9098 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9099}
9100
bf79451e 9101static int ipw_wx_set_power(struct net_device *dev,
0edd5b44
JG		 9102 struct iw_request_info *info,
9103 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 9104{
9105 struct ipw_priv *priv = ieee80211_priv(dev);
9106 int err;
4644151b 9107 mutex_lock(&priv->mutex);
43f66a6c
JK		 9108 if (wrqu->power.disabled) {
9109 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9110 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9111 if (err) {
9112 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9113 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9114 return err;
9115 }
43f66a6c 9116 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
4644151b 9117 mutex_unlock(&priv->mutex);
43f66a6c 9118 return 0;
bf79451e 9119 }
43f66a6c
JK		 9120
9121 switch (wrqu->power.flags & IW_POWER_MODE) {
0edd5b44
JG		 9122 case IW_POWER_ON: /* If not specified */
9123 case IW_POWER_MODE: /* If set all mask */
9124 case IW_POWER_ALL_R: /* If explicitely state all */
43f66a6c 9125 break;
0edd5b44 9126 default: /* Otherwise we don't support it */
43f66a6c
JK		 9127 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9128 wrqu->power.flags);
4644151b 9129 mutex_unlock(&priv->mutex);
bf79451e 9130 return -EOPNOTSUPP;
43f66a6c 9131 }
bf79451e 9132
43f66a6c
JK		 9133 /* If the user hasn't specified a power management mode yet, default
9134 * to BATTERY */
0edd5b44 9135 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
43f66a6c 9136 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
bf79451e 9137 else
43f66a6c
JK		 9138 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9139 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9140 if (err) {
9141 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9142 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9143 return err;
9144 }
9145
0edd5b44 9146 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
4644151b 9147 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9148 return 0;
9149}
9150
bf79451e 9151static int ipw_wx_get_power(struct net_device *dev,
0edd5b44
JG		 9152 struct iw_request_info *info,
9153 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 9154{
9155 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 9156 mutex_lock(&priv->mutex);
a613bffd 9157 if (!(priv->power_mode & IPW_POWER_ENABLED))
43f66a6c 9158 wrqu->power.disabled = 1;
a613bffd 9159 else
43f66a6c 9160 wrqu->power.disabled = 0;
43f66a6c 9161
4644151b 9162 mutex_unlock(&priv->mutex);
43f66a6c 9163 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
bf79451e 9164
43f66a6c
JK		 9165 return 0;
9166}
9167
bf79451e 9168static int ipw_wx_set_powermode(struct net_device *dev,
0edd5b44
JG		 9169 struct iw_request_info *info,
9170 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 9171{
9172 struct ipw_priv *priv = ieee80211_priv(dev);
9173 int mode = *(int *)extra;
9174 int err;
4644151b 9175 mutex_lock(&priv->mutex);
43f66a6c
JK		 9176 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9177 mode = IPW_POWER_AC;
9178 priv->power_mode = mode;
9179 } else {
9180 priv->power_mode = IPW_POWER_ENABLED | mode;
9181 }
bf79451e 9182
43f66a6c
JK		 9183 if (priv->power_mode != mode) {
9184 err = ipw_send_power_mode(priv, mode);
bf79451e 9185
43f66a6c
JK		 9186 if (err) {
9187 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9188 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9189 return err;
9190 }
9191 }
4644151b 9192 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9193 return 0;
9194}
9195
9196#define MAX_WX_STRING 80
bf79451e 9197static int ipw_wx_get_powermode(struct net_device *dev,
0edd5b44
JG		 9198 struct iw_request_info *info,
9199 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 9200{
9201 struct ipw_priv *priv = ieee80211_priv(dev);
9202 int level = IPW_POWER_LEVEL(priv->power_mode);
9203 char *p = extra;
9204
9205 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9206
9207 switch (level) {
9208 case IPW_POWER_AC:
9209 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9210 break;
9211 case IPW_POWER_BATTERY:
9212 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9213 break;
9214 default:
9215 p += snprintf(p, MAX_WX_STRING - (p - extra),
bf79451e 9216 "(Timeout %dms, Period %dms)",
43f66a6c
JK		 9217 timeout_duration[level - 1] / 1000,
9218 period_duration[level - 1] / 1000);
9219 }
9220
9221 if (!(priv->power_mode & IPW_POWER_ENABLED))
0edd5b44 9222 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
43f66a6c
JK		 9223
9224 wrqu->data.length = p - extra + 1;
9225
9226 return 0;
9227}
9228
9229static int ipw_wx_set_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9230 struct iw_request_info *info,
9231 union iwreq_data *wrqu, char *extra)
43f66a6c 9232{
0edd5b44 9233 struct ipw_priv *priv = ieee80211_priv(dev);
43f66a6c
JK		 9234 int mode = *(int *)extra;
9235 u8 band = 0, modulation = 0;
9236
9237 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
0edd5b44 9238 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
43f66a6c
JK		 9239 return -EINVAL;
9240 }
4644151b 9241 mutex_lock(&priv->mutex);
43f66a6c 9242 if (priv->adapter == IPW_2915ABG) {
a33a1982 9243 priv->ieee->abg_true = 1;
43f66a6c
JK		 9244 if (mode & IEEE_A) {
9245 band |= IEEE80211_52GHZ_BAND;
9246 modulation |= IEEE80211_OFDM_MODULATION;
9247 } else
a33a1982 9248 priv->ieee->abg_true = 0;
43f66a6c
JK		 9249 } else {
9250 if (mode & IEEE_A) {
9251 IPW_WARNING("Attempt to set 2200BG into "
9252 "802.11a mode\n");
4644151b 9253 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9254 return -EINVAL;
9255 }
9256
a33a1982 9257 priv->ieee->abg_true = 0;
43f66a6c
JK		 9258 }
9259
9260 if (mode & IEEE_B) {
9261 band |= IEEE80211_24GHZ_BAND;
9262 modulation |= IEEE80211_CCK_MODULATION;
9263 } else
a33a1982 9264 priv->ieee->abg_true = 0;
bf79451e 9265
43f66a6c
JK		 9266 if (mode & IEEE_G) {
9267 band |= IEEE80211_24GHZ_BAND;
9268 modulation |= IEEE80211_OFDM_MODULATION;
9269 } else
a33a1982 9270 priv->ieee->abg_true = 0;
43f66a6c
JK		 9271
9272 priv->ieee->mode = mode;
9273 priv->ieee->freq_band = band;
9274 priv->ieee->modulation = modulation;
0edd5b44 9275 init_supported_rates(priv, &priv->rates);
43f66a6c 9276
c848d0af
JK		 9277 /* Network configuration changed -- force [re]association */
9278 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9279 if (!ipw_disassociate(priv)) {
43f66a6c 9280 ipw_send_supported_rates(priv, &priv->rates);
c848d0af
JK		 9281 ipw_associate(priv);
9282 }
43f66a6c 9283
a613bffd
JK		 9284 /* Update the band LEDs */
9285 ipw_led_band_on(priv);
43f66a6c 9286
bf79451e 9287 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
43f66a6c 9288 mode & IEEE_A ? 'a' : '.',
0edd5b44 9289 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
4644151b 9290 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9291 return 0;
9292}
9293
9294static int ipw_wx_get_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9295 struct iw_request_info *info,
9296 union iwreq_data *wrqu, char *extra)
43f66a6c 9297{
0edd5b44 9298 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 9299 mutex_lock(&priv->mutex);
ea2b26e0
JK		 9300 switch (priv->ieee->mode) {
9301 case IEEE_A:
43f66a6c
JK		 9302 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9303 break;
ea2b26e0
JK		 9304 case IEEE_B:
9305 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9306 break;
9307 case IEEE_A | IEEE_B:
9308 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9309 break;
9310 case IEEE_G:
9311 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9312 break;
9313 case IEEE_A | IEEE_G:
9314 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9315 break;
9316 case IEEE_B | IEEE_G:
9317 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9318 break;
9319 case IEEE_A | IEEE_B | IEEE_G:
9320 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9321 break;
9322 default:
9323 strncpy(extra, "unknown", MAX_WX_STRING);
43f66a6c 9324 break;
bf79451e
JG		 9325 }
9326
43f66a6c
JK		 9327 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9328
0edd5b44 9329 wrqu->data.length = strlen(extra) + 1;
4644151b 9330 mutex_unlock(&priv->mutex);
b095c381
JK		 9331
9332 return 0;
9333}
9334
9335static int ipw_wx_set_preamble(struct net_device *dev,
9336 struct iw_request_info *info,
9337 union iwreq_data *wrqu, char *extra)
9338{
9339 struct ipw_priv *priv = ieee80211_priv(dev);
9340 int mode = *(int *)extra;
4644151b 9341 mutex_lock(&priv->mutex);
b095c381
JK		 9342 /* Switching from SHORT -> LONG requires a disassociation */
9343 if (mode == 1) {
9344 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9345 priv->config |= CFG_PREAMBLE_LONG;
9346
9347 /* Network configuration changed -- force [re]association */
9348 IPW_DEBUG_ASSOC
9349 ("[re]association triggered due to preamble change.\n");
9350 if (!ipw_disassociate(priv))
9351 ipw_associate(priv);
9352 }
9353 goto done;
9354 }
43f66a6c 9355
b095c381
JK		 9356 if (mode == 0) {
9357 priv->config &= ~CFG_PREAMBLE_LONG;
9358 goto done;
9359 }
4644151b 9360 mutex_unlock(&priv->mutex);
b095c381
JK		 9361 return -EINVAL;
9362
9363 done:
4644151b 9364 mutex_unlock(&priv->mutex);
b095c381
JK		 9365 return 0;
9366}
9367
9368static int ipw_wx_get_preamble(struct net_device *dev,
9369 struct iw_request_info *info,
9370 union iwreq_data *wrqu, char *extra)
9371{
9372 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 9373 mutex_lock(&priv->mutex);
b095c381
JK		 9374 if (priv->config & CFG_PREAMBLE_LONG)
9375 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9376 else
9377 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
4644151b 9378 mutex_unlock(&priv->mutex);
0edd5b44 9379 return 0;
43f66a6c
JK		 9380}
9381
b095c381
JK		 9382#ifdef CONFIG_IPW2200_MONITOR
9383static int ipw_wx_set_monitor(struct net_device *dev,
bf79451e 9384 struct iw_request_info *info,
43f66a6c 9385 union iwreq_data *wrqu, char *extra)
bf79451e 9386{
43f66a6c
JK		 9387 struct ipw_priv *priv = ieee80211_priv(dev);
9388 int *parms = (int *)extra;
9389 int enable = (parms[0] > 0);
4644151b 9390 mutex_lock(&priv->mutex);
b095c381 9391 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
43f66a6c
JK		 9392 if (enable) {
9393 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
24a47dbd
MK		 9394#ifdef CONFIG_IEEE80211_RADIOTAP
9395 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9396#else
43f66a6c 9397 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 9398#endif
b095c381 9399 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c 9400 }
bf79451e 9401
43f66a6c
JK		 9402 ipw_set_channel(priv, parms[1]);
9403 } else {
b095c381 9404 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
4644151b 9405 mutex_unlock(&priv->mutex);
43f66a6c 9406 return 0;
b095c381 9407 }
43f66a6c 9408 priv->net_dev->type = ARPHRD_ETHER;
b095c381 9409 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c 9410 }
4644151b 9411 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9412 return 0;
9413}
9414
b095c381
JK		 9415#endif // CONFIG_IPW2200_MONITOR
9416
bf79451e
JG		 9417static int ipw_wx_reset(struct net_device *dev,
9418 struct iw_request_info *info,
43f66a6c 9419 union iwreq_data *wrqu, char *extra)
bf79451e 9420{
43f66a6c
JK		 9421 struct ipw_priv *priv = ieee80211_priv(dev);
9422 IPW_DEBUG_WX("RESET\n");
b095c381
JK		 9423 queue_work(priv->workqueue, &priv->adapter_restart);
9424 return 0;
9425}
9426
b095c381
JK		 9427static int ipw_wx_sw_reset(struct net_device *dev,
9428 struct iw_request_info *info,
9429 union iwreq_data *wrqu, char *extra)
ea2b26e0
JK		 9430{
9431 struct ipw_priv *priv = ieee80211_priv(dev);
b095c381
JK		 9432 union iwreq_data wrqu_sec = {
9433 .encoding = {
9434 .flags = IW_ENCODE_DISABLED,
9435 },
9436 };
afbf30a2 9437 int ret;
c848d0af 9438
b095c381 9439 IPW_DEBUG_WX("SW_RESET\n");
ea2b26e0 9440
4644151b 9441 mutex_lock(&priv->mutex);
ea2b26e0 9442
d6d5b5c1 9443 ret = ipw_sw_reset(priv, 2);
afbf30a2
JK		 9444 if (!ret) {
9445 free_firmware();
9446 ipw_adapter_restart(priv);
9447 }
ea2b26e0 9448
b095c381
JK		 9449 /* The SW reset bit might have been toggled on by the 'disable'
9450 * module parameter, so take appropriate action */
9451 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
ea2b26e0 9452
4644151b 9453 mutex_unlock(&priv->mutex);
b095c381 9454 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
4644151b 9455 mutex_lock(&priv->mutex);
bf79451e 9456
b095c381
JK		 9457 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9458 /* Configuration likely changed -- force [re]association */
9459 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9460 "reset.\n");
9461 if (!ipw_disassociate(priv))
9462 ipw_associate(priv);
43f66a6c 9463 }
b095c381 9464
4644151b 9465 mutex_unlock(&priv->mutex);
43f66a6c 9466
43f66a6c
JK		 9467 return 0;
9468}
43f66a6c
JK		 9469
9470/* Rebase the WE IOCTLs to zero for the handler array */
9471#define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
0edd5b44 9472static iw_handler ipw_wx_handlers[] = {
ea2b26e0
JK		 9473 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9474 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9475 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9476 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9477 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
651be26f
OH		 9478 IW_IOCTL(SIOCSIWSENS) = ipw_wx_set_sens,
9479 IW_IOCTL(SIOCGIWSENS) = ipw_wx_get_sens,
ea2b26e0
JK		 9480 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9481 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9482 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9483 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9484 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9485 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9486 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9487 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9488 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9489 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9490 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9491 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9492 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9493 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9494 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9495 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9496 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9497 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9498 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9499 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9500 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9501 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9502 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
a613bffd
JK		 9503 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9504 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9505 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9506 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
afbf30a2
JK		 9507 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9508 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9509 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9510 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9511 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9512 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9513 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
43f66a6c
JK		 9514};
9515
b095c381
JK		 9516enum {
9517 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9518 IPW_PRIV_GET_POWER,
9519 IPW_PRIV_SET_MODE,
9520 IPW_PRIV_GET_MODE,
9521 IPW_PRIV_SET_PREAMBLE,
9522 IPW_PRIV_GET_PREAMBLE,
9523 IPW_PRIV_RESET,
9524 IPW_PRIV_SW_RESET,
9525#ifdef CONFIG_IPW2200_MONITOR
9526 IPW_PRIV_SET_MONITOR,
9527#endif
9528};
43f66a6c 9529
bf79451e 9530static struct iw_priv_args ipw_priv_args[] = {
43f66a6c 9531 {
0edd5b44
JG		 9532 .cmd = IPW_PRIV_SET_POWER,
9533 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9534 .name = "set_power"},
43f66a6c 9535 {
0edd5b44
JG		 9536 .cmd = IPW_PRIV_GET_POWER,
9537 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9538 .name = "get_power"},
43f66a6c 9539 {
0edd5b44
JG		 9540 .cmd = IPW_PRIV_SET_MODE,
9541 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9542 .name = "set_mode"},
43f66a6c 9543 {
0edd5b44
JG		 9544 .cmd = IPW_PRIV_GET_MODE,
9545 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9546 .name = "get_mode"},
43f66a6c 9547 {
ea2b26e0
JK		 9548 .cmd = IPW_PRIV_SET_PREAMBLE,
9549 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9550 .name = "set_preamble"},
9551 {
9552 .cmd = IPW_PRIV_GET_PREAMBLE,
9553 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9554 .name = "get_preamble"},
43f66a6c 9555 {
0edd5b44
JG		 9556 IPW_PRIV_RESET,
9557 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
b095c381
JK		 9558 {
9559 IPW_PRIV_SW_RESET,
9560 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9561#ifdef CONFIG_IPW2200_MONITOR
9562 {
9563 IPW_PRIV_SET_MONITOR,
9564 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9565#endif /* CONFIG_IPW2200_MONITOR */
43f66a6c
JK		 9566};
9567
9568static iw_handler ipw_priv_handler[] = {
9569 ipw_wx_set_powermode,
9570 ipw_wx_get_powermode,
9571 ipw_wx_set_wireless_mode,
9572 ipw_wx_get_wireless_mode,
ea2b26e0
JK		 9573 ipw_wx_set_preamble,
9574 ipw_wx_get_preamble,
bf79451e 9575 ipw_wx_reset,
b095c381
JK		 9576 ipw_wx_sw_reset,
9577#ifdef CONFIG_IPW2200_MONITOR
9578 ipw_wx_set_monitor,
43f66a6c
JK		 9579#endif
9580};
9581
0edd5b44 9582static struct iw_handler_def ipw_wx_handler_def = {
ea2b26e0
JK		 9583 .standard = ipw_wx_handlers,
9584 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9585 .num_private = ARRAY_SIZE(ipw_priv_handler),
9586 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9587 .private = ipw_priv_handler,
9588 .private_args = ipw_priv_args,
97a78ca9 9589 .get_wireless_stats = ipw_get_wireless_stats,
43f66a6c
JK		 9590};
9591
43f66a6c
JK		 9592/*
9593 * Get wireless statistics.
9594 * Called by /proc/net/wireless
9595 * Also called by SIOCGIWSTATS
9596 */
0edd5b44 9597static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
43f66a6c
JK		 9598{
9599 struct ipw_priv *priv = ieee80211_priv(dev);
9600 struct iw_statistics *wstats;
bf79451e 9601
43f66a6c
JK		 9602 wstats = &priv->wstats;
9603
ea2b26e0 9604 /* if hw is disabled, then ipw_get_ordinal() can't be called.
afbf30a2 9605 * netdev->get_wireless_stats seems to be called before fw is
43f66a6c
JK		 9606 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9607 * and associated; if not associcated, the values are all meaningless
9608 * anyway, so set them all to NULL and INVALID */
9609 if (!(priv->status & STATUS_ASSOCIATED)) {
9610 wstats->miss.beacon = 0;
9611 wstats->discard.retries = 0;
9612 wstats->qual.qual = 0;
9613 wstats->qual.level = 0;
9614 wstats->qual.noise = 0;
9615 wstats->qual.updated = 7;
9616 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
0edd5b44 9617 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
43f66a6c 9618 return wstats;
bf79451e 9619 }
43f66a6c
JK		 9620
9621 wstats->qual.qual = priv->quality;
9622 wstats->qual.level = average_value(&priv->average_rssi);
9623 wstats->qual.noise = average_value(&priv->average_noise);
9624 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
b191608a 9625 IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
43f66a6c
JK		 9626
9627 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9628 wstats->discard.retries = priv->last_tx_failures;
9629 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
bf79451e 9630
43f66a6c
JK		 9631/* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9632 goto fail_get_ordinal;
9633 wstats->discard.retries += tx_retry; */
bf79451e 9634
43f66a6c
JK		 9635 return wstats;
9636}
9637
43f66a6c
JK		 9638/* net device stuff */
9639
858119e1 9640static void init_sys_config(struct ipw_sys_config *sys_config)
43f66a6c 9641{
0edd5b44 9642 memset(sys_config, 0, sizeof(struct ipw_sys_config));
810dabd4 9643 sys_config->bt_coexistence = 0;
43f66a6c
JK		 9644 sys_config->answer_broadcast_ssid_probe = 0;
9645 sys_config->accept_all_data_frames = 0;
9646 sys_config->accept_non_directed_frames = 1;
9647 sys_config->exclude_unicast_unencrypted = 0;
9648 sys_config->disable_unicast_decryption = 1;
9649 sys_config->exclude_multicast_unencrypted = 0;
9650 sys_config->disable_multicast_decryption = 1;
71de1f3d 9651 sys_config->antenna_diversity = CFG_SYS_ANTENNA_SLOW_DIV;
0edd5b44 9652 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
43f66a6c 9653 sys_config->dot11g_auto_detection = 0;
bf79451e 9654 sys_config->enable_cts_to_self = 0;
43f66a6c 9655 sys_config->bt_coexist_collision_thr = 0;
c848d0af 9656 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
12977154 9657 sys_config->silence_threshold = 0x1e;
43f66a6c
JK		 9658}
9659
9660static int ipw_net_open(struct net_device *dev)
9661{
9662 struct ipw_priv *priv = ieee80211_priv(dev);
9663 IPW_DEBUG_INFO("dev->open\n");
9664 /* we should be verifying the device is ready to be opened */
4644151b 9665 mutex_lock(&priv->mutex);
bf79451e
JG		 9666 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9667 (priv->status & STATUS_ASSOCIATED))
43f66a6c 9668 netif_start_queue(dev);
4644151b 9669 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9670 return 0;
9671}
9672
9673static int ipw_net_stop(struct net_device *dev)
9674{
9675 IPW_DEBUG_INFO("dev->close\n");
9676 netif_stop_queue(dev);
9677 return 0;
9678}
9679
9680/*
9681todo:
9682
9683modify to send one tfd per fragment instead of using chunking. otherwise
9684we need to heavily modify the ieee80211_skb_to_txb.
9685*/
9686
858119e1 9687static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
227d2dc1 9688 int pri)
43f66a6c 9689{
0dacca1f 9690 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
0edd5b44 9691 txb->fragments[0]->data;
43f66a6c
JK		 9692 int i = 0;
9693 struct tfd_frame *tfd;
b095c381
JK		 9694#ifdef CONFIG_IPW_QOS
9695 int tx_id = ipw_get_tx_queue_number(priv, pri);
9696 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9697#else
43f66a6c 9698 struct clx2_tx_queue *txq = &priv->txq[0];
b095c381 9699#endif
43f66a6c
JK		 9700 struct clx2_queue *q = &txq->q;
9701 u8 id, hdr_len, unicast;
9702 u16 remaining_bytes;
c848d0af 9703 int fc;
43f66a6c
JK		 9704
9705 switch (priv->ieee->iw_mode) {
9706 case IW_MODE_ADHOC:
9707 hdr_len = IEEE80211_3ADDR_LEN;
3c19065a 9708 unicast = !is_multicast_ether_addr(hdr->addr1);
43f66a6c
JK		 9709 id = ipw_find_station(priv, hdr->addr1);
9710 if (id == IPW_INVALID_STATION) {
9711 id = ipw_add_station(priv, hdr->addr1);
9712 if (id == IPW_INVALID_STATION) {
9713 IPW_WARNING("Attempt to send data to "
bf79451e 9714 "invalid cell: " MAC_FMT "\n",
43f66a6c
JK		 9715 MAC_ARG(hdr->addr1));
9716 goto drop;
9717 }
9718 }
9719 break;
9720
9721 case IW_MODE_INFRA:
9722 default:
3c19065a 9723 unicast = !is_multicast_ether_addr(hdr->addr3);
43f66a6c
JK		 9724 hdr_len = IEEE80211_3ADDR_LEN;
9725 id = 0;
9726 break;
9727 }
9728
9729 tfd = &txq->bd[q->first_empty];
9730 txq->txb[q->first_empty] = txb;
9731 memset(tfd, 0, sizeof(*tfd));
9732 tfd->u.data.station_number = id;
9733
9734 tfd->control_flags.message_type = TX_FRAME_TYPE;
9735 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9736
9737 tfd->u.data.cmd_id = DINO_CMD_TX;
a613bffd 9738 tfd->u.data.len = cpu_to_le16(txb->payload_size);
43f66a6c 9739 remaining_bytes = txb->payload_size;
bf79451e 9740
43f66a6c 9741 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
b095c381 9742 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
43f66a6c 9743 else
b095c381 9744 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
43f66a6c 9745
ea2b26e0
JK		 9746 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9747 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
43f66a6c 9748
c848d0af
JK		 9749 fc = le16_to_cpu(hdr->frame_ctl);
9750 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
43f66a6c
JK		 9751
9752 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9753
b095c381
JK		 9754 if (likely(unicast))
9755 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9756
9757 if (txb->encrypted && !priv->ieee->host_encrypt) {
9758 switch (priv->ieee->sec.level) {
9759 case SEC_LEVEL_3:
9760 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9761 IEEE80211_FCTL_PROTECTED;
9762 /* XXX: ACK flag must be set for CCMP even if it
9763 * is a multicast/broadcast packet, because CCMP
9764 * group communication encrypted by GTK is
9765 * actually done by the AP. */
9766 if (!unicast)
9767 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9768
9769 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9770 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9771 tfd->u.data.key_index = 0;
9772 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9773 break;
9774 case SEC_LEVEL_2:
9775 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9776 IEEE80211_FCTL_PROTECTED;
9777 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9778 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9779 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9780 break;
9781 case SEC_LEVEL_1:
9782 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9783 IEEE80211_FCTL_PROTECTED;
9784 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9785 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9786 40)
9787 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9788 else
9789 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9790 break;
9791 case SEC_LEVEL_0:
9792 break;
9793 default:
9794 printk(KERN_ERR "Unknow security level %d\n",
9795 priv->ieee->sec.level);
9796 break;
9797 }
9798 } else
9799 /* No hardware encryption */
9800 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9801
9802#ifdef CONFIG_IPW_QOS
9803 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9804#endif /* CONFIG_IPW_QOS */
9805
43f66a6c 9806 /* payload */
a613bffd
JK		 9807 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9808 txb->nr_frags));
9809 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9810 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9811 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9812 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9813 i, le32_to_cpu(tfd->u.data.num_chunks),
9814 txb->fragments[i]->len - hdr_len);
bf79451e 9815 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
43f66a6c
JK		 9816 i, tfd->u.data.num_chunks,
9817 txb->fragments[i]->len - hdr_len);
bf79451e 9818 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
43f66a6c
JK		 9819 txb->fragments[i]->len - hdr_len);
9820
0edd5b44 9821 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 9822 cpu_to_le32(pci_map_single
9823 (priv->pci_dev,
9824 txb->fragments[i]->data + hdr_len,
9825 txb->fragments[i]->len - hdr_len,
9826 PCI_DMA_TODEVICE));
9827 tfd->u.data.chunk_len[i] =
9828 cpu_to_le16(txb->fragments[i]->len - hdr_len);
43f66a6c
JK		 9829 }
9830
9831 if (i != txb->nr_frags) {
9832 struct sk_buff *skb;
9833 u16 remaining_bytes = 0;
9834 int j;
9835
9836 for (j = i; j < txb->nr_frags; j++)
9837 remaining_bytes += txb->fragments[j]->len - hdr_len;
9838
9839 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9840 remaining_bytes);
9841 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9842 if (skb != NULL) {
a613bffd 9843 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
43f66a6c
JK		 9844 for (j = i; j < txb->nr_frags; j++) {
9845 int size = txb->fragments[j]->len - hdr_len;
afbf30a2 9846
43f66a6c 9847 printk(KERN_INFO "Adding frag %d %d...\n",
0edd5b44 9848 j, size);
43f66a6c 9849 memcpy(skb_put(skb, size),
0edd5b44 9850 txb->fragments[j]->data + hdr_len, size);
43f66a6c
JK		 9851 }
9852 dev_kfree_skb_any(txb->fragments[i]);
9853 txb->fragments[i] = skb;
0edd5b44 9854 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 9855 cpu_to_le32(pci_map_single
9856 (priv->pci_dev, skb->data,
9857 tfd->u.data.chunk_len[i],
9858 PCI_DMA_TODEVICE));
9859
9860 tfd->u.data.num_chunks =
9861 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9862 1);
bf79451e 9863 }
43f66a6c
JK		 9864 }
9865
9866 /* kick DMA */
9867 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9868 ipw_write32(priv, q->reg_w, q->first_empty);
9869
f697014a
JK		 9870 if (ipw_queue_space(q) < q->high_mark)
9871 netif_stop_queue(priv->net_dev);
9872
227d2dc1 9873 return NETDEV_TX_OK;
43f66a6c 9874
0edd5b44 9875 drop:
43f66a6c
JK		 9876 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9877 ieee80211_txb_free(txb);
227d2dc1
JK		 9878 return NETDEV_TX_OK;
9879}
9880
9881static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9882{
9883 struct ipw_priv *priv = ieee80211_priv(dev);
9884#ifdef CONFIG_IPW_QOS
9885 int tx_id = ipw_get_tx_queue_number(priv, pri);
9886 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9887#else
9888 struct clx2_tx_queue *txq = &priv->txq[0];
9889#endif /* CONFIG_IPW_QOS */
9890
9891 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9892 return 1;
9893
9894 return 0;
43f66a6c
JK		 9895}
9896
9897static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
c8d42d1a 9898 struct net_device *dev, int pri)
43f66a6c
JK		 9899{
9900 struct ipw_priv *priv = ieee80211_priv(dev);
9901 unsigned long flags;
227d2dc1 9902 int ret;
43f66a6c
JK		 9903
9904 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
43f66a6c
JK		 9905 spin_lock_irqsave(&priv->lock, flags);
9906
9907 if (!(priv->status & STATUS_ASSOCIATED)) {
9908 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9909 priv->ieee->stats.tx_carrier_errors++;
9910 netif_stop_queue(dev);
9911 goto fail_unlock;
9912 }
9913
227d2dc1
JK		 9914 ret = ipw_tx_skb(priv, txb, pri);
9915 if (ret == NETDEV_TX_OK)
9916 __ipw_led_activity_on(priv);
43f66a6c 9917 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 9918
227d2dc1 9919 return ret;
43f66a6c 9920
0edd5b44 9921 fail_unlock:
43f66a6c
JK		 9922 spin_unlock_irqrestore(&priv->lock, flags);
9923 return 1;
9924}
9925
9926static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9927{
9928 struct ipw_priv *priv = ieee80211_priv(dev);
bf79451e 9929
43f66a6c
JK		 9930 priv->ieee->stats.tx_packets = priv->tx_packets;
9931 priv->ieee->stats.rx_packets = priv->rx_packets;
9932 return &priv->ieee->stats;
9933}
9934
9935static void ipw_net_set_multicast_list(struct net_device *dev)
9936{
9937
9938}
9939
9940static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9941{
9942 struct ipw_priv *priv = ieee80211_priv(dev);
9943 struct sockaddr *addr = p;
9944 if (!is_valid_ether_addr(addr->sa_data))
9945 return -EADDRNOTAVAIL;
4644151b 9946 mutex_lock(&priv->mutex);
43f66a6c
JK		 9947 priv->config |= CFG_CUSTOM_MAC;
9948 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9949 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9950 priv->net_dev->name, MAC_ARG(priv->mac_addr));
a613bffd 9951 queue_work(priv->workqueue, &priv->adapter_restart);
4644151b 9952 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9953 return 0;
9954}
9955
bf79451e 9956static void ipw_ethtool_get_drvinfo(struct net_device *dev,
43f66a6c
JK		 9957 struct ethtool_drvinfo *info)
9958{
9959 struct ipw_priv *p = ieee80211_priv(dev);
9960 char vers[64];
9961 char date[32];
9962 u32 len;
9963
9964 strcpy(info->driver, DRV_NAME);
9965 strcpy(info->version, DRV_VERSION);
9966
9967 len = sizeof(vers);
9968 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9969 len = sizeof(date);
9970 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9971
0edd5b44 9972 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
43f66a6c
JK		 9973 vers, date);
9974 strcpy(info->bus_info, pci_name(p->pci_dev));
b095c381 9975 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 9976}
9977
9978static u32 ipw_ethtool_get_link(struct net_device *dev)
9979{
9980 struct ipw_priv *priv = ieee80211_priv(dev);
9981 return (priv->status & STATUS_ASSOCIATED) != 0;
9982}
9983
9984static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9985{
b095c381 9986 return IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 9987}
9988
9989static int ipw_ethtool_get_eeprom(struct net_device *dev,
0edd5b44 9990 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c
JK		 9991{
9992 struct ipw_priv *p = ieee80211_priv(dev);
9993
b095c381 9994 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 9995 return -EINVAL;
4644151b 9996 mutex_lock(&p->mutex);
afbf30a2 9997 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
4644151b 9998 mutex_unlock(&p->mutex);
43f66a6c
JK		 9999 return 0;
10000}
10001
10002static int ipw_ethtool_set_eeprom(struct net_device *dev,
0edd5b44 10003 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c
JK		 10004{
10005 struct ipw_priv *p = ieee80211_priv(dev);
10006 int i;
10007
b095c381 10008 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 10009 return -EINVAL;
4644151b 10010 mutex_lock(&p->mutex);
afbf30a2 10011 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
bf79451e 10012 for (i = IPW_EEPROM_DATA;
b095c381 10013 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
43f66a6c 10014 ipw_write8(p, i, p->eeprom[i]);
4644151b 10015 mutex_unlock(&p->mutex);
43f66a6c
JK		 10016 return 0;
10017}
10018
10019static struct ethtool_ops ipw_ethtool_ops = {
ea2b26e0
JK		 10020 .get_link = ipw_ethtool_get_link,
10021 .get_drvinfo = ipw_ethtool_get_drvinfo,
10022 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10023 .get_eeprom = ipw_ethtool_get_eeprom,
10024 .set_eeprom = ipw_ethtool_set_eeprom,
43f66a6c
JK		 10025};
10026
10027static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
10028{
10029 struct ipw_priv *priv = data;
10030 u32 inta, inta_mask;
bf79451e 10031
43f66a6c
JK		 10032 if (!priv)
10033 return IRQ_NONE;
10034
10035 spin_lock(&priv->lock);
10036
10037 if (!(priv->status & STATUS_INT_ENABLED)) {
10038 /* Shared IRQ */
10039 goto none;
10040 }
10041
b095c381
JK		 10042 inta = ipw_read32(priv, IPW_INTA_RW);
10043 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
bf79451e 10044
43f66a6c
JK		 10045 if (inta == 0xFFFFFFFF) {
10046 /* Hardware disappeared */
10047 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10048 goto none;
10049 }
10050
b095c381 10051 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
43f66a6c
JK		 10052 /* Shared interrupt */
10053 goto none;
10054 }
10055
10056 /* tell the device to stop sending interrupts */
10057 ipw_disable_interrupts(priv);
bf79451e 10058
43f66a6c 10059 /* ack current interrupts */
b095c381
JK		 10060 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10061 ipw_write32(priv, IPW_INTA_RW, inta);
bf79451e 10062
43f66a6c
JK		 10063 /* Cache INTA value for our tasklet */
10064 priv->isr_inta = inta;
10065
10066 tasklet_schedule(&priv->irq_tasklet);
10067
0edd5b44 10068 spin_unlock(&priv->lock);
43f66a6c
JK		 10069
10070 return IRQ_HANDLED;
0edd5b44 10071 none:
43f66a6c
JK		 10072 spin_unlock(&priv->lock);
10073 return IRQ_NONE;
10074}
10075
10076static void ipw_rf_kill(void *adapter)
10077{
10078 struct ipw_priv *priv = adapter;
10079 unsigned long flags;
bf79451e 10080
43f66a6c
JK		 10081 spin_lock_irqsave(&priv->lock, flags);
10082
10083 if (rf_kill_active(priv)) {
10084 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10085 if (priv->workqueue)
10086 queue_delayed_work(priv->workqueue,
10087 &priv->rf_kill, 2 * HZ);
10088 goto exit_unlock;
10089 }
10090
10091 /* RF Kill is now disabled, so bring the device back up */
10092
10093 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10094 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10095 "device\n");
10096
10097 /* we can not do an adapter restart while inside an irq lock */
10098 queue_work(priv->workqueue, &priv->adapter_restart);
bf79451e 10099 } else
43f66a6c
JK		 10100 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10101 "enabled\n");
10102
0edd5b44 10103 exit_unlock:
43f66a6c
JK		 10104 spin_unlock_irqrestore(&priv->lock, flags);
10105}
10106
c848d0af
JK		 10107static void ipw_bg_rf_kill(void *data)
10108{
10109 struct ipw_priv *priv = data;
4644151b 10110 mutex_lock(&priv->mutex);
c848d0af 10111 ipw_rf_kill(data);
4644151b 10112 mutex_unlock(&priv->mutex);
c848d0af
JK		 10113}
10114
a73e22b2 10115static void ipw_link_up(struct ipw_priv *priv)
a613bffd 10116{
afbf30a2
JK		 10117 priv->last_seq_num = -1;
10118 priv->last_frag_num = -1;
10119 priv->last_packet_time = 0;
10120
a613bffd
JK		 10121 netif_carrier_on(priv->net_dev);
10122 if (netif_queue_stopped(priv->net_dev)) {
10123 IPW_DEBUG_NOTIF("waking queue\n");
10124 netif_wake_queue(priv->net_dev);
10125 } else {
10126 IPW_DEBUG_NOTIF("starting queue\n");
10127 netif_start_queue(priv->net_dev);
10128 }
10129
c848d0af 10130 cancel_delayed_work(&priv->request_scan);
a613bffd
JK		 10131 ipw_reset_stats(priv);
10132 /* Ensure the rate is updated immediately */
10133 priv->last_rate = ipw_get_current_rate(priv);
10134 ipw_gather_stats(priv);
10135 ipw_led_link_up(priv);
10136 notify_wx_assoc_event(priv);
10137
10138 if (priv->config & CFG_BACKGROUND_SCAN)
10139 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10140}
10141
c848d0af
JK		 10142static void ipw_bg_link_up(void *data)
10143{
10144 struct ipw_priv *priv = data;
4644151b 10145 mutex_lock(&priv->mutex);
c848d0af 10146 ipw_link_up(data);
4644151b 10147 mutex_unlock(&priv->mutex);
c848d0af
JK		 10148}
10149
a73e22b2 10150static void ipw_link_down(struct ipw_priv *priv)
a613bffd
JK		 10151{
10152 ipw_led_link_down(priv);
10153 netif_carrier_off(priv->net_dev);
10154 netif_stop_queue(priv->net_dev);
10155 notify_wx_assoc_event(priv);
10156
10157 /* Cancel any queued work ... */
10158 cancel_delayed_work(&priv->request_scan);
10159 cancel_delayed_work(&priv->adhoc_check);
10160 cancel_delayed_work(&priv->gather_stats);
10161
10162 ipw_reset_stats(priv);
10163
afbf30a2
JK		 10164 if (!(priv->status & STATUS_EXIT_PENDING)) {
10165 /* Queue up another scan... */
10166 queue_work(priv->workqueue, &priv->request_scan);
10167 }
a613bffd
JK		 10168}
10169
c848d0af
JK		 10170static void ipw_bg_link_down(void *data)
10171{
10172 struct ipw_priv *priv = data;
4644151b 10173 mutex_lock(&priv->mutex);
c848d0af 10174 ipw_link_down(data);
4644151b 10175 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10176}
10177
10178static int ipw_setup_deferred_work(struct ipw_priv *priv)
10179{
10180 int ret = 0;
10181
43f66a6c 10182 priv->workqueue = create_workqueue(DRV_NAME);
43f66a6c 10183 init_waitqueue_head(&priv->wait_command_queue);
afbf30a2 10184 init_waitqueue_head(&priv->wait_state);
43f66a6c 10185
c848d0af
JK		 10186 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10187 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10188 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
d8bad6df 10189 INIT_WORK(&priv->system_config, ipw_system_config, priv);
c848d0af
JK		 10190 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10191 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10192 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10193 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10194 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
bf79451e 10195 INIT_WORK(&priv->request_scan,
43f66a6c 10196 (void (*)(void *))ipw_request_scan, priv);
bf79451e 10197 INIT_WORK(&priv->gather_stats,
c848d0af
JK		 10198 (void (*)(void *))ipw_bg_gather_stats, priv);
10199 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10200 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10201 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10202 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10203 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10204 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10205 priv);
10206 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
a613bffd 10207 priv);
c848d0af 10208 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
a613bffd 10209 priv);
c848d0af
JK		 10210 INIT_WORK(&priv->merge_networks,
10211 (void (*)(void *))ipw_merge_adhoc_network, priv);
43f66a6c 10212
b095c381
JK		 10213#ifdef CONFIG_IPW_QOS
10214 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10215 priv);
10216#endif /* CONFIG_IPW_QOS */
43f66a6c
JK		 10217
10218 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10219 ipw_irq_tasklet, (unsigned long)priv);
10220
10221 return ret;
10222}
10223
43f66a6c
JK		 10224static void shim__set_security(struct net_device *dev,
10225 struct ieee80211_security *sec)
10226{
10227 struct ipw_priv *priv = ieee80211_priv(dev);
10228 int i;
bf79451e 10229 for (i = 0; i < 4; i++) {
43f66a6c 10230 if (sec->flags & (1 << i)) {
afbf30a2 10231 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
b095c381 10232 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
43f66a6c 10233 if (sec->key_sizes[i] == 0)
b095c381
JK		 10234 priv->ieee->sec.flags &= ~(1 << i);
10235 else {
10236 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
43f66a6c 10237 sec->key_sizes[i]);
b095c381
JK		 10238 priv->ieee->sec.flags |= (1 << i);
10239 }
43f66a6c 10240 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10241 } else if (sec->level != SEC_LEVEL_1)
10242 priv->ieee->sec.flags &= ~(1 << i);
43f66a6c
JK		 10243 }
10244
b095c381 10245 if (sec->flags & SEC_ACTIVE_KEY) {
43f66a6c 10246 if (sec->active_key <= 3) {
b095c381
JK		 10247 priv->ieee->sec.active_key = sec->active_key;
10248 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
bf79451e 10249 } else
b095c381 10250 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c 10251 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10252 } else
10253 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c
JK		 10254
10255 if ((sec->flags & SEC_AUTH_MODE) &&
b095c381
JK		 10256 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10257 priv->ieee->sec.auth_mode = sec->auth_mode;
10258 priv->ieee->sec.flags |= SEC_AUTH_MODE;
43f66a6c
JK		 10259 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10260 priv->capability |= CAP_SHARED_KEY;
10261 else
10262 priv->capability &= ~CAP_SHARED_KEY;
10263 priv->status |= STATUS_SECURITY_UPDATED;
10264 }
bf79451e 10265
b095c381
JK		 10266 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10267 priv->ieee->sec.flags |= SEC_ENABLED;
10268 priv->ieee->sec.enabled = sec->enabled;
43f66a6c 10269 priv->status |= STATUS_SECURITY_UPDATED;
bf79451e 10270 if (sec->enabled)
43f66a6c
JK		 10271 priv->capability |= CAP_PRIVACY_ON;
10272 else
10273 priv->capability &= ~CAP_PRIVACY_ON;
10274 }
bf79451e 10275
afbf30a2
JK		 10276 if (sec->flags & SEC_ENCRYPT)
10277 priv->ieee->sec.encrypt = sec->encrypt;
bf79451e 10278
b095c381
JK		 10279 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10280 priv->ieee->sec.level = sec->level;
10281 priv->ieee->sec.flags |= SEC_LEVEL;
43f66a6c
JK		 10282 priv->status |= STATUS_SECURITY_UPDATED;
10283 }
10284
1fbfea54
ZY		 10285 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10286 ipw_set_hwcrypto_keys(priv);
10287
bf79451e
JG		 10288 /* To match current functionality of ipw2100 (which works well w/
10289 * various supplicants, we don't force a disassociate if the
43f66a6c
JK		 10290 * privacy capability changes ... */
10291#if 0
10292 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
bf79451e 10293 (((priv->assoc_request.capability &
43f66a6c 10294 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
bf79451e 10295 (!(priv->assoc_request.capability &
0edd5b44 10296 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
43f66a6c
JK		 10297 IPW_DEBUG_ASSOC("Disassociating due to capability "
10298 "change.\n");
10299 ipw_disassociate(priv);
10300 }
10301#endif
10302}
10303
bf79451e 10304static int init_supported_rates(struct ipw_priv *priv,
43f66a6c
JK		 10305 struct ipw_supported_rates *rates)
10306{
10307 /* TODO: Mask out rates based on priv->rates_mask */
10308
10309 memset(rates, 0, sizeof(*rates));
0edd5b44 10310 /* configure supported rates */
43f66a6c
JK		 10311 switch (priv->ieee->freq_band) {
10312 case IEEE80211_52GHZ_BAND:
10313 rates->ieee_mode = IPW_A_MODE;
10314 rates->purpose = IPW_RATE_CAPABILITIES;
10315 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10316 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10317 break;
10318
0edd5b44 10319 default: /* Mixed or 2.4Ghz */
43f66a6c
JK		 10320 rates->ieee_mode = IPW_G_MODE;
10321 rates->purpose = IPW_RATE_CAPABILITIES;
10322 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10323 IEEE80211_CCK_DEFAULT_RATES_MASK);
10324 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10325 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10326 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10327 }
10328 break;
10329 }
10330
10331 return 0;
10332}
10333
bf79451e 10334static int ipw_config(struct ipw_priv *priv)
43f66a6c 10335{
43f66a6c
JK		 10336 /* This is only called from ipw_up, which resets/reloads the firmware
10337 so, we don't need to first disable the card before we configure
10338 it */
6de9f7f2 10339 if (ipw_set_tx_power(priv))
43f66a6c
JK		 10340 goto error;
10341
10342 /* initialize adapter address */
10343 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10344 goto error;
10345
10346 /* set basic system config settings */
10347 init_sys_config(&priv->sys_config);
810dabd4
ZY		 10348
10349 /* Support Bluetooth if we have BT h/w on board, and user wants to.
10350 * Does not support BT priority yet (don't abort or defer our Tx) */
10351 if (bt_coexist) {
2638bc39 10352 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
810dabd4
ZY		 10353
10354 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10355 priv->sys_config.bt_coexistence
2638bc39 10356 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
810dabd4
ZY		 10357 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10358 priv->sys_config.bt_coexistence
2638bc39 10359 |= CFG_BT_COEXISTENCE_OOB;
810dabd4
ZY		 10360 }
10361
c848d0af
JK		 10362 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10363 priv->sys_config.answer_broadcast_ssid_probe = 1;
10364 else
10365 priv->sys_config.answer_broadcast_ssid_probe = 0;
10366
43f66a6c
JK		 10367 if (ipw_send_system_config(priv, &priv->sys_config))
10368 goto error;
10369
0edd5b44
JG		 10370 init_supported_rates(priv, &priv->rates);
10371 if (ipw_send_supported_rates(priv, &priv->rates))
43f66a6c
JK		 10372 goto error;
10373
10374 /* Set request-to-send threshold */
10375 if (priv->rts_threshold) {
10376 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10377 goto error;
10378 }
b095c381
JK		 10379#ifdef CONFIG_IPW_QOS
10380 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10381 ipw_qos_activate(priv, NULL);
10382#endif /* CONFIG_IPW_QOS */
43f66a6c
JK		 10383
10384 if (ipw_set_random_seed(priv))
10385 goto error;
bf79451e 10386
43f66a6c
JK		 10387 /* final state transition to the RUN state */
10388 if (ipw_send_host_complete(priv))
10389 goto error;
10390
e666619e
JK		 10391 priv->status |= STATUS_INIT;
10392
10393 ipw_led_init(priv);
10394 ipw_led_radio_on(priv);
10395 priv->notif_missed_beacons = 0;
10396
10397 /* Set hardware WEP key if it is configured. */
10398 if ((priv->capability & CAP_PRIVACY_ON) &&
10399 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10400 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10401 ipw_set_hwcrypto_keys(priv);
43f66a6c
JK		 10402
10403 return 0;
bf79451e 10404
0edd5b44 10405 error:
43f66a6c
JK		 10406 return -EIO;
10407}
10408
4f36f808
JK		 10409/*
10410 * NOTE:
10411 *
10412 * These tables have been tested in conjunction with the
10413 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10414 *
10415 * Altering this values, using it on other hardware, or in geographies
10416 * not intended for resale of the above mentioned Intel adapters has
10417 * not been tested.
10418 *
48a84770
HBA		 10419 * Remember to update the table in README.ipw2200 when changing this
10420 * table.
10421 *
4f36f808
JK		 10422 */
10423static const struct ieee80211_geo ipw_geos[] = {
10424 { /* Restricted */
10425 "---",
10426 .bg_channels = 11,
10427 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10428 {2427, 4}, {2432, 5}, {2437, 6},
10429 {2442, 7}, {2447, 8}, {2452, 9},
10430 {2457, 10}, {2462, 11}},
10431 },
10432
10433 { /* Custom US/Canada */
10434 "ZZF",
10435 .bg_channels = 11,
10436 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10437 {2427, 4}, {2432, 5}, {2437, 6},
10438 {2442, 7}, {2447, 8}, {2452, 9},
10439 {2457, 10}, {2462, 11}},
10440 .a_channels = 8,
10441 .a = {{5180, 36},
10442 {5200, 40},
10443 {5220, 44},
10444 {5240, 48},
10445 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10446 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10447 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10448 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10449 },
10450
10451 { /* Rest of World */
10452 "ZZD",
10453 .bg_channels = 13,
10454 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10455 {2427, 4}, {2432, 5}, {2437, 6},
10456 {2442, 7}, {2447, 8}, {2452, 9},
10457 {2457, 10}, {2462, 11}, {2467, 12},
10458 {2472, 13}},
10459 },
10460
10461 { /* Custom USA & Europe & High */
10462 "ZZA",
10463 .bg_channels = 11,
10464 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10465 {2427, 4}, {2432, 5}, {2437, 6},
10466 {2442, 7}, {2447, 8}, {2452, 9},
10467 {2457, 10}, {2462, 11}},
10468 .a_channels = 13,
10469 .a = {{5180, 36},
10470 {5200, 40},
10471 {5220, 44},
10472 {5240, 48},
10473 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10474 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10475 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10476 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10477 {5745, 149},
10478 {5765, 153},
10479 {5785, 157},
10480 {5805, 161},
10481 {5825, 165}},
10482 },
10483
10484 { /* Custom NA & Europe */
10485 "ZZB",
10486 .bg_channels = 11,
10487 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10488 {2427, 4}, {2432, 5}, {2437, 6},
10489 {2442, 7}, {2447, 8}, {2452, 9},
10490 {2457, 10}, {2462, 11}},
10491 .a_channels = 13,
10492 .a = {{5180, 36},
10493 {5200, 40},
10494 {5220, 44},
10495 {5240, 48},
10496 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10497 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10498 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10499 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10500 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10501 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10502 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10503 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10504 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10505 },
10506
10507 { /* Custom Japan */
10508 "ZZC",
10509 .bg_channels = 11,
10510 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10511 {2427, 4}, {2432, 5}, {2437, 6},
10512 {2442, 7}, {2447, 8}, {2452, 9},
10513 {2457, 10}, {2462, 11}},
10514 .a_channels = 4,
10515 .a = {{5170, 34}, {5190, 38},
10516 {5210, 42}, {5230, 46}},
10517 },
10518
10519 { /* Custom */
10520 "ZZM",
10521 .bg_channels = 11,
10522 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10523 {2427, 4}, {2432, 5}, {2437, 6},
10524 {2442, 7}, {2447, 8}, {2452, 9},
10525 {2457, 10}, {2462, 11}},
10526 },
10527
10528 { /* Europe */
10529 "ZZE",
10530 .bg_channels = 13,
10531 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10532 {2427, 4}, {2432, 5}, {2437, 6},
10533 {2442, 7}, {2447, 8}, {2452, 9},
10534 {2457, 10}, {2462, 11}, {2467, 12},
10535 {2472, 13}},
10536 .a_channels = 19,
10537 .a = {{5180, 36},
10538 {5200, 40},
10539 {5220, 44},
10540 {5240, 48},
10541 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10542 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10543 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10544 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10545 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10546 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10547 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10548 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10549 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10550 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10551 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10552 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10553 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10554 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10555 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10556 },
10557
10558 { /* Custom Japan */
10559 "ZZJ",
10560 .bg_channels = 14,
10561 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10562 {2427, 4}, {2432, 5}, {2437, 6},
10563 {2442, 7}, {2447, 8}, {2452, 9},
10564 {2457, 10}, {2462, 11}, {2467, 12},
10565 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10566 .a_channels = 4,
10567 .a = {{5170, 34}, {5190, 38},
10568 {5210, 42}, {5230, 46}},
10569 },
10570
03520576
JK		 10571 { /* Rest of World */
10572 "ZZR",
10573 .bg_channels = 14,
10574 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10575 {2427, 4}, {2432, 5}, {2437, 6},
10576 {2442, 7}, {2447, 8}, {2452, 9},
10577 {2457, 10}, {2462, 11}, {2467, 12},
10578 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10579 IEEE80211_CH_PASSIVE_ONLY}},
10580 },
10581
4f36f808
JK		 10582 { /* High Band */
10583 "ZZH",
10584 .bg_channels = 13,
10585 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10586 {2427, 4}, {2432, 5}, {2437, 6},
10587 {2442, 7}, {2447, 8}, {2452, 9},
10588 {2457, 10}, {2462, 11},
10589 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10590 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10591 .a_channels = 4,
10592 .a = {{5745, 149}, {5765, 153},
10593 {5785, 157}, {5805, 161}},
10594 },
10595
10596 { /* Custom Europe */
10597 "ZZG",
10598 .bg_channels = 13,
10599 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10600 {2427, 4}, {2432, 5}, {2437, 6},
10601 {2442, 7}, {2447, 8}, {2452, 9},
10602 {2457, 10}, {2462, 11},
10603 {2467, 12}, {2472, 13}},
10604 .a_channels = 4,
10605 .a = {{5180, 36}, {5200, 40},
10606 {5220, 44}, {5240, 48}},
10607 },
10608
10609 { /* Europe */
10610 "ZZK",
10611 .bg_channels = 13,
10612 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10613 {2427, 4}, {2432, 5}, {2437, 6},
10614 {2442, 7}, {2447, 8}, {2452, 9},
10615 {2457, 10}, {2462, 11},
10616 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10617 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10618 .a_channels = 24,
10619 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10620 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10621 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10622 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10623 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10624 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10625 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10626 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10627 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10628 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10629 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10630 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10631 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10632 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10633 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10634 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10635 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10636 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10637 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10638 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10639 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10640 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10641 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10642 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10643 },
10644
10645 { /* Europe */
10646 "ZZL",
10647 .bg_channels = 11,
10648 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10649 {2427, 4}, {2432, 5}, {2437, 6},
10650 {2442, 7}, {2447, 8}, {2452, 9},
10651 {2457, 10}, {2462, 11}},
10652 .a_channels = 13,
10653 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10654 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10655 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10656 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10657 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10658 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10659 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10660 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10661 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10662 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10663 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10664 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10665 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10666 }
afbf30a2
JK		 10667};
10668
43f66a6c
JK		 10669#define MAX_HW_RESTARTS 5
10670static int ipw_up(struct ipw_priv *priv)
10671{
4f36f808 10672 int rc, i, j;
43f66a6c
JK		 10673
10674 if (priv->status & STATUS_EXIT_PENDING)
10675 return -EIO;
10676
f6c5cb7c
JK		 10677 if (cmdlog && !priv->cmdlog) {
10678 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10679 GFP_KERNEL);
10680 if (priv->cmdlog == NULL) {
10681 IPW_ERROR("Error allocating %d command log entries.\n",
10682 cmdlog);
10683 } else {
10684 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10685 priv->cmdlog_len = cmdlog;
10686 }
10687 }
10688
0edd5b44 10689 for (i = 0; i < MAX_HW_RESTARTS; i++) {
bf79451e 10690 /* Load the microcode, firmware, and eeprom.
43f66a6c
JK		 10691 * Also start the clocks. */
10692 rc = ipw_load(priv);
10693 if (rc) {
a4f6bbb3 10694 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 10695 return rc;
10696 }
10697
10698 ipw_init_ordinals(priv);
10699 if (!(priv->config & CFG_CUSTOM_MAC))
10700 eeprom_parse_mac(priv, priv->mac_addr);
10701 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10702
4f36f808
JK		 10703 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10704 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10705 ipw_geos[j].name, 3))
10706 break;
10707 }
03520576
JK		 10708 if (j == ARRAY_SIZE(ipw_geos)) {
10709 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10710 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10711 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10712 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
4f36f808 10713 j = 0;
03520576 10714 }
1867b117 10715 if (ieee80211_set_geo(priv->ieee, &ipw_geos[j])) {
4f36f808
JK		 10716 IPW_WARNING("Could not set geography.");
10717 return 0;
10718 }
10719
b095c381
JK		 10720 if (priv->status & STATUS_RF_KILL_SW) {
10721 IPW_WARNING("Radio disabled by module parameter.\n");
10722 return 0;
10723 } else if (rf_kill_active(priv)) {
10724 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10725 "Kill switch must be turned off for "
10726 "wireless networking to work.\n");
10727 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10728 2 * HZ);
43f66a6c 10729 return 0;
c848d0af 10730 }
43f66a6c
JK		 10731
10732 rc = ipw_config(priv);
10733 if (!rc) {
10734 IPW_DEBUG_INFO("Configured device on count %i\n", i);
e666619e
JK		 10735
10736 /* If configure to try and auto-associate, kick
10737 * off a scan. */
10738 queue_work(priv->workqueue, &priv->request_scan);
afbf30a2 10739
43f66a6c 10740 return 0;
43f66a6c 10741 }
bf79451e 10742
c848d0af 10743 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
43f66a6c
JK		 10744 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10745 i, MAX_HW_RESTARTS);
10746
10747 /* We had an error bringing up the hardware, so take it
10748 * all the way back down so we can try again */
10749 ipw_down(priv);
10750 }
10751
bf79451e 10752 /* tried to restart and config the device for as long as our
43f66a6c 10753 * patience could withstand */
0edd5b44 10754 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
c848d0af 10755
43f66a6c
JK		 10756 return -EIO;
10757}
10758
c848d0af
JK		 10759static void ipw_bg_up(void *data)
10760{
10761 struct ipw_priv *priv = data;
4644151b 10762 mutex_lock(&priv->mutex);
c848d0af 10763 ipw_up(data);
4644151b 10764 mutex_unlock(&priv->mutex);
c848d0af
JK		 10765}
10766
b095c381 10767static void ipw_deinit(struct ipw_priv *priv)
43f66a6c 10768{
b095c381
JK		 10769 int i;
10770
10771 if (priv->status & STATUS_SCANNING) {
10772 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10773 ipw_abort_scan(priv);
10774 }
10775
10776 if (priv->status & STATUS_ASSOCIATED) {
10777 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10778 ipw_disassociate(priv);
10779 }
10780
10781 ipw_led_shutdown(priv);
10782
10783 /* Wait up to 1s for status to change to not scanning and not
10784 * associated (disassociation can take a while for a ful 802.11
10785 * exchange */
10786 for (i = 1000; i && (priv->status &
10787 (STATUS_DISASSOCIATING |
10788 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10789 udelay(10);
10790
10791 if (priv->status & (STATUS_DISASSOCIATING |
10792 STATUS_ASSOCIATED | STATUS_SCANNING))
10793 IPW_DEBUG_INFO("Still associated or scanning...\n");
10794 else
10795 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10796
43f66a6c 10797 /* Attempt to disable the card */
43f66a6c 10798 ipw_send_card_disable(priv, 0);
b095c381
JK		 10799
10800 priv->status &= ~STATUS_INIT;
10801}
10802
10803static void ipw_down(struct ipw_priv *priv)
10804{
10805 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10806
10807 priv->status |= STATUS_EXIT_PENDING;
10808
10809 if (ipw_is_init(priv))
10810 ipw_deinit(priv);
10811
10812 /* Wipe out the EXIT_PENDING status bit if we are not actually
10813 * exiting the module */
10814 if (!exit_pending)
10815 priv->status &= ~STATUS_EXIT_PENDING;
43f66a6c
JK		 10816
10817 /* tell the device to stop sending interrupts */
10818 ipw_disable_interrupts(priv);
10819
10820 /* Clear all bits but the RF Kill */
b095c381 10821 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
43f66a6c
JK		 10822 netif_carrier_off(priv->net_dev);
10823 netif_stop_queue(priv->net_dev);
10824
10825 ipw_stop_nic(priv);
a613bffd
JK		 10826
10827 ipw_led_radio_off(priv);
43f66a6c
JK		 10828}
10829
c848d0af
JK		 10830static void ipw_bg_down(void *data)
10831{
10832 struct ipw_priv *priv = data;
4644151b 10833 mutex_lock(&priv->mutex);
c848d0af 10834 ipw_down(data);
4644151b 10835 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10836}
10837
10838/* Called by register_netdev() */
10839static int ipw_net_init(struct net_device *dev)
10840{
10841 struct ipw_priv *priv = ieee80211_priv(dev);
4644151b 10842 mutex_lock(&priv->mutex);
43f66a6c 10843
c848d0af 10844 if (ipw_up(priv)) {
4644151b 10845 mutex_unlock(&priv->mutex);
43f66a6c 10846 return -EIO;
c848d0af 10847 }
43f66a6c 10848
4644151b 10849 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10850 return 0;
10851}
10852
10853/* PCI driver stuff */
10854static struct pci_device_id card_ids[] = {
10855 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10856 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10857 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10858 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10859 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10860 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10861 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10862 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10863 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10864 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10865 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10866 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10867 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10868 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10869 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10870 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10871 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10872 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
0edd5b44 10873 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
a613bffd 10874 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
0edd5b44
JG		 10875 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10876 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
bf79451e 10877
43f66a6c
JK		 10878 /* required last entry */
10879 {0,}
10880};
10881
10882MODULE_DEVICE_TABLE(pci, card_ids);
10883
10884static struct attribute *ipw_sysfs_entries[] = {
10885 &dev_attr_rf_kill.attr,
10886 &dev_attr_direct_dword.attr,
10887 &dev_attr_indirect_byte.attr,
10888 &dev_attr_indirect_dword.attr,
10889 &dev_attr_mem_gpio_reg.attr,
10890 &dev_attr_command_event_reg.attr,
10891 &dev_attr_nic_type.attr,
10892 &dev_attr_status.attr,
10893 &dev_attr_cfg.attr,
b39860c6
JK		 10894 &dev_attr_error.attr,
10895 &dev_attr_event_log.attr,
f6c5cb7c 10896 &dev_attr_cmd_log.attr,
43f66a6c
JK		 10897 &dev_attr_eeprom_delay.attr,
10898 &dev_attr_ucode_version.attr,
10899 &dev_attr_rtc.attr,
a613bffd
JK		 10900 &dev_attr_scan_age.attr,
10901 &dev_attr_led.attr,
b095c381
JK		 10902 &dev_attr_speed_scan.attr,
10903 &dev_attr_net_stats.attr,
43f66a6c
JK		 10904 NULL
10905};
10906
10907static struct attribute_group ipw_attribute_group = {
10908 .name = NULL, /* put in device directory */
0edd5b44 10909 .attrs = ipw_sysfs_entries,
43f66a6c
JK		 10910};
10911
0edd5b44 10912static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
43f66a6c
JK		 10913{
10914 int err = 0;
10915 struct net_device *net_dev;
10916 void __iomem *base;
10917 u32 length, val;
10918 struct ipw_priv *priv;
afbf30a2 10919 int i;
43f66a6c
JK		 10920
10921 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10922 if (net_dev == NULL) {
10923 err = -ENOMEM;
10924 goto out;
10925 }
10926
10927 priv = ieee80211_priv(net_dev);
10928 priv->ieee = netdev_priv(net_dev);
a613bffd 10929
43f66a6c
JK		 10930 priv->net_dev = net_dev;
10931 priv->pci_dev = pdev;
0f52bf90 10932#ifdef CONFIG_IPW2200_DEBUG
43f66a6c
JK		 10933 ipw_debug_level = debug;
10934#endif
10935 spin_lock_init(&priv->lock);
afbf30a2
JK		 10936 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10937 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
43f66a6c 10938
4644151b 10939 mutex_init(&priv->mutex);
43f66a6c
JK		 10940 if (pci_enable_device(pdev)) {
10941 err = -ENODEV;
10942 goto out_free_ieee80211;
10943 }
10944
10945 pci_set_master(pdev);
10946
0e08b44e 10947 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
bf79451e 10948 if (!err)
0e08b44e 10949 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
43f66a6c
JK		 10950 if (err) {
10951 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10952 goto out_pci_disable_device;
10953 }
10954
10955 pci_set_drvdata(pdev, priv);
10956
10957 err = pci_request_regions(pdev, DRV_NAME);
bf79451e 10958 if (err)
43f66a6c
JK		 10959 goto out_pci_disable_device;
10960
bf79451e 10961 /* We disable the RETRY_TIMEOUT register (0x41) to keep
43f66a6c 10962 * PCI Tx retries from interfering with C3 CPU state */
bf79451e
JG		 10963 pci_read_config_dword(pdev, 0x40, &val);
10964 if ((val & 0x0000ff00) != 0)
43f66a6c 10965 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
bf79451e 10966
43f66a6c
JK		 10967 length = pci_resource_len(pdev, 0);
10968 priv->hw_len = length;
bf79451e 10969
43f66a6c
JK		 10970 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10971 if (!base) {
10972 err = -ENODEV;
10973 goto out_pci_release_regions;
10974 }
10975
10976 priv->hw_base = base;
10977 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
10978 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
10979
10980 err = ipw_setup_deferred_work(priv);
10981 if (err) {
10982 IPW_ERROR("Unable to setup deferred work\n");
10983 goto out_iounmap;
10984 }
10985
b095c381 10986 ipw_sw_reset(priv, 1);
43f66a6c 10987
0edd5b44 10988 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
43f66a6c
JK		 10989 if (err) {
10990 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
10991 goto out_destroy_workqueue;
10992 }
10993
10994 SET_MODULE_OWNER(net_dev);
10995 SET_NETDEV_DEV(net_dev, &pdev->dev);
10996
4644151b 10997 mutex_lock(&priv->mutex);
c848d0af 10998
43f66a6c
JK		 10999 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11000 priv->ieee->set_security = shim__set_security;
227d2dc1 11001 priv->ieee->is_queue_full = ipw_net_is_queue_full;
43f66a6c 11002
b095c381 11003#ifdef CONFIG_IPW_QOS
3b9990cb
JK		 11004 priv->ieee->handle_probe_response = ipw_handle_beacon;
11005 priv->ieee->handle_beacon = ipw_handle_probe_response;
11006 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
b095c381
JK		 11007#endif /* CONFIG_IPW_QOS */
11008
c848d0af
JK		 11009 priv->ieee->perfect_rssi = -20;
11010 priv->ieee->worst_rssi = -85;
43f66a6c
JK		 11011
11012 net_dev->open = ipw_net_open;
11013 net_dev->stop = ipw_net_stop;
11014 net_dev->init = ipw_net_init;
11015 net_dev->get_stats = ipw_net_get_stats;
11016 net_dev->set_multicast_list = ipw_net_set_multicast_list;
11017 net_dev->set_mac_address = ipw_net_set_mac_address;
97a78ca9 11018 priv->wireless_data.spy_data = &priv->ieee->spy_data;
97a78ca9 11019 net_dev->wireless_data = &priv->wireless_data;
43f66a6c
JK		 11020 net_dev->wireless_handlers = &ipw_wx_handler_def;
11021 net_dev->ethtool_ops = &ipw_ethtool_ops;
11022 net_dev->irq = pdev->irq;
0edd5b44 11023 net_dev->base_addr = (unsigned long)priv->hw_base;
43f66a6c
JK		 11024 net_dev->mem_start = pci_resource_start(pdev, 0);
11025 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11026
11027 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11028 if (err) {
11029 IPW_ERROR("failed to create sysfs device attributes\n");
4644151b 11030 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11031 goto out_release_irq;
11032 }
11033
4644151b 11034 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11035 err = register_netdev(net_dev);
11036 if (err) {
11037 IPW_ERROR("failed to register network device\n");
a613bffd 11038 goto out_remove_sysfs;
43f66a6c 11039 }
48a84770
HBA		 11040
11041 printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
11042 "channels, %d 802.11a channels)\n",
11043 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
11044 priv->ieee->geo.a_channels);
11045
43f66a6c
JK		 11046 return 0;
11047
a613bffd 11048 out_remove_sysfs:
43f66a6c 11049 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
0edd5b44 11050 out_release_irq:
43f66a6c 11051 free_irq(pdev->irq, priv);
0edd5b44 11052 out_destroy_workqueue:
43f66a6c
JK		 11053 destroy_workqueue(priv->workqueue);
11054 priv->workqueue = NULL;
0edd5b44 11055 out_iounmap:
43f66a6c 11056 iounmap(priv->hw_base);
0edd5b44 11057 out_pci_release_regions:
43f66a6c 11058 pci_release_regions(pdev);
0edd5b44 11059 out_pci_disable_device:
43f66a6c
JK		 11060 pci_disable_device(pdev);
11061 pci_set_drvdata(pdev, NULL);
0edd5b44 11062 out_free_ieee80211:
43f66a6c 11063 free_ieee80211(priv->net_dev);
0edd5b44 11064 out:
43f66a6c
JK		 11065 return err;
11066}
11067
11068static void ipw_pci_remove(struct pci_dev *pdev)
11069{
11070 struct ipw_priv *priv = pci_get_drvdata(pdev);
afbf30a2
JK		 11071 struct list_head *p, *q;
11072 int i;
b095c381 11073
43f66a6c
JK		 11074 if (!priv)
11075 return;
11076
4644151b 11077 mutex_lock(&priv->mutex);
43f66a6c 11078
afbf30a2 11079 priv->status |= STATUS_EXIT_PENDING;
43f66a6c 11080 ipw_down(priv);
43f66a6c
JK		 11081 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11082
4644151b 11083 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11084
11085 unregister_netdev(priv->net_dev);
11086
11087 if (priv->rxq) {
11088 ipw_rx_queue_free(priv, priv->rxq);
11089 priv->rxq = NULL;
11090 }
11091 ipw_tx_queue_free(priv);
11092
f6c5cb7c
JK		 11093 if (priv->cmdlog) {
11094 kfree(priv->cmdlog);
11095 priv->cmdlog = NULL;
11096 }
43f66a6c
JK		 11097 /* ipw_down will ensure that there is no more pending work
11098 * in the workqueue's, so we can safely remove them now. */
a613bffd
JK		 11099 cancel_delayed_work(&priv->adhoc_check);
11100 cancel_delayed_work(&priv->gather_stats);
11101 cancel_delayed_work(&priv->request_scan);
11102 cancel_delayed_work(&priv->rf_kill);
11103 cancel_delayed_work(&priv->scan_check);
11104 destroy_workqueue(priv->workqueue);
11105 priv->workqueue = NULL;
43f66a6c 11106
afbf30a2
JK		 11107 /* Free MAC hash list for ADHOC */
11108 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11109 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
afbf30a2 11110 list_del(p);
489f4458 11111 kfree(list_entry(p, struct ipw_ibss_seq, list));
afbf30a2
JK		 11112 }
11113 }
11114
b39860c6
JK		 11115 if (priv->error) {
11116 ipw_free_error_log(priv->error);
11117 priv->error = NULL;
43f66a6c
JK		 11118 }
11119
11120 free_irq(pdev->irq, priv);
11121 iounmap(priv->hw_base);
11122 pci_release_regions(pdev);
11123 pci_disable_device(pdev);
11124 pci_set_drvdata(pdev, NULL);
11125 free_ieee80211(priv->net_dev);
afbf30a2 11126 free_firmware();
43f66a6c
JK		 11127}
11128
43f66a6c 11129#ifdef CONFIG_PM
583a4e88 11130static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
43f66a6c
JK		 11131{
11132 struct ipw_priv *priv = pci_get_drvdata(pdev);
11133 struct net_device *dev = priv->net_dev;
11134
11135 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11136
0edd5b44 11137 /* Take down the device; powers it off, etc. */
43f66a6c
JK		 11138 ipw_down(priv);
11139
11140 /* Remove the PRESENT state of the device */
11141 netif_device_detach(dev);
11142
43f66a6c 11143 pci_save_state(pdev);
43f66a6c 11144 pci_disable_device(pdev);
583a4e88 11145 pci_set_power_state(pdev, pci_choose_state(pdev, state));
bf79451e 11146
43f66a6c
JK		 11147 return 0;
11148}
11149
11150static int ipw_pci_resume(struct pci_dev *pdev)
11151{
11152 struct ipw_priv *priv = pci_get_drvdata(pdev);
11153 struct net_device *dev = priv->net_dev;
11154 u32 val;
bf79451e 11155
43f66a6c
JK		 11156 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11157
ea2b26e0 11158 pci_set_power_state(pdev, PCI_D0);
43f66a6c 11159 pci_enable_device(pdev);
43f66a6c 11160 pci_restore_state(pdev);
ea2b26e0 11161
43f66a6c
JK		 11162 /*
11163 * Suspend/Resume resets the PCI configuration space, so we have to
11164 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11165 * from interfering with C3 CPU state. pci_restore_state won't help
11166 * here since it only restores the first 64 bytes pci config header.
11167 */
bf79451e
JG		 11168 pci_read_config_dword(pdev, 0x40, &val);
11169 if ((val & 0x0000ff00) != 0)
43f66a6c
JK		 11170 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11171
11172 /* Set the device back into the PRESENT state; this will also wake
11173 * the queue of needed */
11174 netif_device_attach(dev);
11175
11176 /* Bring the device back up */
11177 queue_work(priv->workqueue, &priv->up);
bf79451e 11178
43f66a6c
JK		 11179 return 0;
11180}
11181#endif
11182
11183/* driver initialization stuff */
11184static struct pci_driver ipw_driver = {
11185 .name = DRV_NAME,
11186 .id_table = card_ids,
11187 .probe = ipw_pci_probe,
11188 .remove = __devexit_p(ipw_pci_remove),
11189#ifdef CONFIG_PM
11190 .suspend = ipw_pci_suspend,
11191 .resume = ipw_pci_resume,
11192#endif
11193};
11194
11195static int __init ipw_init(void)
11196{
11197 int ret;
11198
11199 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11200 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11201
11202 ret = pci_module_init(&ipw_driver);
11203 if (ret) {
11204 IPW_ERROR("Unable to initialize PCI module\n");
11205 return ret;
11206 }
11207
0edd5b44 11208 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
43f66a6c
JK		 11209 if (ret) {
11210 IPW_ERROR("Unable to create driver sysfs file\n");
11211 pci_unregister_driver(&ipw_driver);
11212 return ret;
11213 }
11214
11215 return ret;
11216}
11217
11218static void __exit ipw_exit(void)
11219{
11220 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11221 pci_unregister_driver(&ipw_driver);
11222}
11223
11224module_param(disable, int, 0444);
11225MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11226
11227module_param(associate, int, 0444);
11228MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11229
11230module_param(auto_create, int, 0444);
11231MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11232
a613bffd 11233module_param(led, int, 0444);
c848d0af 11234MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
a613bffd 11235
3e1555ba 11236#ifdef CONFIG_IPW2200_DEBUG
43f66a6c
JK		 11237module_param(debug, int, 0444);
11238MODULE_PARM_DESC(debug, "debug output mask");
3e1555ba 11239#endif
43f66a6c
JK		 11240
11241module_param(channel, int, 0444);
bf79451e 11242MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
43f66a6c 11243
b095c381
JK		 11244#ifdef CONFIG_IPW_QOS
11245module_param(qos_enable, int, 0444);
11246MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11247
11248module_param(qos_burst_enable, int, 0444);
11249MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11250
11251module_param(qos_no_ack_mask, int, 0444);
11252MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
43f66a6c 11253
b095c381
JK		 11254module_param(burst_duration_CCK, int, 0444);
11255MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11256
11257module_param(burst_duration_OFDM, int, 0444);
11258MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11259#endif /* CONFIG_IPW_QOS */
11260
11261#ifdef CONFIG_IPW2200_MONITOR
43f66a6c
JK		 11262module_param(mode, int, 0444);
11263MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11264#else
11265module_param(mode, int, 0444);
11266MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11267#endif
11268
810dabd4
ZY		 11269module_param(bt_coexist, int, 0444);
11270MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
11271
b095c381 11272module_param(hwcrypto, int, 0444);
bde37d03 11273MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
b095c381 11274
f6c5cb7c
JK		 11275module_param(cmdlog, int, 0444);
11276MODULE_PARM_DESC(cmdlog,
11277 "allocate a ring buffer for logging firmware commands");
11278
4bfdb91d
ZY		 11279module_param(roaming, int, 0444);
11280MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
11281
43f66a6c
JK		 11282module_exit(ipw_exit);
11283module_init(ipw_init);
kernel source for telekom puls (alcatel/mediatek)