]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/net/wireless/ipw2x00/ipw2200.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[net-next-2.6.git] / drivers / net / wireless / ipw2x00 / ipw2200.c
CommitLineData
43f66a6c 1/******************************************************************************
bf79451e 2
171e7b2f 3 Copyright(c) 2003 - 2006 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 27 Contact Information:
c1eb2c82 28 Intel Linux Wireless <ilw@linux.intel.com>
43f66a6c
JK		 29 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30
31******************************************************************************/
32
d43c36dc 33#include <linux/sched.h>
5a0e3ad6 34#include <linux/slab.h>
43f66a6c
JK		 35#include "ipw2200.h"
36
ae4af61f
ZY		 37
38#ifndef KBUILD_EXTMOD
39#define VK "k"
40#else
41#define VK
42#endif
43
44#ifdef CONFIG_IPW2200_DEBUG
45#define VD "d"
46#else
47#define VD
48#endif
49
50#ifdef CONFIG_IPW2200_MONITOR
51#define VM "m"
52#else
53#define VM
54#endif
55
56#ifdef CONFIG_IPW2200_PROMISCUOUS
57#define VP "p"
58#else
59#define VP
60#endif
61
459d4087 62#ifdef CONFIG_IPW2200_RADIOTAP
ae4af61f
ZY		 63#define VR "r"
64#else
65#define VR
66#endif
67
68#ifdef CONFIG_IPW2200_QOS
69#define VQ "q"
70#else
71#define VQ
72#endif
73
ee2c4add 74#define IPW2200_VERSION "1.2.2" VK VD VM VP VR VQ
43f66a6c 75#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
171e7b2f 76#define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
43f66a6c
JK		 77#define DRV_VERSION IPW2200_VERSION
78
b095c381
JK		 79#define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
80
43f66a6c
JK		 81MODULE_DESCRIPTION(DRV_DESCRIPTION);
82MODULE_VERSION(DRV_VERSION);
83MODULE_AUTHOR(DRV_COPYRIGHT);
84MODULE_LICENSE("GPL");
873395a9
BH		 85MODULE_FIRMWARE("ipw2200-ibss.fw");
86#ifdef CONFIG_IPW2200_MONITOR
87MODULE_FIRMWARE("ipw2200-sniffer.fw");
88#endif
89MODULE_FIRMWARE("ipw2200-bss.fw");
43f66a6c 90
f6c5cb7c 91static int cmdlog = 0;
43f66a6c 92static int debug = 0;
21f8a73f
RC		 93static int default_channel = 0;
94static int network_mode = 0;
43f66a6c
JK		 95
96static u32 ipw_debug_level;
5c7f9b73 97static int associate;
43f66a6c 98static int auto_create = 1;
c086abae 99static int led_support = 1;
43f66a6c 100static int disable = 0;
810dabd4 101static int bt_coexist = 0;
bde37d03 102static int hwcrypto = 0;
4bfdb91d 103static int roaming = 1;
43f66a6c
JK		 104static const char ipw_modes[] = {
105 'a', 'b', 'g', '?'
106};
d2b83e12 107static int antenna = CFG_SYS_ANTENNA_BOTH;
43f66a6c 108
d685b8c2
ZY		 109#ifdef CONFIG_IPW2200_PROMISCUOUS
110static int rtap_iface = 0; /* def: 0 -- do not create rtap interface */
111#endif
112
a3caa99e
JL		 113static struct ieee80211_rate ipw2200_rates[] = {
114 { .bitrate = 10 },
115 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
116 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
117 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
118 { .bitrate = 60 },
119 { .bitrate = 90 },
120 { .bitrate = 120 },
121 { .bitrate = 180 },
122 { .bitrate = 240 },
123 { .bitrate = 360 },
124 { .bitrate = 480 },
125 { .bitrate = 540 }
126};
127
128#define ipw2200_a_rates (ipw2200_rates + 4)
129#define ipw2200_num_a_rates 8
130#define ipw2200_bg_rates (ipw2200_rates + 0)
131#define ipw2200_num_bg_rates 12
d685b8c2 132
e43e3c1e 133#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 134static int qos_enable = 0;
135static int qos_burst_enable = 0;
136static int qos_no_ack_mask = 0;
137static int burst_duration_CCK = 0;
138static int burst_duration_OFDM = 0;
139
b0a4e7d8 140static struct libipw_qos_parameters def_qos_parameters_OFDM = {
b095c381
JK		 141 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
142 QOS_TX3_CW_MIN_OFDM},
143 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
144 QOS_TX3_CW_MAX_OFDM},
145 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
146 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
147 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
148 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
149};
150
b0a4e7d8 151static struct libipw_qos_parameters def_qos_parameters_CCK = {
b095c381
JK		 152 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
153 QOS_TX3_CW_MIN_CCK},
154 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
155 QOS_TX3_CW_MAX_CCK},
156 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
157 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
158 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
159 QOS_TX3_TXOP_LIMIT_CCK}
160};
161
b0a4e7d8 162static struct libipw_qos_parameters def_parameters_OFDM = {
b095c381
JK		 163 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
164 DEF_TX3_CW_MIN_OFDM},
165 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
166 DEF_TX3_CW_MAX_OFDM},
167 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
168 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
169 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
170 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
171};
172
b0a4e7d8 173static struct libipw_qos_parameters def_parameters_CCK = {
b095c381
JK		 174 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
175 DEF_TX3_CW_MIN_CCK},
176 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
177 DEF_TX3_CW_MAX_CCK},
178 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
179 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
180 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
181 DEF_TX3_TXOP_LIMIT_CCK}
182};
183
184static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
185
186static int from_priority_to_tx_queue[] = {
187 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
188 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
189};
190
191static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
192
b0a4e7d8 193static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
b095c381 194 *qos_param);
b0a4e7d8 195static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
b095c381 196 *qos_param);
e43e3c1e 197#endif /* CONFIG_IPW2200_QOS */
b095c381 198
97a78ca9 199static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
b095c381 200static void ipw_remove_current_network(struct ipw_priv *priv);
43f66a6c 201static void ipw_rx(struct ipw_priv *priv);
bf79451e 202static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
43f66a6c
JK		 203 struct clx2_tx_queue *txq, int qindex);
204static int ipw_queue_reset(struct ipw_priv *priv);
205
206static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
207 int len, int sync);
208
209static void ipw_tx_queue_free(struct ipw_priv *);
210
211static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
212static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
213static void ipw_rx_queue_replenish(void *);
43f66a6c 214static int ipw_up(struct ipw_priv *);
c4028958 215static void ipw_bg_up(struct work_struct *work);
43f66a6c 216static void ipw_down(struct ipw_priv *);
c4028958 217static void ipw_bg_down(struct work_struct *work);
43f66a6c 218static int ipw_config(struct ipw_priv *);
0edd5b44
JG		 219static int init_supported_rates(struct ipw_priv *priv,
220 struct ipw_supported_rates *prates);
b095c381
JK		 221static void ipw_set_hwcrypto_keys(struct ipw_priv *);
222static void ipw_send_wep_keys(struct ipw_priv *, int);
43f66a6c 223
f6c5cb7c
JK		 224static int snprint_line(char *buf, size_t count,
225 const u8 * data, u32 len, u32 ofs)
43f66a6c
JK		 226{
227 int out, i, j, l;
228 char c;
bf79451e 229
43f66a6c
JK		 230 out = snprintf(buf, count, "%08X", ofs);
231
232 for (l = 0, i = 0; i < 2; i++) {
233 out += snprintf(buf + out, count - out, " ");
bf79451e
JG		 234 for (j = 0; j < 8 && l < len; j++, l++)
235 out += snprintf(buf + out, count - out, "%02X ",
43f66a6c
JK		 236 data[(i * 8 + j)]);
237 for (; j < 8; j++)
238 out += snprintf(buf + out, count - out, " ");
239 }
bf79451e 240
43f66a6c
JK		 241 out += snprintf(buf + out, count - out, " ");
242 for (l = 0, i = 0; i < 2; i++) {
243 out += snprintf(buf + out, count - out, " ");
244 for (j = 0; j < 8 && l < len; j++, l++) {
245 c = data[(i * 8 + j)];
246 if (!isascii(c) || !isprint(c))
247 c = '.';
bf79451e 248
43f66a6c
JK		 249 out += snprintf(buf + out, count - out, "%c", c);
250 }
251
252 for (; j < 8; j++)
253 out += snprintf(buf + out, count - out, " ");
254 }
bf79451e 255
f6c5cb7c 256 return out;
43f66a6c
JK		 257}
258
0edd5b44 259static void printk_buf(int level, const u8 * data, u32 len)
43f66a6c
JK		 260{
261 char line[81];
262 u32 ofs = 0;
263 if (!(ipw_debug_level & level))
264 return;
265
266 while (len) {
f6c5cb7c
JK		 267 snprint_line(line, sizeof(line), &data[ofs],
268 min(len, 16U), ofs);
269 printk(KERN_DEBUG "%s\n", line);
43f66a6c
JK		 270 ofs += 16;
271 len -= min(len, 16U);
272 }
273}
274
f6c5cb7c
JK		 275static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
276{
277 size_t out = size;
278 u32 ofs = 0;
279 int total = 0;
280
281 while (size && len) {
282 out = snprint_line(output, size, &data[ofs],
283 min_t(size_t, len, 16U), ofs);
284
285 ofs += 16;
286 output += out;
287 size -= out;
288 len -= min_t(size_t, len, 16U);
289 total += out;
290 }
291 return total;
292}
293
c8fe6679 294/* alias for 32-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 295static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
296#define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
297
c8fe6679 298/* alias for 8-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 299static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
300#define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
301
c8fe6679 302/* 8-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 303static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
304static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
305{
0edd5b44
JG		 306 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
307 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 308 _ipw_write_reg8(a, b, c);
309}
310
c8fe6679 311/* 16-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 312static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
313static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
314{
0edd5b44
JG		 315 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
316 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 317 _ipw_write_reg16(a, b, c);
318}
319
c8fe6679 320/* 32-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 321static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
322static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
323{
0edd5b44
JG		 324 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
325 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 326 _ipw_write_reg32(a, b, c);
327}
328
c8fe6679 329/* 8-bit direct write (low 4K) */
1788bcd1
JS		 330static inline void _ipw_write8(struct ipw_priv *ipw, unsigned long ofs,
331 u8 val)
332{
333 writeb(val, ipw->hw_base + ofs);
334}
c8fe6679
ZY		 335
336/* 8-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
fb55d887 337#define ipw_write8(ipw, ofs, val) do { \
1788bcd1
JS		 338 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, \
339 __LINE__, (u32)(ofs), (u32)(val)); \
340 _ipw_write8(ipw, ofs, val); \
341} while (0)
43f66a6c 342
c8fe6679 343/* 16-bit direct write (low 4K) */
1788bcd1
JS		 344static inline void _ipw_write16(struct ipw_priv *ipw, unsigned long ofs,
345 u16 val)
346{
347 writew(val, ipw->hw_base + ofs);
348}
c8fe6679
ZY		 349
350/* 16-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 351#define ipw_write16(ipw, ofs, val) do { \
352 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, \
353 __LINE__, (u32)(ofs), (u32)(val)); \
354 _ipw_write16(ipw, ofs, val); \
355} while (0)
43f66a6c 356
c8fe6679 357/* 32-bit direct write (low 4K) */
1788bcd1
JS		 358static inline void _ipw_write32(struct ipw_priv *ipw, unsigned long ofs,
359 u32 val)
360{
361 writel(val, ipw->hw_base + ofs);
362}
c8fe6679
ZY		 363
364/* 32-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 365#define ipw_write32(ipw, ofs, val) do { \
366 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, \
367 __LINE__, (u32)(ofs), (u32)(val)); \
368 _ipw_write32(ipw, ofs, val); \
369} while (0)
43f66a6c 370
c8fe6679 371/* 8-bit direct read (low 4K) */
1788bcd1 372static inline u8 _ipw_read8(struct ipw_priv *ipw, unsigned long ofs)
0edd5b44 373{
1788bcd1 374 return readb(ipw->hw_base + ofs);
43f66a6c 375}
0edd5b44 376
c8fe6679 377/* alias to 8-bit direct read (low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 378#define ipw_read8(ipw, ofs) ({ \
379 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", __FILE__, __LINE__, \
380 (u32)(ofs)); \
381 _ipw_read8(ipw, ofs); \
382})
43f66a6c 383
c8fe6679 384/* 16-bit direct read (low 4K) */
1788bcd1 385static inline u16 _ipw_read16(struct ipw_priv *ipw, unsigned long ofs)
0edd5b44 386{
1788bcd1 387 return readw(ipw->hw_base + ofs);
43f66a6c 388}
0edd5b44 389
c8fe6679 390/* alias to 16-bit direct read (low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 391#define ipw_read16(ipw, ofs) ({ \
392 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", __FILE__, __LINE__, \
393 (u32)(ofs)); \
394 _ipw_read16(ipw, ofs); \
395})
43f66a6c 396
c8fe6679 397/* 32-bit direct read (low 4K) */
1788bcd1 398static inline u32 _ipw_read32(struct ipw_priv *ipw, unsigned long ofs)
0edd5b44 399{
1788bcd1 400 return readl(ipw->hw_base + ofs);
43f66a6c 401}
0edd5b44 402
c8fe6679 403/* alias to 32-bit direct read (low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 404#define ipw_read32(ipw, ofs) ({ \
405 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", __FILE__, __LINE__, \
406 (u32)(ofs)); \
407 _ipw_read32(ipw, ofs); \
408})
43f66a6c
JK		 409
410static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
c8fe6679 411/* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
1788bcd1
JS		 412#define ipw_read_indirect(a, b, c, d) ({ \
413 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %u bytes\n", __FILE__, \
414 __LINE__, (u32)(b), (u32)(d)); \
415 _ipw_read_indirect(a, b, c, d); \
416})
43f66a6c 417
c8fe6679 418/* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
0edd5b44
JG		 419static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
420 int num);
1788bcd1
JS		 421#define ipw_write_indirect(a, b, c, d) do { \
422 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %u bytes\n", __FILE__, \
423 __LINE__, (u32)(b), (u32)(d)); \
424 _ipw_write_indirect(a, b, c, d); \
425} while (0)
43f66a6c 426
c8fe6679 427/* 32-bit indirect write (above 4K) */
0edd5b44 428static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
43f66a6c 429{
0edd5b44 430 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
b095c381
JK		 431 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
432 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
43f66a6c
JK		 433}
434
c8fe6679 435/* 8-bit indirect write (above 4K) */
43f66a6c
JK		 436static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
437{
2638bc39 438 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
c8fe6679
ZY		 439 u32 dif_len = reg - aligned_addr;
440
43f66a6c 441 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
c8fe6679
ZY		 442 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
443 _ipw_write8(priv, IPW_INDIRECT_DATA + dif_len, value);
43f66a6c
JK		 444}
445
c8fe6679 446/* 16-bit indirect write (above 4K) */
0edd5b44 447static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
43f66a6c 448{
2638bc39 449 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
c8fe6679
ZY		 450 u32 dif_len = (reg - aligned_addr) & (~0x1ul);
451
43f66a6c 452 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
c8fe6679
ZY		 453 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
454 _ipw_write16(priv, IPW_INDIRECT_DATA + dif_len, value);
43f66a6c
JK		 455}
456
c8fe6679 457/* 8-bit indirect read (above 4K) */
43f66a6c
JK		 458static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
459{
460 u32 word;
b095c381 461 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
9fd1ea42 462 IPW_DEBUG_IO(" reg = 0x%8X :\n", reg);
b095c381 463 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
0edd5b44 464 return (word >> ((reg & 0x3) * 8)) & 0xff;
43f66a6c
JK		 465}
466
c8fe6679 467/* 32-bit indirect read (above 4K) */
43f66a6c
JK		 468static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
469{
470 u32 value;
471
472 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
473
b095c381
JK		 474 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
475 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
9fd1ea42 476 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x\n", reg, value);
43f66a6c
JK		 477 return value;
478}
479
c8fe6679
ZY		 480/* General purpose, no alignment requirement, iterative (multi-byte) read, */
481/* for area above 1st 4K of SRAM/reg space */
43f66a6c
JK		 482static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
483 int num)
484{
2638bc39 485 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
43f66a6c 486 u32 dif_len = addr - aligned_addr;
43f66a6c 487 u32 i;
bf79451e 488
43f66a6c
JK		 489 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
490
ea2b26e0
JK		 491 if (num <= 0) {
492 return;
493 }
494
c8fe6679 495 /* Read the first dword (or portion) byte by byte */
43f66a6c 496 if (unlikely(dif_len)) {
b095c381 497 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
43f66a6c 498 /* Start reading at aligned_addr + dif_len */
ea2b26e0 499 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
b095c381 500 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
43f66a6c
JK		 501 aligned_addr += 4;
502 }
503
c8fe6679 504 /* Read all of the middle dwords as dwords, with auto-increment */
b095c381 505 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
ea2b26e0 506 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
b095c381 507 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
bf79451e 508
c8fe6679 509 /* Read the last dword (or portion) byte by byte */
ea2b26e0 510 if (unlikely(num)) {
b095c381 511 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0 512 for (i = 0; num > 0; i++, num--)
b095c381 513 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
ea2b26e0 514 }
43f66a6c
JK		 515}
516
c8fe6679
ZY		 517/* General purpose, no alignment requirement, iterative (multi-byte) write, */
518/* for area above 1st 4K of SRAM/reg space */
0edd5b44 519static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
43f66a6c
JK		 520 int num)
521{
2638bc39 522 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
43f66a6c 523 u32 dif_len = addr - aligned_addr;
43f66a6c 524 u32 i;
bf79451e 525
43f66a6c 526 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
bf79451e 527
ea2b26e0
JK		 528 if (num <= 0) {
529 return;
530 }
531
c8fe6679 532 /* Write the first dword (or portion) byte by byte */
43f66a6c 533 if (unlikely(dif_len)) {
b095c381 534 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
c8fe6679 535 /* Start writing at aligned_addr + dif_len */
ea2b26e0 536 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
b095c381 537 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
43f66a6c
JK		 538 aligned_addr += 4;
539 }
bf79451e 540
c8fe6679 541 /* Write all of the middle dwords as dwords, with auto-increment */
b095c381 542 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
ea2b26e0 543 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
b095c381 544 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
bf79451e 545
c8fe6679 546 /* Write the last dword (or portion) byte by byte */
ea2b26e0 547 if (unlikely(num)) {
b095c381 548 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0 549 for (i = 0; num > 0; i++, num--, buf++)
b095c381 550 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
ea2b26e0 551 }
43f66a6c
JK		 552}
553
c8fe6679
ZY		 554/* General purpose, no alignment requirement, iterative (multi-byte) write, */
555/* for 1st 4K of SRAM/regs space */
bf79451e 556static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
43f66a6c
JK		 557 int num)
558{
559 memcpy_toio((priv->hw_base + addr), buf, num);
560}
561
c8fe6679 562/* Set bit(s) in low 4K of SRAM/regs */
43f66a6c
JK		 563static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
564{
565 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
566}
567
c8fe6679 568/* Clear bit(s) in low 4K of SRAM/regs */
43f66a6c
JK		 569static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
570{
571 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
572}
573
89c318ed 574static inline void __ipw_enable_interrupts(struct ipw_priv *priv)
43f66a6c
JK		 575{
576 if (priv->status & STATUS_INT_ENABLED)
577 return;
578 priv->status |= STATUS_INT_ENABLED;
b095c381 579 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
43f66a6c
JK		 580}
581
89c318ed 582static inline void __ipw_disable_interrupts(struct ipw_priv *priv)
43f66a6c
JK		 583{
584 if (!(priv->status & STATUS_INT_ENABLED))
585 return;
586 priv->status &= ~STATUS_INT_ENABLED;
b095c381 587 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
43f66a6c
JK		 588}
589
89c318ed
ZY		 590static inline void ipw_enable_interrupts(struct ipw_priv *priv)
591{
592 unsigned long flags;
593
594 spin_lock_irqsave(&priv->irq_lock, flags);
595 __ipw_enable_interrupts(priv);
596 spin_unlock_irqrestore(&priv->irq_lock, flags);
597}
598
599static inline void ipw_disable_interrupts(struct ipw_priv *priv)
600{
601 unsigned long flags;
602
603 spin_lock_irqsave(&priv->irq_lock, flags);
604 __ipw_disable_interrupts(priv);
605 spin_unlock_irqrestore(&priv->irq_lock, flags);
606}
607
43f66a6c
JK		 608static char *ipw_error_desc(u32 val)
609{
610 switch (val) {
bf79451e 611 case IPW_FW_ERROR_OK:
43f66a6c 612 return "ERROR_OK";
bf79451e 613 case IPW_FW_ERROR_FAIL:
43f66a6c 614 return "ERROR_FAIL";
bf79451e 615 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
43f66a6c 616 return "MEMORY_UNDERFLOW";
bf79451e 617 case IPW_FW_ERROR_MEMORY_OVERFLOW:
43f66a6c 618 return "MEMORY_OVERFLOW";
bf79451e 619 case IPW_FW_ERROR_BAD_PARAM:
b095c381 620 return "BAD_PARAM";
bf79451e 621 case IPW_FW_ERROR_BAD_CHECKSUM:
b095c381 622 return "BAD_CHECKSUM";
bf79451e 623 case IPW_FW_ERROR_NMI_INTERRUPT:
b095c381 624 return "NMI_INTERRUPT";
bf79451e 625 case IPW_FW_ERROR_BAD_DATABASE:
b095c381 626 return "BAD_DATABASE";
bf79451e 627 case IPW_FW_ERROR_ALLOC_FAIL:
b095c381 628 return "ALLOC_FAIL";
bf79451e 629 case IPW_FW_ERROR_DMA_UNDERRUN:
b095c381 630 return "DMA_UNDERRUN";
bf79451e 631 case IPW_FW_ERROR_DMA_STATUS:
b095c381
JK		 632 return "DMA_STATUS";
633 case IPW_FW_ERROR_DINO_ERROR:
634 return "DINO_ERROR";
635 case IPW_FW_ERROR_EEPROM_ERROR:
636 return "EEPROM_ERROR";
bf79451e 637 case IPW_FW_ERROR_SYSASSERT:
b095c381 638 return "SYSASSERT";
bf79451e 639 case IPW_FW_ERROR_FATAL_ERROR:
b095c381 640 return "FATAL_ERROR";
bf79451e 641 default:
b095c381 642 return "UNKNOWN_ERROR";
43f66a6c
JK		 643 }
644}
645
b39860c6
JK		 646static void ipw_dump_error_log(struct ipw_priv *priv,
647 struct ipw_fw_error *error)
43f66a6c 648{
b39860c6 649 u32 i;
bf79451e 650
b39860c6
JK		 651 if (!error) {
652 IPW_ERROR("Error allocating and capturing error log. "
653 "Nothing to dump.\n");
654 return;
43f66a6c
JK		 655 }
656
b39860c6
JK		 657 IPW_ERROR("Start IPW Error Log Dump:\n");
658 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
659 error->status, error->config);
43f66a6c 660
b39860c6 661 for (i = 0; i < error->elem_len; i++)
0edd5b44 662 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
b39860c6
JK		 663 ipw_error_desc(error->elem[i].desc),
664 error->elem[i].time,
665 error->elem[i].blink1,
666 error->elem[i].blink2,
667 error->elem[i].link1,
668 error->elem[i].link2, error->elem[i].data);
669 for (i = 0; i < error->log_len; i++)
670 IPW_ERROR("%i\t0x%08x\t%i\n",
671 error->log[i].time,
286568ab 672 error->log[i].data, error->log[i].event);
43f66a6c
JK		 673}
674
c848d0af 675static inline int ipw_is_init(struct ipw_priv *priv)
43f66a6c 676{
c848d0af 677 return (priv->status & STATUS_INIT) ? 1 : 0;
43f66a6c
JK		 678}
679
0edd5b44 680static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
43f66a6c
JK		 681{
682 u32 addr, field_info, field_len, field_count, total_len;
683
684 IPW_DEBUG_ORD("ordinal = %i\n", ord);
685
686 if (!priv || !val || !len) {
687 IPW_DEBUG_ORD("Invalid argument\n");
688 return -EINVAL;
689 }
bf79451e 690
43f66a6c
JK		 691 /* verify device ordinal tables have been initialized */
692 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
693 IPW_DEBUG_ORD("Access ordinals before initialization\n");
694 return -EINVAL;
695 }
696
697 switch (IPW_ORD_TABLE_ID_MASK & ord) {
698 case IPW_ORD_TABLE_0_MASK:
699 /*
700 * TABLE 0: Direct access to a table of 32 bit values
701 *
bf79451e 702 * This is a very simple table with the data directly
43f66a6c
JK		 703 * read from the table
704 */
705
706 /* remove the table id from the ordinal */
707 ord &= IPW_ORD_TABLE_VALUE_MASK;
708
709 /* boundary check */
710 if (ord > priv->table0_len) {
711 IPW_DEBUG_ORD("ordinal value (%i) longer then "
712 "max (%i)\n", ord, priv->table0_len);
713 return -EINVAL;
714 }
715
716 /* verify we have enough room to store the value */
717 if (*len < sizeof(u32)) {
718 IPW_DEBUG_ORD("ordinal buffer length too small, "
aaa4d308 719 "need %zd\n", sizeof(u32));
43f66a6c
JK		 720 return -EINVAL;
721 }
722
723 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
0edd5b44 724 ord, priv->table0_addr + (ord << 2));
43f66a6c
JK		 725
726 *len = sizeof(u32);
727 ord <<= 2;
0edd5b44 728 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
43f66a6c
JK		 729 break;
730
731 case IPW_ORD_TABLE_1_MASK:
732 /*
733 * TABLE 1: Indirect access to a table of 32 bit values
bf79451e
JG		 734 *
735 * This is a fairly large table of u32 values each
43f66a6c
JK		 736 * representing starting addr for the data (which is
737 * also a u32)
738 */
739
740 /* remove the table id from the ordinal */
741 ord &= IPW_ORD_TABLE_VALUE_MASK;
bf79451e 742
43f66a6c
JK		 743 /* boundary check */
744 if (ord > priv->table1_len) {
745 IPW_DEBUG_ORD("ordinal value too long\n");
746 return -EINVAL;
747 }
748
749 /* verify we have enough room to store the value */
750 if (*len < sizeof(u32)) {
751 IPW_DEBUG_ORD("ordinal buffer length too small, "
aaa4d308 752 "need %zd\n", sizeof(u32));
43f66a6c
JK		 753 return -EINVAL;
754 }
755
0edd5b44
JG		 756 *((u32 *) val) =
757 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
43f66a6c
JK		 758 *len = sizeof(u32);
759 break;
760
761 case IPW_ORD_TABLE_2_MASK:
762 /*
763 * TABLE 2: Indirect access to a table of variable sized values
764 *
765 * This table consist of six values, each containing
766 * - dword containing the starting offset of the data
767 * - dword containing the lengh in the first 16bits
768 * and the count in the second 16bits
769 */
770
771 /* remove the table id from the ordinal */
772 ord &= IPW_ORD_TABLE_VALUE_MASK;
773
774 /* boundary check */
775 if (ord > priv->table2_len) {
776 IPW_DEBUG_ORD("ordinal value too long\n");
777 return -EINVAL;
778 }
779
780 /* get the address of statistic */
781 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
bf79451e
JG		 782
783 /* get the second DW of statistics ;
43f66a6c 784 * two 16-bit words - first is length, second is count */
0edd5b44
JG		 785 field_info =
786 ipw_read_reg32(priv,
787 priv->table2_addr + (ord << 3) +
788 sizeof(u32));
bf79451e 789
43f66a6c 790 /* get each entry length */
0edd5b44 791 field_len = *((u16 *) & field_info);
bf79451e 792
43f66a6c 793 /* get number of entries */
0edd5b44 794 field_count = *(((u16 *) & field_info) + 1);
bf79451e 795
af901ca1 796 /* abort if not enough memory */
43f66a6c
JK		 797 total_len = field_len * field_count;
798 if (total_len > *len) {
799 *len = total_len;
800 return -EINVAL;
801 }
bf79451e 802
43f66a6c
JK		 803 *len = total_len;
804 if (!total_len)
805 return 0;
806
807 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
bf79451e 808 "field_info = 0x%08x\n",
43f66a6c
JK		 809 addr, total_len, field_info);
810 ipw_read_indirect(priv, addr, val, total_len);
811 break;
812
813 default:
814 IPW_DEBUG_ORD("Invalid ordinal!\n");
815 return -EINVAL;
816
817 }
818
43f66a6c
JK		 819 return 0;
820}
821
822static void ipw_init_ordinals(struct ipw_priv *priv)
823{
824 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
bf79451e 825 priv->table0_len = ipw_read32(priv, priv->table0_addr);
43f66a6c
JK		 826
827 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
828 priv->table0_addr, priv->table0_len);
829
830 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
831 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
832
833 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
834 priv->table1_addr, priv->table1_len);
835
836 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
837 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
0edd5b44 838 priv->table2_len &= 0x0000ffff; /* use first two bytes */
43f66a6c
JK		 839
840 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
841 priv->table2_addr, priv->table2_len);
842
843}
844
a73e22b2 845static u32 ipw_register_toggle(u32 reg)
a613bffd 846{
b095c381
JK		 847 reg &= ~IPW_START_STANDBY;
848 if (reg & IPW_GATE_ODMA)
849 reg &= ~IPW_GATE_ODMA;
850 if (reg & IPW_GATE_IDMA)
851 reg &= ~IPW_GATE_IDMA;
852 if (reg & IPW_GATE_ADMA)
853 reg &= ~IPW_GATE_ADMA;
a613bffd
JK		 854 return reg;
855}
856
857/*
858 * LED behavior:
859 * - On radio ON, turn on any LEDs that require to be on during start
860 * - On initialization, start unassociated blink
861 * - On association, disable unassociated blink
862 * - On disassociation, start unassociated blink
863 * - On radio OFF, turn off any LEDs started during radio on
864 *
865 */
ede6111c
ZY		 866#define LD_TIME_LINK_ON msecs_to_jiffies(300)
867#define LD_TIME_LINK_OFF msecs_to_jiffies(2700)
868#define LD_TIME_ACT_ON msecs_to_jiffies(250)
a613bffd 869
a73e22b2 870static void ipw_led_link_on(struct ipw_priv *priv)
a613bffd
JK		 871{
872 unsigned long flags;
873 u32 led;
874
875 /* If configured to not use LEDs, or nic_type is 1,
876 * then we don't toggle a LINK led */
877 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
878 return;
879
880 spin_lock_irqsave(&priv->lock, flags);
881
882 if (!(priv->status & STATUS_RF_KILL_MASK) &&
883 !(priv->status & STATUS_LED_LINK_ON)) {
884 IPW_DEBUG_LED("Link LED On\n");
b095c381 885 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 886 led |= priv->led_association_on;
887
888 led = ipw_register_toggle(led);
889
890 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 891 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 892
893 priv->status |= STATUS_LED_LINK_ON;
894
895 /* If we aren't associated, schedule turning the LED off */
896 if (!(priv->status & STATUS_ASSOCIATED))
897 queue_delayed_work(priv->workqueue,
898 &priv->led_link_off,
899 LD_TIME_LINK_ON);
900 }
901
902 spin_unlock_irqrestore(&priv->lock, flags);
903}
904
c4028958 905static void ipw_bg_led_link_on(struct work_struct *work)
c848d0af 906{
c4028958
DH		 907 struct ipw_priv *priv =
908 container_of(work, struct ipw_priv, led_link_on.work);
4644151b 909 mutex_lock(&priv->mutex);
c4028958 910 ipw_led_link_on(priv);
4644151b 911 mutex_unlock(&priv->mutex);
c848d0af
JK		 912}
913
a73e22b2 914static void ipw_led_link_off(struct ipw_priv *priv)
a613bffd
JK		 915{
916 unsigned long flags;
917 u32 led;
918
919 /* If configured not to use LEDs, or nic type is 1,
920 * then we don't goggle the LINK led. */
921 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
922 return;
923
924 spin_lock_irqsave(&priv->lock, flags);
925
926 if (priv->status & STATUS_LED_LINK_ON) {
b095c381 927 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 928 led &= priv->led_association_off;
929 led = ipw_register_toggle(led);
930
931 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 932 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 933
934 IPW_DEBUG_LED("Link LED Off\n");
935
936 priv->status &= ~STATUS_LED_LINK_ON;
937
938 /* If we aren't associated and the radio is on, schedule
939 * turning the LED on (blink while unassociated) */
940 if (!(priv->status & STATUS_RF_KILL_MASK) &&
941 !(priv->status & STATUS_ASSOCIATED))
942 queue_delayed_work(priv->workqueue, &priv->led_link_on,
943 LD_TIME_LINK_OFF);
944
945 }
946
947 spin_unlock_irqrestore(&priv->lock, flags);
948}
949
c4028958 950static void ipw_bg_led_link_off(struct work_struct *work)
c848d0af 951{
c4028958
DH		 952 struct ipw_priv *priv =
953 container_of(work, struct ipw_priv, led_link_off.work);
4644151b 954 mutex_lock(&priv->mutex);
c4028958 955 ipw_led_link_off(priv);
4644151b 956 mutex_unlock(&priv->mutex);
c848d0af
JK		 957}
958
858119e1 959static void __ipw_led_activity_on(struct ipw_priv *priv)
a613bffd 960{
a613bffd
JK		 961 u32 led;
962
963 if (priv->config & CFG_NO_LED)
964 return;
965
b095c381 966 if (priv->status & STATUS_RF_KILL_MASK)
a613bffd 967 return;
a613bffd
JK		 968
969 if (!(priv->status & STATUS_LED_ACT_ON)) {
b095c381 970 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 971 led |= priv->led_activity_on;
972
973 led = ipw_register_toggle(led);
974
975 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 976 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 977
978 IPW_DEBUG_LED("Activity LED On\n");
979
980 priv->status |= STATUS_LED_ACT_ON;
981
c848d0af 982 cancel_delayed_work(&priv->led_act_off);
a613bffd
JK		 983 queue_delayed_work(priv->workqueue, &priv->led_act_off,
984 LD_TIME_ACT_ON);
985 } else {
986 /* Reschedule LED off for full time period */
987 cancel_delayed_work(&priv->led_act_off);
988 queue_delayed_work(priv->workqueue, &priv->led_act_off,
989 LD_TIME_ACT_ON);
990 }
b095c381 991}
a613bffd 992
a73e22b2 993#if 0
b095c381
JK		 994void ipw_led_activity_on(struct ipw_priv *priv)
995{
996 unsigned long flags;
997 spin_lock_irqsave(&priv->lock, flags);
998 __ipw_led_activity_on(priv);
a613bffd
JK		 999 spin_unlock_irqrestore(&priv->lock, flags);
1000}
a73e22b2 1001#endif /* 0 */
a613bffd 1002
a73e22b2 1003static void ipw_led_activity_off(struct ipw_priv *priv)
a613bffd
JK		 1004{
1005 unsigned long flags;
1006 u32 led;
1007
1008 if (priv->config & CFG_NO_LED)
1009 return;
1010
1011 spin_lock_irqsave(&priv->lock, flags);
1012
1013 if (priv->status & STATUS_LED_ACT_ON) {
b095c381 1014 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 1015 led &= priv->led_activity_off;
1016
1017 led = ipw_register_toggle(led);
1018
1019 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 1020 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 1021
1022 IPW_DEBUG_LED("Activity LED Off\n");
1023
1024 priv->status &= ~STATUS_LED_ACT_ON;
1025 }
1026
1027 spin_unlock_irqrestore(&priv->lock, flags);
1028}
1029
c4028958 1030static void ipw_bg_led_activity_off(struct work_struct *work)
c848d0af 1031{
c4028958
DH		 1032 struct ipw_priv *priv =
1033 container_of(work, struct ipw_priv, led_act_off.work);
4644151b 1034 mutex_lock(&priv->mutex);
c4028958 1035 ipw_led_activity_off(priv);
4644151b 1036 mutex_unlock(&priv->mutex);
c848d0af
JK		 1037}
1038
a73e22b2 1039static void ipw_led_band_on(struct ipw_priv *priv)
a613bffd
JK		 1040{
1041 unsigned long flags;
1042 u32 led;
1043
1044 /* Only nic type 1 supports mode LEDs */
c848d0af
JK		 1045 if (priv->config & CFG_NO_LED ||
1046 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
a613bffd
JK		 1047 return;
1048
1049 spin_lock_irqsave(&priv->lock, flags);
1050
b095c381 1051 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 1052 if (priv->assoc_network->mode == IEEE_A) {
1053 led |= priv->led_ofdm_on;
1054 led &= priv->led_association_off;
1055 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
1056 } else if (priv->assoc_network->mode == IEEE_G) {
1057 led |= priv->led_ofdm_on;
1058 led |= priv->led_association_on;
1059 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
1060 } else {
1061 led &= priv->led_ofdm_off;
1062 led |= priv->led_association_on;
1063 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
1064 }
1065
1066 led = ipw_register_toggle(led);
1067
1068 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 1069 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 1070
1071 spin_unlock_irqrestore(&priv->lock, flags);
1072}
1073
a73e22b2 1074static void ipw_led_band_off(struct ipw_priv *priv)
a613bffd
JK		 1075{
1076 unsigned long flags;
1077 u32 led;
1078
1079 /* Only nic type 1 supports mode LEDs */
1080 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
1081 return;
1082
1083 spin_lock_irqsave(&priv->lock, flags);
1084
b095c381 1085 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 1086 led &= priv->led_ofdm_off;
1087 led &= priv->led_association_off;
1088
1089 led = ipw_register_toggle(led);
1090
1091 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 1092 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 1093
1094 spin_unlock_irqrestore(&priv->lock, flags);
1095}
1096
a73e22b2 1097static void ipw_led_radio_on(struct ipw_priv *priv)
a613bffd
JK		 1098{
1099 ipw_led_link_on(priv);
1100}
1101
a73e22b2 1102static void ipw_led_radio_off(struct ipw_priv *priv)
a613bffd
JK		 1103{
1104 ipw_led_activity_off(priv);
1105 ipw_led_link_off(priv);
1106}
1107
a73e22b2 1108static void ipw_led_link_up(struct ipw_priv *priv)
a613bffd
JK		 1109{
1110 /* Set the Link Led on for all nic types */
1111 ipw_led_link_on(priv);
1112}
1113
a73e22b2 1114static void ipw_led_link_down(struct ipw_priv *priv)
a613bffd
JK		 1115{
1116 ipw_led_activity_off(priv);
1117 ipw_led_link_off(priv);
1118
1119 if (priv->status & STATUS_RF_KILL_MASK)
1120 ipw_led_radio_off(priv);
1121}
1122
a73e22b2 1123static void ipw_led_init(struct ipw_priv *priv)
a613bffd
JK		 1124{
1125 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1126
1127 /* Set the default PINs for the link and activity leds */
b095c381
JK		 1128 priv->led_activity_on = IPW_ACTIVITY_LED;
1129 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
a613bffd 1130
b095c381
JK		 1131 priv->led_association_on = IPW_ASSOCIATED_LED;
1132 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
a613bffd
JK		 1133
1134 /* Set the default PINs for the OFDM leds */
b095c381
JK		 1135 priv->led_ofdm_on = IPW_OFDM_LED;
1136 priv->led_ofdm_off = ~(IPW_OFDM_LED);
a613bffd
JK		 1137
1138 switch (priv->nic_type) {
1139 case EEPROM_NIC_TYPE_1:
1140 /* In this NIC type, the LEDs are reversed.... */
b095c381
JK		 1141 priv->led_activity_on = IPW_ASSOCIATED_LED;
1142 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1143 priv->led_association_on = IPW_ACTIVITY_LED;
1144 priv->led_association_off = ~(IPW_ACTIVITY_LED);
a613bffd
JK		 1145
1146 if (!(priv->config & CFG_NO_LED))
1147 ipw_led_band_on(priv);
1148
1149 /* And we don't blink link LEDs for this nic, so
1150 * just return here */
1151 return;
1152
1153 case EEPROM_NIC_TYPE_3:
1154 case EEPROM_NIC_TYPE_2:
1155 case EEPROM_NIC_TYPE_4:
1156 case EEPROM_NIC_TYPE_0:
1157 break;
1158
1159 default:
1160 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1161 priv->nic_type);
1162 priv->nic_type = EEPROM_NIC_TYPE_0;
1163 break;
1164 }
1165
1166 if (!(priv->config & CFG_NO_LED)) {
1167 if (priv->status & STATUS_ASSOCIATED)
1168 ipw_led_link_on(priv);
1169 else
1170 ipw_led_link_off(priv);
1171 }
1172}
1173
a73e22b2 1174static void ipw_led_shutdown(struct ipw_priv *priv)
a613bffd 1175{
a613bffd
JK		 1176 ipw_led_activity_off(priv);
1177 ipw_led_link_off(priv);
1178 ipw_led_band_off(priv);
afbf30a2
JK		 1179 cancel_delayed_work(&priv->led_link_on);
1180 cancel_delayed_work(&priv->led_link_off);
1181 cancel_delayed_work(&priv->led_act_off);
a613bffd
JK		 1182}
1183
43f66a6c
JK		 1184/*
1185 * The following adds a new attribute to the sysfs representation
1186 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1187 * used for controling the debug level.
bf79451e 1188 *
43f66a6c
JK		 1189 * See the level definitions in ipw for details.
1190 */
1191static ssize_t show_debug_level(struct device_driver *d, char *buf)
1192{
1193 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1194}
a613bffd
JK		 1195
1196static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1197 size_t count)
43f66a6c
JK		 1198{
1199 char *p = (char *)buf;
1200 u32 val;
1201
1202 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1203 p++;
1204 if (p[0] == 'x' || p[0] == 'X')
1205 p++;
1206 val = simple_strtoul(p, &p, 16);
1207 } else
1208 val = simple_strtoul(p, &p, 10);
bf79451e
JG		 1209 if (p == buf)
1210 printk(KERN_INFO DRV_NAME
43f66a6c
JK		 1211 ": %s is not in hex or decimal form.\n", buf);
1212 else
1213 ipw_debug_level = val;
1214
1215 return strnlen(buf, count);
1216}
1217
bf79451e 1218static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
43f66a6c
JK		 1219 show_debug_level, store_debug_level);
1220
b39860c6 1221static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
43f66a6c 1222{
c8fe6679 1223 /* length = 1st dword in log */
b39860c6 1224 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
43f66a6c 1225}
0edd5b44 1226
b39860c6
JK		 1227static void ipw_capture_event_log(struct ipw_priv *priv,
1228 u32 log_len, struct ipw_event *log)
43f66a6c 1229{
b39860c6 1230 u32 base;
0edd5b44 1231
b39860c6
JK		 1232 if (log_len) {
1233 base = ipw_read32(priv, IPW_EVENT_LOG);
1234 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1235 (u8 *) log, sizeof(*log) * log_len);
1236 }
1237}
43f66a6c 1238
b39860c6 1239static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
43f66a6c 1240{
b39860c6
JK		 1241 struct ipw_fw_error *error;
1242 u32 log_len = ipw_get_event_log_len(priv);
1243 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1244 u32 elem_len = ipw_read_reg32(priv, base);
43f66a6c 1245
b39860c6
JK		 1246 error = kmalloc(sizeof(*error) +
1247 sizeof(*error->elem) * elem_len +
1248 sizeof(*error->log) * log_len, GFP_ATOMIC);
1249 if (!error) {
1250 IPW_ERROR("Memory allocation for firmware error log "
1251 "failed.\n");
1252 return NULL;
43f66a6c 1253 }
f6c5cb7c 1254 error->jiffies = jiffies;
b39860c6
JK		 1255 error->status = priv->status;
1256 error->config = priv->config;
1257 error->elem_len = elem_len;
1258 error->log_len = log_len;
1259 error->elem = (struct ipw_error_elem *)error->payload;
3b26b110 1260 error->log = (struct ipw_event *)(error->elem + elem_len);
b39860c6
JK		 1261
1262 ipw_capture_event_log(priv, log_len, error->log);
bf79451e 1263
b39860c6
JK		 1264 if (elem_len)
1265 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1266 sizeof(*error->elem) * elem_len);
1267
1268 return error;
43f66a6c 1269}
0edd5b44 1270
b39860c6
JK		 1271static ssize_t show_event_log(struct device *d,
1272 struct device_attribute *attr, char *buf)
43f66a6c 1273{
b39860c6
JK		 1274 struct ipw_priv *priv = dev_get_drvdata(d);
1275 u32 log_len = ipw_get_event_log_len(priv);
412e9e78
RC		 1276 u32 log_size;
1277 struct ipw_event *log;
b39860c6 1278 u32 len = 0, i;
43f66a6c 1279
412e9e78
RC		 1280 /* not using min() because of its strict type checking */
1281 log_size = PAGE_SIZE / sizeof(*log) > log_len ?
1282 sizeof(*log) * log_len : PAGE_SIZE;
1283 log = kzalloc(log_size, GFP_KERNEL);
1284 if (!log) {
1285 IPW_ERROR("Unable to allocate memory for log\n");
1286 return 0;
1287 }
1288 log_len = log_size / sizeof(*log);
b39860c6 1289 ipw_capture_event_log(priv, log_len, log);
43f66a6c 1290
b39860c6
JK		 1291 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1292 for (i = 0; i < log_len; i++)
1293 len += snprintf(buf + len, PAGE_SIZE - len,
1294 "\n%08X%08X%08X",
1295 log[i].time, log[i].event, log[i].data);
1296 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
412e9e78 1297 kfree(log);
b39860c6 1298 return len;
43f66a6c 1299}
0edd5b44 1300
b39860c6 1301static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
43f66a6c 1302
b39860c6
JK		 1303static ssize_t show_error(struct device *d,
1304 struct device_attribute *attr, char *buf)
43f66a6c 1305{
b39860c6
JK		 1306 struct ipw_priv *priv = dev_get_drvdata(d);
1307 u32 len = 0, i;
1308 if (!priv->error)
1309 return 0;
1310 len += snprintf(buf + len, PAGE_SIZE - len,
f6c5cb7c
JK		 1311 "%08lX%08X%08X%08X",
1312 priv->error->jiffies,
b39860c6
JK		 1313 priv->error->status,
1314 priv->error->config, priv->error->elem_len);
1315 for (i = 0; i < priv->error->elem_len; i++)
1316 len += snprintf(buf + len, PAGE_SIZE - len,
1317 "\n%08X%08X%08X%08X%08X%08X%08X",
1318 priv->error->elem[i].time,
1319 priv->error->elem[i].desc,
1320 priv->error->elem[i].blink1,
1321 priv->error->elem[i].blink2,
1322 priv->error->elem[i].link1,
1323 priv->error->elem[i].link2,
1324 priv->error->elem[i].data);
1325
1326 len += snprintf(buf + len, PAGE_SIZE - len,
1327 "\n%08X", priv->error->log_len);
1328 for (i = 0; i < priv->error->log_len; i++)
1329 len += snprintf(buf + len, PAGE_SIZE - len,
1330 "\n%08X%08X%08X",
1331 priv->error->log[i].time,
1332 priv->error->log[i].event,
1333 priv->error->log[i].data);
1334 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1335 return len;
1336}
1337
1338static ssize_t clear_error(struct device *d,
1339 struct device_attribute *attr,
1340 const char *buf, size_t count)
1341{
1342 struct ipw_priv *priv = dev_get_drvdata(d);
8f760780
JJ		 1343
1344 kfree(priv->error);
1345 priv->error = NULL;
b39860c6
JK		 1346 return count;
1347}
43f66a6c 1348
b39860c6 1349static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
43f66a6c 1350
f6c5cb7c
JK		 1351static ssize_t show_cmd_log(struct device *d,
1352 struct device_attribute *attr, char *buf)
1353{
1354 struct ipw_priv *priv = dev_get_drvdata(d);
1355 u32 len = 0, i;
1356 if (!priv->cmdlog)
1357 return 0;
1358 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1359 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1360 i = (i + 1) % priv->cmdlog_len) {
1361 len +=
1362 snprintf(buf + len, PAGE_SIZE - len,
1363 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1364 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1365 priv->cmdlog[i].cmd.len);
1366 len +=
1367 snprintk_buf(buf + len, PAGE_SIZE - len,
1368 (u8 *) priv->cmdlog[i].cmd.param,
1369 priv->cmdlog[i].cmd.len);
1370 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1371 }
1372 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1373 return len;
43f66a6c 1374}
0edd5b44 1375
f6c5cb7c 1376static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
43f66a6c 1377
d685b8c2
ZY		 1378#ifdef CONFIG_IPW2200_PROMISCUOUS
1379static void ipw_prom_free(struct ipw_priv *priv);
1380static int ipw_prom_alloc(struct ipw_priv *priv);
1381static ssize_t store_rtap_iface(struct device *d,
1382 struct device_attribute *attr,
1383 const char *buf, size_t count)
1384{
1385 struct ipw_priv *priv = dev_get_drvdata(d);
1386 int rc = 0;
1387
1388 if (count < 1)
1389 return -EINVAL;
1390
1391 switch (buf[0]) {
1392 case '0':
1393 if (!rtap_iface)
1394 return count;
1395
1396 if (netif_running(priv->prom_net_dev)) {
1397 IPW_WARNING("Interface is up. Cannot unregister.\n");
1398 return count;
1399 }
1400
1401 ipw_prom_free(priv);
1402 rtap_iface = 0;
1403 break;
1404
1405 case '1':
1406 if (rtap_iface)
1407 return count;
1408
1409 rc = ipw_prom_alloc(priv);
1410 if (!rc)
1411 rtap_iface = 1;
1412 break;
1413
1414 default:
1415 return -EINVAL;
1416 }
1417
1418 if (rc) {
1419 IPW_ERROR("Failed to register promiscuous network "
1420 "device (error %d).\n", rc);
1421 }
1422
1423 return count;
1424}
1425
1426static ssize_t show_rtap_iface(struct device *d,
1427 struct device_attribute *attr,
1428 char *buf)
1429{
1430 struct ipw_priv *priv = dev_get_drvdata(d);
1431 if (rtap_iface)
1432 return sprintf(buf, "%s", priv->prom_net_dev->name);
1433 else {
1434 buf[0] = '-';
1435 buf[1] = '1';
1436 buf[2] = '\0';
1437 return 3;
1438 }
1439}
1440
1441static DEVICE_ATTR(rtap_iface, S_IWUSR | S_IRUSR, show_rtap_iface,
1442 store_rtap_iface);
1443
1444static ssize_t store_rtap_filter(struct device *d,
1445 struct device_attribute *attr,
1446 const char *buf, size_t count)
1447{
1448 struct ipw_priv *priv = dev_get_drvdata(d);
1449
1450 if (!priv->prom_priv) {
1451 IPW_ERROR("Attempting to set filter without "
1452 "rtap_iface enabled.\n");
1453 return -EPERM;
1454 }
1455
1456 priv->prom_priv->filter = simple_strtol(buf, NULL, 0);
1457
1458 IPW_DEBUG_INFO("Setting rtap filter to " BIT_FMT16 "\n",
1459 BIT_ARG16(priv->prom_priv->filter));
1460
1461 return count;
1462}
1463
1464static ssize_t show_rtap_filter(struct device *d,
1465 struct device_attribute *attr,
1466 char *buf)
1467{
1468 struct ipw_priv *priv = dev_get_drvdata(d);
1469 return sprintf(buf, "0x%04X",
1470 priv->prom_priv ? priv->prom_priv->filter : 0);
1471}
1472
1473static DEVICE_ATTR(rtap_filter, S_IWUSR | S_IRUSR, show_rtap_filter,
1474 store_rtap_filter);
1475#endif
1476
a613bffd
JK		 1477static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1478 char *buf)
43f66a6c 1479{
a613bffd
JK		 1480 struct ipw_priv *priv = dev_get_drvdata(d);
1481 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1482}
1483
1484static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1485 const char *buf, size_t count)
1486{
1487 struct ipw_priv *priv = dev_get_drvdata(d);
1488 struct net_device *dev = priv->net_dev;
1489 char buffer[] = "00000000";
1490 unsigned long len =
1491 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1492 unsigned long val;
1493 char *p = buffer;
1494
1495 IPW_DEBUG_INFO("enter\n");
1496
1497 strncpy(buffer, buf, len);
1498 buffer[len] = 0;
1499
1500 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1501 p++;
1502 if (p[0] == 'x' || p[0] == 'X')
1503 p++;
1504 val = simple_strtoul(p, &p, 16);
1505 } else
1506 val = simple_strtoul(p, &p, 10);
1507 if (p == buffer) {
1508 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1509 } else {
1510 priv->ieee->scan_age = val;
1511 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1512 }
1513
1514 IPW_DEBUG_INFO("exit\n");
1515 return len;
1516}
1517
1518static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1519
1520static ssize_t show_led(struct device *d, struct device_attribute *attr,
1521 char *buf)
1522{
1523 struct ipw_priv *priv = dev_get_drvdata(d);
1524 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1525}
1526
1527static ssize_t store_led(struct device *d, struct device_attribute *attr,
1528 const char *buf, size_t count)
1529{
1530 struct ipw_priv *priv = dev_get_drvdata(d);
1531
1532 IPW_DEBUG_INFO("enter\n");
1533
1534 if (count == 0)
1535 return 0;
1536
1537 if (*buf == 0) {
1538 IPW_DEBUG_LED("Disabling LED control.\n");
1539 priv->config |= CFG_NO_LED;
1540 ipw_led_shutdown(priv);
1541 } else {
1542 IPW_DEBUG_LED("Enabling LED control.\n");
1543 priv->config &= ~CFG_NO_LED;
1544 ipw_led_init(priv);
1545 }
1546
1547 IPW_DEBUG_INFO("exit\n");
1548 return count;
1549}
1550
1551static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1552
ad3fee56 1553static ssize_t show_status(struct device *d,
0edd5b44 1554 struct device_attribute *attr, char *buf)
43f66a6c 1555{
928841b1 1556 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1557 return sprintf(buf, "0x%08x\n", (int)p->status);
1558}
0edd5b44 1559
43f66a6c
JK		 1560static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1561
ad3fee56
AM		 1562static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1563 char *buf)
43f66a6c 1564{
928841b1 1565 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1566 return sprintf(buf, "0x%08x\n", (int)p->config);
1567}
0edd5b44 1568
43f66a6c
JK		 1569static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1570
ad3fee56 1571static ssize_t show_nic_type(struct device *d,
0edd5b44 1572 struct device_attribute *attr, char *buf)
43f66a6c 1573{
928841b1 1574 struct ipw_priv *priv = dev_get_drvdata(d);
a613bffd 1575 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
43f66a6c 1576}
0edd5b44 1577
43f66a6c
JK		 1578static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1579
ad3fee56 1580static ssize_t show_ucode_version(struct device *d,
0edd5b44 1581 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1582{
1583 u32 len = sizeof(u32), tmp = 0;
928841b1 1584 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c 1585
0edd5b44 1586 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
43f66a6c
JK		 1587 return 0;
1588
1589 return sprintf(buf, "0x%08x\n", tmp);
1590}
0edd5b44
JG		 1591
1592static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
43f66a6c 1593
ad3fee56
AM		 1594static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1595 char *buf)
43f66a6c
JK		 1596{
1597 u32 len = sizeof(u32), tmp = 0;
928841b1 1598 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c 1599
0edd5b44 1600 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
43f66a6c
JK		 1601 return 0;
1602
1603 return sprintf(buf, "0x%08x\n", tmp);
1604}
0edd5b44
JG		 1605
1606static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
43f66a6c
JK		 1607
1608/*
1609 * Add a device attribute to view/control the delay between eeprom
1610 * operations.
1611 */
ad3fee56 1612static ssize_t show_eeprom_delay(struct device *d,
0edd5b44 1613 struct device_attribute *attr, char *buf)
43f66a6c 1614{
928841b1
GKH		 1615 struct ipw_priv *p = dev_get_drvdata(d);
1616 int n = p->eeprom_delay;
43f66a6c
JK		 1617 return sprintf(buf, "%i\n", n);
1618}
ad3fee56 1619static ssize_t store_eeprom_delay(struct device *d,
0edd5b44
JG		 1620 struct device_attribute *attr,
1621 const char *buf, size_t count)
43f66a6c 1622{
928841b1 1623 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1624 sscanf(buf, "%i", &p->eeprom_delay);
1625 return strnlen(buf, count);
1626}
0edd5b44
JG		 1627
1628static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1629 show_eeprom_delay, store_eeprom_delay);
43f66a6c 1630
ad3fee56 1631static ssize_t show_command_event_reg(struct device *d,
0edd5b44 1632 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1633{
1634 u32 reg = 0;
928841b1 1635 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c 1636
b095c381 1637 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
43f66a6c
JK		 1638 return sprintf(buf, "0x%08x\n", reg);
1639}
ad3fee56 1640static ssize_t store_command_event_reg(struct device *d,
0edd5b44
JG		 1641 struct device_attribute *attr,
1642 const char *buf, size_t count)
43f66a6c
JK		 1643{
1644 u32 reg;
928841b1 1645 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1646
1647 sscanf(buf, "%x", &reg);
b095c381 1648 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
43f66a6c
JK		 1649 return strnlen(buf, count);
1650}
0edd5b44
JG		 1651
1652static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1653 show_command_event_reg, store_command_event_reg);
43f66a6c 1654
ad3fee56 1655static ssize_t show_mem_gpio_reg(struct device *d,
0edd5b44 1656 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1657{
1658 u32 reg = 0;
928841b1 1659 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1660
1661 reg = ipw_read_reg32(p, 0x301100);
1662 return sprintf(buf, "0x%08x\n", reg);
1663}
ad3fee56 1664static ssize_t store_mem_gpio_reg(struct device *d,
0edd5b44
JG		 1665 struct device_attribute *attr,
1666 const char *buf, size_t count)
43f66a6c
JK		 1667{
1668 u32 reg;
928841b1 1669 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1670
1671 sscanf(buf, "%x", &reg);
1672 ipw_write_reg32(p, 0x301100, reg);
1673 return strnlen(buf, count);
1674}
0edd5b44
JG		 1675
1676static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1677 show_mem_gpio_reg, store_mem_gpio_reg);
43f66a6c 1678
ad3fee56 1679static ssize_t show_indirect_dword(struct device *d,
0edd5b44 1680 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1681{
1682 u32 reg = 0;
928841b1 1683 struct ipw_priv *priv = dev_get_drvdata(d);
afbf30a2 1684
bf79451e 1685 if (priv->status & STATUS_INDIRECT_DWORD)
43f66a6c 1686 reg = ipw_read_reg32(priv, priv->indirect_dword);
bf79451e 1687 else
43f66a6c 1688 reg = 0;
bf79451e 1689
43f66a6c
JK		 1690 return sprintf(buf, "0x%08x\n", reg);
1691}
ad3fee56 1692static ssize_t store_indirect_dword(struct device *d,
0edd5b44
JG		 1693 struct device_attribute *attr,
1694 const char *buf, size_t count)
43f66a6c 1695{
928841b1 1696 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c
JK		 1697
1698 sscanf(buf, "%x", &priv->indirect_dword);
1699 priv->status |= STATUS_INDIRECT_DWORD;
1700 return strnlen(buf, count);
1701}
0edd5b44
JG		 1702
1703static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1704 show_indirect_dword, store_indirect_dword);
43f66a6c 1705
ad3fee56 1706static ssize_t show_indirect_byte(struct device *d,
0edd5b44 1707 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1708{
1709 u8 reg = 0;
928841b1 1710 struct ipw_priv *priv = dev_get_drvdata(d);
afbf30a2 1711
bf79451e 1712 if (priv->status & STATUS_INDIRECT_BYTE)
43f66a6c 1713 reg = ipw_read_reg8(priv, priv->indirect_byte);
bf79451e 1714 else
43f66a6c
JK		 1715 reg = 0;
1716
1717 return sprintf(buf, "0x%02x\n", reg);
1718}
ad3fee56 1719static ssize_t store_indirect_byte(struct device *d,
0edd5b44
JG		 1720 struct device_attribute *attr,
1721 const char *buf, size_t count)
43f66a6c 1722{
928841b1 1723 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c
JK		 1724
1725 sscanf(buf, "%x", &priv->indirect_byte);
1726 priv->status |= STATUS_INDIRECT_BYTE;
1727 return strnlen(buf, count);
1728}
0edd5b44
JG		 1729
1730static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
43f66a6c
JK		 1731 show_indirect_byte, store_indirect_byte);
1732
ad3fee56 1733static ssize_t show_direct_dword(struct device *d,
0edd5b44 1734 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1735{
1736 u32 reg = 0;
928841b1 1737 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c 1738
bf79451e 1739 if (priv->status & STATUS_DIRECT_DWORD)
43f66a6c 1740 reg = ipw_read32(priv, priv->direct_dword);
bf79451e 1741 else
43f66a6c
JK		 1742 reg = 0;
1743
1744 return sprintf(buf, "0x%08x\n", reg);
1745}
ad3fee56 1746static ssize_t store_direct_dword(struct device *d,
0edd5b44
JG		 1747 struct device_attribute *attr,
1748 const char *buf, size_t count)
43f66a6c 1749{
928841b1 1750 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c
JK		 1751
1752 sscanf(buf, "%x", &priv->direct_dword);
1753 priv->status |= STATUS_DIRECT_DWORD;
1754 return strnlen(buf, count);
1755}
43f66a6c 1756
0edd5b44
JG		 1757static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1758 show_direct_dword, store_direct_dword);
43f66a6c 1759
858119e1 1760static int rf_kill_active(struct ipw_priv *priv)
43f66a6c 1761{
25f94aea 1762 if (0 == (ipw_read32(priv, 0x30) & 0x10000)) {
43f66a6c 1763 priv->status |= STATUS_RF_KILL_HW;
25f94aea
MG		 1764 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1765 } else {
43f66a6c 1766 priv->status &= ~STATUS_RF_KILL_HW;
25f94aea
MG		 1767 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1768 }
43f66a6c
JK		 1769
1770 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1771}
1772
ad3fee56 1773static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
0edd5b44 1774 char *buf)
43f66a6c
JK		 1775{
1776 /* 0 - RF kill not enabled
bf79451e 1777 1 - SW based RF kill active (sysfs)
43f66a6c
JK		 1778 2 - HW based RF kill active
1779 3 - Both HW and SW baed RF kill active */
928841b1 1780 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c 1781 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
0edd5b44 1782 (rf_kill_active(priv) ? 0x2 : 0x0);
43f66a6c
JK		 1783 return sprintf(buf, "%i\n", val);
1784}
1785
1786static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1787{
bf79451e 1788 if ((disable_radio ? 1 : 0) ==
ea2b26e0 1789 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
0edd5b44 1790 return 0;
43f66a6c
JK		 1791
1792 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1793 disable_radio ? "OFF" : "ON");
1794
1795 if (disable_radio) {
1796 priv->status |= STATUS_RF_KILL_SW;
1797
0b531676 1798 if (priv->workqueue) {
43f66a6c 1799 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 1800 cancel_delayed_work(&priv->request_direct_scan);
1801 cancel_delayed_work(&priv->request_passive_scan);
0b531676
DW		 1802 cancel_delayed_work(&priv->scan_event);
1803 }
43f66a6c
JK		 1804 queue_work(priv->workqueue, &priv->down);
1805 } else {
1806 priv->status &= ~STATUS_RF_KILL_SW;
1807 if (rf_kill_active(priv)) {
1808 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1809 "disabled by HW switch\n");
1810 /* Make sure the RF_KILL check timer is running */
1811 cancel_delayed_work(&priv->rf_kill);
bf79451e 1812 queue_delayed_work(priv->workqueue, &priv->rf_kill,
be84e3d6 1813 round_jiffies_relative(2 * HZ));
bf79451e 1814 } else
43f66a6c
JK		 1815 queue_work(priv->workqueue, &priv->up);
1816 }
1817
1818 return 1;
1819}
1820
0edd5b44
JG		 1821static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1822 const char *buf, size_t count)
43f66a6c 1823{
928841b1 1824 struct ipw_priv *priv = dev_get_drvdata(d);
bf79451e 1825
43f66a6c
JK		 1826 ipw_radio_kill_sw(priv, buf[0] == '1');
1827
1828 return count;
1829}
0edd5b44
JG		 1830
1831static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
43f66a6c 1832
b095c381
JK		 1833static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1834 char *buf)
1835{
928841b1 1836 struct ipw_priv *priv = dev_get_drvdata(d);
b095c381
JK		 1837 int pos = 0, len = 0;
1838 if (priv->config & CFG_SPEED_SCAN) {
1839 while (priv->speed_scan[pos] != 0)
1840 len += sprintf(&buf[len], "%d ",
1841 priv->speed_scan[pos++]);
1842 return len + sprintf(&buf[len], "\n");
1843 }
1844
1845 return sprintf(buf, "0\n");
1846}
1847
1848static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1849 const char *buf, size_t count)
1850{
928841b1 1851 struct ipw_priv *priv = dev_get_drvdata(d);
b095c381
JK		 1852 int channel, pos = 0;
1853 const char *p = buf;
1854
1855 /* list of space separated channels to scan, optionally ending with 0 */
1856 while ((channel = simple_strtol(p, NULL, 0))) {
1857 if (pos == MAX_SPEED_SCAN - 1) {
1858 priv->speed_scan[pos] = 0;
1859 break;
1860 }
1861
b0a4e7d8 1862 if (libipw_is_valid_channel(priv->ieee, channel))
b095c381
JK		 1863 priv->speed_scan[pos++] = channel;
1864 else
1865 IPW_WARNING("Skipping invalid channel request: %d\n",
1866 channel);
1867 p = strchr(p, ' ');
1868 if (!p)
1869 break;
1870 while (*p == ' ' || *p == '\t')
1871 p++;
1872 }
1873
1874 if (pos == 0)
1875 priv->config &= ~CFG_SPEED_SCAN;
1876 else {
1877 priv->speed_scan_pos = 0;
1878 priv->config |= CFG_SPEED_SCAN;
1879 }
1880
1881 return count;
1882}
1883
1884static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1885 store_speed_scan);
1886
1887static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1888 char *buf)
1889{
928841b1 1890 struct ipw_priv *priv = dev_get_drvdata(d);
b095c381
JK		 1891 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1892}
1893
1894static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1895 const char *buf, size_t count)
1896{
928841b1 1897 struct ipw_priv *priv = dev_get_drvdata(d);
b095c381
JK		 1898 if (buf[0] == '1')
1899 priv->config |= CFG_NET_STATS;
1900 else
1901 priv->config &= ~CFG_NET_STATS;
1902
1903 return count;
1904}
1905
afbf30a2
JK		 1906static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1907 show_net_stats, store_net_stats);
b095c381 1908
375dd244
ZY		 1909static ssize_t show_channels(struct device *d,
1910 struct device_attribute *attr,
1911 char *buf)
1912{
1913 struct ipw_priv *priv = dev_get_drvdata(d);
b0a4e7d8 1914 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
375dd244
ZY		 1915 int len = 0, i;
1916
1917 len = sprintf(&buf[len],
1918 "Displaying %d channels in 2.4Ghz band "
1919 "(802.11bg):\n", geo->bg_channels);
1920
1921 for (i = 0; i < geo->bg_channels; i++) {
1922 len += sprintf(&buf[len], "%d: BSS%s%s, %s, Band %s.\n",
1923 geo->bg[i].channel,
b0a4e7d8 1924 geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT ?
375dd244 1925 " (radar spectrum)" : "",
b0a4e7d8
JL		 1926 ((geo->bg[i].flags & LIBIPW_CH_NO_IBSS) ||
1927 (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT))
375dd244 1928 ? "" : ", IBSS",
b0a4e7d8 1929 geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
375dd244 1930 "passive only" : "active/passive",
b0a4e7d8 1931 geo->bg[i].flags & LIBIPW_CH_B_ONLY ?
375dd244
ZY		 1932 "B" : "B/G");
1933 }
1934
1935 len += sprintf(&buf[len],
1936 "Displaying %d channels in 5.2Ghz band "
1937 "(802.11a):\n", geo->a_channels);
1938 for (i = 0; i < geo->a_channels; i++) {
1939 len += sprintf(&buf[len], "%d: BSS%s%s, %s.\n",
1940 geo->a[i].channel,
b0a4e7d8 1941 geo->a[i].flags & LIBIPW_CH_RADAR_DETECT ?
375dd244 1942 " (radar spectrum)" : "",
b0a4e7d8
JL		 1943 ((geo->a[i].flags & LIBIPW_CH_NO_IBSS) ||
1944 (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT))
375dd244 1945 ? "" : ", IBSS",
b0a4e7d8 1946 geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
375dd244
ZY		 1947 "passive only" : "active/passive");
1948 }
1949
1950 return len;
1951}
1952
1953static DEVICE_ATTR(channels, S_IRUSR, show_channels, NULL);
1954
ea2b26e0
JK		 1955static void notify_wx_assoc_event(struct ipw_priv *priv)
1956{
1957 union iwreq_data wrqu;
1958 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1959 if (priv->status & STATUS_ASSOCIATED)
1960 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1961 else
1962 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1963 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1964}
1965
43f66a6c
JK		 1966static void ipw_irq_tasklet(struct ipw_priv *priv)
1967{
1968 u32 inta, inta_mask, handled = 0;
1969 unsigned long flags;
1970 int rc = 0;
1971
89c318ed 1972 spin_lock_irqsave(&priv->irq_lock, flags);
43f66a6c 1973
b095c381
JK		 1974 inta = ipw_read32(priv, IPW_INTA_RW);
1975 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1976 inta &= (IPW_INTA_MASK_ALL & inta_mask);
43f66a6c
JK		 1977
1978 /* Add any cached INTA values that need to be handled */
1979 inta |= priv->isr_inta;
1980
89c318ed
ZY		 1981 spin_unlock_irqrestore(&priv->irq_lock, flags);
1982
1983 spin_lock_irqsave(&priv->lock, flags);
1984
43f66a6c 1985 /* handle all the justifications for the interrupt */
b095c381 1986 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
43f66a6c 1987 ipw_rx(priv);
b095c381 1988 handled |= IPW_INTA_BIT_RX_TRANSFER;
43f66a6c
JK		 1989 }
1990
b095c381 1991 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
43f66a6c 1992 IPW_DEBUG_HC("Command completed.\n");
0edd5b44 1993 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
43f66a6c
JK		 1994 priv->status &= ~STATUS_HCMD_ACTIVE;
1995 wake_up_interruptible(&priv->wait_command_queue);
b095c381 1996 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
43f66a6c
JK		 1997 }
1998
b095c381 1999 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
43f66a6c 2000 IPW_DEBUG_TX("TX_QUEUE_1\n");
0edd5b44 2001 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
b095c381 2002 handled |= IPW_INTA_BIT_TX_QUEUE_1;
43f66a6c
JK		 2003 }
2004
b095c381 2005 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
43f66a6c 2006 IPW_DEBUG_TX("TX_QUEUE_2\n");
0edd5b44 2007 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
b095c381 2008 handled |= IPW_INTA_BIT_TX_QUEUE_2;
43f66a6c
JK		 2009 }
2010
b095c381 2011 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
43f66a6c 2012 IPW_DEBUG_TX("TX_QUEUE_3\n");
0edd5b44 2013 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
b095c381 2014 handled |= IPW_INTA_BIT_TX_QUEUE_3;
43f66a6c
JK		 2015 }
2016
b095c381 2017 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
43f66a6c 2018 IPW_DEBUG_TX("TX_QUEUE_4\n");
0edd5b44 2019 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
b095c381 2020 handled |= IPW_INTA_BIT_TX_QUEUE_4;
43f66a6c
JK		 2021 }
2022
b095c381 2023 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
43f66a6c 2024 IPW_WARNING("STATUS_CHANGE\n");
b095c381 2025 handled |= IPW_INTA_BIT_STATUS_CHANGE;
43f66a6c
JK		 2026 }
2027
b095c381 2028 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
43f66a6c 2029 IPW_WARNING("TX_PERIOD_EXPIRED\n");
b095c381 2030 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
43f66a6c
JK		 2031 }
2032
b095c381 2033 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
43f66a6c 2034 IPW_WARNING("HOST_CMD_DONE\n");
b095c381 2035 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
43f66a6c
JK		 2036 }
2037
b095c381 2038 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
43f66a6c 2039 IPW_WARNING("FW_INITIALIZATION_DONE\n");
b095c381 2040 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
43f66a6c
JK		 2041 }
2042
b095c381 2043 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
43f66a6c 2044 IPW_WARNING("PHY_OFF_DONE\n");
b095c381 2045 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
43f66a6c
JK		 2046 }
2047
b095c381 2048 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
43f66a6c
JK		 2049 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
2050 priv->status |= STATUS_RF_KILL_HW;
25f94aea 2051 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
43f66a6c 2052 wake_up_interruptible(&priv->wait_command_queue);
ea2b26e0 2053 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
43f66a6c 2054 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 2055 cancel_delayed_work(&priv->request_direct_scan);
2056 cancel_delayed_work(&priv->request_passive_scan);
0b531676 2057 cancel_delayed_work(&priv->scan_event);
a613bffd 2058 schedule_work(&priv->link_down);
43f66a6c 2059 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
b095c381 2060 handled |= IPW_INTA_BIT_RF_KILL_DONE;
43f66a6c 2061 }
bf79451e 2062
b095c381 2063 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1d1b09eb 2064 IPW_WARNING("Firmware error detected. Restarting.\n");
b39860c6 2065 if (priv->error) {
1d1b09eb 2066 IPW_DEBUG_FW("Sysfs 'error' log already exists.\n");
b39860c6
JK		 2067 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
2068 struct ipw_fw_error *error =
2069 ipw_alloc_error_log(priv);
2070 ipw_dump_error_log(priv, error);
8f760780 2071 kfree(error);
b39860c6 2072 }
b39860c6
JK		 2073 } else {
2074 priv->error = ipw_alloc_error_log(priv);
2075 if (priv->error)
1d1b09eb 2076 IPW_DEBUG_FW("Sysfs 'error' log captured.\n");
b39860c6 2077 else
1d1b09eb
ZY		 2078 IPW_DEBUG_FW("Error allocating sysfs 'error' "
2079 "log.\n");
b39860c6
JK		 2080 if (ipw_debug_level & IPW_DL_FW_ERRORS)
2081 ipw_dump_error_log(priv, priv->error);
b39860c6
JK		 2082 }
2083
b095c381
JK		 2084 /* XXX: If hardware encryption is for WPA/WPA2,
2085 * we have to notify the supplicant. */
2086 if (priv->ieee->sec.encrypt) {
2087 priv->status &= ~STATUS_ASSOCIATED;
2088 notify_wx_assoc_event(priv);
2089 }
2090
2091 /* Keep the restart process from trying to send host
2092 * commands by clearing the INIT status bit */
2093 priv->status &= ~STATUS_INIT;
afbf30a2
JK		 2094
2095 /* Cancel currently queued command. */
2096 priv->status &= ~STATUS_HCMD_ACTIVE;
2097 wake_up_interruptible(&priv->wait_command_queue);
2098
43f66a6c 2099 queue_work(priv->workqueue, &priv->adapter_restart);
b095c381 2100 handled |= IPW_INTA_BIT_FATAL_ERROR;
43f66a6c
JK		 2101 }
2102
b095c381 2103 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
43f66a6c 2104 IPW_ERROR("Parity error\n");
b095c381 2105 handled |= IPW_INTA_BIT_PARITY_ERROR;
43f66a6c
JK		 2106 }
2107
2108 if (handled != inta) {
0edd5b44 2109 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
43f66a6c
JK		 2110 }
2111
89c318ed
ZY		 2112 spin_unlock_irqrestore(&priv->lock, flags);
2113
43f66a6c
JK		 2114 /* enable all interrupts */
2115 ipw_enable_interrupts(priv);
43f66a6c 2116}
bf79451e 2117
43f66a6c
JK		 2118#define IPW_CMD(x) case IPW_CMD_ ## x : return #x
2119static char *get_cmd_string(u8 cmd)
2120{
2121 switch (cmd) {
2122 IPW_CMD(HOST_COMPLETE);
bf79451e
JG		 2123 IPW_CMD(POWER_DOWN);
2124 IPW_CMD(SYSTEM_CONFIG);
2125 IPW_CMD(MULTICAST_ADDRESS);
2126 IPW_CMD(SSID);
2127 IPW_CMD(ADAPTER_ADDRESS);
2128 IPW_CMD(PORT_TYPE);
2129 IPW_CMD(RTS_THRESHOLD);
2130 IPW_CMD(FRAG_THRESHOLD);
2131 IPW_CMD(POWER_MODE);
2132 IPW_CMD(WEP_KEY);
2133 IPW_CMD(TGI_TX_KEY);
2134 IPW_CMD(SCAN_REQUEST);
2135 IPW_CMD(SCAN_REQUEST_EXT);
2136 IPW_CMD(ASSOCIATE);
2137 IPW_CMD(SUPPORTED_RATES);
2138 IPW_CMD(SCAN_ABORT);
2139 IPW_CMD(TX_FLUSH);
2140 IPW_CMD(QOS_PARAMETERS);
2141 IPW_CMD(DINO_CONFIG);
2142 IPW_CMD(RSN_CAPABILITIES);
2143 IPW_CMD(RX_KEY);
2144 IPW_CMD(CARD_DISABLE);
2145 IPW_CMD(SEED_NUMBER);
2146 IPW_CMD(TX_POWER);
2147 IPW_CMD(COUNTRY_INFO);
2148 IPW_CMD(AIRONET_INFO);
2149 IPW_CMD(AP_TX_POWER);
2150 IPW_CMD(CCKM_INFO);
2151 IPW_CMD(CCX_VER_INFO);
2152 IPW_CMD(SET_CALIBRATION);
2153 IPW_CMD(SENSITIVITY_CALIB);
2154 IPW_CMD(RETRY_LIMIT);
2155 IPW_CMD(IPW_PRE_POWER_DOWN);
2156 IPW_CMD(VAP_BEACON_TEMPLATE);
2157 IPW_CMD(VAP_DTIM_PERIOD);
2158 IPW_CMD(EXT_SUPPORTED_RATES);
2159 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
2160 IPW_CMD(VAP_QUIET_INTERVALS);
2161 IPW_CMD(VAP_CHANNEL_SWITCH);
2162 IPW_CMD(VAP_MANDATORY_CHANNELS);
2163 IPW_CMD(VAP_CELL_PWR_LIMIT);
2164 IPW_CMD(VAP_CF_PARAM_SET);
2165 IPW_CMD(VAP_SET_BEACONING_STATE);
2166 IPW_CMD(MEASUREMENT);
2167 IPW_CMD(POWER_CAPABILITY);
2168 IPW_CMD(SUPPORTED_CHANNELS);
2169 IPW_CMD(TPC_REPORT);
2170 IPW_CMD(WME_INFO);
2171 IPW_CMD(PRODUCTION_COMMAND);
2172 default:
43f66a6c
JK		 2173 return "UNKNOWN";
2174 }
2175}
43f66a6c
JK		 2176
2177#define HOST_COMPLETE_TIMEOUT HZ
0a7bcf26
ZY		 2178
2179static int __ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
43f66a6c
JK		 2180{
2181 int rc = 0;
a613bffd 2182 unsigned long flags;
43f66a6c 2183
a613bffd 2184 spin_lock_irqsave(&priv->lock, flags);
43f66a6c 2185 if (priv->status & STATUS_HCMD_ACTIVE) {
9ddf84f6
JK		 2186 IPW_ERROR("Failed to send %s: Already sending a command.\n",
2187 get_cmd_string(cmd->cmd));
a613bffd 2188 spin_unlock_irqrestore(&priv->lock, flags);
9ddf84f6 2189 return -EAGAIN;
43f66a6c
JK		 2190 }
2191
2192 priv->status |= STATUS_HCMD_ACTIVE;
bf79451e 2193
f6c5cb7c
JK		 2194 if (priv->cmdlog) {
2195 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
2196 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
2197 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
2198 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
2199 cmd->len);
2200 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
2201 }
2202
b095c381
JK		 2203 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
2204 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
2205 priv->status);
f516dbcd
ZY		 2206
2207#ifndef DEBUG_CMD_WEP_KEY
2208 if (cmd->cmd == IPW_CMD_WEP_KEY)
2209 IPW_DEBUG_HC("WEP_KEY command masked out for secure.\n");
2210 else
2211#endif
2212 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
2213
0a7bcf26 2214 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
a613bffd
JK		 2215 if (rc) {
2216 priv->status &= ~STATUS_HCMD_ACTIVE;
9ddf84f6
JK		 2217 IPW_ERROR("Failed to send %s: Reason %d\n",
2218 get_cmd_string(cmd->cmd), rc);
a613bffd 2219 spin_unlock_irqrestore(&priv->lock, flags);
f6c5cb7c 2220 goto exit;
a613bffd
JK		 2221 }
2222 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 2223
0edd5b44
JG		 2224 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
2225 !(priv->
2226 status & STATUS_HCMD_ACTIVE),
2227 HOST_COMPLETE_TIMEOUT);
43f66a6c 2228 if (rc == 0) {
a613bffd
JK		 2229 spin_lock_irqsave(&priv->lock, flags);
2230 if (priv->status & STATUS_HCMD_ACTIVE) {
9ddf84f6
JK		 2231 IPW_ERROR("Failed to send %s: Command timed out.\n",
2232 get_cmd_string(cmd->cmd));
a613bffd
JK		 2233 priv->status &= ~STATUS_HCMD_ACTIVE;
2234 spin_unlock_irqrestore(&priv->lock, flags);
f6c5cb7c
JK		 2235 rc = -EIO;
2236 goto exit;
a613bffd
JK		 2237 }
2238 spin_unlock_irqrestore(&priv->lock, flags);
3b9990cb
JK		 2239 } else
2240 rc = 0;
a613bffd 2241
b095c381 2242 if (priv->status & STATUS_RF_KILL_HW) {
9ddf84f6
JK		 2243 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
2244 get_cmd_string(cmd->cmd));
f6c5cb7c
JK		 2245 rc = -EIO;
2246 goto exit;
43f66a6c
JK		 2247 }
2248
2638bc39 2249 exit:
f6c5cb7c
JK		 2250 if (priv->cmdlog) {
2251 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
2252 priv->cmdlog_pos %= priv->cmdlog_len;
2253 }
2254 return rc;
43f66a6c
JK		 2255}
2256
0a7bcf26
ZY		 2257static int ipw_send_cmd_simple(struct ipw_priv *priv, u8 command)
2258{
2259 struct host_cmd cmd = {
2260 .cmd = command,
2261 };
2262
2263 return __ipw_send_cmd(priv, &cmd);
2264}
2265
2266static int ipw_send_cmd_pdu(struct ipw_priv *priv, u8 command, u8 len,
2267 void *data)
43f66a6c
JK		 2268{
2269 struct host_cmd cmd = {
0a7bcf26
ZY		 2270 .cmd = command,
2271 .len = len,
2272 .param = data,
43f66a6c
JK		 2273 };
2274
0a7bcf26
ZY		 2275 return __ipw_send_cmd(priv, &cmd);
2276}
2277
2278static int ipw_send_host_complete(struct ipw_priv *priv)
2279{
43f66a6c
JK		 2280 if (!priv) {
2281 IPW_ERROR("Invalid args\n");
2282 return -1;
2283 }
2284
0a7bcf26 2285 return ipw_send_cmd_simple(priv, IPW_CMD_HOST_COMPLETE);
43f66a6c
JK		 2286}
2287
d685b8c2 2288static int ipw_send_system_config(struct ipw_priv *priv)
43f66a6c 2289{
d685b8c2
ZY		 2290 return ipw_send_cmd_pdu(priv, IPW_CMD_SYSTEM_CONFIG,
2291 sizeof(priv->sys_config),
2292 &priv->sys_config);
43f66a6c
JK		 2293}
2294
0edd5b44 2295static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
43f66a6c 2296{
43f66a6c
JK		 2297 if (!priv || !ssid) {
2298 IPW_ERROR("Invalid args\n");
2299 return -1;
2300 }
2301
0a7bcf26 2302 return ipw_send_cmd_pdu(priv, IPW_CMD_SSID, min(len, IW_ESSID_MAX_SIZE),
2638bc39 2303 ssid);
43f66a6c
JK		 2304}
2305
0edd5b44 2306static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
43f66a6c 2307{
43f66a6c
JK		 2308 if (!priv || !mac) {
2309 IPW_ERROR("Invalid args\n");
2310 return -1;
2311 }
2312
e174961c
JB		 2313 IPW_DEBUG_INFO("%s: Setting MAC to %pM\n",
2314 priv->net_dev->name, mac);
43f66a6c 2315
2638bc39 2316 return ipw_send_cmd_pdu(priv, IPW_CMD_ADAPTER_ADDRESS, ETH_ALEN, mac);
43f66a6c
JK		 2317}
2318
a613bffd
JK		 2319/*
2320 * NOTE: This must be executed from our workqueue as it results in udelay
2321 * being called which may corrupt the keyboard if executed on default
2322 * workqueue
2323 */
43f66a6c
JK		 2324static void ipw_adapter_restart(void *adapter)
2325{
2326 struct ipw_priv *priv = adapter;
2327
2328 if (priv->status & STATUS_RF_KILL_MASK)
2329 return;
2330
2331 ipw_down(priv);
b095c381
JK		 2332
2333 if (priv->assoc_network &&
2334 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2335 ipw_remove_current_network(priv);
2336
43f66a6c
JK		 2337 if (ipw_up(priv)) {
2338 IPW_ERROR("Failed to up device\n");
2339 return;
2340 }
2341}
2342
c4028958 2343static void ipw_bg_adapter_restart(struct work_struct *work)
c848d0af 2344{
c4028958
DH		 2345 struct ipw_priv *priv =
2346 container_of(work, struct ipw_priv, adapter_restart);
4644151b 2347 mutex_lock(&priv->mutex);
c4028958 2348 ipw_adapter_restart(priv);
4644151b 2349 mutex_unlock(&priv->mutex);
c848d0af
JK		 2350}
2351
e65054b6
ZY		 2352static void ipw_abort_scan(struct ipw_priv *priv);
2353
2354#define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
43f66a6c
JK		 2355
2356static void ipw_scan_check(void *data)
2357{
2358 struct ipw_priv *priv = data;
e65054b6
ZY		 2359
2360 if (priv->status & STATUS_SCAN_ABORTING) {
43f66a6c 2361 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
c7b6a674
ZY		 2362 "adapter after (%dms).\n",
2363 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
a613bffd 2364 queue_work(priv->workqueue, &priv->adapter_restart);
e65054b6
ZY		 2365 } else if (priv->status & STATUS_SCANNING) {
2366 IPW_DEBUG_SCAN("Scan completion watchdog aborting scan "
2367 "after (%dms).\n",
2368 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2369 ipw_abort_scan(priv);
2370 queue_delayed_work(priv->workqueue, &priv->scan_check, HZ);
43f66a6c
JK		 2371 }
2372}
2373
c4028958 2374static void ipw_bg_scan_check(struct work_struct *work)
c848d0af 2375{
c4028958
DH		 2376 struct ipw_priv *priv =
2377 container_of(work, struct ipw_priv, scan_check.work);
4644151b 2378 mutex_lock(&priv->mutex);
c4028958 2379 ipw_scan_check(priv);
4644151b 2380 mutex_unlock(&priv->mutex);
c848d0af
JK		 2381}
2382
43f66a6c
JK		 2383static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2384 struct ipw_scan_request_ext *request)
2385{
0a7bcf26 2386 return ipw_send_cmd_pdu(priv, IPW_CMD_SCAN_REQUEST_EXT,
2638bc39 2387 sizeof(*request), request);
43f66a6c
JK		 2388}
2389
2390static int ipw_send_scan_abort(struct ipw_priv *priv)
2391{
43f66a6c
JK		 2392 if (!priv) {
2393 IPW_ERROR("Invalid args\n");
2394 return -1;
2395 }
2396
0a7bcf26 2397 return ipw_send_cmd_simple(priv, IPW_CMD_SCAN_ABORT);
43f66a6c
JK		 2398}
2399
2400static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2401{
0a7bcf26 2402 struct ipw_sensitivity_calib calib = {
851ca268 2403 .beacon_rssi_raw = cpu_to_le16(sens),
43f66a6c 2404 };
0a7bcf26
ZY		 2405
2406 return ipw_send_cmd_pdu(priv, IPW_CMD_SENSITIVITY_CALIB, sizeof(calib),
2638bc39 2407 &calib);
43f66a6c
JK		 2408}
2409
2410static int ipw_send_associate(struct ipw_priv *priv,
2411 struct ipw_associate *associate)
2412{
0a7bcf26
ZY		 2413 if (!priv || !associate) {
2414 IPW_ERROR("Invalid args\n");
2415 return -1;
2416 }
2417
5b5e807f
AV		 2418 return ipw_send_cmd_pdu(priv, IPW_CMD_ASSOCIATE, sizeof(*associate),
2419 associate);
43f66a6c
JK		 2420}
2421
2422static int ipw_send_supported_rates(struct ipw_priv *priv,
2423 struct ipw_supported_rates *rates)
2424{
43f66a6c
JK		 2425 if (!priv || !rates) {
2426 IPW_ERROR("Invalid args\n");
2427 return -1;
2428 }
2429
0a7bcf26 2430 return ipw_send_cmd_pdu(priv, IPW_CMD_SUPPORTED_RATES, sizeof(*rates),
2638bc39 2431 rates);
43f66a6c
JK		 2432}
2433
2434static int ipw_set_random_seed(struct ipw_priv *priv)
2435{
0a7bcf26 2436 u32 val;
43f66a6c
JK		 2437
2438 if (!priv) {
2439 IPW_ERROR("Invalid args\n");
2440 return -1;
2441 }
2442
0a7bcf26 2443 get_random_bytes(&val, sizeof(val));
43f66a6c 2444
0a7bcf26 2445 return ipw_send_cmd_pdu(priv, IPW_CMD_SEED_NUMBER, sizeof(val), &val);
43f66a6c
JK		 2446}
2447
43f66a6c
JK		 2448static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2449{
e62e1ee0 2450 __le32 v = cpu_to_le32(phy_off);
43f66a6c
JK		 2451 if (!priv) {
2452 IPW_ERROR("Invalid args\n");
2453 return -1;
2454 }
2455
e62e1ee0 2456 return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(v), &v);
43f66a6c 2457}
43f66a6c 2458
0edd5b44 2459static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
43f66a6c 2460{
43f66a6c
JK		 2461 if (!priv || !power) {
2462 IPW_ERROR("Invalid args\n");
2463 return -1;
2464 }
2465
2638bc39 2466 return ipw_send_cmd_pdu(priv, IPW_CMD_TX_POWER, sizeof(*power), power);
43f66a6c
JK		 2467}
2468
6de9f7f2
ZY		 2469static int ipw_set_tx_power(struct ipw_priv *priv)
2470{
b0a4e7d8 2471 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
6de9f7f2
ZY		 2472 struct ipw_tx_power tx_power;
2473 s8 max_power;
2474 int i;
2475
2476 memset(&tx_power, 0, sizeof(tx_power));
2477
2478 /* configure device for 'G' band */
2479 tx_power.ieee_mode = IPW_G_MODE;
2480 tx_power.num_channels = geo->bg_channels;
2481 for (i = 0; i < geo->bg_channels; i++) {
2482 max_power = geo->bg[i].max_power;
2483 tx_power.channels_tx_power[i].channel_number =
2484 geo->bg[i].channel;
2485 tx_power.channels_tx_power[i].tx_power = max_power ?
2486 min(max_power, priv->tx_power) : priv->tx_power;
43f66a6c 2487 }
6de9f7f2
ZY		 2488 if (ipw_send_tx_power(priv, &tx_power))
2489 return -EIO;
2490
2491 /* configure device to also handle 'B' band */
2492 tx_power.ieee_mode = IPW_B_MODE;
2493 if (ipw_send_tx_power(priv, &tx_power))
2494 return -EIO;
bf79451e 2495
6de9f7f2
ZY		 2496 /* configure device to also handle 'A' band */
2497 if (priv->ieee->abg_true) {
2498 tx_power.ieee_mode = IPW_A_MODE;
2499 tx_power.num_channels = geo->a_channels;
2500 for (i = 0; i < tx_power.num_channels; i++) {
2501 max_power = geo->a[i].max_power;
2502 tx_power.channels_tx_power[i].channel_number =
2503 geo->a[i].channel;
2504 tx_power.channels_tx_power[i].tx_power = max_power ?
2505 min(max_power, priv->tx_power) : priv->tx_power;
2506 }
2507 if (ipw_send_tx_power(priv, &tx_power))
2508 return -EIO;
2509 }
43f66a6c
JK		 2510 return 0;
2511}
2512
2513static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2514{
2515 struct ipw_rts_threshold rts_threshold = {
851ca268 2516 .rts_threshold = cpu_to_le16(rts),
43f66a6c 2517 };
43f66a6c
JK		 2518
2519 if (!priv) {
2520 IPW_ERROR("Invalid args\n");
2521 return -1;
2522 }
2523
0a7bcf26
ZY		 2524 return ipw_send_cmd_pdu(priv, IPW_CMD_RTS_THRESHOLD,
2525 sizeof(rts_threshold), &rts_threshold);
43f66a6c
JK		 2526}
2527
2528static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2529{
2530 struct ipw_frag_threshold frag_threshold = {
851ca268 2531 .frag_threshold = cpu_to_le16(frag),
43f66a6c 2532 };
43f66a6c
JK		 2533
2534 if (!priv) {
2535 IPW_ERROR("Invalid args\n");
2536 return -1;
2537 }
2538
0a7bcf26
ZY		 2539 return ipw_send_cmd_pdu(priv, IPW_CMD_FRAG_THRESHOLD,
2540 sizeof(frag_threshold), &frag_threshold);
43f66a6c
JK		 2541}
2542
2543static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2544{
e62e1ee0 2545 __le32 param;
43f66a6c
JK		 2546
2547 if (!priv) {
2548 IPW_ERROR("Invalid args\n");
2549 return -1;
2550 }
bf79451e 2551
43f66a6c
JK		 2552 /* If on battery, set to 3, if AC set to CAM, else user
2553 * level */
2554 switch (mode) {
2555 case IPW_POWER_BATTERY:
e62e1ee0 2556 param = cpu_to_le32(IPW_POWER_INDEX_3);
43f66a6c
JK		 2557 break;
2558 case IPW_POWER_AC:
e62e1ee0 2559 param = cpu_to_le32(IPW_POWER_MODE_CAM);
43f66a6c
JK		 2560 break;
2561 default:
e62e1ee0 2562 param = cpu_to_le32(mode);
43f66a6c
JK		 2563 break;
2564 }
2565
0a7bcf26 2566 return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
2638bc39 2567 &param);
43f66a6c
JK		 2568}
2569
afbf30a2
JK		 2570static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2571{
2572 struct ipw_retry_limit retry_limit = {
2573 .short_retry_limit = slimit,
2574 .long_retry_limit = llimit
2575 };
afbf30a2
JK		 2576
2577 if (!priv) {
2578 IPW_ERROR("Invalid args\n");
2579 return -1;
2580 }
2581
0a7bcf26 2582 return ipw_send_cmd_pdu(priv, IPW_CMD_RETRY_LIMIT, sizeof(retry_limit),
2638bc39 2583 &retry_limit);
afbf30a2
JK		 2584}
2585
43f66a6c
JK		 2586/*
2587 * The IPW device contains a Microwire compatible EEPROM that stores
2588 * various data like the MAC address. Usually the firmware has exclusive
2589 * access to the eeprom, but during device initialization (before the
2590 * device driver has sent the HostComplete command to the firmware) the
2591 * device driver has read access to the EEPROM by way of indirect addressing
2592 * through a couple of memory mapped registers.
2593 *
2594 * The following is a simplified implementation for pulling data out of the
2595 * the eeprom, along with some helper functions to find information in
2596 * the per device private data's copy of the eeprom.
2597 *
2598 * NOTE: To better understand how these functions work (i.e what is a chip
2599 * select and why do have to keep driving the eeprom clock?), read
2600 * just about any data sheet for a Microwire compatible EEPROM.
2601 */
2602
2603/* write a 32 bit value into the indirect accessor register */
2604static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2605{
2606 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
bf79451e 2607
43f66a6c
JK		 2608 /* the eeprom requires some time to complete the operation */
2609 udelay(p->eeprom_delay);
43f66a6c
JK		 2610}
2611
2612/* perform a chip select operation */
858119e1 2613static void eeprom_cs(struct ipw_priv *priv)
43f66a6c 2614{
0edd5b44
JG		 2615 eeprom_write_reg(priv, 0);
2616 eeprom_write_reg(priv, EEPROM_BIT_CS);
2617 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2618 eeprom_write_reg(priv, EEPROM_BIT_CS);
43f66a6c
JK		 2619}
2620
2621/* perform a chip select operation */
858119e1 2622static void eeprom_disable_cs(struct ipw_priv *priv)
43f66a6c 2623{
0edd5b44
JG		 2624 eeprom_write_reg(priv, EEPROM_BIT_CS);
2625 eeprom_write_reg(priv, 0);
2626 eeprom_write_reg(priv, EEPROM_BIT_SK);
43f66a6c
JK		 2627}
2628
2629/* push a single bit down to the eeprom */
0edd5b44 2630static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
43f66a6c 2631{
0edd5b44
JG		 2632 int d = (bit ? EEPROM_BIT_DI : 0);
2633 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2634 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
43f66a6c
JK		 2635}
2636
2637/* push an opcode followed by an address down to the eeprom */
0edd5b44 2638static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
43f66a6c
JK		 2639{
2640 int i;
2641
2642 eeprom_cs(priv);
0edd5b44
JG		 2643 eeprom_write_bit(priv, 1);
2644 eeprom_write_bit(priv, op & 2);
2645 eeprom_write_bit(priv, op & 1);
2646 for (i = 7; i >= 0; i--) {
2647 eeprom_write_bit(priv, addr & (1 << i));
43f66a6c
JK		 2648 }
2649}
2650
2651/* pull 16 bits off the eeprom, one bit at a time */
0edd5b44 2652static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
43f66a6c
JK		 2653{
2654 int i;
0edd5b44 2655 u16 r = 0;
bf79451e 2656
43f66a6c 2657 /* Send READ Opcode */
0edd5b44 2658 eeprom_op(priv, EEPROM_CMD_READ, addr);
43f66a6c
JK		 2659
2660 /* Send dummy bit */
0edd5b44 2661 eeprom_write_reg(priv, EEPROM_BIT_CS);
43f66a6c
JK		 2662
2663 /* Read the byte off the eeprom one bit at a time */
0edd5b44 2664 for (i = 0; i < 16; i++) {
43f66a6c 2665 u32 data = 0;
0edd5b44
JG		 2666 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2667 eeprom_write_reg(priv, EEPROM_BIT_CS);
2668 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2669 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
43f66a6c 2670 }
bf79451e 2671
43f66a6c 2672 /* Send another dummy bit */
0edd5b44 2673 eeprom_write_reg(priv, 0);
43f66a6c 2674 eeprom_disable_cs(priv);
bf79451e 2675
43f66a6c
JK		 2676 return r;
2677}
2678
2679/* helper function for pulling the mac address out of the private */
2680/* data's copy of the eeprom data */
0edd5b44 2681static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
43f66a6c 2682{
afbf30a2 2683 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
43f66a6c
JK		 2684}
2685
2686/*
2687 * Either the device driver (i.e. the host) or the firmware can
2688 * load eeprom data into the designated region in SRAM. If neither
2689 * happens then the FW will shutdown with a fatal error.
2690 *
2691 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2692 * bit needs region of shared SRAM needs to be non-zero.
2693 */
2694static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2695{
2696 int i;
e62e1ee0 2697 __le16 *eeprom = (__le16 *) priv->eeprom;
bf79451e 2698
43f66a6c
JK		 2699 IPW_DEBUG_TRACE(">>\n");
2700
2701 /* read entire contents of eeprom into private buffer */
0edd5b44 2702 for (i = 0; i < 128; i++)
e62e1ee0 2703 eeprom[i] = cpu_to_le16(eeprom_read_u16(priv, (u8) i));
43f66a6c 2704
bf79451e
JG		 2705 /*
2706 If the data looks correct, then copy it to our private
43f66a6c 2707 copy. Otherwise let the firmware know to perform the operation
c7b6a674 2708 on its own.
0edd5b44 2709 */
386093ef 2710 if (priv->eeprom[EEPROM_VERSION] != 0) {
43f66a6c
JK		 2711 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2712
2713 /* write the eeprom data to sram */
b095c381 2714 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
0edd5b44 2715 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
43f66a6c
JK		 2716
2717 /* Do not load eeprom data on fatal error or suspend */
2718 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2719 } else {
2720 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2721
2722 /* Load eeprom data on fatal error or suspend */
2723 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2724 }
2725
2726 IPW_DEBUG_TRACE("<<\n");
2727}
2728
858119e1 2729static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
43f66a6c
JK		 2730{
2731 count >>= 2;
0edd5b44
JG		 2732 if (!count)
2733 return;
b095c381 2734 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
bf79451e 2735 while (count--)
b095c381 2736 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
43f66a6c
JK		 2737}
2738
2739static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2740{
b095c381 2741 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
bf79451e 2742 CB_NUMBER_OF_ELEMENTS_SMALL *
43f66a6c
JK		 2743 sizeof(struct command_block));
2744}
2745
2746static int ipw_fw_dma_enable(struct ipw_priv *priv)
0edd5b44 2747{ /* start dma engine but no transfers yet */
43f66a6c 2748
9fd1ea42 2749 IPW_DEBUG_FW(">> :\n");
bf79451e 2750
43f66a6c
JK		 2751 /* Start the dma */
2752 ipw_fw_dma_reset_command_blocks(priv);
bf79451e 2753
43f66a6c 2754 /* Write CB base address */
b095c381 2755 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
43f66a6c 2756
9fd1ea42 2757 IPW_DEBUG_FW("<< :\n");
43f66a6c
JK		 2758 return 0;
2759}
2760
2761static void ipw_fw_dma_abort(struct ipw_priv *priv)
2762{
2763 u32 control = 0;
2764
2765 IPW_DEBUG_FW(">> :\n");
bf79451e 2766
67fd6b45 2767 /* set the Stop and Abort bit */
43f66a6c 2768 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
b095c381 2769 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
43f66a6c 2770 priv->sram_desc.last_cb_index = 0;
bf79451e 2771
9fd1ea42 2772 IPW_DEBUG_FW("<<\n");
43f66a6c
JK		 2773}
2774
0edd5b44
JG		 2775static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2776 struct command_block *cb)
43f66a6c 2777{
0edd5b44 2778 u32 address =
b095c381 2779 IPW_SHARED_SRAM_DMA_CONTROL +
0edd5b44 2780 (sizeof(struct command_block) * index);
43f66a6c
JK		 2781 IPW_DEBUG_FW(">> :\n");
2782
0edd5b44
JG		 2783 ipw_write_indirect(priv, address, (u8 *) cb,
2784 (int)sizeof(struct command_block));
43f66a6c
JK		 2785
2786 IPW_DEBUG_FW("<< :\n");
2787 return 0;
2788
2789}
2790
2791static int ipw_fw_dma_kick(struct ipw_priv *priv)
2792{
2793 u32 control = 0;
0edd5b44 2794 u32 index = 0;
43f66a6c
JK		 2795
2796 IPW_DEBUG_FW(">> :\n");
bf79451e 2797
43f66a6c 2798 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
0edd5b44
JG		 2799 ipw_fw_dma_write_command_block(priv, index,
2800 &priv->sram_desc.cb_list[index]);
43f66a6c
JK		 2801
2802 /* Enable the DMA in the CSR register */
b095c381
JK		 2803 ipw_clear_bit(priv, IPW_RESET_REG,
2804 IPW_RESET_REG_MASTER_DISABLED |
2805 IPW_RESET_REG_STOP_MASTER);
bf79451e 2806
0edd5b44 2807 /* Set the Start bit. */
43f66a6c 2808 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
b095c381 2809 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
43f66a6c
JK		 2810
2811 IPW_DEBUG_FW("<< :\n");
2812 return 0;
2813}
2814
2815static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2816{
2817 u32 address;
0edd5b44
JG		 2818 u32 register_value = 0;
2819 u32 cb_fields_address = 0;
43f66a6c
JK		 2820
2821 IPW_DEBUG_FW(">> :\n");
b095c381 2822 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
9fd1ea42 2823 IPW_DEBUG_FW_INFO("Current CB is 0x%x\n", address);
43f66a6c
JK		 2824
2825 /* Read the DMA Controlor register */
b095c381 2826 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
9fd1ea42 2827 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x\n", register_value);
43f66a6c 2828
0edd5b44 2829 /* Print the CB values */
43f66a6c
JK		 2830 cb_fields_address = address;
2831 register_value = ipw_read_reg32(priv, cb_fields_address);
9fd1ea42 2832 IPW_DEBUG_FW_INFO("Current CB Control Field is 0x%x\n", register_value);
43f66a6c
JK		 2833
2834 cb_fields_address += sizeof(u32);
2835 register_value = ipw_read_reg32(priv, cb_fields_address);
9fd1ea42 2836 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x\n", register_value);
43f66a6c
JK		 2837
2838 cb_fields_address += sizeof(u32);
2839 register_value = ipw_read_reg32(priv, cb_fields_address);
9fd1ea42 2840 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x\n",
43f66a6c
JK		 2841 register_value);
2842
2843 cb_fields_address += sizeof(u32);
2844 register_value = ipw_read_reg32(priv, cb_fields_address);
9fd1ea42 2845 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x\n", register_value);
43f66a6c
JK		 2846
2847 IPW_DEBUG_FW(">> :\n");
2848}
2849
2850static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2851{
2852 u32 current_cb_address = 0;
2853 u32 current_cb_index = 0;
2854
2855 IPW_DEBUG_FW("<< :\n");
b095c381 2856 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
bf79451e 2857
b095c381 2858 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
0edd5b44 2859 sizeof(struct command_block);
bf79451e 2860
9fd1ea42 2861 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X\n",
0edd5b44 2862 current_cb_index, current_cb_address);
43f66a6c
JK		 2863
2864 IPW_DEBUG_FW(">> :\n");
2865 return current_cb_index;
2866
2867}
2868
2869static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2870 u32 src_address,
2871 u32 dest_address,
2872 u32 length,
0edd5b44 2873 int interrupt_enabled, int is_last)
43f66a6c
JK		 2874{
2875
bf79451e 2876 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
0edd5b44
JG		 2877 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2878 CB_DEST_SIZE_LONG;
43f66a6c 2879 struct command_block *cb;
0edd5b44 2880 u32 last_cb_element = 0;
43f66a6c
JK		 2881
2882 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2883 src_address, dest_address, length);
2884
2885 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2886 return -1;
2887
2888 last_cb_element = priv->sram_desc.last_cb_index;
2889 cb = &priv->sram_desc.cb_list[last_cb_element];
2890 priv->sram_desc.last_cb_index++;
2891
2892 /* Calculate the new CB control word */
0edd5b44 2893 if (interrupt_enabled)
43f66a6c
JK		 2894 control |= CB_INT_ENABLED;
2895
2896 if (is_last)
2897 control |= CB_LAST_VALID;
bf79451e 2898
43f66a6c
JK		 2899 control |= length;
2900
2901 /* Calculate the CB Element's checksum value */
0edd5b44 2902 cb->status = control ^ src_address ^ dest_address;
43f66a6c
JK		 2903
2904 /* Copy the Source and Destination addresses */
2905 cb->dest_addr = dest_address;
2906 cb->source_addr = src_address;
2907
2908 /* Copy the Control Word last */
2909 cb->control = control;
2910
2911 return 0;
2912}
2913
11ebd1bf
ZY		 2914static int ipw_fw_dma_add_buffer(struct ipw_priv *priv, dma_addr_t *src_address,
2915 int nr, u32 dest_address, u32 len)
43f66a6c 2916{
11ebd1bf
ZY		 2917 int ret, i;
2918 u32 size;
2919
9fd1ea42 2920 IPW_DEBUG_FW(">>\n");
11ebd1bf
ZY		 2921 IPW_DEBUG_FW_INFO("nr=%d dest_address=0x%x len=0x%x\n",
2922 nr, dest_address, len);
2923
2924 for (i = 0; i < nr; i++) {
2925 size = min_t(u32, len - i * CB_MAX_LENGTH, CB_MAX_LENGTH);
2926 ret = ipw_fw_dma_add_command_block(priv, src_address[i],
2927 dest_address +
2928 i * CB_MAX_LENGTH, size,
2929 0, 0);
2930 if (ret) {
43f66a6c
JK		 2931 IPW_DEBUG_FW_INFO(": Failed\n");
2932 return -1;
bf79451e 2933 } else
43f66a6c 2934 IPW_DEBUG_FW_INFO(": Added new cb\n");
43f66a6c 2935 }
bf79451e 2936
9fd1ea42 2937 IPW_DEBUG_FW("<<\n");
43f66a6c
JK		 2938 return 0;
2939}
2940
2941static int ipw_fw_dma_wait(struct ipw_priv *priv)
2942{
397ae121 2943 u32 current_index = 0, previous_index;
43f66a6c
JK		 2944 u32 watchdog = 0;
2945
9fd1ea42 2946 IPW_DEBUG_FW(">> :\n");
43f66a6c
JK		 2947
2948 current_index = ipw_fw_dma_command_block_index(priv);
397ae121 2949 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%08X\n",
0edd5b44 2950 (int)priv->sram_desc.last_cb_index);
43f66a6c
JK		 2951
2952 while (current_index < priv->sram_desc.last_cb_index) {
2953 udelay(50);
397ae121 2954 previous_index = current_index;
43f66a6c
JK		 2955 current_index = ipw_fw_dma_command_block_index(priv);
2956
397ae121
ZY		 2957 if (previous_index < current_index) {
2958 watchdog = 0;
2959 continue;
2960 }
2961 if (++watchdog > 400) {
43f66a6c
JK		 2962 IPW_DEBUG_FW_INFO("Timeout\n");
2963 ipw_fw_dma_dump_command_block(priv);
2964 ipw_fw_dma_abort(priv);
2965 return -1;
2966 }
2967 }
2968
2969 ipw_fw_dma_abort(priv);
2970
0edd5b44 2971 /*Disable the DMA in the CSR register */
b095c381
JK		 2972 ipw_set_bit(priv, IPW_RESET_REG,
2973 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
43f66a6c 2974
9fd1ea42 2975 IPW_DEBUG_FW("<< dmaWaitSync\n");
43f66a6c
JK		 2976 return 0;
2977}
2978
bf79451e 2979static void ipw_remove_current_network(struct ipw_priv *priv)
43f66a6c
JK		 2980{
2981 struct list_head *element, *safe;
b0a4e7d8 2982 struct libipw_network *network = NULL;
a613bffd
JK		 2983 unsigned long flags;
2984
2985 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c 2986 list_for_each_safe(element, safe, &priv->ieee->network_list) {
b0a4e7d8 2987 network = list_entry(element, struct libipw_network, list);
43f66a6c
JK		 2988 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2989 list_del(element);
bf79451e 2990 list_add_tail(&network->list,
43f66a6c
JK		 2991 &priv->ieee->network_free_list);
2992 }
2993 }
a613bffd 2994 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c
JK		 2995}
2996
2997/**
bf79451e 2998 * Check that card is still alive.
43f66a6c
JK		 2999 * Reads debug register from domain0.
3000 * If card is present, pre-defined value should
3001 * be found there.
bf79451e 3002 *
43f66a6c
JK		 3003 * @param priv
3004 * @return 1 if card is present, 0 otherwise
3005 */
3006static inline int ipw_alive(struct ipw_priv *priv)
3007{
3008 return ipw_read32(priv, 0x90) == 0xd55555d5;
3009}
3010
c7b6a674 3011/* timeout in msec, attempted in 10-msec quanta */
858119e1 3012static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
43f66a6c
JK		 3013 int timeout)
3014{
3015 int i = 0;
3016
3017 do {
bf79451e 3018 if ((ipw_read32(priv, addr) & mask) == mask)
43f66a6c
JK		 3019 return i;
3020 mdelay(10);
3021 i += 10;
3022 } while (i < timeout);
bf79451e 3023
43f66a6c
JK		 3024 return -ETIME;
3025}
3026
bf79451e 3027/* These functions load the firmware and micro code for the operation of
43f66a6c
JK		 3028 * the ipw hardware. It assumes the buffer has all the bits for the
3029 * image and the caller is handling the memory allocation and clean up.
3030 */
3031
0edd5b44 3032static int ipw_stop_master(struct ipw_priv *priv)
43f66a6c
JK		 3033{
3034 int rc;
bf79451e 3035
9fd1ea42 3036 IPW_DEBUG_TRACE(">>\n");
43f66a6c 3037 /* stop master. typical delay - 0 */
b095c381 3038 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
43f66a6c 3039
c7b6a674 3040 /* timeout is in msec, polled in 10-msec quanta */
b095c381
JK		 3041 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3042 IPW_RESET_REG_MASTER_DISABLED, 100);
43f66a6c 3043 if (rc < 0) {
c7b6a674 3044 IPW_ERROR("wait for stop master failed after 100ms\n");
43f66a6c
JK		 3045 return -1;
3046 }
3047
3048 IPW_DEBUG_INFO("stop master %dms\n", rc);
3049
3050 return rc;
3051}
3052
3053static void ipw_arc_release(struct ipw_priv *priv)
3054{
9fd1ea42 3055 IPW_DEBUG_TRACE(">>\n");
43f66a6c
JK		 3056 mdelay(5);
3057
b095c381 3058 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
43f66a6c
JK		 3059
3060 /* no one knows timing, for safety add some delay */
3061 mdelay(5);
3062}
3063
43f66a6c 3064struct fw_chunk {
e62e1ee0
AV		 3065 __le32 address;
3066 __le32 length;
43f66a6c
JK		 3067};
3068
0edd5b44 3069static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
43f66a6c
JK		 3070{
3071 int rc = 0, i, addr;
3072 u8 cr = 0;
e62e1ee0 3073 __le16 *image;
43f66a6c 3074
e62e1ee0 3075 image = (__le16 *) data;
bf79451e 3076
9fd1ea42 3077 IPW_DEBUG_TRACE(">>\n");
43f66a6c
JK		 3078
3079 rc = ipw_stop_master(priv);
3080
3081 if (rc < 0)
3082 return rc;
bf79451e 3083
b095c381
JK		 3084 for (addr = IPW_SHARED_LOWER_BOUND;
3085 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
43f66a6c
JK		 3086 ipw_write32(priv, addr, 0);
3087 }
3088
3089 /* no ucode (yet) */
3090 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
3091 /* destroy DMA queues */
3092 /* reset sequence */
3093
b095c381 3094 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
43f66a6c 3095 ipw_arc_release(priv);
b095c381 3096 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
43f66a6c
JK		 3097 mdelay(1);
3098
3099 /* reset PHY */
b095c381 3100 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
43f66a6c 3101 mdelay(1);
bf79451e 3102
b095c381 3103 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
43f66a6c 3104 mdelay(1);
bf79451e 3105
43f66a6c 3106 /* enable ucode store */
c8fe6679
ZY		 3107 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
3108 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
43f66a6c
JK		 3109 mdelay(1);
3110
3111 /* write ucode */
3112 /**
3113 * @bug
3114 * Do NOT set indirect address register once and then
3115 * store data to indirect data register in the loop.
3116 * It seems very reasonable, but in this case DINO do not
3117 * accept ucode. It is essential to set address each time.
3118 */
3119 /* load new ipw uCode */
3120 for (i = 0; i < len / 2; i++)
b095c381 3121 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
e62e1ee0 3122 le16_to_cpu(image[i]));
43f66a6c 3123
43f66a6c 3124 /* enable DINO */
b095c381
JK		 3125 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3126 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
43f66a6c 3127
0edd5b44 3128 /* this is where the igx / win driver deveates from the VAP driver. */
43f66a6c
JK		 3129
3130 /* wait for alive response */
3131 for (i = 0; i < 100; i++) {
3132 /* poll for incoming data */
b095c381 3133 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
43f66a6c
JK		 3134 if (cr & DINO_RXFIFO_DATA)
3135 break;
3136 mdelay(1);
3137 }
3138
3139 if (cr & DINO_RXFIFO_DATA) {
3140 /* alive_command_responce size is NOT multiple of 4 */
e62e1ee0 3141 __le32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
bf79451e
JG		 3142
3143 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
43f66a6c 3144 response_buffer[i] =
e62e1ee0 3145 cpu_to_le32(ipw_read_reg32(priv,
b095c381 3146 IPW_BASEBAND_RX_FIFO_READ));
43f66a6c
JK		 3147 memcpy(&priv->dino_alive, response_buffer,
3148 sizeof(priv->dino_alive));
3149 if (priv->dino_alive.alive_command == 1
3150 && priv->dino_alive.ucode_valid == 1) {
3151 rc = 0;
0edd5b44
JG		 3152 IPW_DEBUG_INFO
3153 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
3154 "of %02d/%02d/%02d %02d:%02d\n",
3155 priv->dino_alive.software_revision,
3156 priv->dino_alive.software_revision,
3157 priv->dino_alive.device_identifier,
3158 priv->dino_alive.device_identifier,
3159 priv->dino_alive.time_stamp[0],
3160 priv->dino_alive.time_stamp[1],
3161 priv->dino_alive.time_stamp[2],
3162 priv->dino_alive.time_stamp[3],
3163 priv->dino_alive.time_stamp[4]);
43f66a6c
JK		 3164 } else {
3165 IPW_DEBUG_INFO("Microcode is not alive\n");
3166 rc = -EINVAL;
3167 }
3168 } else {
3169 IPW_DEBUG_INFO("No alive response from DINO\n");
3170 rc = -ETIME;
3171 }
3172
3173 /* disable DINO, otherwise for some reason
3174 firmware have problem getting alive resp. */
b095c381 3175 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
43f66a6c 3176
43f66a6c
JK		 3177 return rc;
3178}
3179
0edd5b44 3180static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
43f66a6c 3181{
11ebd1bf 3182 int ret = -1;
43f66a6c
JK		 3183 int offset = 0;
3184 struct fw_chunk *chunk;
11ebd1bf
ZY		 3185 int total_nr = 0;
3186 int i;
3187 struct pci_pool *pool;
41093167
ZY		 3188 void **virts;
3189 dma_addr_t *phys;
43f66a6c 3190
9fd1ea42 3191 IPW_DEBUG_TRACE("<< :\n");
43f66a6c 3192
41093167
ZY		 3193 virts = kmalloc(sizeof(void *) * CB_NUMBER_OF_ELEMENTS_SMALL,
3194 GFP_KERNEL);
3195 if (!virts)
3196 return -ENOMEM;
3197
3198 phys = kmalloc(sizeof(dma_addr_t) * CB_NUMBER_OF_ELEMENTS_SMALL,
3199 GFP_KERNEL);
3200 if (!phys) {
3201 kfree(virts);
3202 return -ENOMEM;
3203 }
11ebd1bf
ZY		 3204 pool = pci_pool_create("ipw2200", priv->pci_dev, CB_MAX_LENGTH, 0, 0);
3205 if (!pool) {
3206 IPW_ERROR("pci_pool_create failed\n");
41093167
ZY		 3207 kfree(phys);
3208 kfree(virts);
43f66a6c 3209 return -ENOMEM;
11ebd1bf 3210 }
43f66a6c
JK		 3211
3212 /* Start the Dma */
11ebd1bf 3213 ret = ipw_fw_dma_enable(priv);
43f66a6c 3214
0ee904c3
AB		 3215 /* the DMA is already ready this would be a bug. */
3216 BUG_ON(priv->sram_desc.last_cb_index > 0);
43f66a6c
JK		 3217
3218 do {
11ebd1bf
ZY		 3219 u32 chunk_len;
3220 u8 *start;
3221 int size;
3222 int nr = 0;
3223
43f66a6c
JK		 3224 chunk = (struct fw_chunk *)(data + offset);
3225 offset += sizeof(struct fw_chunk);
11ebd1bf
ZY		 3226 chunk_len = le32_to_cpu(chunk->length);
3227 start = data + offset;
3228
3229 nr = (chunk_len + CB_MAX_LENGTH - 1) / CB_MAX_LENGTH;
3230 for (i = 0; i < nr; i++) {
3231 virts[total_nr] = pci_pool_alloc(pool, GFP_KERNEL,
3232 &phys[total_nr]);
3233 if (!virts[total_nr]) {
3234 ret = -ENOMEM;
3235 goto out;
3236 }
3237 size = min_t(u32, chunk_len - i * CB_MAX_LENGTH,
3238 CB_MAX_LENGTH);
3239 memcpy(virts[total_nr], start, size);
3240 start += size;
3241 total_nr++;
3242 /* We don't support fw chunk larger than 64*8K */
3243 BUG_ON(total_nr > CB_NUMBER_OF_ELEMENTS_SMALL);
3244 }
3245
43f66a6c 3246 /* build DMA packet and queue up for sending */
bf79451e 3247 /* dma to chunk->address, the chunk->length bytes from data +
43f66a6c
JK		 3248 * offeset*/
3249 /* Dma loading */
11ebd1bf
ZY		 3250 ret = ipw_fw_dma_add_buffer(priv, &phys[total_nr - nr],
3251 nr, le32_to_cpu(chunk->address),
3252 chunk_len);
3253 if (ret) {
43f66a6c
JK		 3254 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3255 goto out;
3256 }
bf79451e 3257
11ebd1bf 3258 offset += chunk_len;
43f66a6c
JK		 3259 } while (offset < len);
3260
0edd5b44 3261 /* Run the DMA and wait for the answer */
11ebd1bf
ZY		 3262 ret = ipw_fw_dma_kick(priv);
3263 if (ret) {
43f66a6c
JK		 3264 IPW_ERROR("dmaKick Failed\n");
3265 goto out;
3266 }
3267
11ebd1bf
ZY		 3268 ret = ipw_fw_dma_wait(priv);
3269 if (ret) {
43f66a6c
JK		 3270 IPW_ERROR("dmaWaitSync Failed\n");
3271 goto out;
3272 }
11ebd1bf
ZY		 3273 out:
3274 for (i = 0; i < total_nr; i++)
3275 pci_pool_free(pool, virts[i], phys[i]);
3276
3277 pci_pool_destroy(pool);
41093167
ZY		 3278 kfree(phys);
3279 kfree(virts);
11ebd1bf
ZY		 3280
3281 return ret;
43f66a6c
JK		 3282}
3283
3284/* stop nic */
3285static int ipw_stop_nic(struct ipw_priv *priv)
3286{
3287 int rc = 0;
3288
0edd5b44 3289 /* stop */
b095c381 3290 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
bf79451e 3291
b095c381
JK		 3292 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3293 IPW_RESET_REG_MASTER_DISABLED, 500);
43f66a6c 3294 if (rc < 0) {
c7b6a674 3295 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
43f66a6c 3296 return rc;
bf79451e 3297 }
43f66a6c 3298
b095c381 3299 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
bf79451e 3300
43f66a6c
JK		 3301 return rc;
3302}
3303
3304static void ipw_start_nic(struct ipw_priv *priv)
3305{
3306 IPW_DEBUG_TRACE(">>\n");
3307
0edd5b44 3308 /* prvHwStartNic release ARC */
b095c381
JK		 3309 ipw_clear_bit(priv, IPW_RESET_REG,
3310 IPW_RESET_REG_MASTER_DISABLED |
3311 IPW_RESET_REG_STOP_MASTER |
43f66a6c 3312 CBD_RESET_REG_PRINCETON_RESET);
bf79451e 3313
43f66a6c 3314 /* enable power management */
b095c381
JK		 3315 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3316 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
43f66a6c
JK		 3317
3318 IPW_DEBUG_TRACE("<<\n");
3319}
bf79451e 3320
43f66a6c
JK		 3321static int ipw_init_nic(struct ipw_priv *priv)
3322{
3323 int rc;
3324
3325 IPW_DEBUG_TRACE(">>\n");
bf79451e 3326 /* reset */
43f66a6c
JK		 3327 /*prvHwInitNic */
3328 /* set "initialization complete" bit to move adapter to D0 state */
b095c381 3329 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
43f66a6c
JK		 3330
3331 /* low-level PLL activation */
b095c381
JK		 3332 ipw_write32(priv, IPW_READ_INT_REGISTER,
3333 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
43f66a6c
JK		 3334
3335 /* wait for clock stabilization */
b095c381
JK		 3336 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3337 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
0edd5b44 3338 if (rc < 0)
43f66a6c
JK		 3339 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3340
3341 /* assert SW reset */
b095c381 3342 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
43f66a6c
JK		 3343
3344 udelay(10);
3345
3346 /* set "initialization complete" bit to move adapter to D0 state */
b095c381 3347 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
43f66a6c
JK		 3348
3349 IPW_DEBUG_TRACE(">>\n");
3350 return 0;
3351}
3352
bf79451e 3353/* Call this function from process context, it will sleep in request_firmware.
43f66a6c
JK		 3354 * Probe is an ok place to call this from.
3355 */
3356static int ipw_reset_nic(struct ipw_priv *priv)
3357{
3358 int rc = 0;
a613bffd 3359 unsigned long flags;
43f66a6c
JK		 3360
3361 IPW_DEBUG_TRACE(">>\n");
bf79451e 3362
43f66a6c 3363 rc = ipw_init_nic(priv);
bf79451e 3364
a613bffd 3365 spin_lock_irqsave(&priv->lock, flags);
43f66a6c
JK		 3366 /* Clear the 'host command active' bit... */
3367 priv->status &= ~STATUS_HCMD_ACTIVE;
3368 wake_up_interruptible(&priv->wait_command_queue);
afbf30a2
JK		 3369 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3370 wake_up_interruptible(&priv->wait_state);
a613bffd 3371 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c
JK		 3372
3373 IPW_DEBUG_TRACE("<<\n");
3374 return rc;
bf79451e 3375}
43f66a6c 3376
9006ea75
JK		 3377
3378struct ipw_fw {
0070f8c7
ZY		 3379 __le32 ver;
3380 __le32 boot_size;
3381 __le32 ucode_size;
3382 __le32 fw_size;
9006ea75
JK		 3383 u8 data[0];
3384};
3385
bf79451e 3386static int ipw_get_fw(struct ipw_priv *priv,
9006ea75 3387 const struct firmware **raw, const char *name)
43f66a6c 3388{
9006ea75 3389 struct ipw_fw *fw;
43f66a6c
JK		 3390 int rc;
3391
3392 /* ask firmware_class module to get the boot firmware off disk */
9006ea75 3393 rc = request_firmware(raw, name, &priv->pci_dev->dev);
43f66a6c 3394 if (rc < 0) {
9006ea75 3395 IPW_ERROR("%s request_firmware failed: Reason %d\n", name, rc);
43f66a6c 3396 return rc;
bf79451e 3397 }
43f66a6c 3398
9006ea75
JK		 3399 if ((*raw)->size < sizeof(*fw)) {
3400 IPW_ERROR("%s is too small (%zd)\n", name, (*raw)->size);
3401 return -EINVAL;
3402 }
3403
3404 fw = (void *)(*raw)->data;
3405
0070f8c7
ZY		 3406 if ((*raw)->size < sizeof(*fw) + le32_to_cpu(fw->boot_size) +
3407 le32_to_cpu(fw->ucode_size) + le32_to_cpu(fw->fw_size)) {
9006ea75
JK		 3408 IPW_ERROR("%s is too small or corrupt (%zd)\n",
3409 name, (*raw)->size);
43f66a6c
JK		 3410 return -EINVAL;
3411 }
3412
9006ea75 3413 IPW_DEBUG_INFO("Read firmware '%s' image v%d.%d (%zd bytes)\n",
43f66a6c 3414 name,
9006ea75
JK		 3415 le32_to_cpu(fw->ver) >> 16,
3416 le32_to_cpu(fw->ver) & 0xff,
3417 (*raw)->size - sizeof(*fw));
43f66a6c
JK		 3418 return 0;
3419}
3420
b095c381 3421#define IPW_RX_BUF_SIZE (3000)
43f66a6c 3422
858119e1 3423static void ipw_rx_queue_reset(struct ipw_priv *priv,
43f66a6c
JK		 3424 struct ipw_rx_queue *rxq)
3425{
3426 unsigned long flags;
3427 int i;
3428
3429 spin_lock_irqsave(&rxq->lock, flags);
3430
3431 INIT_LIST_HEAD(&rxq->rx_free);
3432 INIT_LIST_HEAD(&rxq->rx_used);
3433
3434 /* Fill the rx_used queue with _all_ of the Rx buffers */
3435 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3436 /* In the reset function, these buffers may have been allocated
3437 * to an SKB, so we need to unmap and free potential storage */
3438 if (rxq->pool[i].skb != NULL) {
3439 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
b095c381 3440 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 3441 dev_kfree_skb(rxq->pool[i].skb);
a613bffd 3442 rxq->pool[i].skb = NULL;
43f66a6c
JK		 3443 }
3444 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3445 }
bf79451e 3446
43f66a6c
JK		 3447 /* Set us so that we have processed and used all buffers, but have
3448 * not restocked the Rx queue with fresh buffers */
3449 rxq->read = rxq->write = 0;
43f66a6c
JK		 3450 rxq->free_count = 0;
3451 spin_unlock_irqrestore(&rxq->lock, flags);
3452}
3453
3454#ifdef CONFIG_PM
3455static int fw_loaded = 0;
9006ea75 3456static const struct firmware *raw = NULL;
afbf30a2
JK		 3457
3458static void free_firmware(void)
3459{
3460 if (fw_loaded) {
9006ea75
JK		 3461 release_firmware(raw);
3462 raw = NULL;
afbf30a2
JK		 3463 fw_loaded = 0;
3464 }
3465}
3466#else
3467#define free_firmware() do {} while (0)
43f66a6c
JK		 3468#endif
3469
3470static int ipw_load(struct ipw_priv *priv)
3471{
3472#ifndef CONFIG_PM
9006ea75 3473 const struct firmware *raw = NULL;
43f66a6c 3474#endif
9006ea75
JK		 3475 struct ipw_fw *fw;
3476 u8 *boot_img, *ucode_img, *fw_img;
3477 u8 *name = NULL;
43f66a6c
JK		 3478 int rc = 0, retries = 3;
3479
397ae121
ZY		 3480 switch (priv->ieee->iw_mode) {
3481 case IW_MODE_ADHOC:
9006ea75 3482 name = "ipw2200-ibss.fw";
397ae121 3483 break;
b095c381 3484#ifdef CONFIG_IPW2200_MONITOR
397ae121 3485 case IW_MODE_MONITOR:
9006ea75 3486 name = "ipw2200-sniffer.fw";
397ae121 3487 break;
43f66a6c 3488#endif
397ae121 3489 case IW_MODE_INFRA:
9006ea75 3490 name = "ipw2200-bss.fw";
397ae121 3491 break;
9006ea75
JK		 3492 }
3493
3494 if (!name) {
397ae121 3495 rc = -EINVAL;
9006ea75
JK		 3496 goto error;
3497 }
3498
3499#ifdef CONFIG_PM
3500 if (!fw_loaded) {
3501#endif
3502 rc = ipw_get_fw(priv, &raw, name);
3503 if (rc < 0)
3504 goto error;
3505#ifdef CONFIG_PM
43f66a6c 3506 }
9006ea75
JK		 3507#endif
3508
3509 fw = (void *)raw->data;
3510 boot_img = &fw->data[0];
0070f8c7
ZY		 3511 ucode_img = &fw->data[le32_to_cpu(fw->boot_size)];
3512 fw_img = &fw->data[le32_to_cpu(fw->boot_size) +
3513 le32_to_cpu(fw->ucode_size)];
397ae121
ZY		 3514
3515 if (rc < 0)
3516 goto error;
43f66a6c
JK		 3517
3518 if (!priv->rxq)
3519 priv->rxq = ipw_rx_queue_alloc(priv);
3520 else
3521 ipw_rx_queue_reset(priv, priv->rxq);
3522 if (!priv->rxq) {
3523 IPW_ERROR("Unable to initialize Rx queue\n");
3524 goto error;
3525 }
3526
0edd5b44 3527 retry:
43f66a6c 3528 /* Ensure interrupts are disabled */
b095c381 3529 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
43f66a6c
JK		 3530 priv->status &= ~STATUS_INT_ENABLED;
3531
3532 /* ack pending interrupts */
b095c381 3533 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
bf79451e 3534
43f66a6c
JK		 3535 ipw_stop_nic(priv);
3536
3537 rc = ipw_reset_nic(priv);
397ae121 3538 if (rc < 0) {
43f66a6c
JK		 3539 IPW_ERROR("Unable to reset NIC\n");
3540 goto error;
3541 }
3542
b095c381
JK		 3543 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3544 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
43f66a6c
JK		 3545
3546 /* DMA the initial boot firmware into the device */
0070f8c7 3547 rc = ipw_load_firmware(priv, boot_img, le32_to_cpu(fw->boot_size));
43f66a6c 3548 if (rc < 0) {
a4f6bbb3 3549 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
43f66a6c
JK		 3550 goto error;
3551 }
3552
3553 /* kick start the device */
3554 ipw_start_nic(priv);
3555
c7b6a674 3556 /* wait for the device to finish its initial startup sequence */
b095c381
JK		 3557 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3558 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
43f66a6c
JK		 3559 if (rc < 0) {
3560 IPW_ERROR("device failed to boot initial fw image\n");
3561 goto error;
3562 }
3563 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3564
bf79451e 3565 /* ack fw init done interrupt */
b095c381 3566 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
43f66a6c
JK		 3567
3568 /* DMA the ucode into the device */
0070f8c7 3569 rc = ipw_load_ucode(priv, ucode_img, le32_to_cpu(fw->ucode_size));
43f66a6c 3570 if (rc < 0) {
a4f6bbb3 3571 IPW_ERROR("Unable to load ucode: %d\n", rc);
43f66a6c
JK		 3572 goto error;
3573 }
bf79451e 3574
43f66a6c
JK		 3575 /* stop nic */
3576 ipw_stop_nic(priv);
3577
3578 /* DMA bss firmware into the device */
0070f8c7 3579 rc = ipw_load_firmware(priv, fw_img, le32_to_cpu(fw->fw_size));
0edd5b44 3580 if (rc < 0) {
a4f6bbb3 3581 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 3582 goto error;
3583 }
397ae121
ZY		 3584#ifdef CONFIG_PM
3585 fw_loaded = 1;
3586#endif
3587
43f66a6c
JK		 3588 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3589
3590 rc = ipw_queue_reset(priv);
397ae121 3591 if (rc < 0) {
43f66a6c
JK		 3592 IPW_ERROR("Unable to initialize queues\n");
3593 goto error;
3594 }
3595
3596 /* Ensure interrupts are disabled */
b095c381 3597 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
c848d0af 3598 /* ack pending interrupts */
b095c381 3599 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
bf79451e 3600
43f66a6c
JK		 3601 /* kick start the device */
3602 ipw_start_nic(priv);
3603
b095c381 3604 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
43f66a6c
JK		 3605 if (retries > 0) {
3606 IPW_WARNING("Parity error. Retrying init.\n");
3607 retries--;
3608 goto retry;
3609 }
3610
3611 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3612 rc = -EIO;
3613 goto error;
3614 }
3615
3616 /* wait for the device */
b095c381
JK		 3617 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3618 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
43f66a6c 3619 if (rc < 0) {
c7b6a674 3620 IPW_ERROR("device failed to start within 500ms\n");
43f66a6c
JK		 3621 goto error;
3622 }
3623 IPW_DEBUG_INFO("device response after %dms\n", rc);
3624
3625 /* ack fw init done interrupt */
b095c381 3626 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
43f66a6c
JK		 3627
3628 /* read eeprom data and initialize the eeprom region of sram */
3629 priv->eeprom_delay = 1;
bf79451e 3630 ipw_eeprom_init_sram(priv);
43f66a6c
JK		 3631
3632 /* enable interrupts */
3633 ipw_enable_interrupts(priv);
3634
3635 /* Ensure our queue has valid packets */
3636 ipw_rx_queue_replenish(priv);
3637
b095c381 3638 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
43f66a6c
JK		 3639
3640 /* ack pending interrupts */
b095c381 3641 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
43f66a6c
JK		 3642
3643#ifndef CONFIG_PM
9006ea75 3644 release_firmware(raw);
43f66a6c
JK		 3645#endif
3646 return 0;
3647
0edd5b44 3648 error:
43f66a6c
JK		 3649 if (priv->rxq) {
3650 ipw_rx_queue_free(priv, priv->rxq);
3651 priv->rxq = NULL;
3652 }
3653 ipw_tx_queue_free(priv);
9006ea75
JK		 3654 if (raw)
3655 release_firmware(raw);
43f66a6c
JK		 3656#ifdef CONFIG_PM
3657 fw_loaded = 0;
9006ea75 3658 raw = NULL;
43f66a6c
JK		 3659#endif
3660
3661 return rc;
3662}
3663
bf79451e 3664/**
43f66a6c
JK		 3665 * DMA services
3666 *
3667 * Theory of operation
3668 *
3669 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3670 * 2 empty entries always kept in the buffer to protect from overflow.
3671 *
3672 * For Tx queue, there are low mark and high mark limits. If, after queuing
bf79451e
JG		 3673 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3674 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
43f66a6c
JK		 3675 * Tx queue resumed.
3676 *
3677 * The IPW operates with six queues, one receive queue in the device's
3678 * sram, one transmit queue for sending commands to the device firmware,
bf79451e 3679 * and four transmit queues for data.
43f66a6c 3680 *
bf79451e 3681 * The four transmit queues allow for performing quality of service (qos)
43f66a6c 3682 * transmissions as per the 802.11 protocol. Currently Linux does not
bf79451e 3683 * provide a mechanism to the user for utilizing prioritized queues, so
43f66a6c
JK		 3684 * we only utilize the first data transmit queue (queue1).
3685 */
3686
3687/**
3688 * Driver allocates buffers of this size for Rx
3689 */
3690
943dbef4
DW		 3691/**
3692 * ipw_rx_queue_space - Return number of free slots available in queue.
3693 */
3694static int ipw_rx_queue_space(const struct ipw_rx_queue *q)
3695{
3696 int s = q->read - q->write;
3697 if (s <= 0)
3698 s += RX_QUEUE_SIZE;
3699 /* keep some buffer to not confuse full and empty queue */
3700 s -= 2;
3701 if (s < 0)
3702 s = 0;
3703 return s;
3704}
3705
3706static inline int ipw_tx_queue_space(const struct clx2_queue *q)
43f66a6c
JK		 3707{
3708 int s = q->last_used - q->first_empty;
3709 if (s <= 0)
3710 s += q->n_bd;
3711 s -= 2; /* keep some reserve to not confuse empty and full situations */
3712 if (s < 0)
3713 s = 0;
3714 return s;
3715}
3716
3717static inline int ipw_queue_inc_wrap(int index, int n_bd)
3718{
3719 return (++index == n_bd) ? 0 : index;
3720}
3721
3722/**
3723 * Initialize common DMA queue structure
bf79451e 3724 *
43f66a6c
JK		 3725 * @param q queue to init
3726 * @param count Number of BD's to allocate. Should be power of 2
3727 * @param read_register Address for 'read' register
3728 * (not offset within BAR, full address)
3729 * @param write_register Address for 'write' register
3730 * (not offset within BAR, full address)
3731 * @param base_register Address for 'base' register
3732 * (not offset within BAR, full address)
3733 * @param size Address for 'size' register
3734 * (not offset within BAR, full address)
3735 */
bf79451e 3736static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
0edd5b44 3737 int count, u32 read, u32 write, u32 base, u32 size)
43f66a6c
JK		 3738{
3739 q->n_bd = count;
3740
3741 q->low_mark = q->n_bd / 4;
3742 if (q->low_mark < 4)
3743 q->low_mark = 4;
3744
3745 q->high_mark = q->n_bd / 8;
3746 if (q->high_mark < 2)
3747 q->high_mark = 2;
3748
3749 q->first_empty = q->last_used = 0;
3750 q->reg_r = read;
3751 q->reg_w = write;
3752
3753 ipw_write32(priv, base, q->dma_addr);
3754 ipw_write32(priv, size, count);
3755 ipw_write32(priv, read, 0);
3756 ipw_write32(priv, write, 0);
3757
3758 _ipw_read32(priv, 0x90);
3759}
3760
bf79451e 3761static int ipw_queue_tx_init(struct ipw_priv *priv,
43f66a6c 3762 struct clx2_tx_queue *q,
0edd5b44 3763 int count, u32 read, u32 write, u32 base, u32 size)
43f66a6c
JK		 3764{
3765 struct pci_dev *dev = priv->pci_dev;
3766
3767 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3768 if (!q->txb) {
3769 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3770 return -ENOMEM;
3771 }
3772
0edd5b44
JG		 3773 q->bd =
3774 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
43f66a6c 3775 if (!q->bd) {
aaa4d308 3776 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
0edd5b44 3777 sizeof(q->bd[0]) * count);
43f66a6c
JK		 3778 kfree(q->txb);
3779 q->txb = NULL;
3780 return -ENOMEM;
3781 }
3782
3783 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3784 return 0;
3785}
3786
3787/**
3788 * Free one TFD, those at index [txq->q.last_used].
3789 * Do NOT advance any indexes
bf79451e 3790 *
43f66a6c
JK		 3791 * @param dev
3792 * @param txq
3793 */
3794static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3795 struct clx2_tx_queue *txq)
3796{
3797 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3798 struct pci_dev *dev = priv->pci_dev;
3799 int i;
bf79451e 3800
43f66a6c
JK		 3801 /* classify bd */
3802 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3803 /* nothing to cleanup after for host commands */
3804 return;
3805
3806 /* sanity check */
a613bffd
JK		 3807 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3808 IPW_ERROR("Too many chunks: %i\n",
3809 le32_to_cpu(bd->u.data.num_chunks));
43f66a6c
JK		 3810 /** @todo issue fatal error, it is quite serious situation */
3811 return;
3812 }
3813
3814 /* unmap chunks if any */
a613bffd
JK		 3815 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3816 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3817 le16_to_cpu(bd->u.data.chunk_len[i]),
3818 PCI_DMA_TODEVICE);
43f66a6c 3819 if (txq->txb[txq->q.last_used]) {
b0a4e7d8 3820 libipw_txb_free(txq->txb[txq->q.last_used]);
43f66a6c
JK		 3821 txq->txb[txq->q.last_used] = NULL;
3822 }
3823 }
3824}
3825
3826/**
3827 * Deallocate DMA queue.
bf79451e 3828 *
43f66a6c
JK		 3829 * Empty queue by removing and destroying all BD's.
3830 * Free all buffers.
bf79451e 3831 *
43f66a6c
JK		 3832 * @param dev
3833 * @param q
3834 */
0edd5b44 3835static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
43f66a6c
JK		 3836{
3837 struct clx2_queue *q = &txq->q;
3838 struct pci_dev *dev = priv->pci_dev;
3839
bf79451e
JG		 3840 if (q->n_bd == 0)
3841 return;
43f66a6c
JK		 3842
3843 /* first, empty all BD's */
3844 for (; q->first_empty != q->last_used;
3845 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3846 ipw_queue_tx_free_tfd(priv, txq);
3847 }
bf79451e 3848
43f66a6c 3849 /* free buffers belonging to queue itself */
0edd5b44 3850 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
43f66a6c
JK		 3851 q->dma_addr);
3852 kfree(txq->txb);
3853
3854 /* 0 fill whole structure */
3855 memset(txq, 0, sizeof(*txq));
3856}
3857
43f66a6c
JK		 3858/**
3859 * Destroy all DMA queues and structures
bf79451e 3860 *
43f66a6c
JK		 3861 * @param priv
3862 */
3863static void ipw_tx_queue_free(struct ipw_priv *priv)
3864{
3865 /* Tx CMD queue */
3866 ipw_queue_tx_free(priv, &priv->txq_cmd);
3867
3868 /* Tx queues */
3869 ipw_queue_tx_free(priv, &priv->txq[0]);
3870 ipw_queue_tx_free(priv, &priv->txq[1]);
3871 ipw_queue_tx_free(priv, &priv->txq[2]);
3872 ipw_queue_tx_free(priv, &priv->txq[3]);
3873}
3874
858119e1 3875static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3876{
3877 /* First 3 bytes are manufacturer */
3878 bssid[0] = priv->mac_addr[0];
3879 bssid[1] = priv->mac_addr[1];
3880 bssid[2] = priv->mac_addr[2];
3881
3882 /* Last bytes are random */
0edd5b44 3883 get_random_bytes(&bssid[3], ETH_ALEN - 3);
43f66a6c 3884
0edd5b44
JG		 3885 bssid[0] &= 0xfe; /* clear multicast bit */
3886 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
43f66a6c
JK		 3887}
3888
858119e1 3889static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3890{
3891 struct ipw_station_entry entry;
3892 int i;
3893
3894 for (i = 0; i < priv->num_stations; i++) {
3895 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3896 /* Another node is active in network */
3897 priv->missed_adhoc_beacons = 0;
3898 if (!(priv->config & CFG_STATIC_CHANNEL))
3899 /* when other nodes drop out, we drop out */
3900 priv->config &= ~CFG_ADHOC_PERSIST;
3901
3902 return i;
3903 }
3904 }
3905
3906 if (i == MAX_STATIONS)
3907 return IPW_INVALID_STATION;
3908
e174961c 3909 IPW_DEBUG_SCAN("Adding AdHoc station: %pM\n", bssid);
43f66a6c
JK		 3910
3911 entry.reserved = 0;
3912 entry.support_mode = 0;
3913 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3914 memcpy(priv->stations[i], bssid, ETH_ALEN);
3915 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
0edd5b44 3916 &entry, sizeof(entry));
43f66a6c
JK		 3917 priv->num_stations++;
3918
3919 return i;
3920}
3921
858119e1 3922static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3923{
3924 int i;
3925
bf79451e
JG		 3926 for (i = 0; i < priv->num_stations; i++)
3927 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
43f66a6c
JK		 3928 return i;
3929
3930 return IPW_INVALID_STATION;
3931}
3932
3933static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3934{
3935 int err;
3936
7b99659f
HL		 3937 if (priv->status & STATUS_ASSOCIATING) {
3938 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3939 queue_work(priv->workqueue, &priv->disassociate);
3940 return;
3941 }
3942
3943 if (!(priv->status & STATUS_ASSOCIATED)) {
43f66a6c
JK		 3944 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3945 return;
3946 }
3947
e174961c 3948 IPW_DEBUG_ASSOC("Disassocation attempt from %pM "
43f66a6c 3949 "on channel %d.\n",
e174961c 3950 priv->assoc_request.bssid,
43f66a6c
JK		 3951 priv->assoc_request.channel);
3952
3953 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3954 priv->status |= STATUS_DISASSOCIATING;
3955
3956 if (quiet)
3957 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3958 else
3959 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
e6324726 3960
43f66a6c
JK		 3961 err = ipw_send_associate(priv, &priv->assoc_request);
3962 if (err) {
3963 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3964 "failed.\n");
3965 return;
3966 }
3967
3968}
3969
c848d0af 3970static int ipw_disassociate(void *data)
43f66a6c 3971{
c848d0af
JK		 3972 struct ipw_priv *priv = data;
3973 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3974 return 0;
43f66a6c 3975 ipw_send_disassociate(data, 0);
b8ddafd7 3976 netif_carrier_off(priv->net_dev);
c848d0af 3977 return 1;
43f66a6c
JK		 3978}
3979
c4028958 3980static void ipw_bg_disassociate(struct work_struct *work)
43f66a6c 3981{
c4028958
DH		 3982 struct ipw_priv *priv =
3983 container_of(work, struct ipw_priv, disassociate);
4644151b 3984 mutex_lock(&priv->mutex);
c4028958 3985 ipw_disassociate(priv);
4644151b 3986 mutex_unlock(&priv->mutex);
43f66a6c
JK		 3987}
3988
c4028958 3989static void ipw_system_config(struct work_struct *work)
d8bad6df 3990{
c4028958
DH		 3991 struct ipw_priv *priv =
3992 container_of(work, struct ipw_priv, system_config);
d685b8c2
ZY		 3993
3994#ifdef CONFIG_IPW2200_PROMISCUOUS
3995 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
3996 priv->sys_config.accept_all_data_frames = 1;
3997 priv->sys_config.accept_non_directed_frames = 1;
3998 priv->sys_config.accept_all_mgmt_bcpr = 1;
3999 priv->sys_config.accept_all_mgmt_frames = 1;
4000 }
4001#endif
4002
4003 ipw_send_system_config(priv);
43f66a6c
JK		 4004}
4005
4006struct ipw_status_code {
4007 u16 status;
4008 const char *reason;
4009};
4010
4011static const struct ipw_status_code ipw_status_codes[] = {
4012 {0x00, "Successful"},
4013 {0x01, "Unspecified failure"},
4014 {0x0A, "Cannot support all requested capabilities in the "
4015 "Capability information field"},
4016 {0x0B, "Reassociation denied due to inability to confirm that "
4017 "association exists"},
4018 {0x0C, "Association denied due to reason outside the scope of this "
4019 "standard"},
0edd5b44
JG		 4020 {0x0D,
4021 "Responding station does not support the specified authentication "
43f66a6c 4022 "algorithm"},
0edd5b44
JG		 4023 {0x0E,
4024 "Received an Authentication frame with authentication sequence "
43f66a6c
JK		 4025 "transaction sequence number out of expected sequence"},
4026 {0x0F, "Authentication rejected because of challenge failure"},
4027 {0x10, "Authentication rejected due to timeout waiting for next "
4028 "frame in sequence"},
4029 {0x11, "Association denied because AP is unable to handle additional "
4030 "associated stations"},
0edd5b44
JG		 4031 {0x12,
4032 "Association denied due to requesting station not supporting all "
43f66a6c 4033 "of the datarates in the BSSBasicServiceSet Parameter"},
0edd5b44
JG		 4034 {0x13,
4035 "Association denied due to requesting station not supporting "
43f66a6c 4036 "short preamble operation"},
0edd5b44
JG		 4037 {0x14,
4038 "Association denied due to requesting station not supporting "
43f66a6c 4039 "PBCC encoding"},
0edd5b44
JG		 4040 {0x15,
4041 "Association denied due to requesting station not supporting "
43f66a6c 4042 "channel agility"},
0edd5b44
JG		 4043 {0x19,
4044 "Association denied due to requesting station not supporting "
43f66a6c 4045 "short slot operation"},
0edd5b44
JG		 4046 {0x1A,
4047 "Association denied due to requesting station not supporting "
43f66a6c
JK		 4048 "DSSS-OFDM operation"},
4049 {0x28, "Invalid Information Element"},
4050 {0x29, "Group Cipher is not valid"},
4051 {0x2A, "Pairwise Cipher is not valid"},
4052 {0x2B, "AKMP is not valid"},
4053 {0x2C, "Unsupported RSN IE version"},
4054 {0x2D, "Invalid RSN IE Capabilities"},
4055 {0x2E, "Cipher suite is rejected per security policy"},
4056};
4057
bf79451e 4058static const char *ipw_get_status_code(u16 status)
43f66a6c
JK		 4059{
4060 int i;
bf79451e 4061 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
ea2b26e0 4062 if (ipw_status_codes[i].status == (status & 0xff))
43f66a6c
JK		 4063 return ipw_status_codes[i].reason;
4064 return "Unknown status value.";
4065}
43f66a6c
JK		 4066
4067static void inline average_init(struct average *avg)
4068{
4069 memset(avg, 0, sizeof(*avg));
4070}
4071
00d21de5
ZY		 4072#define DEPTH_RSSI 8
4073#define DEPTH_NOISE 16
4074static s16 exponential_average(s16 prev_avg, s16 val, u8 depth)
4075{
4076 return ((depth-1)*prev_avg + val)/depth;
4077}
4078
858119e1 4079static void average_add(struct average *avg, s16 val)
43f66a6c
JK		 4080{
4081 avg->sum -= avg->entries[avg->pos];
4082 avg->sum += val;
4083 avg->entries[avg->pos++] = val;
4084 if (unlikely(avg->pos == AVG_ENTRIES)) {
4085 avg->init = 1;
4086 avg->pos = 0;
4087 }
4088}
4089
858119e1 4090static s16 average_value(struct average *avg)
43f66a6c
JK		 4091{
4092 if (!unlikely(avg->init)) {
4093 if (avg->pos)
4094 return avg->sum / avg->pos;
4095 return 0;
4096 }
4097
4098 return avg->sum / AVG_ENTRIES;
4099}
4100
4101static void ipw_reset_stats(struct ipw_priv *priv)
4102{
4103 u32 len = sizeof(u32);
4104
4105 priv->quality = 0;
4106
4107 average_init(&priv->average_missed_beacons);
00d21de5
ZY		 4108 priv->exp_avg_rssi = -60;
4109 priv->exp_avg_noise = -85 + 0x100;
43f66a6c
JK		 4110
4111 priv->last_rate = 0;
4112 priv->last_missed_beacons = 0;
4113 priv->last_rx_packets = 0;
4114 priv->last_tx_packets = 0;
4115 priv->last_tx_failures = 0;
bf79451e 4116
43f66a6c
JK		 4117 /* Firmware managed, reset only when NIC is restarted, so we have to
4118 * normalize on the current value */
bf79451e 4119 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
43f66a6c 4120 &priv->last_rx_err, &len);
bf79451e 4121 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
43f66a6c
JK		 4122 &priv->last_tx_failures, &len);
4123
4124 /* Driver managed, reset with each association */
4125 priv->missed_adhoc_beacons = 0;
4126 priv->missed_beacons = 0;
4127 priv->tx_packets = 0;
4128 priv->rx_packets = 0;
4129
4130}
4131
858119e1 4132static u32 ipw_get_max_rate(struct ipw_priv *priv)
43f66a6c
JK		 4133{
4134 u32 i = 0x80000000;
4135 u32 mask = priv->rates_mask;
4136 /* If currently associated in B mode, restrict the maximum
4137 * rate match to B rates */
4138 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
b0a4e7d8 4139 mask &= LIBIPW_CCK_RATES_MASK;
43f66a6c
JK		 4140
4141 /* TODO: Verify that the rate is supported by the current rates
4142 * list. */
4143
0edd5b44
JG		 4144 while (i && !(mask & i))
4145 i >>= 1;
43f66a6c 4146 switch (i) {
b0a4e7d8 4147 case LIBIPW_CCK_RATE_1MB_MASK:
ea2b26e0 4148 return 1000000;
b0a4e7d8 4149 case LIBIPW_CCK_RATE_2MB_MASK:
ea2b26e0 4150 return 2000000;
b0a4e7d8 4151 case LIBIPW_CCK_RATE_5MB_MASK:
ea2b26e0 4152 return 5500000;
b0a4e7d8 4153 case LIBIPW_OFDM_RATE_6MB_MASK:
ea2b26e0 4154 return 6000000;
b0a4e7d8 4155 case LIBIPW_OFDM_RATE_9MB_MASK:
ea2b26e0 4156 return 9000000;
b0a4e7d8 4157 case LIBIPW_CCK_RATE_11MB_MASK:
ea2b26e0 4158 return 11000000;
b0a4e7d8 4159 case LIBIPW_OFDM_RATE_12MB_MASK:
ea2b26e0 4160 return 12000000;
b0a4e7d8 4161 case LIBIPW_OFDM_RATE_18MB_MASK:
ea2b26e0 4162 return 18000000;
b0a4e7d8 4163 case LIBIPW_OFDM_RATE_24MB_MASK:
ea2b26e0 4164 return 24000000;
b0a4e7d8 4165 case LIBIPW_OFDM_RATE_36MB_MASK:
ea2b26e0 4166 return 36000000;
b0a4e7d8 4167 case LIBIPW_OFDM_RATE_48MB_MASK:
ea2b26e0 4168 return 48000000;
b0a4e7d8 4169 case LIBIPW_OFDM_RATE_54MB_MASK:
ea2b26e0 4170 return 54000000;
43f66a6c
JK		 4171 }
4172
bf79451e 4173 if (priv->ieee->mode == IEEE_B)
43f66a6c
JK		 4174 return 11000000;
4175 else
4176 return 54000000;
4177}
4178
4179static u32 ipw_get_current_rate(struct ipw_priv *priv)
4180{
4181 u32 rate, len = sizeof(rate);
4182 int err;
4183
bf79451e 4184 if (!(priv->status & STATUS_ASSOCIATED))
43f66a6c
JK		 4185 return 0;
4186
4187 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
bf79451e 4188 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
43f66a6c
JK		 4189 &len);
4190 if (err) {
4191 IPW_DEBUG_INFO("failed querying ordinals.\n");
4192 return 0;
4193 }
bf79451e 4194 } else
43f66a6c
JK		 4195 return ipw_get_max_rate(priv);
4196
4197 switch (rate) {
ea2b26e0
JK		 4198 case IPW_TX_RATE_1MB:
4199 return 1000000;
4200 case IPW_TX_RATE_2MB:
4201 return 2000000;
4202 case IPW_TX_RATE_5MB:
4203 return 5500000;
4204 case IPW_TX_RATE_6MB:
4205 return 6000000;
4206 case IPW_TX_RATE_9MB:
4207 return 9000000;
4208 case IPW_TX_RATE_11MB:
4209 return 11000000;
4210 case IPW_TX_RATE_12MB:
4211 return 12000000;
4212 case IPW_TX_RATE_18MB:
4213 return 18000000;
4214 case IPW_TX_RATE_24MB:
4215 return 24000000;
4216 case IPW_TX_RATE_36MB:
4217 return 36000000;
4218 case IPW_TX_RATE_48MB:
4219 return 48000000;
4220 case IPW_TX_RATE_54MB:
4221 return 54000000;
43f66a6c
JK		 4222 }
4223
4224 return 0;
4225}
4226
43f66a6c
JK		 4227#define IPW_STATS_INTERVAL (2 * HZ)
4228static void ipw_gather_stats(struct ipw_priv *priv)
4229{
4230 u32 rx_err, rx_err_delta, rx_packets_delta;
4231 u32 tx_failures, tx_failures_delta, tx_packets_delta;
4232 u32 missed_beacons_percent, missed_beacons_delta;
4233 u32 quality = 0;
4234 u32 len = sizeof(u32);
4235 s16 rssi;
bf79451e 4236 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
0edd5b44 4237 rate_quality;
ea2b26e0 4238 u32 max_rate;
43f66a6c
JK		 4239
4240 if (!(priv->status & STATUS_ASSOCIATED)) {
4241 priv->quality = 0;
4242 return;
4243 }
4244
4245 /* Update the statistics */
bf79451e 4246 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
43f66a6c 4247 &priv->missed_beacons, &len);
0edd5b44 4248 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
43f66a6c
JK		 4249 priv->last_missed_beacons = priv->missed_beacons;
4250 if (priv->assoc_request.beacon_interval) {
4251 missed_beacons_percent = missed_beacons_delta *
5b5e807f 4252 (HZ * le16_to_cpu(priv->assoc_request.beacon_interval)) /
0edd5b44 4253 (IPW_STATS_INTERVAL * 10);
43f66a6c
JK		 4254 } else {
4255 missed_beacons_percent = 0;
4256 }
4257 average_add(&priv->average_missed_beacons, missed_beacons_percent);
4258
4259 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
4260 rx_err_delta = rx_err - priv->last_rx_err;
4261 priv->last_rx_err = rx_err;
4262
4263 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
4264 tx_failures_delta = tx_failures - priv->last_tx_failures;
4265 priv->last_tx_failures = tx_failures;
4266
4267 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4268 priv->last_rx_packets = priv->rx_packets;
4269
4270 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4271 priv->last_tx_packets = priv->tx_packets;
4272
4273 /* Calculate quality based on the following:
bf79451e 4274 *
43f66a6c
JK		 4275 * Missed beacon: 100% = 0, 0% = 70% missed
4276 * Rate: 60% = 1Mbs, 100% = Max
4277 * Rx and Tx errors represent a straight % of total Rx/Tx
4278 * RSSI: 100% = > -50, 0% = < -80
4279 * Rx errors: 100% = 0, 0% = 50% missed
bf79451e 4280 *
43f66a6c
JK		 4281 * The lowest computed quality is used.
4282 *
4283 */
4284#define BEACON_THRESHOLD 5
4285 beacon_quality = 100 - missed_beacons_percent;
4286 if (beacon_quality < BEACON_THRESHOLD)
4287 beacon_quality = 0;
4288 else
bf79451e 4289 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
0edd5b44 4290 (100 - BEACON_THRESHOLD);
bf79451e 4291 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
43f66a6c 4292 beacon_quality, missed_beacons_percent);
bf79451e 4293
43f66a6c 4294 priv->last_rate = ipw_get_current_rate(priv);
ea2b26e0
JK		 4295 max_rate = ipw_get_max_rate(priv);
4296 rate_quality = priv->last_rate * 40 / max_rate + 60;
43f66a6c
JK		 4297 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4298 rate_quality, priv->last_rate / 1000000);
bf79451e 4299
0edd5b44 4300 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
bf79451e 4301 rx_quality = 100 - (rx_err_delta * 100) /
0edd5b44 4302 (rx_packets_delta + rx_err_delta);
43f66a6c
JK		 4303 else
4304 rx_quality = 100;
4305 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4306 rx_quality, rx_err_delta, rx_packets_delta);
bf79451e 4307
0edd5b44 4308 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
bf79451e 4309 tx_quality = 100 - (tx_failures_delta * 100) /
0edd5b44 4310 (tx_packets_delta + tx_failures_delta);
43f66a6c
JK		 4311 else
4312 tx_quality = 100;
4313 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4314 tx_quality, tx_failures_delta, tx_packets_delta);
bf79451e 4315
00d21de5 4316 rssi = priv->exp_avg_rssi;
c848d0af
JK		 4317 signal_quality =
4318 (100 *
4319 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4320 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4321 (priv->ieee->perfect_rssi - rssi) *
4322 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4323 62 * (priv->ieee->perfect_rssi - rssi))) /
4324 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4325 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4326 if (signal_quality > 100)
43f66a6c 4327 signal_quality = 100;
c848d0af 4328 else if (signal_quality < 1)
43f66a6c 4329 signal_quality = 0;
ea2b26e0 4330
61fb9ed9 4331 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
43f66a6c 4332 signal_quality, rssi);
bf79451e 4333
21f8a73f
RC		 4334 quality = min(rx_quality, signal_quality);
4335 quality = min(tx_quality, quality);
4336 quality = min(rate_quality, quality);
4337 quality = min(beacon_quality, quality);
43f66a6c 4338 if (quality == beacon_quality)
0edd5b44
JG		 4339 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4340 quality);
43f66a6c 4341 if (quality == rate_quality)
0edd5b44
JG		 4342 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4343 quality);
43f66a6c 4344 if (quality == tx_quality)
0edd5b44
JG		 4345 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4346 quality);
43f66a6c 4347 if (quality == rx_quality)
0edd5b44
JG		 4348 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4349 quality);
43f66a6c 4350 if (quality == signal_quality)
0edd5b44
JG		 4351 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4352 quality);
43f66a6c
JK		 4353
4354 priv->quality = quality;
bf79451e
JG		 4355
4356 queue_delayed_work(priv->workqueue, &priv->gather_stats,
43f66a6c
JK		 4357 IPW_STATS_INTERVAL);
4358}
4359
c4028958 4360static void ipw_bg_gather_stats(struct work_struct *work)
c848d0af 4361{
c4028958
DH		 4362 struct ipw_priv *priv =
4363 container_of(work, struct ipw_priv, gather_stats.work);
4644151b 4364 mutex_lock(&priv->mutex);
c4028958 4365 ipw_gather_stats(priv);
4644151b 4366 mutex_unlock(&priv->mutex);
c848d0af
JK		 4367}
4368
e7582561
BC		 4369/* Missed beacon behavior:
4370 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4371 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4372 * Above disassociate threshold, give up and stop scanning.
4373 * Roaming is disabled if disassociate_threshold <= roaming_threshold */
858119e1 4374static void ipw_handle_missed_beacon(struct ipw_priv *priv,
ea2b26e0
JK		 4375 int missed_count)
4376{
4377 priv->notif_missed_beacons = missed_count;
4378
afbf30a2 4379 if (missed_count > priv->disassociate_threshold &&
ea2b26e0
JK		 4380 priv->status & STATUS_ASSOCIATED) {
4381 /* If associated and we've hit the missed
4382 * beacon threshold, disassociate, turn
4383 * off roaming, and abort any active scans */
4384 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
afbf30a2 4385 IPW_DL_STATE | IPW_DL_ASSOC,
ea2b26e0
JK		 4386 "Missed beacon: %d - disassociate\n", missed_count);
4387 priv->status &= ~STATUS_ROAMING;
a613bffd
JK		 4388 if (priv->status & STATUS_SCANNING) {
4389 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4390 IPW_DL_STATE,
4391 "Aborting scan with missed beacon.\n");
ea2b26e0 4392 queue_work(priv->workqueue, &priv->abort_scan);
a613bffd
JK		 4393 }
4394
ea2b26e0
JK		 4395 queue_work(priv->workqueue, &priv->disassociate);
4396 return;
4397 }
4398
4399 if (priv->status & STATUS_ROAMING) {
4400 /* If we are currently roaming, then just
4401 * print a debug statement... */
4402 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4403 "Missed beacon: %d - roam in progress\n",
4404 missed_count);
4405 return;
4406 }
4407
4bfdb91d
ZY		 4408 if (roaming &&
4409 (missed_count > priv->roaming_threshold &&
4410 missed_count <= priv->disassociate_threshold)) {
ea2b26e0 4411 /* If we are not already roaming, set the ROAM
e7582561
BC		 4412 * bit in the status and kick off a scan.
4413 * This can happen several times before we reach
4414 * disassociate_threshold. */
ea2b26e0
JK		 4415 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4416 "Missed beacon: %d - initiate "
4417 "roaming\n", missed_count);
4418 if (!(priv->status & STATUS_ROAMING)) {
4419 priv->status |= STATUS_ROAMING;
4420 if (!(priv->status & STATUS_SCANNING))
c4028958
DH		 4421 queue_delayed_work(priv->workqueue,
4422 &priv->request_scan, 0);
ea2b26e0
JK		 4423 }
4424 return;
4425 }
4426
14a4dfe2
HS		 4427 if (priv->status & STATUS_SCANNING &&
4428 missed_count > IPW_MB_SCAN_CANCEL_THRESHOLD) {
ea2b26e0
JK		 4429 /* Stop scan to keep fw from getting
4430 * stuck (only if we aren't roaming --
4431 * otherwise we'll never scan more than 2 or 3
4432 * channels..) */
b095c381
JK		 4433 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4434 "Aborting scan with missed beacon.\n");
ea2b26e0
JK		 4435 queue_work(priv->workqueue, &priv->abort_scan);
4436 }
4437
4438 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
ea2b26e0
JK		 4439}
4440
0b531676
DW		 4441static void ipw_scan_event(struct work_struct *work)
4442{
4443 union iwreq_data wrqu;
4444
4445 struct ipw_priv *priv =
4446 container_of(work, struct ipw_priv, scan_event.work);
4447
4448 wrqu.data.length = 0;
4449 wrqu.data.flags = 0;
4450 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4451}
4452
4453static void handle_scan_event(struct ipw_priv *priv)
4454{
4455 /* Only userspace-requested scan completion events go out immediately */
4456 if (!priv->user_requested_scan) {
4457 if (!delayed_work_pending(&priv->scan_event))
4458 queue_delayed_work(priv->workqueue, &priv->scan_event,
be84e3d6 4459 round_jiffies_relative(msecs_to_jiffies(4000)));
0b531676
DW		 4460 } else {
4461 union iwreq_data wrqu;
4462
4463 priv->user_requested_scan = 0;
4464 cancel_delayed_work(&priv->scan_event);
4465
4466 wrqu.data.length = 0;
4467 wrqu.data.flags = 0;
4468 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4469 }
4470}
4471
43f66a6c
JK		 4472/**
4473 * Handle host notification packet.
4474 * Called from interrupt routine
4475 */
858119e1 4476static void ipw_rx_notification(struct ipw_priv *priv,
43f66a6c
JK		 4477 struct ipw_rx_notification *notif)
4478{
9387b7ca 4479 DECLARE_SSID_BUF(ssid);
e62e1ee0 4480 u16 size = le16_to_cpu(notif->size);
a613bffd 4481
e62e1ee0 4482 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, size);
bf79451e 4483
43f66a6c 4484 switch (notif->subtype) {
0edd5b44
JG		 4485 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4486 struct notif_association *assoc = &notif->u.assoc;
4487
4488 switch (assoc->state) {
4489 case CMAS_ASSOCIATED:{
4490 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4491 IPW_DL_ASSOC,
9fd1ea42 4492 "associated: '%s' %pM\n",
9387b7ca
JL		 4493 print_ssid(ssid, priv->essid,
4494 priv->essid_len),
e174961c 4495 priv->bssid);
0edd5b44
JG		 4496
4497 switch (priv->ieee->iw_mode) {
4498 case IW_MODE_INFRA:
4499 memcpy(priv->ieee->bssid,
4500 priv->bssid, ETH_ALEN);
4501 break;
4502
4503 case IW_MODE_ADHOC:
4504 memcpy(priv->ieee->bssid,
4505 priv->bssid, ETH_ALEN);
4506
4507 /* clear out the station table */
4508 priv->num_stations = 0;
4509
4510 IPW_DEBUG_ASSOC
4511 ("queueing adhoc check\n");
4512 queue_delayed_work(priv->
4513 workqueue,
4514 &priv->
4515 adhoc_check,
5b5e807f 4516 le16_to_cpu(priv->
0edd5b44 4517 assoc_request.
5b5e807f 4518 beacon_interval));
0edd5b44
JG		 4519 break;
4520 }
4521
4522 priv->status &= ~STATUS_ASSOCIATING;
4523 priv->status |= STATUS_ASSOCIATED;
d8bad6df
ZY		 4524 queue_work(priv->workqueue,
4525 &priv->system_config);
0edd5b44 4526
e43e3c1e 4527#ifdef CONFIG_IPW2200_QOS
afbf30a2 4528#define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
72118015 4529 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_control))
afbf30a2
JK		 4530 if ((priv->status & STATUS_AUTH) &&
4531 (IPW_GET_PACKET_STYPE(&notif->u.raw)
4532 == IEEE80211_STYPE_ASSOC_RESP)) {
b095c381
JK		 4533 if ((sizeof
4534 (struct
b0a4e7d8 4535 libipw_assoc_response)
e62e1ee0
AV		 4536 <= size)
4537 && (size <= 2314)) {
b095c381 4538 struct
b0a4e7d8 4539 libipw_rx_stats
b095c381 4540 stats = {
e62e1ee0 4541 .len = size - 1,
b095c381
JK		 4542 };
4543
4544 IPW_DEBUG_QOS
4545 ("QoS Associate "
e62e1ee0 4546 "size %d\n", size);
b0a4e7d8 4547 libipw_rx_mgt(priv->
b095c381
JK		 4548 ieee,
4549 (struct
b0a4e7d8 4550 libipw_hdr_4addr
b095c381
JK		 4551 *)
4552 &notif->u.raw, &stats);
4553 }
0edd5b44 4554 }
b095c381 4555#endif
0edd5b44 4556
a613bffd 4557 schedule_work(&priv->link_up);
43f66a6c 4558
0edd5b44
JG		 4559 break;
4560 }
bf79451e 4561
0edd5b44
JG		 4562 case CMAS_AUTHENTICATED:{
4563 if (priv->
4564 status & (STATUS_ASSOCIATED |
4565 STATUS_AUTH)) {
0edd5b44
JG		 4566 struct notif_authenticate *auth
4567 = &notif->u.auth;
4568 IPW_DEBUG(IPW_DL_NOTIF |
4569 IPW_DL_STATE |
4570 IPW_DL_ASSOC,
4571 "deauthenticated: '%s' "
e174961c 4572 "%pM"
9fd1ea42 4573 ": (0x%04X) - %s\n",
9387b7ca
JL		 4574 print_ssid(ssid,
4575 priv->
4576 essid,
4577 priv->
4578 essid_len),
e174961c 4579 priv->bssid,
83f7d57c 4580 le16_to_cpu(auth->status),
0edd5b44 4581 ipw_get_status_code
83f7d57c 4582 (le16_to_cpu
0edd5b44 4583 (auth->status)));
43f66a6c 4584
0edd5b44
JG		 4585 priv->status &=
4586 ~(STATUS_ASSOCIATING |
4587 STATUS_AUTH |
4588 STATUS_ASSOCIATED);
4589
a613bffd 4590 schedule_work(&priv->link_down);
0edd5b44
JG		 4591 break;
4592 }
4593
4594 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4595 IPW_DL_ASSOC,
e174961c 4596 "authenticated: '%s' %pM\n",
9387b7ca
JL		 4597 print_ssid(ssid, priv->essid,
4598 priv->essid_len),
e174961c 4599 priv->bssid);
0edd5b44
JG		 4600 break;
4601 }
4602
4603 case CMAS_INIT:{
ea2b26e0
JK		 4604 if (priv->status & STATUS_AUTH) {
4605 struct
b0a4e7d8 4606 libipw_assoc_response
ea2b26e0
JK		 4607 *resp;
4608 resp =
4609 (struct
b0a4e7d8 4610 libipw_assoc_response
ea2b26e0
JK		 4611 *)&notif->u.raw;
4612 IPW_DEBUG(IPW_DL_NOTIF |
4613 IPW_DL_STATE |
4614 IPW_DL_ASSOC,
4615 "association failed (0x%04X): %s\n",
83f7d57c 4616 le16_to_cpu(resp->status),
ea2b26e0 4617 ipw_get_status_code
83f7d57c 4618 (le16_to_cpu
ea2b26e0
JK		 4619 (resp->status)));
4620 }
4621
0edd5b44
JG		 4622 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4623 IPW_DL_ASSOC,
9fd1ea42 4624 "disassociated: '%s' %pM\n",
9387b7ca
JL		 4625 print_ssid(ssid, priv->essid,
4626 priv->essid_len),
e174961c 4627 priv->bssid);
0edd5b44
JG		 4628
4629 priv->status &=
4630 ~(STATUS_DISASSOCIATING |
4631 STATUS_ASSOCIATING |
4632 STATUS_ASSOCIATED | STATUS_AUTH);
b095c381
JK		 4633 if (priv->assoc_network
4634 && (priv->assoc_network->
4635 capability &
4636 WLAN_CAPABILITY_IBSS))
4637 ipw_remove_current_network
4638 (priv);
0edd5b44 4639
a613bffd 4640 schedule_work(&priv->link_down);
0edd5b44 4641
0edd5b44
JG		 4642 break;
4643 }
43f66a6c 4644
b095c381
JK		 4645 case CMAS_RX_ASSOC_RESP:
4646 break;
4647
0edd5b44
JG		 4648 default:
4649 IPW_ERROR("assoc: unknown (%d)\n",
4650 assoc->state);
43f66a6c 4651 break;
bf79451e 4652 }
43f66a6c 4653
43f66a6c
JK		 4654 break;
4655 }
bf79451e 4656
0edd5b44
JG		 4657 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4658 struct notif_authenticate *auth = &notif->u.auth;
4659 switch (auth->state) {
4660 case CMAS_AUTHENTICATED:
4661 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
9fd1ea42 4662 "authenticated: '%s' %pM\n",
9387b7ca
JL		 4663 print_ssid(ssid, priv->essid,
4664 priv->essid_len),
e174961c 4665 priv->bssid);
0edd5b44
JG		 4666 priv->status |= STATUS_AUTH;
4667 break;
43f66a6c 4668
0edd5b44
JG		 4669 case CMAS_INIT:
4670 if (priv->status & STATUS_AUTH) {
4671 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4672 IPW_DL_ASSOC,
4673 "authentication failed (0x%04X): %s\n",
83f7d57c
AV		 4674 le16_to_cpu(auth->status),
4675 ipw_get_status_code(le16_to_cpu
0edd5b44
JG		 4676 (auth->
4677 status)));
4678 }
4679 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4680 IPW_DL_ASSOC,
e174961c 4681 "deauthenticated: '%s' %pM\n",
9387b7ca
JL		 4682 print_ssid(ssid, priv->essid,
4683 priv->essid_len),
e174961c 4684 priv->bssid);
bf79451e 4685
0edd5b44
JG		 4686 priv->status &= ~(STATUS_ASSOCIATING |
4687 STATUS_AUTH |
4688 STATUS_ASSOCIATED);
43f66a6c 4689
a613bffd 4690 schedule_work(&priv->link_down);
0edd5b44 4691 break;
43f66a6c 4692
0edd5b44
JG		 4693 case CMAS_TX_AUTH_SEQ_1:
4694 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4695 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4696 break;
4697 case CMAS_RX_AUTH_SEQ_2:
4698 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4699 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4700 break;
4701 case CMAS_AUTH_SEQ_1_PASS:
4702 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4703 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4704 break;
4705 case CMAS_AUTH_SEQ_1_FAIL:
4706 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4707 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4708 break;
4709 case CMAS_TX_AUTH_SEQ_3:
4710 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4711 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4712 break;
4713 case CMAS_RX_AUTH_SEQ_4:
4714 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4715 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4716 break;
4717 case CMAS_AUTH_SEQ_2_PASS:
4718 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4719 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4720 break;
4721 case CMAS_AUTH_SEQ_2_FAIL:
4722 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4723 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4724 break;
4725 case CMAS_TX_ASSOC:
4726 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4727 IPW_DL_ASSOC, "TX_ASSOC\n");
4728 break;
4729 case CMAS_RX_ASSOC_RESP:
4730 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4731 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
b095c381 4732
0edd5b44
JG		 4733 break;
4734 case CMAS_ASSOCIATED:
4735 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4736 IPW_DL_ASSOC, "ASSOCIATED\n");
4737 break;
4738 default:
4739 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4740 auth->state);
4741 break;
43f66a6c 4742 }
43f66a6c
JK		 4743 break;
4744 }
4745
0edd5b44
JG		 4746 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4747 struct notif_channel_result *x =
4748 &notif->u.channel_result;
43f66a6c 4749
e62e1ee0 4750 if (size == sizeof(*x)) {
0edd5b44
JG		 4751 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4752 x->channel_num);
4753 } else {
4754 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4755 "(should be %zd)\n",
e62e1ee0 4756 size, sizeof(*x));
bf79451e 4757 }
43f66a6c
JK		 4758 break;
4759 }
43f66a6c 4760
0edd5b44
JG		 4761 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4762 struct notif_scan_complete *x = &notif->u.scan_complete;
e62e1ee0 4763 if (size == sizeof(*x)) {
0edd5b44
JG		 4764 IPW_DEBUG_SCAN
4765 ("Scan completed: type %d, %d channels, "
4766 "%d status\n", x->scan_type,
4767 x->num_channels, x->status);
4768 } else {
4769 IPW_ERROR("Scan completed of wrong size %d "
4770 "(should be %zd)\n",
e62e1ee0 4771 size, sizeof(*x));
0edd5b44 4772 }
43f66a6c 4773
0edd5b44
JG		 4774 priv->status &=
4775 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4776
a0e04ab3 4777 wake_up_interruptible(&priv->wait_state);
0edd5b44
JG		 4778 cancel_delayed_work(&priv->scan_check);
4779
b095c381
JK		 4780 if (priv->status & STATUS_EXIT_PENDING)
4781 break;
4782
4783 priv->ieee->scans++;
4784
4785#ifdef CONFIG_IPW2200_MONITOR
4786 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 4787 priv->status |= STATUS_SCAN_FORCED;
c4028958
DH		 4788 queue_delayed_work(priv->workqueue,
4789 &priv->request_scan, 0);
b095c381
JK		 4790 break;
4791 }
afbf30a2 4792 priv->status &= ~STATUS_SCAN_FORCED;
b095c381
JK		 4793#endif /* CONFIG_IPW2200_MONITOR */
4794
ea177305
DW		 4795 /* Do queued direct scans first */
4796 if (priv->status & STATUS_DIRECT_SCAN_PENDING) {
4797 queue_delayed_work(priv->workqueue,
4798 &priv->request_direct_scan, 0);
4799 }
4800
0edd5b44
JG		 4801 if (!(priv->status & (STATUS_ASSOCIATED |
4802 STATUS_ASSOCIATING |
4803 STATUS_ROAMING |
4804 STATUS_DISASSOCIATING)))
4805 queue_work(priv->workqueue, &priv->associate);
4806 else if (priv->status & STATUS_ROAMING) {
e7582561
BC		 4807 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4808 /* If a scan completed and we are in roam mode, then
4809 * the scan that completed was the one requested as a
4810 * result of entering roam... so, schedule the
4811 * roam work */
4812 queue_work(priv->workqueue,
4813 &priv->roam);
4814 else
4815 /* Don't schedule if we aborted the scan */
4816 priv->status &= ~STATUS_ROAMING;
0edd5b44 4817 } else if (priv->status & STATUS_SCAN_PENDING)
c4028958
DH		 4818 queue_delayed_work(priv->workqueue,
4819 &priv->request_scan, 0);
a613bffd
JK		 4820 else if (priv->config & CFG_BACKGROUND_SCAN
4821 && priv->status & STATUS_ASSOCIATED)
4822 queue_delayed_work(priv->workqueue,
1c9d5e41 4823 &priv->request_scan,
be84e3d6 4824 round_jiffies_relative(HZ));
07f02e46
ZY		 4825
4826 /* Send an empty event to user space.
4827 * We don't send the received data on the event because
4828 * it would require us to do complex transcoding, and
4829 * we want to minimise the work done in the irq handler
4830 * Use a request to extract the data.
4831 * Also, we generate this even for any scan, regardless
4832 * on how the scan was initiated. User space can just
4833 * sync on periodic scan to get fresh data...
4834 * Jean II */
0b531676
DW		 4835 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4836 handle_scan_event(priv);
0edd5b44 4837 break;
43f66a6c 4838 }
43f66a6c 4839
0edd5b44
JG		 4840 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4841 struct notif_frag_length *x = &notif->u.frag_len;
43f66a6c 4842
e62e1ee0 4843 if (size == sizeof(*x))
a613bffd
JK		 4844 IPW_ERROR("Frag length: %d\n",
4845 le16_to_cpu(x->frag_length));
4846 else
0edd5b44
JG		 4847 IPW_ERROR("Frag length of wrong size %d "
4848 "(should be %zd)\n",
e62e1ee0 4849 size, sizeof(*x));
0edd5b44 4850 break;
43f66a6c 4851 }
43f66a6c 4852
0edd5b44
JG		 4853 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4854 struct notif_link_deterioration *x =
4855 &notif->u.link_deterioration;
afbf30a2 4856
e62e1ee0 4857 if (size == sizeof(*x)) {
0edd5b44 4858 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
12977154
BC		 4859 "link deterioration: type %d, cnt %d\n",
4860 x->silence_notification_type,
4861 x->silence_count);
0edd5b44
JG		 4862 memcpy(&priv->last_link_deterioration, x,
4863 sizeof(*x));
4864 } else {
4865 IPW_ERROR("Link Deterioration of wrong size %d "
4866 "(should be %zd)\n",
e62e1ee0 4867 size, sizeof(*x));
0edd5b44 4868 }
43f66a6c
JK		 4869 break;
4870 }
4871
0edd5b44
JG		 4872 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4873 IPW_ERROR("Dino config\n");
4874 if (priv->hcmd
a613bffd 4875 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
0edd5b44 4876 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
a613bffd 4877
0edd5b44
JG		 4878 break;
4879 }
43f66a6c 4880
0edd5b44
JG		 4881 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4882 struct notif_beacon_state *x = &notif->u.beacon_state;
e62e1ee0 4883 if (size != sizeof(*x)) {
0edd5b44
JG		 4884 IPW_ERROR
4885 ("Beacon state of wrong size %d (should "
e62e1ee0 4886 "be %zd)\n", size, sizeof(*x));
0edd5b44 4887 break;
43f66a6c
JK		 4888 }
4889
a613bffd
JK		 4890 if (le32_to_cpu(x->state) ==
4891 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4892 ipw_handle_missed_beacon(priv,
4893 le32_to_cpu(x->
4894 number));
43f66a6c 4895
0edd5b44
JG		 4896 break;
4897 }
43f66a6c 4898
0edd5b44
JG		 4899 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4900 struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
e62e1ee0 4901 if (size == sizeof(*x)) {
0edd5b44
JG		 4902 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4903 "0x%02x station %d\n",
4904 x->key_state, x->security_type,
4905 x->station_index);
4906 break;
4907 }
43f66a6c 4908
0edd5b44
JG		 4909 IPW_ERROR
4910 ("TGi Tx Key of wrong size %d (should be %zd)\n",
e62e1ee0 4911 size, sizeof(*x));
43f66a6c 4912 break;
bf79451e 4913 }
43f66a6c 4914
0edd5b44
JG		 4915 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4916 struct notif_calibration *x = &notif->u.calibration;
43f66a6c 4917
e62e1ee0 4918 if (size == sizeof(*x)) {
0edd5b44
JG		 4919 memcpy(&priv->calib, x, sizeof(*x));
4920 IPW_DEBUG_INFO("TODO: Calibration\n");
4921 break;
4922 }
43f66a6c 4923
0edd5b44
JG		 4924 IPW_ERROR
4925 ("Calibration of wrong size %d (should be %zd)\n",
e62e1ee0 4926 size, sizeof(*x));
43f66a6c 4927 break;
bf79451e
JG		 4928 }
4929
0edd5b44 4930 case HOST_NOTIFICATION_NOISE_STATS:{
e62e1ee0 4931 if (size == sizeof(u32)) {
00d21de5
ZY		 4932 priv->exp_avg_noise =
4933 exponential_average(priv->exp_avg_noise,
4934 (u8) (le32_to_cpu(notif->u.noise.value) & 0xff),
4935 DEPTH_NOISE);
0edd5b44
JG		 4936 break;
4937 }
43f66a6c 4938
0edd5b44
JG		 4939 IPW_ERROR
4940 ("Noise stat is wrong size %d (should be %zd)\n",
e62e1ee0 4941 size, sizeof(u32));
43f66a6c
JK		 4942 break;
4943 }
4944
43f66a6c 4945 default:
1dd31b6c
ZY		 4946 IPW_DEBUG_NOTIF("Unknown notification: "
4947 "subtype=%d,flags=0x%2x,size=%d\n",
e62e1ee0 4948 notif->subtype, notif->flags, size);
43f66a6c
JK		 4949 }
4950}
4951
4952/**
4953 * Destroys all DMA structures and initialise them again
bf79451e 4954 *
43f66a6c
JK		 4955 * @param priv
4956 * @return error code
4957 */
4958static int ipw_queue_reset(struct ipw_priv *priv)
4959{
4960 int rc = 0;
4961 /** @todo customize queue sizes */
4962 int nTx = 64, nTxCmd = 8;
4963 ipw_tx_queue_free(priv);
4964 /* Tx CMD queue */
4965 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
b095c381
JK		 4966 IPW_TX_CMD_QUEUE_READ_INDEX,
4967 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4968 IPW_TX_CMD_QUEUE_BD_BASE,
4969 IPW_TX_CMD_QUEUE_BD_SIZE);
43f66a6c
JK		 4970 if (rc) {
4971 IPW_ERROR("Tx Cmd queue init failed\n");
4972 goto error;
4973 }
4974 /* Tx queue(s) */
4975 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
b095c381
JK		 4976 IPW_TX_QUEUE_0_READ_INDEX,
4977 IPW_TX_QUEUE_0_WRITE_INDEX,
4978 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
43f66a6c
JK		 4979 if (rc) {
4980 IPW_ERROR("Tx 0 queue init failed\n");
4981 goto error;
4982 }
4983 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
b095c381
JK		 4984 IPW_TX_QUEUE_1_READ_INDEX,
4985 IPW_TX_QUEUE_1_WRITE_INDEX,
4986 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
43f66a6c
JK		 4987 if (rc) {
4988 IPW_ERROR("Tx 1 queue init failed\n");
4989 goto error;
4990 }
4991 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
b095c381
JK		 4992 IPW_TX_QUEUE_2_READ_INDEX,
4993 IPW_TX_QUEUE_2_WRITE_INDEX,
4994 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
43f66a6c
JK		 4995 if (rc) {
4996 IPW_ERROR("Tx 2 queue init failed\n");
4997 goto error;
4998 }
4999 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
b095c381
JK		 5000 IPW_TX_QUEUE_3_READ_INDEX,
5001 IPW_TX_QUEUE_3_WRITE_INDEX,
5002 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
43f66a6c
JK		 5003 if (rc) {
5004 IPW_ERROR("Tx 3 queue init failed\n");
5005 goto error;
5006 }
5007 /* statistics */
5008 priv->rx_bufs_min = 0;
5009 priv->rx_pend_max = 0;
5010 return rc;
5011
0edd5b44 5012 error:
43f66a6c
JK		 5013 ipw_tx_queue_free(priv);
5014 return rc;
5015}
5016
5017/**
5018 * Reclaim Tx queue entries no more used by NIC.
bf79451e 5019 *
8ff9d21e 5020 * When FW advances 'R' index, all entries between old and
43f66a6c
JK		 5021 * new 'R' index need to be reclaimed. As result, some free space
5022 * forms. If there is enough free space (> low mark), wake Tx queue.
bf79451e 5023 *
43f66a6c
JK		 5024 * @note Need to protect against garbage in 'R' index
5025 * @param priv
5026 * @param txq
5027 * @param qindex
5028 * @return Number of used entries remains in the queue
5029 */
bf79451e 5030static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
43f66a6c
JK		 5031 struct clx2_tx_queue *txq, int qindex)
5032{
5033 u32 hw_tail;
5034 int used;
5035 struct clx2_queue *q = &txq->q;
5036
5037 hw_tail = ipw_read32(priv, q->reg_r);
5038 if (hw_tail >= q->n_bd) {
5039 IPW_ERROR
0edd5b44
JG		 5040 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
5041 hw_tail, q->n_bd);
43f66a6c
JK		 5042 goto done;
5043 }
5044 for (; q->last_used != hw_tail;
5045 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
5046 ipw_queue_tx_free_tfd(priv, txq);
5047 priv->tx_packets++;
5048 }
0edd5b44 5049 done:
943dbef4 5050 if ((ipw_tx_queue_space(q) > q->low_mark) &&
521c4d96 5051 (qindex >= 0))
9ddf84f6 5052 netif_wake_queue(priv->net_dev);
43f66a6c
JK		 5053 used = q->first_empty - q->last_used;
5054 if (used < 0)
5055 used += q->n_bd;
5056
5057 return used;
5058}
5059
5060static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
5061 int len, int sync)
5062{
5063 struct clx2_tx_queue *txq = &priv->txq_cmd;
5064 struct clx2_queue *q = &txq->q;
5065 struct tfd_frame *tfd;
5066
943dbef4 5067 if (ipw_tx_queue_space(q) < (sync ? 1 : 2)) {
43f66a6c
JK		 5068 IPW_ERROR("No space for Tx\n");
5069 return -EBUSY;
5070 }
5071
5072 tfd = &txq->bd[q->first_empty];
5073 txq->txb[q->first_empty] = NULL;
5074
5075 memset(tfd, 0, sizeof(*tfd));
5076 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
5077 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
5078 priv->hcmd_seq++;
5079 tfd->u.cmd.index = hcmd;
5080 tfd->u.cmd.length = len;
5081 memcpy(tfd->u.cmd.payload, buf, len);
5082 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
5083 ipw_write32(priv, q->reg_w, q->first_empty);
5084 _ipw_read32(priv, 0x90);
5085
5086 return 0;
5087}
5088
bf79451e 5089/*
43f66a6c
JK		 5090 * Rx theory of operation
5091 *
5092 * The host allocates 32 DMA target addresses and passes the host address
b095c381 5093 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
43f66a6c
JK		 5094 * 0 to 31
5095 *
5096 * Rx Queue Indexes
5097 * The host/firmware share two index registers for managing the Rx buffers.
5098 *
bf79451e
JG		 5099 * The READ index maps to the first position that the firmware may be writing
5100 * to -- the driver can read up to (but not including) this position and get
5101 * good data.
43f66a6c
JK		 5102 * The READ index is managed by the firmware once the card is enabled.
5103 *
5104 * The WRITE index maps to the last position the driver has read from -- the
5105 * position preceding WRITE is the last slot the firmware can place a packet.
5106 *
5107 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
bf79451e 5108 * WRITE = READ.
43f66a6c 5109 *
bf79451e 5110 * During initialization the host sets up the READ queue position to the first
43f66a6c
JK		 5111 * INDEX position, and WRITE to the last (READ - 1 wrapped)
5112 *
5113 * When the firmware places a packet in a buffer it will advance the READ index
5114 * and fire the RX interrupt. The driver can then query the READ index and
5115 * process as many packets as possible, moving the WRITE index forward as it
5116 * resets the Rx queue buffers with new memory.
bf79451e 5117 *
43f66a6c 5118 * The management in the driver is as follows:
bf79451e 5119 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
43f66a6c 5120 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
bf79451e 5121 * to replensish the ipw->rxq->rx_free.
43f66a6c
JK		 5122 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
5123 * ipw->rxq is replenished and the READ INDEX is updated (updating the
5124 * 'processed' and 'read' driver indexes as well)
5125 * + A received packet is processed and handed to the kernel network stack,
5126 * detached from the ipw->rxq. The driver 'processed' index is updated.
5127 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
bf79451e
JG		 5128 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
5129 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
43f66a6c
JK		 5130 * were enough free buffers and RX_STALLED is set it is cleared.
5131 *
5132 *
5133 * Driver sequence:
5134 *
bf79451e 5135 * ipw_rx_queue_alloc() Allocates rx_free
43f66a6c
JK		 5136 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
5137 * ipw_rx_queue_restock
5138 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
5139 * queue, updates firmware pointers, and updates
5140 * the WRITE index. If insufficient rx_free buffers
5141 * are available, schedules ipw_rx_queue_replenish
5142 *
5143 * -- enable interrupts --
5144 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
bf79451e 5145 * READ INDEX, detaching the SKB from the pool.
43f66a6c
JK		 5146 * Moves the packet buffer from queue to rx_used.
5147 * Calls ipw_rx_queue_restock to refill any empty
5148 * slots.
5149 * ...
5150 *
5151 */
5152
bf79451e 5153/*
43f66a6c
JK		 5154 * If there are slots in the RX queue that need to be restocked,
5155 * and we have free pre-allocated buffers, fill the ranks as much
5156 * as we can pulling from rx_free.
5157 *
5158 * This moves the 'write' index forward to catch up with 'processed', and
5159 * also updates the memory address in the firmware to reference the new
5160 * target buffer.
5161 */
5162static void ipw_rx_queue_restock(struct ipw_priv *priv)
5163{
5164 struct ipw_rx_queue *rxq = priv->rxq;
5165 struct list_head *element;
5166 struct ipw_rx_mem_buffer *rxb;
5167 unsigned long flags;
5168 int write;
5169
5170 spin_lock_irqsave(&rxq->lock, flags);
5171 write = rxq->write;
943dbef4 5172 while ((ipw_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
43f66a6c
JK		 5173 element = rxq->rx_free.next;
5174 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
5175 list_del(element);
5176
b095c381 5177 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
43f66a6c
JK		 5178 rxb->dma_addr);
5179 rxq->queue[rxq->write] = rxb;
5180 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
5181 rxq->free_count--;
5182 }
5183 spin_unlock_irqrestore(&rxq->lock, flags);
5184
bf79451e 5185 /* If the pre-allocated buffer pool is dropping low, schedule to
43f66a6c
JK		 5186 * refill it */
5187 if (rxq->free_count <= RX_LOW_WATERMARK)
5188 queue_work(priv->workqueue, &priv->rx_replenish);
5189
5190 /* If we've added more space for the firmware to place data, tell it */
bf79451e 5191 if (write != rxq->write)
b095c381 5192 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
43f66a6c
JK		 5193}
5194
5195/*
5196 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
bf79451e
JG		 5197 * Also restock the Rx queue via ipw_rx_queue_restock.
5198 *
43f66a6c
JK		 5199 * This is called as a scheduled work item (except for during intialization)
5200 */
5201static void ipw_rx_queue_replenish(void *data)
5202{
5203 struct ipw_priv *priv = data;
5204 struct ipw_rx_queue *rxq = priv->rxq;
5205 struct list_head *element;
5206 struct ipw_rx_mem_buffer *rxb;
5207 unsigned long flags;
5208
5209 spin_lock_irqsave(&rxq->lock, flags);
5210 while (!list_empty(&rxq->rx_used)) {
5211 element = rxq->rx_used.next;
5212 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
b095c381 5213 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
43f66a6c
JK		 5214 if (!rxb->skb) {
5215 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
5216 priv->net_dev->name);
5217 /* We don't reschedule replenish work here -- we will
5218 * call the restock method and if it still needs
5219 * more buffers it will schedule replenish */
5220 break;
5221 }
5222 list_del(element);
bf79451e 5223
0edd5b44
JG		 5224 rxb->dma_addr =
5225 pci_map_single(priv->pci_dev, rxb->skb->data,
b095c381 5226 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
bf79451e 5227
43f66a6c
JK		 5228 list_add_tail(&rxb->list, &rxq->rx_free);
5229 rxq->free_count++;
5230 }
5231 spin_unlock_irqrestore(&rxq->lock, flags);
5232
5233 ipw_rx_queue_restock(priv);
5234}
5235
c4028958 5236static void ipw_bg_rx_queue_replenish(struct work_struct *work)
c848d0af 5237{
c4028958
DH		 5238 struct ipw_priv *priv =
5239 container_of(work, struct ipw_priv, rx_replenish);
4644151b 5240 mutex_lock(&priv->mutex);
c4028958 5241 ipw_rx_queue_replenish(priv);
4644151b 5242 mutex_unlock(&priv->mutex);
c848d0af
JK		 5243}
5244
43f66a6c 5245/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
c7b6a674 5246 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
bf79451e 5247 * This free routine walks the list of POOL entries and if SKB is set to
43f66a6c
JK		 5248 * non NULL it is unmapped and freed
5249 */
0edd5b44 5250static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
43f66a6c
JK		 5251{
5252 int i;
5253
5254 if (!rxq)
5255 return;
bf79451e 5256
43f66a6c
JK		 5257 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
5258 if (rxq->pool[i].skb != NULL) {
5259 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
b095c381 5260 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c
JK		 5261 dev_kfree_skb(rxq->pool[i].skb);
5262 }
5263 }
5264
5265 kfree(rxq);
5266}
5267
5268static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
5269{
5270 struct ipw_rx_queue *rxq;
5271 int i;
5272
c75f4742 5273 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
ad18b0ea
PI		 5274 if (unlikely(!rxq)) {
5275 IPW_ERROR("memory allocation failed\n");
5276 return NULL;
5277 }
43f66a6c
JK		 5278 spin_lock_init(&rxq->lock);
5279 INIT_LIST_HEAD(&rxq->rx_free);
5280 INIT_LIST_HEAD(&rxq->rx_used);
5281
5282 /* Fill the rx_used queue with _all_ of the Rx buffers */
bf79451e 5283 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
43f66a6c
JK		 5284 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
5285
5286 /* Set us so that we have processed and used all buffers, but have
5287 * not restocked the Rx queue with fresh buffers */
5288 rxq->read = rxq->write = 0;
43f66a6c
JK		 5289 rxq->free_count = 0;
5290
5291 return rxq;
5292}
5293
5294static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
5295{
b0a4e7d8 5296 rate &= ~LIBIPW_BASIC_RATE_MASK;
43f66a6c
JK		 5297 if (ieee_mode == IEEE_A) {
5298 switch (rate) {
b0a4e7d8
JL		 5299 case LIBIPW_OFDM_RATE_6MB:
5300 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ?
0edd5b44 5301 1 : 0;
b0a4e7d8
JL		 5302 case LIBIPW_OFDM_RATE_9MB:
5303 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ?
0edd5b44 5304 1 : 0;
b0a4e7d8 5305 case LIBIPW_OFDM_RATE_12MB:
0edd5b44 5306 return priv->
b0a4e7d8
JL		 5307 rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5308 case LIBIPW_OFDM_RATE_18MB:
0edd5b44 5309 return priv->
b0a4e7d8
JL		 5310 rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5311 case LIBIPW_OFDM_RATE_24MB:
0edd5b44 5312 return priv->
b0a4e7d8
JL		 5313 rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5314 case LIBIPW_OFDM_RATE_36MB:
0edd5b44 5315 return priv->
b0a4e7d8
JL		 5316 rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5317 case LIBIPW_OFDM_RATE_48MB:
0edd5b44 5318 return priv->
b0a4e7d8
JL		 5319 rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5320 case LIBIPW_OFDM_RATE_54MB:
0edd5b44 5321 return priv->
b0a4e7d8 5322 rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
43f66a6c
JK		 5323 default:
5324 return 0;
5325 }
5326 }
bf79451e 5327
43f66a6c
JK		 5328 /* B and G mixed */
5329 switch (rate) {
b0a4e7d8
JL		 5330 case LIBIPW_CCK_RATE_1MB:
5331 return priv->rates_mask & LIBIPW_CCK_RATE_1MB_MASK ? 1 : 0;
5332 case LIBIPW_CCK_RATE_2MB:
5333 return priv->rates_mask & LIBIPW_CCK_RATE_2MB_MASK ? 1 : 0;
5334 case LIBIPW_CCK_RATE_5MB:
5335 return priv->rates_mask & LIBIPW_CCK_RATE_5MB_MASK ? 1 : 0;
5336 case LIBIPW_CCK_RATE_11MB:
5337 return priv->rates_mask & LIBIPW_CCK_RATE_11MB_MASK ? 1 : 0;
43f66a6c
JK		 5338 }
5339
5340 /* If we are limited to B modulations, bail at this point */
5341 if (ieee_mode == IEEE_B)
5342 return 0;
5343
5344 /* G */
5345 switch (rate) {
b0a4e7d8
JL		 5346 case LIBIPW_OFDM_RATE_6MB:
5347 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ? 1 : 0;
5348 case LIBIPW_OFDM_RATE_9MB:
5349 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ? 1 : 0;
5350 case LIBIPW_OFDM_RATE_12MB:
5351 return priv->rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5352 case LIBIPW_OFDM_RATE_18MB:
5353 return priv->rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5354 case LIBIPW_OFDM_RATE_24MB:
5355 return priv->rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5356 case LIBIPW_OFDM_RATE_36MB:
5357 return priv->rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5358 case LIBIPW_OFDM_RATE_48MB:
5359 return priv->rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5360 case LIBIPW_OFDM_RATE_54MB:
5361 return priv->rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
43f66a6c
JK		 5362 }
5363
5364 return 0;
5365}
5366
bf79451e 5367static int ipw_compatible_rates(struct ipw_priv *priv,
b0a4e7d8 5368 const struct libipw_network *network,
43f66a6c
JK		 5369 struct ipw_supported_rates *rates)
5370{
5371 int num_rates, i;
5372
5373 memset(rates, 0, sizeof(*rates));
0edd5b44 5374 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
43f66a6c
JK		 5375 rates->num_rates = 0;
5376 for (i = 0; i < num_rates; i++) {
a613bffd
JK		 5377 if (!ipw_is_rate_in_mask(priv, network->mode,
5378 network->rates[i])) {
5379
b0a4e7d8 5380 if (network->rates[i] & LIBIPW_BASIC_RATE_MASK) {
a613bffd
JK		 5381 IPW_DEBUG_SCAN("Adding masked mandatory "
5382 "rate %02X\n",
5383 network->rates[i]);
5384 rates->supported_rates[rates->num_rates++] =
5385 network->rates[i];
5386 continue;
ea2b26e0
JK		 5387 }
5388
43f66a6c
JK		 5389 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5390 network->rates[i], priv->rates_mask);
5391 continue;
5392 }
bf79451e 5393
43f66a6c
JK		 5394 rates->supported_rates[rates->num_rates++] = network->rates[i];
5395 }
5396
a613bffd
JK		 5397 num_rates = min(network->rates_ex_len,
5398 (u8) (IPW_MAX_RATES - num_rates));
43f66a6c 5399 for (i = 0; i < num_rates; i++) {
a613bffd
JK		 5400 if (!ipw_is_rate_in_mask(priv, network->mode,
5401 network->rates_ex[i])) {
b0a4e7d8 5402 if (network->rates_ex[i] & LIBIPW_BASIC_RATE_MASK) {
a613bffd
JK		 5403 IPW_DEBUG_SCAN("Adding masked mandatory "
5404 "rate %02X\n",
5405 network->rates_ex[i]);
5406 rates->supported_rates[rates->num_rates++] =
5407 network->rates[i];
5408 continue;
ea2b26e0
JK		 5409 }
5410
43f66a6c
JK		 5411 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5412 network->rates_ex[i], priv->rates_mask);
5413 continue;
5414 }
bf79451e 5415
0edd5b44
JG		 5416 rates->supported_rates[rates->num_rates++] =
5417 network->rates_ex[i];
43f66a6c
JK		 5418 }
5419
ea2b26e0 5420 return 1;
43f66a6c
JK		 5421}
5422
858119e1 5423static void ipw_copy_rates(struct ipw_supported_rates *dest,
43f66a6c
JK		 5424 const struct ipw_supported_rates *src)
5425{
5426 u8 i;
5427 for (i = 0; i < src->num_rates; i++)
5428 dest->supported_rates[i] = src->supported_rates[i];
5429 dest->num_rates = src->num_rates;
5430}
5431
5432/* TODO: Look at sniffed packets in the air to determine if the basic rate
5433 * mask should ever be used -- right now all callers to add the scan rates are
5434 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5435static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
0edd5b44 5436 u8 modulation, u32 rate_mask)
43f66a6c 5437{
b0a4e7d8
JL		 5438 u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5439 LIBIPW_BASIC_RATE_MASK : 0;
bf79451e 5440
b0a4e7d8 5441 if (rate_mask & LIBIPW_CCK_RATE_1MB_MASK)
bf79451e 5442 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5443 LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_1MB;
43f66a6c 5444
b0a4e7d8 5445 if (rate_mask & LIBIPW_CCK_RATE_2MB_MASK)
bf79451e 5446 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5447 LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_2MB;
43f66a6c 5448
b0a4e7d8 5449 if (rate_mask & LIBIPW_CCK_RATE_5MB_MASK)
bf79451e 5450 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5451 LIBIPW_CCK_RATE_5MB;
43f66a6c 5452
b0a4e7d8 5453 if (rate_mask & LIBIPW_CCK_RATE_11MB_MASK)
bf79451e 5454 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5455 LIBIPW_CCK_RATE_11MB;
43f66a6c
JK		 5456}
5457
5458static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
0edd5b44 5459 u8 modulation, u32 rate_mask)
43f66a6c 5460{
b0a4e7d8
JL		 5461 u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5462 LIBIPW_BASIC_RATE_MASK : 0;
43f66a6c 5463
b0a4e7d8 5464 if (rate_mask & LIBIPW_OFDM_RATE_6MB_MASK)
bf79451e 5465 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5466 LIBIPW_OFDM_RATE_6MB;
43f66a6c 5467
b0a4e7d8 5468 if (rate_mask & LIBIPW_OFDM_RATE_9MB_MASK)
bf79451e 5469 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5470 LIBIPW_OFDM_RATE_9MB;
43f66a6c 5471
b0a4e7d8 5472 if (rate_mask & LIBIPW_OFDM_RATE_12MB_MASK)
bf79451e 5473 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5474 LIBIPW_OFDM_RATE_12MB;
43f66a6c 5475
b0a4e7d8 5476 if (rate_mask & LIBIPW_OFDM_RATE_18MB_MASK)
bf79451e 5477 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5478 LIBIPW_OFDM_RATE_18MB;
43f66a6c 5479
b0a4e7d8 5480 if (rate_mask & LIBIPW_OFDM_RATE_24MB_MASK)
bf79451e 5481 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5482 LIBIPW_OFDM_RATE_24MB;
43f66a6c 5483
b0a4e7d8 5484 if (rate_mask & LIBIPW_OFDM_RATE_36MB_MASK)
bf79451e 5485 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5486 LIBIPW_OFDM_RATE_36MB;
43f66a6c 5487
b0a4e7d8 5488 if (rate_mask & LIBIPW_OFDM_RATE_48MB_MASK)
bf79451e 5489 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5490 LIBIPW_OFDM_RATE_48MB;
43f66a6c 5491
b0a4e7d8 5492 if (rate_mask & LIBIPW_OFDM_RATE_54MB_MASK)
bf79451e 5493 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5494 LIBIPW_OFDM_RATE_54MB;
43f66a6c
JK		 5495}
5496
5497struct ipw_network_match {
b0a4e7d8 5498 struct libipw_network *network;
43f66a6c
JK		 5499 struct ipw_supported_rates rates;
5500};
5501
c848d0af
JK		 5502static int ipw_find_adhoc_network(struct ipw_priv *priv,
5503 struct ipw_network_match *match,
b0a4e7d8 5504 struct libipw_network *network,
c848d0af 5505 int roaming)
43f66a6c
JK		 5506{
5507 struct ipw_supported_rates rates;
9387b7ca 5508 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 5509
5510 /* Verify that this network's capability is compatible with the
5511 * current mode (AdHoc or Infrastructure) */
c848d0af 5512 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
43f66a6c 5513 !(network->capability & WLAN_CAPABILITY_IBSS))) {
e174961c 5514 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded due to "
bf79451e 5515 "capability mismatch.\n",
9387b7ca
JL		 5516 print_ssid(ssid, network->ssid,
5517 network->ssid_len),
e174961c 5518 network->bssid);
43f66a6c
JK		 5519 return 0;
5520 }
5521
43f66a6c
JK		 5522 if (unlikely(roaming)) {
5523 /* If we are roaming, then ensure check if this is a valid
5524 * network to try and roam to */
5525 if ((network->ssid_len != match->network->ssid_len) ||
bf79451e 5526 memcmp(network->ssid, match->network->ssid,
43f66a6c 5527 network->ssid_len)) {
e174961c 5528 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c 5529 "because of non-network ESSID.\n",
9387b7ca
JL		 5530 print_ssid(ssid, network->ssid,
5531 network->ssid_len),
e174961c 5532 network->bssid);
43f66a6c
JK		 5533 return 0;
5534 }
5535 } else {
bf79451e
JG		 5536 /* If an ESSID has been configured then compare the broadcast
5537 * ESSID to ours */
5538 if ((priv->config & CFG_STATIC_ESSID) &&
43f66a6c 5539 ((network->ssid_len != priv->essid_len) ||
bf79451e 5540 memcmp(network->ssid, priv->essid,
43f66a6c
JK		 5541 min(network->ssid_len, priv->essid_len)))) {
5542 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
afbf30a2 5543
0edd5b44 5544 strncpy(escaped,
9387b7ca
JL		 5545 print_ssid(ssid, network->ssid,
5546 network->ssid_len),
43f66a6c 5547 sizeof(escaped));
e174961c 5548 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
bf79451e 5549 "because of ESSID mismatch: '%s'.\n",
e174961c 5550 escaped, network->bssid,
9387b7ca
JL		 5551 print_ssid(ssid, priv->essid,
5552 priv->essid_len));
43f66a6c
JK		 5553 return 0;
5554 }
5555 }
5556
5557 /* If the old network rate is better than this one, don't bother
5558 * testing everything else. */
c848d0af
JK		 5559
5560 if (network->time_stamp[0] < match->network->time_stamp[0]) {
afbf30a2
JK		 5561 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5562 "current network.\n",
9387b7ca
JL		 5563 print_ssid(ssid, match->network->ssid,
5564 match->network->ssid_len));
43f66a6c 5565 return 0;
c848d0af 5566 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
afbf30a2
JK		 5567 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5568 "current network.\n",
9387b7ca
JL		 5569 print_ssid(ssid, match->network->ssid,
5570 match->network->ssid_len));
43f66a6c
JK		 5571 return 0;
5572 }
5573
5574 /* Now go through and see if the requested network is valid... */
bf79451e 5575 if (priv->ieee->scan_age != 0 &&
c848d0af 5576 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
e174961c 5577 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
c7b6a674 5578 "because of age: %ums.\n",
9387b7ca
JL		 5579 print_ssid(ssid, network->ssid,
5580 network->ssid_len),
e174961c 5581 network->bssid,
2638bc39
ZY		 5582 jiffies_to_msecs(jiffies -
5583 network->last_scanned));
43f66a6c 5584 return 0;
bf79451e 5585 }
43f66a6c 5586
bf79451e 5587 if ((priv->config & CFG_STATIC_CHANNEL) &&
43f66a6c 5588 (network->channel != priv->channel)) {
e174961c 5589 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c 5590 "because of channel mismatch: %d != %d.\n",
9387b7ca
JL		 5591 print_ssid(ssid, network->ssid,
5592 network->ssid_len),
e174961c 5593 network->bssid,
43f66a6c
JK		 5594 network->channel, priv->channel);
5595 return 0;
5596 }
bf79451e 5597
43f66a6c 5598 /* Verify privacy compatability */
bf79451e 5599 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
43f66a6c 5600 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
e174961c 5601 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c 5602 "because of privacy mismatch: %s != %s.\n",
9387b7ca
JL		 5603 print_ssid(ssid, network->ssid,
5604 network->ssid_len),
e174961c 5605 network->bssid,
afbf30a2
JK		 5606 priv->
5607 capability & CAP_PRIVACY_ON ? "on" : "off",
5608 network->
5609 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5610 "off");
43f66a6c
JK		 5611 return 0;
5612 }
bf79451e 5613
c848d0af 5614 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
e174961c
JB		 5615 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5616 "because of the same BSSID match: %pM"
9387b7ca
JL		 5617 ".\n", print_ssid(ssid, network->ssid,
5618 network->ssid_len),
e174961c
JB		 5619 network->bssid,
5620 priv->bssid);
43f66a6c
JK		 5621 return 0;
5622 }
bf79451e 5623
43f66a6c 5624 /* Filter out any incompatible freq / mode combinations */
b0a4e7d8 5625 if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
e174961c 5626 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c
JK		 5627 "because of invalid frequency/mode "
5628 "combination.\n",
9387b7ca
JL		 5629 print_ssid(ssid, network->ssid,
5630 network->ssid_len),
e174961c 5631 network->bssid);
43f66a6c
JK		 5632 return 0;
5633 }
bf79451e 5634
c848d0af
JK		 5635 /* Ensure that the rates supported by the driver are compatible with
5636 * this AP, including verification of basic rates (mandatory) */
5637 if (!ipw_compatible_rates(priv, network, &rates)) {
e174961c 5638 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
c848d0af
JK		 5639 "because configured rate mask excludes "
5640 "AP mandatory rate.\n",
9387b7ca
JL		 5641 print_ssid(ssid, network->ssid,
5642 network->ssid_len),
e174961c 5643 network->bssid);
c848d0af
JK		 5644 return 0;
5645 }
5646
43f66a6c 5647 if (rates.num_rates == 0) {
e174961c 5648 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c 5649 "because of no compatible rates.\n",
9387b7ca
JL		 5650 print_ssid(ssid, network->ssid,
5651 network->ssid_len),
e174961c 5652 network->bssid);
43f66a6c
JK		 5653 return 0;
5654 }
bf79451e 5655
43f66a6c
JK		 5656 /* TODO: Perform any further minimal comparititive tests. We do not
5657 * want to put too much policy logic here; intelligent scan selection
5658 * should occur within a generic IEEE 802.11 user space tool. */
5659
5660 /* Set up 'new' AP to this network */
5661 ipw_copy_rates(&match->rates, &rates);
5662 match->network = network;
e174961c 5663 IPW_DEBUG_MERGE("Network '%s (%pM)' is a viable match.\n",
9387b7ca 5664 print_ssid(ssid, network->ssid, network->ssid_len),
e174961c 5665 network->bssid);
43f66a6c
JK		 5666
5667 return 1;
5668}
5669
c4028958 5670static void ipw_merge_adhoc_network(struct work_struct *work)
43f66a6c 5671{
9387b7ca 5672 DECLARE_SSID_BUF(ssid);
c4028958
DH		 5673 struct ipw_priv *priv =
5674 container_of(work, struct ipw_priv, merge_networks);
b0a4e7d8 5675 struct libipw_network *network = NULL;
c848d0af
JK		 5676 struct ipw_network_match match = {
5677 .network = priv->assoc_network
5678 };
5679
afbf30a2
JK		 5680 if ((priv->status & STATUS_ASSOCIATED) &&
5681 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
c848d0af
JK		 5682 /* First pass through ROAM process -- look for a better
5683 * network */
5684 unsigned long flags;
5685
5686 spin_lock_irqsave(&priv->ieee->lock, flags);
5687 list_for_each_entry(network, &priv->ieee->network_list, list) {
5688 if (network != priv->assoc_network)
5689 ipw_find_adhoc_network(priv, &match, network,
5690 1);
5691 }
5692 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5693
5694 if (match.network == priv->assoc_network) {
5695 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5696 "merge to.\n");
5697 return;
5698 }
5699
4644151b 5700 mutex_lock(&priv->mutex);
c848d0af
JK		 5701 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5702 IPW_DEBUG_MERGE("remove network %s\n",
9387b7ca
JL		 5703 print_ssid(ssid, priv->essid,
5704 priv->essid_len));
c848d0af 5705 ipw_remove_current_network(priv);
43f66a6c 5706 }
c848d0af
JK		 5707
5708 ipw_disassociate(priv);
5709 priv->assoc_network = match.network;
4644151b 5710 mutex_unlock(&priv->mutex);
c848d0af 5711 return;
43f66a6c 5712 }
c848d0af 5713}
43f66a6c 5714
0edd5b44
JG		 5715static int ipw_best_network(struct ipw_priv *priv,
5716 struct ipw_network_match *match,
b0a4e7d8 5717 struct libipw_network *network, int roaming)
43f66a6c
JK		 5718{
5719 struct ipw_supported_rates rates;
9387b7ca 5720 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 5721
5722 /* Verify that this network's capability is compatible with the
5723 * current mode (AdHoc or Infrastructure) */
5724 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
2474385e 5725 !(network->capability & WLAN_CAPABILITY_ESS)) ||
43f66a6c
JK		 5726 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5727 !(network->capability & WLAN_CAPABILITY_IBSS))) {
e174961c 5728 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded due to "
bf79451e 5729 "capability mismatch.\n",
9387b7ca
JL		 5730 print_ssid(ssid, network->ssid,
5731 network->ssid_len),
e174961c 5732 network->bssid);
43f66a6c
JK		 5733 return 0;
5734 }
5735
43f66a6c
JK		 5736 if (unlikely(roaming)) {
5737 /* If we are roaming, then ensure check if this is a valid
5738 * network to try and roam to */
5739 if ((network->ssid_len != match->network->ssid_len) ||
bf79451e 5740 memcmp(network->ssid, match->network->ssid,
43f66a6c 5741 network->ssid_len)) {
e174961c 5742 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c 5743 "because of non-network ESSID.\n",
9387b7ca
JL		 5744 print_ssid(ssid, network->ssid,
5745 network->ssid_len),
e174961c 5746 network->bssid);
43f66a6c
JK		 5747 return 0;
5748 }
5749 } else {
bf79451e
JG		 5750 /* If an ESSID has been configured then compare the broadcast
5751 * ESSID to ours */
5752 if ((priv->config & CFG_STATIC_ESSID) &&
43f66a6c 5753 ((network->ssid_len != priv->essid_len) ||
bf79451e 5754 memcmp(network->ssid, priv->essid,
43f66a6c
JK		 5755 min(network->ssid_len, priv->essid_len)))) {
5756 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
0edd5b44 5757 strncpy(escaped,
9387b7ca
JL		 5758 print_ssid(ssid, network->ssid,
5759 network->ssid_len),
43f66a6c 5760 sizeof(escaped));
e174961c 5761 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
bf79451e 5762 "because of ESSID mismatch: '%s'.\n",
e174961c 5763 escaped, network->bssid,
9387b7ca
JL		 5764 print_ssid(ssid, priv->essid,
5765 priv->essid_len));
43f66a6c
JK		 5766 return 0;
5767 }
5768 }
5769
5770 /* If the old network rate is better than this one, don't bother
5771 * testing everything else. */
0edd5b44 5772 if (match->network && match->network->stats.rssi > network->stats.rssi) {
43f66a6c 5773 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
bf79451e 5774 strncpy(escaped,
9387b7ca 5775 print_ssid(ssid, network->ssid, network->ssid_len),
43f66a6c 5776 sizeof(escaped));
e174961c
JB		 5777 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded because "
5778 "'%s (%pM)' has a stronger signal.\n",
5779 escaped, network->bssid,
9387b7ca
JL		 5780 print_ssid(ssid, match->network->ssid,
5781 match->network->ssid_len),
e174961c 5782 match->network->bssid);
43f66a6c
JK		 5783 return 0;
5784 }
bf79451e 5785
43f66a6c
JK		 5786 /* If this network has already had an association attempt within the
5787 * last 3 seconds, do not try and associate again... */
5788 if (network->last_associate &&
ea2b26e0 5789 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
e174961c 5790 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
c7b6a674 5791 "because of storming (%ums since last "
43f66a6c 5792 "assoc attempt).\n",
9387b7ca
JL		 5793 print_ssid(ssid, network->ssid,
5794 network->ssid_len),
e174961c 5795 network->bssid,
2638bc39
ZY		 5796 jiffies_to_msecs(jiffies -
5797 network->last_associate));
43f66a6c
JK		 5798 return 0;
5799 }
5800
5801 /* Now go through and see if the requested network is valid... */
bf79451e 5802 if (priv->ieee->scan_age != 0 &&
ea2b26e0 5803 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
e174961c 5804 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
c7b6a674 5805 "because of age: %ums.\n",
9387b7ca
JL		 5806 print_ssid(ssid, network->ssid,
5807 network->ssid_len),
e174961c 5808 network->bssid,
2638bc39
ZY		 5809 jiffies_to_msecs(jiffies -
5810 network->last_scanned));
43f66a6c 5811 return 0;
bf79451e 5812 }
43f66a6c 5813
bf79451e 5814 if ((priv->config & CFG_STATIC_CHANNEL) &&
43f66a6c 5815 (network->channel != priv->channel)) {
e174961c 5816 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c 5817 "because of channel mismatch: %d != %d.\n",
9387b7ca
JL		 5818 print_ssid(ssid, network->ssid,
5819 network->ssid_len),
e174961c 5820 network->bssid,
43f66a6c
JK		 5821 network->channel, priv->channel);
5822 return 0;
5823 }
bf79451e 5824
43f66a6c 5825 /* Verify privacy compatability */
bf79451e 5826 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
43f66a6c 5827 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
e174961c 5828 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c 5829 "because of privacy mismatch: %s != %s.\n",
9387b7ca
JL		 5830 print_ssid(ssid, network->ssid,
5831 network->ssid_len),
e174961c 5832 network->bssid,
bf79451e 5833 priv->capability & CAP_PRIVACY_ON ? "on" :
43f66a6c 5834 "off",
bf79451e 5835 network->capability &
0edd5b44 5836 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
43f66a6c
JK		 5837 return 0;
5838 }
bf79451e
JG		 5839
5840 if ((priv->config & CFG_STATIC_BSSID) &&
43f66a6c 5841 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
e174961c
JB		 5842 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5843 "because of BSSID mismatch: %pM.\n",
9387b7ca
JL		 5844 print_ssid(ssid, network->ssid,
5845 network->ssid_len),
e174961c 5846 network->bssid, priv->bssid);
43f66a6c
JK		 5847 return 0;
5848 }
bf79451e 5849
43f66a6c 5850 /* Filter out any incompatible freq / mode combinations */
b0a4e7d8 5851 if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
e174961c 5852 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c
JK		 5853 "because of invalid frequency/mode "
5854 "combination.\n",
9387b7ca
JL		 5855 print_ssid(ssid, network->ssid,
5856 network->ssid_len),
e174961c 5857 network->bssid);
43f66a6c
JK		 5858 return 0;
5859 }
bf79451e 5860
1fe0adb4 5861 /* Filter out invalid channel in current GEO */
b0a4e7d8 5862 if (!libipw_is_valid_channel(priv->ieee, network->channel)) {
e174961c 5863 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
1fe0adb4 5864 "because of invalid channel in current GEO\n",
9387b7ca
JL		 5865 print_ssid(ssid, network->ssid,
5866 network->ssid_len),
e174961c 5867 network->bssid);
1fe0adb4
LH		 5868 return 0;
5869 }
5870
ea2b26e0
JK		 5871 /* Ensure that the rates supported by the driver are compatible with
5872 * this AP, including verification of basic rates (mandatory) */
5873 if (!ipw_compatible_rates(priv, network, &rates)) {
e174961c 5874 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
ea2b26e0
JK		 5875 "because configured rate mask excludes "
5876 "AP mandatory rate.\n",
9387b7ca
JL		 5877 print_ssid(ssid, network->ssid,
5878 network->ssid_len),
e174961c 5879 network->bssid);
ea2b26e0
JK		 5880 return 0;
5881 }
5882
43f66a6c 5883 if (rates.num_rates == 0) {
e174961c 5884 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c 5885 "because of no compatible rates.\n",
9387b7ca
JL		 5886 print_ssid(ssid, network->ssid,
5887 network->ssid_len),
e174961c 5888 network->bssid);
43f66a6c
JK		 5889 return 0;
5890 }
bf79451e 5891
43f66a6c
JK		 5892 /* TODO: Perform any further minimal comparititive tests. We do not
5893 * want to put too much policy logic here; intelligent scan selection
5894 * should occur within a generic IEEE 802.11 user space tool. */
5895
5896 /* Set up 'new' AP to this network */
5897 ipw_copy_rates(&match->rates, &rates);
5898 match->network = network;
5899
e174961c 5900 IPW_DEBUG_ASSOC("Network '%s (%pM)' is a viable match.\n",
9387b7ca 5901 print_ssid(ssid, network->ssid, network->ssid_len),
e174961c 5902 network->bssid);
43f66a6c
JK		 5903
5904 return 1;
5905}
5906
bf79451e 5907static void ipw_adhoc_create(struct ipw_priv *priv,
b0a4e7d8 5908 struct libipw_network *network)
43f66a6c 5909{
b0a4e7d8 5910 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
afbf30a2
JK		 5911 int i;
5912
43f66a6c
JK		 5913 /*
5914 * For the purposes of scanning, we can set our wireless mode
5915 * to trigger scans across combinations of bands, but when it
5916 * comes to creating a new ad-hoc network, we have tell the FW
5917 * exactly which band to use.
5918 *
bf79451e 5919 * We also have the possibility of an invalid channel for the
43f66a6c
JK		 5920 * chossen band. Attempting to create a new ad-hoc network
5921 * with an invalid channel for wireless mode will trigger a
5922 * FW fatal error.
afbf30a2 5923 *
43f66a6c 5924 */
b0a4e7d8
JL		 5925 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
5926 case LIBIPW_52GHZ_BAND:
afbf30a2 5927 network->mode = IEEE_A;
b0a4e7d8 5928 i = libipw_channel_to_index(priv->ieee, priv->channel);
5d9428de 5929 BUG_ON(i == -1);
b0a4e7d8 5930 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
afbf30a2
JK		 5931 IPW_WARNING("Overriding invalid channel\n");
5932 priv->channel = geo->a[0].channel;
5933 }
5934 break;
5935
b0a4e7d8 5936 case LIBIPW_24GHZ_BAND:
afbf30a2
JK		 5937 if (priv->ieee->mode & IEEE_G)
5938 network->mode = IEEE_G;
5939 else
5940 network->mode = IEEE_B;
b0a4e7d8 5941 i = libipw_channel_to_index(priv->ieee, priv->channel);
5d9428de 5942 BUG_ON(i == -1);
b0a4e7d8 5943 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
1fe0adb4
LH		 5944 IPW_WARNING("Overriding invalid channel\n");
5945 priv->channel = geo->bg[0].channel;
5946 }
afbf30a2
JK		 5947 break;
5948
5949 default:
43f66a6c
JK		 5950 IPW_WARNING("Overriding invalid channel\n");
5951 if (priv->ieee->mode & IEEE_A) {
5952 network->mode = IEEE_A;
b095c381 5953 priv->channel = geo->a[0].channel;
43f66a6c
JK		 5954 } else if (priv->ieee->mode & IEEE_G) {
5955 network->mode = IEEE_G;
b095c381 5956 priv->channel = geo->bg[0].channel;
43f66a6c
JK		 5957 } else {
5958 network->mode = IEEE_B;
b095c381 5959 priv->channel = geo->bg[0].channel;
43f66a6c 5960 }
afbf30a2
JK		 5961 break;
5962 }
43f66a6c
JK		 5963
5964 network->channel = priv->channel;
5965 priv->config |= CFG_ADHOC_PERSIST;
5966 ipw_create_bssid(priv, network->bssid);
5967 network->ssid_len = priv->essid_len;
5968 memcpy(network->ssid, priv->essid, priv->essid_len);
5969 memset(&network->stats, 0, sizeof(network->stats));
5970 network->capability = WLAN_CAPABILITY_IBSS;
ea2b26e0
JK		 5971 if (!(priv->config & CFG_PREAMBLE_LONG))
5972 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
43f66a6c
JK		 5973 if (priv->capability & CAP_PRIVACY_ON)
5974 network->capability |= WLAN_CAPABILITY_PRIVACY;
5975 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
0edd5b44 5976 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
43f66a6c 5977 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
bf79451e 5978 memcpy(network->rates_ex,
43f66a6c
JK		 5979 &priv->rates.supported_rates[network->rates_len],
5980 network->rates_ex_len);
5981 network->last_scanned = 0;
5982 network->flags = 0;
5983 network->last_associate = 0;
5984 network->time_stamp[0] = 0;
5985 network->time_stamp[1] = 0;
0edd5b44
JG		 5986 network->beacon_interval = 100; /* Default */
5987 network->listen_interval = 10; /* Default */
5988 network->atim_window = 0; /* Default */
43f66a6c
JK		 5989 network->wpa_ie_len = 0;
5990 network->rsn_ie_len = 0;
43f66a6c
JK		 5991}
5992
b095c381
JK		 5993static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5994{
0a7bcf26 5995 struct ipw_tgi_tx_key key;
b095c381
JK		 5996
5997 if (!(priv->ieee->sec.flags & (1 << index)))
5998 return;
5999
0a7bcf26
ZY		 6000 key.key_id = index;
6001 memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
6002 key.security_type = type;
6003 key.station_index = 0; /* always 0 for BSS */
6004 key.flags = 0;
b095c381 6005 /* 0 for new key; previous value of counter (after fatal error) */
851ca268
ZY		 6006 key.tx_counter[0] = cpu_to_le32(0);
6007 key.tx_counter[1] = cpu_to_le32(0);
b095c381 6008
0a7bcf26 6009 ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
b095c381
JK		 6010}
6011
6012static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
43f66a6c 6013{
0a7bcf26 6014 struct ipw_wep_key key;
43f66a6c 6015 int i;
43f66a6c 6016
0a7bcf26
ZY		 6017 key.cmd_id = DINO_CMD_WEP_KEY;
6018 key.seq_num = 0;
43f66a6c 6019
b095c381
JK		 6020 /* Note: AES keys cannot be set for multiple times.
6021 * Only set it at the first time. */
bf79451e 6022 for (i = 0; i < 4; i++) {
0a7bcf26 6023 key.key_index = i | type;
b095c381 6024 if (!(priv->ieee->sec.flags & (1 << i))) {
0a7bcf26 6025 key.key_size = 0;
b095c381 6026 continue;
43f66a6c
JK		 6027 }
6028
0a7bcf26
ZY		 6029 key.key_size = priv->ieee->sec.key_sizes[i];
6030 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
b095c381 6031
0a7bcf26 6032 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
bf79451e 6033 }
43f66a6c
JK		 6034}
6035
1fbfea54 6036static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
43f66a6c 6037{
1fbfea54 6038 if (priv->ieee->host_encrypt)
43f66a6c 6039 return;
43f66a6c 6040
1fbfea54
ZY		 6041 switch (level) {
6042 case SEC_LEVEL_3:
6043 priv->sys_config.disable_unicast_decryption = 0;
6044 priv->ieee->host_decrypt = 0;
6045 break;
6046 case SEC_LEVEL_2:
6047 priv->sys_config.disable_unicast_decryption = 1;
6048 priv->ieee->host_decrypt = 1;
6049 break;
6050 case SEC_LEVEL_1:
6051 priv->sys_config.disable_unicast_decryption = 0;
6052 priv->ieee->host_decrypt = 0;
6053 break;
6054 case SEC_LEVEL_0:
6055 priv->sys_config.disable_unicast_decryption = 1;
6056 break;
6057 default:
6058 break;
6059 }
6060}
6061
6062static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
6063{
6064 if (priv->ieee->host_encrypt)
6065 return;
6066
6067 switch (level) {
6068 case SEC_LEVEL_3:
6069 priv->sys_config.disable_multicast_decryption = 0;
6070 break;
6071 case SEC_LEVEL_2:
6072 priv->sys_config.disable_multicast_decryption = 1;
6073 break;
6074 case SEC_LEVEL_1:
6075 priv->sys_config.disable_multicast_decryption = 0;
6076 break;
6077 case SEC_LEVEL_0:
6078 priv->sys_config.disable_multicast_decryption = 1;
6079 break;
6080 default:
6081 break;
6082 }
6083}
6084
b095c381
JK		 6085static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
6086{
6087 switch (priv->ieee->sec.level) {
6088 case SEC_LEVEL_3:
d8bad6df
ZY		 6089 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
6090 ipw_send_tgi_tx_key(priv,
6091 DCT_FLAG_EXT_SECURITY_CCM,
6092 priv->ieee->sec.active_key);
afbf30a2 6093
567deaf6
HL		 6094 if (!priv->ieee->host_mc_decrypt)
6095 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
b095c381
JK		 6096 break;
6097 case SEC_LEVEL_2:
d8bad6df
ZY		 6098 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
6099 ipw_send_tgi_tx_key(priv,
6100 DCT_FLAG_EXT_SECURITY_TKIP,
6101 priv->ieee->sec.active_key);
b095c381
JK		 6102 break;
6103 case SEC_LEVEL_1:
6104 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
29cb843e
HL		 6105 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
6106 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
b095c381
JK		 6107 break;
6108 case SEC_LEVEL_0:
6109 default:
6110 break;
6111 }
6112}
6113
43f66a6c
JK		 6114static void ipw_adhoc_check(void *data)
6115{
6116 struct ipw_priv *priv = data;
bf79451e 6117
afbf30a2 6118 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
43f66a6c 6119 !(priv->config & CFG_ADHOC_PERSIST)) {
afbf30a2
JK		 6120 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
6121 IPW_DL_STATE | IPW_DL_ASSOC,
6122 "Missed beacon: %d - disassociate\n",
6123 priv->missed_adhoc_beacons);
43f66a6c
JK		 6124 ipw_remove_current_network(priv);
6125 ipw_disassociate(priv);
6126 return;
6127 }
6128
bf79451e 6129 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5b5e807f 6130 le16_to_cpu(priv->assoc_request.beacon_interval));
43f66a6c
JK		 6131}
6132
c4028958 6133static void ipw_bg_adhoc_check(struct work_struct *work)
c848d0af 6134{
c4028958
DH		 6135 struct ipw_priv *priv =
6136 container_of(work, struct ipw_priv, adhoc_check.work);
4644151b 6137 mutex_lock(&priv->mutex);
c4028958 6138 ipw_adhoc_check(priv);
4644151b 6139 mutex_unlock(&priv->mutex);
c848d0af
JK		 6140}
6141
43f66a6c
JK		 6142static void ipw_debug_config(struct ipw_priv *priv)
6143{
9387b7ca 6144 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 6145 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
6146 "[CFG 0x%08X]\n", priv->config);
6147 if (priv->config & CFG_STATIC_CHANNEL)
0edd5b44 6148 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
43f66a6c
JK		 6149 else
6150 IPW_DEBUG_INFO("Channel unlocked.\n");
6151 if (priv->config & CFG_STATIC_ESSID)
bf79451e 6152 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
9387b7ca 6153 print_ssid(ssid, priv->essid, priv->essid_len));
43f66a6c
JK		 6154 else
6155 IPW_DEBUG_INFO("ESSID unlocked.\n");
6156 if (priv->config & CFG_STATIC_BSSID)
e174961c 6157 IPW_DEBUG_INFO("BSSID locked to %pM\n", priv->bssid);
43f66a6c
JK		 6158 else
6159 IPW_DEBUG_INFO("BSSID unlocked.\n");
6160 if (priv->capability & CAP_PRIVACY_ON)
6161 IPW_DEBUG_INFO("PRIVACY on\n");
6162 else
6163 IPW_DEBUG_INFO("PRIVACY off\n");
6164 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
6165}
43f66a6c 6166
858119e1 6167static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
43f66a6c
JK		 6168{
6169 /* TODO: Verify that this works... */
21f8a73f 6170 struct ipw_fixed_rate fr;
43f66a6c
JK		 6171 u32 reg;
6172 u16 mask = 0;
21f8a73f 6173 u16 new_tx_rates = priv->rates_mask;
43f66a6c 6174
bf79451e 6175 /* Identify 'current FW band' and match it with the fixed
43f66a6c 6176 * Tx rates */
bf79451e 6177
43f66a6c 6178 switch (priv->ieee->freq_band) {
b0a4e7d8 6179 case LIBIPW_52GHZ_BAND: /* A only */
43f66a6c 6180 /* IEEE_A */
b0a4e7d8 6181 if (priv->rates_mask & ~LIBIPW_OFDM_RATES_MASK) {
43f66a6c 6182 /* Invalid fixed rate mask */
ea2b26e0
JK		 6183 IPW_DEBUG_WX
6184 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
21f8a73f 6185 new_tx_rates = 0;
43f66a6c
JK		 6186 break;
6187 }
bf79451e 6188
b0a4e7d8 6189 new_tx_rates >>= LIBIPW_OFDM_SHIFT_MASK_A;
43f66a6c
JK		 6190 break;
6191
0edd5b44 6192 default: /* 2.4Ghz or Mixed */
43f66a6c 6193 /* IEEE_B */
b095c381 6194 if (mode == IEEE_B) {
b0a4e7d8 6195 if (new_tx_rates & ~LIBIPW_CCK_RATES_MASK) {
43f66a6c 6196 /* Invalid fixed rate mask */
ea2b26e0
JK		 6197 IPW_DEBUG_WX
6198 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
21f8a73f 6199 new_tx_rates = 0;
43f66a6c
JK		 6200 }
6201 break;
bf79451e 6202 }
43f66a6c
JK		 6203
6204 /* IEEE_G */
b0a4e7d8
JL		 6205 if (new_tx_rates & ~(LIBIPW_CCK_RATES_MASK |
6206 LIBIPW_OFDM_RATES_MASK)) {
43f66a6c 6207 /* Invalid fixed rate mask */
ea2b26e0
JK		 6208 IPW_DEBUG_WX
6209 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
21f8a73f 6210 new_tx_rates = 0;
43f66a6c
JK		 6211 break;
6212 }
bf79451e 6213
b0a4e7d8
JL		 6214 if (LIBIPW_OFDM_RATE_6MB_MASK & new_tx_rates) {
6215 mask |= (LIBIPW_OFDM_RATE_6MB_MASK >> 1);
6216 new_tx_rates &= ~LIBIPW_OFDM_RATE_6MB_MASK;
43f66a6c 6217 }
bf79451e 6218
b0a4e7d8
JL		 6219 if (LIBIPW_OFDM_RATE_9MB_MASK & new_tx_rates) {
6220 mask |= (LIBIPW_OFDM_RATE_9MB_MASK >> 1);
6221 new_tx_rates &= ~LIBIPW_OFDM_RATE_9MB_MASK;
43f66a6c 6222 }
bf79451e 6223
b0a4e7d8
JL		 6224 if (LIBIPW_OFDM_RATE_12MB_MASK & new_tx_rates) {
6225 mask |= (LIBIPW_OFDM_RATE_12MB_MASK >> 1);
6226 new_tx_rates &= ~LIBIPW_OFDM_RATE_12MB_MASK;
43f66a6c 6227 }
bf79451e 6228
21f8a73f 6229 new_tx_rates |= mask;
43f66a6c
JK		 6230 break;
6231 }
6232
21f8a73f
RC		 6233 fr.tx_rates = cpu_to_le16(new_tx_rates);
6234
43f66a6c 6235 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
0edd5b44 6236 ipw_write_reg32(priv, reg, *(u32 *) & fr);
43f66a6c
JK		 6237}
6238
ea2b26e0 6239static void ipw_abort_scan(struct ipw_priv *priv)
43f66a6c
JK		 6240{
6241 int err;
6242
ea2b26e0
JK		 6243 if (priv->status & STATUS_SCAN_ABORTING) {
6244 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
6245 return;
6246 }
6247 priv->status |= STATUS_SCAN_ABORTING;
43f66a6c 6248
ea2b26e0
JK		 6249 err = ipw_send_scan_abort(priv);
6250 if (err)
6251 IPW_DEBUG_HC("Request to abort scan failed.\n");
6252}
6253
afbf30a2
JK		 6254static void ipw_add_scan_channels(struct ipw_priv *priv,
6255 struct ipw_scan_request_ext *scan,
6256 int scan_type)
ea2b26e0 6257{
ea2b26e0 6258 int channel_index = 0;
b0a4e7d8 6259 const struct libipw_geo *geo;
afbf30a2 6260 int i;
b095c381 6261
b0a4e7d8 6262 geo = libipw_get_geo(priv->ieee);
43f66a6c 6263
b0a4e7d8 6264 if (priv->ieee->freq_band & LIBIPW_52GHZ_BAND) {
afbf30a2
JK		 6265 int start = channel_index;
6266 for (i = 0; i < geo->a_channels; i++) {
6267 if ((priv->status & STATUS_ASSOCIATED) &&
6268 geo->a[i].channel == priv->channel)
6269 continue;
6270 channel_index++;
6271 scan->channels_list[channel_index] = geo->a[i].channel;
1fe0adb4
LH		 6272 ipw_set_scan_type(scan, channel_index,
6273 geo->a[i].
b0a4e7d8 6274 flags & LIBIPW_CH_PASSIVE_ONLY ?
1fe0adb4
LH		 6275 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
6276 scan_type);
afbf30a2
JK		 6277 }
6278
6279 if (start != channel_index) {
6280 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
6281 (channel_index - start);
6282 channel_index++;
6283 }
6284 }
6285
b0a4e7d8 6286 if (priv->ieee->freq_band & LIBIPW_24GHZ_BAND) {
afbf30a2
JK		 6287 int start = channel_index;
6288 if (priv->config & CFG_SPEED_SCAN) {
1fe0adb4 6289 int index;
b0a4e7d8 6290 u8 channels[LIBIPW_24GHZ_CHANNELS] = {
afbf30a2
JK		 6291 /* nop out the list */
6292 [0] = 0
6293 };
6294
6295 u8 channel;
7dd2459d 6296 while (channel_index < IPW_SCAN_CHANNELS - 1) {
afbf30a2
JK		 6297 channel =
6298 priv->speed_scan[priv->speed_scan_pos];
6299 if (channel == 0) {
6300 priv->speed_scan_pos = 0;
6301 channel = priv->speed_scan[0];
6302 }
6303 if ((priv->status & STATUS_ASSOCIATED) &&
6304 channel == priv->channel) {
6305 priv->speed_scan_pos++;
6306 continue;
6307 }
6308
6309 /* If this channel has already been
6310 * added in scan, break from loop
6311 * and this will be the first channel
6312 * in the next scan.
6313 */
6314 if (channels[channel - 1] != 0)
6315 break;
6316
6317 channels[channel - 1] = 1;
6318 priv->speed_scan_pos++;
6319 channel_index++;
6320 scan->channels_list[channel_index] = channel;
1fe0adb4 6321 index =
b0a4e7d8 6322 libipw_channel_to_index(priv->ieee, channel);
afbf30a2 6323 ipw_set_scan_type(scan, channel_index,
1fe0adb4
LH		 6324 geo->bg[index].
6325 flags &
b0a4e7d8 6326 LIBIPW_CH_PASSIVE_ONLY ?
1fe0adb4
LH		 6327 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6328 : scan_type);
afbf30a2
JK		 6329 }
6330 } else {
6331 for (i = 0; i < geo->bg_channels; i++) {
6332 if ((priv->status & STATUS_ASSOCIATED) &&
6333 geo->bg[i].channel == priv->channel)
6334 continue;
6335 channel_index++;
6336 scan->channels_list[channel_index] =
6337 geo->bg[i].channel;
6338 ipw_set_scan_type(scan, channel_index,
1fe0adb4
LH		 6339 geo->bg[i].
6340 flags &
b0a4e7d8 6341 LIBIPW_CH_PASSIVE_ONLY ?
1fe0adb4
LH		 6342 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6343 : scan_type);
afbf30a2
JK		 6344 }
6345 }
6346
6347 if (start != channel_index) {
6348 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6349 (channel_index - start);
6350 }
6351 }
6352}
6353
14a4dfe2
HS		 6354static int ipw_passive_dwell_time(struct ipw_priv *priv)
6355{
6356 /* staying on passive channels longer than the DTIM interval during a
6357 * scan, while associated, causes the firmware to cancel the scan
6358 * without notification. Hence, don't stay on passive channels longer
6359 * than the beacon interval.
6360 */
6361 if (priv->status & STATUS_ASSOCIATED
6362 && priv->assoc_network->beacon_interval > 10)
6363 return priv->assoc_network->beacon_interval - 10;
6364 else
6365 return 120;
6366}
6367
ea177305 6368static int ipw_request_scan_helper(struct ipw_priv *priv, int type, int direct)
afbf30a2
JK		 6369{
6370 struct ipw_scan_request_ext scan;
6371 int err = 0, scan_type;
6372
6373 if (!(priv->status & STATUS_INIT) ||
6374 (priv->status & STATUS_EXIT_PENDING))
6375 return 0;
6376
4644151b 6377 mutex_lock(&priv->mutex);
afbf30a2 6378
ea177305
DW		 6379 if (direct && (priv->direct_scan_ssid_len == 0)) {
6380 IPW_DEBUG_HC("Direct scan requested but no SSID to scan for\n");
6381 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6382 goto done;
6383 }
6384
ea2b26e0 6385 if (priv->status & STATUS_SCANNING) {
ea177305
DW		 6386 IPW_DEBUG_HC("Concurrent scan requested. Queuing.\n");
6387 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6388 STATUS_SCAN_PENDING;
b095c381 6389 goto done;
ea2b26e0 6390 }
43f66a6c 6391
afbf30a2
JK		 6392 if (!(priv->status & STATUS_SCAN_FORCED) &&
6393 priv->status & STATUS_SCAN_ABORTING) {
ea2b26e0 6394 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
ea177305
DW		 6395 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6396 STATUS_SCAN_PENDING;
b095c381 6397 goto done;
43f66a6c
JK		 6398 }
6399
ea2b26e0 6400 if (priv->status & STATUS_RF_KILL_MASK) {
ea177305
DW		 6401 IPW_DEBUG_HC("Queuing scan due to RF Kill activation\n");
6402 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6403 STATUS_SCAN_PENDING;
b095c381 6404 goto done;
ea2b26e0 6405 }
43f66a6c 6406
ea2b26e0 6407 memset(&scan, 0, sizeof(scan));
b0a4e7d8 6408 scan.full_scan_index = cpu_to_le32(libipw_get_scans(priv->ieee));
43f66a6c 6409
094c4d2d 6410 if (type == IW_SCAN_TYPE_PASSIVE) {
14a4dfe2
HS		 6411 IPW_DEBUG_WX("use passive scanning\n");
6412 scan_type = IPW_SCAN_PASSIVE_FULL_DWELL_SCAN;
094c4d2d 6413 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
14a4dfe2 6414 cpu_to_le16(ipw_passive_dwell_time(priv));
094c4d2d
ZY		 6415 ipw_add_scan_channels(priv, &scan, scan_type);
6416 goto send_request;
6417 }
6418
6419 /* Use active scan by default. */
14a4dfe2 6420 if (priv->config & CFG_SPEED_SCAN)
b095c381 6421 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
094c4d2d 6422 cpu_to_le16(30);
b095c381
JK		 6423 else
6424 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
094c4d2d 6425 cpu_to_le16(20);
b095c381 6426
a613bffd 6427 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
094c4d2d 6428 cpu_to_le16(20);
43f66a6c 6429
14a4dfe2
HS		 6430 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6431 cpu_to_le16(ipw_passive_dwell_time(priv));
ea177305 6432 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
43f66a6c 6433
b095c381 6434#ifdef CONFIG_IPW2200_MONITOR
ea2b26e0 6435 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 6436 u8 channel;
b095c381 6437 u8 band = 0;
43f66a6c 6438
b0a4e7d8
JL		 6439 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
6440 case LIBIPW_52GHZ_BAND:
ea2b26e0 6441 band = (u8) (IPW_A_MODE << 6) | 1;
b095c381
JK		 6442 channel = priv->channel;
6443 break;
ea2b26e0 6444
b0a4e7d8 6445 case LIBIPW_24GHZ_BAND:
ea2b26e0 6446 band = (u8) (IPW_B_MODE << 6) | 1;
b095c381
JK		 6447 channel = priv->channel;
6448 break;
ea2b26e0 6449
b095c381 6450 default:
ea2b26e0
JK		 6451 band = (u8) (IPW_B_MODE << 6) | 1;
6452 channel = 9;
b095c381 6453 break;
ea2b26e0
JK		 6454 }
6455
b095c381
JK		 6456 scan.channels_list[0] = band;
6457 scan.channels_list[1] = channel;
6458 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
ea2b26e0 6459
b095c381
JK		 6460 /* NOTE: The card will sit on this channel for this time
6461 * period. Scan aborts are timing sensitive and frequently
6462 * result in firmware restarts. As such, it is best to
6463 * set a small dwell_time here and just keep re-issuing
6464 * scans. Otherwise fast channel hopping will not actually
6465 * hop channels.
6466 *
6467 * TODO: Move SPEED SCAN support to all modes and bands */
a613bffd 6468 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
094c4d2d 6469 cpu_to_le16(2000);
43f66a6c 6470 } else {
b095c381 6471#endif /* CONFIG_IPW2200_MONITOR */
ea177305
DW		 6472 /* Honor direct scans first, otherwise if we are roaming make
6473 * this a direct scan for the current network. Finally,
6474 * ensure that every other scan is a fast channel hop scan */
6475 if (direct) {
6476 err = ipw_send_ssid(priv, priv->direct_scan_ssid,
6477 priv->direct_scan_ssid_len);
6478 if (err) {
6479 IPW_DEBUG_HC("Attempt to send SSID command "
6480 "failed\n");
6481 goto done;
6482 }
6483
6484 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6485 } else if ((priv->status & STATUS_ROAMING)
6486 || (!(priv->status & STATUS_ASSOCIATED)
6487 && (priv->config & CFG_STATIC_ESSID)
6488 && (le32_to_cpu(scan.full_scan_index) % 2))) {
ea2b26e0
JK		 6489 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6490 if (err) {
b095c381
JK		 6491 IPW_DEBUG_HC("Attempt to send SSID command "
6492 "failed.\n");
6493 goto done;
ea2b26e0 6494 }
43f66a6c 6495
ea2b26e0 6496 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
afbf30a2 6497 } else
ea2b26e0 6498 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
ea2b26e0 6499
afbf30a2 6500 ipw_add_scan_channels(priv, &scan, scan_type);
b095c381 6501#ifdef CONFIG_IPW2200_MONITOR
43f66a6c 6502 }
ea2b26e0 6503#endif
bf79451e 6504
094c4d2d 6505send_request:
ea2b26e0 6506 err = ipw_send_scan_request_ext(priv, &scan);
43f66a6c 6507 if (err) {
ea2b26e0 6508 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
b095c381 6509 goto done;
43f66a6c
JK		 6510 }
6511
ea2b26e0 6512 priv->status |= STATUS_SCANNING;
ea177305
DW		 6513 if (direct) {
6514 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6515 priv->direct_scan_ssid_len = 0;
6516 } else
6517 priv->status &= ~STATUS_SCAN_PENDING;
6518
afbf30a2
JK		 6519 queue_delayed_work(priv->workqueue, &priv->scan_check,
6520 IPW_SCAN_CHECK_WATCHDOG);
094c4d2d 6521done:
4644151b 6522 mutex_unlock(&priv->mutex);
b095c381 6523 return err;
c848d0af
JK		 6524}
6525
c4028958
DH		 6526static void ipw_request_passive_scan(struct work_struct *work)
6527{
6528 struct ipw_priv *priv =
ea177305
DW		 6529 container_of(work, struct ipw_priv, request_passive_scan.work);
6530 ipw_request_scan_helper(priv, IW_SCAN_TYPE_PASSIVE, 0);
094c4d2d
ZY		 6531}
6532
c4028958
DH		 6533static void ipw_request_scan(struct work_struct *work)
6534{
6535 struct ipw_priv *priv =
6536 container_of(work, struct ipw_priv, request_scan.work);
ea177305
DW		 6537 ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 0);
6538}
6539
6540static void ipw_request_direct_scan(struct work_struct *work)
6541{
6542 struct ipw_priv *priv =
6543 container_of(work, struct ipw_priv, request_direct_scan.work);
6544 ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 1);
094c4d2d
ZY		 6545}
6546
c4028958 6547static void ipw_bg_abort_scan(struct work_struct *work)
c848d0af 6548{
c4028958
DH		 6549 struct ipw_priv *priv =
6550 container_of(work, struct ipw_priv, abort_scan);
4644151b 6551 mutex_lock(&priv->mutex);
c4028958 6552 ipw_abort_scan(priv);
4644151b 6553 mutex_unlock(&priv->mutex);
c848d0af
JK		 6554}
6555
ea2b26e0
JK		 6556static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6557{
b095c381
JK		 6558 /* This is called when wpa_supplicant loads and closes the driver
6559 * interface. */
cdd1fa1e 6560 priv->ieee->wpa_enabled = value;
b095c381 6561 return 0;
ea2b26e0
JK		 6562}
6563
ea2b26e0
JK		 6564static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6565{
b0a4e7d8
JL		 6566 struct libipw_device *ieee = priv->ieee;
6567 struct libipw_security sec = {
ea2b26e0
JK		 6568 .flags = SEC_AUTH_MODE,
6569 };
6570 int ret = 0;
6571
afbf30a2 6572 if (value & IW_AUTH_ALG_SHARED_KEY) {
ea2b26e0
JK		 6573 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6574 ieee->open_wep = 0;
afbf30a2 6575 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
ea2b26e0
JK		 6576 sec.auth_mode = WLAN_AUTH_OPEN;
6577 ieee->open_wep = 1;
3e234b4e
ZY		 6578 } else if (value & IW_AUTH_ALG_LEAP) {
6579 sec.auth_mode = WLAN_AUTH_LEAP;
6580 ieee->open_wep = 1;
afbf30a2
JK		 6581 } else
6582 return -EINVAL;
ea2b26e0
JK		 6583
6584 if (ieee->set_security)
6585 ieee->set_security(ieee->dev, &sec);
6586 else
6587 ret = -EOPNOTSUPP;
6588
6589 return ret;
6590}
6591
a73e22b2
AB		 6592static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6593 int wpa_ie_len)
afbf30a2
JK		 6594{
6595 /* make sure WPA is enabled */
6596 ipw_wpa_enable(priv, 1);
afbf30a2
JK		 6597}
6598
6599static int ipw_set_rsn_capa(struct ipw_priv *priv,
6600 char *capabilities, int length)
6601{
afbf30a2
JK		 6602 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6603
0a7bcf26 6604 return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
2638bc39 6605 capabilities);
afbf30a2
JK		 6606}
6607
b095c381 6608/*
afbf30a2
JK		 6609 * WE-18 support
6610 */
6611
6612/* SIOCSIWGENIE */
6613static int ipw_wx_set_genie(struct net_device *dev,
6614 struct iw_request_info *info,
6615 union iwreq_data *wrqu, char *extra)
ea2b26e0 6616{
b0a4e7d8
JL		 6617 struct ipw_priv *priv = libipw_priv(dev);
6618 struct libipw_device *ieee = priv->ieee;
afbf30a2
JK		 6619 u8 *buf;
6620 int err = 0;
ea2b26e0 6621
afbf30a2
JK		 6622 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6623 (wrqu->data.length && extra == NULL))
6624 return -EINVAL;
ea2b26e0 6625
afbf30a2 6626 if (wrqu->data.length) {
d3e5033d 6627 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
afbf30a2
JK		 6628 if (buf == NULL) {
6629 err = -ENOMEM;
6630 goto out;
6631 }
6632
afbf30a2
JK		 6633 kfree(ieee->wpa_ie);
6634 ieee->wpa_ie = buf;
6635 ieee->wpa_ie_len = wrqu->data.length;
b095c381 6636 } else {
afbf30a2
JK		 6637 kfree(ieee->wpa_ie);
6638 ieee->wpa_ie = NULL;
6639 ieee->wpa_ie_len = 0;
ea2b26e0 6640 }
afbf30a2
JK		 6641
6642 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6643 out:
afbf30a2
JK		 6644 return err;
6645}
6646
6647/* SIOCGIWGENIE */
6648static int ipw_wx_get_genie(struct net_device *dev,
6649 struct iw_request_info *info,
6650 union iwreq_data *wrqu, char *extra)
6651{
b0a4e7d8
JL		 6652 struct ipw_priv *priv = libipw_priv(dev);
6653 struct libipw_device *ieee = priv->ieee;
afbf30a2
JK		 6654 int err = 0;
6655
afbf30a2
JK		 6656 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6657 wrqu->data.length = 0;
6658 goto out;
6659 }
6660
6661 if (wrqu->data.length < ieee->wpa_ie_len) {
6662 err = -E2BIG;
6663 goto out;
6664 }
6665
6666 wrqu->data.length = ieee->wpa_ie_len;
6667 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6668
6669 out:
afbf30a2
JK		 6670 return err;
6671}
6672
1fbfea54
ZY		 6673static int wext_cipher2level(int cipher)
6674{
6675 switch (cipher) {
6676 case IW_AUTH_CIPHER_NONE:
6677 return SEC_LEVEL_0;
6678 case IW_AUTH_CIPHER_WEP40:
6679 case IW_AUTH_CIPHER_WEP104:
6680 return SEC_LEVEL_1;
6681 case IW_AUTH_CIPHER_TKIP:
6682 return SEC_LEVEL_2;
6683 case IW_AUTH_CIPHER_CCMP:
6684 return SEC_LEVEL_3;
6685 default:
6686 return -1;
6687 }
6688}
6689
afbf30a2
JK		 6690/* SIOCSIWAUTH */
6691static int ipw_wx_set_auth(struct net_device *dev,
6692 struct iw_request_info *info,
6693 union iwreq_data *wrqu, char *extra)
6694{
b0a4e7d8
JL		 6695 struct ipw_priv *priv = libipw_priv(dev);
6696 struct libipw_device *ieee = priv->ieee;
afbf30a2 6697 struct iw_param *param = &wrqu->param;
274bfb8d 6698 struct lib80211_crypt_data *crypt;
afbf30a2
JK		 6699 unsigned long flags;
6700 int ret = 0;
6701
6702 switch (param->flags & IW_AUTH_INDEX) {
6703 case IW_AUTH_WPA_VERSION:
1fbfea54 6704 break;
afbf30a2 6705 case IW_AUTH_CIPHER_PAIRWISE:
1fbfea54
ZY		 6706 ipw_set_hw_decrypt_unicast(priv,
6707 wext_cipher2level(param->value));
6708 break;
afbf30a2 6709 case IW_AUTH_CIPHER_GROUP:
1fbfea54
ZY		 6710 ipw_set_hw_decrypt_multicast(priv,
6711 wext_cipher2level(param->value));
6712 break;
afbf30a2
JK		 6713 case IW_AUTH_KEY_MGMT:
6714 /*
6715 * ipw2200 does not use these parameters
6716 */
6717 break;
6718
6719 case IW_AUTH_TKIP_COUNTERMEASURES:
274bfb8d 6720 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
991d1cc5 6721 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
afbf30a2 6722 break;
afbf30a2
JK		 6723
6724 flags = crypt->ops->get_flags(crypt->priv);
6725
6726 if (param->value)
6727 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6728 else
6729 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6730
6731 crypt->ops->set_flags(flags, crypt->priv);
6732
6733 break;
6734
6735 case IW_AUTH_DROP_UNENCRYPTED:{
6736 /* HACK:
6737 *
6738 * wpa_supplicant calls set_wpa_enabled when the driver
6739 * is loaded and unloaded, regardless of if WPA is being
6740 * used. No other calls are made which can be used to
6741 * determine if encryption will be used or not prior to
6742 * association being expected. If encryption is not being
6743 * used, drop_unencrypted is set to false, else true -- we
6744 * can use this to determine if the CAP_PRIVACY_ON bit should
6745 * be set.
6746 */
b0a4e7d8 6747 struct libipw_security sec = {
afbf30a2
JK		 6748 .flags = SEC_ENABLED,
6749 .enabled = param->value,
6750 };
6751 priv->ieee->drop_unencrypted = param->value;
6752 /* We only change SEC_LEVEL for open mode. Others
6753 * are set by ipw_wpa_set_encryption.
6754 */
6755 if (!param->value) {
6756 sec.flags |= SEC_LEVEL;
6757 sec.level = SEC_LEVEL_0;
6758 } else {
6759 sec.flags |= SEC_LEVEL;
6760 sec.level = SEC_LEVEL_1;
6761 }
6762 if (priv->ieee->set_security)
6763 priv->ieee->set_security(priv->ieee->dev, &sec);
6764 break;
6765 }
6766
6767 case IW_AUTH_80211_AUTH_ALG:
6768 ret = ipw_wpa_set_auth_algs(priv, param->value);
6769 break;
6770
6771 case IW_AUTH_WPA_ENABLED:
6772 ret = ipw_wpa_enable(priv, param->value);
e3c5a64e 6773 ipw_disassociate(priv);
afbf30a2
JK		 6774 break;
6775
6776 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6777 ieee->ieee802_1x = param->value;
6778 break;
6779
afbf30a2
JK		 6780 case IW_AUTH_PRIVACY_INVOKED:
6781 ieee->privacy_invoked = param->value;
6782 break;
6783
6784 default:
6785 return -EOPNOTSUPP;
6786 }
6787 return ret;
6788}
6789
6790/* SIOCGIWAUTH */
6791static int ipw_wx_get_auth(struct net_device *dev,
6792 struct iw_request_info *info,
6793 union iwreq_data *wrqu, char *extra)
6794{
b0a4e7d8
JL		 6795 struct ipw_priv *priv = libipw_priv(dev);
6796 struct libipw_device *ieee = priv->ieee;
274bfb8d 6797 struct lib80211_crypt_data *crypt;
afbf30a2
JK		 6798 struct iw_param *param = &wrqu->param;
6799 int ret = 0;
6800
6801 switch (param->flags & IW_AUTH_INDEX) {
6802 case IW_AUTH_WPA_VERSION:
6803 case IW_AUTH_CIPHER_PAIRWISE:
6804 case IW_AUTH_CIPHER_GROUP:
6805 case IW_AUTH_KEY_MGMT:
6806 /*
6807 * wpa_supplicant will control these internally
6808 */
6809 ret = -EOPNOTSUPP;
6810 break;
6811
6812 case IW_AUTH_TKIP_COUNTERMEASURES:
274bfb8d 6813 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
991d1cc5 6814 if (!crypt || !crypt->ops->get_flags)
afbf30a2 6815 break;
afbf30a2
JK		 6816
6817 param->value = (crypt->ops->get_flags(crypt->priv) &
6818 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6819
6820 break;
6821
6822 case IW_AUTH_DROP_UNENCRYPTED:
6823 param->value = ieee->drop_unencrypted;
6824 break;
6825
6826 case IW_AUTH_80211_AUTH_ALG:
6827 param->value = ieee->sec.auth_mode;
6828 break;
6829
6830 case IW_AUTH_WPA_ENABLED:
6831 param->value = ieee->wpa_enabled;
6832 break;
6833
6834 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6835 param->value = ieee->ieee802_1x;
6836 break;
6837
6838 case IW_AUTH_ROAMING_CONTROL:
6839 case IW_AUTH_PRIVACY_INVOKED:
6840 param->value = ieee->privacy_invoked;
6841 break;
6842
6843 default:
6844 return -EOPNOTSUPP;
6845 }
6846 return 0;
6847}
6848
6849/* SIOCSIWENCODEEXT */
6850static int ipw_wx_set_encodeext(struct net_device *dev,
6851 struct iw_request_info *info,
6852 union iwreq_data *wrqu, char *extra)
6853{
b0a4e7d8 6854 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2
JK		 6855 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6856
6857 if (hwcrypto) {
afbf30a2 6858 if (ext->alg == IW_ENCODE_ALG_TKIP) {
567deaf6
HL		 6859 /* IPW HW can't build TKIP MIC,
6860 host decryption still needed */
6861 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6862 priv->ieee->host_mc_decrypt = 1;
6863 else {
6864 priv->ieee->host_encrypt = 0;
6865 priv->ieee->host_encrypt_msdu = 1;
6866 priv->ieee->host_decrypt = 1;
6867 }
afbf30a2
JK		 6868 } else {
6869 priv->ieee->host_encrypt = 0;
6870 priv->ieee->host_encrypt_msdu = 0;
6871 priv->ieee->host_decrypt = 0;
567deaf6 6872 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 6873 }
6874 }
6875
b0a4e7d8 6876 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
afbf30a2
JK		 6877}
6878
6879/* SIOCGIWENCODEEXT */
6880static int ipw_wx_get_encodeext(struct net_device *dev,
6881 struct iw_request_info *info,
6882 union iwreq_data *wrqu, char *extra)
6883{
b0a4e7d8
JL		 6884 struct ipw_priv *priv = libipw_priv(dev);
6885 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
afbf30a2
JK		 6886}
6887
6888/* SIOCSIWMLME */
6889static int ipw_wx_set_mlme(struct net_device *dev,
6890 struct iw_request_info *info,
6891 union iwreq_data *wrqu, char *extra)
6892{
b0a4e7d8 6893 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 6894 struct iw_mlme *mlme = (struct iw_mlme *)extra;
e62e1ee0 6895 __le16 reason;
afbf30a2
JK		 6896
6897 reason = cpu_to_le16(mlme->reason_code);
6898
6899 switch (mlme->cmd) {
6900 case IW_MLME_DEAUTH:
67fd6b45 6901 /* silently ignore */
afbf30a2
JK		 6902 break;
6903
6904 case IW_MLME_DISASSOC:
6905 ipw_disassociate(priv);
6906 break;
6907
6908 default:
6909 return -EOPNOTSUPP;
6910 }
6911 return 0;
6912}
afbf30a2 6913
e43e3c1e 6914#ifdef CONFIG_IPW2200_QOS
afbf30a2
JK		 6915
6916/* QoS */
6917/*
6918* get the modulation type of the current network or
6919* the card current mode
6920*/
53d0bcf8 6921static u8 ipw_qos_current_mode(struct ipw_priv * priv)
afbf30a2
JK		 6922{
6923 u8 mode = 0;
6924
6925 if (priv->status & STATUS_ASSOCIATED) {
6926 unsigned long flags;
6927
6928 spin_lock_irqsave(&priv->ieee->lock, flags);
6929 mode = priv->assoc_network->mode;
6930 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6931 } else {
6932 mode = priv->ieee->mode;
6933 }
9fd1ea42 6934 IPW_DEBUG_QOS("QoS network/card mode %d\n", mode);
afbf30a2 6935 return mode;
b095c381 6936}
ea2b26e0 6937
b095c381
JK		 6938/*
6939* Handle management frame beacon and probe response
6940*/
3b9990cb
JK		 6941static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6942 int active_network,
b0a4e7d8 6943 struct libipw_network *network)
b095c381 6944{
b0a4e7d8 6945 u32 size = sizeof(struct libipw_qos_parameters);
b095c381 6946
afbf30a2 6947 if (network->capability & WLAN_CAPABILITY_IBSS)
b095c381
JK		 6948 network->qos_data.active = network->qos_data.supported;
6949
6950 if (network->flags & NETWORK_HAS_QOS_MASK) {
afbf30a2
JK		 6951 if (active_network &&
6952 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
b095c381
JK		 6953 network->qos_data.active = network->qos_data.supported;
6954
6955 if ((network->qos_data.active == 1) && (active_network == 1) &&
6956 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6957 (network->qos_data.old_param_count !=
6958 network->qos_data.param_count)) {
6959 network->qos_data.old_param_count =
6960 network->qos_data.param_count;
6961 schedule_work(&priv->qos_activate);
afbf30a2
JK		 6962 IPW_DEBUG_QOS("QoS parameters change call "
6963 "qos_activate\n");
b095c381 6964 }
ea2b26e0 6965 } else {
afbf30a2
JK		 6966 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6967 memcpy(&network->qos_data.parameters,
b095c381 6968 &def_parameters_CCK, size);
afbf30a2
JK		 6969 else
6970 memcpy(&network->qos_data.parameters,
b095c381 6971 &def_parameters_OFDM, size);
afbf30a2 6972
b095c381 6973 if ((network->qos_data.active == 1) && (active_network == 1)) {
9fd1ea42 6974 IPW_DEBUG_QOS("QoS was disabled call qos_activate\n");
b095c381
JK		 6975 schedule_work(&priv->qos_activate);
6976 }
6977
6978 network->qos_data.active = 0;
6979 network->qos_data.supported = 0;
ea2b26e0 6980 }
afbf30a2
JK		 6981 if ((priv->status & STATUS_ASSOCIATED) &&
6982 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6983 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
c5d3dce8 6984 if (network->capability & WLAN_CAPABILITY_IBSS)
b095c381 6985 if ((network->ssid_len ==
afbf30a2
JK		 6986 priv->assoc_network->ssid_len) &&
6987 !memcmp(network->ssid,
6988 priv->assoc_network->ssid,
6989 network->ssid_len)) {
b095c381
JK		 6990 queue_work(priv->workqueue,
6991 &priv->merge_networks);
6992 }
b095c381 6993 }
ea2b26e0 6994
b095c381
JK		 6995 return 0;
6996}
6997
6998/*
6999* This function set up the firmware to support QoS. It sends
7000* IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
7001*/
7002static int ipw_qos_activate(struct ipw_priv *priv,
b0a4e7d8 7003 struct libipw_qos_data *qos_network_data)
b095c381
JK		 7004{
7005 int err;
b0a4e7d8
JL		 7006 struct libipw_qos_parameters qos_parameters[QOS_QOS_SETS];
7007 struct libipw_qos_parameters *active_one = NULL;
7008 u32 size = sizeof(struct libipw_qos_parameters);
b095c381
JK		 7009 u32 burst_duration;
7010 int i;
7011 u8 type;
7012
7013 type = ipw_qos_current_mode(priv);
7014
7015 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
7016 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
7017 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
7018 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
7019
7020 if (qos_network_data == NULL) {
7021 if (type == IEEE_B) {
7022 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
7023 active_one = &def_parameters_CCK;
7024 } else
7025 active_one = &def_parameters_OFDM;
7026
afbf30a2 7027 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7028 burst_duration = ipw_qos_get_burst_duration(priv);
7029 for (i = 0; i < QOS_QUEUE_NUM; i++)
afbf30a2 7030 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
8fffc15d 7031 cpu_to_le16(burst_duration);
afbf30a2 7032 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
b095c381
JK		 7033 if (type == IEEE_B) {
7034 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
7035 type);
7036 if (priv->qos_data.qos_enable == 0)
7037 active_one = &def_parameters_CCK;
7038 else
7039 active_one = priv->qos_data.def_qos_parm_CCK;
7040 } else {
7041 if (priv->qos_data.qos_enable == 0)
7042 active_one = &def_parameters_OFDM;
7043 else
7044 active_one = priv->qos_data.def_qos_parm_OFDM;
7045 }
afbf30a2 7046 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7047 } else {
7048 unsigned long flags;
7049 int active;
7050
7051 spin_lock_irqsave(&priv->ieee->lock, flags);
7052 active_one = &(qos_network_data->parameters);
7053 qos_network_data->old_param_count =
7054 qos_network_data->param_count;
afbf30a2 7055 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7056 active = qos_network_data->supported;
7057 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7058
7059 if (active == 0) {
7060 burst_duration = ipw_qos_get_burst_duration(priv);
7061 for (i = 0; i < QOS_QUEUE_NUM; i++)
7062 qos_parameters[QOS_PARAM_SET_ACTIVE].
8fffc15d 7063 tx_op_limit[i] = cpu_to_le16(burst_duration);
b095c381
JK		 7064 }
7065 }
7066
7067 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
afbf30a2 7068 err = ipw_send_qos_params_command(priv,
b0a4e7d8 7069 (struct libipw_qos_parameters *)
afbf30a2 7070 &(qos_parameters[0]));
b095c381
JK		 7071 if (err)
7072 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
7073
7074 return err;
7075}
7076
7077/*
7078* send IPW_CMD_WME_INFO to the firmware
7079*/
7080static int ipw_qos_set_info_element(struct ipw_priv *priv)
7081{
7082 int ret = 0;
b0a4e7d8 7083 struct libipw_qos_information_element qos_info;
b095c381
JK		 7084
7085 if (priv == NULL)
7086 return -1;
7087
7088 qos_info.elementID = QOS_ELEMENT_ID;
b0a4e7d8 7089 qos_info.length = sizeof(struct libipw_qos_information_element) - 2;
b095c381
JK		 7090
7091 qos_info.version = QOS_VERSION_1;
7092 qos_info.ac_info = 0;
7093
7094 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
7095 qos_info.qui_type = QOS_OUI_TYPE;
7096 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
7097
7098 ret = ipw_send_qos_info_command(priv, &qos_info);
7099 if (ret != 0) {
7100 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
7101 }
7102 return ret;
7103}
7104
7105/*
7106* Set the QoS parameter with the association request structure
7107*/
7108static int ipw_qos_association(struct ipw_priv *priv,
b0a4e7d8 7109 struct libipw_network *network)
b095c381
JK		 7110{
7111 int err = 0;
b0a4e7d8
JL		 7112 struct libipw_qos_data *qos_data = NULL;
7113 struct libipw_qos_data ibss_data = {
b095c381
JK		 7114 .supported = 1,
7115 .active = 1,
7116 };
7117
7118 switch (priv->ieee->iw_mode) {
7119 case IW_MODE_ADHOC:
5d9428de 7120 BUG_ON(!(network->capability & WLAN_CAPABILITY_IBSS));
b095c381
JK		 7121
7122 qos_data = &ibss_data;
7123 break;
7124
7125 case IW_MODE_INFRA:
7126 qos_data = &network->qos_data;
7127 break;
7128
7129 default:
7130 BUG();
7131 break;
7132 }
7133
7134 err = ipw_qos_activate(priv, qos_data);
7135 if (err) {
7136 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
7137 return err;
7138 }
7139
7140 if (priv->qos_data.qos_enable && qos_data->supported) {
7141 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
7142 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
7143 return ipw_qos_set_info_element(priv);
7144 }
7145
7146 return 0;
7147}
7148
7149/*
0779bf2d
ML		 7150* handling the beaconing responses. if we get different QoS setting
7151* off the network from the associated setting, adjust the QoS
b095c381
JK		 7152* setting
7153*/
7154static int ipw_qos_association_resp(struct ipw_priv *priv,
b0a4e7d8 7155 struct libipw_network *network)
b095c381
JK		 7156{
7157 int ret = 0;
7158 unsigned long flags;
b0a4e7d8 7159 u32 size = sizeof(struct libipw_qos_parameters);
b095c381
JK		 7160 int set_qos_param = 0;
7161
afbf30a2
JK		 7162 if ((priv == NULL) || (network == NULL) ||
7163 (priv->assoc_network == NULL))
b095c381
JK		 7164 return ret;
7165
7166 if (!(priv->status & STATUS_ASSOCIATED))
7167 return ret;
7168
afbf30a2 7169 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
b095c381 7170 return ret;
b095c381
JK		 7171
7172 spin_lock_irqsave(&priv->ieee->lock, flags);
7173 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
afbf30a2 7174 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
b0a4e7d8 7175 sizeof(struct libipw_qos_data));
b095c381
JK		 7176 priv->assoc_network->qos_data.active = 1;
7177 if ((network->qos_data.old_param_count !=
7178 network->qos_data.param_count)) {
7179 set_qos_param = 1;
7180 network->qos_data.old_param_count =
7181 network->qos_data.param_count;
7182 }
7183
7184 } else {
afbf30a2
JK		 7185 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7186 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 7187 &def_parameters_CCK, size);
afbf30a2
JK		 7188 else
7189 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 7190 &def_parameters_OFDM, size);
b095c381
JK		 7191 priv->assoc_network->qos_data.active = 0;
7192 priv->assoc_network->qos_data.supported = 0;
7193 set_qos_param = 1;
7194 }
7195
7196 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7197
7198 if (set_qos_param == 1)
7199 schedule_work(&priv->qos_activate);
7200
7201 return ret;
7202}
7203
7204static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
7205{
7206 u32 ret = 0;
7207
7208 if ((priv == NULL))
7209 return 0;
7210
b0a4e7d8 7211 if (!(priv->ieee->modulation & LIBIPW_OFDM_MODULATION))
b095c381 7212 ret = priv->qos_data.burst_duration_CCK;
afbf30a2 7213 else
b095c381 7214 ret = priv->qos_data.burst_duration_OFDM;
afbf30a2 7215
b095c381
JK		 7216 return ret;
7217}
7218
7219/*
7220* Initialize the setting of QoS global
7221*/
7222static void ipw_qos_init(struct ipw_priv *priv, int enable,
7223 int burst_enable, u32 burst_duration_CCK,
7224 u32 burst_duration_OFDM)
7225{
7226 priv->qos_data.qos_enable = enable;
7227
7228 if (priv->qos_data.qos_enable) {
7229 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7230 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7231 IPW_DEBUG_QOS("QoS is enabled\n");
7232 } else {
7233 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7234 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7235 IPW_DEBUG_QOS("QoS is not enabled\n");
7236 }
7237
7238 priv->qos_data.burst_enable = burst_enable;
7239
7240 if (burst_enable) {
7241 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7242 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7243 } else {
7244 priv->qos_data.burst_duration_CCK = 0;
7245 priv->qos_data.burst_duration_OFDM = 0;
7246 }
7247}
7248
7249/*
7250* map the packet priority to the right TX Queue
7251*/
7252static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
7253{
7254 if (priority > 7 || !priv->qos_data.qos_enable)
7255 priority = 0;
7256
7257 return from_priority_to_tx_queue[priority] - 1;
7258}
7259
a5cf4fe6
ZY		 7260static int ipw_is_qos_active(struct net_device *dev,
7261 struct sk_buff *skb)
b095c381 7262{
b0a4e7d8
JL		 7263 struct ipw_priv *priv = libipw_priv(dev);
7264 struct libipw_qos_data *qos_data = NULL;
b095c381 7265 int active, supported;
a5cf4fe6
ZY		 7266 u8 *daddr = skb->data + ETH_ALEN;
7267 int unicast = !is_multicast_ether_addr(daddr);
b095c381
JK		 7268
7269 if (!(priv->status & STATUS_ASSOCIATED))
7270 return 0;
7271
7272 qos_data = &priv->assoc_network->qos_data;
7273
b095c381
JK		 7274 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7275 if (unicast == 0)
7276 qos_data->active = 0;
7277 else
7278 qos_data->active = qos_data->supported;
7279 }
b095c381
JK		 7280 active = qos_data->active;
7281 supported = qos_data->supported;
afbf30a2
JK		 7282 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
7283 "unicast %d\n",
7284 priv->qos_data.qos_enable, active, supported, unicast);
a5cf4fe6
ZY		 7285 if (active && priv->qos_data.qos_enable)
7286 return 1;
b095c381 7287
a5cf4fe6
ZY		 7288 return 0;
7289
7290}
7291/*
7292* add QoS parameter to the TX command
7293*/
7294static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
7295 u16 priority,
7296 struct tfd_data *tfd)
7297{
7298 int tx_queue_id = 0;
7299
7300
7301 tx_queue_id = from_priority_to_tx_queue[priority] - 1;
7302 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7303
7304 if (priv->qos_data.qos_no_ack_mask & (1UL << tx_queue_id)) {
7305 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
851ca268 7306 tfd->tfd.tfd_26.mchdr.qos_ctrl |= cpu_to_le16(CTRL_QOS_NO_ACK);
a5cf4fe6
ZY		 7307 }
7308 return 0;
b095c381
JK		 7309}
7310
7311/*
7312* background support to run QoS activate functionality
7313*/
c4028958 7314static void ipw_bg_qos_activate(struct work_struct *work)
b095c381 7315{
c4028958
DH		 7316 struct ipw_priv *priv =
7317 container_of(work, struct ipw_priv, qos_activate);
b095c381 7318
4644151b 7319 mutex_lock(&priv->mutex);
b095c381
JK		 7320
7321 if (priv->status & STATUS_ASSOCIATED)
7322 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7323
4644151b 7324 mutex_unlock(&priv->mutex);
b095c381
JK		 7325}
7326
3b9990cb 7327static int ipw_handle_probe_response(struct net_device *dev,
b0a4e7d8
JL		 7328 struct libipw_probe_response *resp,
7329 struct libipw_network *network)
b095c381 7330{
b0a4e7d8 7331 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7332 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7333 (network == priv->assoc_network));
43f66a6c 7334
3b9990cb 7335 ipw_qos_handle_probe_response(priv, active_network, network);
43f66a6c 7336
3b9990cb
JK		 7337 return 0;
7338}
43f66a6c 7339
3b9990cb 7340static int ipw_handle_beacon(struct net_device *dev,
b0a4e7d8
JL		 7341 struct libipw_beacon *resp,
7342 struct libipw_network *network)
3b9990cb 7343{
b0a4e7d8 7344 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7345 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7346 (network == priv->assoc_network));
bf79451e 7347
3b9990cb 7348 ipw_qos_handle_probe_response(priv, active_network, network);
bf79451e 7349
b095c381
JK		 7350 return 0;
7351}
bf79451e 7352
3b9990cb 7353static int ipw_handle_assoc_response(struct net_device *dev,
b0a4e7d8
JL		 7354 struct libipw_assoc_response *resp,
7355 struct libipw_network *network)
3b9990cb 7356{
b0a4e7d8 7357 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7358 ipw_qos_association_resp(priv, network);
7359 return 0;
7360}
43f66a6c 7361
b0a4e7d8 7362static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
b095c381
JK		 7363 *qos_param)
7364{
4e22699f
ZY		 7365 return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7366 sizeof(*qos_param) * 3, qos_param);
b095c381
JK		 7367}
7368
b0a4e7d8 7369static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
b095c381
JK		 7370 *qos_param)
7371{
4e22699f
ZY		 7372 return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7373 qos_param);
43f66a6c
JK		 7374}
7375
e43e3c1e 7376#endif /* CONFIG_IPW2200_QOS */
b095c381 7377
43f66a6c 7378static int ipw_associate_network(struct ipw_priv *priv,
b0a4e7d8 7379 struct libipw_network *network,
0edd5b44 7380 struct ipw_supported_rates *rates, int roaming)
43f66a6c
JK		 7381{
7382 int err;
9387b7ca 7383 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 7384
7385 if (priv->config & CFG_FIXED_RATE)
b095c381 7386 ipw_set_fixed_rate(priv, network->mode);
43f66a6c
JK		 7387
7388 if (!(priv->config & CFG_STATIC_ESSID)) {
bf79451e 7389 priv->essid_len = min(network->ssid_len,
0edd5b44 7390 (u8) IW_ESSID_MAX_SIZE);
43f66a6c
JK		 7391 memcpy(priv->essid, network->ssid, priv->essid_len);
7392 }
7393
7394 network->last_associate = jiffies;
7395
7396 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7397 priv->assoc_request.channel = network->channel;
3e234b4e
ZY		 7398 priv->assoc_request.auth_key = 0;
7399
43f66a6c 7400 if ((priv->capability & CAP_PRIVACY_ON) &&
3e234b4e 7401 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
43f66a6c 7402 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
b095c381
JK		 7403 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7404
1ba61e05 7405 if (priv->ieee->sec.level == SEC_LEVEL_1)
b095c381 7406 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
3e234b4e
ZY		 7407
7408 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7409 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7410 priv->assoc_request.auth_type = AUTH_LEAP;
7411 else
43f66a6c 7412 priv->assoc_request.auth_type = AUTH_OPEN;
43f66a6c 7413
b095c381 7414 if (priv->ieee->wpa_ie_len) {
5b5e807f 7415 priv->assoc_request.policy_support = cpu_to_le16(0x02); /* RSN active */
ea2b26e0
JK		 7416 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7417 priv->ieee->wpa_ie_len);
7418 }
43f66a6c 7419
bf79451e
JG		 7420 /*
7421 * It is valid for our ieee device to support multiple modes, but
7422 * when it comes to associating to a given network we have to choose
43f66a6c
JK		 7423 * just one mode.
7424 */
7425 if (network->mode & priv->ieee->mode & IEEE_A)
7426 priv->assoc_request.ieee_mode = IPW_A_MODE;
7427 else if (network->mode & priv->ieee->mode & IEEE_G)
7428 priv->assoc_request.ieee_mode = IPW_G_MODE;
7429 else if (network->mode & priv->ieee->mode & IEEE_B)
7430 priv->assoc_request.ieee_mode = IPW_B_MODE;
7431
5b5e807f 7432 priv->assoc_request.capability = cpu_to_le16(network->capability);
ea2b26e0
JK		 7433 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7434 && !(priv->config & CFG_PREAMBLE_LONG)) {
7435 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7436 } else {
7437 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7438
7439 /* Clear the short preamble if we won't be supporting it */
7440 priv->assoc_request.capability &=
5b5e807f 7441 ~cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
ea2b26e0
JK		 7442 }
7443
afbf30a2
JK		 7444 /* Clear capability bits that aren't used in Ad Hoc */
7445 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7446 priv->assoc_request.capability &=
5b5e807f 7447 ~cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME);
afbf30a2 7448
43f66a6c 7449 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
ea2b26e0 7450 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
43f66a6c 7451 roaming ? "Rea" : "A",
9387b7ca 7452 print_ssid(ssid, priv->essid, priv->essid_len),
bf79451e
JG		 7453 network->channel,
7454 ipw_modes[priv->assoc_request.ieee_mode],
7455 rates->num_rates,
ea2b26e0
JK		 7456 (priv->assoc_request.preamble_length ==
7457 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7458 network->capability &
7459 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
43f66a6c 7460 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
bf79451e
JG		 7461 priv->capability & CAP_PRIVACY_ON ?
7462 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
43f66a6c
JK		 7463 "(open)") : "",
7464 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
bf79451e 7465 priv->capability & CAP_PRIVACY_ON ?
b095c381 7466 '1' + priv->ieee->sec.active_key : '.',
0edd5b44 7467 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
43f66a6c 7468
5b5e807f 7469 priv->assoc_request.beacon_interval = cpu_to_le16(network->beacon_interval);
43f66a6c 7470 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
0edd5b44 7471 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
43f66a6c
JK		 7472 priv->assoc_request.assoc_type = HC_IBSS_START;
7473 priv->assoc_request.assoc_tsf_msw = 0;
7474 priv->assoc_request.assoc_tsf_lsw = 0;
7475 } else {
7476 if (unlikely(roaming))
7477 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7478 else
7479 priv->assoc_request.assoc_type = HC_ASSOCIATE;
5b5e807f
AV		 7480 priv->assoc_request.assoc_tsf_msw = cpu_to_le32(network->time_stamp[1]);
7481 priv->assoc_request.assoc_tsf_lsw = cpu_to_le32(network->time_stamp[0]);
43f66a6c
JK		 7482 }
7483
afbf30a2 7484 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
43f66a6c
JK		 7485
7486 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7487 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
5b5e807f 7488 priv->assoc_request.atim_window = cpu_to_le16(network->atim_window);
43f66a6c 7489 } else {
afbf30a2 7490 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
43f66a6c
JK		 7491 priv->assoc_request.atim_window = 0;
7492 }
7493
5b5e807f 7494 priv->assoc_request.listen_interval = cpu_to_le16(network->listen_interval);
bf79451e 7495
43f66a6c
JK		 7496 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7497 if (err) {
7498 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7499 return err;
7500 }
7501
7502 rates->ieee_mode = priv->assoc_request.ieee_mode;
7503 rates->purpose = IPW_RATE_CONNECT;
7504 ipw_send_supported_rates(priv, rates);
bf79451e 7505
43f66a6c
JK		 7506 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7507 priv->sys_config.dot11g_auto_detection = 1;
7508 else
7509 priv->sys_config.dot11g_auto_detection = 0;
c848d0af
JK		 7510
7511 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7512 priv->sys_config.answer_broadcast_ssid_probe = 1;
7513 else
7514 priv->sys_config.answer_broadcast_ssid_probe = 0;
7515
d685b8c2 7516 err = ipw_send_system_config(priv);
43f66a6c
JK		 7517 if (err) {
7518 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7519 return err;
7520 }
bf79451e 7521
43f66a6c 7522 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
ea2b26e0 7523 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
43f66a6c
JK		 7524 if (err) {
7525 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7526 return err;
7527 }
7528
7529 /*
7530 * If preemption is enabled, it is possible for the association
7531 * to complete before we return from ipw_send_associate. Therefore
7532 * we have to be sure and update our priviate data first.
7533 */
7534 priv->channel = network->channel;
7535 memcpy(priv->bssid, network->bssid, ETH_ALEN);
bf79451e 7536 priv->status |= STATUS_ASSOCIATING;
43f66a6c
JK		 7537 priv->status &= ~STATUS_SECURITY_UPDATED;
7538
7539 priv->assoc_network = network;
7540
e43e3c1e 7541#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 7542 ipw_qos_association(priv, network);
7543#endif
7544
43f66a6c
JK		 7545 err = ipw_send_associate(priv, &priv->assoc_request);
7546 if (err) {
7547 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7548 return err;
7549 }
bf79451e 7550
9fd1ea42 7551 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' %pM\n",
9387b7ca 7552 print_ssid(ssid, priv->essid, priv->essid_len),
e174961c 7553 priv->bssid);
43f66a6c
JK		 7554
7555 return 0;
7556}
7557
7558static void ipw_roam(void *data)
7559{
7560 struct ipw_priv *priv = data;
b0a4e7d8 7561 struct libipw_network *network = NULL;
43f66a6c
JK		 7562 struct ipw_network_match match = {
7563 .network = priv->assoc_network
7564 };
7565
7566 /* The roaming process is as follows:
bf79451e
JG		 7567 *
7568 * 1. Missed beacon threshold triggers the roaming process by
43f66a6c
JK		 7569 * setting the status ROAM bit and requesting a scan.
7570 * 2. When the scan completes, it schedules the ROAM work
7571 * 3. The ROAM work looks at all of the known networks for one that
7572 * is a better network than the currently associated. If none
7573 * found, the ROAM process is over (ROAM bit cleared)
7574 * 4. If a better network is found, a disassociation request is
7575 * sent.
7576 * 5. When the disassociation completes, the roam work is again
7577 * scheduled. The second time through, the driver is no longer
7578 * associated, and the newly selected network is sent an
bf79451e 7579 * association request.
43f66a6c
JK		 7580 * 6. At this point ,the roaming process is complete and the ROAM
7581 * status bit is cleared.
7582 */
7583
7584 /* If we are no longer associated, and the roaming bit is no longer
7585 * set, then we are not actively roaming, so just return */
7586 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7587 return;
bf79451e 7588
43f66a6c 7589 if (priv->status & STATUS_ASSOCIATED) {
bf79451e 7590 /* First pass through ROAM process -- look for a better
43f66a6c 7591 * network */
a613bffd 7592 unsigned long flags;
43f66a6c
JK		 7593 u8 rssi = priv->assoc_network->stats.rssi;
7594 priv->assoc_network->stats.rssi = -128;
a613bffd 7595 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c
JK		 7596 list_for_each_entry(network, &priv->ieee->network_list, list) {
7597 if (network != priv->assoc_network)
7598 ipw_best_network(priv, &match, network, 1);
7599 }
a613bffd 7600 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c 7601 priv->assoc_network->stats.rssi = rssi;
bf79451e 7602
43f66a6c
JK		 7603 if (match.network == priv->assoc_network) {
7604 IPW_DEBUG_ASSOC("No better APs in this network to "
7605 "roam to.\n");
7606 priv->status &= ~STATUS_ROAMING;
7607 ipw_debug_config(priv);
7608 return;
7609 }
bf79451e 7610
43f66a6c
JK		 7611 ipw_send_disassociate(priv, 1);
7612 priv->assoc_network = match.network;
7613
7614 return;
bf79451e 7615 }
43f66a6c
JK		 7616
7617 /* Second pass through ROAM process -- request association */
7618 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7619 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7620 priv->status &= ~STATUS_ROAMING;
7621}
7622
c4028958 7623static void ipw_bg_roam(struct work_struct *work)
c848d0af 7624{
c4028958
DH		 7625 struct ipw_priv *priv =
7626 container_of(work, struct ipw_priv, roam);
4644151b 7627 mutex_lock(&priv->mutex);
c4028958 7628 ipw_roam(priv);
4644151b 7629 mutex_unlock(&priv->mutex);
c848d0af
JK		 7630}
7631
7632static int ipw_associate(void *data)
43f66a6c
JK		 7633{
7634 struct ipw_priv *priv = data;
7635
b0a4e7d8 7636 struct libipw_network *network = NULL;
43f66a6c
JK		 7637 struct ipw_network_match match = {
7638 .network = NULL
7639 };
7640 struct ipw_supported_rates *rates;
7641 struct list_head *element;
a613bffd 7642 unsigned long flags;
9387b7ca 7643 DECLARE_SSID_BUF(ssid);
43f66a6c 7644
b095c381
JK		 7645 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7646 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7647 return 0;
7648 }
7649
c848d0af 7650 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
afbf30a2
JK		 7651 IPW_DEBUG_ASSOC("Not attempting association (already in "
7652 "progress)\n");
c848d0af
JK		 7653 return 0;
7654 }
7655
e6324726
HL		 7656 if (priv->status & STATUS_DISASSOCIATING) {
7657 IPW_DEBUG_ASSOC("Not attempting association (in "
7658 "disassociating)\n ");
7659 queue_work(priv->workqueue, &priv->associate);
7660 return 0;
7661 }
7662
c848d0af 7663 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
afbf30a2
JK		 7664 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7665 "initialized)\n");
c848d0af
JK		 7666 return 0;
7667 }
43f66a6c
JK		 7668
7669 if (!(priv->config & CFG_ASSOCIATE) &&
3e4127fa 7670 !(priv->config & (CFG_STATIC_ESSID | CFG_STATIC_BSSID))) {
43f66a6c 7671 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
c848d0af 7672 return 0;
43f66a6c
JK		 7673 }
7674
a613bffd
JK		 7675 /* Protect our use of the network_list */
7676 spin_lock_irqsave(&priv->ieee->lock, flags);
bf79451e 7677 list_for_each_entry(network, &priv->ieee->network_list, list)
0edd5b44 7678 ipw_best_network(priv, &match, network, 0);
43f66a6c
JK		 7679
7680 network = match.network;
7681 rates = &match.rates;
7682
7683 if (network == NULL &&
7684 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7685 priv->config & CFG_ADHOC_CREATE &&
7686 priv->config & CFG_STATIC_ESSID &&
a6d4eae8
DW		 7687 priv->config & CFG_STATIC_CHANNEL) {
7688 /* Use oldest network if the free list is empty */
7689 if (list_empty(&priv->ieee->network_free_list)) {
b0a4e7d8
JL		 7690 struct libipw_network *oldest = NULL;
7691 struct libipw_network *target;
a6d4eae8
DW		 7692
7693 list_for_each_entry(target, &priv->ieee->network_list, list) {
7694 if ((oldest == NULL) ||
7695 (target->last_scanned < oldest->last_scanned))
7696 oldest = target;
7697 }
7698
7699 /* If there are no more slots, expire the oldest */
7700 list_del(&oldest->list);
7701 target = oldest;
e174961c 7702 IPW_DEBUG_ASSOC("Expired '%s' (%pM) from "
a6d4eae8 7703 "network list.\n",
9387b7ca
JL		 7704 print_ssid(ssid, target->ssid,
7705 target->ssid_len),
e174961c 7706 target->bssid);
a6d4eae8
DW		 7707 list_add_tail(&target->list,
7708 &priv->ieee->network_free_list);
7709 }
7710
43f66a6c 7711 element = priv->ieee->network_free_list.next;
b0a4e7d8 7712 network = list_entry(element, struct libipw_network, list);
43f66a6c
JK		 7713 ipw_adhoc_create(priv, network);
7714 rates = &priv->rates;
7715 list_del(element);
7716 list_add_tail(&network->list, &priv->ieee->network_list);
7717 }
a613bffd 7718 spin_unlock_irqrestore(&priv->ieee->lock, flags);
bf79451e 7719
43f66a6c
JK		 7720 /* If we reached the end of the list, then we don't have any valid
7721 * matching APs */
7722 if (!network) {
7723 ipw_debug_config(priv);
7724
b095c381
JK		 7725 if (!(priv->status & STATUS_SCANNING)) {
7726 if (!(priv->config & CFG_SPEED_SCAN))
7727 queue_delayed_work(priv->workqueue,
7728 &priv->request_scan,
7729 SCAN_INTERVAL);
7730 else
c4028958
DH		 7731 queue_delayed_work(priv->workqueue,
7732 &priv->request_scan, 0);
b095c381 7733 }
bf79451e 7734
c848d0af 7735 return 0;
43f66a6c
JK		 7736 }
7737
7738 ipw_associate_network(priv, network, rates, 0);
c848d0af
JK		 7739
7740 return 1;
7741}
7742
c4028958 7743static void ipw_bg_associate(struct work_struct *work)
c848d0af 7744{
c4028958
DH		 7745 struct ipw_priv *priv =
7746 container_of(work, struct ipw_priv, associate);
4644151b 7747 mutex_lock(&priv->mutex);
c4028958 7748 ipw_associate(priv);
4644151b 7749 mutex_unlock(&priv->mutex);
43f66a6c 7750}
bf79451e 7751
b095c381
JK		 7752static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7753 struct sk_buff *skb)
7754{
7755 struct ieee80211_hdr *hdr;
7756 u16 fc;
7757
7758 hdr = (struct ieee80211_hdr *)skb->data;
72118015 7759 fc = le16_to_cpu(hdr->frame_control);
b095c381
JK		 7760 if (!(fc & IEEE80211_FCTL_PROTECTED))
7761 return;
7762
7763 fc &= ~IEEE80211_FCTL_PROTECTED;
72118015 7764 hdr->frame_control = cpu_to_le16(fc);
b095c381
JK		 7765 switch (priv->ieee->sec.level) {
7766 case SEC_LEVEL_3:
7767 /* Remove CCMP HDR */
b0a4e7d8
JL		 7768 memmove(skb->data + LIBIPW_3ADDR_LEN,
7769 skb->data + LIBIPW_3ADDR_LEN + 8,
7770 skb->len - LIBIPW_3ADDR_LEN - 8);
f4ff497d 7771 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
b095c381
JK		 7772 break;
7773 case SEC_LEVEL_2:
7774 break;
7775 case SEC_LEVEL_1:
7776 /* Remove IV */
b0a4e7d8
JL		 7777 memmove(skb->data + LIBIPW_3ADDR_LEN,
7778 skb->data + LIBIPW_3ADDR_LEN + 4,
7779 skb->len - LIBIPW_3ADDR_LEN - 4);
f4ff497d 7780 skb_trim(skb, skb->len - 8); /* IV + ICV */
b095c381
JK		 7781 break;
7782 case SEC_LEVEL_0:
7783 break;
7784 default:
af901ca1 7785 printk(KERN_ERR "Unknown security level %d\n",
b095c381
JK		 7786 priv->ieee->sec.level);
7787 break;
7788 }
43f66a6c 7789}
bf79451e 7790
b095c381
JK		 7791static void ipw_handle_data_packet(struct ipw_priv *priv,
7792 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 7793 struct libipw_rx_stats *stats)
43f66a6c 7794{
ce55cbaf 7795 struct net_device *dev = priv->net_dev;
b0a4e7d8 7796 struct libipw_hdr_4addr *hdr;
43f66a6c
JK		 7797 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7798
7799 /* We received data from the HW, so stop the watchdog */
ce55cbaf 7800 dev->trans_start = jiffies;
43f66a6c 7801
bf79451e 7802 /* We only process data packets if the
43f66a6c 7803 * interface is open */
a613bffd 7804 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
43f66a6c 7805 skb_tailroom(rxb->skb))) {
ce55cbaf 7806 dev->stats.rx_errors++;
43f66a6c
JK		 7807 priv->wstats.discard.misc++;
7808 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7809 return;
7810 } else if (unlikely(!netif_running(priv->net_dev))) {
ce55cbaf 7811 dev->stats.rx_dropped++;
43f66a6c
JK		 7812 priv->wstats.discard.misc++;
7813 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7814 return;
7815 }
7816
7817 /* Advance skb->data to the start of the actual payload */
aaa4d308 7818 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
43f66a6c
JK		 7819
7820 /* Set the size of the skb to the size of the frame */
a613bffd 7821 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
43f66a6c
JK		 7822
7823 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7824
b095c381 7825 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
b0a4e7d8 7826 hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
567deaf6 7827 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
3c19065a 7828 (is_multicast_ether_addr(hdr->addr1) ?
567deaf6 7829 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
b095c381
JK		 7830 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7831
b0a4e7d8 7832 if (!libipw_rx(priv->ieee, rxb->skb, stats))
ce55cbaf 7833 dev->stats.rx_errors++;
b0a4e7d8 7834 else { /* libipw_rx succeeded, so it now owns the SKB */
43f66a6c 7835 rxb->skb = NULL;
b095c381 7836 __ipw_led_activity_on(priv);
a613bffd 7837 }
43f66a6c
JK		 7838}
7839
459d4087 7840#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 7841static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7842 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 7843 struct libipw_rx_stats *stats)
24a47dbd 7844{
ce55cbaf 7845 struct net_device *dev = priv->net_dev;
24a47dbd
MK		 7846 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7847 struct ipw_rx_frame *frame = &pkt->u.frame;
7848
7849 /* initial pull of some data */
7850 u16 received_channel = frame->received_channel;
7851 u8 antennaAndPhy = frame->antennaAndPhy;
7852 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7853 u16 pktrate = frame->rate;
7854
7855 /* Magic struct that slots into the radiotap header -- no reason
7856 * to build this manually element by element, we can write it much
7857 * more efficiently than we can parse it. ORDER MATTERS HERE */
d685b8c2 7858 struct ipw_rt_hdr *ipw_rt;
24a47dbd
MK		 7859
7860 short len = le16_to_cpu(pkt->u.frame.length);
7861
7862 /* We received data from the HW, so stop the watchdog */
ce55cbaf 7863 dev->trans_start = jiffies;
24a47dbd
MK		 7864
7865 /* We only process data packets if the
7866 * interface is open */
7867 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7868 skb_tailroom(rxb->skb))) {
ce55cbaf 7869 dev->stats.rx_errors++;
24a47dbd
MK		 7870 priv->wstats.discard.misc++;
7871 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7872 return;
7873 } else if (unlikely(!netif_running(priv->net_dev))) {
ce55cbaf 7874 dev->stats.rx_dropped++;
24a47dbd
MK		 7875 priv->wstats.discard.misc++;
7876 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7877 return;
7878 }
7879
7880 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7881 * that now */
7882 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7883 /* FIXME: Should alloc bigger skb instead */
ce55cbaf 7884 dev->stats.rx_dropped++;
24a47dbd
MK		 7885 priv->wstats.discard.misc++;
7886 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7887 return;
7888 }
7889
7890 /* copy the frame itself */
7891 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7892 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7893
24a47dbd
MK		 7894 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7895
7896 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7897 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
743b84d2 7898 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total header+data */
24a47dbd
MK		 7899
7900 /* Big bitfield of all the fields we provide in radiotap */
743b84d2
AV		 7901 ipw_rt->rt_hdr.it_present = cpu_to_le32(
7902 (1 << IEEE80211_RADIOTAP_TSFT) |
4b1f8a99 7903 (1 << IEEE80211_RADIOTAP_FLAGS) |
24a47dbd
MK		 7904 (1 << IEEE80211_RADIOTAP_RATE) |
7905 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7906 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
d685b8c2 7907 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
24a47dbd
MK		 7908 (1 << IEEE80211_RADIOTAP_ANTENNA));
7909
7910 /* Zero the flags, we'll add to them as we go */
7911 ipw_rt->rt_flags = 0;
4b1f8a99
ZY		 7912 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7913 frame->parent_tsf[2] << 16 |
7914 frame->parent_tsf[1] << 8 |
7915 frame->parent_tsf[0]);
24a47dbd
MK		 7916
7917 /* Convert signal to DBM */
7918 ipw_rt->rt_dbmsignal = antsignal;
21f8a73f 7919 ipw_rt->rt_dbmnoise = (s8) le16_to_cpu(frame->noise);
24a47dbd
MK		 7920
7921 /* Convert the channel data and set the flags */
7922 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7923 if (received_channel > 14) { /* 802.11a */
7924 ipw_rt->rt_chbitmask =
7925 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7926 } else if (antennaAndPhy & 32) { /* 802.11b */
7927 ipw_rt->rt_chbitmask =
7928 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7929 } else { /* 802.11g */
7930 ipw_rt->rt_chbitmask =
472caf8c 7931 cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
24a47dbd
MK		 7932 }
7933
7934 /* set the rate in multiples of 500k/s */
7935 switch (pktrate) {
7936 case IPW_TX_RATE_1MB:
7937 ipw_rt->rt_rate = 2;
7938 break;
7939 case IPW_TX_RATE_2MB:
7940 ipw_rt->rt_rate = 4;
7941 break;
7942 case IPW_TX_RATE_5MB:
7943 ipw_rt->rt_rate = 10;
7944 break;
7945 case IPW_TX_RATE_6MB:
7946 ipw_rt->rt_rate = 12;
7947 break;
7948 case IPW_TX_RATE_9MB:
7949 ipw_rt->rt_rate = 18;
7950 break;
7951 case IPW_TX_RATE_11MB:
7952 ipw_rt->rt_rate = 22;
7953 break;
7954 case IPW_TX_RATE_12MB:
7955 ipw_rt->rt_rate = 24;
7956 break;
7957 case IPW_TX_RATE_18MB:
7958 ipw_rt->rt_rate = 36;
7959 break;
7960 case IPW_TX_RATE_24MB:
7961 ipw_rt->rt_rate = 48;
7962 break;
7963 case IPW_TX_RATE_36MB:
7964 ipw_rt->rt_rate = 72;
7965 break;
7966 case IPW_TX_RATE_48MB:
7967 ipw_rt->rt_rate = 96;
7968 break;
7969 case IPW_TX_RATE_54MB:
7970 ipw_rt->rt_rate = 108;
7971 break;
7972 default:
7973 ipw_rt->rt_rate = 0;
7974 break;
7975 }
7976
7977 /* antenna number */
7978 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7979
7980 /* set the preamble flag if we have it */
7981 if ((antennaAndPhy & 64))
7982 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7983
7984 /* Set the size of the skb to the size of the frame */
7985 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
43f66a6c
JK		 7986
7987 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7988
b0a4e7d8 7989 if (!libipw_rx(priv->ieee, rxb->skb, stats))
ce55cbaf 7990 dev->stats.rx_errors++;
b0a4e7d8 7991 else { /* libipw_rx succeeded, so it now owns the SKB */
24a47dbd
MK		 7992 rxb->skb = NULL;
7993 /* no LED during capture */
7994 }
7995}
7996#endif
7997
d685b8c2 7998#ifdef CONFIG_IPW2200_PROMISCUOUS
b0a4e7d8 7999#define libipw_is_probe_response(fc) \
d685b8c2
ZY		 8000 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT && \
8001 (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP )
8002
b0a4e7d8 8003#define libipw_is_management(fc) \
d685b8c2
ZY		 8004 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT)
8005
b0a4e7d8 8006#define libipw_is_control(fc) \
d685b8c2
ZY		 8007 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL)
8008
b0a4e7d8 8009#define libipw_is_data(fc) \
d685b8c2
ZY		 8010 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA)
8011
b0a4e7d8 8012#define libipw_is_assoc_request(fc) \
d685b8c2
ZY		 8013 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_ASSOC_REQ)
8014
b0a4e7d8 8015#define libipw_is_reassoc_request(fc) \
d685b8c2
ZY		 8016 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_REASSOC_REQ)
8017
8018static void ipw_handle_promiscuous_rx(struct ipw_priv *priv,
8019 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 8020 struct libipw_rx_stats *stats)
d685b8c2 8021{
ce55cbaf 8022 struct net_device *dev = priv->prom_net_dev;
d685b8c2
ZY		 8023 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
8024 struct ipw_rx_frame *frame = &pkt->u.frame;
8025 struct ipw_rt_hdr *ipw_rt;
8026
8027 /* First cache any information we need before we overwrite
8028 * the information provided in the skb from the hardware */
8029 struct ieee80211_hdr *hdr;
8030 u16 channel = frame->received_channel;
8031 u8 phy_flags = frame->antennaAndPhy;
8032 s8 signal = frame->rssi_dbm - IPW_RSSI_TO_DBM;
21f8a73f 8033 s8 noise = (s8) le16_to_cpu(frame->noise);
d685b8c2
ZY		 8034 u8 rate = frame->rate;
8035 short len = le16_to_cpu(pkt->u.frame.length);
d685b8c2
ZY		 8036 struct sk_buff *skb;
8037 int hdr_only = 0;
8038 u16 filter = priv->prom_priv->filter;
8039
8040 /* If the filter is set to not include Rx frames then return */
8041 if (filter & IPW_PROM_NO_RX)
8042 return;
8043
d685b8c2 8044 /* We received data from the HW, so stop the watchdog */
ce55cbaf 8045 dev->trans_start = jiffies;
d685b8c2
ZY		 8046
8047 if (unlikely((len + IPW_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) {
ce55cbaf 8048 dev->stats.rx_errors++;
d685b8c2
ZY		 8049 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
8050 return;
8051 }
8052
8053 /* We only process data packets if the interface is open */
ce55cbaf
SH		 8054 if (unlikely(!netif_running(dev))) {
8055 dev->stats.rx_dropped++;
d685b8c2
ZY		 8056 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
8057 return;
8058 }
8059
8060 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
8061 * that now */
8062 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
8063 /* FIXME: Should alloc bigger skb instead */
ce55cbaf 8064 dev->stats.rx_dropped++;
d685b8c2
ZY		 8065 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
8066 return;
8067 }
8068
8069 hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
b0a4e7d8 8070 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8071 if (filter & IPW_PROM_NO_MGMT)
8072 return;
8073 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
8074 hdr_only = 1;
b0a4e7d8 8075 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8076 if (filter & IPW_PROM_NO_CTL)
8077 return;
8078 if (filter & IPW_PROM_CTL_HEADER_ONLY)
8079 hdr_only = 1;
b0a4e7d8 8080 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8081 if (filter & IPW_PROM_NO_DATA)
8082 return;
8083 if (filter & IPW_PROM_DATA_HEADER_ONLY)
8084 hdr_only = 1;
8085 }
8086
8087 /* Copy the SKB since this is for the promiscuous side */
8088 skb = skb_copy(rxb->skb, GFP_ATOMIC);
8089 if (skb == NULL) {
8090 IPW_ERROR("skb_clone failed for promiscuous copy.\n");
8091 return;
8092 }
8093
8094 /* copy the frame data to write after where the radiotap header goes */
8095 ipw_rt = (void *)skb->data;
8096
8097 if (hdr_only)
b0a4e7d8 8098 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
d685b8c2
ZY		 8099
8100 memcpy(ipw_rt->payload, hdr, len);
8101
d685b8c2
ZY		 8102 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
8103 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
743b84d2 8104 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt)); /* total header+data */
d685b8c2
ZY		 8105
8106 /* Set the size of the skb to the size of the frame */
743b84d2 8107 skb_put(skb, sizeof(*ipw_rt) + len);
d685b8c2
ZY		 8108
8109 /* Big bitfield of all the fields we provide in radiotap */
743b84d2
AV		 8110 ipw_rt->rt_hdr.it_present = cpu_to_le32(
8111 (1 << IEEE80211_RADIOTAP_TSFT) |
4b1f8a99 8112 (1 << IEEE80211_RADIOTAP_FLAGS) |
d685b8c2
ZY		 8113 (1 << IEEE80211_RADIOTAP_RATE) |
8114 (1 << IEEE80211_RADIOTAP_CHANNEL) |
8115 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
8116 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
8117 (1 << IEEE80211_RADIOTAP_ANTENNA));
8118
8119 /* Zero the flags, we'll add to them as we go */
8120 ipw_rt->rt_flags = 0;
4b1f8a99
ZY		 8121 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
8122 frame->parent_tsf[2] << 16 |
8123 frame->parent_tsf[1] << 8 |
8124 frame->parent_tsf[0]);
d685b8c2
ZY		 8125
8126 /* Convert to DBM */
8127 ipw_rt->rt_dbmsignal = signal;
8128 ipw_rt->rt_dbmnoise = noise;
8129
8130 /* Convert the channel data and set the flags */
8131 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(channel));
8132 if (channel > 14) { /* 802.11a */
8133 ipw_rt->rt_chbitmask =
8134 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
8135 } else if (phy_flags & (1 << 5)) { /* 802.11b */
8136 ipw_rt->rt_chbitmask =
8137 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
8138 } else { /* 802.11g */
8139 ipw_rt->rt_chbitmask =
472caf8c 8140 cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
d685b8c2
ZY		 8141 }
8142
8143 /* set the rate in multiples of 500k/s */
8144 switch (rate) {
8145 case IPW_TX_RATE_1MB:
8146 ipw_rt->rt_rate = 2;
8147 break;
8148 case IPW_TX_RATE_2MB:
8149 ipw_rt->rt_rate = 4;
8150 break;
8151 case IPW_TX_RATE_5MB:
8152 ipw_rt->rt_rate = 10;
8153 break;
8154 case IPW_TX_RATE_6MB:
8155 ipw_rt->rt_rate = 12;
8156 break;
8157 case IPW_TX_RATE_9MB:
8158 ipw_rt->rt_rate = 18;
8159 break;
8160 case IPW_TX_RATE_11MB:
8161 ipw_rt->rt_rate = 22;
8162 break;
8163 case IPW_TX_RATE_12MB:
8164 ipw_rt->rt_rate = 24;
8165 break;
8166 case IPW_TX_RATE_18MB:
8167 ipw_rt->rt_rate = 36;
8168 break;
8169 case IPW_TX_RATE_24MB:
8170 ipw_rt->rt_rate = 48;
8171 break;
8172 case IPW_TX_RATE_36MB:
8173 ipw_rt->rt_rate = 72;
8174 break;
8175 case IPW_TX_RATE_48MB:
8176 ipw_rt->rt_rate = 96;
8177 break;
8178 case IPW_TX_RATE_54MB:
8179 ipw_rt->rt_rate = 108;
8180 break;
8181 default:
8182 ipw_rt->rt_rate = 0;
8183 break;
8184 }
8185
8186 /* antenna number */
8187 ipw_rt->rt_antenna = (phy_flags & 3);
8188
8189 /* set the preamble flag if we have it */
8190 if (phy_flags & (1 << 6))
8191 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8192
8193 IPW_DEBUG_RX("Rx packet of %d bytes.\n", skb->len);
8194
b0a4e7d8 8195 if (!libipw_rx(priv->prom_priv->ieee, skb, stats)) {
ce55cbaf 8196 dev->stats.rx_errors++;
d685b8c2
ZY		 8197 dev_kfree_skb_any(skb);
8198 }
8199}
8200#endif
8201
858119e1 8202static int is_network_packet(struct ipw_priv *priv,
b0a4e7d8 8203 struct libipw_hdr_4addr *header)
ea2b26e0
JK		 8204{
8205 /* Filter incoming packets to determine if they are targetted toward
8206 * this network, discarding packets coming from ourselves */
8207 switch (priv->ieee->iw_mode) {
a613bffd 8208 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
c848d0af
JK		 8209 /* packets from our adapter are dropped (echo) */
8210 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
8211 return 0;
8212
90700fd9 8213 /* {broad,multi}cast packets to our BSSID go through */
3c19065a 8214 if (is_multicast_ether_addr(header->addr1))
ea2b26e0 8215 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
a613bffd
JK		 8216
8217 /* packets to our adapter go through */
8218 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8219 ETH_ALEN);
a613bffd 8220
90700fd9 8221 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
c848d0af
JK		 8222 /* packets from our adapter are dropped (echo) */
8223 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
8224 return 0;
8225
90700fd9 8226 /* {broad,multi}cast packets to our BSS go through */
3c19065a 8227 if (is_multicast_ether_addr(header->addr1))
a613bffd
JK		 8228 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
8229
8230 /* packets to our adapter go through */
8231 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8232 ETH_ALEN);
ea2b26e0 8233 }
a613bffd 8234
ea2b26e0
JK		 8235 return 1;
8236}
8237
afbf30a2
JK		 8238#define IPW_PACKET_RETRY_TIME HZ
8239
858119e1 8240static int is_duplicate_packet(struct ipw_priv *priv,
b0a4e7d8 8241 struct libipw_hdr_4addr *header)
afbf30a2 8242{
afbf30a2
JK		 8243 u16 sc = le16_to_cpu(header->seq_ctl);
8244 u16 seq = WLAN_GET_SEQ_SEQ(sc);
8245 u16 frag = WLAN_GET_SEQ_FRAG(sc);
8246 u16 *last_seq, *last_frag;
8247 unsigned long *last_time;
8248
8249 switch (priv->ieee->iw_mode) {
8250 case IW_MODE_ADHOC:
8251 {
8252 struct list_head *p;
8253 struct ipw_ibss_seq *entry = NULL;
8254 u8 *mac = header->addr2;
8255 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
8256
8257 __list_for_each(p, &priv->ibss_mac_hash[index]) {
8258 entry =
8259 list_entry(p, struct ipw_ibss_seq, list);
8260 if (!memcmp(entry->mac, mac, ETH_ALEN))
8261 break;
8262 }
8263 if (p == &priv->ibss_mac_hash[index]) {
8264 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
8265 if (!entry) {
8266 IPW_ERROR
8267 ("Cannot malloc new mac entry\n");
8268 return 0;
8269 }
8270 memcpy(entry->mac, mac, ETH_ALEN);
8271 entry->seq_num = seq;
8272 entry->frag_num = frag;
8273 entry->packet_time = jiffies;
8274 list_add(&entry->list,
8275 &priv->ibss_mac_hash[index]);
8276 return 0;
8277 }
8278 last_seq = &entry->seq_num;
8279 last_frag = &entry->frag_num;
8280 last_time = &entry->packet_time;
8281 break;
8282 }
8283 case IW_MODE_INFRA:
8284 last_seq = &priv->last_seq_num;
8285 last_frag = &priv->last_frag_num;
8286 last_time = &priv->last_packet_time;
8287 break;
8288 default:
8289 return 0;
8290 }
8291 if ((*last_seq == seq) &&
8292 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
8293 if (*last_frag == frag)
8294 goto drop;
8295 if (*last_frag + 1 != frag)
8296 /* out-of-order fragment */
8297 goto drop;
afbf30a2
JK		 8298 } else
8299 *last_seq = seq;
8300
f57ce7ce 8301 *last_frag = frag;
afbf30a2
JK		 8302 *last_time = jiffies;
8303 return 0;
8304
8305 drop:
87b016cb
ZY		 8306 /* Comment this line now since we observed the card receives
8307 * duplicate packets but the FCTL_RETRY bit is not set in the
8308 * IBSS mode with fragmentation enabled.
72118015 8309 BUG_ON(!(le16_to_cpu(header->frame_control) & IEEE80211_FCTL_RETRY)); */
afbf30a2
JK		 8310 return 1;
8311}
8312
b095c381
JK		 8313static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
8314 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 8315 struct libipw_rx_stats *stats)
b095c381
JK		 8316{
8317 struct sk_buff *skb = rxb->skb;
8318 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
b0a4e7d8 8319 struct libipw_hdr_4addr *header = (struct libipw_hdr_4addr *)
b095c381
JK		 8320 (skb->data + IPW_RX_FRAME_SIZE);
8321
b0a4e7d8 8322 libipw_rx_mgt(priv->ieee, header, stats);
b095c381
JK		 8323
8324 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8325 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8326 IEEE80211_STYPE_PROBE_RESP) ||
8327 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8328 IEEE80211_STYPE_BEACON))) {
8329 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
8330 ipw_add_station(priv, header->addr2);
8331 }
8332
8333 if (priv->config & CFG_NET_STATS) {
8334 IPW_DEBUG_HC("sending stat packet\n");
8335
8336 /* Set the size of the skb to the size of the full
8337 * ipw header and 802.11 frame */
8338 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8339 IPW_RX_FRAME_SIZE);
8340
8341 /* Advance past the ipw packet header to the 802.11 frame */
8342 skb_pull(skb, IPW_RX_FRAME_SIZE);
8343
b0a4e7d8 8344 /* Push the libipw_rx_stats before the 802.11 frame */
b095c381
JK		 8345 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
8346
8347 skb->dev = priv->ieee->dev;
8348
b0a4e7d8 8349 /* Point raw at the libipw_stats */
459a98ed 8350 skb_reset_mac_header(skb);
b095c381
JK		 8351
8352 skb->pkt_type = PACKET_OTHERHOST;
c1b4aa3f 8353 skb->protocol = cpu_to_be16(ETH_P_80211_STATS);
b095c381
JK		 8354 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8355 netif_rx(skb);
43f66a6c 8356 rxb->skb = NULL;
b095c381 8357 }
43f66a6c
JK		 8358}
8359
43f66a6c
JK		 8360/*
8361 * Main entry function for recieving a packet with 80211 headers. This
8362 * should be called when ever the FW has notified us that there is a new
8363 * skb in the recieve queue.
8364 */
8365static void ipw_rx(struct ipw_priv *priv)
8366{
8367 struct ipw_rx_mem_buffer *rxb;
8368 struct ipw_rx_packet *pkt;
b0a4e7d8 8369 struct libipw_hdr_4addr *header;
43f66a6c
JK		 8370 u32 r, w, i;
8371 u8 network_packet;
943dbef4 8372 u8 fill_rx = 0;
43f66a6c 8373
b095c381
JK		 8374 r = ipw_read32(priv, IPW_RX_READ_INDEX);
8375 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
943dbef4
DW		 8376 i = priv->rxq->read;
8377
8378 if (ipw_rx_queue_space (priv->rxq) > (RX_QUEUE_SIZE / 2))
8379 fill_rx = 1;
43f66a6c
JK		 8380
8381 while (i != r) {
8382 rxb = priv->rxq->queue[i];
43f66a6c
JK		 8383 if (unlikely(rxb == NULL)) {
8384 printk(KERN_CRIT "Queue not allocated!\n");
8385 break;
8386 }
43f66a6c
JK		 8387 priv->rxq->queue[i] = NULL;
8388
8389 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
b095c381 8390 IPW_RX_BUF_SIZE,
43f66a6c
JK		 8391 PCI_DMA_FROMDEVICE);
8392
8393 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8394 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
8395 pkt->header.message_type,
0edd5b44 8396 pkt->header.rx_seq_num, pkt->header.control_bits);
43f66a6c
JK		 8397
8398 switch (pkt->header.message_type) {
0edd5b44 8399 case RX_FRAME_TYPE: /* 802.11 frame */ {
b0a4e7d8 8400 struct libipw_rx_stats stats = {
851ca268 8401 .rssi = pkt->u.frame.rssi_dbm -
0edd5b44 8402 IPW_RSSI_TO_DBM,
c848d0af 8403 .signal =
21f8a73f 8404 pkt->u.frame.rssi_dbm -
b191608a 8405 IPW_RSSI_TO_DBM + 0x100,
c848d0af
JK		 8406 .noise =
8407 le16_to_cpu(pkt->u.frame.noise),
0edd5b44
JG		 8408 .rate = pkt->u.frame.rate,
8409 .mac_time = jiffies,
8410 .received_channel =
8411 pkt->u.frame.received_channel,
8412 .freq =
8413 (pkt->u.frame.
8414 control & (1 << 0)) ?
b0a4e7d8
JL		 8415 LIBIPW_24GHZ_BAND :
8416 LIBIPW_52GHZ_BAND,
a613bffd 8417 .len = le16_to_cpu(pkt->u.frame.length),
0edd5b44
JG		 8418 };
8419
8420 if (stats.rssi != 0)
b0a4e7d8 8421 stats.mask |= LIBIPW_STATMASK_RSSI;
0edd5b44 8422 if (stats.signal != 0)
b0a4e7d8 8423 stats.mask |= LIBIPW_STATMASK_SIGNAL;
c848d0af 8424 if (stats.noise != 0)
b0a4e7d8 8425 stats.mask |= LIBIPW_STATMASK_NOISE;
0edd5b44 8426 if (stats.rate != 0)
b0a4e7d8 8427 stats.mask |= LIBIPW_STATMASK_RATE;
0edd5b44
JG		 8428
8429 priv->rx_packets++;
43f66a6c 8430
d685b8c2
ZY		 8431#ifdef CONFIG_IPW2200_PROMISCUOUS
8432 if (priv->prom_net_dev && netif_running(priv->prom_net_dev))
8433 ipw_handle_promiscuous_rx(priv, rxb, &stats);
8434#endif
8435
b095c381 8436#ifdef CONFIG_IPW2200_MONITOR
0edd5b44 8437 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
459d4087 8438#ifdef CONFIG_IPW2200_RADIOTAP
d685b8c2
ZY		 8439
8440 ipw_handle_data_packet_monitor(priv,
8441 rxb,
8442 &stats);
24a47dbd 8443#else
d685b8c2
ZY		 8444 ipw_handle_data_packet(priv, rxb,
8445 &stats);
24a47dbd 8446#endif
0edd5b44
JG		 8447 break;
8448 }
43f66a6c 8449#endif
bf79451e 8450
0edd5b44 8451 header =
b0a4e7d8 8452 (struct libipw_hdr_4addr *)(rxb->skb->
0dacca1f
JK		 8453 data +
8454 IPW_RX_FRAME_SIZE);
43f66a6c
JK		 8455 /* TODO: Check Ad-Hoc dest/source and make sure
8456 * that we are actually parsing these packets
bf79451e 8457 * correctly -- we should probably use the
43f66a6c
JK		 8458 * frame control of the packet and disregard
8459 * the current iw_mode */
0edd5b44 8460
ea2b26e0
JK		 8461 network_packet =
8462 is_network_packet(priv, header);
0edd5b44
JG		 8463 if (network_packet && priv->assoc_network) {
8464 priv->assoc_network->stats.rssi =
8465 stats.rssi;
00d21de5
ZY		 8466 priv->exp_avg_rssi =
8467 exponential_average(priv->exp_avg_rssi,
8468 stats.rssi, DEPTH_RSSI);
0edd5b44
JG		 8469 }
8470
8471 IPW_DEBUG_RX("Frame: len=%u\n",
a613bffd 8472 le16_to_cpu(pkt->u.frame.length));
0edd5b44 8473
a613bffd 8474 if (le16_to_cpu(pkt->u.frame.length) <
b0a4e7d8 8475 libipw_get_hdrlen(le16_to_cpu(
9d0be03a 8476 header->frame_ctl))) {
0edd5b44
JG		 8477 IPW_DEBUG_DROP
8478 ("Received packet is too small. "
8479 "Dropping.\n");
ce55cbaf 8480 priv->net_dev->stats.rx_errors++;
0edd5b44
JG		 8481 priv->wstats.discard.misc++;
8482 break;
8483 }
8484
a613bffd
JK		 8485 switch (WLAN_FC_GET_TYPE
8486 (le16_to_cpu(header->frame_ctl))) {
b095c381 8487
0edd5b44 8488 case IEEE80211_FTYPE_MGMT:
b095c381
JK		 8489 ipw_handle_mgmt_packet(priv, rxb,
8490 &stats);
0edd5b44
JG		 8491 break;
8492
8493 case IEEE80211_FTYPE_CTL:
8494 break;
8495
8496 case IEEE80211_FTYPE_DATA:
afbf30a2
JK		 8497 if (unlikely(!network_packet ||
8498 is_duplicate_packet(priv,
8499 header)))
8500 {
0edd5b44 8501 IPW_DEBUG_DROP("Dropping: "
e174961c
JB		 8502 "%pM, "
8503 "%pM, "
8504 "%pM\n",
8505 header->addr1,
8506 header->addr2,
8507 header->addr3);
b095c381
JK		 8508 break;
8509 }
8510
8511 ipw_handle_data_packet(priv, rxb,
8512 &stats);
8513
0edd5b44
JG		 8514 break;
8515 }
43f66a6c
JK		 8516 break;
8517 }
bf79451e 8518
0edd5b44
JG		 8519 case RX_HOST_NOTIFICATION_TYPE:{
8520 IPW_DEBUG_RX
8521 ("Notification: subtype=%02X flags=%02X size=%d\n",
43f66a6c
JK		 8522 pkt->u.notification.subtype,
8523 pkt->u.notification.flags,
720eeb43 8524 le16_to_cpu(pkt->u.notification.size));
0edd5b44
JG		 8525 ipw_rx_notification(priv, &pkt->u.notification);
8526 break;
8527 }
43f66a6c
JK		 8528
8529 default:
8530 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8531 pkt->header.message_type);
8532 break;
8533 }
bf79451e
JG		 8534
8535 /* For now we just don't re-use anything. We can tweak this
8536 * later to try and re-use notification packets and SKBs that
43f66a6c
JK		 8537 * fail to Rx correctly */
8538 if (rxb->skb != NULL) {
8539 dev_kfree_skb_any(rxb->skb);
8540 rxb->skb = NULL;
8541 }
bf79451e 8542
43f66a6c 8543 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
b095c381 8544 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 8545 list_add_tail(&rxb->list, &priv->rxq->rx_used);
bf79451e 8546
43f66a6c 8547 i = (i + 1) % RX_QUEUE_SIZE;
943dbef4
DW		 8548
8549 /* If there are a lot of unsued frames, restock the Rx queue
8550 * so the ucode won't assert */
8551 if (fill_rx) {
8552 priv->rxq->read = i;
8553 ipw_rx_queue_replenish(priv);
8554 }
43f66a6c
JK		 8555 }
8556
8557 /* Backtrack one entry */
943dbef4 8558 priv->rxq->read = i;
43f66a6c
JK		 8559 ipw_rx_queue_restock(priv);
8560}
8561
afbf30a2
JK		 8562#define DEFAULT_RTS_THRESHOLD 2304U
8563#define MIN_RTS_THRESHOLD 1U
8564#define MAX_RTS_THRESHOLD 2304U
8565#define DEFAULT_BEACON_INTERVAL 100U
8566#define DEFAULT_SHORT_RETRY_LIMIT 7U
8567#define DEFAULT_LONG_RETRY_LIMIT 4U
8568
d6d5b5c1
ZY		 8569/**
8570 * ipw_sw_reset
8571 * @option: options to control different reset behaviour
8572 * 0 = reset everything except the 'disable' module_param
8573 * 1 = reset everything and print out driver info (for probe only)
8574 * 2 = reset everything
8575 */
8576static int ipw_sw_reset(struct ipw_priv *priv, int option)
43f66a6c 8577{
afbf30a2
JK		 8578 int band, modulation;
8579 int old_mode = priv->ieee->iw_mode;
43f66a6c 8580
afbf30a2
JK		 8581 /* Initialize module parameter values here */
8582 priv->config = 0;
43f66a6c 8583
afbf30a2
JK		 8584 /* We default to disabling the LED code as right now it causes
8585 * too many systems to lock up... */
21f8a73f 8586 if (!led_support)
afbf30a2 8587 priv->config |= CFG_NO_LED;
43f66a6c 8588
afbf30a2
JK		 8589 if (associate)
8590 priv->config |= CFG_ASSOCIATE;
8591 else
8592 IPW_DEBUG_INFO("Auto associate disabled.\n");
bf79451e 8593
afbf30a2
JK		 8594 if (auto_create)
8595 priv->config |= CFG_ADHOC_CREATE;
8596 else
8597 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
43f66a6c 8598
17ed081d
ZY		 8599 priv->config &= ~CFG_STATIC_ESSID;
8600 priv->essid_len = 0;
8601 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8602
d6d5b5c1 8603 if (disable && option) {
afbf30a2
JK		 8604 priv->status |= STATUS_RF_KILL_SW;
8605 IPW_DEBUG_INFO("Radio disabled.\n");
43f66a6c 8606 }
bf79451e 8607
21f8a73f 8608 if (default_channel != 0) {
afbf30a2 8609 priv->config |= CFG_STATIC_CHANNEL;
21f8a73f
RC		 8610 priv->channel = default_channel;
8611 IPW_DEBUG_INFO("Bind to static channel %d\n", default_channel);
afbf30a2 8612 /* TODO: Validate that provided channel is in range */
43f66a6c 8613 }
e43e3c1e 8614#ifdef CONFIG_IPW2200_QOS
afbf30a2
JK		 8615 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8616 burst_duration_CCK, burst_duration_OFDM);
e43e3c1e 8617#endif /* CONFIG_IPW2200_QOS */
43f66a6c 8618
21f8a73f 8619 switch (network_mode) {
afbf30a2
JK		 8620 case 1:
8621 priv->ieee->iw_mode = IW_MODE_ADHOC;
8622 priv->net_dev->type = ARPHRD_ETHER;
8623
8624 break;
8625#ifdef CONFIG_IPW2200_MONITOR
8626 case 2:
8627 priv->ieee->iw_mode = IW_MODE_MONITOR;
459d4087 8628#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 8629 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8630#else
afbf30a2 8631 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8632#endif
afbf30a2
JK		 8633 break;
8634#endif
8635 default:
8636 case 0:
8637 priv->net_dev->type = ARPHRD_ETHER;
8638 priv->ieee->iw_mode = IW_MODE_INFRA;
8639 break;
43f66a6c
JK		 8640 }
8641
afbf30a2
JK		 8642 if (hwcrypto) {
8643 priv->ieee->host_encrypt = 0;
8644 priv->ieee->host_encrypt_msdu = 0;
8645 priv->ieee->host_decrypt = 0;
567deaf6 8646 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 8647 }
8648 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
43f66a6c 8649
e402c937
ZY		 8650 /* IPW2200/2915 is abled to do hardware fragmentation. */
8651 priv->ieee->host_open_frag = 0;
bf79451e 8652
afbf30a2
JK		 8653 if ((priv->pci_dev->device == 0x4223) ||
8654 (priv->pci_dev->device == 0x4224)) {
e8c69e27 8655 if (option == 1)
afbf30a2
JK		 8656 printk(KERN_INFO DRV_NAME
8657 ": Detected Intel PRO/Wireless 2915ABG Network "
8658 "Connection\n");
8659 priv->ieee->abg_true = 1;
b0a4e7d8
JL		 8660 band = LIBIPW_52GHZ_BAND | LIBIPW_24GHZ_BAND;
8661 modulation = LIBIPW_OFDM_MODULATION |
8662 LIBIPW_CCK_MODULATION;
afbf30a2
JK		 8663 priv->adapter = IPW_2915ABG;
8664 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
43f66a6c 8665 } else {
e8c69e27 8666 if (option == 1)
afbf30a2
JK		 8667 printk(KERN_INFO DRV_NAME
8668 ": Detected Intel PRO/Wireless 2200BG Network "
8669 "Connection\n");
bf79451e 8670
afbf30a2 8671 priv->ieee->abg_true = 0;
b0a4e7d8
JL		 8672 band = LIBIPW_24GHZ_BAND;
8673 modulation = LIBIPW_OFDM_MODULATION |
8674 LIBIPW_CCK_MODULATION;
afbf30a2
JK		 8675 priv->adapter = IPW_2200BG;
8676 priv->ieee->mode = IEEE_G | IEEE_B;
43f66a6c
JK		 8677 }
8678
afbf30a2
JK		 8679 priv->ieee->freq_band = band;
8680 priv->ieee->modulation = modulation;
43f66a6c 8681
b0a4e7d8 8682 priv->rates_mask = LIBIPW_DEFAULT_RATES_MASK;
bf79451e 8683
afbf30a2
JK		 8684 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8685 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
43f66a6c 8686
afbf30a2
JK		 8687 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8688 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8689 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
43f66a6c 8690
afbf30a2
JK		 8691 /* If power management is turned on, default to AC mode */
8692 priv->power_mode = IPW_POWER_AC;
8693 priv->tx_power = IPW_TX_POWER_DEFAULT;
8694
0ece35b5 8695 return old_mode == priv->ieee->iw_mode;
43f66a6c
JK		 8696}
8697
8698/*
8699 * This file defines the Wireless Extension handlers. It does not
8700 * define any methods of hardware manipulation and relies on the
8701 * functions defined in ipw_main to provide the HW interaction.
bf79451e
JG		 8702 *
8703 * The exception to this is the use of the ipw_get_ordinal()
43f66a6c
JK		 8704 * function used to poll the hardware vs. making unecessary calls.
8705 *
8706 */
8707
43f66a6c
JK		 8708static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8709{
8710 if (channel == 0) {
8711 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8712 priv->config &= ~CFG_STATIC_CHANNEL;
c848d0af
JK		 8713 IPW_DEBUG_ASSOC("Attempting to associate with new "
8714 "parameters.\n");
8715 ipw_associate(priv);
43f66a6c
JK		 8716 return 0;
8717 }
8718
8719 priv->config |= CFG_STATIC_CHANNEL;
8720
8721 if (priv->channel == channel) {
0edd5b44
JG		 8722 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8723 channel);
43f66a6c
JK		 8724 return 0;
8725 }
8726
8727 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8728 priv->channel = channel;
8729
b095c381
JK		 8730#ifdef CONFIG_IPW2200_MONITOR
8731 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 8732 int i;
b095c381 8733 if (priv->status & STATUS_SCANNING) {
afbf30a2 8734 IPW_DEBUG_SCAN("Scan abort triggered due to "
b095c381 8735 "channel change.\n");
afbf30a2 8736 ipw_abort_scan(priv);
b095c381
JK		 8737 }
8738
8739 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8740 udelay(10);
8741
8742 if (priv->status & STATUS_SCANNING)
8743 IPW_DEBUG_SCAN("Still scanning...\n");
8744 else
8745 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8746 1000 - i);
8747
8748 return 0;
43f66a6c 8749 }
b095c381
JK		 8750#endif /* CONFIG_IPW2200_MONITOR */
8751
c848d0af
JK		 8752 /* Network configuration changed -- force [re]association */
8753 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8754 if (!ipw_disassociate(priv))
43f66a6c 8755 ipw_associate(priv);
43f66a6c
JK		 8756
8757 return 0;
8758}
8759
bf79451e
JG		 8760static int ipw_wx_set_freq(struct net_device *dev,
8761 struct iw_request_info *info,
8762 union iwreq_data *wrqu, char *extra)
43f66a6c 8763{
b0a4e7d8
JL		 8764 struct ipw_priv *priv = libipw_priv(dev);
8765 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
43f66a6c 8766 struct iw_freq *fwrq = &wrqu->freq;
afbf30a2 8767 int ret = 0, i;
1fe0adb4
LH		 8768 u8 channel, flags;
8769 int band;
b095c381
JK		 8770
8771 if (fwrq->m == 0) {
8772 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
4644151b 8773 mutex_lock(&priv->mutex);
b095c381 8774 ret = ipw_set_channel(priv, 0);
4644151b 8775 mutex_unlock(&priv->mutex);
b095c381
JK		 8776 return ret;
8777 }
43f66a6c
JK		 8778 /* if setting by freq convert to channel */
8779 if (fwrq->e == 1) {
b0a4e7d8 8780 channel = libipw_freq_to_channel(priv->ieee, fwrq->m);
b095c381
JK		 8781 if (channel == 0)
8782 return -EINVAL;
8783 } else
8784 channel = fwrq->m;
bf79451e 8785
b0a4e7d8 8786 if (!(band = libipw_is_valid_channel(priv->ieee, channel)))
b095c381 8787 return -EINVAL;
43f66a6c 8788
1fe0adb4 8789 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
b0a4e7d8 8790 i = libipw_channel_to_index(priv->ieee, channel);
afbf30a2
JK		 8791 if (i == -1)
8792 return -EINVAL;
bf79451e 8793
b0a4e7d8 8794 flags = (band == LIBIPW_24GHZ_BAND) ?
1fe0adb4 8795 geo->bg[i].flags : geo->a[i].flags;
b0a4e7d8 8796 if (flags & LIBIPW_CH_PASSIVE_ONLY) {
afbf30a2
JK		 8797 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8798 return -EINVAL;
43f66a6c
JK		 8799 }
8800 }
bf79451e 8801
9fd1ea42 8802 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
4644151b 8803 mutex_lock(&priv->mutex);
b095c381 8804 ret = ipw_set_channel(priv, channel);
4644151b 8805 mutex_unlock(&priv->mutex);
c848d0af 8806 return ret;
43f66a6c
JK		 8807}
8808
bf79451e
JG		 8809static int ipw_wx_get_freq(struct net_device *dev,
8810 struct iw_request_info *info,
43f66a6c
JK		 8811 union iwreq_data *wrqu, char *extra)
8812{
b0a4e7d8 8813 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 8814
8815 wrqu->freq.e = 0;
8816
8817 /* If we are associated, trying to associate, or have a statically
8818 * configured CHANNEL then return that; otherwise return ANY */
4644151b 8819 mutex_lock(&priv->mutex);
43f66a6c 8820 if (priv->config & CFG_STATIC_CHANNEL ||
c580f67f
ZY		 8821 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) {
8822 int i;
8823
b0a4e7d8 8824 i = libipw_channel_to_index(priv->ieee, priv->channel);
c580f67f
ZY		 8825 BUG_ON(i == -1);
8826 wrqu->freq.e = 1;
8827
b0a4e7d8
JL		 8828 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
8829 case LIBIPW_52GHZ_BAND:
c580f67f
ZY		 8830 wrqu->freq.m = priv->ieee->geo.a[i].freq * 100000;
8831 break;
8832
b0a4e7d8 8833 case LIBIPW_24GHZ_BAND:
c580f67f
ZY		 8834 wrqu->freq.m = priv->ieee->geo.bg[i].freq * 100000;
8835 break;
8836
8837 default:
8838 BUG();
8839 }
8840 } else
43f66a6c
JK		 8841 wrqu->freq.m = 0;
8842
4644151b 8843 mutex_unlock(&priv->mutex);
9fd1ea42 8844 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
43f66a6c
JK		 8845 return 0;
8846}
8847
bf79451e
JG		 8848static int ipw_wx_set_mode(struct net_device *dev,
8849 struct iw_request_info *info,
43f66a6c
JK		 8850 union iwreq_data *wrqu, char *extra)
8851{
b0a4e7d8 8852 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 8853 int err = 0;
8854
8855 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8856
43f66a6c 8857 switch (wrqu->mode) {
b095c381 8858#ifdef CONFIG_IPW2200_MONITOR
43f66a6c
JK		 8859 case IW_MODE_MONITOR:
8860#endif
8861 case IW_MODE_ADHOC:
8862 case IW_MODE_INFRA:
8863 break;
8864 case IW_MODE_AUTO:
8865 wrqu->mode = IW_MODE_INFRA;
8866 break;
8867 default:
8868 return -EINVAL;
8869 }
b095c381
JK		 8870 if (wrqu->mode == priv->ieee->iw_mode)
8871 return 0;
43f66a6c 8872
4644151b 8873 mutex_lock(&priv->mutex);
43f66a6c 8874
afbf30a2
JK		 8875 ipw_sw_reset(priv, 0);
8876
b095c381 8877#ifdef CONFIG_IPW2200_MONITOR
bf79451e 8878 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
43f66a6c 8879 priv->net_dev->type = ARPHRD_ETHER;
bf79451e
JG		 8880
8881 if (wrqu->mode == IW_MODE_MONITOR)
459d4087 8882#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 8883 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8884#else
43f66a6c 8885 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8886#endif
b095c381 8887#endif /* CONFIG_IPW2200_MONITOR */
bf79451e 8888
bf79451e 8889 /* Free the existing firmware and reset the fw_loaded
877d0310 8890 * flag so ipw_load() will bring in the new firmware */
afbf30a2 8891 free_firmware();
43f66a6c
JK		 8892
8893 priv->ieee->iw_mode = wrqu->mode;
bf79451e 8894
c848d0af 8895 queue_work(priv->workqueue, &priv->adapter_restart);
4644151b 8896 mutex_unlock(&priv->mutex);
0edd5b44 8897 return err;
43f66a6c
JK		 8898}
8899
bf79451e 8900static int ipw_wx_get_mode(struct net_device *dev,
0edd5b44
JG		 8901 struct iw_request_info *info,
8902 union iwreq_data *wrqu, char *extra)
43f66a6c 8903{
b0a4e7d8 8904 struct ipw_priv *priv = libipw_priv(dev);
4644151b 8905 mutex_lock(&priv->mutex);
43f66a6c
JK		 8906 wrqu->mode = priv->ieee->iw_mode;
8907 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
4644151b 8908 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8909 return 0;
8910}
8911
43f66a6c
JK		 8912/* Values are in microsecond */
8913static const s32 timeout_duration[] = {
8914 350000,
8915 250000,
8916 75000,
8917 37000,
8918 25000,
8919};
8920
8921static const s32 period_duration[] = {
8922 400000,
8923 700000,
8924 1000000,
8925 1000000,
8926 1000000
8927};
8928
bf79451e
JG		 8929static int ipw_wx_get_range(struct net_device *dev,
8930 struct iw_request_info *info,
43f66a6c
JK		 8931 union iwreq_data *wrqu, char *extra)
8932{
b0a4e7d8 8933 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 8934 struct iw_range *range = (struct iw_range *)extra;
b0a4e7d8 8935 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
b095c381 8936 int i = 0, j;
43f66a6c
JK		 8937
8938 wrqu->data.length = sizeof(*range);
8939 memset(range, 0, sizeof(*range));
8940
8941 /* 54Mbs == ~27 Mb/s real (802.11g) */
bf79451e 8942 range->throughput = 27 * 1000 * 1000;
43f66a6c
JK		 8943
8944 range->max_qual.qual = 100;
8945 /* TODO: Find real max RSSI and stick here */
8946 range->max_qual.level = 0;
b191608a 8947 range->max_qual.noise = 0;
0edd5b44 8948 range->max_qual.updated = 7; /* Updated all three */
43f66a6c
JK		 8949
8950 range->avg_qual.qual = 70;
af901ca1 8951 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
0edd5b44 8952 range->avg_qual.level = 0; /* FIXME to real average level */
43f66a6c 8953 range->avg_qual.noise = 0;
0edd5b44 8954 range->avg_qual.updated = 7; /* Updated all three */
4644151b 8955 mutex_lock(&priv->mutex);
0edd5b44 8956 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
43f66a6c 8957
bf79451e
JG		 8958 for (i = 0; i < range->num_bitrates; i++)
8959 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
0edd5b44 8960 500000;
bf79451e 8961
43f66a6c
JK		 8962 range->max_rts = DEFAULT_RTS_THRESHOLD;
8963 range->min_frag = MIN_FRAG_THRESHOLD;
8964 range->max_frag = MAX_FRAG_THRESHOLD;
8965
8966 range->encoding_size[0] = 5;
bf79451e 8967 range->encoding_size[1] = 13;
43f66a6c
JK		 8968 range->num_encoding_sizes = 2;
8969 range->max_encoding_tokens = WEP_KEYS;
8970
8971 /* Set the Wireless Extension versions */
8972 range->we_version_compiled = WIRELESS_EXT;
f1b50863 8973 range->we_version_source = 18;
43f66a6c 8974
b095c381
JK		 8975 i = 0;
8976 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
e815de42
ZY		 8977 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8978 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
b0a4e7d8 8979 (geo->bg[j].flags & LIBIPW_CH_PASSIVE_ONLY))
e815de42
ZY		 8980 continue;
8981
b095c381
JK		 8982 range->freq[i].i = geo->bg[j].channel;
8983 range->freq[i].m = geo->bg[j].freq * 100000;
8984 range->freq[i].e = 1;
e815de42 8985 i++;
b095c381
JK		 8986 }
8987 }
43f66a6c 8988
b095c381 8989 if (priv->ieee->mode & IEEE_A) {
e815de42
ZY		 8990 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8991 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
b0a4e7d8 8992 (geo->a[j].flags & LIBIPW_CH_PASSIVE_ONLY))
e815de42
ZY		 8993 continue;
8994
b095c381
JK		 8995 range->freq[i].i = geo->a[j].channel;
8996 range->freq[i].m = geo->a[j].freq * 100000;
8997 range->freq[i].e = 1;
e815de42 8998 i++;
b095c381 8999 }
43f66a6c 9000 }
b095c381
JK		 9001
9002 range->num_channels = i;
9003 range->num_frequency = i;
9004
4644151b 9005 mutex_unlock(&priv->mutex);
97a78ca9
BB		 9006
9007 /* Event capability (kernel + driver) */
9008 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
9009 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
07f02e46
ZY		 9010 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
9011 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
97a78ca9 9012 range->event_capa[1] = IW_EVENT_CAPA_K_1;
43f66a6c 9013
f1b50863
DW		 9014 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
9015 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
9016
374fdfbc
DW		 9017 range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
9018
43f66a6c
JK		 9019 IPW_DEBUG_WX("GET Range\n");
9020 return 0;
9021}
9022
bf79451e
JG		 9023static int ipw_wx_set_wap(struct net_device *dev,
9024 struct iw_request_info *info,
43f66a6c
JK		 9025 union iwreq_data *wrqu, char *extra)
9026{
b0a4e7d8 9027 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9028
9029 static const unsigned char any[] = {
9030 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
9031 };
9032 static const unsigned char off[] = {
9033 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
9034 };
9035
bf79451e 9036 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
43f66a6c 9037 return -EINVAL;
4644151b 9038 mutex_lock(&priv->mutex);
43f66a6c
JK		 9039 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
9040 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
9041 /* we disable mandatory BSSID association */
9042 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
9043 priv->config &= ~CFG_STATIC_BSSID;
c848d0af
JK		 9044 IPW_DEBUG_ASSOC("Attempting to associate with new "
9045 "parameters.\n");
9046 ipw_associate(priv);
4644151b 9047 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9048 return 0;
9049 }
9050
9051 priv->config |= CFG_STATIC_BSSID;
9052 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
9053 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
4644151b 9054 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9055 return 0;
9056 }
9057
e174961c
JB		 9058 IPW_DEBUG_WX("Setting mandatory BSSID to %pM\n",
9059 wrqu->ap_addr.sa_data);
43f66a6c
JK		 9060
9061 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
9062
c848d0af
JK		 9063 /* Network configuration changed -- force [re]association */
9064 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
9065 if (!ipw_disassociate(priv))
43f66a6c 9066 ipw_associate(priv);
43f66a6c 9067
4644151b 9068 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9069 return 0;
9070}
9071
bf79451e
JG		 9072static int ipw_wx_get_wap(struct net_device *dev,
9073 struct iw_request_info *info,
43f66a6c
JK		 9074 union iwreq_data *wrqu, char *extra)
9075{
b0a4e7d8 9076 struct ipw_priv *priv = libipw_priv(dev);
0795af57 9077
43f66a6c
JK		 9078 /* If we are associated, trying to associate, or have a statically
9079 * configured BSSID then return that; otherwise return ANY */
4644151b 9080 mutex_lock(&priv->mutex);
bf79451e 9081 if (priv->config & CFG_STATIC_BSSID ||
43f66a6c
JK		 9082 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9083 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
afbf30a2 9084 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
43f66a6c
JK		 9085 } else
9086 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
9087
e174961c
JB		 9088 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n",
9089 wrqu->ap_addr.sa_data);
4644151b 9090 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9091 return 0;
9092}
9093
bf79451e
JG		 9094static int ipw_wx_set_essid(struct net_device *dev,
9095 struct iw_request_info *info,
43f66a6c
JK		 9096 union iwreq_data *wrqu, char *extra)
9097{
b0a4e7d8 9098 struct ipw_priv *priv = libipw_priv(dev);
ab644b0b 9099 int length;
9387b7ca 9100 DECLARE_SSID_BUF(ssid);
ab644b0b
ZY		 9101
9102 mutex_lock(&priv->mutex);
43f66a6c 9103
ab644b0b
ZY		 9104 if (!wrqu->essid.flags)
9105 {
9106 IPW_DEBUG_WX("Setting ESSID to ANY\n");
9107 ipw_disassociate(priv);
9108 priv->config &= ~CFG_STATIC_ESSID;
9109 ipw_associate(priv);
9110 mutex_unlock(&priv->mutex);
9111 return 0;
9112 }
43f66a6c 9113
a9f0d423 9114 length = min((int)wrqu->essid.length, IW_ESSID_MAX_SIZE);
43f66a6c
JK		 9115
9116 priv->config |= CFG_STATIC_ESSID;
9117
a9f0d423
ZY		 9118 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)
9119 && (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) {
43f66a6c 9120 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
4644151b 9121 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9122 return 0;
9123 }
9124
9387b7ca
JL		 9125 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n",
9126 print_ssid(ssid, extra, length), length);
43f66a6c
JK		 9127
9128 priv->essid_len = length;
a9f0d423 9129 memcpy(priv->essid, extra, priv->essid_len);
bf79451e 9130
c848d0af
JK		 9131 /* Network configuration changed -- force [re]association */
9132 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
9133 if (!ipw_disassociate(priv))
43f66a6c 9134 ipw_associate(priv);
43f66a6c 9135
4644151b 9136 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9137 return 0;
9138}
9139
bf79451e
JG		 9140static int ipw_wx_get_essid(struct net_device *dev,
9141 struct iw_request_info *info,
43f66a6c
JK		 9142 union iwreq_data *wrqu, char *extra)
9143{
b0a4e7d8 9144 struct ipw_priv *priv = libipw_priv(dev);
9387b7ca 9145 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 9146
9147 /* If we are associated, trying to associate, or have a statically
9148 * configured ESSID then return that; otherwise return ANY */
4644151b 9149 mutex_lock(&priv->mutex);
43f66a6c 9150 if (priv->config & CFG_STATIC_ESSID ||
bf79451e
JG		 9151 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9152 IPW_DEBUG_WX("Getting essid: '%s'\n",
9387b7ca 9153 print_ssid(ssid, priv->essid, priv->essid_len));
bf79451e 9154 memcpy(extra, priv->essid, priv->essid_len);
43f66a6c 9155 wrqu->essid.length = priv->essid_len;
0edd5b44 9156 wrqu->essid.flags = 1; /* active */
43f66a6c
JK		 9157 } else {
9158 IPW_DEBUG_WX("Getting essid: ANY\n");
9159 wrqu->essid.length = 0;
0edd5b44 9160 wrqu->essid.flags = 0; /* active */
43f66a6c 9161 }
4644151b 9162 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9163 return 0;
9164}
9165
bf79451e
JG		 9166static int ipw_wx_set_nick(struct net_device *dev,
9167 struct iw_request_info *info,
43f66a6c 9168 union iwreq_data *wrqu, char *extra)
bf79451e 9169{
b0a4e7d8 9170 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9171
9172 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
9173 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9174 return -E2BIG;
4644151b 9175 mutex_lock(&priv->mutex);
0edd5b44 9176 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
43f66a6c 9177 memset(priv->nick, 0, sizeof(priv->nick));
0edd5b44 9178 memcpy(priv->nick, extra, wrqu->data.length);
43f66a6c 9179 IPW_DEBUG_TRACE("<<\n");
4644151b 9180 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9181 return 0;
9182
9183}
9184
bf79451e
JG		 9185static int ipw_wx_get_nick(struct net_device *dev,
9186 struct iw_request_info *info,
43f66a6c 9187 union iwreq_data *wrqu, char *extra)
bf79451e 9188{
b0a4e7d8 9189 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9190 IPW_DEBUG_WX("Getting nick\n");
4644151b 9191 mutex_lock(&priv->mutex);
919ee6dd 9192 wrqu->data.length = strlen(priv->nick);
43f66a6c 9193 memcpy(extra, priv->nick, wrqu->data.length);
0edd5b44 9194 wrqu->data.flags = 1; /* active */
4644151b 9195 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9196 return 0;
9197}
9198
651be26f
OH		 9199static int ipw_wx_set_sens(struct net_device *dev,
9200 struct iw_request_info *info,
9201 union iwreq_data *wrqu, char *extra)
9202{
b0a4e7d8 9203 struct ipw_priv *priv = libipw_priv(dev);
651be26f
OH		 9204 int err = 0;
9205
9206 IPW_DEBUG_WX("Setting roaming threshold to %d\n", wrqu->sens.value);
9207 IPW_DEBUG_WX("Setting disassociate threshold to %d\n", 3*wrqu->sens.value);
9208 mutex_lock(&priv->mutex);
9209
9210 if (wrqu->sens.fixed == 0)
9211 {
9212 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
9213 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
9214 goto out;
9215 }
9216 if ((wrqu->sens.value > IPW_MB_ROAMING_THRESHOLD_MAX) ||
9217 (wrqu->sens.value < IPW_MB_ROAMING_THRESHOLD_MIN)) {
9218 err = -EINVAL;
9219 goto out;
9220 }
9221
9222 priv->roaming_threshold = wrqu->sens.value;
9223 priv->disassociate_threshold = 3*wrqu->sens.value;
9224 out:
9225 mutex_unlock(&priv->mutex);
9226 return err;
9227}
9228
9229static int ipw_wx_get_sens(struct net_device *dev,
9230 struct iw_request_info *info,
9231 union iwreq_data *wrqu, char *extra)
9232{
b0a4e7d8 9233 struct ipw_priv *priv = libipw_priv(dev);
651be26f
OH		 9234 mutex_lock(&priv->mutex);
9235 wrqu->sens.fixed = 1;
9236 wrqu->sens.value = priv->roaming_threshold;
9237 mutex_unlock(&priv->mutex);
9238
9fd1ea42 9239 IPW_DEBUG_WX("GET roaming threshold -> %s %d\n",
651be26f
OH		 9240 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9241
9242 return 0;
9243}
9244
43f66a6c
JK		 9245static int ipw_wx_set_rate(struct net_device *dev,
9246 struct iw_request_info *info,
9247 union iwreq_data *wrqu, char *extra)
bf79451e 9248{
ea2b26e0 9249 /* TODO: We should use semaphores or locks for access to priv */
b0a4e7d8 9250 struct ipw_priv *priv = libipw_priv(dev);
ea2b26e0
JK		 9251 u32 target_rate = wrqu->bitrate.value;
9252 u32 fixed, mask;
9253
9254 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
9255 /* value = X, fixed = 1 means only rate X */
9256 /* value = X, fixed = 0 means all rates lower equal X */
9257
9258 if (target_rate == -1) {
9259 fixed = 0;
b0a4e7d8 9260 mask = LIBIPW_DEFAULT_RATES_MASK;
ea2b26e0
JK		 9261 /* Now we should reassociate */
9262 goto apply;
9263 }
9264
9265 mask = 0;
9266 fixed = wrqu->bitrate.fixed;
9267
9268 if (target_rate == 1000000 || !fixed)
b0a4e7d8 9269 mask |= LIBIPW_CCK_RATE_1MB_MASK;
ea2b26e0
JK		 9270 if (target_rate == 1000000)
9271 goto apply;
9272
9273 if (target_rate == 2000000 || !fixed)
b0a4e7d8 9274 mask |= LIBIPW_CCK_RATE_2MB_MASK;
ea2b26e0
JK		 9275 if (target_rate == 2000000)
9276 goto apply;
9277
9278 if (target_rate == 5500000 || !fixed)
b0a4e7d8 9279 mask |= LIBIPW_CCK_RATE_5MB_MASK;
ea2b26e0
JK		 9280 if (target_rate == 5500000)
9281 goto apply;
9282
9283 if (target_rate == 6000000 || !fixed)
b0a4e7d8 9284 mask |= LIBIPW_OFDM_RATE_6MB_MASK;
ea2b26e0
JK		 9285 if (target_rate == 6000000)
9286 goto apply;
9287
9288 if (target_rate == 9000000 || !fixed)
b0a4e7d8 9289 mask |= LIBIPW_OFDM_RATE_9MB_MASK;
ea2b26e0
JK		 9290 if (target_rate == 9000000)
9291 goto apply;
9292
9293 if (target_rate == 11000000 || !fixed)
b0a4e7d8 9294 mask |= LIBIPW_CCK_RATE_11MB_MASK;
ea2b26e0
JK		 9295 if (target_rate == 11000000)
9296 goto apply;
9297
9298 if (target_rate == 12000000 || !fixed)
b0a4e7d8 9299 mask |= LIBIPW_OFDM_RATE_12MB_MASK;
ea2b26e0
JK		 9300 if (target_rate == 12000000)
9301 goto apply;
9302
9303 if (target_rate == 18000000 || !fixed)
b0a4e7d8 9304 mask |= LIBIPW_OFDM_RATE_18MB_MASK;
ea2b26e0
JK		 9305 if (target_rate == 18000000)
9306 goto apply;
9307
9308 if (target_rate == 24000000 || !fixed)
b0a4e7d8 9309 mask |= LIBIPW_OFDM_RATE_24MB_MASK;
ea2b26e0
JK		 9310 if (target_rate == 24000000)
9311 goto apply;
9312
9313 if (target_rate == 36000000 || !fixed)
b0a4e7d8 9314 mask |= LIBIPW_OFDM_RATE_36MB_MASK;
ea2b26e0
JK		 9315 if (target_rate == 36000000)
9316 goto apply;
9317
9318 if (target_rate == 48000000 || !fixed)
b0a4e7d8 9319 mask |= LIBIPW_OFDM_RATE_48MB_MASK;
ea2b26e0
JK		 9320 if (target_rate == 48000000)
9321 goto apply;
9322
9323 if (target_rate == 54000000 || !fixed)
b0a4e7d8 9324 mask |= LIBIPW_OFDM_RATE_54MB_MASK;
ea2b26e0
JK		 9325 if (target_rate == 54000000)
9326 goto apply;
9327
9328 IPW_DEBUG_WX("invalid rate specified, returning error\n");
9329 return -EINVAL;
9330
9331 apply:
9332 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
9333 mask, fixed ? "fixed" : "sub-rates");
4644151b 9334 mutex_lock(&priv->mutex);
b0a4e7d8 9335 if (mask == LIBIPW_DEFAULT_RATES_MASK) {
ea2b26e0 9336 priv->config &= ~CFG_FIXED_RATE;
b095c381
JK		 9337 ipw_set_fixed_rate(priv, priv->ieee->mode);
9338 } else
ea2b26e0
JK		 9339 priv->config |= CFG_FIXED_RATE;
9340
c848d0af
JK		 9341 if (priv->rates_mask == mask) {
9342 IPW_DEBUG_WX("Mask set to current mask.\n");
4644151b 9343 mutex_unlock(&priv->mutex);
c848d0af 9344 return 0;
ea2b26e0
JK		 9345 }
9346
c848d0af
JK		 9347 priv->rates_mask = mask;
9348
9349 /* Network configuration changed -- force [re]association */
9350 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
9351 if (!ipw_disassociate(priv))
9352 ipw_associate(priv);
9353
4644151b 9354 mutex_unlock(&priv->mutex);
ea2b26e0 9355 return 0;
43f66a6c
JK		 9356}
9357
bf79451e
JG		 9358static int ipw_wx_get_rate(struct net_device *dev,
9359 struct iw_request_info *info,
43f66a6c 9360 union iwreq_data *wrqu, char *extra)
bf79451e 9361{
b0a4e7d8 9362 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9363 mutex_lock(&priv->mutex);
43f66a6c 9364 wrqu->bitrate.value = priv->last_rate;
455936c7 9365 wrqu->bitrate.fixed = (priv->config & CFG_FIXED_RATE) ? 1 : 0;
4644151b 9366 mutex_unlock(&priv->mutex);
9fd1ea42 9367 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
43f66a6c
JK		 9368 return 0;
9369}
9370
bf79451e
JG		 9371static int ipw_wx_set_rts(struct net_device *dev,
9372 struct iw_request_info *info,
43f66a6c 9373 union iwreq_data *wrqu, char *extra)
bf79451e 9374{
b0a4e7d8 9375 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9376 mutex_lock(&priv->mutex);
ea8862dc 9377 if (wrqu->rts.disabled || !wrqu->rts.fixed)
43f66a6c
JK		 9378 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9379 else {
9380 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
c848d0af 9381 wrqu->rts.value > MAX_RTS_THRESHOLD) {
4644151b 9382 mutex_unlock(&priv->mutex);
43f66a6c 9383 return -EINVAL;
c848d0af 9384 }
43f66a6c
JK		 9385 priv->rts_threshold = wrqu->rts.value;
9386 }
9387
9388 ipw_send_rts_threshold(priv, priv->rts_threshold);
4644151b 9389 mutex_unlock(&priv->mutex);
9fd1ea42 9390 IPW_DEBUG_WX("SET RTS Threshold -> %d\n", priv->rts_threshold);
43f66a6c
JK		 9391 return 0;
9392}
9393
bf79451e
JG		 9394static int ipw_wx_get_rts(struct net_device *dev,
9395 struct iw_request_info *info,
43f66a6c 9396 union iwreq_data *wrqu, char *extra)
bf79451e 9397{
b0a4e7d8 9398 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9399 mutex_lock(&priv->mutex);
43f66a6c
JK		 9400 wrqu->rts.value = priv->rts_threshold;
9401 wrqu->rts.fixed = 0; /* no auto select */
0edd5b44 9402 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
4644151b 9403 mutex_unlock(&priv->mutex);
9fd1ea42 9404 IPW_DEBUG_WX("GET RTS Threshold -> %d\n", wrqu->rts.value);
43f66a6c
JK		 9405 return 0;
9406}
9407
bf79451e
JG		 9408static int ipw_wx_set_txpow(struct net_device *dev,
9409 struct iw_request_info *info,
43f66a6c 9410 union iwreq_data *wrqu, char *extra)
bf79451e 9411{
b0a4e7d8 9412 struct ipw_priv *priv = libipw_priv(dev);
6de9f7f2 9413 int err = 0;
43f66a6c 9414
4644151b 9415 mutex_lock(&priv->mutex);
c848d0af 9416 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
6de9f7f2
ZY		 9417 err = -EINPROGRESS;
9418 goto out;
43f66a6c 9419 }
43f66a6c 9420
b095c381
JK		 9421 if (!wrqu->power.fixed)
9422 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9423
c848d0af 9424 if (wrqu->power.flags != IW_TXPOW_DBM) {
6de9f7f2
ZY		 9425 err = -EINVAL;
9426 goto out;
c848d0af 9427 }
43f66a6c 9428
b095c381 9429 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
afbf30a2 9430 (wrqu->power.value < IPW_TX_POWER_MIN)) {
6de9f7f2
ZY		 9431 err = -EINVAL;
9432 goto out;
c848d0af 9433 }
43f66a6c 9434
43f66a6c 9435 priv->tx_power = wrqu->power.value;
6de9f7f2
ZY		 9436 err = ipw_set_tx_power(priv);
9437 out:
4644151b 9438 mutex_unlock(&priv->mutex);
6de9f7f2 9439 return err;
43f66a6c
JK		 9440}
9441
bf79451e
JG		 9442static int ipw_wx_get_txpow(struct net_device *dev,
9443 struct iw_request_info *info,
43f66a6c 9444 union iwreq_data *wrqu, char *extra)
bf79451e 9445{
b0a4e7d8 9446 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9447 mutex_lock(&priv->mutex);
43f66a6c
JK		 9448 wrqu->power.value = priv->tx_power;
9449 wrqu->power.fixed = 1;
9450 wrqu->power.flags = IW_TXPOW_DBM;
9451 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
4644151b 9452 mutex_unlock(&priv->mutex);
43f66a6c 9453
9fd1ea42 9454 IPW_DEBUG_WX("GET TX Power -> %s %d\n",
22501c8e 9455 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
43f66a6c
JK		 9456
9457 return 0;
9458}
9459
bf79451e 9460static int ipw_wx_set_frag(struct net_device *dev,
0edd5b44
JG		 9461 struct iw_request_info *info,
9462 union iwreq_data *wrqu, char *extra)
43f66a6c 9463{
b0a4e7d8 9464 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9465 mutex_lock(&priv->mutex);
ea8862dc 9466 if (wrqu->frag.disabled || !wrqu->frag.fixed)
43f66a6c
JK		 9467 priv->ieee->fts = DEFAULT_FTS;
9468 else {
9469 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
b095c381 9470 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
4644151b 9471 mutex_unlock(&priv->mutex);
43f66a6c 9472 return -EINVAL;
b095c381 9473 }
bf79451e 9474
43f66a6c
JK		 9475 priv->ieee->fts = wrqu->frag.value & ~0x1;
9476 }
9477
9478 ipw_send_frag_threshold(priv, wrqu->frag.value);
4644151b 9479 mutex_unlock(&priv->mutex);
9fd1ea42 9480 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", wrqu->frag.value);
43f66a6c
JK		 9481 return 0;
9482}
9483
bf79451e 9484static int ipw_wx_get_frag(struct net_device *dev,
0edd5b44
JG		 9485 struct iw_request_info *info,
9486 union iwreq_data *wrqu, char *extra)
43f66a6c 9487{
b0a4e7d8 9488 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9489 mutex_lock(&priv->mutex);
43f66a6c
JK		 9490 wrqu->frag.value = priv->ieee->fts;
9491 wrqu->frag.fixed = 0; /* no auto select */
0edd5b44 9492 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
4644151b 9493 mutex_unlock(&priv->mutex);
9fd1ea42 9494 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
43f66a6c
JK		 9495
9496 return 0;
9497}
9498
bf79451e
JG		 9499static int ipw_wx_set_retry(struct net_device *dev,
9500 struct iw_request_info *info,
43f66a6c 9501 union iwreq_data *wrqu, char *extra)
bf79451e 9502{
b0a4e7d8 9503 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2
JK		 9504
9505 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9506 return -EINVAL;
9507
9508 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9509 return 0;
9510
d5f7ac20 9511 if (wrqu->retry.value < 0 || wrqu->retry.value >= 255)
afbf30a2
JK		 9512 return -EINVAL;
9513
4644151b 9514 mutex_lock(&priv->mutex);
919ee6dd 9515 if (wrqu->retry.flags & IW_RETRY_SHORT)
afbf30a2 9516 priv->short_retry_limit = (u8) wrqu->retry.value;
919ee6dd 9517 else if (wrqu->retry.flags & IW_RETRY_LONG)
afbf30a2
JK		 9518 priv->long_retry_limit = (u8) wrqu->retry.value;
9519 else {
9520 priv->short_retry_limit = (u8) wrqu->retry.value;
9521 priv->long_retry_limit = (u8) wrqu->retry.value;
9522 }
9523
9524 ipw_send_retry_limit(priv, priv->short_retry_limit,
9525 priv->long_retry_limit);
4644151b 9526 mutex_unlock(&priv->mutex);
afbf30a2
JK		 9527 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9528 priv->short_retry_limit, priv->long_retry_limit);
9529 return 0;
43f66a6c
JK		 9530}
9531
bf79451e
JG		 9532static int ipw_wx_get_retry(struct net_device *dev,
9533 struct iw_request_info *info,
43f66a6c 9534 union iwreq_data *wrqu, char *extra)
bf79451e 9535{
b0a4e7d8 9536 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 9537
4644151b 9538 mutex_lock(&priv->mutex);
afbf30a2
JK		 9539 wrqu->retry.disabled = 0;
9540
9541 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
4644151b 9542 mutex_unlock(&priv->mutex);
afbf30a2
JK		 9543 return -EINVAL;
9544 }
9545
919ee6dd
JT		 9546 if (wrqu->retry.flags & IW_RETRY_LONG) {
9547 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
afbf30a2 9548 wrqu->retry.value = priv->long_retry_limit;
919ee6dd
JT		 9549 } else if (wrqu->retry.flags & IW_RETRY_SHORT) {
9550 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
afbf30a2
JK		 9551 wrqu->retry.value = priv->short_retry_limit;
9552 } else {
9553 wrqu->retry.flags = IW_RETRY_LIMIT;
9554 wrqu->retry.value = priv->short_retry_limit;
9555 }
4644151b 9556 mutex_unlock(&priv->mutex);
afbf30a2 9557
9fd1ea42 9558 IPW_DEBUG_WX("GET retry -> %d\n", wrqu->retry.value);
afbf30a2
JK		 9559
9560 return 0;
9561}
9562
bf79451e
JG		 9563static int ipw_wx_set_scan(struct net_device *dev,
9564 struct iw_request_info *info,
43f66a6c
JK		 9565 union iwreq_data *wrqu, char *extra)
9566{
b0a4e7d8 9567 struct ipw_priv *priv = libipw_priv(dev);
094c4d2d 9568 struct iw_scan_req *req = (struct iw_scan_req *)extra;
ea177305 9569 struct delayed_work *work = NULL;
094c4d2d 9570
0b531676 9571 mutex_lock(&priv->mutex);
ea177305 9572
0b531676 9573 priv->user_requested_scan = 1;
0b531676 9574
094c4d2d 9575 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
afbf30a2 9576 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
ea177305
DW		 9577 int len = min((int)req->essid_len,
9578 (int)sizeof(priv->direct_scan_ssid));
9579 memcpy(priv->direct_scan_ssid, req->essid, len);
9580 priv->direct_scan_ssid_len = len;
9581 work = &priv->request_direct_scan;
9582 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
9583 work = &priv->request_passive_scan;
094c4d2d 9584 }
ea177305
DW		 9585 } else {
9586 /* Normal active broadcast scan */
9587 work = &priv->request_scan;
afbf30a2 9588 }
8935f39e 9589
ea177305
DW		 9590 mutex_unlock(&priv->mutex);
9591
43f66a6c 9592 IPW_DEBUG_WX("Start scan\n");
b095c381 9593
ea177305 9594 queue_delayed_work(priv->workqueue, work, 0);
b095c381 9595
43f66a6c
JK		 9596 return 0;
9597}
9598
bf79451e
JG		 9599static int ipw_wx_get_scan(struct net_device *dev,
9600 struct iw_request_info *info,
43f66a6c 9601 union iwreq_data *wrqu, char *extra)
bf79451e 9602{
b0a4e7d8
JL		 9603 struct ipw_priv *priv = libipw_priv(dev);
9604 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
43f66a6c
JK		 9605}
9606
bf79451e 9607static int ipw_wx_set_encode(struct net_device *dev,
0edd5b44
JG		 9608 struct iw_request_info *info,
9609 union iwreq_data *wrqu, char *key)
43f66a6c 9610{
b0a4e7d8 9611 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 9612 int ret;
caeff81b 9613 u32 cap = priv->capability;
afbf30a2 9614
4644151b 9615 mutex_lock(&priv->mutex);
b0a4e7d8 9616 ret = libipw_wx_set_encode(priv->ieee, info, wrqu, key);
afbf30a2 9617
caeff81b
HL		 9618 /* In IBSS mode, we need to notify the firmware to update
9619 * the beacon info after we changed the capability. */
9620 if (cap != priv->capability &&
9621 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9622 priv->status & STATUS_ASSOCIATED)
9623 ipw_disassociate(priv);
9624
4644151b 9625 mutex_unlock(&priv->mutex);
afbf30a2 9626 return ret;
43f66a6c
JK		 9627}
9628
bf79451e 9629static int ipw_wx_get_encode(struct net_device *dev,
0edd5b44
JG		 9630 struct iw_request_info *info,
9631 union iwreq_data *wrqu, char *key)
43f66a6c 9632{
b0a4e7d8
JL		 9633 struct ipw_priv *priv = libipw_priv(dev);
9634 return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
43f66a6c
JK		 9635}
9636
bf79451e 9637static int ipw_wx_set_power(struct net_device *dev,
0edd5b44
JG		 9638 struct iw_request_info *info,
9639 union iwreq_data *wrqu, char *extra)
43f66a6c 9640{
b0a4e7d8 9641 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9642 int err;
4644151b 9643 mutex_lock(&priv->mutex);
43f66a6c
JK		 9644 if (wrqu->power.disabled) {
9645 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9646 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9647 if (err) {
9648 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9649 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9650 return err;
9651 }
43f66a6c 9652 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
4644151b 9653 mutex_unlock(&priv->mutex);
43f66a6c 9654 return 0;
bf79451e 9655 }
43f66a6c
JK		 9656
9657 switch (wrqu->power.flags & IW_POWER_MODE) {
0edd5b44
JG		 9658 case IW_POWER_ON: /* If not specified */
9659 case IW_POWER_MODE: /* If set all mask */
c03983ac 9660 case IW_POWER_ALL_R: /* If explicitly state all */
43f66a6c 9661 break;
0edd5b44 9662 default: /* Otherwise we don't support it */
43f66a6c
JK		 9663 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9664 wrqu->power.flags);
4644151b 9665 mutex_unlock(&priv->mutex);
bf79451e 9666 return -EOPNOTSUPP;
43f66a6c 9667 }
bf79451e 9668
43f66a6c
JK		 9669 /* If the user hasn't specified a power management mode yet, default
9670 * to BATTERY */
0edd5b44 9671 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
43f66a6c 9672 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
bf79451e 9673 else
43f66a6c 9674 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
4e157f08 9675
43f66a6c
JK		 9676 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9677 if (err) {
9678 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9679 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9680 return err;
9681 }
9682
0edd5b44 9683 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
4644151b 9684 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9685 return 0;
9686}
9687
bf79451e 9688static int ipw_wx_get_power(struct net_device *dev,
0edd5b44
JG		 9689 struct iw_request_info *info,
9690 union iwreq_data *wrqu, char *extra)
43f66a6c 9691{
b0a4e7d8 9692 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9693 mutex_lock(&priv->mutex);
a613bffd 9694 if (!(priv->power_mode & IPW_POWER_ENABLED))
43f66a6c 9695 wrqu->power.disabled = 1;
a613bffd 9696 else
43f66a6c 9697 wrqu->power.disabled = 0;
43f66a6c 9698
4644151b 9699 mutex_unlock(&priv->mutex);
43f66a6c 9700 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
bf79451e 9701
43f66a6c
JK		 9702 return 0;
9703}
9704
bf79451e 9705static int ipw_wx_set_powermode(struct net_device *dev,
0edd5b44
JG		 9706 struct iw_request_info *info,
9707 union iwreq_data *wrqu, char *extra)
43f66a6c 9708{
b0a4e7d8 9709 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9710 int mode = *(int *)extra;
9711 int err;
4e157f08 9712
4644151b 9713 mutex_lock(&priv->mutex);
4e157f08 9714 if ((mode < 1) || (mode > IPW_POWER_LIMIT))
43f66a6c 9715 mode = IPW_POWER_AC;
bf79451e 9716
4e157f08 9717 if (IPW_POWER_LEVEL(priv->power_mode) != mode) {
43f66a6c 9718 err = ipw_send_power_mode(priv, mode);
43f66a6c
JK		 9719 if (err) {
9720 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9721 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9722 return err;
9723 }
4e157f08 9724 priv->power_mode = IPW_POWER_ENABLED | mode;
43f66a6c 9725 }
4644151b 9726 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9727 return 0;
9728}
9729
9730#define MAX_WX_STRING 80
bf79451e 9731static int ipw_wx_get_powermode(struct net_device *dev,
0edd5b44
JG		 9732 struct iw_request_info *info,
9733 union iwreq_data *wrqu, char *extra)
43f66a6c 9734{
b0a4e7d8 9735 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9736 int level = IPW_POWER_LEVEL(priv->power_mode);
9737 char *p = extra;
9738
9739 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9740
9741 switch (level) {
9742 case IPW_POWER_AC:
9743 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9744 break;
9745 case IPW_POWER_BATTERY:
9746 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9747 break;
9748 default:
9749 p += snprintf(p, MAX_WX_STRING - (p - extra),
bf79451e 9750 "(Timeout %dms, Period %dms)",
43f66a6c
JK		 9751 timeout_duration[level - 1] / 1000,
9752 period_duration[level - 1] / 1000);
9753 }
9754
9755 if (!(priv->power_mode & IPW_POWER_ENABLED))
0edd5b44 9756 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
43f66a6c
JK		 9757
9758 wrqu->data.length = p - extra + 1;
9759
9760 return 0;
9761}
9762
9763static int ipw_wx_set_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9764 struct iw_request_info *info,
9765 union iwreq_data *wrqu, char *extra)
43f66a6c 9766{
b0a4e7d8 9767 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9768 int mode = *(int *)extra;
9769 u8 band = 0, modulation = 0;
9770
9771 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
0edd5b44 9772 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
43f66a6c
JK		 9773 return -EINVAL;
9774 }
4644151b 9775 mutex_lock(&priv->mutex);
43f66a6c 9776 if (priv->adapter == IPW_2915ABG) {
a33a1982 9777 priv->ieee->abg_true = 1;
43f66a6c 9778 if (mode & IEEE_A) {
b0a4e7d8
JL		 9779 band |= LIBIPW_52GHZ_BAND;
9780 modulation |= LIBIPW_OFDM_MODULATION;
43f66a6c 9781 } else
a33a1982 9782 priv->ieee->abg_true = 0;
43f66a6c
JK		 9783 } else {
9784 if (mode & IEEE_A) {
9785 IPW_WARNING("Attempt to set 2200BG into "
9786 "802.11a mode\n");
4644151b 9787 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9788 return -EINVAL;
9789 }
9790
a33a1982 9791 priv->ieee->abg_true = 0;
43f66a6c
JK		 9792 }
9793
9794 if (mode & IEEE_B) {
b0a4e7d8
JL		 9795 band |= LIBIPW_24GHZ_BAND;
9796 modulation |= LIBIPW_CCK_MODULATION;
43f66a6c 9797 } else
a33a1982 9798 priv->ieee->abg_true = 0;
bf79451e 9799
43f66a6c 9800 if (mode & IEEE_G) {
b0a4e7d8
JL		 9801 band |= LIBIPW_24GHZ_BAND;
9802 modulation |= LIBIPW_OFDM_MODULATION;
43f66a6c 9803 } else
a33a1982 9804 priv->ieee->abg_true = 0;
43f66a6c
JK		 9805
9806 priv->ieee->mode = mode;
9807 priv->ieee->freq_band = band;
9808 priv->ieee->modulation = modulation;
0edd5b44 9809 init_supported_rates(priv, &priv->rates);
43f66a6c 9810
c848d0af
JK		 9811 /* Network configuration changed -- force [re]association */
9812 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9813 if (!ipw_disassociate(priv)) {
43f66a6c 9814 ipw_send_supported_rates(priv, &priv->rates);
c848d0af
JK		 9815 ipw_associate(priv);
9816 }
43f66a6c 9817
a613bffd
JK		 9818 /* Update the band LEDs */
9819 ipw_led_band_on(priv);
43f66a6c 9820
bf79451e 9821 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
43f66a6c 9822 mode & IEEE_A ? 'a' : '.',
0edd5b44 9823 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
4644151b 9824 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9825 return 0;
9826}
9827
9828static int ipw_wx_get_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9829 struct iw_request_info *info,
9830 union iwreq_data *wrqu, char *extra)
43f66a6c 9831{
b0a4e7d8 9832 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9833 mutex_lock(&priv->mutex);
ea2b26e0
JK		 9834 switch (priv->ieee->mode) {
9835 case IEEE_A:
43f66a6c
JK		 9836 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9837 break;
ea2b26e0
JK		 9838 case IEEE_B:
9839 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9840 break;
9841 case IEEE_A | IEEE_B:
9842 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9843 break;
9844 case IEEE_G:
9845 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9846 break;
9847 case IEEE_A | IEEE_G:
9848 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9849 break;
9850 case IEEE_B | IEEE_G:
9851 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9852 break;
9853 case IEEE_A | IEEE_B | IEEE_G:
9854 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9855 break;
9856 default:
9857 strncpy(extra, "unknown", MAX_WX_STRING);
43f66a6c 9858 break;
bf79451e
JG		 9859 }
9860
43f66a6c
JK		 9861 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9862
0edd5b44 9863 wrqu->data.length = strlen(extra) + 1;
4644151b 9864 mutex_unlock(&priv->mutex);
b095c381
JK		 9865
9866 return 0;
9867}
9868
9869static int ipw_wx_set_preamble(struct net_device *dev,
9870 struct iw_request_info *info,
9871 union iwreq_data *wrqu, char *extra)
9872{
b0a4e7d8 9873 struct ipw_priv *priv = libipw_priv(dev);
b095c381 9874 int mode = *(int *)extra;
4644151b 9875 mutex_lock(&priv->mutex);
b095c381
JK		 9876 /* Switching from SHORT -> LONG requires a disassociation */
9877 if (mode == 1) {
9878 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9879 priv->config |= CFG_PREAMBLE_LONG;
9880
9881 /* Network configuration changed -- force [re]association */
9882 IPW_DEBUG_ASSOC
9883 ("[re]association triggered due to preamble change.\n");
9884 if (!ipw_disassociate(priv))
9885 ipw_associate(priv);
9886 }
9887 goto done;
9888 }
43f66a6c 9889
b095c381
JK		 9890 if (mode == 0) {
9891 priv->config &= ~CFG_PREAMBLE_LONG;
9892 goto done;
9893 }
4644151b 9894 mutex_unlock(&priv->mutex);
b095c381
JK		 9895 return -EINVAL;
9896
9897 done:
4644151b 9898 mutex_unlock(&priv->mutex);
b095c381
JK		 9899 return 0;
9900}
9901
9902static int ipw_wx_get_preamble(struct net_device *dev,
9903 struct iw_request_info *info,
9904 union iwreq_data *wrqu, char *extra)
9905{
b0a4e7d8 9906 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9907 mutex_lock(&priv->mutex);
b095c381
JK		 9908 if (priv->config & CFG_PREAMBLE_LONG)
9909 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9910 else
9911 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
4644151b 9912 mutex_unlock(&priv->mutex);
0edd5b44 9913 return 0;
43f66a6c
JK		 9914}
9915
b095c381
JK		 9916#ifdef CONFIG_IPW2200_MONITOR
9917static int ipw_wx_set_monitor(struct net_device *dev,
bf79451e 9918 struct iw_request_info *info,
43f66a6c 9919 union iwreq_data *wrqu, char *extra)
bf79451e 9920{
b0a4e7d8 9921 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9922 int *parms = (int *)extra;
9923 int enable = (parms[0] > 0);
4644151b 9924 mutex_lock(&priv->mutex);
b095c381 9925 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
43f66a6c
JK		 9926 if (enable) {
9927 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
459d4087 9928#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 9929 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9930#else
43f66a6c 9931 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 9932#endif
b095c381 9933 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c 9934 }
bf79451e 9935
43f66a6c
JK		 9936 ipw_set_channel(priv, parms[1]);
9937 } else {
b095c381 9938 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
4644151b 9939 mutex_unlock(&priv->mutex);
43f66a6c 9940 return 0;
b095c381 9941 }
43f66a6c 9942 priv->net_dev->type = ARPHRD_ETHER;
b095c381 9943 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c 9944 }
4644151b 9945 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9946 return 0;
9947}
9948
67fd6b45 9949#endif /* CONFIG_IPW2200_MONITOR */
b095c381 9950
bf79451e
JG		 9951static int ipw_wx_reset(struct net_device *dev,
9952 struct iw_request_info *info,
43f66a6c 9953 union iwreq_data *wrqu, char *extra)
bf79451e 9954{
b0a4e7d8 9955 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9956 IPW_DEBUG_WX("RESET\n");
b095c381
JK		 9957 queue_work(priv->workqueue, &priv->adapter_restart);
9958 return 0;
9959}
9960
b095c381
JK		 9961static int ipw_wx_sw_reset(struct net_device *dev,
9962 struct iw_request_info *info,
9963 union iwreq_data *wrqu, char *extra)
ea2b26e0 9964{
b0a4e7d8 9965 struct ipw_priv *priv = libipw_priv(dev);
b095c381
JK		 9966 union iwreq_data wrqu_sec = {
9967 .encoding = {
9968 .flags = IW_ENCODE_DISABLED,
9969 },
9970 };
afbf30a2 9971 int ret;
c848d0af 9972
b095c381 9973 IPW_DEBUG_WX("SW_RESET\n");
ea2b26e0 9974
4644151b 9975 mutex_lock(&priv->mutex);
ea2b26e0 9976
d6d5b5c1 9977 ret = ipw_sw_reset(priv, 2);
afbf30a2
JK		 9978 if (!ret) {
9979 free_firmware();
9980 ipw_adapter_restart(priv);
9981 }
ea2b26e0 9982
b095c381
JK		 9983 /* The SW reset bit might have been toggled on by the 'disable'
9984 * module parameter, so take appropriate action */
9985 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
ea2b26e0 9986
4644151b 9987 mutex_unlock(&priv->mutex);
b0a4e7d8 9988 libipw_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
4644151b 9989 mutex_lock(&priv->mutex);
bf79451e 9990
b095c381
JK		 9991 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9992 /* Configuration likely changed -- force [re]association */
9993 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9994 "reset.\n");
9995 if (!ipw_disassociate(priv))
9996 ipw_associate(priv);
43f66a6c 9997 }
b095c381 9998
4644151b 9999 mutex_unlock(&priv->mutex);
43f66a6c 10000
43f66a6c
JK		 10001 return 0;
10002}
43f66a6c
JK		 10003
10004/* Rebase the WE IOCTLs to zero for the handler array */
0edd5b44 10005static iw_handler ipw_wx_handlers[] = {
56b632e8
JP		 10006 IW_HANDLER(SIOCGIWNAME, (iw_handler)cfg80211_wext_giwname),
10007 IW_HANDLER(SIOCSIWFREQ, ipw_wx_set_freq),
10008 IW_HANDLER(SIOCGIWFREQ, ipw_wx_get_freq),
10009 IW_HANDLER(SIOCSIWMODE, ipw_wx_set_mode),
10010 IW_HANDLER(SIOCGIWMODE, ipw_wx_get_mode),
10011 IW_HANDLER(SIOCSIWSENS, ipw_wx_set_sens),
10012 IW_HANDLER(SIOCGIWSENS, ipw_wx_get_sens),
10013 IW_HANDLER(SIOCGIWRANGE, ipw_wx_get_range),
10014 IW_HANDLER(SIOCSIWAP, ipw_wx_set_wap),
10015 IW_HANDLER(SIOCGIWAP, ipw_wx_get_wap),
10016 IW_HANDLER(SIOCSIWSCAN, ipw_wx_set_scan),
10017 IW_HANDLER(SIOCGIWSCAN, ipw_wx_get_scan),
10018 IW_HANDLER(SIOCSIWESSID, ipw_wx_set_essid),
10019 IW_HANDLER(SIOCGIWESSID, ipw_wx_get_essid),
10020 IW_HANDLER(SIOCSIWNICKN, ipw_wx_set_nick),
10021 IW_HANDLER(SIOCGIWNICKN, ipw_wx_get_nick),
10022 IW_HANDLER(SIOCSIWRATE, ipw_wx_set_rate),
10023 IW_HANDLER(SIOCGIWRATE, ipw_wx_get_rate),
10024 IW_HANDLER(SIOCSIWRTS, ipw_wx_set_rts),
10025 IW_HANDLER(SIOCGIWRTS, ipw_wx_get_rts),
10026 IW_HANDLER(SIOCSIWFRAG, ipw_wx_set_frag),
10027 IW_HANDLER(SIOCGIWFRAG, ipw_wx_get_frag),
10028 IW_HANDLER(SIOCSIWTXPOW, ipw_wx_set_txpow),
10029 IW_HANDLER(SIOCGIWTXPOW, ipw_wx_get_txpow),
10030 IW_HANDLER(SIOCSIWRETRY, ipw_wx_set_retry),
10031 IW_HANDLER(SIOCGIWRETRY, ipw_wx_get_retry),
10032 IW_HANDLER(SIOCSIWENCODE, ipw_wx_set_encode),
10033 IW_HANDLER(SIOCGIWENCODE, ipw_wx_get_encode),
10034 IW_HANDLER(SIOCSIWPOWER, ipw_wx_set_power),
10035 IW_HANDLER(SIOCGIWPOWER, ipw_wx_get_power),
10036 IW_HANDLER(SIOCSIWSPY, iw_handler_set_spy),
10037 IW_HANDLER(SIOCGIWSPY, iw_handler_get_spy),
10038 IW_HANDLER(SIOCSIWTHRSPY, iw_handler_set_thrspy),
10039 IW_HANDLER(SIOCGIWTHRSPY, iw_handler_get_thrspy),
10040 IW_HANDLER(SIOCSIWGENIE, ipw_wx_set_genie),
10041 IW_HANDLER(SIOCGIWGENIE, ipw_wx_get_genie),
10042 IW_HANDLER(SIOCSIWMLME, ipw_wx_set_mlme),
10043 IW_HANDLER(SIOCSIWAUTH, ipw_wx_set_auth),
10044 IW_HANDLER(SIOCGIWAUTH, ipw_wx_get_auth),
10045 IW_HANDLER(SIOCSIWENCODEEXT, ipw_wx_set_encodeext),
10046 IW_HANDLER(SIOCGIWENCODEEXT, ipw_wx_get_encodeext),
43f66a6c
JK		 10047};
10048
b095c381
JK		 10049enum {
10050 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
10051 IPW_PRIV_GET_POWER,
10052 IPW_PRIV_SET_MODE,
10053 IPW_PRIV_GET_MODE,
10054 IPW_PRIV_SET_PREAMBLE,
10055 IPW_PRIV_GET_PREAMBLE,
10056 IPW_PRIV_RESET,
10057 IPW_PRIV_SW_RESET,
10058#ifdef CONFIG_IPW2200_MONITOR
10059 IPW_PRIV_SET_MONITOR,
10060#endif
10061};
43f66a6c 10062
bf79451e 10063static struct iw_priv_args ipw_priv_args[] = {
43f66a6c 10064 {
0edd5b44
JG		 10065 .cmd = IPW_PRIV_SET_POWER,
10066 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10067 .name = "set_power"},
43f66a6c 10068 {
0edd5b44
JG		 10069 .cmd = IPW_PRIV_GET_POWER,
10070 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
10071 .name = "get_power"},
43f66a6c 10072 {
0edd5b44
JG		 10073 .cmd = IPW_PRIV_SET_MODE,
10074 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10075 .name = "set_mode"},
43f66a6c 10076 {
0edd5b44
JG		 10077 .cmd = IPW_PRIV_GET_MODE,
10078 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
10079 .name = "get_mode"},
43f66a6c 10080 {
ea2b26e0
JK		 10081 .cmd = IPW_PRIV_SET_PREAMBLE,
10082 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10083 .name = "set_preamble"},
10084 {
10085 .cmd = IPW_PRIV_GET_PREAMBLE,
10086 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
10087 .name = "get_preamble"},
43f66a6c 10088 {
0edd5b44
JG		 10089 IPW_PRIV_RESET,
10090 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
b095c381
JK		 10091 {
10092 IPW_PRIV_SW_RESET,
10093 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
10094#ifdef CONFIG_IPW2200_MONITOR
10095 {
10096 IPW_PRIV_SET_MONITOR,
10097 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
10098#endif /* CONFIG_IPW2200_MONITOR */
43f66a6c
JK		 10099};
10100
10101static iw_handler ipw_priv_handler[] = {
10102 ipw_wx_set_powermode,
10103 ipw_wx_get_powermode,
10104 ipw_wx_set_wireless_mode,
10105 ipw_wx_get_wireless_mode,
ea2b26e0
JK		 10106 ipw_wx_set_preamble,
10107 ipw_wx_get_preamble,
bf79451e 10108 ipw_wx_reset,
b095c381
JK		 10109 ipw_wx_sw_reset,
10110#ifdef CONFIG_IPW2200_MONITOR
10111 ipw_wx_set_monitor,
43f66a6c
JK		 10112#endif
10113};
10114
0edd5b44 10115static struct iw_handler_def ipw_wx_handler_def = {
ea2b26e0
JK		 10116 .standard = ipw_wx_handlers,
10117 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
10118 .num_private = ARRAY_SIZE(ipw_priv_handler),
10119 .num_private_args = ARRAY_SIZE(ipw_priv_args),
10120 .private = ipw_priv_handler,
10121 .private_args = ipw_priv_args,
97a78ca9 10122 .get_wireless_stats = ipw_get_wireless_stats,
43f66a6c
JK		 10123};
10124
43f66a6c
JK		 10125/*
10126 * Get wireless statistics.
10127 * Called by /proc/net/wireless
10128 * Also called by SIOCGIWSTATS
10129 */
0edd5b44 10130static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
43f66a6c 10131{
b0a4e7d8 10132 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10133 struct iw_statistics *wstats;
bf79451e 10134
43f66a6c
JK		 10135 wstats = &priv->wstats;
10136
ea2b26e0 10137 /* if hw is disabled, then ipw_get_ordinal() can't be called.
afbf30a2 10138 * netdev->get_wireless_stats seems to be called before fw is
43f66a6c
JK		 10139 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
10140 * and associated; if not associcated, the values are all meaningless
10141 * anyway, so set them all to NULL and INVALID */
10142 if (!(priv->status & STATUS_ASSOCIATED)) {
10143 wstats->miss.beacon = 0;
10144 wstats->discard.retries = 0;
10145 wstats->qual.qual = 0;
10146 wstats->qual.level = 0;
10147 wstats->qual.noise = 0;
10148 wstats->qual.updated = 7;
10149 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
0edd5b44 10150 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
43f66a6c 10151 return wstats;
bf79451e 10152 }
43f66a6c
JK		 10153
10154 wstats->qual.qual = priv->quality;
00d21de5
ZY		 10155 wstats->qual.level = priv->exp_avg_rssi;
10156 wstats->qual.noise = priv->exp_avg_noise;
43f66a6c 10157 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
b191608a 10158 IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
43f66a6c
JK		 10159
10160 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
10161 wstats->discard.retries = priv->last_tx_failures;
10162 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
bf79451e 10163
43f66a6c
JK		 10164/* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
10165 goto fail_get_ordinal;
10166 wstats->discard.retries += tx_retry; */
bf79451e 10167
43f66a6c
JK		 10168 return wstats;
10169}
10170
43f66a6c
JK		 10171/* net device stuff */
10172
858119e1 10173static void init_sys_config(struct ipw_sys_config *sys_config)
43f66a6c 10174{
0edd5b44 10175 memset(sys_config, 0, sizeof(struct ipw_sys_config));
810dabd4 10176 sys_config->bt_coexistence = 0;
43f66a6c
JK		 10177 sys_config->answer_broadcast_ssid_probe = 0;
10178 sys_config->accept_all_data_frames = 0;
10179 sys_config->accept_non_directed_frames = 1;
10180 sys_config->exclude_unicast_unencrypted = 0;
10181 sys_config->disable_unicast_decryption = 1;
10182 sys_config->exclude_multicast_unencrypted = 0;
10183 sys_config->disable_multicast_decryption = 1;
d2b83e12
ZY		 10184 if (antenna < CFG_SYS_ANTENNA_BOTH || antenna > CFG_SYS_ANTENNA_B)
10185 antenna = CFG_SYS_ANTENNA_BOTH;
10186 sys_config->antenna_diversity = antenna;
0edd5b44 10187 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
43f66a6c 10188 sys_config->dot11g_auto_detection = 0;
bf79451e 10189 sys_config->enable_cts_to_self = 0;
43f66a6c 10190 sys_config->bt_coexist_collision_thr = 0;
67fd6b45 10191 sys_config->pass_noise_stats_to_host = 1; /* 1 -- fix for 256 */
12977154 10192 sys_config->silence_threshold = 0x1e;
43f66a6c
JK		 10193}
10194
10195static int ipw_net_open(struct net_device *dev)
10196{
43f66a6c 10197 IPW_DEBUG_INFO("dev->open\n");
521c4d96 10198 netif_start_queue(dev);
43f66a6c
JK		 10199 return 0;
10200}
10201
10202static int ipw_net_stop(struct net_device *dev)
10203{
10204 IPW_DEBUG_INFO("dev->close\n");
10205 netif_stop_queue(dev);
10206 return 0;
10207}
10208
10209/*
10210todo:
10211
10212modify to send one tfd per fragment instead of using chunking. otherwise
b0a4e7d8 10213we need to heavily modify the libipw_skb_to_txb.
43f66a6c
JK		 10214*/
10215
b0a4e7d8 10216static int ipw_tx_skb(struct ipw_priv *priv, struct libipw_txb *txb,
227d2dc1 10217 int pri)
43f66a6c 10218{
b0a4e7d8 10219 struct libipw_hdr_3addrqos *hdr = (struct libipw_hdr_3addrqos *)
0edd5b44 10220 txb->fragments[0]->data;
43f66a6c
JK		 10221 int i = 0;
10222 struct tfd_frame *tfd;
e43e3c1e 10223#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 10224 int tx_id = ipw_get_tx_queue_number(priv, pri);
10225 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10226#else
43f66a6c 10227 struct clx2_tx_queue *txq = &priv->txq[0];
b095c381 10228#endif
43f66a6c
JK		 10229 struct clx2_queue *q = &txq->q;
10230 u8 id, hdr_len, unicast;
c848d0af 10231 int fc;
43f66a6c 10232
b8ddafd7
ZY		 10233 if (!(priv->status & STATUS_ASSOCIATED))
10234 goto drop;
10235
b0a4e7d8 10236 hdr_len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
43f66a6c
JK		 10237 switch (priv->ieee->iw_mode) {
10238 case IW_MODE_ADHOC:
3c19065a 10239 unicast = !is_multicast_ether_addr(hdr->addr1);
43f66a6c
JK		 10240 id = ipw_find_station(priv, hdr->addr1);
10241 if (id == IPW_INVALID_STATION) {
10242 id = ipw_add_station(priv, hdr->addr1);
10243 if (id == IPW_INVALID_STATION) {
10244 IPW_WARNING("Attempt to send data to "
e174961c
JB		 10245 "invalid cell: %pM\n",
10246 hdr->addr1);
43f66a6c
JK		 10247 goto drop;
10248 }
10249 }
10250 break;
10251
10252 case IW_MODE_INFRA:
10253 default:
3c19065a 10254 unicast = !is_multicast_ether_addr(hdr->addr3);
43f66a6c
JK		 10255 id = 0;
10256 break;
10257 }
10258
10259 tfd = &txq->bd[q->first_empty];
10260 txq->txb[q->first_empty] = txb;
10261 memset(tfd, 0, sizeof(*tfd));
10262 tfd->u.data.station_number = id;
10263
10264 tfd->control_flags.message_type = TX_FRAME_TYPE;
10265 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10266
10267 tfd->u.data.cmd_id = DINO_CMD_TX;
a613bffd 10268 tfd->u.data.len = cpu_to_le16(txb->payload_size);
bf79451e 10269
43f66a6c 10270 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
b095c381 10271 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
43f66a6c 10272 else
b095c381 10273 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
43f66a6c 10274
ea2b26e0
JK		 10275 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10276 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
43f66a6c 10277
c848d0af
JK		 10278 fc = le16_to_cpu(hdr->frame_ctl);
10279 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
43f66a6c
JK		 10280
10281 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10282
b095c381
JK		 10283 if (likely(unicast))
10284 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10285
10286 if (txb->encrypted && !priv->ieee->host_encrypt) {
10287 switch (priv->ieee->sec.level) {
10288 case SEC_LEVEL_3:
10289 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10290 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
b095c381
JK		 10291 /* XXX: ACK flag must be set for CCMP even if it
10292 * is a multicast/broadcast packet, because CCMP
10293 * group communication encrypted by GTK is
10294 * actually done by the AP. */
10295 if (!unicast)
10296 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10297
10298 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10299 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10300 tfd->u.data.key_index = 0;
10301 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10302 break;
10303 case SEC_LEVEL_2:
10304 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10305 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
b095c381
JK		 10306 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10307 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10308 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10309 break;
10310 case SEC_LEVEL_1:
10311 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10312 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
274bfb8d
JL		 10313 tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10314 if (priv->ieee->sec.key_sizes[priv->ieee->crypt_info.tx_keyidx] <=
b095c381
JK		 10315 40)
10316 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10317 else
10318 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10319 break;
10320 case SEC_LEVEL_0:
10321 break;
10322 default:
af901ca1 10323 printk(KERN_ERR "Unknown security level %d\n",
b095c381
JK		 10324 priv->ieee->sec.level);
10325 break;
10326 }
10327 } else
10328 /* No hardware encryption */
10329 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10330
e43e3c1e 10331#ifdef CONFIG_IPW2200_QOS
a5cf4fe6
ZY		 10332 if (fc & IEEE80211_STYPE_QOS_DATA)
10333 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
e43e3c1e 10334#endif /* CONFIG_IPW2200_QOS */
b095c381 10335
43f66a6c 10336 /* payload */
a613bffd
JK		 10337 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10338 txb->nr_frags));
10339 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
10340 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10341 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10342 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
10343 i, le32_to_cpu(tfd->u.data.num_chunks),
10344 txb->fragments[i]->len - hdr_len);
bf79451e 10345 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
43f66a6c
JK		 10346 i, tfd->u.data.num_chunks,
10347 txb->fragments[i]->len - hdr_len);
bf79451e 10348 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
43f66a6c
JK		 10349 txb->fragments[i]->len - hdr_len);
10350
0edd5b44 10351 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 10352 cpu_to_le32(pci_map_single
10353 (priv->pci_dev,
10354 txb->fragments[i]->data + hdr_len,
10355 txb->fragments[i]->len - hdr_len,
10356 PCI_DMA_TODEVICE));
10357 tfd->u.data.chunk_len[i] =
10358 cpu_to_le16(txb->fragments[i]->len - hdr_len);
43f66a6c
JK		 10359 }
10360
10361 if (i != txb->nr_frags) {
10362 struct sk_buff *skb;
10363 u16 remaining_bytes = 0;
10364 int j;
10365
10366 for (j = i; j < txb->nr_frags; j++)
10367 remaining_bytes += txb->fragments[j]->len - hdr_len;
10368
10369 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
10370 remaining_bytes);
10371 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
10372 if (skb != NULL) {
a613bffd 10373 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
43f66a6c
JK		 10374 for (j = i; j < txb->nr_frags; j++) {
10375 int size = txb->fragments[j]->len - hdr_len;
afbf30a2 10376
43f66a6c 10377 printk(KERN_INFO "Adding frag %d %d...\n",
0edd5b44 10378 j, size);
43f66a6c 10379 memcpy(skb_put(skb, size),
0edd5b44 10380 txb->fragments[j]->data + hdr_len, size);
43f66a6c
JK		 10381 }
10382 dev_kfree_skb_any(txb->fragments[i]);
10383 txb->fragments[i] = skb;
0edd5b44 10384 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 10385 cpu_to_le32(pci_map_single
10386 (priv->pci_dev, skb->data,
4958730e 10387 remaining_bytes,
a613bffd
JK		 10388 PCI_DMA_TODEVICE));
10389
5c05863d 10390 le32_add_cpu(&tfd->u.data.num_chunks, 1);
bf79451e 10391 }
43f66a6c
JK		 10392 }
10393
10394 /* kick DMA */
10395 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10396 ipw_write32(priv, q->reg_w, q->first_empty);
10397
943dbef4 10398 if (ipw_tx_queue_space(q) < q->high_mark)
f697014a
JK		 10399 netif_stop_queue(priv->net_dev);
10400
227d2dc1 10401 return NETDEV_TX_OK;
43f66a6c 10402
0edd5b44 10403 drop:
43f66a6c 10404 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
b0a4e7d8 10405 libipw_txb_free(txb);
227d2dc1
JK		 10406 return NETDEV_TX_OK;
10407}
10408
10409static int ipw_net_is_queue_full(struct net_device *dev, int pri)
10410{
b0a4e7d8 10411 struct ipw_priv *priv = libipw_priv(dev);
e43e3c1e 10412#ifdef CONFIG_IPW2200_QOS
227d2dc1
JK		 10413 int tx_id = ipw_get_tx_queue_number(priv, pri);
10414 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10415#else
10416 struct clx2_tx_queue *txq = &priv->txq[0];
e43e3c1e 10417#endif /* CONFIG_IPW2200_QOS */
227d2dc1 10418
943dbef4 10419 if (ipw_tx_queue_space(&txq->q) < txq->q.high_mark)
227d2dc1
JK		 10420 return 1;
10421
10422 return 0;
43f66a6c
JK		 10423}
10424
d685b8c2
ZY		 10425#ifdef CONFIG_IPW2200_PROMISCUOUS
10426static void ipw_handle_promiscuous_tx(struct ipw_priv *priv,
b0a4e7d8 10427 struct libipw_txb *txb)
d685b8c2 10428{
b0a4e7d8 10429 struct libipw_rx_stats dummystats;
d685b8c2
ZY		 10430 struct ieee80211_hdr *hdr;
10431 u8 n;
10432 u16 filter = priv->prom_priv->filter;
10433 int hdr_only = 0;
10434
10435 if (filter & IPW_PROM_NO_TX)
10436 return;
10437
10438 memset(&dummystats, 0, sizeof(dummystats));
10439
10440 /* Filtering of fragment chains is done agains the first fragment */
10441 hdr = (void *)txb->fragments[0]->data;
b0a4e7d8 10442 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10443 if (filter & IPW_PROM_NO_MGMT)
10444 return;
10445 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
10446 hdr_only = 1;
b0a4e7d8 10447 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10448 if (filter & IPW_PROM_NO_CTL)
10449 return;
10450 if (filter & IPW_PROM_CTL_HEADER_ONLY)
10451 hdr_only = 1;
b0a4e7d8 10452 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10453 if (filter & IPW_PROM_NO_DATA)
10454 return;
10455 if (filter & IPW_PROM_DATA_HEADER_ONLY)
10456 hdr_only = 1;
10457 }
10458
10459 for(n=0; n<txb->nr_frags; ++n) {
10460 struct sk_buff *src = txb->fragments[n];
10461 struct sk_buff *dst;
10462 struct ieee80211_radiotap_header *rt_hdr;
10463 int len;
10464
10465 if (hdr_only) {
10466 hdr = (void *)src->data;
b0a4e7d8 10467 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
d685b8c2
ZY		 10468 } else
10469 len = src->len;
10470
007e5ddd
JB		 10471 dst = alloc_skb(len + sizeof(*rt_hdr), GFP_ATOMIC);
10472 if (!dst)
10473 continue;
d685b8c2
ZY		 10474
10475 rt_hdr = (void *)skb_put(dst, sizeof(*rt_hdr));
10476
10477 rt_hdr->it_version = PKTHDR_RADIOTAP_VERSION;
10478 rt_hdr->it_pad = 0;
10479 rt_hdr->it_present = 0; /* after all, it's just an idea */
743b84d2 10480 rt_hdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_CHANNEL);
d685b8c2 10481
e62e1ee0 10482 *(__le16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(
d685b8c2
ZY		 10483 ieee80211chan2mhz(priv->channel));
10484 if (priv->channel > 14) /* 802.11a */
e62e1ee0 10485 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10486 cpu_to_le16(IEEE80211_CHAN_OFDM |
10487 IEEE80211_CHAN_5GHZ);
10488 else if (priv->ieee->mode == IEEE_B) /* 802.11b */
e62e1ee0 10489 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10490 cpu_to_le16(IEEE80211_CHAN_CCK |
10491 IEEE80211_CHAN_2GHZ);
10492 else /* 802.11g */
e62e1ee0 10493 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10494 cpu_to_le16(IEEE80211_CHAN_OFDM |
10495 IEEE80211_CHAN_2GHZ);
10496
743b84d2 10497 rt_hdr->it_len = cpu_to_le16(dst->len);
d685b8c2 10498
d626f62b 10499 skb_copy_from_linear_data(src, skb_put(dst, len), len);
d685b8c2 10500
b0a4e7d8 10501 if (!libipw_rx(priv->prom_priv->ieee, dst, &dummystats))
d685b8c2
ZY		 10502 dev_kfree_skb_any(dst);
10503 }
10504}
10505#endif
10506
d0cf9c0d
SH		 10507static netdev_tx_t ipw_net_hard_start_xmit(struct libipw_txb *txb,
10508 struct net_device *dev, int pri)
43f66a6c 10509{
b0a4e7d8 10510 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10511 unsigned long flags;
d0cf9c0d 10512 netdev_tx_t ret;
43f66a6c
JK		 10513
10514 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
43f66a6c
JK		 10515 spin_lock_irqsave(&priv->lock, flags);
10516
d685b8c2
ZY		 10517#ifdef CONFIG_IPW2200_PROMISCUOUS
10518 if (rtap_iface && netif_running(priv->prom_net_dev))
10519 ipw_handle_promiscuous_tx(priv, txb);
10520#endif
10521
227d2dc1
JK		 10522 ret = ipw_tx_skb(priv, txb, pri);
10523 if (ret == NETDEV_TX_OK)
10524 __ipw_led_activity_on(priv);
43f66a6c 10525 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 10526
227d2dc1 10527 return ret;
43f66a6c
JK		 10528}
10529
43f66a6c
JK		 10530static void ipw_net_set_multicast_list(struct net_device *dev)
10531{
10532
10533}
10534
10535static int ipw_net_set_mac_address(struct net_device *dev, void *p)
10536{
b0a4e7d8 10537 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10538 struct sockaddr *addr = p;
0795af57 10539
43f66a6c
JK		 10540 if (!is_valid_ether_addr(addr->sa_data))
10541 return -EADDRNOTAVAIL;
4644151b 10542 mutex_lock(&priv->mutex);
43f66a6c
JK		 10543 priv->config |= CFG_CUSTOM_MAC;
10544 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
e174961c
JB		 10545 printk(KERN_INFO "%s: Setting MAC to %pM\n",
10546 priv->net_dev->name, priv->mac_addr);
a613bffd 10547 queue_work(priv->workqueue, &priv->adapter_restart);
4644151b 10548 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10549 return 0;
10550}
10551
bf79451e 10552static void ipw_ethtool_get_drvinfo(struct net_device *dev,
43f66a6c
JK		 10553 struct ethtool_drvinfo *info)
10554{
b0a4e7d8 10555 struct ipw_priv *p = libipw_priv(dev);
43f66a6c
JK		 10556 char vers[64];
10557 char date[32];
10558 u32 len;
10559
10560 strcpy(info->driver, DRV_NAME);
10561 strcpy(info->version, DRV_VERSION);
10562
10563 len = sizeof(vers);
10564 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
10565 len = sizeof(date);
10566 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
10567
0edd5b44 10568 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
43f66a6c
JK		 10569 vers, date);
10570 strcpy(info->bus_info, pci_name(p->pci_dev));
b095c381 10571 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 10572}
10573
10574static u32 ipw_ethtool_get_link(struct net_device *dev)
10575{
b0a4e7d8 10576 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 10577 return (priv->status & STATUS_ASSOCIATED) != 0;
10578}
10579
10580static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10581{
b095c381 10582 return IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 10583}
10584
10585static int ipw_ethtool_get_eeprom(struct net_device *dev,
0edd5b44 10586 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c 10587{
b0a4e7d8 10588 struct ipw_priv *p = libipw_priv(dev);
43f66a6c 10589
b095c381 10590 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 10591 return -EINVAL;
4644151b 10592 mutex_lock(&p->mutex);
afbf30a2 10593 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
4644151b 10594 mutex_unlock(&p->mutex);
43f66a6c
JK		 10595 return 0;
10596}
10597
10598static int ipw_ethtool_set_eeprom(struct net_device *dev,
0edd5b44 10599 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c 10600{
b0a4e7d8 10601 struct ipw_priv *p = libipw_priv(dev);
43f66a6c
JK		 10602 int i;
10603
b095c381 10604 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 10605 return -EINVAL;
4644151b 10606 mutex_lock(&p->mutex);
afbf30a2 10607 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
71e585fc
AB		 10608 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
10609 ipw_write8(p, i + IPW_EEPROM_DATA, p->eeprom[i]);
4644151b 10610 mutex_unlock(&p->mutex);
43f66a6c
JK		 10611 return 0;
10612}
10613
7282d491 10614static const struct ethtool_ops ipw_ethtool_ops = {
ea2b26e0
JK		 10615 .get_link = ipw_ethtool_get_link,
10616 .get_drvinfo = ipw_ethtool_get_drvinfo,
10617 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10618 .get_eeprom = ipw_ethtool_get_eeprom,
10619 .set_eeprom = ipw_ethtool_set_eeprom,
43f66a6c
JK		 10620};
10621
7d12e780 10622static irqreturn_t ipw_isr(int irq, void *data)
43f66a6c
JK		 10623{
10624 struct ipw_priv *priv = data;
10625 u32 inta, inta_mask;
bf79451e 10626
43f66a6c
JK		 10627 if (!priv)
10628 return IRQ_NONE;
10629
89c318ed 10630 spin_lock(&priv->irq_lock);
43f66a6c
JK		 10631
10632 if (!(priv->status & STATUS_INT_ENABLED)) {
d00d0121 10633 /* IRQ is disabled */
43f66a6c
JK		 10634 goto none;
10635 }
10636
b095c381
JK		 10637 inta = ipw_read32(priv, IPW_INTA_RW);
10638 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
bf79451e 10639
43f66a6c
JK		 10640 if (inta == 0xFFFFFFFF) {
10641 /* Hardware disappeared */
10642 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10643 goto none;
10644 }
10645
b095c381 10646 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
43f66a6c
JK		 10647 /* Shared interrupt */
10648 goto none;
10649 }
10650
10651 /* tell the device to stop sending interrupts */
89c318ed 10652 __ipw_disable_interrupts(priv);
bf79451e 10653
43f66a6c 10654 /* ack current interrupts */
b095c381
JK		 10655 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10656 ipw_write32(priv, IPW_INTA_RW, inta);
bf79451e 10657
43f66a6c
JK		 10658 /* Cache INTA value for our tasklet */
10659 priv->isr_inta = inta;
10660
10661 tasklet_schedule(&priv->irq_tasklet);
10662
89c318ed 10663 spin_unlock(&priv->irq_lock);
43f66a6c
JK		 10664
10665 return IRQ_HANDLED;
0edd5b44 10666 none:
89c318ed 10667 spin_unlock(&priv->irq_lock);
43f66a6c
JK		 10668 return IRQ_NONE;
10669}
10670
10671static void ipw_rf_kill(void *adapter)
10672{
10673 struct ipw_priv *priv = adapter;
10674 unsigned long flags;
bf79451e 10675
43f66a6c
JK		 10676 spin_lock_irqsave(&priv->lock, flags);
10677
10678 if (rf_kill_active(priv)) {
10679 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10680 if (priv->workqueue)
10681 queue_delayed_work(priv->workqueue,
10682 &priv->rf_kill, 2 * HZ);
10683 goto exit_unlock;
10684 }
10685
10686 /* RF Kill is now disabled, so bring the device back up */
10687
10688 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10689 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10690 "device\n");
10691
10692 /* we can not do an adapter restart while inside an irq lock */
10693 queue_work(priv->workqueue, &priv->adapter_restart);
bf79451e 10694 } else
43f66a6c
JK		 10695 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10696 "enabled\n");
10697
0edd5b44 10698 exit_unlock:
43f66a6c
JK		 10699 spin_unlock_irqrestore(&priv->lock, flags);
10700}
10701
c4028958 10702static void ipw_bg_rf_kill(struct work_struct *work)
c848d0af 10703{
c4028958
DH		 10704 struct ipw_priv *priv =
10705 container_of(work, struct ipw_priv, rf_kill.work);
4644151b 10706 mutex_lock(&priv->mutex);
c4028958 10707 ipw_rf_kill(priv);
4644151b 10708 mutex_unlock(&priv->mutex);
c848d0af
JK		 10709}
10710
a73e22b2 10711static void ipw_link_up(struct ipw_priv *priv)
a613bffd 10712{
afbf30a2
JK		 10713 priv->last_seq_num = -1;
10714 priv->last_frag_num = -1;
10715 priv->last_packet_time = 0;
10716
a613bffd 10717 netif_carrier_on(priv->net_dev);
a613bffd 10718
c848d0af 10719 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 10720 cancel_delayed_work(&priv->request_direct_scan);
10721 cancel_delayed_work(&priv->request_passive_scan);
0b531676 10722 cancel_delayed_work(&priv->scan_event);
a613bffd
JK		 10723 ipw_reset_stats(priv);
10724 /* Ensure the rate is updated immediately */
10725 priv->last_rate = ipw_get_current_rate(priv);
10726 ipw_gather_stats(priv);
10727 ipw_led_link_up(priv);
10728 notify_wx_assoc_event(priv);
10729
10730 if (priv->config & CFG_BACKGROUND_SCAN)
10731 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10732}
10733
c4028958 10734static void ipw_bg_link_up(struct work_struct *work)
c848d0af 10735{
c4028958
DH		 10736 struct ipw_priv *priv =
10737 container_of(work, struct ipw_priv, link_up);
4644151b 10738 mutex_lock(&priv->mutex);
c4028958 10739 ipw_link_up(priv);
4644151b 10740 mutex_unlock(&priv->mutex);
c848d0af
JK		 10741}
10742
a73e22b2 10743static void ipw_link_down(struct ipw_priv *priv)
a613bffd
JK		 10744{
10745 ipw_led_link_down(priv);
10746 netif_carrier_off(priv->net_dev);
a613bffd
JK		 10747 notify_wx_assoc_event(priv);
10748
10749 /* Cancel any queued work ... */
10750 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 10751 cancel_delayed_work(&priv->request_direct_scan);
10752 cancel_delayed_work(&priv->request_passive_scan);
a613bffd
JK		 10753 cancel_delayed_work(&priv->adhoc_check);
10754 cancel_delayed_work(&priv->gather_stats);
10755
10756 ipw_reset_stats(priv);
10757
afbf30a2
JK		 10758 if (!(priv->status & STATUS_EXIT_PENDING)) {
10759 /* Queue up another scan... */
c4028958 10760 queue_delayed_work(priv->workqueue, &priv->request_scan, 0);
0b531676
DW		 10761 } else
10762 cancel_delayed_work(&priv->scan_event);
a613bffd
JK		 10763}
10764
c4028958 10765static void ipw_bg_link_down(struct work_struct *work)
c848d0af 10766{
c4028958
DH		 10767 struct ipw_priv *priv =
10768 container_of(work, struct ipw_priv, link_down);
4644151b 10769 mutex_lock(&priv->mutex);
c4028958 10770 ipw_link_down(priv);
4644151b 10771 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10772}
10773
2ef19e63 10774static int __devinit ipw_setup_deferred_work(struct ipw_priv *priv)
43f66a6c
JK		 10775{
10776 int ret = 0;
10777
43f66a6c 10778 priv->workqueue = create_workqueue(DRV_NAME);
43f66a6c 10779 init_waitqueue_head(&priv->wait_command_queue);
afbf30a2 10780 init_waitqueue_head(&priv->wait_state);
43f66a6c 10781
c4028958
DH		 10782 INIT_DELAYED_WORK(&priv->adhoc_check, ipw_bg_adhoc_check);
10783 INIT_WORK(&priv->associate, ipw_bg_associate);
10784 INIT_WORK(&priv->disassociate, ipw_bg_disassociate);
10785 INIT_WORK(&priv->system_config, ipw_system_config);
10786 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish);
10787 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart);
10788 INIT_DELAYED_WORK(&priv->rf_kill, ipw_bg_rf_kill);
10789 INIT_WORK(&priv->up, ipw_bg_up);
10790 INIT_WORK(&priv->down, ipw_bg_down);
10791 INIT_DELAYED_WORK(&priv->request_scan, ipw_request_scan);
ea177305
DW		 10792 INIT_DELAYED_WORK(&priv->request_direct_scan, ipw_request_direct_scan);
10793 INIT_DELAYED_WORK(&priv->request_passive_scan, ipw_request_passive_scan);
0b531676 10794 INIT_DELAYED_WORK(&priv->scan_event, ipw_scan_event);
c4028958
DH		 10795 INIT_DELAYED_WORK(&priv->gather_stats, ipw_bg_gather_stats);
10796 INIT_WORK(&priv->abort_scan, ipw_bg_abort_scan);
10797 INIT_WORK(&priv->roam, ipw_bg_roam);
10798 INIT_DELAYED_WORK(&priv->scan_check, ipw_bg_scan_check);
10799 INIT_WORK(&priv->link_up, ipw_bg_link_up);
10800 INIT_WORK(&priv->link_down, ipw_bg_link_down);
10801 INIT_DELAYED_WORK(&priv->led_link_on, ipw_bg_led_link_on);
10802 INIT_DELAYED_WORK(&priv->led_link_off, ipw_bg_led_link_off);
10803 INIT_DELAYED_WORK(&priv->led_act_off, ipw_bg_led_activity_off);
10804 INIT_WORK(&priv->merge_networks, ipw_merge_adhoc_network);
43f66a6c 10805
e43e3c1e 10806#ifdef CONFIG_IPW2200_QOS
c4028958 10807 INIT_WORK(&priv->qos_activate, ipw_bg_qos_activate);
e43e3c1e 10808#endif /* CONFIG_IPW2200_QOS */
43f66a6c
JK		 10809
10810 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10811 ipw_irq_tasklet, (unsigned long)priv);
10812
10813 return ret;
10814}
10815
43f66a6c 10816static void shim__set_security(struct net_device *dev,
b0a4e7d8 10817 struct libipw_security *sec)
43f66a6c 10818{
b0a4e7d8 10819 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10820 int i;
bf79451e 10821 for (i = 0; i < 4; i++) {
43f66a6c 10822 if (sec->flags & (1 << i)) {
afbf30a2 10823 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
b095c381 10824 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
43f66a6c 10825 if (sec->key_sizes[i] == 0)
b095c381
JK		 10826 priv->ieee->sec.flags &= ~(1 << i);
10827 else {
10828 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
43f66a6c 10829 sec->key_sizes[i]);
b095c381
JK		 10830 priv->ieee->sec.flags |= (1 << i);
10831 }
43f66a6c 10832 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10833 } else if (sec->level != SEC_LEVEL_1)
10834 priv->ieee->sec.flags &= ~(1 << i);
43f66a6c
JK		 10835 }
10836
b095c381 10837 if (sec->flags & SEC_ACTIVE_KEY) {
43f66a6c 10838 if (sec->active_key <= 3) {
b095c381
JK		 10839 priv->ieee->sec.active_key = sec->active_key;
10840 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
bf79451e 10841 } else
b095c381 10842 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c 10843 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10844 } else
10845 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c
JK		 10846
10847 if ((sec->flags & SEC_AUTH_MODE) &&
b095c381
JK		 10848 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10849 priv->ieee->sec.auth_mode = sec->auth_mode;
10850 priv->ieee->sec.flags |= SEC_AUTH_MODE;
43f66a6c
JK		 10851 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10852 priv->capability |= CAP_SHARED_KEY;
10853 else
10854 priv->capability &= ~CAP_SHARED_KEY;
10855 priv->status |= STATUS_SECURITY_UPDATED;
10856 }
bf79451e 10857
b095c381
JK		 10858 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10859 priv->ieee->sec.flags |= SEC_ENABLED;
10860 priv->ieee->sec.enabled = sec->enabled;
43f66a6c 10861 priv->status |= STATUS_SECURITY_UPDATED;
bf79451e 10862 if (sec->enabled)
43f66a6c
JK		 10863 priv->capability |= CAP_PRIVACY_ON;
10864 else
10865 priv->capability &= ~CAP_PRIVACY_ON;
10866 }
bf79451e 10867
afbf30a2
JK		 10868 if (sec->flags & SEC_ENCRYPT)
10869 priv->ieee->sec.encrypt = sec->encrypt;
bf79451e 10870
b095c381
JK		 10871 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10872 priv->ieee->sec.level = sec->level;
10873 priv->ieee->sec.flags |= SEC_LEVEL;
43f66a6c
JK		 10874 priv->status |= STATUS_SECURITY_UPDATED;
10875 }
10876
1fbfea54
ZY		 10877 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10878 ipw_set_hwcrypto_keys(priv);
10879
bf79451e
JG		 10880 /* To match current functionality of ipw2100 (which works well w/
10881 * various supplicants, we don't force a disassociate if the
43f66a6c
JK		 10882 * privacy capability changes ... */
10883#if 0
10884 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
bf79451e 10885 (((priv->assoc_request.capability &
5b5e807f 10886 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && !sec->enabled) ||
bf79451e 10887 (!(priv->assoc_request.capability &
5b5e807f 10888 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && sec->enabled))) {
43f66a6c
JK		 10889 IPW_DEBUG_ASSOC("Disassociating due to capability "
10890 "change.\n");
10891 ipw_disassociate(priv);
10892 }
10893#endif
10894}
10895
bf79451e 10896static int init_supported_rates(struct ipw_priv *priv,
43f66a6c
JK		 10897 struct ipw_supported_rates *rates)
10898{
10899 /* TODO: Mask out rates based on priv->rates_mask */
10900
10901 memset(rates, 0, sizeof(*rates));
0edd5b44 10902 /* configure supported rates */
43f66a6c 10903 switch (priv->ieee->freq_band) {
b0a4e7d8 10904 case LIBIPW_52GHZ_BAND:
43f66a6c
JK		 10905 rates->ieee_mode = IPW_A_MODE;
10906 rates->purpose = IPW_RATE_CAPABILITIES;
b0a4e7d8
JL		 10907 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10908 LIBIPW_OFDM_DEFAULT_RATES_MASK);
43f66a6c
JK		 10909 break;
10910
0edd5b44 10911 default: /* Mixed or 2.4Ghz */
43f66a6c
JK		 10912 rates->ieee_mode = IPW_G_MODE;
10913 rates->purpose = IPW_RATE_CAPABILITIES;
b0a4e7d8
JL		 10914 ipw_add_cck_scan_rates(rates, LIBIPW_CCK_MODULATION,
10915 LIBIPW_CCK_DEFAULT_RATES_MASK);
10916 if (priv->ieee->modulation & LIBIPW_OFDM_MODULATION) {
10917 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10918 LIBIPW_OFDM_DEFAULT_RATES_MASK);
43f66a6c
JK		 10919 }
10920 break;
10921 }
10922
10923 return 0;
10924}
10925
bf79451e 10926static int ipw_config(struct ipw_priv *priv)
43f66a6c 10927{
43f66a6c
JK		 10928 /* This is only called from ipw_up, which resets/reloads the firmware
10929 so, we don't need to first disable the card before we configure
10930 it */
6de9f7f2 10931 if (ipw_set_tx_power(priv))
43f66a6c
JK		 10932 goto error;
10933
10934 /* initialize adapter address */
10935 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10936 goto error;
10937
10938 /* set basic system config settings */
10939 init_sys_config(&priv->sys_config);
810dabd4
ZY		 10940
10941 /* Support Bluetooth if we have BT h/w on board, and user wants to.
10942 * Does not support BT priority yet (don't abort or defer our Tx) */
10943 if (bt_coexist) {
2638bc39 10944 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
810dabd4
ZY		 10945
10946 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10947 priv->sys_config.bt_coexistence
2638bc39 10948 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
810dabd4
ZY		 10949 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10950 priv->sys_config.bt_coexistence
2638bc39 10951 |= CFG_BT_COEXISTENCE_OOB;
810dabd4
ZY		 10952 }
10953
d685b8c2
ZY		 10954#ifdef CONFIG_IPW2200_PROMISCUOUS
10955 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
10956 priv->sys_config.accept_all_data_frames = 1;
10957 priv->sys_config.accept_non_directed_frames = 1;
10958 priv->sys_config.accept_all_mgmt_bcpr = 1;
10959 priv->sys_config.accept_all_mgmt_frames = 1;
10960 }
10961#endif
10962
c848d0af
JK		 10963 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10964 priv->sys_config.answer_broadcast_ssid_probe = 1;
10965 else
10966 priv->sys_config.answer_broadcast_ssid_probe = 0;
10967
d685b8c2 10968 if (ipw_send_system_config(priv))
43f66a6c
JK		 10969 goto error;
10970
0edd5b44
JG		 10971 init_supported_rates(priv, &priv->rates);
10972 if (ipw_send_supported_rates(priv, &priv->rates))
43f66a6c
JK		 10973 goto error;
10974
10975 /* Set request-to-send threshold */
10976 if (priv->rts_threshold) {
10977 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10978 goto error;
10979 }
e43e3c1e 10980#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 10981 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10982 ipw_qos_activate(priv, NULL);
e43e3c1e 10983#endif /* CONFIG_IPW2200_QOS */
43f66a6c
JK		 10984
10985 if (ipw_set_random_seed(priv))
10986 goto error;
bf79451e 10987
43f66a6c
JK		 10988 /* final state transition to the RUN state */
10989 if (ipw_send_host_complete(priv))
10990 goto error;
10991
e666619e
JK		 10992 priv->status |= STATUS_INIT;
10993
10994 ipw_led_init(priv);
10995 ipw_led_radio_on(priv);
10996 priv->notif_missed_beacons = 0;
10997
10998 /* Set hardware WEP key if it is configured. */
10999 if ((priv->capability & CAP_PRIVACY_ON) &&
11000 (priv->ieee->sec.level == SEC_LEVEL_1) &&
11001 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
11002 ipw_set_hwcrypto_keys(priv);
43f66a6c
JK		 11003
11004 return 0;
bf79451e 11005
0edd5b44 11006 error:
43f66a6c
JK		 11007 return -EIO;
11008}
11009
4f36f808
JK		 11010/*
11011 * NOTE:
11012 *
11013 * These tables have been tested in conjunction with the
11014 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
11015 *
11016 * Altering this values, using it on other hardware, or in geographies
11017 * not intended for resale of the above mentioned Intel adapters has
11018 * not been tested.
11019 *
48a84770
HBA		 11020 * Remember to update the table in README.ipw2200 when changing this
11021 * table.
11022 *
4f36f808 11023 */
b0a4e7d8 11024static const struct libipw_geo ipw_geos[] = {
4f36f808
JK		 11025 { /* Restricted */
11026 "---",
11027 .bg_channels = 11,
11028 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11029 {2427, 4}, {2432, 5}, {2437, 6},
11030 {2442, 7}, {2447, 8}, {2452, 9},
11031 {2457, 10}, {2462, 11}},
11032 },
11033
11034 { /* Custom US/Canada */
11035 "ZZF",
11036 .bg_channels = 11,
11037 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11038 {2427, 4}, {2432, 5}, {2437, 6},
11039 {2442, 7}, {2447, 8}, {2452, 9},
11040 {2457, 10}, {2462, 11}},
11041 .a_channels = 8,
11042 .a = {{5180, 36},
11043 {5200, 40},
11044 {5220, 44},
11045 {5240, 48},
b0a4e7d8
JL		 11046 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11047 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11048 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11049 {5320, 64, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11050 },
11051
11052 { /* Rest of World */
11053 "ZZD",
11054 .bg_channels = 13,
11055 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11056 {2427, 4}, {2432, 5}, {2437, 6},
11057 {2442, 7}, {2447, 8}, {2452, 9},
11058 {2457, 10}, {2462, 11}, {2467, 12},
11059 {2472, 13}},
11060 },
11061
11062 { /* Custom USA & Europe & High */
11063 "ZZA",
11064 .bg_channels = 11,
11065 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11066 {2427, 4}, {2432, 5}, {2437, 6},
11067 {2442, 7}, {2447, 8}, {2452, 9},
11068 {2457, 10}, {2462, 11}},
11069 .a_channels = 13,
11070 .a = {{5180, 36},
11071 {5200, 40},
11072 {5220, 44},
11073 {5240, 48},
b0a4e7d8
JL		 11074 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11075 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11076 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11077 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
4f36f808
JK		 11078 {5745, 149},
11079 {5765, 153},
11080 {5785, 157},
11081 {5805, 161},
11082 {5825, 165}},
11083 },
11084
11085 { /* Custom NA & Europe */
11086 "ZZB",
11087 .bg_channels = 11,
11088 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11089 {2427, 4}, {2432, 5}, {2437, 6},
11090 {2442, 7}, {2447, 8}, {2452, 9},
11091 {2457, 10}, {2462, 11}},
11092 .a_channels = 13,
11093 .a = {{5180, 36},
11094 {5200, 40},
11095 {5220, 44},
11096 {5240, 48},
b0a4e7d8
JL		 11097 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11098 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11099 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11100 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11101 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11102 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11103 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11104 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11105 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11106 },
11107
11108 { /* Custom Japan */
11109 "ZZC",
11110 .bg_channels = 11,
11111 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11112 {2427, 4}, {2432, 5}, {2437, 6},
11113 {2442, 7}, {2447, 8}, {2452, 9},
11114 {2457, 10}, {2462, 11}},
11115 .a_channels = 4,
11116 .a = {{5170, 34}, {5190, 38},
11117 {5210, 42}, {5230, 46}},
11118 },
11119
11120 { /* Custom */
11121 "ZZM",
11122 .bg_channels = 11,
11123 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11124 {2427, 4}, {2432, 5}, {2437, 6},
11125 {2442, 7}, {2447, 8}, {2452, 9},
11126 {2457, 10}, {2462, 11}},
11127 },
11128
11129 { /* Europe */
11130 "ZZE",
11131 .bg_channels = 13,
11132 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11133 {2427, 4}, {2432, 5}, {2437, 6},
11134 {2442, 7}, {2447, 8}, {2452, 9},
11135 {2457, 10}, {2462, 11}, {2467, 12},
11136 {2472, 13}},
11137 .a_channels = 19,
11138 .a = {{5180, 36},
11139 {5200, 40},
11140 {5220, 44},
11141 {5240, 48},
b0a4e7d8
JL		 11142 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11143 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11144 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11145 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11146 {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11147 {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11148 {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11149 {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11150 {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11151 {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11152 {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11153 {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11154 {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11155 {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11156 {5700, 140, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11157 },
11158
11159 { /* Custom Japan */
11160 "ZZJ",
11161 .bg_channels = 14,
11162 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11163 {2427, 4}, {2432, 5}, {2437, 6},
11164 {2442, 7}, {2447, 8}, {2452, 9},
11165 {2457, 10}, {2462, 11}, {2467, 12},
b0a4e7d8 11166 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY}},
4f36f808
JK		 11167 .a_channels = 4,
11168 .a = {{5170, 34}, {5190, 38},
11169 {5210, 42}, {5230, 46}},
11170 },
11171
03520576
JK		 11172 { /* Rest of World */
11173 "ZZR",
11174 .bg_channels = 14,
11175 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11176 {2427, 4}, {2432, 5}, {2437, 6},
11177 {2442, 7}, {2447, 8}, {2452, 9},
11178 {2457, 10}, {2462, 11}, {2467, 12},
b0a4e7d8
JL		 11179 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY |
11180 LIBIPW_CH_PASSIVE_ONLY}},
03520576
JK		 11181 },
11182
4f36f808
JK		 11183 { /* High Band */
11184 "ZZH",
11185 .bg_channels = 13,
11186 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11187 {2427, 4}, {2432, 5}, {2437, 6},
11188 {2442, 7}, {2447, 8}, {2452, 9},
11189 {2457, 10}, {2462, 11},
b0a4e7d8
JL		 11190 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11191 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11192 .a_channels = 4,
11193 .a = {{5745, 149}, {5765, 153},
11194 {5785, 157}, {5805, 161}},
11195 },
11196
11197 { /* Custom Europe */
11198 "ZZG",
11199 .bg_channels = 13,
11200 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11201 {2427, 4}, {2432, 5}, {2437, 6},
11202 {2442, 7}, {2447, 8}, {2452, 9},
11203 {2457, 10}, {2462, 11},
11204 {2467, 12}, {2472, 13}},
11205 .a_channels = 4,
11206 .a = {{5180, 36}, {5200, 40},
11207 {5220, 44}, {5240, 48}},
11208 },
11209
11210 { /* Europe */
11211 "ZZK",
11212 .bg_channels = 13,
11213 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11214 {2427, 4}, {2432, 5}, {2437, 6},
11215 {2442, 7}, {2447, 8}, {2452, 9},
11216 {2457, 10}, {2462, 11},
b0a4e7d8
JL		 11217 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11218 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808 11219 .a_channels = 24,
b0a4e7d8
JL		 11220 .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11221 {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11222 {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11223 {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11224 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11225 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11226 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11227 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11228 {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11229 {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11230 {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11231 {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11232 {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11233 {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11234 {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11235 {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11236 {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11237 {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11238 {5700, 140, LIBIPW_CH_PASSIVE_ONLY},
11239 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11240 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11241 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11242 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11243 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11244 },
11245
11246 { /* Europe */
11247 "ZZL",
11248 .bg_channels = 11,
11249 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11250 {2427, 4}, {2432, 5}, {2437, 6},
11251 {2442, 7}, {2447, 8}, {2452, 9},
11252 {2457, 10}, {2462, 11}},
11253 .a_channels = 13,
b0a4e7d8
JL		 11254 .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11255 {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11256 {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11257 {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11258 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11259 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11260 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11261 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11262 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11263 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11264 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11265 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11266 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808 11267 }
afbf30a2
JK		 11268};
11269
43f66a6c
JK		 11270#define MAX_HW_RESTARTS 5
11271static int ipw_up(struct ipw_priv *priv)
11272{
4f36f808 11273 int rc, i, j;
43f66a6c 11274
c3d72b96
DW		 11275 /* Age scan list entries found before suspend */
11276 if (priv->suspend_time) {
b0a4e7d8 11277 libipw_networks_age(priv->ieee, priv->suspend_time);
c3d72b96
DW		 11278 priv->suspend_time = 0;
11279 }
11280
43f66a6c
JK		 11281 if (priv->status & STATUS_EXIT_PENDING)
11282 return -EIO;
11283
f6c5cb7c 11284 if (cmdlog && !priv->cmdlog) {
e6e3f12a 11285 priv->cmdlog = kcalloc(cmdlog, sizeof(*priv->cmdlog),
f6c5cb7c
JK		 11286 GFP_KERNEL);
11287 if (priv->cmdlog == NULL) {
11288 IPW_ERROR("Error allocating %d command log entries.\n",
11289 cmdlog);
d0b526b7 11290 return -ENOMEM;
f6c5cb7c 11291 } else {
f6c5cb7c
JK		 11292 priv->cmdlog_len = cmdlog;
11293 }
11294 }
11295
0edd5b44 11296 for (i = 0; i < MAX_HW_RESTARTS; i++) {
bf79451e 11297 /* Load the microcode, firmware, and eeprom.
43f66a6c
JK		 11298 * Also start the clocks. */
11299 rc = ipw_load(priv);
11300 if (rc) {
a4f6bbb3 11301 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 11302 return rc;
11303 }
11304
11305 ipw_init_ordinals(priv);
11306 if (!(priv->config & CFG_CUSTOM_MAC))
11307 eeprom_parse_mac(priv, priv->mac_addr);
11308 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
5e5eab5d 11309 memcpy(priv->net_dev->perm_addr, priv->mac_addr, ETH_ALEN);
43f66a6c 11310
4f36f808
JK		 11311 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
11312 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11313 ipw_geos[j].name, 3))
11314 break;
11315 }
03520576
JK		 11316 if (j == ARRAY_SIZE(ipw_geos)) {
11317 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
11318 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
11319 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
11320 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
4f36f808 11321 j = 0;
03520576 11322 }
b0a4e7d8 11323 if (libipw_set_geo(priv->ieee, &ipw_geos[j])) {
4f36f808
JK		 11324 IPW_WARNING("Could not set geography.");
11325 return 0;
11326 }
11327
b095c381
JK		 11328 if (priv->status & STATUS_RF_KILL_SW) {
11329 IPW_WARNING("Radio disabled by module parameter.\n");
11330 return 0;
11331 } else if (rf_kill_active(priv)) {
11332 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
11333 "Kill switch must be turned off for "
11334 "wireless networking to work.\n");
11335 queue_delayed_work(priv->workqueue, &priv->rf_kill,
11336 2 * HZ);
43f66a6c 11337 return 0;
c848d0af 11338 }
43f66a6c
JK		 11339
11340 rc = ipw_config(priv);
11341 if (!rc) {
11342 IPW_DEBUG_INFO("Configured device on count %i\n", i);
e666619e
JK		 11343
11344 /* If configure to try and auto-associate, kick
11345 * off a scan. */
c4028958
DH		 11346 queue_delayed_work(priv->workqueue,
11347 &priv->request_scan, 0);
afbf30a2 11348
43f66a6c 11349 return 0;
43f66a6c 11350 }
bf79451e 11351
c848d0af 11352 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
43f66a6c
JK		 11353 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
11354 i, MAX_HW_RESTARTS);
11355
11356 /* We had an error bringing up the hardware, so take it
11357 * all the way back down so we can try again */
11358 ipw_down(priv);
11359 }
11360
bf79451e 11361 /* tried to restart and config the device for as long as our
43f66a6c 11362 * patience could withstand */
0edd5b44 11363 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
c848d0af 11364
43f66a6c
JK		 11365 return -EIO;
11366}
11367
c4028958 11368static void ipw_bg_up(struct work_struct *work)
c848d0af 11369{
c4028958
DH		 11370 struct ipw_priv *priv =
11371 container_of(work, struct ipw_priv, up);
4644151b 11372 mutex_lock(&priv->mutex);
c4028958 11373 ipw_up(priv);
4644151b 11374 mutex_unlock(&priv->mutex);
c848d0af
JK		 11375}
11376
b095c381 11377static void ipw_deinit(struct ipw_priv *priv)
43f66a6c 11378{
b095c381
JK		 11379 int i;
11380
11381 if (priv->status & STATUS_SCANNING) {
11382 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
11383 ipw_abort_scan(priv);
11384 }
11385
11386 if (priv->status & STATUS_ASSOCIATED) {
11387 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
11388 ipw_disassociate(priv);
11389 }
11390
11391 ipw_led_shutdown(priv);
11392
11393 /* Wait up to 1s for status to change to not scanning and not
11394 * associated (disassociation can take a while for a ful 802.11
11395 * exchange */
11396 for (i = 1000; i && (priv->status &
11397 (STATUS_DISASSOCIATING |
11398 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11399 udelay(10);
11400
11401 if (priv->status & (STATUS_DISASSOCIATING |
11402 STATUS_ASSOCIATED | STATUS_SCANNING))
11403 IPW_DEBUG_INFO("Still associated or scanning...\n");
11404 else
11405 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11406
43f66a6c 11407 /* Attempt to disable the card */
43f66a6c 11408 ipw_send_card_disable(priv, 0);
b095c381
JK		 11409
11410 priv->status &= ~STATUS_INIT;
11411}
11412
11413static void ipw_down(struct ipw_priv *priv)
11414{
11415 int exit_pending = priv->status & STATUS_EXIT_PENDING;
11416
11417 priv->status |= STATUS_EXIT_PENDING;
11418
11419 if (ipw_is_init(priv))
11420 ipw_deinit(priv);
11421
11422 /* Wipe out the EXIT_PENDING status bit if we are not actually
11423 * exiting the module */
11424 if (!exit_pending)
11425 priv->status &= ~STATUS_EXIT_PENDING;
43f66a6c
JK		 11426
11427 /* tell the device to stop sending interrupts */
11428 ipw_disable_interrupts(priv);
11429
11430 /* Clear all bits but the RF Kill */
b095c381 11431 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
43f66a6c 11432 netif_carrier_off(priv->net_dev);
43f66a6c
JK		 11433
11434 ipw_stop_nic(priv);
a613bffd
JK		 11435
11436 ipw_led_radio_off(priv);
43f66a6c
JK		 11437}
11438
c4028958 11439static void ipw_bg_down(struct work_struct *work)
c848d0af 11440{
c4028958
DH		 11441 struct ipw_priv *priv =
11442 container_of(work, struct ipw_priv, down);
4644151b 11443 mutex_lock(&priv->mutex);
c4028958 11444 ipw_down(priv);
4644151b 11445 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11446}
11447
11448/* Called by register_netdev() */
11449static int ipw_net_init(struct net_device *dev)
11450{
a3caa99e 11451 int i, rc = 0;
b0a4e7d8 11452 struct ipw_priv *priv = libipw_priv(dev);
a3caa99e
JL		 11453 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
11454 struct wireless_dev *wdev = &priv->ieee->wdev;
4644151b 11455 mutex_lock(&priv->mutex);
43f66a6c 11456
c848d0af 11457 if (ipw_up(priv)) {
a3caa99e
JL		 11458 rc = -EIO;
11459 goto out;
b8ecd988
JL		 11460 }
11461
a3caa99e
JL		 11462 memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
11463
11464 /* fill-out priv->ieee->bg_band */
11465 if (geo->bg_channels) {
11466 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
11467
11468 bg_band->band = IEEE80211_BAND_2GHZ;
11469 bg_band->n_channels = geo->bg_channels;
baeb2ffa
JP		 11470 bg_band->channels = kcalloc(geo->bg_channels,
11471 sizeof(struct ieee80211_channel),
11472 GFP_KERNEL);
a3caa99e
JL		 11473 /* translate geo->bg to bg_band.channels */
11474 for (i = 0; i < geo->bg_channels; i++) {
11475 bg_band->channels[i].band = IEEE80211_BAND_2GHZ;
11476 bg_band->channels[i].center_freq = geo->bg[i].freq;
11477 bg_band->channels[i].hw_value = geo->bg[i].channel;
11478 bg_band->channels[i].max_power = geo->bg[i].max_power;
11479 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11480 bg_band->channels[i].flags |=
11481 IEEE80211_CHAN_PASSIVE_SCAN;
11482 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
11483 bg_band->channels[i].flags |=
11484 IEEE80211_CHAN_NO_IBSS;
11485 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
11486 bg_band->channels[i].flags |=
11487 IEEE80211_CHAN_RADAR;
11488 /* No equivalent for LIBIPW_CH_80211H_RULES,
11489 LIBIPW_CH_UNIFORM_SPREADING, or
11490 LIBIPW_CH_B_ONLY... */
11491 }
11492 /* point at bitrate info */
11493 bg_band->bitrates = ipw2200_bg_rates;
11494 bg_band->n_bitrates = ipw2200_num_bg_rates;
11495
11496 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = bg_band;
b8ecd988
JL		 11497 }
11498
a3caa99e
JL		 11499 /* fill-out priv->ieee->a_band */
11500 if (geo->a_channels) {
11501 struct ieee80211_supported_band *a_band = &priv->ieee->a_band;
11502
11503 a_band->band = IEEE80211_BAND_5GHZ;
11504 a_band->n_channels = geo->a_channels;
baeb2ffa
JP		 11505 a_band->channels = kcalloc(geo->a_channels,
11506 sizeof(struct ieee80211_channel),
11507 GFP_KERNEL);
a3caa99e
JL		 11508 /* translate geo->bg to a_band.channels */
11509 for (i = 0; i < geo->a_channels; i++) {
11510 a_band->channels[i].band = IEEE80211_BAND_2GHZ;
11511 a_band->channels[i].center_freq = geo->a[i].freq;
11512 a_band->channels[i].hw_value = geo->a[i].channel;
11513 a_band->channels[i].max_power = geo->a[i].max_power;
11514 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11515 a_band->channels[i].flags |=
11516 IEEE80211_CHAN_PASSIVE_SCAN;
11517 if (geo->a[i].flags & LIBIPW_CH_NO_IBSS)
11518 a_band->channels[i].flags |=
11519 IEEE80211_CHAN_NO_IBSS;
11520 if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)
11521 a_band->channels[i].flags |=
11522 IEEE80211_CHAN_RADAR;
11523 /* No equivalent for LIBIPW_CH_80211H_RULES,
11524 LIBIPW_CH_UNIFORM_SPREADING, or
11525 LIBIPW_CH_B_ONLY... */
11526 }
11527 /* point at bitrate info */
11528 a_band->bitrates = ipw2200_a_rates;
11529 a_band->n_bitrates = ipw2200_num_a_rates;
11530
11531 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = a_band;
11532 }
11533
11534 set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
11535
11536 /* With that information in place, we can now register the wiphy... */
11537 if (wiphy_register(wdev->wiphy)) {
11538 rc = -EIO;
11539 goto out;
11540 }
11541
11542out:
4644151b 11543 mutex_unlock(&priv->mutex);
a3caa99e 11544 return rc;
43f66a6c
JK		 11545}
11546
11547/* PCI driver stuff */
a3aa1884 11548static DEFINE_PCI_DEVICE_TABLE(card_ids) = {
43f66a6c
JK		 11549 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
11550 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
11551 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
11552 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
11553 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
11554 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
11555 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
11556 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
11557 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
11558 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
11559 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
11560 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
11561 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
11562 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
11563 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
11564 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
11565 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
8ab0ea77
JP		 11566 {PCI_VDEVICE(INTEL, 0x104f), 0},
11567 {PCI_VDEVICE(INTEL, 0x4220), 0}, /* BG */
11568 {PCI_VDEVICE(INTEL, 0x4221), 0}, /* BG */
11569 {PCI_VDEVICE(INTEL, 0x4223), 0}, /* ABG */
11570 {PCI_VDEVICE(INTEL, 0x4224), 0}, /* ABG */
bf79451e 11571
43f66a6c
JK		 11572 /* required last entry */
11573 {0,}
11574};
11575
11576MODULE_DEVICE_TABLE(pci, card_ids);
11577
11578static struct attribute *ipw_sysfs_entries[] = {
11579 &dev_attr_rf_kill.attr,
11580 &dev_attr_direct_dword.attr,
11581 &dev_attr_indirect_byte.attr,
11582 &dev_attr_indirect_dword.attr,
11583 &dev_attr_mem_gpio_reg.attr,
11584 &dev_attr_command_event_reg.attr,
11585 &dev_attr_nic_type.attr,
11586 &dev_attr_status.attr,
11587 &dev_attr_cfg.attr,
b39860c6
JK		 11588 &dev_attr_error.attr,
11589 &dev_attr_event_log.attr,
f6c5cb7c 11590 &dev_attr_cmd_log.attr,
43f66a6c
JK		 11591 &dev_attr_eeprom_delay.attr,
11592 &dev_attr_ucode_version.attr,
11593 &dev_attr_rtc.attr,
a613bffd
JK		 11594 &dev_attr_scan_age.attr,
11595 &dev_attr_led.attr,
b095c381
JK		 11596 &dev_attr_speed_scan.attr,
11597 &dev_attr_net_stats.attr,
375dd244 11598 &dev_attr_channels.attr,
d685b8c2
ZY		 11599#ifdef CONFIG_IPW2200_PROMISCUOUS
11600 &dev_attr_rtap_iface.attr,
11601 &dev_attr_rtap_filter.attr,
11602#endif
43f66a6c
JK		 11603 NULL
11604};
11605
11606static struct attribute_group ipw_attribute_group = {
11607 .name = NULL, /* put in device directory */
0edd5b44 11608 .attrs = ipw_sysfs_entries,
43f66a6c
JK		 11609};
11610
d685b8c2
ZY		 11611#ifdef CONFIG_IPW2200_PROMISCUOUS
11612static int ipw_prom_open(struct net_device *dev)
11613{
b0a4e7d8 11614 struct ipw_prom_priv *prom_priv = libipw_priv(dev);
d685b8c2
ZY		 11615 struct ipw_priv *priv = prom_priv->priv;
11616
11617 IPW_DEBUG_INFO("prom dev->open\n");
11618 netif_carrier_off(dev);
d685b8c2
ZY		 11619
11620 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11621 priv->sys_config.accept_all_data_frames = 1;
11622 priv->sys_config.accept_non_directed_frames = 1;
11623 priv->sys_config.accept_all_mgmt_bcpr = 1;
11624 priv->sys_config.accept_all_mgmt_frames = 1;
11625
11626 ipw_send_system_config(priv);
11627 }
11628
11629 return 0;
11630}
11631
11632static int ipw_prom_stop(struct net_device *dev)
11633{
b0a4e7d8 11634 struct ipw_prom_priv *prom_priv = libipw_priv(dev);
d685b8c2
ZY		 11635 struct ipw_priv *priv = prom_priv->priv;
11636
11637 IPW_DEBUG_INFO("prom dev->stop\n");
11638
11639 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11640 priv->sys_config.accept_all_data_frames = 0;
11641 priv->sys_config.accept_non_directed_frames = 0;
11642 priv->sys_config.accept_all_mgmt_bcpr = 0;
11643 priv->sys_config.accept_all_mgmt_frames = 0;
11644
11645 ipw_send_system_config(priv);
11646 }
11647
11648 return 0;
11649}
11650
d0cf9c0d
SH		 11651static netdev_tx_t ipw_prom_hard_start_xmit(struct sk_buff *skb,
11652 struct net_device *dev)
d685b8c2
ZY		 11653{
11654 IPW_DEBUG_INFO("prom dev->xmit\n");
4153e775
PM		 11655 dev_kfree_skb(skb);
11656 return NETDEV_TX_OK;
d685b8c2
ZY		 11657}
11658
44e9ad0b
SH		 11659static const struct net_device_ops ipw_prom_netdev_ops = {
11660 .ndo_open = ipw_prom_open,
11661 .ndo_stop = ipw_prom_stop,
11662 .ndo_start_xmit = ipw_prom_hard_start_xmit,
b0a4e7d8 11663 .ndo_change_mtu = libipw_change_mtu,
44e9ad0b
SH		 11664 .ndo_set_mac_address = eth_mac_addr,
11665 .ndo_validate_addr = eth_validate_addr,
11666};
11667
d685b8c2
ZY		 11668static int ipw_prom_alloc(struct ipw_priv *priv)
11669{
11670 int rc = 0;
11671
11672 if (priv->prom_net_dev)
11673 return -EPERM;
11674
27ae60f8 11675 priv->prom_net_dev = alloc_libipw(sizeof(struct ipw_prom_priv), 1);
d685b8c2
ZY		 11676 if (priv->prom_net_dev == NULL)
11677 return -ENOMEM;
11678
b0a4e7d8 11679 priv->prom_priv = libipw_priv(priv->prom_net_dev);
d685b8c2
ZY		 11680 priv->prom_priv->ieee = netdev_priv(priv->prom_net_dev);
11681 priv->prom_priv->priv = priv;
11682
11683 strcpy(priv->prom_net_dev->name, "rtap%d");
3f2eeac9 11684 memcpy(priv->prom_net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
d685b8c2
ZY		 11685
11686 priv->prom_net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
44e9ad0b 11687 priv->prom_net_dev->netdev_ops = &ipw_prom_netdev_ops;
d685b8c2
ZY		 11688
11689 priv->prom_priv->ieee->iw_mode = IW_MODE_MONITOR;
229ce3ab 11690 SET_NETDEV_DEV(priv->prom_net_dev, &priv->pci_dev->dev);
d685b8c2
ZY		 11691
11692 rc = register_netdev(priv->prom_net_dev);
11693 if (rc) {
27ae60f8 11694 free_libipw(priv->prom_net_dev, 1);
d685b8c2
ZY		 11695 priv->prom_net_dev = NULL;
11696 return rc;
11697 }
11698
11699 return 0;
11700}
11701
11702static void ipw_prom_free(struct ipw_priv *priv)
11703{
11704 if (!priv->prom_net_dev)
11705 return;
11706
11707 unregister_netdev(priv->prom_net_dev);
27ae60f8 11708 free_libipw(priv->prom_net_dev, 1);
d685b8c2
ZY		 11709
11710 priv->prom_net_dev = NULL;
11711}
11712
11713#endif
11714
44e9ad0b
SH		 11715static const struct net_device_ops ipw_netdev_ops = {
11716 .ndo_init = ipw_net_init,
11717 .ndo_open = ipw_net_open,
11718 .ndo_stop = ipw_net_stop,
11719 .ndo_set_multicast_list = ipw_net_set_multicast_list,
11720 .ndo_set_mac_address = ipw_net_set_mac_address,
b0a4e7d8
JL		 11721 .ndo_start_xmit = libipw_xmit,
11722 .ndo_change_mtu = libipw_change_mtu,
44e9ad0b
SH		 11723 .ndo_validate_addr = eth_validate_addr,
11724};
d685b8c2 11725
2ef19e63
AB		 11726static int __devinit ipw_pci_probe(struct pci_dev *pdev,
11727 const struct pci_device_id *ent)
43f66a6c
JK		 11728{
11729 int err = 0;
11730 struct net_device *net_dev;
11731 void __iomem *base;
11732 u32 length, val;
11733 struct ipw_priv *priv;
afbf30a2 11734 int i;
43f66a6c 11735
27ae60f8 11736 net_dev = alloc_libipw(sizeof(struct ipw_priv), 0);
43f66a6c
JK		 11737 if (net_dev == NULL) {
11738 err = -ENOMEM;
11739 goto out;
11740 }
11741
b0a4e7d8 11742 priv = libipw_priv(net_dev);
43f66a6c 11743 priv->ieee = netdev_priv(net_dev);
a613bffd 11744
43f66a6c
JK		 11745 priv->net_dev = net_dev;
11746 priv->pci_dev = pdev;
43f66a6c 11747 ipw_debug_level = debug;
89c318ed 11748 spin_lock_init(&priv->irq_lock);
43f66a6c 11749 spin_lock_init(&priv->lock);
afbf30a2
JK		 11750 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11751 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
43f66a6c 11752
4644151b 11753 mutex_init(&priv->mutex);
43f66a6c
JK		 11754 if (pci_enable_device(pdev)) {
11755 err = -ENODEV;
27ae60f8 11756 goto out_free_libipw;
43f66a6c
JK		 11757 }
11758
11759 pci_set_master(pdev);
11760
284901a9 11761 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
bf79451e 11762 if (!err)
284901a9 11763 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
43f66a6c
JK		 11764 if (err) {
11765 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11766 goto out_pci_disable_device;
11767 }
11768
11769 pci_set_drvdata(pdev, priv);
11770
11771 err = pci_request_regions(pdev, DRV_NAME);
bf79451e 11772 if (err)
43f66a6c
JK		 11773 goto out_pci_disable_device;
11774
bf79451e 11775 /* We disable the RETRY_TIMEOUT register (0x41) to keep
43f66a6c 11776 * PCI Tx retries from interfering with C3 CPU state */
bf79451e
JG		 11777 pci_read_config_dword(pdev, 0x40, &val);
11778 if ((val & 0x0000ff00) != 0)
43f66a6c 11779 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
bf79451e 11780
43f66a6c
JK		 11781 length = pci_resource_len(pdev, 0);
11782 priv->hw_len = length;
bf79451e 11783
275f165f 11784 base = pci_ioremap_bar(pdev, 0);
43f66a6c
JK		 11785 if (!base) {
11786 err = -ENODEV;
11787 goto out_pci_release_regions;
11788 }
11789
11790 priv->hw_base = base;
11791 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11792 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11793
11794 err = ipw_setup_deferred_work(priv);
11795 if (err) {
11796 IPW_ERROR("Unable to setup deferred work\n");
11797 goto out_iounmap;
11798 }
11799
b095c381 11800 ipw_sw_reset(priv, 1);
43f66a6c 11801
1fb9df5d 11802 err = request_irq(pdev->irq, ipw_isr, IRQF_SHARED, DRV_NAME, priv);
43f66a6c
JK		 11803 if (err) {
11804 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11805 goto out_destroy_workqueue;
11806 }
11807
43f66a6c
JK		 11808 SET_NETDEV_DEV(net_dev, &pdev->dev);
11809
4644151b 11810 mutex_lock(&priv->mutex);
c848d0af 11811
43f66a6c
JK		 11812 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11813 priv->ieee->set_security = shim__set_security;
227d2dc1 11814 priv->ieee->is_queue_full = ipw_net_is_queue_full;
43f66a6c 11815
e43e3c1e 11816#ifdef CONFIG_IPW2200_QOS
a5cf4fe6 11817 priv->ieee->is_qos_active = ipw_is_qos_active;
3b9990cb
JK		 11818 priv->ieee->handle_probe_response = ipw_handle_beacon;
11819 priv->ieee->handle_beacon = ipw_handle_probe_response;
11820 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
e43e3c1e 11821#endif /* CONFIG_IPW2200_QOS */
b095c381 11822
c848d0af
JK		 11823 priv->ieee->perfect_rssi = -20;
11824 priv->ieee->worst_rssi = -85;
43f66a6c 11825
44e9ad0b 11826 net_dev->netdev_ops = &ipw_netdev_ops;
97a78ca9 11827 priv->wireless_data.spy_data = &priv->ieee->spy_data;
97a78ca9 11828 net_dev->wireless_data = &priv->wireless_data;
43f66a6c
JK		 11829 net_dev->wireless_handlers = &ipw_wx_handler_def;
11830 net_dev->ethtool_ops = &ipw_ethtool_ops;
11831 net_dev->irq = pdev->irq;
0edd5b44 11832 net_dev->base_addr = (unsigned long)priv->hw_base;
43f66a6c
JK		 11833 net_dev->mem_start = pci_resource_start(pdev, 0);
11834 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11835
11836 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11837 if (err) {
11838 IPW_ERROR("failed to create sysfs device attributes\n");
4644151b 11839 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11840 goto out_release_irq;
11841 }
11842
4644151b 11843 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11844 err = register_netdev(net_dev);
11845 if (err) {
11846 IPW_ERROR("failed to register network device\n");
a613bffd 11847 goto out_remove_sysfs;
43f66a6c 11848 }
48a84770 11849
d685b8c2
ZY		 11850#ifdef CONFIG_IPW2200_PROMISCUOUS
11851 if (rtap_iface) {
11852 err = ipw_prom_alloc(priv);
11853 if (err) {
11854 IPW_ERROR("Failed to register promiscuous network "
11855 "device (error %d).\n", err);
11856 unregister_netdev(priv->net_dev);
11857 goto out_remove_sysfs;
11858 }
11859 }
11860#endif
11861
48a84770
HBA		 11862 printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
11863 "channels, %d 802.11a channels)\n",
11864 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
11865 priv->ieee->geo.a_channels);
11866
43f66a6c
JK		 11867 return 0;
11868
a613bffd 11869 out_remove_sysfs:
43f66a6c 11870 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
0edd5b44 11871 out_release_irq:
43f66a6c 11872 free_irq(pdev->irq, priv);
0edd5b44 11873 out_destroy_workqueue:
43f66a6c
JK		 11874 destroy_workqueue(priv->workqueue);
11875 priv->workqueue = NULL;
0edd5b44 11876 out_iounmap:
43f66a6c 11877 iounmap(priv->hw_base);
0edd5b44 11878 out_pci_release_regions:
43f66a6c 11879 pci_release_regions(pdev);
0edd5b44 11880 out_pci_disable_device:
43f66a6c
JK		 11881 pci_disable_device(pdev);
11882 pci_set_drvdata(pdev, NULL);
27ae60f8
PR		 11883 out_free_libipw:
11884 free_libipw(priv->net_dev, 0);
0edd5b44 11885 out:
43f66a6c
JK		 11886 return err;
11887}
11888
2ef19e63 11889static void __devexit ipw_pci_remove(struct pci_dev *pdev)
43f66a6c
JK		 11890{
11891 struct ipw_priv *priv = pci_get_drvdata(pdev);
afbf30a2
JK		 11892 struct list_head *p, *q;
11893 int i;
b095c381 11894
43f66a6c
JK		 11895 if (!priv)
11896 return;
11897
4644151b 11898 mutex_lock(&priv->mutex);
43f66a6c 11899
afbf30a2 11900 priv->status |= STATUS_EXIT_PENDING;
43f66a6c 11901 ipw_down(priv);
43f66a6c
JK		 11902 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11903
4644151b 11904 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11905
11906 unregister_netdev(priv->net_dev);
11907
11908 if (priv->rxq) {
11909 ipw_rx_queue_free(priv, priv->rxq);
11910 priv->rxq = NULL;
11911 }
11912 ipw_tx_queue_free(priv);
11913
f6c5cb7c
JK		 11914 if (priv->cmdlog) {
11915 kfree(priv->cmdlog);
11916 priv->cmdlog = NULL;
11917 }
43f66a6c
JK		 11918 /* ipw_down will ensure that there is no more pending work
11919 * in the workqueue's, so we can safely remove them now. */
a613bffd
JK		 11920 cancel_delayed_work(&priv->adhoc_check);
11921 cancel_delayed_work(&priv->gather_stats);
11922 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 11923 cancel_delayed_work(&priv->request_direct_scan);
11924 cancel_delayed_work(&priv->request_passive_scan);
0b531676 11925 cancel_delayed_work(&priv->scan_event);
a613bffd
JK		 11926 cancel_delayed_work(&priv->rf_kill);
11927 cancel_delayed_work(&priv->scan_check);
11928 destroy_workqueue(priv->workqueue);
11929 priv->workqueue = NULL;
43f66a6c 11930
afbf30a2
JK		 11931 /* Free MAC hash list for ADHOC */
11932 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11933 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
afbf30a2 11934 list_del(p);
489f4458 11935 kfree(list_entry(p, struct ipw_ibss_seq, list));
afbf30a2
JK		 11936 }
11937 }
11938
8f760780
JJ		 11939 kfree(priv->error);
11940 priv->error = NULL;
43f66a6c 11941
d685b8c2
ZY		 11942#ifdef CONFIG_IPW2200_PROMISCUOUS
11943 ipw_prom_free(priv);
11944#endif
11945
43f66a6c
JK		 11946 free_irq(pdev->irq, priv);
11947 iounmap(priv->hw_base);
11948 pci_release_regions(pdev);
11949 pci_disable_device(pdev);
11950 pci_set_drvdata(pdev, NULL);
27ae60f8 11951 /* wiphy_unregister needs to be here, before free_libipw */
a3caa99e
JL		 11952 wiphy_unregister(priv->ieee->wdev.wiphy);
11953 kfree(priv->ieee->a_band.channels);
11954 kfree(priv->ieee->bg_band.channels);
27ae60f8 11955 free_libipw(priv->net_dev, 0);
afbf30a2 11956 free_firmware();
43f66a6c
JK		 11957}
11958
43f66a6c 11959#ifdef CONFIG_PM
583a4e88 11960static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
43f66a6c
JK		 11961{
11962 struct ipw_priv *priv = pci_get_drvdata(pdev);
11963 struct net_device *dev = priv->net_dev;
11964
11965 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11966
0edd5b44 11967 /* Take down the device; powers it off, etc. */
43f66a6c
JK		 11968 ipw_down(priv);
11969
11970 /* Remove the PRESENT state of the device */
11971 netif_device_detach(dev);
11972
43f66a6c 11973 pci_save_state(pdev);
43f66a6c 11974 pci_disable_device(pdev);
583a4e88 11975 pci_set_power_state(pdev, pci_choose_state(pdev, state));
bf79451e 11976
c3d72b96
DW		 11977 priv->suspend_at = get_seconds();
11978
43f66a6c
JK		 11979 return 0;
11980}
11981
11982static int ipw_pci_resume(struct pci_dev *pdev)
11983{
11984 struct ipw_priv *priv = pci_get_drvdata(pdev);
11985 struct net_device *dev = priv->net_dev;
02e0e5e9 11986 int err;
43f66a6c 11987 u32 val;
bf79451e 11988
43f66a6c
JK		 11989 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11990
ea2b26e0 11991 pci_set_power_state(pdev, PCI_D0);
02e0e5e9
JL		 11992 err = pci_enable_device(pdev);
11993 if (err) {
11994 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
11995 dev->name);
11996 return err;
11997 }
43f66a6c 11998 pci_restore_state(pdev);
ea2b26e0 11999
43f66a6c
JK		 12000 /*
12001 * Suspend/Resume resets the PCI configuration space, so we have to
12002 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
12003 * from interfering with C3 CPU state. pci_restore_state won't help
12004 * here since it only restores the first 64 bytes pci config header.
12005 */
bf79451e
JG		 12006 pci_read_config_dword(pdev, 0x40, &val);
12007 if ((val & 0x0000ff00) != 0)
43f66a6c
JK		 12008 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
12009
12010 /* Set the device back into the PRESENT state; this will also wake
12011 * the queue of needed */
12012 netif_device_attach(dev);
12013
c3d72b96
DW		 12014 priv->suspend_time = get_seconds() - priv->suspend_at;
12015
43f66a6c
JK		 12016 /* Bring the device back up */
12017 queue_work(priv->workqueue, &priv->up);
bf79451e 12018
43f66a6c
JK		 12019 return 0;
12020}
12021#endif
12022
c8c22c94
ZY		 12023static void ipw_pci_shutdown(struct pci_dev *pdev)
12024{
12025 struct ipw_priv *priv = pci_get_drvdata(pdev);
12026
12027 /* Take down the device; powers it off, etc. */
12028 ipw_down(priv);
12029
12030 pci_disable_device(pdev);
12031}
12032
43f66a6c
JK		 12033/* driver initialization stuff */
12034static struct pci_driver ipw_driver = {
12035 .name = DRV_NAME,
12036 .id_table = card_ids,
12037 .probe = ipw_pci_probe,
12038 .remove = __devexit_p(ipw_pci_remove),
12039#ifdef CONFIG_PM
12040 .suspend = ipw_pci_suspend,
12041 .resume = ipw_pci_resume,
12042#endif
c8c22c94 12043 .shutdown = ipw_pci_shutdown,
43f66a6c
JK		 12044};
12045
12046static int __init ipw_init(void)
12047{
12048 int ret;
12049
12050 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
12051 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
12052
29917620 12053 ret = pci_register_driver(&ipw_driver);
43f66a6c
JK		 12054 if (ret) {
12055 IPW_ERROR("Unable to initialize PCI module\n");
12056 return ret;
12057 }
12058
0edd5b44 12059 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
43f66a6c
JK		 12060 if (ret) {
12061 IPW_ERROR("Unable to create driver sysfs file\n");
12062 pci_unregister_driver(&ipw_driver);
12063 return ret;
12064 }
12065
12066 return ret;
12067}
12068
12069static void __exit ipw_exit(void)
12070{
12071 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
12072 pci_unregister_driver(&ipw_driver);
12073}
12074
12075module_param(disable, int, 0444);
12076MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
12077
12078module_param(associate, int, 0444);
5c7f9b73 12079MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
43f66a6c
JK		 12080
12081module_param(auto_create, int, 0444);
12082MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
12083
21f8a73f 12084module_param_named(led, led_support, int, 0444);
c086abae 12085MODULE_PARM_DESC(led, "enable led control on some systems (default 1 on)");
a613bffd 12086
43f66a6c
JK		 12087module_param(debug, int, 0444);
12088MODULE_PARM_DESC(debug, "debug output mask");
12089
21f8a73f 12090module_param_named(channel, default_channel, int, 0444);
bf79451e 12091MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
43f66a6c 12092
d685b8c2
ZY		 12093#ifdef CONFIG_IPW2200_PROMISCUOUS
12094module_param(rtap_iface, int, 0444);
12095MODULE_PARM_DESC(rtap_iface, "create the rtap interface (1 - create, default 0)");
12096#endif
12097
e43e3c1e 12098#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 12099module_param(qos_enable, int, 0444);
12100MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
12101
12102module_param(qos_burst_enable, int, 0444);
12103MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
12104
12105module_param(qos_no_ack_mask, int, 0444);
12106MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
43f66a6c 12107
b095c381
JK		 12108module_param(burst_duration_CCK, int, 0444);
12109MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
12110
12111module_param(burst_duration_OFDM, int, 0444);
12112MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
e43e3c1e 12113#endif /* CONFIG_IPW2200_QOS */
b095c381
JK		 12114
12115#ifdef CONFIG_IPW2200_MONITOR
21f8a73f 12116module_param_named(mode, network_mode, int, 0444);
43f66a6c
JK		 12117MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
12118#else
21f8a73f 12119module_param_named(mode, network_mode, int, 0444);
43f66a6c
JK		 12120MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
12121#endif
12122
810dabd4
ZY		 12123module_param(bt_coexist, int, 0444);
12124MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
12125
b095c381 12126module_param(hwcrypto, int, 0444);
bde37d03 12127MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
b095c381 12128
f6c5cb7c
JK		 12129module_param(cmdlog, int, 0444);
12130MODULE_PARM_DESC(cmdlog,
12131 "allocate a ring buffer for logging firmware commands");
12132
4bfdb91d
ZY		 12133module_param(roaming, int, 0444);
12134MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
12135
d2b83e12
ZY		 12136module_param(antenna, int, 0444);
12137MODULE_PARM_DESC(antenna, "select antenna 1=Main, 3=Aux, default 0 [both], 2=slow_diversity (choose the one with lower background noise)");
12138
43f66a6c
JK		 12139module_exit(ipw_exit);
12140module_init(ipw_init);
Clone of davem's net-next-2.6 tree