]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/net/wireless/ipw2x00/ipw2200.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drivers/net/wireless/b43: Use kmemdup
[mirror_ubuntu-bionic-kernel.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;
21f8a73f 99static int led_support = 0;
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
JK		 6626 if (wrqu->data.length) {
6627 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6628 if (buf == NULL) {
6629 err = -ENOMEM;
6630 goto out;
6631 }
6632
6633 memcpy(buf, extra, wrqu->data.length);
6634 kfree(ieee->wpa_ie);
6635 ieee->wpa_ie = buf;
6636 ieee->wpa_ie_len = wrqu->data.length;
b095c381 6637 } else {
afbf30a2
JK		 6638 kfree(ieee->wpa_ie);
6639 ieee->wpa_ie = NULL;
6640 ieee->wpa_ie_len = 0;
ea2b26e0 6641 }
afbf30a2
JK		 6642
6643 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6644 out:
afbf30a2
JK		 6645 return err;
6646}
6647
6648/* SIOCGIWGENIE */
6649static int ipw_wx_get_genie(struct net_device *dev,
6650 struct iw_request_info *info,
6651 union iwreq_data *wrqu, char *extra)
6652{
b0a4e7d8
JL		 6653 struct ipw_priv *priv = libipw_priv(dev);
6654 struct libipw_device *ieee = priv->ieee;
afbf30a2
JK		 6655 int err = 0;
6656
afbf30a2
JK		 6657 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6658 wrqu->data.length = 0;
6659 goto out;
6660 }
6661
6662 if (wrqu->data.length < ieee->wpa_ie_len) {
6663 err = -E2BIG;
6664 goto out;
6665 }
6666
6667 wrqu->data.length = ieee->wpa_ie_len;
6668 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6669
6670 out:
afbf30a2
JK		 6671 return err;
6672}
6673
1fbfea54
ZY		 6674static int wext_cipher2level(int cipher)
6675{
6676 switch (cipher) {
6677 case IW_AUTH_CIPHER_NONE:
6678 return SEC_LEVEL_0;
6679 case IW_AUTH_CIPHER_WEP40:
6680 case IW_AUTH_CIPHER_WEP104:
6681 return SEC_LEVEL_1;
6682 case IW_AUTH_CIPHER_TKIP:
6683 return SEC_LEVEL_2;
6684 case IW_AUTH_CIPHER_CCMP:
6685 return SEC_LEVEL_3;
6686 default:
6687 return -1;
6688 }
6689}
6690
afbf30a2
JK		 6691/* SIOCSIWAUTH */
6692static int ipw_wx_set_auth(struct net_device *dev,
6693 struct iw_request_info *info,
6694 union iwreq_data *wrqu, char *extra)
6695{
b0a4e7d8
JL		 6696 struct ipw_priv *priv = libipw_priv(dev);
6697 struct libipw_device *ieee = priv->ieee;
afbf30a2 6698 struct iw_param *param = &wrqu->param;
274bfb8d 6699 struct lib80211_crypt_data *crypt;
afbf30a2
JK		 6700 unsigned long flags;
6701 int ret = 0;
6702
6703 switch (param->flags & IW_AUTH_INDEX) {
6704 case IW_AUTH_WPA_VERSION:
1fbfea54 6705 break;
afbf30a2 6706 case IW_AUTH_CIPHER_PAIRWISE:
1fbfea54
ZY		 6707 ipw_set_hw_decrypt_unicast(priv,
6708 wext_cipher2level(param->value));
6709 break;
afbf30a2 6710 case IW_AUTH_CIPHER_GROUP:
1fbfea54
ZY		 6711 ipw_set_hw_decrypt_multicast(priv,
6712 wext_cipher2level(param->value));
6713 break;
afbf30a2
JK		 6714 case IW_AUTH_KEY_MGMT:
6715 /*
6716 * ipw2200 does not use these parameters
6717 */
6718 break;
6719
6720 case IW_AUTH_TKIP_COUNTERMEASURES:
274bfb8d 6721 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
991d1cc5 6722 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
afbf30a2 6723 break;
afbf30a2
JK		 6724
6725 flags = crypt->ops->get_flags(crypt->priv);
6726
6727 if (param->value)
6728 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6729 else
6730 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6731
6732 crypt->ops->set_flags(flags, crypt->priv);
6733
6734 break;
6735
6736 case IW_AUTH_DROP_UNENCRYPTED:{
6737 /* HACK:
6738 *
6739 * wpa_supplicant calls set_wpa_enabled when the driver
6740 * is loaded and unloaded, regardless of if WPA is being
6741 * used. No other calls are made which can be used to
6742 * determine if encryption will be used or not prior to
6743 * association being expected. If encryption is not being
6744 * used, drop_unencrypted is set to false, else true -- we
6745 * can use this to determine if the CAP_PRIVACY_ON bit should
6746 * be set.
6747 */
b0a4e7d8 6748 struct libipw_security sec = {
afbf30a2
JK		 6749 .flags = SEC_ENABLED,
6750 .enabled = param->value,
6751 };
6752 priv->ieee->drop_unencrypted = param->value;
6753 /* We only change SEC_LEVEL for open mode. Others
6754 * are set by ipw_wpa_set_encryption.
6755 */
6756 if (!param->value) {
6757 sec.flags |= SEC_LEVEL;
6758 sec.level = SEC_LEVEL_0;
6759 } else {
6760 sec.flags |= SEC_LEVEL;
6761 sec.level = SEC_LEVEL_1;
6762 }
6763 if (priv->ieee->set_security)
6764 priv->ieee->set_security(priv->ieee->dev, &sec);
6765 break;
6766 }
6767
6768 case IW_AUTH_80211_AUTH_ALG:
6769 ret = ipw_wpa_set_auth_algs(priv, param->value);
6770 break;
6771
6772 case IW_AUTH_WPA_ENABLED:
6773 ret = ipw_wpa_enable(priv, param->value);
e3c5a64e 6774 ipw_disassociate(priv);
afbf30a2
JK		 6775 break;
6776
6777 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6778 ieee->ieee802_1x = param->value;
6779 break;
6780
afbf30a2
JK		 6781 case IW_AUTH_PRIVACY_INVOKED:
6782 ieee->privacy_invoked = param->value;
6783 break;
6784
6785 default:
6786 return -EOPNOTSUPP;
6787 }
6788 return ret;
6789}
6790
6791/* SIOCGIWAUTH */
6792static int ipw_wx_get_auth(struct net_device *dev,
6793 struct iw_request_info *info,
6794 union iwreq_data *wrqu, char *extra)
6795{
b0a4e7d8
JL		 6796 struct ipw_priv *priv = libipw_priv(dev);
6797 struct libipw_device *ieee = priv->ieee;
274bfb8d 6798 struct lib80211_crypt_data *crypt;
afbf30a2
JK		 6799 struct iw_param *param = &wrqu->param;
6800 int ret = 0;
6801
6802 switch (param->flags & IW_AUTH_INDEX) {
6803 case IW_AUTH_WPA_VERSION:
6804 case IW_AUTH_CIPHER_PAIRWISE:
6805 case IW_AUTH_CIPHER_GROUP:
6806 case IW_AUTH_KEY_MGMT:
6807 /*
6808 * wpa_supplicant will control these internally
6809 */
6810 ret = -EOPNOTSUPP;
6811 break;
6812
6813 case IW_AUTH_TKIP_COUNTERMEASURES:
274bfb8d 6814 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
991d1cc5 6815 if (!crypt || !crypt->ops->get_flags)
afbf30a2 6816 break;
afbf30a2
JK		 6817
6818 param->value = (crypt->ops->get_flags(crypt->priv) &
6819 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6820
6821 break;
6822
6823 case IW_AUTH_DROP_UNENCRYPTED:
6824 param->value = ieee->drop_unencrypted;
6825 break;
6826
6827 case IW_AUTH_80211_AUTH_ALG:
6828 param->value = ieee->sec.auth_mode;
6829 break;
6830
6831 case IW_AUTH_WPA_ENABLED:
6832 param->value = ieee->wpa_enabled;
6833 break;
6834
6835 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6836 param->value = ieee->ieee802_1x;
6837 break;
6838
6839 case IW_AUTH_ROAMING_CONTROL:
6840 case IW_AUTH_PRIVACY_INVOKED:
6841 param->value = ieee->privacy_invoked;
6842 break;
6843
6844 default:
6845 return -EOPNOTSUPP;
6846 }
6847 return 0;
6848}
6849
6850/* SIOCSIWENCODEEXT */
6851static int ipw_wx_set_encodeext(struct net_device *dev,
6852 struct iw_request_info *info,
6853 union iwreq_data *wrqu, char *extra)
6854{
b0a4e7d8 6855 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2
JK		 6856 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6857
6858 if (hwcrypto) {
afbf30a2 6859 if (ext->alg == IW_ENCODE_ALG_TKIP) {
567deaf6
HL		 6860 /* IPW HW can't build TKIP MIC,
6861 host decryption still needed */
6862 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6863 priv->ieee->host_mc_decrypt = 1;
6864 else {
6865 priv->ieee->host_encrypt = 0;
6866 priv->ieee->host_encrypt_msdu = 1;
6867 priv->ieee->host_decrypt = 1;
6868 }
afbf30a2
JK		 6869 } else {
6870 priv->ieee->host_encrypt = 0;
6871 priv->ieee->host_encrypt_msdu = 0;
6872 priv->ieee->host_decrypt = 0;
567deaf6 6873 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 6874 }
6875 }
6876
b0a4e7d8 6877 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
afbf30a2
JK		 6878}
6879
6880/* SIOCGIWENCODEEXT */
6881static int ipw_wx_get_encodeext(struct net_device *dev,
6882 struct iw_request_info *info,
6883 union iwreq_data *wrqu, char *extra)
6884{
b0a4e7d8
JL		 6885 struct ipw_priv *priv = libipw_priv(dev);
6886 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
afbf30a2
JK		 6887}
6888
6889/* SIOCSIWMLME */
6890static int ipw_wx_set_mlme(struct net_device *dev,
6891 struct iw_request_info *info,
6892 union iwreq_data *wrqu, char *extra)
6893{
b0a4e7d8 6894 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 6895 struct iw_mlme *mlme = (struct iw_mlme *)extra;
e62e1ee0 6896 __le16 reason;
afbf30a2
JK		 6897
6898 reason = cpu_to_le16(mlme->reason_code);
6899
6900 switch (mlme->cmd) {
6901 case IW_MLME_DEAUTH:
67fd6b45 6902 /* silently ignore */
afbf30a2
JK		 6903 break;
6904
6905 case IW_MLME_DISASSOC:
6906 ipw_disassociate(priv);
6907 break;
6908
6909 default:
6910 return -EOPNOTSUPP;
6911 }
6912 return 0;
6913}
afbf30a2 6914
e43e3c1e 6915#ifdef CONFIG_IPW2200_QOS
afbf30a2
JK		 6916
6917/* QoS */
6918/*
6919* get the modulation type of the current network or
6920* the card current mode
6921*/
53d0bcf8 6922static u8 ipw_qos_current_mode(struct ipw_priv * priv)
afbf30a2
JK		 6923{
6924 u8 mode = 0;
6925
6926 if (priv->status & STATUS_ASSOCIATED) {
6927 unsigned long flags;
6928
6929 spin_lock_irqsave(&priv->ieee->lock, flags);
6930 mode = priv->assoc_network->mode;
6931 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6932 } else {
6933 mode = priv->ieee->mode;
6934 }
9fd1ea42 6935 IPW_DEBUG_QOS("QoS network/card mode %d\n", mode);
afbf30a2 6936 return mode;
b095c381 6937}
ea2b26e0 6938
b095c381
JK		 6939/*
6940* Handle management frame beacon and probe response
6941*/
3b9990cb
JK		 6942static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6943 int active_network,
b0a4e7d8 6944 struct libipw_network *network)
b095c381 6945{
b0a4e7d8 6946 u32 size = sizeof(struct libipw_qos_parameters);
b095c381 6947
afbf30a2 6948 if (network->capability & WLAN_CAPABILITY_IBSS)
b095c381
JK		 6949 network->qos_data.active = network->qos_data.supported;
6950
6951 if (network->flags & NETWORK_HAS_QOS_MASK) {
afbf30a2
JK		 6952 if (active_network &&
6953 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
b095c381
JK		 6954 network->qos_data.active = network->qos_data.supported;
6955
6956 if ((network->qos_data.active == 1) && (active_network == 1) &&
6957 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6958 (network->qos_data.old_param_count !=
6959 network->qos_data.param_count)) {
6960 network->qos_data.old_param_count =
6961 network->qos_data.param_count;
6962 schedule_work(&priv->qos_activate);
afbf30a2
JK		 6963 IPW_DEBUG_QOS("QoS parameters change call "
6964 "qos_activate\n");
b095c381 6965 }
ea2b26e0 6966 } else {
afbf30a2
JK		 6967 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6968 memcpy(&network->qos_data.parameters,
b095c381 6969 &def_parameters_CCK, size);
afbf30a2
JK		 6970 else
6971 memcpy(&network->qos_data.parameters,
b095c381 6972 &def_parameters_OFDM, size);
afbf30a2 6973
b095c381 6974 if ((network->qos_data.active == 1) && (active_network == 1)) {
9fd1ea42 6975 IPW_DEBUG_QOS("QoS was disabled call qos_activate\n");
b095c381
JK		 6976 schedule_work(&priv->qos_activate);
6977 }
6978
6979 network->qos_data.active = 0;
6980 network->qos_data.supported = 0;
ea2b26e0 6981 }
afbf30a2
JK		 6982 if ((priv->status & STATUS_ASSOCIATED) &&
6983 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6984 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
c5d3dce8 6985 if (network->capability & WLAN_CAPABILITY_IBSS)
b095c381 6986 if ((network->ssid_len ==
afbf30a2
JK		 6987 priv->assoc_network->ssid_len) &&
6988 !memcmp(network->ssid,
6989 priv->assoc_network->ssid,
6990 network->ssid_len)) {
b095c381
JK		 6991 queue_work(priv->workqueue,
6992 &priv->merge_networks);
6993 }
b095c381 6994 }
ea2b26e0 6995
b095c381
JK		 6996 return 0;
6997}
6998
6999/*
7000* This function set up the firmware to support QoS. It sends
7001* IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
7002*/
7003static int ipw_qos_activate(struct ipw_priv *priv,
b0a4e7d8 7004 struct libipw_qos_data *qos_network_data)
b095c381
JK		 7005{
7006 int err;
b0a4e7d8
JL		 7007 struct libipw_qos_parameters qos_parameters[QOS_QOS_SETS];
7008 struct libipw_qos_parameters *active_one = NULL;
7009 u32 size = sizeof(struct libipw_qos_parameters);
b095c381
JK		 7010 u32 burst_duration;
7011 int i;
7012 u8 type;
7013
7014 type = ipw_qos_current_mode(priv);
7015
7016 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
7017 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
7018 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
7019 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
7020
7021 if (qos_network_data == NULL) {
7022 if (type == IEEE_B) {
7023 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
7024 active_one = &def_parameters_CCK;
7025 } else
7026 active_one = &def_parameters_OFDM;
7027
afbf30a2 7028 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7029 burst_duration = ipw_qos_get_burst_duration(priv);
7030 for (i = 0; i < QOS_QUEUE_NUM; i++)
afbf30a2 7031 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
8fffc15d 7032 cpu_to_le16(burst_duration);
afbf30a2 7033 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
b095c381
JK		 7034 if (type == IEEE_B) {
7035 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
7036 type);
7037 if (priv->qos_data.qos_enable == 0)
7038 active_one = &def_parameters_CCK;
7039 else
7040 active_one = priv->qos_data.def_qos_parm_CCK;
7041 } else {
7042 if (priv->qos_data.qos_enable == 0)
7043 active_one = &def_parameters_OFDM;
7044 else
7045 active_one = priv->qos_data.def_qos_parm_OFDM;
7046 }
afbf30a2 7047 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7048 } else {
7049 unsigned long flags;
7050 int active;
7051
7052 spin_lock_irqsave(&priv->ieee->lock, flags);
7053 active_one = &(qos_network_data->parameters);
7054 qos_network_data->old_param_count =
7055 qos_network_data->param_count;
afbf30a2 7056 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7057 active = qos_network_data->supported;
7058 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7059
7060 if (active == 0) {
7061 burst_duration = ipw_qos_get_burst_duration(priv);
7062 for (i = 0; i < QOS_QUEUE_NUM; i++)
7063 qos_parameters[QOS_PARAM_SET_ACTIVE].
8fffc15d 7064 tx_op_limit[i] = cpu_to_le16(burst_duration);
b095c381
JK		 7065 }
7066 }
7067
7068 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
afbf30a2 7069 err = ipw_send_qos_params_command(priv,
b0a4e7d8 7070 (struct libipw_qos_parameters *)
afbf30a2 7071 &(qos_parameters[0]));
b095c381
JK		 7072 if (err)
7073 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
7074
7075 return err;
7076}
7077
7078/*
7079* send IPW_CMD_WME_INFO to the firmware
7080*/
7081static int ipw_qos_set_info_element(struct ipw_priv *priv)
7082{
7083 int ret = 0;
b0a4e7d8 7084 struct libipw_qos_information_element qos_info;
b095c381
JK		 7085
7086 if (priv == NULL)
7087 return -1;
7088
7089 qos_info.elementID = QOS_ELEMENT_ID;
b0a4e7d8 7090 qos_info.length = sizeof(struct libipw_qos_information_element) - 2;
b095c381
JK		 7091
7092 qos_info.version = QOS_VERSION_1;
7093 qos_info.ac_info = 0;
7094
7095 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
7096 qos_info.qui_type = QOS_OUI_TYPE;
7097 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
7098
7099 ret = ipw_send_qos_info_command(priv, &qos_info);
7100 if (ret != 0) {
7101 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
7102 }
7103 return ret;
7104}
7105
7106/*
7107* Set the QoS parameter with the association request structure
7108*/
7109static int ipw_qos_association(struct ipw_priv *priv,
b0a4e7d8 7110 struct libipw_network *network)
b095c381
JK		 7111{
7112 int err = 0;
b0a4e7d8
JL		 7113 struct libipw_qos_data *qos_data = NULL;
7114 struct libipw_qos_data ibss_data = {
b095c381
JK		 7115 .supported = 1,
7116 .active = 1,
7117 };
7118
7119 switch (priv->ieee->iw_mode) {
7120 case IW_MODE_ADHOC:
5d9428de 7121 BUG_ON(!(network->capability & WLAN_CAPABILITY_IBSS));
b095c381
JK		 7122
7123 qos_data = &ibss_data;
7124 break;
7125
7126 case IW_MODE_INFRA:
7127 qos_data = &network->qos_data;
7128 break;
7129
7130 default:
7131 BUG();
7132 break;
7133 }
7134
7135 err = ipw_qos_activate(priv, qos_data);
7136 if (err) {
7137 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
7138 return err;
7139 }
7140
7141 if (priv->qos_data.qos_enable && qos_data->supported) {
7142 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
7143 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
7144 return ipw_qos_set_info_element(priv);
7145 }
7146
7147 return 0;
7148}
7149
7150/*
0779bf2d
ML		 7151* handling the beaconing responses. if we get different QoS setting
7152* off the network from the associated setting, adjust the QoS
b095c381
JK		 7153* setting
7154*/
7155static int ipw_qos_association_resp(struct ipw_priv *priv,
b0a4e7d8 7156 struct libipw_network *network)
b095c381
JK		 7157{
7158 int ret = 0;
7159 unsigned long flags;
b0a4e7d8 7160 u32 size = sizeof(struct libipw_qos_parameters);
b095c381
JK		 7161 int set_qos_param = 0;
7162
afbf30a2
JK		 7163 if ((priv == NULL) || (network == NULL) ||
7164 (priv->assoc_network == NULL))
b095c381
JK		 7165 return ret;
7166
7167 if (!(priv->status & STATUS_ASSOCIATED))
7168 return ret;
7169
afbf30a2 7170 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
b095c381 7171 return ret;
b095c381
JK		 7172
7173 spin_lock_irqsave(&priv->ieee->lock, flags);
7174 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
afbf30a2 7175 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
b0a4e7d8 7176 sizeof(struct libipw_qos_data));
b095c381
JK		 7177 priv->assoc_network->qos_data.active = 1;
7178 if ((network->qos_data.old_param_count !=
7179 network->qos_data.param_count)) {
7180 set_qos_param = 1;
7181 network->qos_data.old_param_count =
7182 network->qos_data.param_count;
7183 }
7184
7185 } else {
afbf30a2
JK		 7186 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7187 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 7188 &def_parameters_CCK, size);
afbf30a2
JK		 7189 else
7190 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 7191 &def_parameters_OFDM, size);
b095c381
JK		 7192 priv->assoc_network->qos_data.active = 0;
7193 priv->assoc_network->qos_data.supported = 0;
7194 set_qos_param = 1;
7195 }
7196
7197 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7198
7199 if (set_qos_param == 1)
7200 schedule_work(&priv->qos_activate);
7201
7202 return ret;
7203}
7204
7205static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
7206{
7207 u32 ret = 0;
7208
7209 if ((priv == NULL))
7210 return 0;
7211
b0a4e7d8 7212 if (!(priv->ieee->modulation & LIBIPW_OFDM_MODULATION))
b095c381 7213 ret = priv->qos_data.burst_duration_CCK;
afbf30a2 7214 else
b095c381 7215 ret = priv->qos_data.burst_duration_OFDM;
afbf30a2 7216
b095c381
JK		 7217 return ret;
7218}
7219
7220/*
7221* Initialize the setting of QoS global
7222*/
7223static void ipw_qos_init(struct ipw_priv *priv, int enable,
7224 int burst_enable, u32 burst_duration_CCK,
7225 u32 burst_duration_OFDM)
7226{
7227 priv->qos_data.qos_enable = enable;
7228
7229 if (priv->qos_data.qos_enable) {
7230 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7231 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7232 IPW_DEBUG_QOS("QoS is enabled\n");
7233 } else {
7234 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7235 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7236 IPW_DEBUG_QOS("QoS is not enabled\n");
7237 }
7238
7239 priv->qos_data.burst_enable = burst_enable;
7240
7241 if (burst_enable) {
7242 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7243 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7244 } else {
7245 priv->qos_data.burst_duration_CCK = 0;
7246 priv->qos_data.burst_duration_OFDM = 0;
7247 }
7248}
7249
7250/*
7251* map the packet priority to the right TX Queue
7252*/
7253static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
7254{
7255 if (priority > 7 || !priv->qos_data.qos_enable)
7256 priority = 0;
7257
7258 return from_priority_to_tx_queue[priority] - 1;
7259}
7260
a5cf4fe6
ZY		 7261static int ipw_is_qos_active(struct net_device *dev,
7262 struct sk_buff *skb)
b095c381 7263{
b0a4e7d8
JL		 7264 struct ipw_priv *priv = libipw_priv(dev);
7265 struct libipw_qos_data *qos_data = NULL;
b095c381 7266 int active, supported;
a5cf4fe6
ZY		 7267 u8 *daddr = skb->data + ETH_ALEN;
7268 int unicast = !is_multicast_ether_addr(daddr);
b095c381
JK		 7269
7270 if (!(priv->status & STATUS_ASSOCIATED))
7271 return 0;
7272
7273 qos_data = &priv->assoc_network->qos_data;
7274
b095c381
JK		 7275 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7276 if (unicast == 0)
7277 qos_data->active = 0;
7278 else
7279 qos_data->active = qos_data->supported;
7280 }
b095c381
JK		 7281 active = qos_data->active;
7282 supported = qos_data->supported;
afbf30a2
JK		 7283 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
7284 "unicast %d\n",
7285 priv->qos_data.qos_enable, active, supported, unicast);
a5cf4fe6
ZY		 7286 if (active && priv->qos_data.qos_enable)
7287 return 1;
b095c381 7288
a5cf4fe6
ZY		 7289 return 0;
7290
7291}
7292/*
7293* add QoS parameter to the TX command
7294*/
7295static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
7296 u16 priority,
7297 struct tfd_data *tfd)
7298{
7299 int tx_queue_id = 0;
7300
7301
7302 tx_queue_id = from_priority_to_tx_queue[priority] - 1;
7303 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7304
7305 if (priv->qos_data.qos_no_ack_mask & (1UL << tx_queue_id)) {
7306 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
851ca268 7307 tfd->tfd.tfd_26.mchdr.qos_ctrl |= cpu_to_le16(CTRL_QOS_NO_ACK);
a5cf4fe6
ZY		 7308 }
7309 return 0;
b095c381
JK		 7310}
7311
7312/*
7313* background support to run QoS activate functionality
7314*/
c4028958 7315static void ipw_bg_qos_activate(struct work_struct *work)
b095c381 7316{
c4028958
DH		 7317 struct ipw_priv *priv =
7318 container_of(work, struct ipw_priv, qos_activate);
b095c381 7319
4644151b 7320 mutex_lock(&priv->mutex);
b095c381
JK		 7321
7322 if (priv->status & STATUS_ASSOCIATED)
7323 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7324
4644151b 7325 mutex_unlock(&priv->mutex);
b095c381
JK		 7326}
7327
3b9990cb 7328static int ipw_handle_probe_response(struct net_device *dev,
b0a4e7d8
JL		 7329 struct libipw_probe_response *resp,
7330 struct libipw_network *network)
b095c381 7331{
b0a4e7d8 7332 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7333 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7334 (network == priv->assoc_network));
43f66a6c 7335
3b9990cb 7336 ipw_qos_handle_probe_response(priv, active_network, network);
43f66a6c 7337
3b9990cb
JK		 7338 return 0;
7339}
43f66a6c 7340
3b9990cb 7341static int ipw_handle_beacon(struct net_device *dev,
b0a4e7d8
JL		 7342 struct libipw_beacon *resp,
7343 struct libipw_network *network)
3b9990cb 7344{
b0a4e7d8 7345 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7346 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7347 (network == priv->assoc_network));
bf79451e 7348
3b9990cb 7349 ipw_qos_handle_probe_response(priv, active_network, network);
bf79451e 7350
b095c381
JK		 7351 return 0;
7352}
bf79451e 7353
3b9990cb 7354static int ipw_handle_assoc_response(struct net_device *dev,
b0a4e7d8
JL		 7355 struct libipw_assoc_response *resp,
7356 struct libipw_network *network)
3b9990cb 7357{
b0a4e7d8 7358 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7359 ipw_qos_association_resp(priv, network);
7360 return 0;
7361}
43f66a6c 7362
b0a4e7d8 7363static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
b095c381
JK		 7364 *qos_param)
7365{
4e22699f
ZY		 7366 return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7367 sizeof(*qos_param) * 3, qos_param);
b095c381
JK		 7368}
7369
b0a4e7d8 7370static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
b095c381
JK		 7371 *qos_param)
7372{
4e22699f
ZY		 7373 return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7374 qos_param);
43f66a6c
JK		 7375}
7376
e43e3c1e 7377#endif /* CONFIG_IPW2200_QOS */
b095c381 7378
43f66a6c 7379static int ipw_associate_network(struct ipw_priv *priv,
b0a4e7d8 7380 struct libipw_network *network,
0edd5b44 7381 struct ipw_supported_rates *rates, int roaming)
43f66a6c
JK		 7382{
7383 int err;
9387b7ca 7384 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 7385
7386 if (priv->config & CFG_FIXED_RATE)
b095c381 7387 ipw_set_fixed_rate(priv, network->mode);
43f66a6c
JK		 7388
7389 if (!(priv->config & CFG_STATIC_ESSID)) {
bf79451e 7390 priv->essid_len = min(network->ssid_len,
0edd5b44 7391 (u8) IW_ESSID_MAX_SIZE);
43f66a6c
JK		 7392 memcpy(priv->essid, network->ssid, priv->essid_len);
7393 }
7394
7395 network->last_associate = jiffies;
7396
7397 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7398 priv->assoc_request.channel = network->channel;
3e234b4e
ZY		 7399 priv->assoc_request.auth_key = 0;
7400
43f66a6c 7401 if ((priv->capability & CAP_PRIVACY_ON) &&
3e234b4e 7402 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
43f66a6c 7403 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
b095c381
JK		 7404 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7405
1ba61e05 7406 if (priv->ieee->sec.level == SEC_LEVEL_1)
b095c381 7407 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
3e234b4e
ZY		 7408
7409 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7410 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7411 priv->assoc_request.auth_type = AUTH_LEAP;
7412 else
43f66a6c 7413 priv->assoc_request.auth_type = AUTH_OPEN;
43f66a6c 7414
b095c381 7415 if (priv->ieee->wpa_ie_len) {
5b5e807f 7416 priv->assoc_request.policy_support = cpu_to_le16(0x02); /* RSN active */
ea2b26e0
JK		 7417 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7418 priv->ieee->wpa_ie_len);
7419 }
43f66a6c 7420
bf79451e
JG		 7421 /*
7422 * It is valid for our ieee device to support multiple modes, but
7423 * when it comes to associating to a given network we have to choose
43f66a6c
JK		 7424 * just one mode.
7425 */
7426 if (network->mode & priv->ieee->mode & IEEE_A)
7427 priv->assoc_request.ieee_mode = IPW_A_MODE;
7428 else if (network->mode & priv->ieee->mode & IEEE_G)
7429 priv->assoc_request.ieee_mode = IPW_G_MODE;
7430 else if (network->mode & priv->ieee->mode & IEEE_B)
7431 priv->assoc_request.ieee_mode = IPW_B_MODE;
7432
5b5e807f 7433 priv->assoc_request.capability = cpu_to_le16(network->capability);
ea2b26e0
JK		 7434 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7435 && !(priv->config & CFG_PREAMBLE_LONG)) {
7436 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7437 } else {
7438 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7439
7440 /* Clear the short preamble if we won't be supporting it */
7441 priv->assoc_request.capability &=
5b5e807f 7442 ~cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
ea2b26e0
JK		 7443 }
7444
afbf30a2
JK		 7445 /* Clear capability bits that aren't used in Ad Hoc */
7446 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7447 priv->assoc_request.capability &=
5b5e807f 7448 ~cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME);
afbf30a2 7449
43f66a6c 7450 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
ea2b26e0 7451 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
43f66a6c 7452 roaming ? "Rea" : "A",
9387b7ca 7453 print_ssid(ssid, priv->essid, priv->essid_len),
bf79451e
JG		 7454 network->channel,
7455 ipw_modes[priv->assoc_request.ieee_mode],
7456 rates->num_rates,
ea2b26e0
JK		 7457 (priv->assoc_request.preamble_length ==
7458 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7459 network->capability &
7460 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
43f66a6c 7461 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
bf79451e
JG		 7462 priv->capability & CAP_PRIVACY_ON ?
7463 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
43f66a6c
JK		 7464 "(open)") : "",
7465 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
bf79451e 7466 priv->capability & CAP_PRIVACY_ON ?
b095c381 7467 '1' + priv->ieee->sec.active_key : '.',
0edd5b44 7468 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
43f66a6c 7469
5b5e807f 7470 priv->assoc_request.beacon_interval = cpu_to_le16(network->beacon_interval);
43f66a6c 7471 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
0edd5b44 7472 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
43f66a6c
JK		 7473 priv->assoc_request.assoc_type = HC_IBSS_START;
7474 priv->assoc_request.assoc_tsf_msw = 0;
7475 priv->assoc_request.assoc_tsf_lsw = 0;
7476 } else {
7477 if (unlikely(roaming))
7478 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7479 else
7480 priv->assoc_request.assoc_type = HC_ASSOCIATE;
5b5e807f
AV		 7481 priv->assoc_request.assoc_tsf_msw = cpu_to_le32(network->time_stamp[1]);
7482 priv->assoc_request.assoc_tsf_lsw = cpu_to_le32(network->time_stamp[0]);
43f66a6c
JK		 7483 }
7484
afbf30a2 7485 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
43f66a6c
JK		 7486
7487 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7488 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
5b5e807f 7489 priv->assoc_request.atim_window = cpu_to_le16(network->atim_window);
43f66a6c 7490 } else {
afbf30a2 7491 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
43f66a6c
JK		 7492 priv->assoc_request.atim_window = 0;
7493 }
7494
5b5e807f 7495 priv->assoc_request.listen_interval = cpu_to_le16(network->listen_interval);
bf79451e 7496
43f66a6c
JK		 7497 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7498 if (err) {
7499 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7500 return err;
7501 }
7502
7503 rates->ieee_mode = priv->assoc_request.ieee_mode;
7504 rates->purpose = IPW_RATE_CONNECT;
7505 ipw_send_supported_rates(priv, rates);
bf79451e 7506
43f66a6c
JK		 7507 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7508 priv->sys_config.dot11g_auto_detection = 1;
7509 else
7510 priv->sys_config.dot11g_auto_detection = 0;
c848d0af
JK		 7511
7512 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7513 priv->sys_config.answer_broadcast_ssid_probe = 1;
7514 else
7515 priv->sys_config.answer_broadcast_ssid_probe = 0;
7516
d685b8c2 7517 err = ipw_send_system_config(priv);
43f66a6c
JK		 7518 if (err) {
7519 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7520 return err;
7521 }
bf79451e 7522
43f66a6c 7523 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
ea2b26e0 7524 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
43f66a6c
JK		 7525 if (err) {
7526 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7527 return err;
7528 }
7529
7530 /*
7531 * If preemption is enabled, it is possible for the association
7532 * to complete before we return from ipw_send_associate. Therefore
7533 * we have to be sure and update our priviate data first.
7534 */
7535 priv->channel = network->channel;
7536 memcpy(priv->bssid, network->bssid, ETH_ALEN);
bf79451e 7537 priv->status |= STATUS_ASSOCIATING;
43f66a6c
JK		 7538 priv->status &= ~STATUS_SECURITY_UPDATED;
7539
7540 priv->assoc_network = network;
7541
e43e3c1e 7542#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 7543 ipw_qos_association(priv, network);
7544#endif
7545
43f66a6c
JK		 7546 err = ipw_send_associate(priv, &priv->assoc_request);
7547 if (err) {
7548 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7549 return err;
7550 }
bf79451e 7551
9fd1ea42 7552 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' %pM\n",
9387b7ca 7553 print_ssid(ssid, priv->essid, priv->essid_len),
e174961c 7554 priv->bssid);
43f66a6c
JK		 7555
7556 return 0;
7557}
7558
7559static void ipw_roam(void *data)
7560{
7561 struct ipw_priv *priv = data;
b0a4e7d8 7562 struct libipw_network *network = NULL;
43f66a6c
JK		 7563 struct ipw_network_match match = {
7564 .network = priv->assoc_network
7565 };
7566
7567 /* The roaming process is as follows:
bf79451e
JG		 7568 *
7569 * 1. Missed beacon threshold triggers the roaming process by
43f66a6c
JK		 7570 * setting the status ROAM bit and requesting a scan.
7571 * 2. When the scan completes, it schedules the ROAM work
7572 * 3. The ROAM work looks at all of the known networks for one that
7573 * is a better network than the currently associated. If none
7574 * found, the ROAM process is over (ROAM bit cleared)
7575 * 4. If a better network is found, a disassociation request is
7576 * sent.
7577 * 5. When the disassociation completes, the roam work is again
7578 * scheduled. The second time through, the driver is no longer
7579 * associated, and the newly selected network is sent an
bf79451e 7580 * association request.
43f66a6c
JK		 7581 * 6. At this point ,the roaming process is complete and the ROAM
7582 * status bit is cleared.
7583 */
7584
7585 /* If we are no longer associated, and the roaming bit is no longer
7586 * set, then we are not actively roaming, so just return */
7587 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7588 return;
bf79451e 7589
43f66a6c 7590 if (priv->status & STATUS_ASSOCIATED) {
bf79451e 7591 /* First pass through ROAM process -- look for a better
43f66a6c 7592 * network */
a613bffd 7593 unsigned long flags;
43f66a6c
JK		 7594 u8 rssi = priv->assoc_network->stats.rssi;
7595 priv->assoc_network->stats.rssi = -128;
a613bffd 7596 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c
JK		 7597 list_for_each_entry(network, &priv->ieee->network_list, list) {
7598 if (network != priv->assoc_network)
7599 ipw_best_network(priv, &match, network, 1);
7600 }
a613bffd 7601 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c 7602 priv->assoc_network->stats.rssi = rssi;
bf79451e 7603
43f66a6c
JK		 7604 if (match.network == priv->assoc_network) {
7605 IPW_DEBUG_ASSOC("No better APs in this network to "
7606 "roam to.\n");
7607 priv->status &= ~STATUS_ROAMING;
7608 ipw_debug_config(priv);
7609 return;
7610 }
bf79451e 7611
43f66a6c
JK		 7612 ipw_send_disassociate(priv, 1);
7613 priv->assoc_network = match.network;
7614
7615 return;
bf79451e 7616 }
43f66a6c
JK		 7617
7618 /* Second pass through ROAM process -- request association */
7619 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7620 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7621 priv->status &= ~STATUS_ROAMING;
7622}
7623
c4028958 7624static void ipw_bg_roam(struct work_struct *work)
c848d0af 7625{
c4028958
DH		 7626 struct ipw_priv *priv =
7627 container_of(work, struct ipw_priv, roam);
4644151b 7628 mutex_lock(&priv->mutex);
c4028958 7629 ipw_roam(priv);
4644151b 7630 mutex_unlock(&priv->mutex);
c848d0af
JK		 7631}
7632
7633static int ipw_associate(void *data)
43f66a6c
JK		 7634{
7635 struct ipw_priv *priv = data;
7636
b0a4e7d8 7637 struct libipw_network *network = NULL;
43f66a6c
JK		 7638 struct ipw_network_match match = {
7639 .network = NULL
7640 };
7641 struct ipw_supported_rates *rates;
7642 struct list_head *element;
a613bffd 7643 unsigned long flags;
9387b7ca 7644 DECLARE_SSID_BUF(ssid);
43f66a6c 7645
b095c381
JK		 7646 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7647 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7648 return 0;
7649 }
7650
c848d0af 7651 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
afbf30a2
JK		 7652 IPW_DEBUG_ASSOC("Not attempting association (already in "
7653 "progress)\n");
c848d0af
JK		 7654 return 0;
7655 }
7656
e6324726
HL		 7657 if (priv->status & STATUS_DISASSOCIATING) {
7658 IPW_DEBUG_ASSOC("Not attempting association (in "
7659 "disassociating)\n ");
7660 queue_work(priv->workqueue, &priv->associate);
7661 return 0;
7662 }
7663
c848d0af 7664 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
afbf30a2
JK		 7665 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7666 "initialized)\n");
c848d0af
JK		 7667 return 0;
7668 }
43f66a6c
JK		 7669
7670 if (!(priv->config & CFG_ASSOCIATE) &&
3e4127fa 7671 !(priv->config & (CFG_STATIC_ESSID | CFG_STATIC_BSSID))) {
43f66a6c 7672 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
c848d0af 7673 return 0;
43f66a6c
JK		 7674 }
7675
a613bffd
JK		 7676 /* Protect our use of the network_list */
7677 spin_lock_irqsave(&priv->ieee->lock, flags);
bf79451e 7678 list_for_each_entry(network, &priv->ieee->network_list, list)
0edd5b44 7679 ipw_best_network(priv, &match, network, 0);
43f66a6c
JK		 7680
7681 network = match.network;
7682 rates = &match.rates;
7683
7684 if (network == NULL &&
7685 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7686 priv->config & CFG_ADHOC_CREATE &&
7687 priv->config & CFG_STATIC_ESSID &&
a6d4eae8
DW		 7688 priv->config & CFG_STATIC_CHANNEL) {
7689 /* Use oldest network if the free list is empty */
7690 if (list_empty(&priv->ieee->network_free_list)) {
b0a4e7d8
JL		 7691 struct libipw_network *oldest = NULL;
7692 struct libipw_network *target;
a6d4eae8
DW		 7693
7694 list_for_each_entry(target, &priv->ieee->network_list, list) {
7695 if ((oldest == NULL) ||
7696 (target->last_scanned < oldest->last_scanned))
7697 oldest = target;
7698 }
7699
7700 /* If there are no more slots, expire the oldest */
7701 list_del(&oldest->list);
7702 target = oldest;
e174961c 7703 IPW_DEBUG_ASSOC("Expired '%s' (%pM) from "
a6d4eae8 7704 "network list.\n",
9387b7ca
JL		 7705 print_ssid(ssid, target->ssid,
7706 target->ssid_len),
e174961c 7707 target->bssid);
a6d4eae8
DW		 7708 list_add_tail(&target->list,
7709 &priv->ieee->network_free_list);
7710 }
7711
43f66a6c 7712 element = priv->ieee->network_free_list.next;
b0a4e7d8 7713 network = list_entry(element, struct libipw_network, list);
43f66a6c
JK		 7714 ipw_adhoc_create(priv, network);
7715 rates = &priv->rates;
7716 list_del(element);
7717 list_add_tail(&network->list, &priv->ieee->network_list);
7718 }
a613bffd 7719 spin_unlock_irqrestore(&priv->ieee->lock, flags);
bf79451e 7720
43f66a6c
JK		 7721 /* If we reached the end of the list, then we don't have any valid
7722 * matching APs */
7723 if (!network) {
7724 ipw_debug_config(priv);
7725
b095c381
JK		 7726 if (!(priv->status & STATUS_SCANNING)) {
7727 if (!(priv->config & CFG_SPEED_SCAN))
7728 queue_delayed_work(priv->workqueue,
7729 &priv->request_scan,
7730 SCAN_INTERVAL);
7731 else
c4028958
DH		 7732 queue_delayed_work(priv->workqueue,
7733 &priv->request_scan, 0);
b095c381 7734 }
bf79451e 7735
c848d0af 7736 return 0;
43f66a6c
JK		 7737 }
7738
7739 ipw_associate_network(priv, network, rates, 0);
c848d0af
JK		 7740
7741 return 1;
7742}
7743
c4028958 7744static void ipw_bg_associate(struct work_struct *work)
c848d0af 7745{
c4028958
DH		 7746 struct ipw_priv *priv =
7747 container_of(work, struct ipw_priv, associate);
4644151b 7748 mutex_lock(&priv->mutex);
c4028958 7749 ipw_associate(priv);
4644151b 7750 mutex_unlock(&priv->mutex);
43f66a6c 7751}
bf79451e 7752
b095c381
JK		 7753static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7754 struct sk_buff *skb)
7755{
7756 struct ieee80211_hdr *hdr;
7757 u16 fc;
7758
7759 hdr = (struct ieee80211_hdr *)skb->data;
72118015 7760 fc = le16_to_cpu(hdr->frame_control);
b095c381
JK		 7761 if (!(fc & IEEE80211_FCTL_PROTECTED))
7762 return;
7763
7764 fc &= ~IEEE80211_FCTL_PROTECTED;
72118015 7765 hdr->frame_control = cpu_to_le16(fc);
b095c381
JK		 7766 switch (priv->ieee->sec.level) {
7767 case SEC_LEVEL_3:
7768 /* Remove CCMP HDR */
b0a4e7d8
JL		 7769 memmove(skb->data + LIBIPW_3ADDR_LEN,
7770 skb->data + LIBIPW_3ADDR_LEN + 8,
7771 skb->len - LIBIPW_3ADDR_LEN - 8);
f4ff497d 7772 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
b095c381
JK		 7773 break;
7774 case SEC_LEVEL_2:
7775 break;
7776 case SEC_LEVEL_1:
7777 /* Remove IV */
b0a4e7d8
JL		 7778 memmove(skb->data + LIBIPW_3ADDR_LEN,
7779 skb->data + LIBIPW_3ADDR_LEN + 4,
7780 skb->len - LIBIPW_3ADDR_LEN - 4);
f4ff497d 7781 skb_trim(skb, skb->len - 8); /* IV + ICV */
b095c381
JK		 7782 break;
7783 case SEC_LEVEL_0:
7784 break;
7785 default:
af901ca1 7786 printk(KERN_ERR "Unknown security level %d\n",
b095c381
JK		 7787 priv->ieee->sec.level);
7788 break;
7789 }
43f66a6c 7790}
bf79451e 7791
b095c381
JK		 7792static void ipw_handle_data_packet(struct ipw_priv *priv,
7793 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 7794 struct libipw_rx_stats *stats)
43f66a6c 7795{
ce55cbaf 7796 struct net_device *dev = priv->net_dev;
b0a4e7d8 7797 struct libipw_hdr_4addr *hdr;
43f66a6c
JK		 7798 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7799
7800 /* We received data from the HW, so stop the watchdog */
ce55cbaf 7801 dev->trans_start = jiffies;
43f66a6c 7802
bf79451e 7803 /* We only process data packets if the
43f66a6c 7804 * interface is open */
a613bffd 7805 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
43f66a6c 7806 skb_tailroom(rxb->skb))) {
ce55cbaf 7807 dev->stats.rx_errors++;
43f66a6c
JK		 7808 priv->wstats.discard.misc++;
7809 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7810 return;
7811 } else if (unlikely(!netif_running(priv->net_dev))) {
ce55cbaf 7812 dev->stats.rx_dropped++;
43f66a6c
JK		 7813 priv->wstats.discard.misc++;
7814 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7815 return;
7816 }
7817
7818 /* Advance skb->data to the start of the actual payload */
aaa4d308 7819 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
43f66a6c
JK		 7820
7821 /* Set the size of the skb to the size of the frame */
a613bffd 7822 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
43f66a6c
JK		 7823
7824 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7825
b095c381 7826 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
b0a4e7d8 7827 hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
567deaf6 7828 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
3c19065a 7829 (is_multicast_ether_addr(hdr->addr1) ?
567deaf6 7830 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
b095c381
JK		 7831 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7832
b0a4e7d8 7833 if (!libipw_rx(priv->ieee, rxb->skb, stats))
ce55cbaf 7834 dev->stats.rx_errors++;
b0a4e7d8 7835 else { /* libipw_rx succeeded, so it now owns the SKB */
43f66a6c 7836 rxb->skb = NULL;
b095c381 7837 __ipw_led_activity_on(priv);
a613bffd 7838 }
43f66a6c
JK		 7839}
7840
459d4087 7841#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 7842static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7843 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 7844 struct libipw_rx_stats *stats)
24a47dbd 7845{
ce55cbaf 7846 struct net_device *dev = priv->net_dev;
24a47dbd
MK		 7847 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7848 struct ipw_rx_frame *frame = &pkt->u.frame;
7849
7850 /* initial pull of some data */
7851 u16 received_channel = frame->received_channel;
7852 u8 antennaAndPhy = frame->antennaAndPhy;
7853 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7854 u16 pktrate = frame->rate;
7855
7856 /* Magic struct that slots into the radiotap header -- no reason
7857 * to build this manually element by element, we can write it much
7858 * more efficiently than we can parse it. ORDER MATTERS HERE */
d685b8c2 7859 struct ipw_rt_hdr *ipw_rt;
24a47dbd
MK		 7860
7861 short len = le16_to_cpu(pkt->u.frame.length);
7862
7863 /* We received data from the HW, so stop the watchdog */
ce55cbaf 7864 dev->trans_start = jiffies;
24a47dbd
MK		 7865
7866 /* We only process data packets if the
7867 * interface is open */
7868 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7869 skb_tailroom(rxb->skb))) {
ce55cbaf 7870 dev->stats.rx_errors++;
24a47dbd
MK		 7871 priv->wstats.discard.misc++;
7872 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7873 return;
7874 } else if (unlikely(!netif_running(priv->net_dev))) {
ce55cbaf 7875 dev->stats.rx_dropped++;
24a47dbd
MK		 7876 priv->wstats.discard.misc++;
7877 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7878 return;
7879 }
7880
7881 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7882 * that now */
7883 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7884 /* FIXME: Should alloc bigger skb instead */
ce55cbaf 7885 dev->stats.rx_dropped++;
24a47dbd
MK		 7886 priv->wstats.discard.misc++;
7887 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7888 return;
7889 }
7890
7891 /* copy the frame itself */
7892 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7893 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7894
24a47dbd
MK		 7895 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7896
7897 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7898 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
743b84d2 7899 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total header+data */
24a47dbd
MK		 7900
7901 /* Big bitfield of all the fields we provide in radiotap */
743b84d2
AV		 7902 ipw_rt->rt_hdr.it_present = cpu_to_le32(
7903 (1 << IEEE80211_RADIOTAP_TSFT) |
4b1f8a99 7904 (1 << IEEE80211_RADIOTAP_FLAGS) |
24a47dbd
MK		 7905 (1 << IEEE80211_RADIOTAP_RATE) |
7906 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7907 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
d685b8c2 7908 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
24a47dbd
MK		 7909 (1 << IEEE80211_RADIOTAP_ANTENNA));
7910
7911 /* Zero the flags, we'll add to them as we go */
7912 ipw_rt->rt_flags = 0;
4b1f8a99
ZY		 7913 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7914 frame->parent_tsf[2] << 16 |
7915 frame->parent_tsf[1] << 8 |
7916 frame->parent_tsf[0]);
24a47dbd
MK		 7917
7918 /* Convert signal to DBM */
7919 ipw_rt->rt_dbmsignal = antsignal;
21f8a73f 7920 ipw_rt->rt_dbmnoise = (s8) le16_to_cpu(frame->noise);
24a47dbd
MK		 7921
7922 /* Convert the channel data and set the flags */
7923 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7924 if (received_channel > 14) { /* 802.11a */
7925 ipw_rt->rt_chbitmask =
7926 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7927 } else if (antennaAndPhy & 32) { /* 802.11b */
7928 ipw_rt->rt_chbitmask =
7929 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7930 } else { /* 802.11g */
7931 ipw_rt->rt_chbitmask =
472caf8c 7932 cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
24a47dbd
MK		 7933 }
7934
7935 /* set the rate in multiples of 500k/s */
7936 switch (pktrate) {
7937 case IPW_TX_RATE_1MB:
7938 ipw_rt->rt_rate = 2;
7939 break;
7940 case IPW_TX_RATE_2MB:
7941 ipw_rt->rt_rate = 4;
7942 break;
7943 case IPW_TX_RATE_5MB:
7944 ipw_rt->rt_rate = 10;
7945 break;
7946 case IPW_TX_RATE_6MB:
7947 ipw_rt->rt_rate = 12;
7948 break;
7949 case IPW_TX_RATE_9MB:
7950 ipw_rt->rt_rate = 18;
7951 break;
7952 case IPW_TX_RATE_11MB:
7953 ipw_rt->rt_rate = 22;
7954 break;
7955 case IPW_TX_RATE_12MB:
7956 ipw_rt->rt_rate = 24;
7957 break;
7958 case IPW_TX_RATE_18MB:
7959 ipw_rt->rt_rate = 36;
7960 break;
7961 case IPW_TX_RATE_24MB:
7962 ipw_rt->rt_rate = 48;
7963 break;
7964 case IPW_TX_RATE_36MB:
7965 ipw_rt->rt_rate = 72;
7966 break;
7967 case IPW_TX_RATE_48MB:
7968 ipw_rt->rt_rate = 96;
7969 break;
7970 case IPW_TX_RATE_54MB:
7971 ipw_rt->rt_rate = 108;
7972 break;
7973 default:
7974 ipw_rt->rt_rate = 0;
7975 break;
7976 }
7977
7978 /* antenna number */
7979 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7980
7981 /* set the preamble flag if we have it */
7982 if ((antennaAndPhy & 64))
7983 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7984
7985 /* Set the size of the skb to the size of the frame */
7986 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
43f66a6c
JK		 7987
7988 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7989
b0a4e7d8 7990 if (!libipw_rx(priv->ieee, rxb->skb, stats))
ce55cbaf 7991 dev->stats.rx_errors++;
b0a4e7d8 7992 else { /* libipw_rx succeeded, so it now owns the SKB */
24a47dbd
MK		 7993 rxb->skb = NULL;
7994 /* no LED during capture */
7995 }
7996}
7997#endif
7998
d685b8c2 7999#ifdef CONFIG_IPW2200_PROMISCUOUS
b0a4e7d8 8000#define libipw_is_probe_response(fc) \
d685b8c2
ZY		 8001 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT && \
8002 (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP )
8003
b0a4e7d8 8004#define libipw_is_management(fc) \
d685b8c2
ZY		 8005 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT)
8006
b0a4e7d8 8007#define libipw_is_control(fc) \
d685b8c2
ZY		 8008 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL)
8009
b0a4e7d8 8010#define libipw_is_data(fc) \
d685b8c2
ZY		 8011 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA)
8012
b0a4e7d8 8013#define libipw_is_assoc_request(fc) \
d685b8c2
ZY		 8014 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_ASSOC_REQ)
8015
b0a4e7d8 8016#define libipw_is_reassoc_request(fc) \
d685b8c2
ZY		 8017 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_REASSOC_REQ)
8018
8019static void ipw_handle_promiscuous_rx(struct ipw_priv *priv,
8020 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 8021 struct libipw_rx_stats *stats)
d685b8c2 8022{
ce55cbaf 8023 struct net_device *dev = priv->prom_net_dev;
d685b8c2
ZY		 8024 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
8025 struct ipw_rx_frame *frame = &pkt->u.frame;
8026 struct ipw_rt_hdr *ipw_rt;
8027
8028 /* First cache any information we need before we overwrite
8029 * the information provided in the skb from the hardware */
8030 struct ieee80211_hdr *hdr;
8031 u16 channel = frame->received_channel;
8032 u8 phy_flags = frame->antennaAndPhy;
8033 s8 signal = frame->rssi_dbm - IPW_RSSI_TO_DBM;
21f8a73f 8034 s8 noise = (s8) le16_to_cpu(frame->noise);
d685b8c2
ZY		 8035 u8 rate = frame->rate;
8036 short len = le16_to_cpu(pkt->u.frame.length);
d685b8c2
ZY		 8037 struct sk_buff *skb;
8038 int hdr_only = 0;
8039 u16 filter = priv->prom_priv->filter;
8040
8041 /* If the filter is set to not include Rx frames then return */
8042 if (filter & IPW_PROM_NO_RX)
8043 return;
8044
d685b8c2 8045 /* We received data from the HW, so stop the watchdog */
ce55cbaf 8046 dev->trans_start = jiffies;
d685b8c2
ZY		 8047
8048 if (unlikely((len + IPW_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) {
ce55cbaf 8049 dev->stats.rx_errors++;
d685b8c2
ZY		 8050 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
8051 return;
8052 }
8053
8054 /* We only process data packets if the interface is open */
ce55cbaf
SH		 8055 if (unlikely(!netif_running(dev))) {
8056 dev->stats.rx_dropped++;
d685b8c2
ZY		 8057 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
8058 return;
8059 }
8060
8061 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
8062 * that now */
8063 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
8064 /* FIXME: Should alloc bigger skb instead */
ce55cbaf 8065 dev->stats.rx_dropped++;
d685b8c2
ZY		 8066 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
8067 return;
8068 }
8069
8070 hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
b0a4e7d8 8071 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8072 if (filter & IPW_PROM_NO_MGMT)
8073 return;
8074 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
8075 hdr_only = 1;
b0a4e7d8 8076 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8077 if (filter & IPW_PROM_NO_CTL)
8078 return;
8079 if (filter & IPW_PROM_CTL_HEADER_ONLY)
8080 hdr_only = 1;
b0a4e7d8 8081 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8082 if (filter & IPW_PROM_NO_DATA)
8083 return;
8084 if (filter & IPW_PROM_DATA_HEADER_ONLY)
8085 hdr_only = 1;
8086 }
8087
8088 /* Copy the SKB since this is for the promiscuous side */
8089 skb = skb_copy(rxb->skb, GFP_ATOMIC);
8090 if (skb == NULL) {
8091 IPW_ERROR("skb_clone failed for promiscuous copy.\n");
8092 return;
8093 }
8094
8095 /* copy the frame data to write after where the radiotap header goes */
8096 ipw_rt = (void *)skb->data;
8097
8098 if (hdr_only)
b0a4e7d8 8099 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
d685b8c2
ZY		 8100
8101 memcpy(ipw_rt->payload, hdr, len);
8102
d685b8c2
ZY		 8103 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
8104 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
743b84d2 8105 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt)); /* total header+data */
d685b8c2
ZY		 8106
8107 /* Set the size of the skb to the size of the frame */
743b84d2 8108 skb_put(skb, sizeof(*ipw_rt) + len);
d685b8c2
ZY		 8109
8110 /* Big bitfield of all the fields we provide in radiotap */
743b84d2
AV		 8111 ipw_rt->rt_hdr.it_present = cpu_to_le32(
8112 (1 << IEEE80211_RADIOTAP_TSFT) |
4b1f8a99 8113 (1 << IEEE80211_RADIOTAP_FLAGS) |
d685b8c2
ZY		 8114 (1 << IEEE80211_RADIOTAP_RATE) |
8115 (1 << IEEE80211_RADIOTAP_CHANNEL) |
8116 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
8117 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
8118 (1 << IEEE80211_RADIOTAP_ANTENNA));
8119
8120 /* Zero the flags, we'll add to them as we go */
8121 ipw_rt->rt_flags = 0;
4b1f8a99
ZY		 8122 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
8123 frame->parent_tsf[2] << 16 |
8124 frame->parent_tsf[1] << 8 |
8125 frame->parent_tsf[0]);
d685b8c2
ZY		 8126
8127 /* Convert to DBM */
8128 ipw_rt->rt_dbmsignal = signal;
8129 ipw_rt->rt_dbmnoise = noise;
8130
8131 /* Convert the channel data and set the flags */
8132 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(channel));
8133 if (channel > 14) { /* 802.11a */
8134 ipw_rt->rt_chbitmask =
8135 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
8136 } else if (phy_flags & (1 << 5)) { /* 802.11b */
8137 ipw_rt->rt_chbitmask =
8138 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
8139 } else { /* 802.11g */
8140 ipw_rt->rt_chbitmask =
472caf8c 8141 cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
d685b8c2
ZY		 8142 }
8143
8144 /* set the rate in multiples of 500k/s */
8145 switch (rate) {
8146 case IPW_TX_RATE_1MB:
8147 ipw_rt->rt_rate = 2;
8148 break;
8149 case IPW_TX_RATE_2MB:
8150 ipw_rt->rt_rate = 4;
8151 break;
8152 case IPW_TX_RATE_5MB:
8153 ipw_rt->rt_rate = 10;
8154 break;
8155 case IPW_TX_RATE_6MB:
8156 ipw_rt->rt_rate = 12;
8157 break;
8158 case IPW_TX_RATE_9MB:
8159 ipw_rt->rt_rate = 18;
8160 break;
8161 case IPW_TX_RATE_11MB:
8162 ipw_rt->rt_rate = 22;
8163 break;
8164 case IPW_TX_RATE_12MB:
8165 ipw_rt->rt_rate = 24;
8166 break;
8167 case IPW_TX_RATE_18MB:
8168 ipw_rt->rt_rate = 36;
8169 break;
8170 case IPW_TX_RATE_24MB:
8171 ipw_rt->rt_rate = 48;
8172 break;
8173 case IPW_TX_RATE_36MB:
8174 ipw_rt->rt_rate = 72;
8175 break;
8176 case IPW_TX_RATE_48MB:
8177 ipw_rt->rt_rate = 96;
8178 break;
8179 case IPW_TX_RATE_54MB:
8180 ipw_rt->rt_rate = 108;
8181 break;
8182 default:
8183 ipw_rt->rt_rate = 0;
8184 break;
8185 }
8186
8187 /* antenna number */
8188 ipw_rt->rt_antenna = (phy_flags & 3);
8189
8190 /* set the preamble flag if we have it */
8191 if (phy_flags & (1 << 6))
8192 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8193
8194 IPW_DEBUG_RX("Rx packet of %d bytes.\n", skb->len);
8195
b0a4e7d8 8196 if (!libipw_rx(priv->prom_priv->ieee, skb, stats)) {
ce55cbaf 8197 dev->stats.rx_errors++;
d685b8c2
ZY		 8198 dev_kfree_skb_any(skb);
8199 }
8200}
8201#endif
8202
858119e1 8203static int is_network_packet(struct ipw_priv *priv,
b0a4e7d8 8204 struct libipw_hdr_4addr *header)
ea2b26e0
JK		 8205{
8206 /* Filter incoming packets to determine if they are targetted toward
8207 * this network, discarding packets coming from ourselves */
8208 switch (priv->ieee->iw_mode) {
a613bffd 8209 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
c848d0af
JK		 8210 /* packets from our adapter are dropped (echo) */
8211 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
8212 return 0;
8213
90700fd9 8214 /* {broad,multi}cast packets to our BSSID go through */
3c19065a 8215 if (is_multicast_ether_addr(header->addr1))
ea2b26e0 8216 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
a613bffd
JK		 8217
8218 /* packets to our adapter go through */
8219 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8220 ETH_ALEN);
a613bffd 8221
90700fd9 8222 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
c848d0af
JK		 8223 /* packets from our adapter are dropped (echo) */
8224 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
8225 return 0;
8226
90700fd9 8227 /* {broad,multi}cast packets to our BSS go through */
3c19065a 8228 if (is_multicast_ether_addr(header->addr1))
a613bffd
JK		 8229 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
8230
8231 /* packets to our adapter go through */
8232 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8233 ETH_ALEN);
ea2b26e0 8234 }
a613bffd 8235
ea2b26e0
JK		 8236 return 1;
8237}
8238
afbf30a2
JK		 8239#define IPW_PACKET_RETRY_TIME HZ
8240
858119e1 8241static int is_duplicate_packet(struct ipw_priv *priv,
b0a4e7d8 8242 struct libipw_hdr_4addr *header)
afbf30a2 8243{
afbf30a2
JK		 8244 u16 sc = le16_to_cpu(header->seq_ctl);
8245 u16 seq = WLAN_GET_SEQ_SEQ(sc);
8246 u16 frag = WLAN_GET_SEQ_FRAG(sc);
8247 u16 *last_seq, *last_frag;
8248 unsigned long *last_time;
8249
8250 switch (priv->ieee->iw_mode) {
8251 case IW_MODE_ADHOC:
8252 {
8253 struct list_head *p;
8254 struct ipw_ibss_seq *entry = NULL;
8255 u8 *mac = header->addr2;
8256 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
8257
8258 __list_for_each(p, &priv->ibss_mac_hash[index]) {
8259 entry =
8260 list_entry(p, struct ipw_ibss_seq, list);
8261 if (!memcmp(entry->mac, mac, ETH_ALEN))
8262 break;
8263 }
8264 if (p == &priv->ibss_mac_hash[index]) {
8265 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
8266 if (!entry) {
8267 IPW_ERROR
8268 ("Cannot malloc new mac entry\n");
8269 return 0;
8270 }
8271 memcpy(entry->mac, mac, ETH_ALEN);
8272 entry->seq_num = seq;
8273 entry->frag_num = frag;
8274 entry->packet_time = jiffies;
8275 list_add(&entry->list,
8276 &priv->ibss_mac_hash[index]);
8277 return 0;
8278 }
8279 last_seq = &entry->seq_num;
8280 last_frag = &entry->frag_num;
8281 last_time = &entry->packet_time;
8282 break;
8283 }
8284 case IW_MODE_INFRA:
8285 last_seq = &priv->last_seq_num;
8286 last_frag = &priv->last_frag_num;
8287 last_time = &priv->last_packet_time;
8288 break;
8289 default:
8290 return 0;
8291 }
8292 if ((*last_seq == seq) &&
8293 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
8294 if (*last_frag == frag)
8295 goto drop;
8296 if (*last_frag + 1 != frag)
8297 /* out-of-order fragment */
8298 goto drop;
afbf30a2
JK		 8299 } else
8300 *last_seq = seq;
8301
f57ce7ce 8302 *last_frag = frag;
afbf30a2
JK		 8303 *last_time = jiffies;
8304 return 0;
8305
8306 drop:
87b016cb
ZY		 8307 /* Comment this line now since we observed the card receives
8308 * duplicate packets but the FCTL_RETRY bit is not set in the
8309 * IBSS mode with fragmentation enabled.
72118015 8310 BUG_ON(!(le16_to_cpu(header->frame_control) & IEEE80211_FCTL_RETRY)); */
afbf30a2
JK		 8311 return 1;
8312}
8313
b095c381
JK		 8314static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
8315 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 8316 struct libipw_rx_stats *stats)
b095c381
JK		 8317{
8318 struct sk_buff *skb = rxb->skb;
8319 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
b0a4e7d8 8320 struct libipw_hdr_4addr *header = (struct libipw_hdr_4addr *)
b095c381
JK		 8321 (skb->data + IPW_RX_FRAME_SIZE);
8322
b0a4e7d8 8323 libipw_rx_mgt(priv->ieee, header, stats);
b095c381
JK		 8324
8325 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8326 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8327 IEEE80211_STYPE_PROBE_RESP) ||
8328 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8329 IEEE80211_STYPE_BEACON))) {
8330 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
8331 ipw_add_station(priv, header->addr2);
8332 }
8333
8334 if (priv->config & CFG_NET_STATS) {
8335 IPW_DEBUG_HC("sending stat packet\n");
8336
8337 /* Set the size of the skb to the size of the full
8338 * ipw header and 802.11 frame */
8339 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8340 IPW_RX_FRAME_SIZE);
8341
8342 /* Advance past the ipw packet header to the 802.11 frame */
8343 skb_pull(skb, IPW_RX_FRAME_SIZE);
8344
b0a4e7d8 8345 /* Push the libipw_rx_stats before the 802.11 frame */
b095c381
JK		 8346 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
8347
8348 skb->dev = priv->ieee->dev;
8349
b0a4e7d8 8350 /* Point raw at the libipw_stats */
459a98ed 8351 skb_reset_mac_header(skb);
b095c381
JK		 8352
8353 skb->pkt_type = PACKET_OTHERHOST;
c1b4aa3f 8354 skb->protocol = cpu_to_be16(ETH_P_80211_STATS);
b095c381
JK		 8355 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8356 netif_rx(skb);
43f66a6c 8357 rxb->skb = NULL;
b095c381 8358 }
43f66a6c
JK		 8359}
8360
43f66a6c
JK		 8361/*
8362 * Main entry function for recieving a packet with 80211 headers. This
8363 * should be called when ever the FW has notified us that there is a new
8364 * skb in the recieve queue.
8365 */
8366static void ipw_rx(struct ipw_priv *priv)
8367{
8368 struct ipw_rx_mem_buffer *rxb;
8369 struct ipw_rx_packet *pkt;
b0a4e7d8 8370 struct libipw_hdr_4addr *header;
43f66a6c
JK		 8371 u32 r, w, i;
8372 u8 network_packet;
943dbef4 8373 u8 fill_rx = 0;
43f66a6c 8374
b095c381
JK		 8375 r = ipw_read32(priv, IPW_RX_READ_INDEX);
8376 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
943dbef4
DW		 8377 i = priv->rxq->read;
8378
8379 if (ipw_rx_queue_space (priv->rxq) > (RX_QUEUE_SIZE / 2))
8380 fill_rx = 1;
43f66a6c
JK		 8381
8382 while (i != r) {
8383 rxb = priv->rxq->queue[i];
43f66a6c
JK		 8384 if (unlikely(rxb == NULL)) {
8385 printk(KERN_CRIT "Queue not allocated!\n");
8386 break;
8387 }
43f66a6c
JK		 8388 priv->rxq->queue[i] = NULL;
8389
8390 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
b095c381 8391 IPW_RX_BUF_SIZE,
43f66a6c
JK		 8392 PCI_DMA_FROMDEVICE);
8393
8394 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8395 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
8396 pkt->header.message_type,
0edd5b44 8397 pkt->header.rx_seq_num, pkt->header.control_bits);
43f66a6c
JK		 8398
8399 switch (pkt->header.message_type) {
0edd5b44 8400 case RX_FRAME_TYPE: /* 802.11 frame */ {
b0a4e7d8 8401 struct libipw_rx_stats stats = {
851ca268 8402 .rssi = pkt->u.frame.rssi_dbm -
0edd5b44 8403 IPW_RSSI_TO_DBM,
c848d0af 8404 .signal =
21f8a73f 8405 pkt->u.frame.rssi_dbm -
b191608a 8406 IPW_RSSI_TO_DBM + 0x100,
c848d0af
JK		 8407 .noise =
8408 le16_to_cpu(pkt->u.frame.noise),
0edd5b44
JG		 8409 .rate = pkt->u.frame.rate,
8410 .mac_time = jiffies,
8411 .received_channel =
8412 pkt->u.frame.received_channel,
8413 .freq =
8414 (pkt->u.frame.
8415 control & (1 << 0)) ?
b0a4e7d8
JL		 8416 LIBIPW_24GHZ_BAND :
8417 LIBIPW_52GHZ_BAND,
a613bffd 8418 .len = le16_to_cpu(pkt->u.frame.length),
0edd5b44
JG		 8419 };
8420
8421 if (stats.rssi != 0)
b0a4e7d8 8422 stats.mask |= LIBIPW_STATMASK_RSSI;
0edd5b44 8423 if (stats.signal != 0)
b0a4e7d8 8424 stats.mask |= LIBIPW_STATMASK_SIGNAL;
c848d0af 8425 if (stats.noise != 0)
b0a4e7d8 8426 stats.mask |= LIBIPW_STATMASK_NOISE;
0edd5b44 8427 if (stats.rate != 0)
b0a4e7d8 8428 stats.mask |= LIBIPW_STATMASK_RATE;
0edd5b44
JG		 8429
8430 priv->rx_packets++;
43f66a6c 8431
d685b8c2
ZY		 8432#ifdef CONFIG_IPW2200_PROMISCUOUS
8433 if (priv->prom_net_dev && netif_running(priv->prom_net_dev))
8434 ipw_handle_promiscuous_rx(priv, rxb, &stats);
8435#endif
8436
b095c381 8437#ifdef CONFIG_IPW2200_MONITOR
0edd5b44 8438 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
459d4087 8439#ifdef CONFIG_IPW2200_RADIOTAP
d685b8c2
ZY		 8440
8441 ipw_handle_data_packet_monitor(priv,
8442 rxb,
8443 &stats);
24a47dbd 8444#else
d685b8c2
ZY		 8445 ipw_handle_data_packet(priv, rxb,
8446 &stats);
24a47dbd 8447#endif
0edd5b44
JG		 8448 break;
8449 }
43f66a6c 8450#endif
bf79451e 8451
0edd5b44 8452 header =
b0a4e7d8 8453 (struct libipw_hdr_4addr *)(rxb->skb->
0dacca1f
JK		 8454 data +
8455 IPW_RX_FRAME_SIZE);
43f66a6c
JK		 8456 /* TODO: Check Ad-Hoc dest/source and make sure
8457 * that we are actually parsing these packets
bf79451e 8458 * correctly -- we should probably use the
43f66a6c
JK		 8459 * frame control of the packet and disregard
8460 * the current iw_mode */
0edd5b44 8461
ea2b26e0
JK		 8462 network_packet =
8463 is_network_packet(priv, header);
0edd5b44
JG		 8464 if (network_packet && priv->assoc_network) {
8465 priv->assoc_network->stats.rssi =
8466 stats.rssi;
00d21de5
ZY		 8467 priv->exp_avg_rssi =
8468 exponential_average(priv->exp_avg_rssi,
8469 stats.rssi, DEPTH_RSSI);
0edd5b44
JG		 8470 }
8471
8472 IPW_DEBUG_RX("Frame: len=%u\n",
a613bffd 8473 le16_to_cpu(pkt->u.frame.length));
0edd5b44 8474
a613bffd 8475 if (le16_to_cpu(pkt->u.frame.length) <
b0a4e7d8 8476 libipw_get_hdrlen(le16_to_cpu(
9d0be03a 8477 header->frame_ctl))) {
0edd5b44
JG		 8478 IPW_DEBUG_DROP
8479 ("Received packet is too small. "
8480 "Dropping.\n");
ce55cbaf 8481 priv->net_dev->stats.rx_errors++;
0edd5b44
JG		 8482 priv->wstats.discard.misc++;
8483 break;
8484 }
8485
a613bffd
JK		 8486 switch (WLAN_FC_GET_TYPE
8487 (le16_to_cpu(header->frame_ctl))) {
b095c381 8488
0edd5b44 8489 case IEEE80211_FTYPE_MGMT:
b095c381
JK		 8490 ipw_handle_mgmt_packet(priv, rxb,
8491 &stats);
0edd5b44
JG		 8492 break;
8493
8494 case IEEE80211_FTYPE_CTL:
8495 break;
8496
8497 case IEEE80211_FTYPE_DATA:
afbf30a2
JK		 8498 if (unlikely(!network_packet ||
8499 is_duplicate_packet(priv,
8500 header)))
8501 {
0edd5b44 8502 IPW_DEBUG_DROP("Dropping: "
e174961c
JB		 8503 "%pM, "
8504 "%pM, "
8505 "%pM\n",
8506 header->addr1,
8507 header->addr2,
8508 header->addr3);
b095c381
JK		 8509 break;
8510 }
8511
8512 ipw_handle_data_packet(priv, rxb,
8513 &stats);
8514
0edd5b44
JG		 8515 break;
8516 }
43f66a6c
JK		 8517 break;
8518 }
bf79451e 8519
0edd5b44
JG		 8520 case RX_HOST_NOTIFICATION_TYPE:{
8521 IPW_DEBUG_RX
8522 ("Notification: subtype=%02X flags=%02X size=%d\n",
43f66a6c
JK		 8523 pkt->u.notification.subtype,
8524 pkt->u.notification.flags,
720eeb43 8525 le16_to_cpu(pkt->u.notification.size));
0edd5b44
JG		 8526 ipw_rx_notification(priv, &pkt->u.notification);
8527 break;
8528 }
43f66a6c
JK		 8529
8530 default:
8531 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8532 pkt->header.message_type);
8533 break;
8534 }
bf79451e
JG		 8535
8536 /* For now we just don't re-use anything. We can tweak this
8537 * later to try and re-use notification packets and SKBs that
43f66a6c
JK		 8538 * fail to Rx correctly */
8539 if (rxb->skb != NULL) {
8540 dev_kfree_skb_any(rxb->skb);
8541 rxb->skb = NULL;
8542 }
bf79451e 8543
43f66a6c 8544 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
b095c381 8545 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 8546 list_add_tail(&rxb->list, &priv->rxq->rx_used);
bf79451e 8547
43f66a6c 8548 i = (i + 1) % RX_QUEUE_SIZE;
943dbef4
DW		 8549
8550 /* If there are a lot of unsued frames, restock the Rx queue
8551 * so the ucode won't assert */
8552 if (fill_rx) {
8553 priv->rxq->read = i;
8554 ipw_rx_queue_replenish(priv);
8555 }
43f66a6c
JK		 8556 }
8557
8558 /* Backtrack one entry */
943dbef4 8559 priv->rxq->read = i;
43f66a6c
JK		 8560 ipw_rx_queue_restock(priv);
8561}
8562
afbf30a2
JK		 8563#define DEFAULT_RTS_THRESHOLD 2304U
8564#define MIN_RTS_THRESHOLD 1U
8565#define MAX_RTS_THRESHOLD 2304U
8566#define DEFAULT_BEACON_INTERVAL 100U
8567#define DEFAULT_SHORT_RETRY_LIMIT 7U
8568#define DEFAULT_LONG_RETRY_LIMIT 4U
8569
d6d5b5c1
ZY		 8570/**
8571 * ipw_sw_reset
8572 * @option: options to control different reset behaviour
8573 * 0 = reset everything except the 'disable' module_param
8574 * 1 = reset everything and print out driver info (for probe only)
8575 * 2 = reset everything
8576 */
8577static int ipw_sw_reset(struct ipw_priv *priv, int option)
43f66a6c 8578{
afbf30a2
JK		 8579 int band, modulation;
8580 int old_mode = priv->ieee->iw_mode;
43f66a6c 8581
afbf30a2
JK		 8582 /* Initialize module parameter values here */
8583 priv->config = 0;
43f66a6c 8584
afbf30a2
JK		 8585 /* We default to disabling the LED code as right now it causes
8586 * too many systems to lock up... */
21f8a73f 8587 if (!led_support)
afbf30a2 8588 priv->config |= CFG_NO_LED;
43f66a6c 8589
afbf30a2
JK		 8590 if (associate)
8591 priv->config |= CFG_ASSOCIATE;
8592 else
8593 IPW_DEBUG_INFO("Auto associate disabled.\n");
bf79451e 8594
afbf30a2
JK		 8595 if (auto_create)
8596 priv->config |= CFG_ADHOC_CREATE;
8597 else
8598 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
43f66a6c 8599
17ed081d
ZY		 8600 priv->config &= ~CFG_STATIC_ESSID;
8601 priv->essid_len = 0;
8602 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8603
d6d5b5c1 8604 if (disable && option) {
afbf30a2
JK		 8605 priv->status |= STATUS_RF_KILL_SW;
8606 IPW_DEBUG_INFO("Radio disabled.\n");
43f66a6c 8607 }
bf79451e 8608
21f8a73f 8609 if (default_channel != 0) {
afbf30a2 8610 priv->config |= CFG_STATIC_CHANNEL;
21f8a73f
RC		 8611 priv->channel = default_channel;
8612 IPW_DEBUG_INFO("Bind to static channel %d\n", default_channel);
afbf30a2 8613 /* TODO: Validate that provided channel is in range */
43f66a6c 8614 }
e43e3c1e 8615#ifdef CONFIG_IPW2200_QOS
afbf30a2
JK		 8616 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8617 burst_duration_CCK, burst_duration_OFDM);
e43e3c1e 8618#endif /* CONFIG_IPW2200_QOS */
43f66a6c 8619
21f8a73f 8620 switch (network_mode) {
afbf30a2
JK		 8621 case 1:
8622 priv->ieee->iw_mode = IW_MODE_ADHOC;
8623 priv->net_dev->type = ARPHRD_ETHER;
8624
8625 break;
8626#ifdef CONFIG_IPW2200_MONITOR
8627 case 2:
8628 priv->ieee->iw_mode = IW_MODE_MONITOR;
459d4087 8629#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 8630 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8631#else
afbf30a2 8632 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8633#endif
afbf30a2
JK		 8634 break;
8635#endif
8636 default:
8637 case 0:
8638 priv->net_dev->type = ARPHRD_ETHER;
8639 priv->ieee->iw_mode = IW_MODE_INFRA;
8640 break;
43f66a6c
JK		 8641 }
8642
afbf30a2
JK		 8643 if (hwcrypto) {
8644 priv->ieee->host_encrypt = 0;
8645 priv->ieee->host_encrypt_msdu = 0;
8646 priv->ieee->host_decrypt = 0;
567deaf6 8647 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 8648 }
8649 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
43f66a6c 8650
e402c937
ZY		 8651 /* IPW2200/2915 is abled to do hardware fragmentation. */
8652 priv->ieee->host_open_frag = 0;
bf79451e 8653
afbf30a2
JK		 8654 if ((priv->pci_dev->device == 0x4223) ||
8655 (priv->pci_dev->device == 0x4224)) {
e8c69e27 8656 if (option == 1)
afbf30a2
JK		 8657 printk(KERN_INFO DRV_NAME
8658 ": Detected Intel PRO/Wireless 2915ABG Network "
8659 "Connection\n");
8660 priv->ieee->abg_true = 1;
b0a4e7d8
JL		 8661 band = LIBIPW_52GHZ_BAND | LIBIPW_24GHZ_BAND;
8662 modulation = LIBIPW_OFDM_MODULATION |
8663 LIBIPW_CCK_MODULATION;
afbf30a2
JK		 8664 priv->adapter = IPW_2915ABG;
8665 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
43f66a6c 8666 } else {
e8c69e27 8667 if (option == 1)
afbf30a2
JK		 8668 printk(KERN_INFO DRV_NAME
8669 ": Detected Intel PRO/Wireless 2200BG Network "
8670 "Connection\n");
bf79451e 8671
afbf30a2 8672 priv->ieee->abg_true = 0;
b0a4e7d8
JL		 8673 band = LIBIPW_24GHZ_BAND;
8674 modulation = LIBIPW_OFDM_MODULATION |
8675 LIBIPW_CCK_MODULATION;
afbf30a2
JK		 8676 priv->adapter = IPW_2200BG;
8677 priv->ieee->mode = IEEE_G | IEEE_B;
43f66a6c
JK		 8678 }
8679
afbf30a2
JK		 8680 priv->ieee->freq_band = band;
8681 priv->ieee->modulation = modulation;
43f66a6c 8682
b0a4e7d8 8683 priv->rates_mask = LIBIPW_DEFAULT_RATES_MASK;
bf79451e 8684
afbf30a2
JK		 8685 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8686 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
43f66a6c 8687
afbf30a2
JK		 8688 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8689 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8690 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
43f66a6c 8691
afbf30a2
JK		 8692 /* If power management is turned on, default to AC mode */
8693 priv->power_mode = IPW_POWER_AC;
8694 priv->tx_power = IPW_TX_POWER_DEFAULT;
8695
0ece35b5 8696 return old_mode == priv->ieee->iw_mode;
43f66a6c
JK		 8697}
8698
8699/*
8700 * This file defines the Wireless Extension handlers. It does not
8701 * define any methods of hardware manipulation and relies on the
8702 * functions defined in ipw_main to provide the HW interaction.
bf79451e
JG		 8703 *
8704 * The exception to this is the use of the ipw_get_ordinal()
43f66a6c
JK		 8705 * function used to poll the hardware vs. making unecessary calls.
8706 *
8707 */
8708
43f66a6c
JK		 8709static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8710{
8711 if (channel == 0) {
8712 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8713 priv->config &= ~CFG_STATIC_CHANNEL;
c848d0af
JK		 8714 IPW_DEBUG_ASSOC("Attempting to associate with new "
8715 "parameters.\n");
8716 ipw_associate(priv);
43f66a6c
JK		 8717 return 0;
8718 }
8719
8720 priv->config |= CFG_STATIC_CHANNEL;
8721
8722 if (priv->channel == channel) {
0edd5b44
JG		 8723 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8724 channel);
43f66a6c
JK		 8725 return 0;
8726 }
8727
8728 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8729 priv->channel = channel;
8730
b095c381
JK		 8731#ifdef CONFIG_IPW2200_MONITOR
8732 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 8733 int i;
b095c381 8734 if (priv->status & STATUS_SCANNING) {
afbf30a2 8735 IPW_DEBUG_SCAN("Scan abort triggered due to "
b095c381 8736 "channel change.\n");
afbf30a2 8737 ipw_abort_scan(priv);
b095c381
JK		 8738 }
8739
8740 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8741 udelay(10);
8742
8743 if (priv->status & STATUS_SCANNING)
8744 IPW_DEBUG_SCAN("Still scanning...\n");
8745 else
8746 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8747 1000 - i);
8748
8749 return 0;
43f66a6c 8750 }
b095c381
JK		 8751#endif /* CONFIG_IPW2200_MONITOR */
8752
c848d0af
JK		 8753 /* Network configuration changed -- force [re]association */
8754 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8755 if (!ipw_disassociate(priv))
43f66a6c 8756 ipw_associate(priv);
43f66a6c
JK		 8757
8758 return 0;
8759}
8760
bf79451e
JG		 8761static int ipw_wx_set_freq(struct net_device *dev,
8762 struct iw_request_info *info,
8763 union iwreq_data *wrqu, char *extra)
43f66a6c 8764{
b0a4e7d8
JL		 8765 struct ipw_priv *priv = libipw_priv(dev);
8766 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
43f66a6c 8767 struct iw_freq *fwrq = &wrqu->freq;
afbf30a2 8768 int ret = 0, i;
1fe0adb4
LH		 8769 u8 channel, flags;
8770 int band;
b095c381
JK		 8771
8772 if (fwrq->m == 0) {
8773 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
4644151b 8774 mutex_lock(&priv->mutex);
b095c381 8775 ret = ipw_set_channel(priv, 0);
4644151b 8776 mutex_unlock(&priv->mutex);
b095c381
JK		 8777 return ret;
8778 }
43f66a6c
JK		 8779 /* if setting by freq convert to channel */
8780 if (fwrq->e == 1) {
b0a4e7d8 8781 channel = libipw_freq_to_channel(priv->ieee, fwrq->m);
b095c381
JK		 8782 if (channel == 0)
8783 return -EINVAL;
8784 } else
8785 channel = fwrq->m;
bf79451e 8786
b0a4e7d8 8787 if (!(band = libipw_is_valid_channel(priv->ieee, channel)))
b095c381 8788 return -EINVAL;
43f66a6c 8789
1fe0adb4 8790 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
b0a4e7d8 8791 i = libipw_channel_to_index(priv->ieee, channel);
afbf30a2
JK		 8792 if (i == -1)
8793 return -EINVAL;
bf79451e 8794
b0a4e7d8 8795 flags = (band == LIBIPW_24GHZ_BAND) ?
1fe0adb4 8796 geo->bg[i].flags : geo->a[i].flags;
b0a4e7d8 8797 if (flags & LIBIPW_CH_PASSIVE_ONLY) {
afbf30a2
JK		 8798 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8799 return -EINVAL;
43f66a6c
JK		 8800 }
8801 }
bf79451e 8802
9fd1ea42 8803 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
4644151b 8804 mutex_lock(&priv->mutex);
b095c381 8805 ret = ipw_set_channel(priv, channel);
4644151b 8806 mutex_unlock(&priv->mutex);
c848d0af 8807 return ret;
43f66a6c
JK		 8808}
8809
bf79451e
JG		 8810static int ipw_wx_get_freq(struct net_device *dev,
8811 struct iw_request_info *info,
43f66a6c
JK		 8812 union iwreq_data *wrqu, char *extra)
8813{
b0a4e7d8 8814 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 8815
8816 wrqu->freq.e = 0;
8817
8818 /* If we are associated, trying to associate, or have a statically
8819 * configured CHANNEL then return that; otherwise return ANY */
4644151b 8820 mutex_lock(&priv->mutex);
43f66a6c 8821 if (priv->config & CFG_STATIC_CHANNEL ||
c580f67f
ZY		 8822 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) {
8823 int i;
8824
b0a4e7d8 8825 i = libipw_channel_to_index(priv->ieee, priv->channel);
c580f67f
ZY		 8826 BUG_ON(i == -1);
8827 wrqu->freq.e = 1;
8828
b0a4e7d8
JL		 8829 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
8830 case LIBIPW_52GHZ_BAND:
c580f67f
ZY		 8831 wrqu->freq.m = priv->ieee->geo.a[i].freq * 100000;
8832 break;
8833
b0a4e7d8 8834 case LIBIPW_24GHZ_BAND:
c580f67f
ZY		 8835 wrqu->freq.m = priv->ieee->geo.bg[i].freq * 100000;
8836 break;
8837
8838 default:
8839 BUG();
8840 }
8841 } else
43f66a6c
JK		 8842 wrqu->freq.m = 0;
8843
4644151b 8844 mutex_unlock(&priv->mutex);
9fd1ea42 8845 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
43f66a6c
JK		 8846 return 0;
8847}
8848
bf79451e
JG		 8849static int ipw_wx_set_mode(struct net_device *dev,
8850 struct iw_request_info *info,
43f66a6c
JK		 8851 union iwreq_data *wrqu, char *extra)
8852{
b0a4e7d8 8853 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 8854 int err = 0;
8855
8856 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8857
43f66a6c 8858 switch (wrqu->mode) {
b095c381 8859#ifdef CONFIG_IPW2200_MONITOR
43f66a6c
JK		 8860 case IW_MODE_MONITOR:
8861#endif
8862 case IW_MODE_ADHOC:
8863 case IW_MODE_INFRA:
8864 break;
8865 case IW_MODE_AUTO:
8866 wrqu->mode = IW_MODE_INFRA;
8867 break;
8868 default:
8869 return -EINVAL;
8870 }
b095c381
JK		 8871 if (wrqu->mode == priv->ieee->iw_mode)
8872 return 0;
43f66a6c 8873
4644151b 8874 mutex_lock(&priv->mutex);
43f66a6c 8875
afbf30a2
JK		 8876 ipw_sw_reset(priv, 0);
8877
b095c381 8878#ifdef CONFIG_IPW2200_MONITOR
bf79451e 8879 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
43f66a6c 8880 priv->net_dev->type = ARPHRD_ETHER;
bf79451e
JG		 8881
8882 if (wrqu->mode == IW_MODE_MONITOR)
459d4087 8883#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 8884 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8885#else
43f66a6c 8886 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8887#endif
b095c381 8888#endif /* CONFIG_IPW2200_MONITOR */
bf79451e 8889
bf79451e 8890 /* Free the existing firmware and reset the fw_loaded
877d0310 8891 * flag so ipw_load() will bring in the new firmware */
afbf30a2 8892 free_firmware();
43f66a6c
JK		 8893
8894 priv->ieee->iw_mode = wrqu->mode;
bf79451e 8895
c848d0af 8896 queue_work(priv->workqueue, &priv->adapter_restart);
4644151b 8897 mutex_unlock(&priv->mutex);
0edd5b44 8898 return err;
43f66a6c
JK		 8899}
8900
bf79451e 8901static int ipw_wx_get_mode(struct net_device *dev,
0edd5b44
JG		 8902 struct iw_request_info *info,
8903 union iwreq_data *wrqu, char *extra)
43f66a6c 8904{
b0a4e7d8 8905 struct ipw_priv *priv = libipw_priv(dev);
4644151b 8906 mutex_lock(&priv->mutex);
43f66a6c
JK		 8907 wrqu->mode = priv->ieee->iw_mode;
8908 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
4644151b 8909 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8910 return 0;
8911}
8912
43f66a6c
JK		 8913/* Values are in microsecond */
8914static const s32 timeout_duration[] = {
8915 350000,
8916 250000,
8917 75000,
8918 37000,
8919 25000,
8920};
8921
8922static const s32 period_duration[] = {
8923 400000,
8924 700000,
8925 1000000,
8926 1000000,
8927 1000000
8928};
8929
bf79451e
JG		 8930static int ipw_wx_get_range(struct net_device *dev,
8931 struct iw_request_info *info,
43f66a6c
JK		 8932 union iwreq_data *wrqu, char *extra)
8933{
b0a4e7d8 8934 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 8935 struct iw_range *range = (struct iw_range *)extra;
b0a4e7d8 8936 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
b095c381 8937 int i = 0, j;
43f66a6c
JK		 8938
8939 wrqu->data.length = sizeof(*range);
8940 memset(range, 0, sizeof(*range));
8941
8942 /* 54Mbs == ~27 Mb/s real (802.11g) */
bf79451e 8943 range->throughput = 27 * 1000 * 1000;
43f66a6c
JK		 8944
8945 range->max_qual.qual = 100;
8946 /* TODO: Find real max RSSI and stick here */
8947 range->max_qual.level = 0;
b191608a 8948 range->max_qual.noise = 0;
0edd5b44 8949 range->max_qual.updated = 7; /* Updated all three */
43f66a6c
JK		 8950
8951 range->avg_qual.qual = 70;
af901ca1 8952 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
0edd5b44 8953 range->avg_qual.level = 0; /* FIXME to real average level */
43f66a6c 8954 range->avg_qual.noise = 0;
0edd5b44 8955 range->avg_qual.updated = 7; /* Updated all three */
4644151b 8956 mutex_lock(&priv->mutex);
0edd5b44 8957 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
43f66a6c 8958
bf79451e
JG		 8959 for (i = 0; i < range->num_bitrates; i++)
8960 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
0edd5b44 8961 500000;
bf79451e 8962
43f66a6c
JK		 8963 range->max_rts = DEFAULT_RTS_THRESHOLD;
8964 range->min_frag = MIN_FRAG_THRESHOLD;
8965 range->max_frag = MAX_FRAG_THRESHOLD;
8966
8967 range->encoding_size[0] = 5;
bf79451e 8968 range->encoding_size[1] = 13;
43f66a6c
JK		 8969 range->num_encoding_sizes = 2;
8970 range->max_encoding_tokens = WEP_KEYS;
8971
8972 /* Set the Wireless Extension versions */
8973 range->we_version_compiled = WIRELESS_EXT;
f1b50863 8974 range->we_version_source = 18;
43f66a6c 8975
b095c381
JK		 8976 i = 0;
8977 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
e815de42
ZY		 8978 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8979 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
b0a4e7d8 8980 (geo->bg[j].flags & LIBIPW_CH_PASSIVE_ONLY))
e815de42
ZY		 8981 continue;
8982
b095c381
JK		 8983 range->freq[i].i = geo->bg[j].channel;
8984 range->freq[i].m = geo->bg[j].freq * 100000;
8985 range->freq[i].e = 1;
e815de42 8986 i++;
b095c381
JK		 8987 }
8988 }
43f66a6c 8989
b095c381 8990 if (priv->ieee->mode & IEEE_A) {
e815de42
ZY		 8991 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8992 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
b0a4e7d8 8993 (geo->a[j].flags & LIBIPW_CH_PASSIVE_ONLY))
e815de42
ZY		 8994 continue;
8995
b095c381
JK		 8996 range->freq[i].i = geo->a[j].channel;
8997 range->freq[i].m = geo->a[j].freq * 100000;
8998 range->freq[i].e = 1;
e815de42 8999 i++;
b095c381 9000 }
43f66a6c 9001 }
b095c381
JK		 9002
9003 range->num_channels = i;
9004 range->num_frequency = i;
9005
4644151b 9006 mutex_unlock(&priv->mutex);
97a78ca9
BB		 9007
9008 /* Event capability (kernel + driver) */
9009 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
9010 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
07f02e46
ZY		 9011 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
9012 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
97a78ca9 9013 range->event_capa[1] = IW_EVENT_CAPA_K_1;
43f66a6c 9014
f1b50863
DW		 9015 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
9016 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
9017
374fdfbc
DW		 9018 range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
9019
43f66a6c
JK		 9020 IPW_DEBUG_WX("GET Range\n");
9021 return 0;
9022}
9023
bf79451e
JG		 9024static int ipw_wx_set_wap(struct net_device *dev,
9025 struct iw_request_info *info,
43f66a6c
JK		 9026 union iwreq_data *wrqu, char *extra)
9027{
b0a4e7d8 9028 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9029
9030 static const unsigned char any[] = {
9031 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
9032 };
9033 static const unsigned char off[] = {
9034 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
9035 };
9036
bf79451e 9037 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
43f66a6c 9038 return -EINVAL;
4644151b 9039 mutex_lock(&priv->mutex);
43f66a6c
JK		 9040 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
9041 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
9042 /* we disable mandatory BSSID association */
9043 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
9044 priv->config &= ~CFG_STATIC_BSSID;
c848d0af
JK		 9045 IPW_DEBUG_ASSOC("Attempting to associate with new "
9046 "parameters.\n");
9047 ipw_associate(priv);
4644151b 9048 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9049 return 0;
9050 }
9051
9052 priv->config |= CFG_STATIC_BSSID;
9053 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
9054 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
4644151b 9055 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9056 return 0;
9057 }
9058
e174961c
JB		 9059 IPW_DEBUG_WX("Setting mandatory BSSID to %pM\n",
9060 wrqu->ap_addr.sa_data);
43f66a6c
JK		 9061
9062 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
9063
c848d0af
JK		 9064 /* Network configuration changed -- force [re]association */
9065 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
9066 if (!ipw_disassociate(priv))
43f66a6c 9067 ipw_associate(priv);
43f66a6c 9068
4644151b 9069 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9070 return 0;
9071}
9072
bf79451e
JG		 9073static int ipw_wx_get_wap(struct net_device *dev,
9074 struct iw_request_info *info,
43f66a6c
JK		 9075 union iwreq_data *wrqu, char *extra)
9076{
b0a4e7d8 9077 struct ipw_priv *priv = libipw_priv(dev);
0795af57 9078
43f66a6c
JK		 9079 /* If we are associated, trying to associate, or have a statically
9080 * configured BSSID then return that; otherwise return ANY */
4644151b 9081 mutex_lock(&priv->mutex);
bf79451e 9082 if (priv->config & CFG_STATIC_BSSID ||
43f66a6c
JK		 9083 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9084 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
afbf30a2 9085 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
43f66a6c
JK		 9086 } else
9087 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
9088
e174961c
JB		 9089 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n",
9090 wrqu->ap_addr.sa_data);
4644151b 9091 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9092 return 0;
9093}
9094
bf79451e
JG		 9095static int ipw_wx_set_essid(struct net_device *dev,
9096 struct iw_request_info *info,
43f66a6c
JK		 9097 union iwreq_data *wrqu, char *extra)
9098{
b0a4e7d8 9099 struct ipw_priv *priv = libipw_priv(dev);
ab644b0b 9100 int length;
9387b7ca 9101 DECLARE_SSID_BUF(ssid);
ab644b0b
ZY		 9102
9103 mutex_lock(&priv->mutex);
43f66a6c 9104
ab644b0b
ZY		 9105 if (!wrqu->essid.flags)
9106 {
9107 IPW_DEBUG_WX("Setting ESSID to ANY\n");
9108 ipw_disassociate(priv);
9109 priv->config &= ~CFG_STATIC_ESSID;
9110 ipw_associate(priv);
9111 mutex_unlock(&priv->mutex);
9112 return 0;
9113 }
43f66a6c 9114
a9f0d423 9115 length = min((int)wrqu->essid.length, IW_ESSID_MAX_SIZE);
43f66a6c
JK		 9116
9117 priv->config |= CFG_STATIC_ESSID;
9118
a9f0d423
ZY		 9119 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)
9120 && (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) {
43f66a6c 9121 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
4644151b 9122 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9123 return 0;
9124 }
9125
9387b7ca
JL		 9126 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n",
9127 print_ssid(ssid, extra, length), length);
43f66a6c
JK		 9128
9129 priv->essid_len = length;
a9f0d423 9130 memcpy(priv->essid, extra, priv->essid_len);
bf79451e 9131
c848d0af
JK		 9132 /* Network configuration changed -- force [re]association */
9133 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
9134 if (!ipw_disassociate(priv))
43f66a6c 9135 ipw_associate(priv);
43f66a6c 9136
4644151b 9137 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9138 return 0;
9139}
9140
bf79451e
JG		 9141static int ipw_wx_get_essid(struct net_device *dev,
9142 struct iw_request_info *info,
43f66a6c
JK		 9143 union iwreq_data *wrqu, char *extra)
9144{
b0a4e7d8 9145 struct ipw_priv *priv = libipw_priv(dev);
9387b7ca 9146 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 9147
9148 /* If we are associated, trying to associate, or have a statically
9149 * configured ESSID then return that; otherwise return ANY */
4644151b 9150 mutex_lock(&priv->mutex);
43f66a6c 9151 if (priv->config & CFG_STATIC_ESSID ||
bf79451e
JG		 9152 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9153 IPW_DEBUG_WX("Getting essid: '%s'\n",
9387b7ca 9154 print_ssid(ssid, priv->essid, priv->essid_len));
bf79451e 9155 memcpy(extra, priv->essid, priv->essid_len);
43f66a6c 9156 wrqu->essid.length = priv->essid_len;
0edd5b44 9157 wrqu->essid.flags = 1; /* active */
43f66a6c
JK		 9158 } else {
9159 IPW_DEBUG_WX("Getting essid: ANY\n");
9160 wrqu->essid.length = 0;
0edd5b44 9161 wrqu->essid.flags = 0; /* active */
43f66a6c 9162 }
4644151b 9163 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9164 return 0;
9165}
9166
bf79451e
JG		 9167static int ipw_wx_set_nick(struct net_device *dev,
9168 struct iw_request_info *info,
43f66a6c 9169 union iwreq_data *wrqu, char *extra)
bf79451e 9170{
b0a4e7d8 9171 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9172
9173 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
9174 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9175 return -E2BIG;
4644151b 9176 mutex_lock(&priv->mutex);
0edd5b44 9177 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
43f66a6c 9178 memset(priv->nick, 0, sizeof(priv->nick));
0edd5b44 9179 memcpy(priv->nick, extra, wrqu->data.length);
43f66a6c 9180 IPW_DEBUG_TRACE("<<\n");
4644151b 9181 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9182 return 0;
9183
9184}
9185
bf79451e
JG		 9186static int ipw_wx_get_nick(struct net_device *dev,
9187 struct iw_request_info *info,
43f66a6c 9188 union iwreq_data *wrqu, char *extra)
bf79451e 9189{
b0a4e7d8 9190 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9191 IPW_DEBUG_WX("Getting nick\n");
4644151b 9192 mutex_lock(&priv->mutex);
919ee6dd 9193 wrqu->data.length = strlen(priv->nick);
43f66a6c 9194 memcpy(extra, priv->nick, wrqu->data.length);
0edd5b44 9195 wrqu->data.flags = 1; /* active */
4644151b 9196 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9197 return 0;
9198}
9199
651be26f
OH		 9200static int ipw_wx_set_sens(struct net_device *dev,
9201 struct iw_request_info *info,
9202 union iwreq_data *wrqu, char *extra)
9203{
b0a4e7d8 9204 struct ipw_priv *priv = libipw_priv(dev);
651be26f
OH		 9205 int err = 0;
9206
9207 IPW_DEBUG_WX("Setting roaming threshold to %d\n", wrqu->sens.value);
9208 IPW_DEBUG_WX("Setting disassociate threshold to %d\n", 3*wrqu->sens.value);
9209 mutex_lock(&priv->mutex);
9210
9211 if (wrqu->sens.fixed == 0)
9212 {
9213 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
9214 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
9215 goto out;
9216 }
9217 if ((wrqu->sens.value > IPW_MB_ROAMING_THRESHOLD_MAX) ||
9218 (wrqu->sens.value < IPW_MB_ROAMING_THRESHOLD_MIN)) {
9219 err = -EINVAL;
9220 goto out;
9221 }
9222
9223 priv->roaming_threshold = wrqu->sens.value;
9224 priv->disassociate_threshold = 3*wrqu->sens.value;
9225 out:
9226 mutex_unlock(&priv->mutex);
9227 return err;
9228}
9229
9230static int ipw_wx_get_sens(struct net_device *dev,
9231 struct iw_request_info *info,
9232 union iwreq_data *wrqu, char *extra)
9233{
b0a4e7d8 9234 struct ipw_priv *priv = libipw_priv(dev);
651be26f
OH		 9235 mutex_lock(&priv->mutex);
9236 wrqu->sens.fixed = 1;
9237 wrqu->sens.value = priv->roaming_threshold;
9238 mutex_unlock(&priv->mutex);
9239
9fd1ea42 9240 IPW_DEBUG_WX("GET roaming threshold -> %s %d\n",
651be26f
OH		 9241 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9242
9243 return 0;
9244}
9245
43f66a6c
JK		 9246static int ipw_wx_set_rate(struct net_device *dev,
9247 struct iw_request_info *info,
9248 union iwreq_data *wrqu, char *extra)
bf79451e 9249{
ea2b26e0 9250 /* TODO: We should use semaphores or locks for access to priv */
b0a4e7d8 9251 struct ipw_priv *priv = libipw_priv(dev);
ea2b26e0
JK		 9252 u32 target_rate = wrqu->bitrate.value;
9253 u32 fixed, mask;
9254
9255 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
9256 /* value = X, fixed = 1 means only rate X */
9257 /* value = X, fixed = 0 means all rates lower equal X */
9258
9259 if (target_rate == -1) {
9260 fixed = 0;
b0a4e7d8 9261 mask = LIBIPW_DEFAULT_RATES_MASK;
ea2b26e0
JK		 9262 /* Now we should reassociate */
9263 goto apply;
9264 }
9265
9266 mask = 0;
9267 fixed = wrqu->bitrate.fixed;
9268
9269 if (target_rate == 1000000 || !fixed)
b0a4e7d8 9270 mask |= LIBIPW_CCK_RATE_1MB_MASK;
ea2b26e0
JK		 9271 if (target_rate == 1000000)
9272 goto apply;
9273
9274 if (target_rate == 2000000 || !fixed)
b0a4e7d8 9275 mask |= LIBIPW_CCK_RATE_2MB_MASK;
ea2b26e0
JK		 9276 if (target_rate == 2000000)
9277 goto apply;
9278
9279 if (target_rate == 5500000 || !fixed)
b0a4e7d8 9280 mask |= LIBIPW_CCK_RATE_5MB_MASK;
ea2b26e0
JK		 9281 if (target_rate == 5500000)
9282 goto apply;
9283
9284 if (target_rate == 6000000 || !fixed)
b0a4e7d8 9285 mask |= LIBIPW_OFDM_RATE_6MB_MASK;
ea2b26e0
JK		 9286 if (target_rate == 6000000)
9287 goto apply;
9288
9289 if (target_rate == 9000000 || !fixed)
b0a4e7d8 9290 mask |= LIBIPW_OFDM_RATE_9MB_MASK;
ea2b26e0
JK		 9291 if (target_rate == 9000000)
9292 goto apply;
9293
9294 if (target_rate == 11000000 || !fixed)
b0a4e7d8 9295 mask |= LIBIPW_CCK_RATE_11MB_MASK;
ea2b26e0
JK		 9296 if (target_rate == 11000000)
9297 goto apply;
9298
9299 if (target_rate == 12000000 || !fixed)
b0a4e7d8 9300 mask |= LIBIPW_OFDM_RATE_12MB_MASK;
ea2b26e0
JK		 9301 if (target_rate == 12000000)
9302 goto apply;
9303
9304 if (target_rate == 18000000 || !fixed)
b0a4e7d8 9305 mask |= LIBIPW_OFDM_RATE_18MB_MASK;
ea2b26e0
JK		 9306 if (target_rate == 18000000)
9307 goto apply;
9308
9309 if (target_rate == 24000000 || !fixed)
b0a4e7d8 9310 mask |= LIBIPW_OFDM_RATE_24MB_MASK;
ea2b26e0
JK		 9311 if (target_rate == 24000000)
9312 goto apply;
9313
9314 if (target_rate == 36000000 || !fixed)
b0a4e7d8 9315 mask |= LIBIPW_OFDM_RATE_36MB_MASK;
ea2b26e0
JK		 9316 if (target_rate == 36000000)
9317 goto apply;
9318
9319 if (target_rate == 48000000 || !fixed)
b0a4e7d8 9320 mask |= LIBIPW_OFDM_RATE_48MB_MASK;
ea2b26e0
JK		 9321 if (target_rate == 48000000)
9322 goto apply;
9323
9324 if (target_rate == 54000000 || !fixed)
b0a4e7d8 9325 mask |= LIBIPW_OFDM_RATE_54MB_MASK;
ea2b26e0
JK		 9326 if (target_rate == 54000000)
9327 goto apply;
9328
9329 IPW_DEBUG_WX("invalid rate specified, returning error\n");
9330 return -EINVAL;
9331
9332 apply:
9333 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
9334 mask, fixed ? "fixed" : "sub-rates");
4644151b 9335 mutex_lock(&priv->mutex);
b0a4e7d8 9336 if (mask == LIBIPW_DEFAULT_RATES_MASK) {
ea2b26e0 9337 priv->config &= ~CFG_FIXED_RATE;
b095c381
JK		 9338 ipw_set_fixed_rate(priv, priv->ieee->mode);
9339 } else
ea2b26e0
JK		 9340 priv->config |= CFG_FIXED_RATE;
9341
c848d0af
JK		 9342 if (priv->rates_mask == mask) {
9343 IPW_DEBUG_WX("Mask set to current mask.\n");
4644151b 9344 mutex_unlock(&priv->mutex);
c848d0af 9345 return 0;
ea2b26e0
JK		 9346 }
9347
c848d0af
JK		 9348 priv->rates_mask = mask;
9349
9350 /* Network configuration changed -- force [re]association */
9351 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
9352 if (!ipw_disassociate(priv))
9353 ipw_associate(priv);
9354
4644151b 9355 mutex_unlock(&priv->mutex);
ea2b26e0 9356 return 0;
43f66a6c
JK		 9357}
9358
bf79451e
JG		 9359static int ipw_wx_get_rate(struct net_device *dev,
9360 struct iw_request_info *info,
43f66a6c 9361 union iwreq_data *wrqu, char *extra)
bf79451e 9362{
b0a4e7d8 9363 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9364 mutex_lock(&priv->mutex);
43f66a6c 9365 wrqu->bitrate.value = priv->last_rate;
455936c7 9366 wrqu->bitrate.fixed = (priv->config & CFG_FIXED_RATE) ? 1 : 0;
4644151b 9367 mutex_unlock(&priv->mutex);
9fd1ea42 9368 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
43f66a6c
JK		 9369 return 0;
9370}
9371
bf79451e
JG		 9372static int ipw_wx_set_rts(struct net_device *dev,
9373 struct iw_request_info *info,
43f66a6c 9374 union iwreq_data *wrqu, char *extra)
bf79451e 9375{
b0a4e7d8 9376 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9377 mutex_lock(&priv->mutex);
ea8862dc 9378 if (wrqu->rts.disabled || !wrqu->rts.fixed)
43f66a6c
JK		 9379 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9380 else {
9381 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
c848d0af 9382 wrqu->rts.value > MAX_RTS_THRESHOLD) {
4644151b 9383 mutex_unlock(&priv->mutex);
43f66a6c 9384 return -EINVAL;
c848d0af 9385 }
43f66a6c
JK		 9386 priv->rts_threshold = wrqu->rts.value;
9387 }
9388
9389 ipw_send_rts_threshold(priv, priv->rts_threshold);
4644151b 9390 mutex_unlock(&priv->mutex);
9fd1ea42 9391 IPW_DEBUG_WX("SET RTS Threshold -> %d\n", priv->rts_threshold);
43f66a6c
JK		 9392 return 0;
9393}
9394
bf79451e
JG		 9395static int ipw_wx_get_rts(struct net_device *dev,
9396 struct iw_request_info *info,
43f66a6c 9397 union iwreq_data *wrqu, char *extra)
bf79451e 9398{
b0a4e7d8 9399 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9400 mutex_lock(&priv->mutex);
43f66a6c
JK		 9401 wrqu->rts.value = priv->rts_threshold;
9402 wrqu->rts.fixed = 0; /* no auto select */
0edd5b44 9403 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
4644151b 9404 mutex_unlock(&priv->mutex);
9fd1ea42 9405 IPW_DEBUG_WX("GET RTS Threshold -> %d\n", wrqu->rts.value);
43f66a6c
JK		 9406 return 0;
9407}
9408
bf79451e
JG		 9409static int ipw_wx_set_txpow(struct net_device *dev,
9410 struct iw_request_info *info,
43f66a6c 9411 union iwreq_data *wrqu, char *extra)
bf79451e 9412{
b0a4e7d8 9413 struct ipw_priv *priv = libipw_priv(dev);
6de9f7f2 9414 int err = 0;
43f66a6c 9415
4644151b 9416 mutex_lock(&priv->mutex);
c848d0af 9417 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
6de9f7f2
ZY		 9418 err = -EINPROGRESS;
9419 goto out;
43f66a6c 9420 }
43f66a6c 9421
b095c381
JK		 9422 if (!wrqu->power.fixed)
9423 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9424
c848d0af 9425 if (wrqu->power.flags != IW_TXPOW_DBM) {
6de9f7f2
ZY		 9426 err = -EINVAL;
9427 goto out;
c848d0af 9428 }
43f66a6c 9429
b095c381 9430 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
afbf30a2 9431 (wrqu->power.value < IPW_TX_POWER_MIN)) {
6de9f7f2
ZY		 9432 err = -EINVAL;
9433 goto out;
c848d0af 9434 }
43f66a6c 9435
43f66a6c 9436 priv->tx_power = wrqu->power.value;
6de9f7f2
ZY		 9437 err = ipw_set_tx_power(priv);
9438 out:
4644151b 9439 mutex_unlock(&priv->mutex);
6de9f7f2 9440 return err;
43f66a6c
JK		 9441}
9442
bf79451e
JG		 9443static int ipw_wx_get_txpow(struct net_device *dev,
9444 struct iw_request_info *info,
43f66a6c 9445 union iwreq_data *wrqu, char *extra)
bf79451e 9446{
b0a4e7d8 9447 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9448 mutex_lock(&priv->mutex);
43f66a6c
JK		 9449 wrqu->power.value = priv->tx_power;
9450 wrqu->power.fixed = 1;
9451 wrqu->power.flags = IW_TXPOW_DBM;
9452 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
4644151b 9453 mutex_unlock(&priv->mutex);
43f66a6c 9454
9fd1ea42 9455 IPW_DEBUG_WX("GET TX Power -> %s %d\n",
22501c8e 9456 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
43f66a6c
JK		 9457
9458 return 0;
9459}
9460
bf79451e 9461static int ipw_wx_set_frag(struct net_device *dev,
0edd5b44
JG		 9462 struct iw_request_info *info,
9463 union iwreq_data *wrqu, char *extra)
43f66a6c 9464{
b0a4e7d8 9465 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9466 mutex_lock(&priv->mutex);
ea8862dc 9467 if (wrqu->frag.disabled || !wrqu->frag.fixed)
43f66a6c
JK		 9468 priv->ieee->fts = DEFAULT_FTS;
9469 else {
9470 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
b095c381 9471 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
4644151b 9472 mutex_unlock(&priv->mutex);
43f66a6c 9473 return -EINVAL;
b095c381 9474 }
bf79451e 9475
43f66a6c
JK		 9476 priv->ieee->fts = wrqu->frag.value & ~0x1;
9477 }
9478
9479 ipw_send_frag_threshold(priv, wrqu->frag.value);
4644151b 9480 mutex_unlock(&priv->mutex);
9fd1ea42 9481 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", wrqu->frag.value);
43f66a6c
JK		 9482 return 0;
9483}
9484
bf79451e 9485static int ipw_wx_get_frag(struct net_device *dev,
0edd5b44
JG		 9486 struct iw_request_info *info,
9487 union iwreq_data *wrqu, char *extra)
43f66a6c 9488{
b0a4e7d8 9489 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9490 mutex_lock(&priv->mutex);
43f66a6c
JK		 9491 wrqu->frag.value = priv->ieee->fts;
9492 wrqu->frag.fixed = 0; /* no auto select */
0edd5b44 9493 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
4644151b 9494 mutex_unlock(&priv->mutex);
9fd1ea42 9495 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
43f66a6c
JK		 9496
9497 return 0;
9498}
9499
bf79451e
JG		 9500static int ipw_wx_set_retry(struct net_device *dev,
9501 struct iw_request_info *info,
43f66a6c 9502 union iwreq_data *wrqu, char *extra)
bf79451e 9503{
b0a4e7d8 9504 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2
JK		 9505
9506 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9507 return -EINVAL;
9508
9509 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9510 return 0;
9511
d5f7ac20 9512 if (wrqu->retry.value < 0 || wrqu->retry.value >= 255)
afbf30a2
JK		 9513 return -EINVAL;
9514
4644151b 9515 mutex_lock(&priv->mutex);
919ee6dd 9516 if (wrqu->retry.flags & IW_RETRY_SHORT)
afbf30a2 9517 priv->short_retry_limit = (u8) wrqu->retry.value;
919ee6dd 9518 else if (wrqu->retry.flags & IW_RETRY_LONG)
afbf30a2
JK		 9519 priv->long_retry_limit = (u8) wrqu->retry.value;
9520 else {
9521 priv->short_retry_limit = (u8) wrqu->retry.value;
9522 priv->long_retry_limit = (u8) wrqu->retry.value;
9523 }
9524
9525 ipw_send_retry_limit(priv, priv->short_retry_limit,
9526 priv->long_retry_limit);
4644151b 9527 mutex_unlock(&priv->mutex);
afbf30a2
JK		 9528 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9529 priv->short_retry_limit, priv->long_retry_limit);
9530 return 0;
43f66a6c
JK		 9531}
9532
bf79451e
JG		 9533static int ipw_wx_get_retry(struct net_device *dev,
9534 struct iw_request_info *info,
43f66a6c 9535 union iwreq_data *wrqu, char *extra)
bf79451e 9536{
b0a4e7d8 9537 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 9538
4644151b 9539 mutex_lock(&priv->mutex);
afbf30a2
JK		 9540 wrqu->retry.disabled = 0;
9541
9542 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
4644151b 9543 mutex_unlock(&priv->mutex);
afbf30a2
JK		 9544 return -EINVAL;
9545 }
9546
919ee6dd
JT		 9547 if (wrqu->retry.flags & IW_RETRY_LONG) {
9548 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
afbf30a2 9549 wrqu->retry.value = priv->long_retry_limit;
919ee6dd
JT		 9550 } else if (wrqu->retry.flags & IW_RETRY_SHORT) {
9551 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
afbf30a2
JK		 9552 wrqu->retry.value = priv->short_retry_limit;
9553 } else {
9554 wrqu->retry.flags = IW_RETRY_LIMIT;
9555 wrqu->retry.value = priv->short_retry_limit;
9556 }
4644151b 9557 mutex_unlock(&priv->mutex);
afbf30a2 9558
9fd1ea42 9559 IPW_DEBUG_WX("GET retry -> %d\n", wrqu->retry.value);
afbf30a2
JK		 9560
9561 return 0;
9562}
9563
bf79451e
JG		 9564static int ipw_wx_set_scan(struct net_device *dev,
9565 struct iw_request_info *info,
43f66a6c
JK		 9566 union iwreq_data *wrqu, char *extra)
9567{
b0a4e7d8 9568 struct ipw_priv *priv = libipw_priv(dev);
094c4d2d 9569 struct iw_scan_req *req = (struct iw_scan_req *)extra;
ea177305 9570 struct delayed_work *work = NULL;
094c4d2d 9571
0b531676 9572 mutex_lock(&priv->mutex);
ea177305 9573
0b531676 9574 priv->user_requested_scan = 1;
0b531676 9575
094c4d2d 9576 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
afbf30a2 9577 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
ea177305
DW		 9578 int len = min((int)req->essid_len,
9579 (int)sizeof(priv->direct_scan_ssid));
9580 memcpy(priv->direct_scan_ssid, req->essid, len);
9581 priv->direct_scan_ssid_len = len;
9582 work = &priv->request_direct_scan;
9583 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
9584 work = &priv->request_passive_scan;
094c4d2d 9585 }
ea177305
DW		 9586 } else {
9587 /* Normal active broadcast scan */
9588 work = &priv->request_scan;
afbf30a2 9589 }
8935f39e 9590
ea177305
DW		 9591 mutex_unlock(&priv->mutex);
9592
43f66a6c 9593 IPW_DEBUG_WX("Start scan\n");
b095c381 9594
ea177305 9595 queue_delayed_work(priv->workqueue, work, 0);
b095c381 9596
43f66a6c
JK		 9597 return 0;
9598}
9599
bf79451e
JG		 9600static int ipw_wx_get_scan(struct net_device *dev,
9601 struct iw_request_info *info,
43f66a6c 9602 union iwreq_data *wrqu, char *extra)
bf79451e 9603{
b0a4e7d8
JL		 9604 struct ipw_priv *priv = libipw_priv(dev);
9605 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
43f66a6c
JK		 9606}
9607
bf79451e 9608static int ipw_wx_set_encode(struct net_device *dev,
0edd5b44
JG		 9609 struct iw_request_info *info,
9610 union iwreq_data *wrqu, char *key)
43f66a6c 9611{
b0a4e7d8 9612 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 9613 int ret;
caeff81b 9614 u32 cap = priv->capability;
afbf30a2 9615
4644151b 9616 mutex_lock(&priv->mutex);
b0a4e7d8 9617 ret = libipw_wx_set_encode(priv->ieee, info, wrqu, key);
afbf30a2 9618
caeff81b
HL		 9619 /* In IBSS mode, we need to notify the firmware to update
9620 * the beacon info after we changed the capability. */
9621 if (cap != priv->capability &&
9622 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9623 priv->status & STATUS_ASSOCIATED)
9624 ipw_disassociate(priv);
9625
4644151b 9626 mutex_unlock(&priv->mutex);
afbf30a2 9627 return ret;
43f66a6c
JK		 9628}
9629
bf79451e 9630static int ipw_wx_get_encode(struct net_device *dev,
0edd5b44
JG		 9631 struct iw_request_info *info,
9632 union iwreq_data *wrqu, char *key)
43f66a6c 9633{
b0a4e7d8
JL		 9634 struct ipw_priv *priv = libipw_priv(dev);
9635 return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
43f66a6c
JK		 9636}
9637
bf79451e 9638static int ipw_wx_set_power(struct net_device *dev,
0edd5b44
JG		 9639 struct iw_request_info *info,
9640 union iwreq_data *wrqu, char *extra)
43f66a6c 9641{
b0a4e7d8 9642 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9643 int err;
4644151b 9644 mutex_lock(&priv->mutex);
43f66a6c
JK		 9645 if (wrqu->power.disabled) {
9646 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9647 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9648 if (err) {
9649 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9650 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9651 return err;
9652 }
43f66a6c 9653 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
4644151b 9654 mutex_unlock(&priv->mutex);
43f66a6c 9655 return 0;
bf79451e 9656 }
43f66a6c
JK		 9657
9658 switch (wrqu->power.flags & IW_POWER_MODE) {
0edd5b44
JG		 9659 case IW_POWER_ON: /* If not specified */
9660 case IW_POWER_MODE: /* If set all mask */
c03983ac 9661 case IW_POWER_ALL_R: /* If explicitly state all */
43f66a6c 9662 break;
0edd5b44 9663 default: /* Otherwise we don't support it */
43f66a6c
JK		 9664 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9665 wrqu->power.flags);
4644151b 9666 mutex_unlock(&priv->mutex);
bf79451e 9667 return -EOPNOTSUPP;
43f66a6c 9668 }
bf79451e 9669
43f66a6c
JK		 9670 /* If the user hasn't specified a power management mode yet, default
9671 * to BATTERY */
0edd5b44 9672 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
43f66a6c 9673 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
bf79451e 9674 else
43f66a6c 9675 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
4e157f08 9676
43f66a6c
JK		 9677 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9678 if (err) {
9679 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9680 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9681 return err;
9682 }
9683
0edd5b44 9684 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
4644151b 9685 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9686 return 0;
9687}
9688
bf79451e 9689static int ipw_wx_get_power(struct net_device *dev,
0edd5b44
JG		 9690 struct iw_request_info *info,
9691 union iwreq_data *wrqu, char *extra)
43f66a6c 9692{
b0a4e7d8 9693 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9694 mutex_lock(&priv->mutex);
a613bffd 9695 if (!(priv->power_mode & IPW_POWER_ENABLED))
43f66a6c 9696 wrqu->power.disabled = 1;
a613bffd 9697 else
43f66a6c 9698 wrqu->power.disabled = 0;
43f66a6c 9699
4644151b 9700 mutex_unlock(&priv->mutex);
43f66a6c 9701 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
bf79451e 9702
43f66a6c
JK		 9703 return 0;
9704}
9705
bf79451e 9706static int ipw_wx_set_powermode(struct net_device *dev,
0edd5b44
JG		 9707 struct iw_request_info *info,
9708 union iwreq_data *wrqu, char *extra)
43f66a6c 9709{
b0a4e7d8 9710 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9711 int mode = *(int *)extra;
9712 int err;
4e157f08 9713
4644151b 9714 mutex_lock(&priv->mutex);
4e157f08 9715 if ((mode < 1) || (mode > IPW_POWER_LIMIT))
43f66a6c 9716 mode = IPW_POWER_AC;
bf79451e 9717
4e157f08 9718 if (IPW_POWER_LEVEL(priv->power_mode) != mode) {
43f66a6c 9719 err = ipw_send_power_mode(priv, mode);
43f66a6c
JK		 9720 if (err) {
9721 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9722 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9723 return err;
9724 }
4e157f08 9725 priv->power_mode = IPW_POWER_ENABLED | mode;
43f66a6c 9726 }
4644151b 9727 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9728 return 0;
9729}
9730
9731#define MAX_WX_STRING 80
bf79451e 9732static int ipw_wx_get_powermode(struct net_device *dev,
0edd5b44
JG		 9733 struct iw_request_info *info,
9734 union iwreq_data *wrqu, char *extra)
43f66a6c 9735{
b0a4e7d8 9736 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9737 int level = IPW_POWER_LEVEL(priv->power_mode);
9738 char *p = extra;
9739
9740 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9741
9742 switch (level) {
9743 case IPW_POWER_AC:
9744 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9745 break;
9746 case IPW_POWER_BATTERY:
9747 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9748 break;
9749 default:
9750 p += snprintf(p, MAX_WX_STRING - (p - extra),
bf79451e 9751 "(Timeout %dms, Period %dms)",
43f66a6c
JK		 9752 timeout_duration[level - 1] / 1000,
9753 period_duration[level - 1] / 1000);
9754 }
9755
9756 if (!(priv->power_mode & IPW_POWER_ENABLED))
0edd5b44 9757 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
43f66a6c
JK		 9758
9759 wrqu->data.length = p - extra + 1;
9760
9761 return 0;
9762}
9763
9764static int ipw_wx_set_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9765 struct iw_request_info *info,
9766 union iwreq_data *wrqu, char *extra)
43f66a6c 9767{
b0a4e7d8 9768 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9769 int mode = *(int *)extra;
9770 u8 band = 0, modulation = 0;
9771
9772 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
0edd5b44 9773 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
43f66a6c
JK		 9774 return -EINVAL;
9775 }
4644151b 9776 mutex_lock(&priv->mutex);
43f66a6c 9777 if (priv->adapter == IPW_2915ABG) {
a33a1982 9778 priv->ieee->abg_true = 1;
43f66a6c 9779 if (mode & IEEE_A) {
b0a4e7d8
JL		 9780 band |= LIBIPW_52GHZ_BAND;
9781 modulation |= LIBIPW_OFDM_MODULATION;
43f66a6c 9782 } else
a33a1982 9783 priv->ieee->abg_true = 0;
43f66a6c
JK		 9784 } else {
9785 if (mode & IEEE_A) {
9786 IPW_WARNING("Attempt to set 2200BG into "
9787 "802.11a mode\n");
4644151b 9788 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9789 return -EINVAL;
9790 }
9791
a33a1982 9792 priv->ieee->abg_true = 0;
43f66a6c
JK		 9793 }
9794
9795 if (mode & IEEE_B) {
b0a4e7d8
JL		 9796 band |= LIBIPW_24GHZ_BAND;
9797 modulation |= LIBIPW_CCK_MODULATION;
43f66a6c 9798 } else
a33a1982 9799 priv->ieee->abg_true = 0;
bf79451e 9800
43f66a6c 9801 if (mode & IEEE_G) {
b0a4e7d8
JL		 9802 band |= LIBIPW_24GHZ_BAND;
9803 modulation |= LIBIPW_OFDM_MODULATION;
43f66a6c 9804 } else
a33a1982 9805 priv->ieee->abg_true = 0;
43f66a6c
JK		 9806
9807 priv->ieee->mode = mode;
9808 priv->ieee->freq_band = band;
9809 priv->ieee->modulation = modulation;
0edd5b44 9810 init_supported_rates(priv, &priv->rates);
43f66a6c 9811
c848d0af
JK		 9812 /* Network configuration changed -- force [re]association */
9813 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9814 if (!ipw_disassociate(priv)) {
43f66a6c 9815 ipw_send_supported_rates(priv, &priv->rates);
c848d0af
JK		 9816 ipw_associate(priv);
9817 }
43f66a6c 9818
a613bffd
JK		 9819 /* Update the band LEDs */
9820 ipw_led_band_on(priv);
43f66a6c 9821
bf79451e 9822 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
43f66a6c 9823 mode & IEEE_A ? 'a' : '.',
0edd5b44 9824 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
4644151b 9825 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9826 return 0;
9827}
9828
9829static int ipw_wx_get_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9830 struct iw_request_info *info,
9831 union iwreq_data *wrqu, char *extra)
43f66a6c 9832{
b0a4e7d8 9833 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9834 mutex_lock(&priv->mutex);
ea2b26e0
JK		 9835 switch (priv->ieee->mode) {
9836 case IEEE_A:
43f66a6c
JK		 9837 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9838 break;
ea2b26e0
JK		 9839 case IEEE_B:
9840 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9841 break;
9842 case IEEE_A | IEEE_B:
9843 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9844 break;
9845 case IEEE_G:
9846 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9847 break;
9848 case IEEE_A | IEEE_G:
9849 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9850 break;
9851 case IEEE_B | IEEE_G:
9852 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9853 break;
9854 case IEEE_A | IEEE_B | IEEE_G:
9855 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9856 break;
9857 default:
9858 strncpy(extra, "unknown", MAX_WX_STRING);
43f66a6c 9859 break;
bf79451e
JG		 9860 }
9861
43f66a6c
JK		 9862 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9863
0edd5b44 9864 wrqu->data.length = strlen(extra) + 1;
4644151b 9865 mutex_unlock(&priv->mutex);
b095c381
JK		 9866
9867 return 0;
9868}
9869
9870static int ipw_wx_set_preamble(struct net_device *dev,
9871 struct iw_request_info *info,
9872 union iwreq_data *wrqu, char *extra)
9873{
b0a4e7d8 9874 struct ipw_priv *priv = libipw_priv(dev);
b095c381 9875 int mode = *(int *)extra;
4644151b 9876 mutex_lock(&priv->mutex);
b095c381
JK		 9877 /* Switching from SHORT -> LONG requires a disassociation */
9878 if (mode == 1) {
9879 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9880 priv->config |= CFG_PREAMBLE_LONG;
9881
9882 /* Network configuration changed -- force [re]association */
9883 IPW_DEBUG_ASSOC
9884 ("[re]association triggered due to preamble change.\n");
9885 if (!ipw_disassociate(priv))
9886 ipw_associate(priv);
9887 }
9888 goto done;
9889 }
43f66a6c 9890
b095c381
JK		 9891 if (mode == 0) {
9892 priv->config &= ~CFG_PREAMBLE_LONG;
9893 goto done;
9894 }
4644151b 9895 mutex_unlock(&priv->mutex);
b095c381
JK		 9896 return -EINVAL;
9897
9898 done:
4644151b 9899 mutex_unlock(&priv->mutex);
b095c381
JK		 9900 return 0;
9901}
9902
9903static int ipw_wx_get_preamble(struct net_device *dev,
9904 struct iw_request_info *info,
9905 union iwreq_data *wrqu, char *extra)
9906{
b0a4e7d8 9907 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9908 mutex_lock(&priv->mutex);
b095c381
JK		 9909 if (priv->config & CFG_PREAMBLE_LONG)
9910 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9911 else
9912 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
4644151b 9913 mutex_unlock(&priv->mutex);
0edd5b44 9914 return 0;
43f66a6c
JK		 9915}
9916
b095c381
JK		 9917#ifdef CONFIG_IPW2200_MONITOR
9918static int ipw_wx_set_monitor(struct net_device *dev,
bf79451e 9919 struct iw_request_info *info,
43f66a6c 9920 union iwreq_data *wrqu, char *extra)
bf79451e 9921{
b0a4e7d8 9922 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9923 int *parms = (int *)extra;
9924 int enable = (parms[0] > 0);
4644151b 9925 mutex_lock(&priv->mutex);
b095c381 9926 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
43f66a6c
JK		 9927 if (enable) {
9928 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
459d4087 9929#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 9930 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9931#else
43f66a6c 9932 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 9933#endif
b095c381 9934 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c 9935 }
bf79451e 9936
43f66a6c
JK		 9937 ipw_set_channel(priv, parms[1]);
9938 } else {
b095c381 9939 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
4644151b 9940 mutex_unlock(&priv->mutex);
43f66a6c 9941 return 0;
b095c381 9942 }
43f66a6c 9943 priv->net_dev->type = ARPHRD_ETHER;
b095c381 9944 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c 9945 }
4644151b 9946 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9947 return 0;
9948}
9949
67fd6b45 9950#endif /* CONFIG_IPW2200_MONITOR */
b095c381 9951
bf79451e
JG		 9952static int ipw_wx_reset(struct net_device *dev,
9953 struct iw_request_info *info,
43f66a6c 9954 union iwreq_data *wrqu, char *extra)
bf79451e 9955{
b0a4e7d8 9956 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9957 IPW_DEBUG_WX("RESET\n");
b095c381
JK		 9958 queue_work(priv->workqueue, &priv->adapter_restart);
9959 return 0;
9960}
9961
b095c381
JK		 9962static int ipw_wx_sw_reset(struct net_device *dev,
9963 struct iw_request_info *info,
9964 union iwreq_data *wrqu, char *extra)
ea2b26e0 9965{
b0a4e7d8 9966 struct ipw_priv *priv = libipw_priv(dev);
b095c381
JK		 9967 union iwreq_data wrqu_sec = {
9968 .encoding = {
9969 .flags = IW_ENCODE_DISABLED,
9970 },
9971 };
afbf30a2 9972 int ret;
c848d0af 9973
b095c381 9974 IPW_DEBUG_WX("SW_RESET\n");
ea2b26e0 9975
4644151b 9976 mutex_lock(&priv->mutex);
ea2b26e0 9977
d6d5b5c1 9978 ret = ipw_sw_reset(priv, 2);
afbf30a2
JK		 9979 if (!ret) {
9980 free_firmware();
9981 ipw_adapter_restart(priv);
9982 }
ea2b26e0 9983
b095c381
JK		 9984 /* The SW reset bit might have been toggled on by the 'disable'
9985 * module parameter, so take appropriate action */
9986 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
ea2b26e0 9987
4644151b 9988 mutex_unlock(&priv->mutex);
b0a4e7d8 9989 libipw_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
4644151b 9990 mutex_lock(&priv->mutex);
bf79451e 9991
b095c381
JK		 9992 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9993 /* Configuration likely changed -- force [re]association */
9994 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9995 "reset.\n");
9996 if (!ipw_disassociate(priv))
9997 ipw_associate(priv);
43f66a6c 9998 }
b095c381 9999
4644151b 10000 mutex_unlock(&priv->mutex);
43f66a6c 10001
43f66a6c
JK		 10002 return 0;
10003}
43f66a6c
JK		 10004
10005/* Rebase the WE IOCTLs to zero for the handler array */
0edd5b44 10006static iw_handler ipw_wx_handlers[] = {
56b632e8
JP		 10007 IW_HANDLER(SIOCGIWNAME, (iw_handler)cfg80211_wext_giwname),
10008 IW_HANDLER(SIOCSIWFREQ, ipw_wx_set_freq),
10009 IW_HANDLER(SIOCGIWFREQ, ipw_wx_get_freq),
10010 IW_HANDLER(SIOCSIWMODE, ipw_wx_set_mode),
10011 IW_HANDLER(SIOCGIWMODE, ipw_wx_get_mode),
10012 IW_HANDLER(SIOCSIWSENS, ipw_wx_set_sens),
10013 IW_HANDLER(SIOCGIWSENS, ipw_wx_get_sens),
10014 IW_HANDLER(SIOCGIWRANGE, ipw_wx_get_range),
10015 IW_HANDLER(SIOCSIWAP, ipw_wx_set_wap),
10016 IW_HANDLER(SIOCGIWAP, ipw_wx_get_wap),
10017 IW_HANDLER(SIOCSIWSCAN, ipw_wx_set_scan),
10018 IW_HANDLER(SIOCGIWSCAN, ipw_wx_get_scan),
10019 IW_HANDLER(SIOCSIWESSID, ipw_wx_set_essid),
10020 IW_HANDLER(SIOCGIWESSID, ipw_wx_get_essid),
10021 IW_HANDLER(SIOCSIWNICKN, ipw_wx_set_nick),
10022 IW_HANDLER(SIOCGIWNICKN, ipw_wx_get_nick),
10023 IW_HANDLER(SIOCSIWRATE, ipw_wx_set_rate),
10024 IW_HANDLER(SIOCGIWRATE, ipw_wx_get_rate),
10025 IW_HANDLER(SIOCSIWRTS, ipw_wx_set_rts),
10026 IW_HANDLER(SIOCGIWRTS, ipw_wx_get_rts),
10027 IW_HANDLER(SIOCSIWFRAG, ipw_wx_set_frag),
10028 IW_HANDLER(SIOCGIWFRAG, ipw_wx_get_frag),
10029 IW_HANDLER(SIOCSIWTXPOW, ipw_wx_set_txpow),
10030 IW_HANDLER(SIOCGIWTXPOW, ipw_wx_get_txpow),
10031 IW_HANDLER(SIOCSIWRETRY, ipw_wx_set_retry),
10032 IW_HANDLER(SIOCGIWRETRY, ipw_wx_get_retry),
10033 IW_HANDLER(SIOCSIWENCODE, ipw_wx_set_encode),
10034 IW_HANDLER(SIOCGIWENCODE, ipw_wx_get_encode),
10035 IW_HANDLER(SIOCSIWPOWER, ipw_wx_set_power),
10036 IW_HANDLER(SIOCGIWPOWER, ipw_wx_get_power),
10037 IW_HANDLER(SIOCSIWSPY, iw_handler_set_spy),
10038 IW_HANDLER(SIOCGIWSPY, iw_handler_get_spy),
10039 IW_HANDLER(SIOCSIWTHRSPY, iw_handler_set_thrspy),
10040 IW_HANDLER(SIOCGIWTHRSPY, iw_handler_get_thrspy),
10041 IW_HANDLER(SIOCSIWGENIE, ipw_wx_set_genie),
10042 IW_HANDLER(SIOCGIWGENIE, ipw_wx_get_genie),
10043 IW_HANDLER(SIOCSIWMLME, ipw_wx_set_mlme),
10044 IW_HANDLER(SIOCSIWAUTH, ipw_wx_set_auth),
10045 IW_HANDLER(SIOCGIWAUTH, ipw_wx_get_auth),
10046 IW_HANDLER(SIOCSIWENCODEEXT, ipw_wx_set_encodeext),
10047 IW_HANDLER(SIOCGIWENCODEEXT, ipw_wx_get_encodeext),
43f66a6c
JK		 10048};
10049
b095c381
JK		 10050enum {
10051 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
10052 IPW_PRIV_GET_POWER,
10053 IPW_PRIV_SET_MODE,
10054 IPW_PRIV_GET_MODE,
10055 IPW_PRIV_SET_PREAMBLE,
10056 IPW_PRIV_GET_PREAMBLE,
10057 IPW_PRIV_RESET,
10058 IPW_PRIV_SW_RESET,
10059#ifdef CONFIG_IPW2200_MONITOR
10060 IPW_PRIV_SET_MONITOR,
10061#endif
10062};
43f66a6c 10063
bf79451e 10064static struct iw_priv_args ipw_priv_args[] = {
43f66a6c 10065 {
0edd5b44
JG		 10066 .cmd = IPW_PRIV_SET_POWER,
10067 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10068 .name = "set_power"},
43f66a6c 10069 {
0edd5b44
JG		 10070 .cmd = IPW_PRIV_GET_POWER,
10071 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
10072 .name = "get_power"},
43f66a6c 10073 {
0edd5b44
JG		 10074 .cmd = IPW_PRIV_SET_MODE,
10075 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10076 .name = "set_mode"},
43f66a6c 10077 {
0edd5b44
JG		 10078 .cmd = IPW_PRIV_GET_MODE,
10079 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
10080 .name = "get_mode"},
43f66a6c 10081 {
ea2b26e0
JK		 10082 .cmd = IPW_PRIV_SET_PREAMBLE,
10083 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10084 .name = "set_preamble"},
10085 {
10086 .cmd = IPW_PRIV_GET_PREAMBLE,
10087 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
10088 .name = "get_preamble"},
43f66a6c 10089 {
0edd5b44
JG		 10090 IPW_PRIV_RESET,
10091 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
b095c381
JK		 10092 {
10093 IPW_PRIV_SW_RESET,
10094 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
10095#ifdef CONFIG_IPW2200_MONITOR
10096 {
10097 IPW_PRIV_SET_MONITOR,
10098 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
10099#endif /* CONFIG_IPW2200_MONITOR */
43f66a6c
JK		 10100};
10101
10102static iw_handler ipw_priv_handler[] = {
10103 ipw_wx_set_powermode,
10104 ipw_wx_get_powermode,
10105 ipw_wx_set_wireless_mode,
10106 ipw_wx_get_wireless_mode,
ea2b26e0
JK		 10107 ipw_wx_set_preamble,
10108 ipw_wx_get_preamble,
bf79451e 10109 ipw_wx_reset,
b095c381
JK		 10110 ipw_wx_sw_reset,
10111#ifdef CONFIG_IPW2200_MONITOR
10112 ipw_wx_set_monitor,
43f66a6c
JK		 10113#endif
10114};
10115
0edd5b44 10116static struct iw_handler_def ipw_wx_handler_def = {
ea2b26e0
JK		 10117 .standard = ipw_wx_handlers,
10118 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
10119 .num_private = ARRAY_SIZE(ipw_priv_handler),
10120 .num_private_args = ARRAY_SIZE(ipw_priv_args),
10121 .private = ipw_priv_handler,
10122 .private_args = ipw_priv_args,
97a78ca9 10123 .get_wireless_stats = ipw_get_wireless_stats,
43f66a6c
JK		 10124};
10125
43f66a6c
JK		 10126/*
10127 * Get wireless statistics.
10128 * Called by /proc/net/wireless
10129 * Also called by SIOCGIWSTATS
10130 */
0edd5b44 10131static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
43f66a6c 10132{
b0a4e7d8 10133 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10134 struct iw_statistics *wstats;
bf79451e 10135
43f66a6c
JK		 10136 wstats = &priv->wstats;
10137
ea2b26e0 10138 /* if hw is disabled, then ipw_get_ordinal() can't be called.
afbf30a2 10139 * netdev->get_wireless_stats seems to be called before fw is
43f66a6c
JK		 10140 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
10141 * and associated; if not associcated, the values are all meaningless
10142 * anyway, so set them all to NULL and INVALID */
10143 if (!(priv->status & STATUS_ASSOCIATED)) {
10144 wstats->miss.beacon = 0;
10145 wstats->discard.retries = 0;
10146 wstats->qual.qual = 0;
10147 wstats->qual.level = 0;
10148 wstats->qual.noise = 0;
10149 wstats->qual.updated = 7;
10150 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
0edd5b44 10151 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
43f66a6c 10152 return wstats;
bf79451e 10153 }
43f66a6c
JK		 10154
10155 wstats->qual.qual = priv->quality;
00d21de5
ZY		 10156 wstats->qual.level = priv->exp_avg_rssi;
10157 wstats->qual.noise = priv->exp_avg_noise;
43f66a6c 10158 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
b191608a 10159 IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
43f66a6c
JK		 10160
10161 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
10162 wstats->discard.retries = priv->last_tx_failures;
10163 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
bf79451e 10164
43f66a6c
JK		 10165/* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
10166 goto fail_get_ordinal;
10167 wstats->discard.retries += tx_retry; */
bf79451e 10168
43f66a6c
JK		 10169 return wstats;
10170}
10171
43f66a6c
JK		 10172/* net device stuff */
10173
858119e1 10174static void init_sys_config(struct ipw_sys_config *sys_config)
43f66a6c 10175{
0edd5b44 10176 memset(sys_config, 0, sizeof(struct ipw_sys_config));
810dabd4 10177 sys_config->bt_coexistence = 0;
43f66a6c
JK		 10178 sys_config->answer_broadcast_ssid_probe = 0;
10179 sys_config->accept_all_data_frames = 0;
10180 sys_config->accept_non_directed_frames = 1;
10181 sys_config->exclude_unicast_unencrypted = 0;
10182 sys_config->disable_unicast_decryption = 1;
10183 sys_config->exclude_multicast_unencrypted = 0;
10184 sys_config->disable_multicast_decryption = 1;
d2b83e12
ZY		 10185 if (antenna < CFG_SYS_ANTENNA_BOTH || antenna > CFG_SYS_ANTENNA_B)
10186 antenna = CFG_SYS_ANTENNA_BOTH;
10187 sys_config->antenna_diversity = antenna;
0edd5b44 10188 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
43f66a6c 10189 sys_config->dot11g_auto_detection = 0;
bf79451e 10190 sys_config->enable_cts_to_self = 0;
43f66a6c 10191 sys_config->bt_coexist_collision_thr = 0;
67fd6b45 10192 sys_config->pass_noise_stats_to_host = 1; /* 1 -- fix for 256 */
12977154 10193 sys_config->silence_threshold = 0x1e;
43f66a6c
JK		 10194}
10195
10196static int ipw_net_open(struct net_device *dev)
10197{
43f66a6c 10198 IPW_DEBUG_INFO("dev->open\n");
521c4d96 10199 netif_start_queue(dev);
43f66a6c
JK		 10200 return 0;
10201}
10202
10203static int ipw_net_stop(struct net_device *dev)
10204{
10205 IPW_DEBUG_INFO("dev->close\n");
10206 netif_stop_queue(dev);
10207 return 0;
10208}
10209
10210/*
10211todo:
10212
10213modify to send one tfd per fragment instead of using chunking. otherwise
b0a4e7d8 10214we need to heavily modify the libipw_skb_to_txb.
43f66a6c
JK		 10215*/
10216
b0a4e7d8 10217static int ipw_tx_skb(struct ipw_priv *priv, struct libipw_txb *txb,
227d2dc1 10218 int pri)
43f66a6c 10219{
b0a4e7d8 10220 struct libipw_hdr_3addrqos *hdr = (struct libipw_hdr_3addrqos *)
0edd5b44 10221 txb->fragments[0]->data;
43f66a6c
JK		 10222 int i = 0;
10223 struct tfd_frame *tfd;
e43e3c1e 10224#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 10225 int tx_id = ipw_get_tx_queue_number(priv, pri);
10226 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10227#else
43f66a6c 10228 struct clx2_tx_queue *txq = &priv->txq[0];
b095c381 10229#endif
43f66a6c
JK		 10230 struct clx2_queue *q = &txq->q;
10231 u8 id, hdr_len, unicast;
c848d0af 10232 int fc;
43f66a6c 10233
b8ddafd7
ZY		 10234 if (!(priv->status & STATUS_ASSOCIATED))
10235 goto drop;
10236
b0a4e7d8 10237 hdr_len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
43f66a6c
JK		 10238 switch (priv->ieee->iw_mode) {
10239 case IW_MODE_ADHOC:
3c19065a 10240 unicast = !is_multicast_ether_addr(hdr->addr1);
43f66a6c
JK		 10241 id = ipw_find_station(priv, hdr->addr1);
10242 if (id == IPW_INVALID_STATION) {
10243 id = ipw_add_station(priv, hdr->addr1);
10244 if (id == IPW_INVALID_STATION) {
10245 IPW_WARNING("Attempt to send data to "
e174961c
JB		 10246 "invalid cell: %pM\n",
10247 hdr->addr1);
43f66a6c
JK		 10248 goto drop;
10249 }
10250 }
10251 break;
10252
10253 case IW_MODE_INFRA:
10254 default:
3c19065a 10255 unicast = !is_multicast_ether_addr(hdr->addr3);
43f66a6c
JK		 10256 id = 0;
10257 break;
10258 }
10259
10260 tfd = &txq->bd[q->first_empty];
10261 txq->txb[q->first_empty] = txb;
10262 memset(tfd, 0, sizeof(*tfd));
10263 tfd->u.data.station_number = id;
10264
10265 tfd->control_flags.message_type = TX_FRAME_TYPE;
10266 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10267
10268 tfd->u.data.cmd_id = DINO_CMD_TX;
a613bffd 10269 tfd->u.data.len = cpu_to_le16(txb->payload_size);
bf79451e 10270
43f66a6c 10271 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
b095c381 10272 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
43f66a6c 10273 else
b095c381 10274 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
43f66a6c 10275
ea2b26e0
JK		 10276 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10277 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
43f66a6c 10278
c848d0af
JK		 10279 fc = le16_to_cpu(hdr->frame_ctl);
10280 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
43f66a6c
JK		 10281
10282 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10283
b095c381
JK		 10284 if (likely(unicast))
10285 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10286
10287 if (txb->encrypted && !priv->ieee->host_encrypt) {
10288 switch (priv->ieee->sec.level) {
10289 case SEC_LEVEL_3:
10290 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10291 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
b095c381
JK		 10292 /* XXX: ACK flag must be set for CCMP even if it
10293 * is a multicast/broadcast packet, because CCMP
10294 * group communication encrypted by GTK is
10295 * actually done by the AP. */
10296 if (!unicast)
10297 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10298
10299 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10300 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10301 tfd->u.data.key_index = 0;
10302 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10303 break;
10304 case SEC_LEVEL_2:
10305 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10306 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
b095c381
JK		 10307 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10308 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10309 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10310 break;
10311 case SEC_LEVEL_1:
10312 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10313 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
274bfb8d
JL		 10314 tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10315 if (priv->ieee->sec.key_sizes[priv->ieee->crypt_info.tx_keyidx] <=
b095c381
JK		 10316 40)
10317 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10318 else
10319 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10320 break;
10321 case SEC_LEVEL_0:
10322 break;
10323 default:
af901ca1 10324 printk(KERN_ERR "Unknown security level %d\n",
b095c381
JK		 10325 priv->ieee->sec.level);
10326 break;
10327 }
10328 } else
10329 /* No hardware encryption */
10330 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10331
e43e3c1e 10332#ifdef CONFIG_IPW2200_QOS
a5cf4fe6
ZY		 10333 if (fc & IEEE80211_STYPE_QOS_DATA)
10334 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
e43e3c1e 10335#endif /* CONFIG_IPW2200_QOS */
b095c381 10336
43f66a6c 10337 /* payload */
a613bffd
JK		 10338 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10339 txb->nr_frags));
10340 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
10341 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10342 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10343 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
10344 i, le32_to_cpu(tfd->u.data.num_chunks),
10345 txb->fragments[i]->len - hdr_len);
bf79451e 10346 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
43f66a6c
JK		 10347 i, tfd->u.data.num_chunks,
10348 txb->fragments[i]->len - hdr_len);
bf79451e 10349 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
43f66a6c
JK		 10350 txb->fragments[i]->len - hdr_len);
10351
0edd5b44 10352 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 10353 cpu_to_le32(pci_map_single
10354 (priv->pci_dev,
10355 txb->fragments[i]->data + hdr_len,
10356 txb->fragments[i]->len - hdr_len,
10357 PCI_DMA_TODEVICE));
10358 tfd->u.data.chunk_len[i] =
10359 cpu_to_le16(txb->fragments[i]->len - hdr_len);
43f66a6c
JK		 10360 }
10361
10362 if (i != txb->nr_frags) {
10363 struct sk_buff *skb;
10364 u16 remaining_bytes = 0;
10365 int j;
10366
10367 for (j = i; j < txb->nr_frags; j++)
10368 remaining_bytes += txb->fragments[j]->len - hdr_len;
10369
10370 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
10371 remaining_bytes);
10372 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
10373 if (skb != NULL) {
a613bffd 10374 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
43f66a6c
JK		 10375 for (j = i; j < txb->nr_frags; j++) {
10376 int size = txb->fragments[j]->len - hdr_len;
afbf30a2 10377
43f66a6c 10378 printk(KERN_INFO "Adding frag %d %d...\n",
0edd5b44 10379 j, size);
43f66a6c 10380 memcpy(skb_put(skb, size),
0edd5b44 10381 txb->fragments[j]->data + hdr_len, size);
43f66a6c
JK		 10382 }
10383 dev_kfree_skb_any(txb->fragments[i]);
10384 txb->fragments[i] = skb;
0edd5b44 10385 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 10386 cpu_to_le32(pci_map_single
10387 (priv->pci_dev, skb->data,
4958730e 10388 remaining_bytes,
a613bffd
JK		 10389 PCI_DMA_TODEVICE));
10390
5c05863d 10391 le32_add_cpu(&tfd->u.data.num_chunks, 1);
bf79451e 10392 }
43f66a6c
JK		 10393 }
10394
10395 /* kick DMA */
10396 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10397 ipw_write32(priv, q->reg_w, q->first_empty);
10398
943dbef4 10399 if (ipw_tx_queue_space(q) < q->high_mark)
f697014a
JK		 10400 netif_stop_queue(priv->net_dev);
10401
227d2dc1 10402 return NETDEV_TX_OK;
43f66a6c 10403
0edd5b44 10404 drop:
43f66a6c 10405 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
b0a4e7d8 10406 libipw_txb_free(txb);
227d2dc1
JK		 10407 return NETDEV_TX_OK;
10408}
10409
10410static int ipw_net_is_queue_full(struct net_device *dev, int pri)
10411{
b0a4e7d8 10412 struct ipw_priv *priv = libipw_priv(dev);
e43e3c1e 10413#ifdef CONFIG_IPW2200_QOS
227d2dc1
JK		 10414 int tx_id = ipw_get_tx_queue_number(priv, pri);
10415 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10416#else
10417 struct clx2_tx_queue *txq = &priv->txq[0];
e43e3c1e 10418#endif /* CONFIG_IPW2200_QOS */
227d2dc1 10419
943dbef4 10420 if (ipw_tx_queue_space(&txq->q) < txq->q.high_mark)
227d2dc1
JK		 10421 return 1;
10422
10423 return 0;
43f66a6c
JK		 10424}
10425
d685b8c2
ZY		 10426#ifdef CONFIG_IPW2200_PROMISCUOUS
10427static void ipw_handle_promiscuous_tx(struct ipw_priv *priv,
b0a4e7d8 10428 struct libipw_txb *txb)
d685b8c2 10429{
b0a4e7d8 10430 struct libipw_rx_stats dummystats;
d685b8c2
ZY		 10431 struct ieee80211_hdr *hdr;
10432 u8 n;
10433 u16 filter = priv->prom_priv->filter;
10434 int hdr_only = 0;
10435
10436 if (filter & IPW_PROM_NO_TX)
10437 return;
10438
10439 memset(&dummystats, 0, sizeof(dummystats));
10440
10441 /* Filtering of fragment chains is done agains the first fragment */
10442 hdr = (void *)txb->fragments[0]->data;
b0a4e7d8 10443 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10444 if (filter & IPW_PROM_NO_MGMT)
10445 return;
10446 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
10447 hdr_only = 1;
b0a4e7d8 10448 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10449 if (filter & IPW_PROM_NO_CTL)
10450 return;
10451 if (filter & IPW_PROM_CTL_HEADER_ONLY)
10452 hdr_only = 1;
b0a4e7d8 10453 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10454 if (filter & IPW_PROM_NO_DATA)
10455 return;
10456 if (filter & IPW_PROM_DATA_HEADER_ONLY)
10457 hdr_only = 1;
10458 }
10459
10460 for(n=0; n<txb->nr_frags; ++n) {
10461 struct sk_buff *src = txb->fragments[n];
10462 struct sk_buff *dst;
10463 struct ieee80211_radiotap_header *rt_hdr;
10464 int len;
10465
10466 if (hdr_only) {
10467 hdr = (void *)src->data;
b0a4e7d8 10468 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
d685b8c2
ZY		 10469 } else
10470 len = src->len;
10471
007e5ddd
JB		 10472 dst = alloc_skb(len + sizeof(*rt_hdr), GFP_ATOMIC);
10473 if (!dst)
10474 continue;
d685b8c2
ZY		 10475
10476 rt_hdr = (void *)skb_put(dst, sizeof(*rt_hdr));
10477
10478 rt_hdr->it_version = PKTHDR_RADIOTAP_VERSION;
10479 rt_hdr->it_pad = 0;
10480 rt_hdr->it_present = 0; /* after all, it's just an idea */
743b84d2 10481 rt_hdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_CHANNEL);
d685b8c2 10482
e62e1ee0 10483 *(__le16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(
d685b8c2
ZY		 10484 ieee80211chan2mhz(priv->channel));
10485 if (priv->channel > 14) /* 802.11a */
e62e1ee0 10486 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10487 cpu_to_le16(IEEE80211_CHAN_OFDM |
10488 IEEE80211_CHAN_5GHZ);
10489 else if (priv->ieee->mode == IEEE_B) /* 802.11b */
e62e1ee0 10490 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10491 cpu_to_le16(IEEE80211_CHAN_CCK |
10492 IEEE80211_CHAN_2GHZ);
10493 else /* 802.11g */
e62e1ee0 10494 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10495 cpu_to_le16(IEEE80211_CHAN_OFDM |
10496 IEEE80211_CHAN_2GHZ);
10497
743b84d2 10498 rt_hdr->it_len = cpu_to_le16(dst->len);
d685b8c2 10499
d626f62b 10500 skb_copy_from_linear_data(src, skb_put(dst, len), len);
d685b8c2 10501
b0a4e7d8 10502 if (!libipw_rx(priv->prom_priv->ieee, dst, &dummystats))
d685b8c2
ZY		 10503 dev_kfree_skb_any(dst);
10504 }
10505}
10506#endif
10507
d0cf9c0d
SH		 10508static netdev_tx_t ipw_net_hard_start_xmit(struct libipw_txb *txb,
10509 struct net_device *dev, int pri)
43f66a6c 10510{
b0a4e7d8 10511 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10512 unsigned long flags;
d0cf9c0d 10513 netdev_tx_t ret;
43f66a6c
JK		 10514
10515 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
43f66a6c
JK		 10516 spin_lock_irqsave(&priv->lock, flags);
10517
d685b8c2
ZY		 10518#ifdef CONFIG_IPW2200_PROMISCUOUS
10519 if (rtap_iface && netif_running(priv->prom_net_dev))
10520 ipw_handle_promiscuous_tx(priv, txb);
10521#endif
10522
227d2dc1
JK		 10523 ret = ipw_tx_skb(priv, txb, pri);
10524 if (ret == NETDEV_TX_OK)
10525 __ipw_led_activity_on(priv);
43f66a6c 10526 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 10527
227d2dc1 10528 return ret;
43f66a6c
JK		 10529}
10530
43f66a6c
JK		 10531static void ipw_net_set_multicast_list(struct net_device *dev)
10532{
10533
10534}
10535
10536static int ipw_net_set_mac_address(struct net_device *dev, void *p)
10537{
b0a4e7d8 10538 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10539 struct sockaddr *addr = p;
0795af57 10540
43f66a6c
JK		 10541 if (!is_valid_ether_addr(addr->sa_data))
10542 return -EADDRNOTAVAIL;
4644151b 10543 mutex_lock(&priv->mutex);
43f66a6c
JK		 10544 priv->config |= CFG_CUSTOM_MAC;
10545 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
e174961c
JB		 10546 printk(KERN_INFO "%s: Setting MAC to %pM\n",
10547 priv->net_dev->name, priv->mac_addr);
a613bffd 10548 queue_work(priv->workqueue, &priv->adapter_restart);
4644151b 10549 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10550 return 0;
10551}
10552
bf79451e 10553static void ipw_ethtool_get_drvinfo(struct net_device *dev,
43f66a6c
JK		 10554 struct ethtool_drvinfo *info)
10555{
b0a4e7d8 10556 struct ipw_priv *p = libipw_priv(dev);
43f66a6c
JK		 10557 char vers[64];
10558 char date[32];
10559 u32 len;
10560
10561 strcpy(info->driver, DRV_NAME);
10562 strcpy(info->version, DRV_VERSION);
10563
10564 len = sizeof(vers);
10565 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
10566 len = sizeof(date);
10567 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
10568
0edd5b44 10569 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
43f66a6c
JK		 10570 vers, date);
10571 strcpy(info->bus_info, pci_name(p->pci_dev));
b095c381 10572 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 10573}
10574
10575static u32 ipw_ethtool_get_link(struct net_device *dev)
10576{
b0a4e7d8 10577 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 10578 return (priv->status & STATUS_ASSOCIATED) != 0;
10579}
10580
10581static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10582{
b095c381 10583 return IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 10584}
10585
10586static int ipw_ethtool_get_eeprom(struct net_device *dev,
0edd5b44 10587 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c 10588{
b0a4e7d8 10589 struct ipw_priv *p = libipw_priv(dev);
43f66a6c 10590
b095c381 10591 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 10592 return -EINVAL;
4644151b 10593 mutex_lock(&p->mutex);
afbf30a2 10594 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
4644151b 10595 mutex_unlock(&p->mutex);
43f66a6c
JK		 10596 return 0;
10597}
10598
10599static int ipw_ethtool_set_eeprom(struct net_device *dev,
0edd5b44 10600 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c 10601{
b0a4e7d8 10602 struct ipw_priv *p = libipw_priv(dev);
43f66a6c
JK		 10603 int i;
10604
b095c381 10605 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 10606 return -EINVAL;
4644151b 10607 mutex_lock(&p->mutex);
afbf30a2 10608 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
71e585fc
AB		 10609 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
10610 ipw_write8(p, i + IPW_EEPROM_DATA, p->eeprom[i]);
4644151b 10611 mutex_unlock(&p->mutex);
43f66a6c
JK		 10612 return 0;
10613}
10614
7282d491 10615static const struct ethtool_ops ipw_ethtool_ops = {
ea2b26e0
JK		 10616 .get_link = ipw_ethtool_get_link,
10617 .get_drvinfo = ipw_ethtool_get_drvinfo,
10618 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10619 .get_eeprom = ipw_ethtool_get_eeprom,
10620 .set_eeprom = ipw_ethtool_set_eeprom,
43f66a6c
JK		 10621};
10622
7d12e780 10623static irqreturn_t ipw_isr(int irq, void *data)
43f66a6c
JK		 10624{
10625 struct ipw_priv *priv = data;
10626 u32 inta, inta_mask;
bf79451e 10627
43f66a6c
JK		 10628 if (!priv)
10629 return IRQ_NONE;
10630
89c318ed 10631 spin_lock(&priv->irq_lock);
43f66a6c
JK		 10632
10633 if (!(priv->status & STATUS_INT_ENABLED)) {
d00d0121 10634 /* IRQ is disabled */
43f66a6c
JK		 10635 goto none;
10636 }
10637
b095c381
JK		 10638 inta = ipw_read32(priv, IPW_INTA_RW);
10639 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
bf79451e 10640
43f66a6c
JK		 10641 if (inta == 0xFFFFFFFF) {
10642 /* Hardware disappeared */
10643 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10644 goto none;
10645 }
10646
b095c381 10647 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
43f66a6c
JK		 10648 /* Shared interrupt */
10649 goto none;
10650 }
10651
10652 /* tell the device to stop sending interrupts */
89c318ed 10653 __ipw_disable_interrupts(priv);
bf79451e 10654
43f66a6c 10655 /* ack current interrupts */
b095c381
JK		 10656 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10657 ipw_write32(priv, IPW_INTA_RW, inta);
bf79451e 10658
43f66a6c
JK		 10659 /* Cache INTA value for our tasklet */
10660 priv->isr_inta = inta;
10661
10662 tasklet_schedule(&priv->irq_tasklet);
10663
89c318ed 10664 spin_unlock(&priv->irq_lock);
43f66a6c
JK		 10665
10666 return IRQ_HANDLED;
0edd5b44 10667 none:
89c318ed 10668 spin_unlock(&priv->irq_lock);
43f66a6c
JK		 10669 return IRQ_NONE;
10670}
10671
10672static void ipw_rf_kill(void *adapter)
10673{
10674 struct ipw_priv *priv = adapter;
10675 unsigned long flags;
bf79451e 10676
43f66a6c
JK		 10677 spin_lock_irqsave(&priv->lock, flags);
10678
10679 if (rf_kill_active(priv)) {
10680 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10681 if (priv->workqueue)
10682 queue_delayed_work(priv->workqueue,
10683 &priv->rf_kill, 2 * HZ);
10684 goto exit_unlock;
10685 }
10686
10687 /* RF Kill is now disabled, so bring the device back up */
10688
10689 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10690 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10691 "device\n");
10692
10693 /* we can not do an adapter restart while inside an irq lock */
10694 queue_work(priv->workqueue, &priv->adapter_restart);
bf79451e 10695 } else
43f66a6c
JK		 10696 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10697 "enabled\n");
10698
0edd5b44 10699 exit_unlock:
43f66a6c
JK		 10700 spin_unlock_irqrestore(&priv->lock, flags);
10701}
10702
c4028958 10703static void ipw_bg_rf_kill(struct work_struct *work)
c848d0af 10704{
c4028958
DH		 10705 struct ipw_priv *priv =
10706 container_of(work, struct ipw_priv, rf_kill.work);
4644151b 10707 mutex_lock(&priv->mutex);
c4028958 10708 ipw_rf_kill(priv);
4644151b 10709 mutex_unlock(&priv->mutex);
c848d0af
JK		 10710}
10711
a73e22b2 10712static void ipw_link_up(struct ipw_priv *priv)
a613bffd 10713{
afbf30a2
JK		 10714 priv->last_seq_num = -1;
10715 priv->last_frag_num = -1;
10716 priv->last_packet_time = 0;
10717
a613bffd 10718 netif_carrier_on(priv->net_dev);
a613bffd 10719
c848d0af 10720 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 10721 cancel_delayed_work(&priv->request_direct_scan);
10722 cancel_delayed_work(&priv->request_passive_scan);
0b531676 10723 cancel_delayed_work(&priv->scan_event);
a613bffd
JK		 10724 ipw_reset_stats(priv);
10725 /* Ensure the rate is updated immediately */
10726 priv->last_rate = ipw_get_current_rate(priv);
10727 ipw_gather_stats(priv);
10728 ipw_led_link_up(priv);
10729 notify_wx_assoc_event(priv);
10730
10731 if (priv->config & CFG_BACKGROUND_SCAN)
10732 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10733}
10734
c4028958 10735static void ipw_bg_link_up(struct work_struct *work)
c848d0af 10736{
c4028958
DH		 10737 struct ipw_priv *priv =
10738 container_of(work, struct ipw_priv, link_up);
4644151b 10739 mutex_lock(&priv->mutex);
c4028958 10740 ipw_link_up(priv);
4644151b 10741 mutex_unlock(&priv->mutex);
c848d0af
JK		 10742}
10743
a73e22b2 10744static void ipw_link_down(struct ipw_priv *priv)
a613bffd
JK		 10745{
10746 ipw_led_link_down(priv);
10747 netif_carrier_off(priv->net_dev);
a613bffd
JK		 10748 notify_wx_assoc_event(priv);
10749
10750 /* Cancel any queued work ... */
10751 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 10752 cancel_delayed_work(&priv->request_direct_scan);
10753 cancel_delayed_work(&priv->request_passive_scan);
a613bffd
JK		 10754 cancel_delayed_work(&priv->adhoc_check);
10755 cancel_delayed_work(&priv->gather_stats);
10756
10757 ipw_reset_stats(priv);
10758
afbf30a2
JK		 10759 if (!(priv->status & STATUS_EXIT_PENDING)) {
10760 /* Queue up another scan... */
c4028958 10761 queue_delayed_work(priv->workqueue, &priv->request_scan, 0);
0b531676
DW		 10762 } else
10763 cancel_delayed_work(&priv->scan_event);
a613bffd
JK		 10764}
10765
c4028958 10766static void ipw_bg_link_down(struct work_struct *work)
c848d0af 10767{
c4028958
DH		 10768 struct ipw_priv *priv =
10769 container_of(work, struct ipw_priv, link_down);
4644151b 10770 mutex_lock(&priv->mutex);
c4028958 10771 ipw_link_down(priv);
4644151b 10772 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10773}
10774
2ef19e63 10775static int __devinit ipw_setup_deferred_work(struct ipw_priv *priv)
43f66a6c
JK		 10776{
10777 int ret = 0;
10778
43f66a6c 10779 priv->workqueue = create_workqueue(DRV_NAME);
43f66a6c 10780 init_waitqueue_head(&priv->wait_command_queue);
afbf30a2 10781 init_waitqueue_head(&priv->wait_state);
43f66a6c 10782
c4028958
DH		 10783 INIT_DELAYED_WORK(&priv->adhoc_check, ipw_bg_adhoc_check);
10784 INIT_WORK(&priv->associate, ipw_bg_associate);
10785 INIT_WORK(&priv->disassociate, ipw_bg_disassociate);
10786 INIT_WORK(&priv->system_config, ipw_system_config);
10787 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish);
10788 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart);
10789 INIT_DELAYED_WORK(&priv->rf_kill, ipw_bg_rf_kill);
10790 INIT_WORK(&priv->up, ipw_bg_up);
10791 INIT_WORK(&priv->down, ipw_bg_down);
10792 INIT_DELAYED_WORK(&priv->request_scan, ipw_request_scan);
ea177305
DW		 10793 INIT_DELAYED_WORK(&priv->request_direct_scan, ipw_request_direct_scan);
10794 INIT_DELAYED_WORK(&priv->request_passive_scan, ipw_request_passive_scan);
0b531676 10795 INIT_DELAYED_WORK(&priv->scan_event, ipw_scan_event);
c4028958
DH		 10796 INIT_DELAYED_WORK(&priv->gather_stats, ipw_bg_gather_stats);
10797 INIT_WORK(&priv->abort_scan, ipw_bg_abort_scan);
10798 INIT_WORK(&priv->roam, ipw_bg_roam);
10799 INIT_DELAYED_WORK(&priv->scan_check, ipw_bg_scan_check);
10800 INIT_WORK(&priv->link_up, ipw_bg_link_up);
10801 INIT_WORK(&priv->link_down, ipw_bg_link_down);
10802 INIT_DELAYED_WORK(&priv->led_link_on, ipw_bg_led_link_on);
10803 INIT_DELAYED_WORK(&priv->led_link_off, ipw_bg_led_link_off);
10804 INIT_DELAYED_WORK(&priv->led_act_off, ipw_bg_led_activity_off);
10805 INIT_WORK(&priv->merge_networks, ipw_merge_adhoc_network);
43f66a6c 10806
e43e3c1e 10807#ifdef CONFIG_IPW2200_QOS
c4028958 10808 INIT_WORK(&priv->qos_activate, ipw_bg_qos_activate);
e43e3c1e 10809#endif /* CONFIG_IPW2200_QOS */
43f66a6c
JK		 10810
10811 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10812 ipw_irq_tasklet, (unsigned long)priv);
10813
10814 return ret;
10815}
10816
43f66a6c 10817static void shim__set_security(struct net_device *dev,
b0a4e7d8 10818 struct libipw_security *sec)
43f66a6c 10819{
b0a4e7d8 10820 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10821 int i;
bf79451e 10822 for (i = 0; i < 4; i++) {
43f66a6c 10823 if (sec->flags & (1 << i)) {
afbf30a2 10824 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
b095c381 10825 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
43f66a6c 10826 if (sec->key_sizes[i] == 0)
b095c381
JK		 10827 priv->ieee->sec.flags &= ~(1 << i);
10828 else {
10829 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
43f66a6c 10830 sec->key_sizes[i]);
b095c381
JK		 10831 priv->ieee->sec.flags |= (1 << i);
10832 }
43f66a6c 10833 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10834 } else if (sec->level != SEC_LEVEL_1)
10835 priv->ieee->sec.flags &= ~(1 << i);
43f66a6c
JK		 10836 }
10837
b095c381 10838 if (sec->flags & SEC_ACTIVE_KEY) {
43f66a6c 10839 if (sec->active_key <= 3) {
b095c381
JK		 10840 priv->ieee->sec.active_key = sec->active_key;
10841 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
bf79451e 10842 } else
b095c381 10843 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c 10844 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10845 } else
10846 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c
JK		 10847
10848 if ((sec->flags & SEC_AUTH_MODE) &&
b095c381
JK		 10849 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10850 priv->ieee->sec.auth_mode = sec->auth_mode;
10851 priv->ieee->sec.flags |= SEC_AUTH_MODE;
43f66a6c
JK		 10852 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10853 priv->capability |= CAP_SHARED_KEY;
10854 else
10855 priv->capability &= ~CAP_SHARED_KEY;
10856 priv->status |= STATUS_SECURITY_UPDATED;
10857 }
bf79451e 10858
b095c381
JK		 10859 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10860 priv->ieee->sec.flags |= SEC_ENABLED;
10861 priv->ieee->sec.enabled = sec->enabled;
43f66a6c 10862 priv->status |= STATUS_SECURITY_UPDATED;
bf79451e 10863 if (sec->enabled)
43f66a6c
JK		 10864 priv->capability |= CAP_PRIVACY_ON;
10865 else
10866 priv->capability &= ~CAP_PRIVACY_ON;
10867 }
bf79451e 10868
afbf30a2
JK		 10869 if (sec->flags & SEC_ENCRYPT)
10870 priv->ieee->sec.encrypt = sec->encrypt;
bf79451e 10871
b095c381
JK		 10872 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10873 priv->ieee->sec.level = sec->level;
10874 priv->ieee->sec.flags |= SEC_LEVEL;
43f66a6c
JK		 10875 priv->status |= STATUS_SECURITY_UPDATED;
10876 }
10877
1fbfea54
ZY		 10878 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10879 ipw_set_hwcrypto_keys(priv);
10880
bf79451e
JG		 10881 /* To match current functionality of ipw2100 (which works well w/
10882 * various supplicants, we don't force a disassociate if the
43f66a6c
JK		 10883 * privacy capability changes ... */
10884#if 0
10885 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
bf79451e 10886 (((priv->assoc_request.capability &
5b5e807f 10887 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && !sec->enabled) ||
bf79451e 10888 (!(priv->assoc_request.capability &
5b5e807f 10889 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && sec->enabled))) {
43f66a6c
JK		 10890 IPW_DEBUG_ASSOC("Disassociating due to capability "
10891 "change.\n");
10892 ipw_disassociate(priv);
10893 }
10894#endif
10895}
10896
bf79451e 10897static int init_supported_rates(struct ipw_priv *priv,
43f66a6c
JK		 10898 struct ipw_supported_rates *rates)
10899{
10900 /* TODO: Mask out rates based on priv->rates_mask */
10901
10902 memset(rates, 0, sizeof(*rates));
0edd5b44 10903 /* configure supported rates */
43f66a6c 10904 switch (priv->ieee->freq_band) {
b0a4e7d8 10905 case LIBIPW_52GHZ_BAND:
43f66a6c
JK		 10906 rates->ieee_mode = IPW_A_MODE;
10907 rates->purpose = IPW_RATE_CAPABILITIES;
b0a4e7d8
JL		 10908 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10909 LIBIPW_OFDM_DEFAULT_RATES_MASK);
43f66a6c
JK		 10910 break;
10911
0edd5b44 10912 default: /* Mixed or 2.4Ghz */
43f66a6c
JK		 10913 rates->ieee_mode = IPW_G_MODE;
10914 rates->purpose = IPW_RATE_CAPABILITIES;
b0a4e7d8
JL		 10915 ipw_add_cck_scan_rates(rates, LIBIPW_CCK_MODULATION,
10916 LIBIPW_CCK_DEFAULT_RATES_MASK);
10917 if (priv->ieee->modulation & LIBIPW_OFDM_MODULATION) {
10918 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10919 LIBIPW_OFDM_DEFAULT_RATES_MASK);
43f66a6c
JK		 10920 }
10921 break;
10922 }
10923
10924 return 0;
10925}
10926
bf79451e 10927static int ipw_config(struct ipw_priv *priv)
43f66a6c 10928{
43f66a6c
JK		 10929 /* This is only called from ipw_up, which resets/reloads the firmware
10930 so, we don't need to first disable the card before we configure
10931 it */
6de9f7f2 10932 if (ipw_set_tx_power(priv))
43f66a6c
JK		 10933 goto error;
10934
10935 /* initialize adapter address */
10936 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10937 goto error;
10938
10939 /* set basic system config settings */
10940 init_sys_config(&priv->sys_config);
810dabd4
ZY		 10941
10942 /* Support Bluetooth if we have BT h/w on board, and user wants to.
10943 * Does not support BT priority yet (don't abort or defer our Tx) */
10944 if (bt_coexist) {
2638bc39 10945 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
810dabd4
ZY		 10946
10947 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10948 priv->sys_config.bt_coexistence
2638bc39 10949 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
810dabd4
ZY		 10950 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10951 priv->sys_config.bt_coexistence
2638bc39 10952 |= CFG_BT_COEXISTENCE_OOB;
810dabd4
ZY		 10953 }
10954
d685b8c2
ZY		 10955#ifdef CONFIG_IPW2200_PROMISCUOUS
10956 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
10957 priv->sys_config.accept_all_data_frames = 1;
10958 priv->sys_config.accept_non_directed_frames = 1;
10959 priv->sys_config.accept_all_mgmt_bcpr = 1;
10960 priv->sys_config.accept_all_mgmt_frames = 1;
10961 }
10962#endif
10963
c848d0af
JK		 10964 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10965 priv->sys_config.answer_broadcast_ssid_probe = 1;
10966 else
10967 priv->sys_config.answer_broadcast_ssid_probe = 0;
10968
d685b8c2 10969 if (ipw_send_system_config(priv))
43f66a6c
JK		 10970 goto error;
10971
0edd5b44
JG		 10972 init_supported_rates(priv, &priv->rates);
10973 if (ipw_send_supported_rates(priv, &priv->rates))
43f66a6c
JK		 10974 goto error;
10975
10976 /* Set request-to-send threshold */
10977 if (priv->rts_threshold) {
10978 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10979 goto error;
10980 }
e43e3c1e 10981#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 10982 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10983 ipw_qos_activate(priv, NULL);
e43e3c1e 10984#endif /* CONFIG_IPW2200_QOS */
43f66a6c
JK		 10985
10986 if (ipw_set_random_seed(priv))
10987 goto error;
bf79451e 10988
43f66a6c
JK		 10989 /* final state transition to the RUN state */
10990 if (ipw_send_host_complete(priv))
10991 goto error;
10992
e666619e
JK		 10993 priv->status |= STATUS_INIT;
10994
10995 ipw_led_init(priv);
10996 ipw_led_radio_on(priv);
10997 priv->notif_missed_beacons = 0;
10998
10999 /* Set hardware WEP key if it is configured. */
11000 if ((priv->capability & CAP_PRIVACY_ON) &&
11001 (priv->ieee->sec.level == SEC_LEVEL_1) &&
11002 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
11003 ipw_set_hwcrypto_keys(priv);
43f66a6c
JK		 11004
11005 return 0;
bf79451e 11006
0edd5b44 11007 error:
43f66a6c
JK		 11008 return -EIO;
11009}
11010
4f36f808
JK		 11011/*
11012 * NOTE:
11013 *
11014 * These tables have been tested in conjunction with the
11015 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
11016 *
11017 * Altering this values, using it on other hardware, or in geographies
11018 * not intended for resale of the above mentioned Intel adapters has
11019 * not been tested.
11020 *
48a84770
HBA		 11021 * Remember to update the table in README.ipw2200 when changing this
11022 * table.
11023 *
4f36f808 11024 */
b0a4e7d8 11025static const struct libipw_geo ipw_geos[] = {
4f36f808
JK		 11026 { /* Restricted */
11027 "---",
11028 .bg_channels = 11,
11029 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11030 {2427, 4}, {2432, 5}, {2437, 6},
11031 {2442, 7}, {2447, 8}, {2452, 9},
11032 {2457, 10}, {2462, 11}},
11033 },
11034
11035 { /* Custom US/Canada */
11036 "ZZF",
11037 .bg_channels = 11,
11038 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11039 {2427, 4}, {2432, 5}, {2437, 6},
11040 {2442, 7}, {2447, 8}, {2452, 9},
11041 {2457, 10}, {2462, 11}},
11042 .a_channels = 8,
11043 .a = {{5180, 36},
11044 {5200, 40},
11045 {5220, 44},
11046 {5240, 48},
b0a4e7d8
JL		 11047 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11048 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11049 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11050 {5320, 64, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11051 },
11052
11053 { /* Rest of World */
11054 "ZZD",
11055 .bg_channels = 13,
11056 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11057 {2427, 4}, {2432, 5}, {2437, 6},
11058 {2442, 7}, {2447, 8}, {2452, 9},
11059 {2457, 10}, {2462, 11}, {2467, 12},
11060 {2472, 13}},
11061 },
11062
11063 { /* Custom USA & Europe & High */
11064 "ZZA",
11065 .bg_channels = 11,
11066 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11067 {2427, 4}, {2432, 5}, {2437, 6},
11068 {2442, 7}, {2447, 8}, {2452, 9},
11069 {2457, 10}, {2462, 11}},
11070 .a_channels = 13,
11071 .a = {{5180, 36},
11072 {5200, 40},
11073 {5220, 44},
11074 {5240, 48},
b0a4e7d8
JL		 11075 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11076 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11077 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11078 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
4f36f808
JK		 11079 {5745, 149},
11080 {5765, 153},
11081 {5785, 157},
11082 {5805, 161},
11083 {5825, 165}},
11084 },
11085
11086 { /* Custom NA & Europe */
11087 "ZZB",
11088 .bg_channels = 11,
11089 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11090 {2427, 4}, {2432, 5}, {2437, 6},
11091 {2442, 7}, {2447, 8}, {2452, 9},
11092 {2457, 10}, {2462, 11}},
11093 .a_channels = 13,
11094 .a = {{5180, 36},
11095 {5200, 40},
11096 {5220, 44},
11097 {5240, 48},
b0a4e7d8
JL		 11098 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11099 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11100 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11101 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11102 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11103 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11104 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11105 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11106 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11107 },
11108
11109 { /* Custom Japan */
11110 "ZZC",
11111 .bg_channels = 11,
11112 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11113 {2427, 4}, {2432, 5}, {2437, 6},
11114 {2442, 7}, {2447, 8}, {2452, 9},
11115 {2457, 10}, {2462, 11}},
11116 .a_channels = 4,
11117 .a = {{5170, 34}, {5190, 38},
11118 {5210, 42}, {5230, 46}},
11119 },
11120
11121 { /* Custom */
11122 "ZZM",
11123 .bg_channels = 11,
11124 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11125 {2427, 4}, {2432, 5}, {2437, 6},
11126 {2442, 7}, {2447, 8}, {2452, 9},
11127 {2457, 10}, {2462, 11}},
11128 },
11129
11130 { /* Europe */
11131 "ZZE",
11132 .bg_channels = 13,
11133 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11134 {2427, 4}, {2432, 5}, {2437, 6},
11135 {2442, 7}, {2447, 8}, {2452, 9},
11136 {2457, 10}, {2462, 11}, {2467, 12},
11137 {2472, 13}},
11138 .a_channels = 19,
11139 .a = {{5180, 36},
11140 {5200, 40},
11141 {5220, 44},
11142 {5240, 48},
b0a4e7d8
JL		 11143 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11144 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11145 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11146 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11147 {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11148 {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11149 {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11150 {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11151 {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11152 {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11153 {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11154 {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11155 {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11156 {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11157 {5700, 140, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11158 },
11159
11160 { /* Custom Japan */
11161 "ZZJ",
11162 .bg_channels = 14,
11163 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11164 {2427, 4}, {2432, 5}, {2437, 6},
11165 {2442, 7}, {2447, 8}, {2452, 9},
11166 {2457, 10}, {2462, 11}, {2467, 12},
b0a4e7d8 11167 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY}},
4f36f808
JK		 11168 .a_channels = 4,
11169 .a = {{5170, 34}, {5190, 38},
11170 {5210, 42}, {5230, 46}},
11171 },
11172
03520576
JK		 11173 { /* Rest of World */
11174 "ZZR",
11175 .bg_channels = 14,
11176 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11177 {2427, 4}, {2432, 5}, {2437, 6},
11178 {2442, 7}, {2447, 8}, {2452, 9},
11179 {2457, 10}, {2462, 11}, {2467, 12},
b0a4e7d8
JL		 11180 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY |
11181 LIBIPW_CH_PASSIVE_ONLY}},
03520576
JK		 11182 },
11183
4f36f808
JK		 11184 { /* High Band */
11185 "ZZH",
11186 .bg_channels = 13,
11187 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11188 {2427, 4}, {2432, 5}, {2437, 6},
11189 {2442, 7}, {2447, 8}, {2452, 9},
11190 {2457, 10}, {2462, 11},
b0a4e7d8
JL		 11191 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11192 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11193 .a_channels = 4,
11194 .a = {{5745, 149}, {5765, 153},
11195 {5785, 157}, {5805, 161}},
11196 },
11197
11198 { /* Custom Europe */
11199 "ZZG",
11200 .bg_channels = 13,
11201 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11202 {2427, 4}, {2432, 5}, {2437, 6},
11203 {2442, 7}, {2447, 8}, {2452, 9},
11204 {2457, 10}, {2462, 11},
11205 {2467, 12}, {2472, 13}},
11206 .a_channels = 4,
11207 .a = {{5180, 36}, {5200, 40},
11208 {5220, 44}, {5240, 48}},
11209 },
11210
11211 { /* Europe */
11212 "ZZK",
11213 .bg_channels = 13,
11214 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11215 {2427, 4}, {2432, 5}, {2437, 6},
11216 {2442, 7}, {2447, 8}, {2452, 9},
11217 {2457, 10}, {2462, 11},
b0a4e7d8
JL		 11218 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11219 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808 11220 .a_channels = 24,
b0a4e7d8
JL		 11221 .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11222 {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11223 {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11224 {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11225 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11226 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11227 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11228 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11229 {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11230 {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11231 {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11232 {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11233 {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11234 {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11235 {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11236 {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11237 {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11238 {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11239 {5700, 140, LIBIPW_CH_PASSIVE_ONLY},
11240 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11241 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11242 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11243 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11244 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11245 },
11246
11247 { /* Europe */
11248 "ZZL",
11249 .bg_channels = 11,
11250 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11251 {2427, 4}, {2432, 5}, {2437, 6},
11252 {2442, 7}, {2447, 8}, {2452, 9},
11253 {2457, 10}, {2462, 11}},
11254 .a_channels = 13,
b0a4e7d8
JL		 11255 .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11256 {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11257 {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11258 {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11259 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11260 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11261 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11262 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11263 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11264 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11265 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11266 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11267 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808 11268 }
afbf30a2
JK		 11269};
11270
43f66a6c
JK		 11271#define MAX_HW_RESTARTS 5
11272static int ipw_up(struct ipw_priv *priv)
11273{
4f36f808 11274 int rc, i, j;
43f66a6c 11275
c3d72b96
DW		 11276 /* Age scan list entries found before suspend */
11277 if (priv->suspend_time) {
b0a4e7d8 11278 libipw_networks_age(priv->ieee, priv->suspend_time);
c3d72b96
DW		 11279 priv->suspend_time = 0;
11280 }
11281
43f66a6c
JK		 11282 if (priv->status & STATUS_EXIT_PENDING)
11283 return -EIO;
11284
f6c5cb7c 11285 if (cmdlog && !priv->cmdlog) {
e6e3f12a 11286 priv->cmdlog = kcalloc(cmdlog, sizeof(*priv->cmdlog),
f6c5cb7c
JK		 11287 GFP_KERNEL);
11288 if (priv->cmdlog == NULL) {
11289 IPW_ERROR("Error allocating %d command log entries.\n",
11290 cmdlog);
d0b526b7 11291 return -ENOMEM;
f6c5cb7c 11292 } else {
f6c5cb7c
JK		 11293 priv->cmdlog_len = cmdlog;
11294 }
11295 }
11296
0edd5b44 11297 for (i = 0; i < MAX_HW_RESTARTS; i++) {
bf79451e 11298 /* Load the microcode, firmware, and eeprom.
43f66a6c
JK		 11299 * Also start the clocks. */
11300 rc = ipw_load(priv);
11301 if (rc) {
a4f6bbb3 11302 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 11303 return rc;
11304 }
11305
11306 ipw_init_ordinals(priv);
11307 if (!(priv->config & CFG_CUSTOM_MAC))
11308 eeprom_parse_mac(priv, priv->mac_addr);
11309 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
5e5eab5d 11310 memcpy(priv->net_dev->perm_addr, priv->mac_addr, ETH_ALEN);
43f66a6c 11311
4f36f808
JK		 11312 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
11313 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11314 ipw_geos[j].name, 3))
11315 break;
11316 }
03520576
JK		 11317 if (j == ARRAY_SIZE(ipw_geos)) {
11318 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
11319 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
11320 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
11321 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
4f36f808 11322 j = 0;
03520576 11323 }
b0a4e7d8 11324 if (libipw_set_geo(priv->ieee, &ipw_geos[j])) {
4f36f808
JK		 11325 IPW_WARNING("Could not set geography.");
11326 return 0;
11327 }
11328
b095c381
JK		 11329 if (priv->status & STATUS_RF_KILL_SW) {
11330 IPW_WARNING("Radio disabled by module parameter.\n");
11331 return 0;
11332 } else if (rf_kill_active(priv)) {
11333 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
11334 "Kill switch must be turned off for "
11335 "wireless networking to work.\n");
11336 queue_delayed_work(priv->workqueue, &priv->rf_kill,
11337 2 * HZ);
43f66a6c 11338 return 0;
c848d0af 11339 }
43f66a6c
JK		 11340
11341 rc = ipw_config(priv);
11342 if (!rc) {
11343 IPW_DEBUG_INFO("Configured device on count %i\n", i);
e666619e
JK		 11344
11345 /* If configure to try and auto-associate, kick
11346 * off a scan. */
c4028958
DH		 11347 queue_delayed_work(priv->workqueue,
11348 &priv->request_scan, 0);
afbf30a2 11349
43f66a6c 11350 return 0;
43f66a6c 11351 }
bf79451e 11352
c848d0af 11353 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
43f66a6c
JK		 11354 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
11355 i, MAX_HW_RESTARTS);
11356
11357 /* We had an error bringing up the hardware, so take it
11358 * all the way back down so we can try again */
11359 ipw_down(priv);
11360 }
11361
bf79451e 11362 /* tried to restart and config the device for as long as our
43f66a6c 11363 * patience could withstand */
0edd5b44 11364 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
c848d0af 11365
43f66a6c
JK		 11366 return -EIO;
11367}
11368
c4028958 11369static void ipw_bg_up(struct work_struct *work)
c848d0af 11370{
c4028958
DH		 11371 struct ipw_priv *priv =
11372 container_of(work, struct ipw_priv, up);
4644151b 11373 mutex_lock(&priv->mutex);
c4028958 11374 ipw_up(priv);
4644151b 11375 mutex_unlock(&priv->mutex);
c848d0af
JK		 11376}
11377
b095c381 11378static void ipw_deinit(struct ipw_priv *priv)
43f66a6c 11379{
b095c381
JK		 11380 int i;
11381
11382 if (priv->status & STATUS_SCANNING) {
11383 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
11384 ipw_abort_scan(priv);
11385 }
11386
11387 if (priv->status & STATUS_ASSOCIATED) {
11388 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
11389 ipw_disassociate(priv);
11390 }
11391
11392 ipw_led_shutdown(priv);
11393
11394 /* Wait up to 1s for status to change to not scanning and not
11395 * associated (disassociation can take a while for a ful 802.11
11396 * exchange */
11397 for (i = 1000; i && (priv->status &
11398 (STATUS_DISASSOCIATING |
11399 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11400 udelay(10);
11401
11402 if (priv->status & (STATUS_DISASSOCIATING |
11403 STATUS_ASSOCIATED | STATUS_SCANNING))
11404 IPW_DEBUG_INFO("Still associated or scanning...\n");
11405 else
11406 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11407
43f66a6c 11408 /* Attempt to disable the card */
43f66a6c 11409 ipw_send_card_disable(priv, 0);
b095c381
JK		 11410
11411 priv->status &= ~STATUS_INIT;
11412}
11413
11414static void ipw_down(struct ipw_priv *priv)
11415{
11416 int exit_pending = priv->status & STATUS_EXIT_PENDING;
11417
11418 priv->status |= STATUS_EXIT_PENDING;
11419
11420 if (ipw_is_init(priv))
11421 ipw_deinit(priv);
11422
11423 /* Wipe out the EXIT_PENDING status bit if we are not actually
11424 * exiting the module */
11425 if (!exit_pending)
11426 priv->status &= ~STATUS_EXIT_PENDING;
43f66a6c
JK		 11427
11428 /* tell the device to stop sending interrupts */
11429 ipw_disable_interrupts(priv);
11430
11431 /* Clear all bits but the RF Kill */
b095c381 11432 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
43f66a6c 11433 netif_carrier_off(priv->net_dev);
43f66a6c
JK		 11434
11435 ipw_stop_nic(priv);
a613bffd
JK		 11436
11437 ipw_led_radio_off(priv);
43f66a6c
JK		 11438}
11439
c4028958 11440static void ipw_bg_down(struct work_struct *work)
c848d0af 11441{
c4028958
DH		 11442 struct ipw_priv *priv =
11443 container_of(work, struct ipw_priv, down);
4644151b 11444 mutex_lock(&priv->mutex);
c4028958 11445 ipw_down(priv);
4644151b 11446 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11447}
11448
11449/* Called by register_netdev() */
11450static int ipw_net_init(struct net_device *dev)
11451{
a3caa99e 11452 int i, rc = 0;
b0a4e7d8 11453 struct ipw_priv *priv = libipw_priv(dev);
a3caa99e
JL		 11454 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
11455 struct wireless_dev *wdev = &priv->ieee->wdev;
4644151b 11456 mutex_lock(&priv->mutex);
43f66a6c 11457
c848d0af 11458 if (ipw_up(priv)) {
a3caa99e
JL		 11459 rc = -EIO;
11460 goto out;
b8ecd988
JL		 11461 }
11462
a3caa99e
JL		 11463 memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
11464
11465 /* fill-out priv->ieee->bg_band */
11466 if (geo->bg_channels) {
11467 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
11468
11469 bg_band->band = IEEE80211_BAND_2GHZ;
11470 bg_band->n_channels = geo->bg_channels;
11471 bg_band->channels =
11472 kzalloc(geo->bg_channels *
11473 sizeof(struct ieee80211_channel), GFP_KERNEL);
11474 /* translate geo->bg to bg_band.channels */
11475 for (i = 0; i < geo->bg_channels; i++) {
11476 bg_band->channels[i].band = IEEE80211_BAND_2GHZ;
11477 bg_band->channels[i].center_freq = geo->bg[i].freq;
11478 bg_band->channels[i].hw_value = geo->bg[i].channel;
11479 bg_band->channels[i].max_power = geo->bg[i].max_power;
11480 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11481 bg_band->channels[i].flags |=
11482 IEEE80211_CHAN_PASSIVE_SCAN;
11483 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
11484 bg_band->channels[i].flags |=
11485 IEEE80211_CHAN_NO_IBSS;
11486 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
11487 bg_band->channels[i].flags |=
11488 IEEE80211_CHAN_RADAR;
11489 /* No equivalent for LIBIPW_CH_80211H_RULES,
11490 LIBIPW_CH_UNIFORM_SPREADING, or
11491 LIBIPW_CH_B_ONLY... */
11492 }
11493 /* point at bitrate info */
11494 bg_band->bitrates = ipw2200_bg_rates;
11495 bg_band->n_bitrates = ipw2200_num_bg_rates;
11496
11497 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = bg_band;
b8ecd988
JL		 11498 }
11499
a3caa99e
JL		 11500 /* fill-out priv->ieee->a_band */
11501 if (geo->a_channels) {
11502 struct ieee80211_supported_band *a_band = &priv->ieee->a_band;
11503
11504 a_band->band = IEEE80211_BAND_5GHZ;
11505 a_band->n_channels = geo->a_channels;
11506 a_band->channels =
11507 kzalloc(geo->a_channels *
11508 sizeof(struct ieee80211_channel), GFP_KERNEL);
11509 /* translate geo->bg to a_band.channels */
11510 for (i = 0; i < geo->a_channels; i++) {
11511 a_band->channels[i].band = IEEE80211_BAND_2GHZ;
11512 a_band->channels[i].center_freq = geo->a[i].freq;
11513 a_band->channels[i].hw_value = geo->a[i].channel;
11514 a_band->channels[i].max_power = geo->a[i].max_power;
11515 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11516 a_band->channels[i].flags |=
11517 IEEE80211_CHAN_PASSIVE_SCAN;
11518 if (geo->a[i].flags & LIBIPW_CH_NO_IBSS)
11519 a_band->channels[i].flags |=
11520 IEEE80211_CHAN_NO_IBSS;
11521 if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)
11522 a_band->channels[i].flags |=
11523 IEEE80211_CHAN_RADAR;
11524 /* No equivalent for LIBIPW_CH_80211H_RULES,
11525 LIBIPW_CH_UNIFORM_SPREADING, or
11526 LIBIPW_CH_B_ONLY... */
11527 }
11528 /* point at bitrate info */
11529 a_band->bitrates = ipw2200_a_rates;
11530 a_band->n_bitrates = ipw2200_num_a_rates;
11531
11532 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = a_band;
11533 }
11534
11535 set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
11536
11537 /* With that information in place, we can now register the wiphy... */
11538 if (wiphy_register(wdev->wiphy)) {
11539 rc = -EIO;
11540 goto out;
11541 }
11542
11543out:
4644151b 11544 mutex_unlock(&priv->mutex);
a3caa99e 11545 return rc;
43f66a6c
JK		 11546}
11547
11548/* PCI driver stuff */
a3aa1884 11549static DEFINE_PCI_DEVICE_TABLE(card_ids) = {
43f66a6c
JK		 11550 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
11551 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
11552 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
11553 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
11554 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
11555 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
11556 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
11557 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
11558 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
11559 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
11560 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
11561 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
11562 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
11563 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
11564 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
11565 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
11566 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
8ab0ea77
JP		 11567 {PCI_VDEVICE(INTEL, 0x104f), 0},
11568 {PCI_VDEVICE(INTEL, 0x4220), 0}, /* BG */
11569 {PCI_VDEVICE(INTEL, 0x4221), 0}, /* BG */
11570 {PCI_VDEVICE(INTEL, 0x4223), 0}, /* ABG */
11571 {PCI_VDEVICE(INTEL, 0x4224), 0}, /* ABG */
bf79451e 11572
43f66a6c
JK		 11573 /* required last entry */
11574 {0,}
11575};
11576
11577MODULE_DEVICE_TABLE(pci, card_ids);
11578
11579static struct attribute *ipw_sysfs_entries[] = {
11580 &dev_attr_rf_kill.attr,
11581 &dev_attr_direct_dword.attr,
11582 &dev_attr_indirect_byte.attr,
11583 &dev_attr_indirect_dword.attr,
11584 &dev_attr_mem_gpio_reg.attr,
11585 &dev_attr_command_event_reg.attr,
11586 &dev_attr_nic_type.attr,
11587 &dev_attr_status.attr,
11588 &dev_attr_cfg.attr,
b39860c6
JK		 11589 &dev_attr_error.attr,
11590 &dev_attr_event_log.attr,
f6c5cb7c 11591 &dev_attr_cmd_log.attr,
43f66a6c
JK		 11592 &dev_attr_eeprom_delay.attr,
11593 &dev_attr_ucode_version.attr,
11594 &dev_attr_rtc.attr,
a613bffd
JK		 11595 &dev_attr_scan_age.attr,
11596 &dev_attr_led.attr,
b095c381
JK		 11597 &dev_attr_speed_scan.attr,
11598 &dev_attr_net_stats.attr,
375dd244 11599 &dev_attr_channels.attr,
d685b8c2
ZY		 11600#ifdef CONFIG_IPW2200_PROMISCUOUS
11601 &dev_attr_rtap_iface.attr,
11602 &dev_attr_rtap_filter.attr,
11603#endif
43f66a6c
JK		 11604 NULL
11605};
11606
11607static struct attribute_group ipw_attribute_group = {
11608 .name = NULL, /* put in device directory */
0edd5b44 11609 .attrs = ipw_sysfs_entries,
43f66a6c
JK		 11610};
11611
d685b8c2
ZY		 11612#ifdef CONFIG_IPW2200_PROMISCUOUS
11613static int ipw_prom_open(struct net_device *dev)
11614{
b0a4e7d8 11615 struct ipw_prom_priv *prom_priv = libipw_priv(dev);
d685b8c2
ZY		 11616 struct ipw_priv *priv = prom_priv->priv;
11617
11618 IPW_DEBUG_INFO("prom dev->open\n");
11619 netif_carrier_off(dev);
d685b8c2
ZY		 11620
11621 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11622 priv->sys_config.accept_all_data_frames = 1;
11623 priv->sys_config.accept_non_directed_frames = 1;
11624 priv->sys_config.accept_all_mgmt_bcpr = 1;
11625 priv->sys_config.accept_all_mgmt_frames = 1;
11626
11627 ipw_send_system_config(priv);
11628 }
11629
11630 return 0;
11631}
11632
11633static int ipw_prom_stop(struct net_device *dev)
11634{
b0a4e7d8 11635 struct ipw_prom_priv *prom_priv = libipw_priv(dev);
d685b8c2
ZY		 11636 struct ipw_priv *priv = prom_priv->priv;
11637
11638 IPW_DEBUG_INFO("prom dev->stop\n");
11639
11640 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11641 priv->sys_config.accept_all_data_frames = 0;
11642 priv->sys_config.accept_non_directed_frames = 0;
11643 priv->sys_config.accept_all_mgmt_bcpr = 0;
11644 priv->sys_config.accept_all_mgmt_frames = 0;
11645
11646 ipw_send_system_config(priv);
11647 }
11648
11649 return 0;
11650}
11651
d0cf9c0d
SH		 11652static netdev_tx_t ipw_prom_hard_start_xmit(struct sk_buff *skb,
11653 struct net_device *dev)
d685b8c2
ZY		 11654{
11655 IPW_DEBUG_INFO("prom dev->xmit\n");
4153e775
PM		 11656 dev_kfree_skb(skb);
11657 return NETDEV_TX_OK;
d685b8c2
ZY		 11658}
11659
44e9ad0b
SH		 11660static const struct net_device_ops ipw_prom_netdev_ops = {
11661 .ndo_open = ipw_prom_open,
11662 .ndo_stop = ipw_prom_stop,
11663 .ndo_start_xmit = ipw_prom_hard_start_xmit,
b0a4e7d8 11664 .ndo_change_mtu = libipw_change_mtu,
44e9ad0b
SH		 11665 .ndo_set_mac_address = eth_mac_addr,
11666 .ndo_validate_addr = eth_validate_addr,
11667};
11668
d685b8c2
ZY		 11669static int ipw_prom_alloc(struct ipw_priv *priv)
11670{
11671 int rc = 0;
11672
11673 if (priv->prom_net_dev)
11674 return -EPERM;
11675
27ae60f8 11676 priv->prom_net_dev = alloc_libipw(sizeof(struct ipw_prom_priv), 1);
d685b8c2
ZY		 11677 if (priv->prom_net_dev == NULL)
11678 return -ENOMEM;
11679
b0a4e7d8 11680 priv->prom_priv = libipw_priv(priv->prom_net_dev);
d685b8c2
ZY		 11681 priv->prom_priv->ieee = netdev_priv(priv->prom_net_dev);
11682 priv->prom_priv->priv = priv;
11683
11684 strcpy(priv->prom_net_dev->name, "rtap%d");
3f2eeac9 11685 memcpy(priv->prom_net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
d685b8c2
ZY		 11686
11687 priv->prom_net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
44e9ad0b 11688 priv->prom_net_dev->netdev_ops = &ipw_prom_netdev_ops;
d685b8c2
ZY		 11689
11690 priv->prom_priv->ieee->iw_mode = IW_MODE_MONITOR;
229ce3ab 11691 SET_NETDEV_DEV(priv->prom_net_dev, &priv->pci_dev->dev);
d685b8c2
ZY		 11692
11693 rc = register_netdev(priv->prom_net_dev);
11694 if (rc) {
27ae60f8 11695 free_libipw(priv->prom_net_dev, 1);
d685b8c2
ZY		 11696 priv->prom_net_dev = NULL;
11697 return rc;
11698 }
11699
11700 return 0;
11701}
11702
11703static void ipw_prom_free(struct ipw_priv *priv)
11704{
11705 if (!priv->prom_net_dev)
11706 return;
11707
11708 unregister_netdev(priv->prom_net_dev);
27ae60f8 11709 free_libipw(priv->prom_net_dev, 1);
d685b8c2
ZY		 11710
11711 priv->prom_net_dev = NULL;
11712}
11713
11714#endif
11715
44e9ad0b
SH		 11716static const struct net_device_ops ipw_netdev_ops = {
11717 .ndo_init = ipw_net_init,
11718 .ndo_open = ipw_net_open,
11719 .ndo_stop = ipw_net_stop,
11720 .ndo_set_multicast_list = ipw_net_set_multicast_list,
11721 .ndo_set_mac_address = ipw_net_set_mac_address,
b0a4e7d8
JL		 11722 .ndo_start_xmit = libipw_xmit,
11723 .ndo_change_mtu = libipw_change_mtu,
44e9ad0b
SH		 11724 .ndo_validate_addr = eth_validate_addr,
11725};
d685b8c2 11726
2ef19e63
AB		 11727static int __devinit ipw_pci_probe(struct pci_dev *pdev,
11728 const struct pci_device_id *ent)
43f66a6c
JK		 11729{
11730 int err = 0;
11731 struct net_device *net_dev;
11732 void __iomem *base;
11733 u32 length, val;
11734 struct ipw_priv *priv;
afbf30a2 11735 int i;
43f66a6c 11736
27ae60f8 11737 net_dev = alloc_libipw(sizeof(struct ipw_priv), 0);
43f66a6c
JK		 11738 if (net_dev == NULL) {
11739 err = -ENOMEM;
11740 goto out;
11741 }
11742
b0a4e7d8 11743 priv = libipw_priv(net_dev);
43f66a6c 11744 priv->ieee = netdev_priv(net_dev);
a613bffd 11745
43f66a6c
JK		 11746 priv->net_dev = net_dev;
11747 priv->pci_dev = pdev;
43f66a6c 11748 ipw_debug_level = debug;
89c318ed 11749 spin_lock_init(&priv->irq_lock);
43f66a6c 11750 spin_lock_init(&priv->lock);
afbf30a2
JK		 11751 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11752 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
43f66a6c 11753
4644151b 11754 mutex_init(&priv->mutex);
43f66a6c
JK		 11755 if (pci_enable_device(pdev)) {
11756 err = -ENODEV;
27ae60f8 11757 goto out_free_libipw;
43f66a6c
JK		 11758 }
11759
11760 pci_set_master(pdev);
11761
284901a9 11762 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
bf79451e 11763 if (!err)
284901a9 11764 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
43f66a6c
JK		 11765 if (err) {
11766 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11767 goto out_pci_disable_device;
11768 }
11769
11770 pci_set_drvdata(pdev, priv);
11771
11772 err = pci_request_regions(pdev, DRV_NAME);
bf79451e 11773 if (err)
43f66a6c
JK		 11774 goto out_pci_disable_device;
11775
bf79451e 11776 /* We disable the RETRY_TIMEOUT register (0x41) to keep
43f66a6c 11777 * PCI Tx retries from interfering with C3 CPU state */
bf79451e
JG		 11778 pci_read_config_dword(pdev, 0x40, &val);
11779 if ((val & 0x0000ff00) != 0)
43f66a6c 11780 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
bf79451e 11781
43f66a6c
JK		 11782 length = pci_resource_len(pdev, 0);
11783 priv->hw_len = length;
bf79451e 11784
275f165f 11785 base = pci_ioremap_bar(pdev, 0);
43f66a6c
JK		 11786 if (!base) {
11787 err = -ENODEV;
11788 goto out_pci_release_regions;
11789 }
11790
11791 priv->hw_base = base;
11792 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11793 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11794
11795 err = ipw_setup_deferred_work(priv);
11796 if (err) {
11797 IPW_ERROR("Unable to setup deferred work\n");
11798 goto out_iounmap;
11799 }
11800
b095c381 11801 ipw_sw_reset(priv, 1);
43f66a6c 11802
1fb9df5d 11803 err = request_irq(pdev->irq, ipw_isr, IRQF_SHARED, DRV_NAME, priv);
43f66a6c
JK		 11804 if (err) {
11805 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11806 goto out_destroy_workqueue;
11807 }
11808
43f66a6c
JK		 11809 SET_NETDEV_DEV(net_dev, &pdev->dev);
11810
4644151b 11811 mutex_lock(&priv->mutex);
c848d0af 11812
43f66a6c
JK		 11813 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11814 priv->ieee->set_security = shim__set_security;
227d2dc1 11815 priv->ieee->is_queue_full = ipw_net_is_queue_full;
43f66a6c 11816
e43e3c1e 11817#ifdef CONFIG_IPW2200_QOS
a5cf4fe6 11818 priv->ieee->is_qos_active = ipw_is_qos_active;
3b9990cb
JK		 11819 priv->ieee->handle_probe_response = ipw_handle_beacon;
11820 priv->ieee->handle_beacon = ipw_handle_probe_response;
11821 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
e43e3c1e 11822#endif /* CONFIG_IPW2200_QOS */
b095c381 11823
c848d0af
JK		 11824 priv->ieee->perfect_rssi = -20;
11825 priv->ieee->worst_rssi = -85;
43f66a6c 11826
44e9ad0b 11827 net_dev->netdev_ops = &ipw_netdev_ops;
97a78ca9 11828 priv->wireless_data.spy_data = &priv->ieee->spy_data;
97a78ca9 11829 net_dev->wireless_data = &priv->wireless_data;
43f66a6c
JK		 11830 net_dev->wireless_handlers = &ipw_wx_handler_def;
11831 net_dev->ethtool_ops = &ipw_ethtool_ops;
11832 net_dev->irq = pdev->irq;
0edd5b44 11833 net_dev->base_addr = (unsigned long)priv->hw_base;
43f66a6c
JK		 11834 net_dev->mem_start = pci_resource_start(pdev, 0);
11835 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11836
11837 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11838 if (err) {
11839 IPW_ERROR("failed to create sysfs device attributes\n");
4644151b 11840 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11841 goto out_release_irq;
11842 }
11843
4644151b 11844 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11845 err = register_netdev(net_dev);
11846 if (err) {
11847 IPW_ERROR("failed to register network device\n");
a613bffd 11848 goto out_remove_sysfs;
43f66a6c 11849 }
48a84770 11850
d685b8c2
ZY		 11851#ifdef CONFIG_IPW2200_PROMISCUOUS
11852 if (rtap_iface) {
11853 err = ipw_prom_alloc(priv);
11854 if (err) {
11855 IPW_ERROR("Failed to register promiscuous network "
11856 "device (error %d).\n", err);
11857 unregister_netdev(priv->net_dev);
11858 goto out_remove_sysfs;
11859 }
11860 }
11861#endif
11862
48a84770
HBA		 11863 printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
11864 "channels, %d 802.11a channels)\n",
11865 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
11866 priv->ieee->geo.a_channels);
11867
43f66a6c
JK		 11868 return 0;
11869
a613bffd 11870 out_remove_sysfs:
43f66a6c 11871 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
0edd5b44 11872 out_release_irq:
43f66a6c 11873 free_irq(pdev->irq, priv);
0edd5b44 11874 out_destroy_workqueue:
43f66a6c
JK		 11875 destroy_workqueue(priv->workqueue);
11876 priv->workqueue = NULL;
0edd5b44 11877 out_iounmap:
43f66a6c 11878 iounmap(priv->hw_base);
0edd5b44 11879 out_pci_release_regions:
43f66a6c 11880 pci_release_regions(pdev);
0edd5b44 11881 out_pci_disable_device:
43f66a6c
JK		 11882 pci_disable_device(pdev);
11883 pci_set_drvdata(pdev, NULL);
27ae60f8
PR		 11884 out_free_libipw:
11885 free_libipw(priv->net_dev, 0);
0edd5b44 11886 out:
43f66a6c
JK		 11887 return err;
11888}
11889
2ef19e63 11890static void __devexit ipw_pci_remove(struct pci_dev *pdev)
43f66a6c
JK		 11891{
11892 struct ipw_priv *priv = pci_get_drvdata(pdev);
afbf30a2
JK		 11893 struct list_head *p, *q;
11894 int i;
b095c381 11895
43f66a6c
JK		 11896 if (!priv)
11897 return;
11898
4644151b 11899 mutex_lock(&priv->mutex);
43f66a6c 11900
afbf30a2 11901 priv->status |= STATUS_EXIT_PENDING;
43f66a6c 11902 ipw_down(priv);
43f66a6c
JK		 11903 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11904
4644151b 11905 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11906
11907 unregister_netdev(priv->net_dev);
11908
11909 if (priv->rxq) {
11910 ipw_rx_queue_free(priv, priv->rxq);
11911 priv->rxq = NULL;
11912 }
11913 ipw_tx_queue_free(priv);
11914
f6c5cb7c
JK		 11915 if (priv->cmdlog) {
11916 kfree(priv->cmdlog);
11917 priv->cmdlog = NULL;
11918 }
43f66a6c
JK		 11919 /* ipw_down will ensure that there is no more pending work
11920 * in the workqueue's, so we can safely remove them now. */
a613bffd
JK		 11921 cancel_delayed_work(&priv->adhoc_check);
11922 cancel_delayed_work(&priv->gather_stats);
11923 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 11924 cancel_delayed_work(&priv->request_direct_scan);
11925 cancel_delayed_work(&priv->request_passive_scan);
0b531676 11926 cancel_delayed_work(&priv->scan_event);
a613bffd
JK		 11927 cancel_delayed_work(&priv->rf_kill);
11928 cancel_delayed_work(&priv->scan_check);
11929 destroy_workqueue(priv->workqueue);
11930 priv->workqueue = NULL;
43f66a6c 11931
afbf30a2
JK		 11932 /* Free MAC hash list for ADHOC */
11933 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11934 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
afbf30a2 11935 list_del(p);
489f4458 11936 kfree(list_entry(p, struct ipw_ibss_seq, list));
afbf30a2
JK		 11937 }
11938 }
11939
8f760780
JJ		 11940 kfree(priv->error);
11941 priv->error = NULL;
43f66a6c 11942
d685b8c2
ZY		 11943#ifdef CONFIG_IPW2200_PROMISCUOUS
11944 ipw_prom_free(priv);
11945#endif
11946
43f66a6c
JK		 11947 free_irq(pdev->irq, priv);
11948 iounmap(priv->hw_base);
11949 pci_release_regions(pdev);
11950 pci_disable_device(pdev);
11951 pci_set_drvdata(pdev, NULL);
27ae60f8 11952 /* wiphy_unregister needs to be here, before free_libipw */
a3caa99e
JL		 11953 wiphy_unregister(priv->ieee->wdev.wiphy);
11954 kfree(priv->ieee->a_band.channels);
11955 kfree(priv->ieee->bg_band.channels);
27ae60f8 11956 free_libipw(priv->net_dev, 0);
afbf30a2 11957 free_firmware();
43f66a6c
JK		 11958}
11959
43f66a6c 11960#ifdef CONFIG_PM
583a4e88 11961static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
43f66a6c
JK		 11962{
11963 struct ipw_priv *priv = pci_get_drvdata(pdev);
11964 struct net_device *dev = priv->net_dev;
11965
11966 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11967
0edd5b44 11968 /* Take down the device; powers it off, etc. */
43f66a6c
JK		 11969 ipw_down(priv);
11970
11971 /* Remove the PRESENT state of the device */
11972 netif_device_detach(dev);
11973
43f66a6c 11974 pci_save_state(pdev);
43f66a6c 11975 pci_disable_device(pdev);
583a4e88 11976 pci_set_power_state(pdev, pci_choose_state(pdev, state));
bf79451e 11977
c3d72b96
DW		 11978 priv->suspend_at = get_seconds();
11979
43f66a6c
JK		 11980 return 0;
11981}
11982
11983static int ipw_pci_resume(struct pci_dev *pdev)
11984{
11985 struct ipw_priv *priv = pci_get_drvdata(pdev);
11986 struct net_device *dev = priv->net_dev;
02e0e5e9 11987 int err;
43f66a6c 11988 u32 val;
bf79451e 11989
43f66a6c
JK		 11990 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11991
ea2b26e0 11992 pci_set_power_state(pdev, PCI_D0);
02e0e5e9
JL		 11993 err = pci_enable_device(pdev);
11994 if (err) {
11995 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
11996 dev->name);
11997 return err;
11998 }
43f66a6c 11999 pci_restore_state(pdev);
ea2b26e0 12000
43f66a6c
JK		 12001 /*
12002 * Suspend/Resume resets the PCI configuration space, so we have to
12003 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
12004 * from interfering with C3 CPU state. pci_restore_state won't help
12005 * here since it only restores the first 64 bytes pci config header.
12006 */
bf79451e
JG		 12007 pci_read_config_dword(pdev, 0x40, &val);
12008 if ((val & 0x0000ff00) != 0)
43f66a6c
JK		 12009 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
12010
12011 /* Set the device back into the PRESENT state; this will also wake
12012 * the queue of needed */
12013 netif_device_attach(dev);
12014
c3d72b96
DW		 12015 priv->suspend_time = get_seconds() - priv->suspend_at;
12016
43f66a6c
JK		 12017 /* Bring the device back up */
12018 queue_work(priv->workqueue, &priv->up);
bf79451e 12019
43f66a6c
JK		 12020 return 0;
12021}
12022#endif
12023
c8c22c94
ZY		 12024static void ipw_pci_shutdown(struct pci_dev *pdev)
12025{
12026 struct ipw_priv *priv = pci_get_drvdata(pdev);
12027
12028 /* Take down the device; powers it off, etc. */
12029 ipw_down(priv);
12030
12031 pci_disable_device(pdev);
12032}
12033
43f66a6c
JK		 12034/* driver initialization stuff */
12035static struct pci_driver ipw_driver = {
12036 .name = DRV_NAME,
12037 .id_table = card_ids,
12038 .probe = ipw_pci_probe,
12039 .remove = __devexit_p(ipw_pci_remove),
12040#ifdef CONFIG_PM
12041 .suspend = ipw_pci_suspend,
12042 .resume = ipw_pci_resume,
12043#endif
c8c22c94 12044 .shutdown = ipw_pci_shutdown,
43f66a6c
JK		 12045};
12046
12047static int __init ipw_init(void)
12048{
12049 int ret;
12050
12051 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
12052 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
12053
29917620 12054 ret = pci_register_driver(&ipw_driver);
43f66a6c
JK		 12055 if (ret) {
12056 IPW_ERROR("Unable to initialize PCI module\n");
12057 return ret;
12058 }
12059
0edd5b44 12060 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
43f66a6c
JK		 12061 if (ret) {
12062 IPW_ERROR("Unable to create driver sysfs file\n");
12063 pci_unregister_driver(&ipw_driver);
12064 return ret;
12065 }
12066
12067 return ret;
12068}
12069
12070static void __exit ipw_exit(void)
12071{
12072 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
12073 pci_unregister_driver(&ipw_driver);
12074}
12075
12076module_param(disable, int, 0444);
12077MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
12078
12079module_param(associate, int, 0444);
5c7f9b73 12080MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
43f66a6c
JK		 12081
12082module_param(auto_create, int, 0444);
12083MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
12084
21f8a73f 12085module_param_named(led, led_support, int, 0444);
61a2d07d 12086MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)");
a613bffd 12087
43f66a6c
JK		 12088module_param(debug, int, 0444);
12089MODULE_PARM_DESC(debug, "debug output mask");
12090
21f8a73f 12091module_param_named(channel, default_channel, int, 0444);
bf79451e 12092MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
43f66a6c 12093
d685b8c2
ZY		 12094#ifdef CONFIG_IPW2200_PROMISCUOUS
12095module_param(rtap_iface, int, 0444);
12096MODULE_PARM_DESC(rtap_iface, "create the rtap interface (1 - create, default 0)");
12097#endif
12098
e43e3c1e 12099#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 12100module_param(qos_enable, int, 0444);
12101MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
12102
12103module_param(qos_burst_enable, int, 0444);
12104MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
12105
12106module_param(qos_no_ack_mask, int, 0444);
12107MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
43f66a6c 12108
b095c381
JK		 12109module_param(burst_duration_CCK, int, 0444);
12110MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
12111
12112module_param(burst_duration_OFDM, int, 0444);
12113MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
e43e3c1e 12114#endif /* CONFIG_IPW2200_QOS */
b095c381
JK		 12115
12116#ifdef CONFIG_IPW2200_MONITOR
21f8a73f 12117module_param_named(mode, network_mode, int, 0444);
43f66a6c
JK		 12118MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
12119#else
21f8a73f 12120module_param_named(mode, network_mode, int, 0444);
43f66a6c
JK		 12121MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
12122#endif
12123
810dabd4
ZY		 12124module_param(bt_coexist, int, 0444);
12125MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
12126
b095c381 12127module_param(hwcrypto, int, 0444);
bde37d03 12128MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
b095c381 12129
f6c5cb7c
JK		 12130module_param(cmdlog, int, 0444);
12131MODULE_PARM_DESC(cmdlog,
12132 "allocate a ring buffer for logging firmware commands");
12133
4bfdb91d
ZY		 12134module_param(roaming, int, 0444);
12135MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
12136
d2b83e12
ZY		 12137module_param(antenna, int, 0444);
12138MODULE_PARM_DESC(antenna, "select antenna 1=Main, 3=Aux, default 0 [both], 2=slow_diversity (choose the one with lower background noise)");
12139
43f66a6c
JK		 12140module_exit(ipw_exit);
12141module_init(ipw_init);
ubuntu-bionic-kernel mirror