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