]> 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
cfg80211: split wext compatibility to separate header
[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>
262eb9b2 35#include <net/cfg80211-wext.h>
43f66a6c
JK		 36#include "ipw2200.h"
37
ae4af61f
ZY		 38
39#ifndef KBUILD_EXTMOD
40#define VK "k"
41#else
42#define VK
43#endif
44
45#ifdef CONFIG_IPW2200_DEBUG
46#define VD "d"
47#else
48#define VD
49#endif
50
51#ifdef CONFIG_IPW2200_MONITOR
52#define VM "m"
53#else
54#define VM
55#endif
56
57#ifdef CONFIG_IPW2200_PROMISCUOUS
58#define VP "p"
59#else
60#define VP
61#endif
62
459d4087 63#ifdef CONFIG_IPW2200_RADIOTAP
ae4af61f
ZY		 64#define VR "r"
65#else
66#define VR
67#endif
68
69#ifdef CONFIG_IPW2200_QOS
70#define VQ "q"
71#else
72#define VQ
73#endif
74
ee2c4add 75#define IPW2200_VERSION "1.2.2" VK VD VM VP VR VQ
43f66a6c 76#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
171e7b2f 77#define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
43f66a6c
JK		 78#define DRV_VERSION IPW2200_VERSION
79
b095c381
JK		 80#define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
81
43f66a6c
JK		 82MODULE_DESCRIPTION(DRV_DESCRIPTION);
83MODULE_VERSION(DRV_VERSION);
84MODULE_AUTHOR(DRV_COPYRIGHT);
85MODULE_LICENSE("GPL");
873395a9
BH		 86MODULE_FIRMWARE("ipw2200-ibss.fw");
87#ifdef CONFIG_IPW2200_MONITOR
88MODULE_FIRMWARE("ipw2200-sniffer.fw");
89#endif
90MODULE_FIRMWARE("ipw2200-bss.fw");
43f66a6c 91
f6c5cb7c 92static int cmdlog = 0;
43f66a6c 93static int debug = 0;
21f8a73f
RC		 94static int default_channel = 0;
95static int network_mode = 0;
43f66a6c
JK		 96
97static u32 ipw_debug_level;
5c7f9b73 98static int associate;
43f66a6c 99static int auto_create = 1;
c086abae 100static int led_support = 1;
43f66a6c 101static int disable = 0;
810dabd4 102static int bt_coexist = 0;
bde37d03 103static int hwcrypto = 0;
4bfdb91d 104static int roaming = 1;
43f66a6c
JK		 105static const char ipw_modes[] = {
106 'a', 'b', 'g', '?'
107};
d2b83e12 108static int antenna = CFG_SYS_ANTENNA_BOTH;
43f66a6c 109
d685b8c2
ZY		 110#ifdef CONFIG_IPW2200_PROMISCUOUS
111static int rtap_iface = 0; /* def: 0 -- do not create rtap interface */
112#endif
113
a3caa99e
JL		 114static struct ieee80211_rate ipw2200_rates[] = {
115 { .bitrate = 10 },
116 { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
117 { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
118 { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
119 { .bitrate = 60 },
120 { .bitrate = 90 },
121 { .bitrate = 120 },
122 { .bitrate = 180 },
123 { .bitrate = 240 },
124 { .bitrate = 360 },
125 { .bitrate = 480 },
126 { .bitrate = 540 }
127};
128
129#define ipw2200_a_rates (ipw2200_rates + 4)
130#define ipw2200_num_a_rates 8
131#define ipw2200_bg_rates (ipw2200_rates + 0)
132#define ipw2200_num_bg_rates 12
d685b8c2 133
e43e3c1e 134#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 135static int qos_enable = 0;
136static int qos_burst_enable = 0;
137static int qos_no_ack_mask = 0;
138static int burst_duration_CCK = 0;
139static int burst_duration_OFDM = 0;
140
b0a4e7d8 141static struct libipw_qos_parameters def_qos_parameters_OFDM = {
b095c381
JK		 142 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
143 QOS_TX3_CW_MIN_OFDM},
144 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
145 QOS_TX3_CW_MAX_OFDM},
146 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
147 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
148 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
149 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
150};
151
b0a4e7d8 152static struct libipw_qos_parameters def_qos_parameters_CCK = {
b095c381
JK		 153 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
154 QOS_TX3_CW_MIN_CCK},
155 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
156 QOS_TX3_CW_MAX_CCK},
157 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
158 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
159 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
160 QOS_TX3_TXOP_LIMIT_CCK}
161};
162
b0a4e7d8 163static struct libipw_qos_parameters def_parameters_OFDM = {
b095c381
JK		 164 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
165 DEF_TX3_CW_MIN_OFDM},
166 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
167 DEF_TX3_CW_MAX_OFDM},
168 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
169 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
170 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
171 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
172};
173
b0a4e7d8 174static struct libipw_qos_parameters def_parameters_CCK = {
b095c381
JK		 175 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
176 DEF_TX3_CW_MIN_CCK},
177 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
178 DEF_TX3_CW_MAX_CCK},
179 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
180 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
181 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
182 DEF_TX3_TXOP_LIMIT_CCK}
183};
184
185static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
186
187static int from_priority_to_tx_queue[] = {
188 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
189 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
190};
191
192static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
193
b0a4e7d8 194static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
b095c381 195 *qos_param);
b0a4e7d8 196static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
b095c381 197 *qos_param);
e43e3c1e 198#endif /* CONFIG_IPW2200_QOS */
b095c381 199
97a78ca9 200static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
b095c381 201static void ipw_remove_current_network(struct ipw_priv *priv);
43f66a6c 202static void ipw_rx(struct ipw_priv *priv);
bf79451e 203static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
43f66a6c
JK		 204 struct clx2_tx_queue *txq, int qindex);
205static int ipw_queue_reset(struct ipw_priv *priv);
206
207static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
208 int len, int sync);
209
210static void ipw_tx_queue_free(struct ipw_priv *);
211
212static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
213static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
214static void ipw_rx_queue_replenish(void *);
43f66a6c 215static int ipw_up(struct ipw_priv *);
c4028958 216static void ipw_bg_up(struct work_struct *work);
43f66a6c 217static void ipw_down(struct ipw_priv *);
c4028958 218static void ipw_bg_down(struct work_struct *work);
43f66a6c 219static int ipw_config(struct ipw_priv *);
0edd5b44
JG		 220static int init_supported_rates(struct ipw_priv *priv,
221 struct ipw_supported_rates *prates);
b095c381
JK		 222static void ipw_set_hwcrypto_keys(struct ipw_priv *);
223static void ipw_send_wep_keys(struct ipw_priv *, int);
43f66a6c 224
f6c5cb7c
JK		 225static int snprint_line(char *buf, size_t count,
226 const u8 * data, u32 len, u32 ofs)
43f66a6c
JK		 227{
228 int out, i, j, l;
229 char c;
bf79451e 230
43f66a6c
JK		 231 out = snprintf(buf, count, "%08X", ofs);
232
233 for (l = 0, i = 0; i < 2; i++) {
234 out += snprintf(buf + out, count - out, " ");
bf79451e
JG		 235 for (j = 0; j < 8 && l < len; j++, l++)
236 out += snprintf(buf + out, count - out, "%02X ",
43f66a6c
JK		 237 data[(i * 8 + j)]);
238 for (; j < 8; j++)
239 out += snprintf(buf + out, count - out, " ");
240 }
bf79451e 241
43f66a6c
JK		 242 out += snprintf(buf + out, count - out, " ");
243 for (l = 0, i = 0; i < 2; i++) {
244 out += snprintf(buf + out, count - out, " ");
245 for (j = 0; j < 8 && l < len; j++, l++) {
246 c = data[(i * 8 + j)];
247 if (!isascii(c) || !isprint(c))
248 c = '.';
bf79451e 249
43f66a6c
JK		 250 out += snprintf(buf + out, count - out, "%c", c);
251 }
252
253 for (; j < 8; j++)
254 out += snprintf(buf + out, count - out, " ");
255 }
bf79451e 256
f6c5cb7c 257 return out;
43f66a6c
JK		 258}
259
0edd5b44 260static void printk_buf(int level, const u8 * data, u32 len)
43f66a6c
JK		 261{
262 char line[81];
263 u32 ofs = 0;
264 if (!(ipw_debug_level & level))
265 return;
266
267 while (len) {
f6c5cb7c
JK		 268 snprint_line(line, sizeof(line), &data[ofs],
269 min(len, 16U), ofs);
270 printk(KERN_DEBUG "%s\n", line);
43f66a6c
JK		 271 ofs += 16;
272 len -= min(len, 16U);
273 }
274}
275
f6c5cb7c
JK		 276static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
277{
278 size_t out = size;
279 u32 ofs = 0;
280 int total = 0;
281
282 while (size && len) {
283 out = snprint_line(output, size, &data[ofs],
284 min_t(size_t, len, 16U), ofs);
285
286 ofs += 16;
287 output += out;
288 size -= out;
289 len -= min_t(size_t, len, 16U);
290 total += out;
291 }
292 return total;
293}
294
c8fe6679 295/* alias for 32-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 296static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
297#define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
298
c8fe6679 299/* alias for 8-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 300static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
301#define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
302
c8fe6679 303/* 8-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 304static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
305static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
306{
0edd5b44
JG		 307 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
308 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 309 _ipw_write_reg8(a, b, c);
310}
311
c8fe6679 312/* 16-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 313static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
314static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
315{
0edd5b44
JG		 316 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
317 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 318 _ipw_write_reg16(a, b, c);
319}
320
c8fe6679 321/* 32-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
43f66a6c
JK		 322static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
323static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
324{
0edd5b44
JG		 325 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
326 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 327 _ipw_write_reg32(a, b, c);
328}
329
c8fe6679 330/* 8-bit direct write (low 4K) */
1788bcd1
JS		 331static inline void _ipw_write8(struct ipw_priv *ipw, unsigned long ofs,
332 u8 val)
333{
334 writeb(val, ipw->hw_base + ofs);
335}
c8fe6679
ZY		 336
337/* 8-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
fb55d887 338#define ipw_write8(ipw, ofs, val) do { \
1788bcd1
JS		 339 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, \
340 __LINE__, (u32)(ofs), (u32)(val)); \
341 _ipw_write8(ipw, ofs, val); \
342} while (0)
43f66a6c 343
c8fe6679 344/* 16-bit direct write (low 4K) */
1788bcd1
JS		 345static inline void _ipw_write16(struct ipw_priv *ipw, unsigned long ofs,
346 u16 val)
347{
348 writew(val, ipw->hw_base + ofs);
349}
c8fe6679
ZY		 350
351/* 16-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 352#define ipw_write16(ipw, ofs, val) do { \
353 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, \
354 __LINE__, (u32)(ofs), (u32)(val)); \
355 _ipw_write16(ipw, ofs, val); \
356} while (0)
43f66a6c 357
c8fe6679 358/* 32-bit direct write (low 4K) */
1788bcd1
JS		 359static inline void _ipw_write32(struct ipw_priv *ipw, unsigned long ofs,
360 u32 val)
361{
362 writel(val, ipw->hw_base + ofs);
363}
c8fe6679
ZY		 364
365/* 32-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 366#define ipw_write32(ipw, ofs, val) do { \
367 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, \
368 __LINE__, (u32)(ofs), (u32)(val)); \
369 _ipw_write32(ipw, ofs, val); \
370} while (0)
43f66a6c 371
c8fe6679 372/* 8-bit direct read (low 4K) */
1788bcd1 373static inline u8 _ipw_read8(struct ipw_priv *ipw, unsigned long ofs)
0edd5b44 374{
1788bcd1 375 return readb(ipw->hw_base + ofs);
43f66a6c 376}
0edd5b44 377
c8fe6679 378/* alias to 8-bit direct read (low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 379#define ipw_read8(ipw, ofs) ({ \
380 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", __FILE__, __LINE__, \
381 (u32)(ofs)); \
382 _ipw_read8(ipw, ofs); \
383})
43f66a6c 384
c8fe6679 385/* 16-bit direct read (low 4K) */
1788bcd1 386static inline u16 _ipw_read16(struct ipw_priv *ipw, unsigned long ofs)
0edd5b44 387{
1788bcd1 388 return readw(ipw->hw_base + ofs);
43f66a6c 389}
0edd5b44 390
c8fe6679 391/* alias to 16-bit direct read (low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 392#define ipw_read16(ipw, ofs) ({ \
393 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", __FILE__, __LINE__, \
394 (u32)(ofs)); \
395 _ipw_read16(ipw, ofs); \
396})
43f66a6c 397
c8fe6679 398/* 32-bit direct read (low 4K) */
1788bcd1 399static inline u32 _ipw_read32(struct ipw_priv *ipw, unsigned long ofs)
0edd5b44 400{
1788bcd1 401 return readl(ipw->hw_base + ofs);
43f66a6c 402}
0edd5b44 403
c8fe6679 404/* alias to 32-bit direct read (low 4K of SRAM/regs), with debug wrapper */
1788bcd1
JS		 405#define ipw_read32(ipw, ofs) ({ \
406 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", __FILE__, __LINE__, \
407 (u32)(ofs)); \
408 _ipw_read32(ipw, ofs); \
409})
43f66a6c
JK		 410
411static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
c8fe6679 412/* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
1788bcd1
JS		 413#define ipw_read_indirect(a, b, c, d) ({ \
414 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %u bytes\n", __FILE__, \
415 __LINE__, (u32)(b), (u32)(d)); \
416 _ipw_read_indirect(a, b, c, d); \
417})
43f66a6c 418
c8fe6679 419/* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
0edd5b44
JG		 420static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
421 int num);
1788bcd1
JS		 422#define ipw_write_indirect(a, b, c, d) do { \
423 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %u bytes\n", __FILE__, \
424 __LINE__, (u32)(b), (u32)(d)); \
425 _ipw_write_indirect(a, b, c, d); \
426} while (0)
43f66a6c 427
c8fe6679 428/* 32-bit indirect write (above 4K) */
0edd5b44 429static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
43f66a6c 430{
0edd5b44 431 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
b095c381
JK		 432 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
433 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
43f66a6c
JK		 434}
435
c8fe6679 436/* 8-bit indirect write (above 4K) */
43f66a6c
JK		 437static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
438{
2638bc39 439 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
c8fe6679
ZY		 440 u32 dif_len = reg - aligned_addr;
441
43f66a6c 442 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
c8fe6679
ZY		 443 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
444 _ipw_write8(priv, IPW_INDIRECT_DATA + dif_len, value);
43f66a6c
JK		 445}
446
c8fe6679 447/* 16-bit indirect write (above 4K) */
0edd5b44 448static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
43f66a6c 449{
2638bc39 450 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
c8fe6679
ZY		 451 u32 dif_len = (reg - aligned_addr) & (~0x1ul);
452
43f66a6c 453 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
c8fe6679
ZY		 454 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
455 _ipw_write16(priv, IPW_INDIRECT_DATA + dif_len, value);
43f66a6c
JK		 456}
457
c8fe6679 458/* 8-bit indirect read (above 4K) */
43f66a6c
JK		 459static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
460{
461 u32 word;
b095c381 462 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
9fd1ea42 463 IPW_DEBUG_IO(" reg = 0x%8X :\n", reg);
b095c381 464 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
0edd5b44 465 return (word >> ((reg & 0x3) * 8)) & 0xff;
43f66a6c
JK		 466}
467
c8fe6679 468/* 32-bit indirect read (above 4K) */
43f66a6c
JK		 469static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
470{
471 u32 value;
472
473 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
474
b095c381
JK		 475 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
476 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
9fd1ea42 477 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x\n", reg, value);
43f66a6c
JK		 478 return value;
479}
480
c8fe6679
ZY		 481/* General purpose, no alignment requirement, iterative (multi-byte) read, */
482/* for area above 1st 4K of SRAM/reg space */
43f66a6c
JK		 483static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
484 int num)
485{
2638bc39 486 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
43f66a6c 487 u32 dif_len = addr - aligned_addr;
43f66a6c 488 u32 i;
bf79451e 489
43f66a6c
JK		 490 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
491
ea2b26e0
JK		 492 if (num <= 0) {
493 return;
494 }
495
c8fe6679 496 /* Read the first dword (or portion) byte by byte */
43f66a6c 497 if (unlikely(dif_len)) {
b095c381 498 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
43f66a6c 499 /* Start reading at aligned_addr + dif_len */
ea2b26e0 500 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
b095c381 501 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
43f66a6c
JK		 502 aligned_addr += 4;
503 }
504
c8fe6679 505 /* Read all of the middle dwords as dwords, with auto-increment */
b095c381 506 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
ea2b26e0 507 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
b095c381 508 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
bf79451e 509
c8fe6679 510 /* Read the last dword (or portion) byte by byte */
ea2b26e0 511 if (unlikely(num)) {
b095c381 512 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0 513 for (i = 0; num > 0; i++, num--)
b095c381 514 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
ea2b26e0 515 }
43f66a6c
JK		 516}
517
c8fe6679
ZY		 518/* General purpose, no alignment requirement, iterative (multi-byte) write, */
519/* for area above 1st 4K of SRAM/reg space */
0edd5b44 520static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
43f66a6c
JK		 521 int num)
522{
2638bc39 523 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
43f66a6c 524 u32 dif_len = addr - aligned_addr;
43f66a6c 525 u32 i;
bf79451e 526
43f66a6c 527 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
bf79451e 528
ea2b26e0
JK		 529 if (num <= 0) {
530 return;
531 }
532
c8fe6679 533 /* Write the first dword (or portion) byte by byte */
43f66a6c 534 if (unlikely(dif_len)) {
b095c381 535 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
c8fe6679 536 /* Start writing at aligned_addr + dif_len */
ea2b26e0 537 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
b095c381 538 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
43f66a6c
JK		 539 aligned_addr += 4;
540 }
bf79451e 541
c8fe6679 542 /* Write all of the middle dwords as dwords, with auto-increment */
b095c381 543 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
ea2b26e0 544 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
b095c381 545 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
bf79451e 546
c8fe6679 547 /* Write the last dword (or portion) byte by byte */
ea2b26e0 548 if (unlikely(num)) {
b095c381 549 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0 550 for (i = 0; num > 0; i++, num--, buf++)
b095c381 551 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
ea2b26e0 552 }
43f66a6c
JK		 553}
554
c8fe6679
ZY		 555/* General purpose, no alignment requirement, iterative (multi-byte) write, */
556/* for 1st 4K of SRAM/regs space */
bf79451e 557static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
43f66a6c
JK		 558 int num)
559{
560 memcpy_toio((priv->hw_base + addr), buf, num);
561}
562
c8fe6679 563/* Set bit(s) in low 4K of SRAM/regs */
43f66a6c
JK		 564static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
565{
566 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
567}
568
c8fe6679 569/* Clear bit(s) in low 4K of SRAM/regs */
43f66a6c
JK		 570static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
571{
572 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
573}
574
89c318ed 575static inline void __ipw_enable_interrupts(struct ipw_priv *priv)
43f66a6c
JK		 576{
577 if (priv->status & STATUS_INT_ENABLED)
578 return;
579 priv->status |= STATUS_INT_ENABLED;
b095c381 580 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
43f66a6c
JK		 581}
582
89c318ed 583static inline void __ipw_disable_interrupts(struct ipw_priv *priv)
43f66a6c
JK		 584{
585 if (!(priv->status & STATUS_INT_ENABLED))
586 return;
587 priv->status &= ~STATUS_INT_ENABLED;
b095c381 588 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
43f66a6c
JK		 589}
590
89c318ed
ZY		 591static inline void ipw_enable_interrupts(struct ipw_priv *priv)
592{
593 unsigned long flags;
594
595 spin_lock_irqsave(&priv->irq_lock, flags);
596 __ipw_enable_interrupts(priv);
597 spin_unlock_irqrestore(&priv->irq_lock, flags);
598}
599
600static inline void ipw_disable_interrupts(struct ipw_priv *priv)
601{
602 unsigned long flags;
603
604 spin_lock_irqsave(&priv->irq_lock, flags);
605 __ipw_disable_interrupts(priv);
606 spin_unlock_irqrestore(&priv->irq_lock, flags);
607}
608
43f66a6c
JK		 609static char *ipw_error_desc(u32 val)
610{
611 switch (val) {
bf79451e 612 case IPW_FW_ERROR_OK:
43f66a6c 613 return "ERROR_OK";
bf79451e 614 case IPW_FW_ERROR_FAIL:
43f66a6c 615 return "ERROR_FAIL";
bf79451e 616 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
43f66a6c 617 return "MEMORY_UNDERFLOW";
bf79451e 618 case IPW_FW_ERROR_MEMORY_OVERFLOW:
43f66a6c 619 return "MEMORY_OVERFLOW";
bf79451e 620 case IPW_FW_ERROR_BAD_PARAM:
b095c381 621 return "BAD_PARAM";
bf79451e 622 case IPW_FW_ERROR_BAD_CHECKSUM:
b095c381 623 return "BAD_CHECKSUM";
bf79451e 624 case IPW_FW_ERROR_NMI_INTERRUPT:
b095c381 625 return "NMI_INTERRUPT";
bf79451e 626 case IPW_FW_ERROR_BAD_DATABASE:
b095c381 627 return "BAD_DATABASE";
bf79451e 628 case IPW_FW_ERROR_ALLOC_FAIL:
b095c381 629 return "ALLOC_FAIL";
bf79451e 630 case IPW_FW_ERROR_DMA_UNDERRUN:
b095c381 631 return "DMA_UNDERRUN";
bf79451e 632 case IPW_FW_ERROR_DMA_STATUS:
b095c381
JK		 633 return "DMA_STATUS";
634 case IPW_FW_ERROR_DINO_ERROR:
635 return "DINO_ERROR";
636 case IPW_FW_ERROR_EEPROM_ERROR:
637 return "EEPROM_ERROR";
bf79451e 638 case IPW_FW_ERROR_SYSASSERT:
b095c381 639 return "SYSASSERT";
bf79451e 640 case IPW_FW_ERROR_FATAL_ERROR:
b095c381 641 return "FATAL_ERROR";
bf79451e 642 default:
b095c381 643 return "UNKNOWN_ERROR";
43f66a6c
JK		 644 }
645}
646
b39860c6
JK		 647static void ipw_dump_error_log(struct ipw_priv *priv,
648 struct ipw_fw_error *error)
43f66a6c 649{
b39860c6 650 u32 i;
bf79451e 651
b39860c6
JK		 652 if (!error) {
653 IPW_ERROR("Error allocating and capturing error log. "
654 "Nothing to dump.\n");
655 return;
43f66a6c
JK		 656 }
657
b39860c6
JK		 658 IPW_ERROR("Start IPW Error Log Dump:\n");
659 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
660 error->status, error->config);
43f66a6c 661
b39860c6 662 for (i = 0; i < error->elem_len; i++)
0edd5b44 663 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
b39860c6
JK		 664 ipw_error_desc(error->elem[i].desc),
665 error->elem[i].time,
666 error->elem[i].blink1,
667 error->elem[i].blink2,
668 error->elem[i].link1,
669 error->elem[i].link2, error->elem[i].data);
670 for (i = 0; i < error->log_len; i++)
671 IPW_ERROR("%i\t0x%08x\t%i\n",
672 error->log[i].time,
286568ab 673 error->log[i].data, error->log[i].event);
43f66a6c
JK		 674}
675
c848d0af 676static inline int ipw_is_init(struct ipw_priv *priv)
43f66a6c 677{
c848d0af 678 return (priv->status & STATUS_INIT) ? 1 : 0;
43f66a6c
JK		 679}
680
0edd5b44 681static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
43f66a6c
JK		 682{
683 u32 addr, field_info, field_len, field_count, total_len;
684
685 IPW_DEBUG_ORD("ordinal = %i\n", ord);
686
687 if (!priv || !val || !len) {
688 IPW_DEBUG_ORD("Invalid argument\n");
689 return -EINVAL;
690 }
bf79451e 691
43f66a6c
JK		 692 /* verify device ordinal tables have been initialized */
693 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
694 IPW_DEBUG_ORD("Access ordinals before initialization\n");
695 return -EINVAL;
696 }
697
698 switch (IPW_ORD_TABLE_ID_MASK & ord) {
699 case IPW_ORD_TABLE_0_MASK:
700 /*
701 * TABLE 0: Direct access to a table of 32 bit values
702 *
bf79451e 703 * This is a very simple table with the data directly
43f66a6c
JK		 704 * read from the table
705 */
706
707 /* remove the table id from the ordinal */
708 ord &= IPW_ORD_TABLE_VALUE_MASK;
709
710 /* boundary check */
711 if (ord > priv->table0_len) {
712 IPW_DEBUG_ORD("ordinal value (%i) longer then "
713 "max (%i)\n", ord, priv->table0_len);
714 return -EINVAL;
715 }
716
717 /* verify we have enough room to store the value */
718 if (*len < sizeof(u32)) {
719 IPW_DEBUG_ORD("ordinal buffer length too small, "
aaa4d308 720 "need %zd\n", sizeof(u32));
43f66a6c
JK		 721 return -EINVAL;
722 }
723
724 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
0edd5b44 725 ord, priv->table0_addr + (ord << 2));
43f66a6c
JK		 726
727 *len = sizeof(u32);
728 ord <<= 2;
0edd5b44 729 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
43f66a6c
JK		 730 break;
731
732 case IPW_ORD_TABLE_1_MASK:
733 /*
734 * TABLE 1: Indirect access to a table of 32 bit values
bf79451e
JG		 735 *
736 * This is a fairly large table of u32 values each
43f66a6c
JK		 737 * representing starting addr for the data (which is
738 * also a u32)
739 */
740
741 /* remove the table id from the ordinal */
742 ord &= IPW_ORD_TABLE_VALUE_MASK;
bf79451e 743
43f66a6c
JK		 744 /* boundary check */
745 if (ord > priv->table1_len) {
746 IPW_DEBUG_ORD("ordinal value too long\n");
747 return -EINVAL;
748 }
749
750 /* verify we have enough room to store the value */
751 if (*len < sizeof(u32)) {
752 IPW_DEBUG_ORD("ordinal buffer length too small, "
aaa4d308 753 "need %zd\n", sizeof(u32));
43f66a6c
JK		 754 return -EINVAL;
755 }
756
0edd5b44
JG		 757 *((u32 *) val) =
758 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
43f66a6c
JK		 759 *len = sizeof(u32);
760 break;
761
762 case IPW_ORD_TABLE_2_MASK:
763 /*
764 * TABLE 2: Indirect access to a table of variable sized values
765 *
766 * This table consist of six values, each containing
767 * - dword containing the starting offset of the data
768 * - dword containing the lengh in the first 16bits
769 * and the count in the second 16bits
770 */
771
772 /* remove the table id from the ordinal */
773 ord &= IPW_ORD_TABLE_VALUE_MASK;
774
775 /* boundary check */
776 if (ord > priv->table2_len) {
777 IPW_DEBUG_ORD("ordinal value too long\n");
778 return -EINVAL;
779 }
780
781 /* get the address of statistic */
782 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
bf79451e
JG		 783
784 /* get the second DW of statistics ;
43f66a6c 785 * two 16-bit words - first is length, second is count */
0edd5b44
JG		 786 field_info =
787 ipw_read_reg32(priv,
788 priv->table2_addr + (ord << 3) +
789 sizeof(u32));
bf79451e 790
43f66a6c 791 /* get each entry length */
0edd5b44 792 field_len = *((u16 *) & field_info);
bf79451e 793
43f66a6c 794 /* get number of entries */
0edd5b44 795 field_count = *(((u16 *) & field_info) + 1);
bf79451e 796
af901ca1 797 /* abort if not enough memory */
43f66a6c
JK		 798 total_len = field_len * field_count;
799 if (total_len > *len) {
800 *len = total_len;
801 return -EINVAL;
802 }
bf79451e 803
43f66a6c
JK		 804 *len = total_len;
805 if (!total_len)
806 return 0;
807
808 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
bf79451e 809 "field_info = 0x%08x\n",
43f66a6c
JK		 810 addr, total_len, field_info);
811 ipw_read_indirect(priv, addr, val, total_len);
812 break;
813
814 default:
815 IPW_DEBUG_ORD("Invalid ordinal!\n");
816 return -EINVAL;
817
818 }
819
43f66a6c
JK		 820 return 0;
821}
822
823static void ipw_init_ordinals(struct ipw_priv *priv)
824{
825 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
bf79451e 826 priv->table0_len = ipw_read32(priv, priv->table0_addr);
43f66a6c
JK		 827
828 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
829 priv->table0_addr, priv->table0_len);
830
831 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
832 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
833
834 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
835 priv->table1_addr, priv->table1_len);
836
837 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
838 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
0edd5b44 839 priv->table2_len &= 0x0000ffff; /* use first two bytes */
43f66a6c
JK		 840
841 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
842 priv->table2_addr, priv->table2_len);
843
844}
845
a73e22b2 846static u32 ipw_register_toggle(u32 reg)
a613bffd 847{
b095c381
JK		 848 reg &= ~IPW_START_STANDBY;
849 if (reg & IPW_GATE_ODMA)
850 reg &= ~IPW_GATE_ODMA;
851 if (reg & IPW_GATE_IDMA)
852 reg &= ~IPW_GATE_IDMA;
853 if (reg & IPW_GATE_ADMA)
854 reg &= ~IPW_GATE_ADMA;
a613bffd
JK		 855 return reg;
856}
857
858/*
859 * LED behavior:
860 * - On radio ON, turn on any LEDs that require to be on during start
861 * - On initialization, start unassociated blink
862 * - On association, disable unassociated blink
863 * - On disassociation, start unassociated blink
864 * - On radio OFF, turn off any LEDs started during radio on
865 *
866 */
ede6111c
ZY		 867#define LD_TIME_LINK_ON msecs_to_jiffies(300)
868#define LD_TIME_LINK_OFF msecs_to_jiffies(2700)
869#define LD_TIME_ACT_ON msecs_to_jiffies(250)
a613bffd 870
a73e22b2 871static void ipw_led_link_on(struct ipw_priv *priv)
a613bffd
JK		 872{
873 unsigned long flags;
874 u32 led;
875
876 /* If configured to not use LEDs, or nic_type is 1,
877 * then we don't toggle a LINK led */
878 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
879 return;
880
881 spin_lock_irqsave(&priv->lock, flags);
882
883 if (!(priv->status & STATUS_RF_KILL_MASK) &&
884 !(priv->status & STATUS_LED_LINK_ON)) {
885 IPW_DEBUG_LED("Link LED On\n");
b095c381 886 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 887 led |= priv->led_association_on;
888
889 led = ipw_register_toggle(led);
890
891 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 892 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 893
894 priv->status |= STATUS_LED_LINK_ON;
895
896 /* If we aren't associated, schedule turning the LED off */
897 if (!(priv->status & STATUS_ASSOCIATED))
bcb6d916
TH		 898 schedule_delayed_work(&priv->led_link_off,
899 LD_TIME_LINK_ON);
a613bffd
JK		 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))
bcb6d916
TH		 942 schedule_delayed_work(&priv->led_link_on,
943 LD_TIME_LINK_OFF);
a613bffd
JK		 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);
bcb6d916 983 schedule_delayed_work(&priv->led_act_off, LD_TIME_ACT_ON);
a613bffd
JK		 984 } else {
985 /* Reschedule LED off for full time period */
986 cancel_delayed_work(&priv->led_act_off);
bcb6d916 987 schedule_delayed_work(&priv->led_act_off, LD_TIME_ACT_ON);
a613bffd 988 }
b095c381 989}
a613bffd 990
a73e22b2 991#if 0
b095c381
JK		 992void ipw_led_activity_on(struct ipw_priv *priv)
993{
994 unsigned long flags;
995 spin_lock_irqsave(&priv->lock, flags);
996 __ipw_led_activity_on(priv);
a613bffd
JK		 997 spin_unlock_irqrestore(&priv->lock, flags);
998}
a73e22b2 999#endif /* 0 */
a613bffd 1000
a73e22b2 1001static void ipw_led_activity_off(struct ipw_priv *priv)
a613bffd
JK		 1002{
1003 unsigned long flags;
1004 u32 led;
1005
1006 if (priv->config & CFG_NO_LED)
1007 return;
1008
1009 spin_lock_irqsave(&priv->lock, flags);
1010
1011 if (priv->status & STATUS_LED_ACT_ON) {
b095c381 1012 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 1013 led &= priv->led_activity_off;
1014
1015 led = ipw_register_toggle(led);
1016
1017 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 1018 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 1019
1020 IPW_DEBUG_LED("Activity LED Off\n");
1021
1022 priv->status &= ~STATUS_LED_ACT_ON;
1023 }
1024
1025 spin_unlock_irqrestore(&priv->lock, flags);
1026}
1027
c4028958 1028static void ipw_bg_led_activity_off(struct work_struct *work)
c848d0af 1029{
c4028958
DH		 1030 struct ipw_priv *priv =
1031 container_of(work, struct ipw_priv, led_act_off.work);
4644151b 1032 mutex_lock(&priv->mutex);
c4028958 1033 ipw_led_activity_off(priv);
4644151b 1034 mutex_unlock(&priv->mutex);
c848d0af
JK		 1035}
1036
a73e22b2 1037static void ipw_led_band_on(struct ipw_priv *priv)
a613bffd
JK		 1038{
1039 unsigned long flags;
1040 u32 led;
1041
1042 /* Only nic type 1 supports mode LEDs */
c848d0af
JK		 1043 if (priv->config & CFG_NO_LED ||
1044 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
a613bffd
JK		 1045 return;
1046
1047 spin_lock_irqsave(&priv->lock, flags);
1048
b095c381 1049 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 1050 if (priv->assoc_network->mode == IEEE_A) {
1051 led |= priv->led_ofdm_on;
1052 led &= priv->led_association_off;
1053 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
1054 } else if (priv->assoc_network->mode == IEEE_G) {
1055 led |= priv->led_ofdm_on;
1056 led |= priv->led_association_on;
1057 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
1058 } else {
1059 led &= priv->led_ofdm_off;
1060 led |= priv->led_association_on;
1061 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
1062 }
1063
1064 led = ipw_register_toggle(led);
1065
1066 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 1067 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 1068
1069 spin_unlock_irqrestore(&priv->lock, flags);
1070}
1071
a73e22b2 1072static void ipw_led_band_off(struct ipw_priv *priv)
a613bffd
JK		 1073{
1074 unsigned long flags;
1075 u32 led;
1076
1077 /* Only nic type 1 supports mode LEDs */
1078 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
1079 return;
1080
1081 spin_lock_irqsave(&priv->lock, flags);
1082
b095c381 1083 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 1084 led &= priv->led_ofdm_off;
1085 led &= priv->led_association_off;
1086
1087 led = ipw_register_toggle(led);
1088
1089 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 1090 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 1091
1092 spin_unlock_irqrestore(&priv->lock, flags);
1093}
1094
a73e22b2 1095static void ipw_led_radio_on(struct ipw_priv *priv)
a613bffd
JK		 1096{
1097 ipw_led_link_on(priv);
1098}
1099
a73e22b2 1100static void ipw_led_radio_off(struct ipw_priv *priv)
a613bffd
JK		 1101{
1102 ipw_led_activity_off(priv);
1103 ipw_led_link_off(priv);
1104}
1105
a73e22b2 1106static void ipw_led_link_up(struct ipw_priv *priv)
a613bffd
JK		 1107{
1108 /* Set the Link Led on for all nic types */
1109 ipw_led_link_on(priv);
1110}
1111
a73e22b2 1112static void ipw_led_link_down(struct ipw_priv *priv)
a613bffd
JK		 1113{
1114 ipw_led_activity_off(priv);
1115 ipw_led_link_off(priv);
1116
1117 if (priv->status & STATUS_RF_KILL_MASK)
1118 ipw_led_radio_off(priv);
1119}
1120
a73e22b2 1121static void ipw_led_init(struct ipw_priv *priv)
a613bffd
JK		 1122{
1123 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1124
1125 /* Set the default PINs for the link and activity leds */
b095c381
JK		 1126 priv->led_activity_on = IPW_ACTIVITY_LED;
1127 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
a613bffd 1128
b095c381
JK		 1129 priv->led_association_on = IPW_ASSOCIATED_LED;
1130 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
a613bffd
JK		 1131
1132 /* Set the default PINs for the OFDM leds */
b095c381
JK		 1133 priv->led_ofdm_on = IPW_OFDM_LED;
1134 priv->led_ofdm_off = ~(IPW_OFDM_LED);
a613bffd
JK		 1135
1136 switch (priv->nic_type) {
1137 case EEPROM_NIC_TYPE_1:
1138 /* In this NIC type, the LEDs are reversed.... */
b095c381
JK		 1139 priv->led_activity_on = IPW_ASSOCIATED_LED;
1140 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1141 priv->led_association_on = IPW_ACTIVITY_LED;
1142 priv->led_association_off = ~(IPW_ACTIVITY_LED);
a613bffd
JK		 1143
1144 if (!(priv->config & CFG_NO_LED))
1145 ipw_led_band_on(priv);
1146
1147 /* And we don't blink link LEDs for this nic, so
1148 * just return here */
1149 return;
1150
1151 case EEPROM_NIC_TYPE_3:
1152 case EEPROM_NIC_TYPE_2:
1153 case EEPROM_NIC_TYPE_4:
1154 case EEPROM_NIC_TYPE_0:
1155 break;
1156
1157 default:
1158 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1159 priv->nic_type);
1160 priv->nic_type = EEPROM_NIC_TYPE_0;
1161 break;
1162 }
1163
1164 if (!(priv->config & CFG_NO_LED)) {
1165 if (priv->status & STATUS_ASSOCIATED)
1166 ipw_led_link_on(priv);
1167 else
1168 ipw_led_link_off(priv);
1169 }
1170}
1171
a73e22b2 1172static void ipw_led_shutdown(struct ipw_priv *priv)
a613bffd 1173{
a613bffd
JK		 1174 ipw_led_activity_off(priv);
1175 ipw_led_link_off(priv);
1176 ipw_led_band_off(priv);
afbf30a2
JK		 1177 cancel_delayed_work(&priv->led_link_on);
1178 cancel_delayed_work(&priv->led_link_off);
1179 cancel_delayed_work(&priv->led_act_off);
a613bffd
JK		 1180}
1181
43f66a6c
JK		 1182/*
1183 * The following adds a new attribute to the sysfs representation
1184 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
25985edc 1185 * used for controlling the debug level.
bf79451e 1186 *
43f66a6c
JK		 1187 * See the level definitions in ipw for details.
1188 */
1189static ssize_t show_debug_level(struct device_driver *d, char *buf)
1190{
1191 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1192}
a613bffd
JK		 1193
1194static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1195 size_t count)
43f66a6c
JK		 1196{
1197 char *p = (char *)buf;
1198 u32 val;
1199
1200 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1201 p++;
1202 if (p[0] == 'x' || p[0] == 'X')
1203 p++;
1204 val = simple_strtoul(p, &p, 16);
1205 } else
1206 val = simple_strtoul(p, &p, 10);
bf79451e
JG		 1207 if (p == buf)
1208 printk(KERN_INFO DRV_NAME
43f66a6c
JK		 1209 ": %s is not in hex or decimal form.\n", buf);
1210 else
1211 ipw_debug_level = val;
1212
1213 return strnlen(buf, count);
1214}
1215
bf79451e 1216static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
43f66a6c
JK		 1217 show_debug_level, store_debug_level);
1218
b39860c6 1219static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
43f66a6c 1220{
c8fe6679 1221 /* length = 1st dword in log */
b39860c6 1222 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
43f66a6c 1223}
0edd5b44 1224
b39860c6
JK		 1225static void ipw_capture_event_log(struct ipw_priv *priv,
1226 u32 log_len, struct ipw_event *log)
43f66a6c 1227{
b39860c6 1228 u32 base;
0edd5b44 1229
b39860c6
JK		 1230 if (log_len) {
1231 base = ipw_read32(priv, IPW_EVENT_LOG);
1232 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1233 (u8 *) log, sizeof(*log) * log_len);
1234 }
1235}
43f66a6c 1236
b39860c6 1237static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
43f66a6c 1238{
b39860c6
JK		 1239 struct ipw_fw_error *error;
1240 u32 log_len = ipw_get_event_log_len(priv);
1241 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1242 u32 elem_len = ipw_read_reg32(priv, base);
43f66a6c 1243
b39860c6
JK		 1244 error = kmalloc(sizeof(*error) +
1245 sizeof(*error->elem) * elem_len +
1246 sizeof(*error->log) * log_len, GFP_ATOMIC);
1247 if (!error) {
1248 IPW_ERROR("Memory allocation for firmware error log "
1249 "failed.\n");
1250 return NULL;
43f66a6c 1251 }
f6c5cb7c 1252 error->jiffies = jiffies;
b39860c6
JK		 1253 error->status = priv->status;
1254 error->config = priv->config;
1255 error->elem_len = elem_len;
1256 error->log_len = log_len;
1257 error->elem = (struct ipw_error_elem *)error->payload;
3b26b110 1258 error->log = (struct ipw_event *)(error->elem + elem_len);
b39860c6
JK		 1259
1260 ipw_capture_event_log(priv, log_len, error->log);
bf79451e 1261
b39860c6
JK		 1262 if (elem_len)
1263 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1264 sizeof(*error->elem) * elem_len);
1265
1266 return error;
43f66a6c 1267}
0edd5b44 1268
b39860c6
JK		 1269static ssize_t show_event_log(struct device *d,
1270 struct device_attribute *attr, char *buf)
43f66a6c 1271{
b39860c6
JK		 1272 struct ipw_priv *priv = dev_get_drvdata(d);
1273 u32 log_len = ipw_get_event_log_len(priv);
412e9e78
RC		 1274 u32 log_size;
1275 struct ipw_event *log;
b39860c6 1276 u32 len = 0, i;
43f66a6c 1277
412e9e78
RC		 1278 /* not using min() because of its strict type checking */
1279 log_size = PAGE_SIZE / sizeof(*log) > log_len ?
1280 sizeof(*log) * log_len : PAGE_SIZE;
1281 log = kzalloc(log_size, GFP_KERNEL);
1282 if (!log) {
1283 IPW_ERROR("Unable to allocate memory for log\n");
1284 return 0;
1285 }
1286 log_len = log_size / sizeof(*log);
b39860c6 1287 ipw_capture_event_log(priv, log_len, log);
43f66a6c 1288
b39860c6
JK		 1289 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1290 for (i = 0; i < log_len; i++)
1291 len += snprintf(buf + len, PAGE_SIZE - len,
1292 "\n%08X%08X%08X",
1293 log[i].time, log[i].event, log[i].data);
1294 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
412e9e78 1295 kfree(log);
b39860c6 1296 return len;
43f66a6c 1297}
0edd5b44 1298
b39860c6 1299static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
43f66a6c 1300
b39860c6
JK		 1301static ssize_t show_error(struct device *d,
1302 struct device_attribute *attr, char *buf)
43f66a6c 1303{
b39860c6
JK		 1304 struct ipw_priv *priv = dev_get_drvdata(d);
1305 u32 len = 0, i;
1306 if (!priv->error)
1307 return 0;
1308 len += snprintf(buf + len, PAGE_SIZE - len,
f6c5cb7c
JK		 1309 "%08lX%08X%08X%08X",
1310 priv->error->jiffies,
b39860c6
JK		 1311 priv->error->status,
1312 priv->error->config, priv->error->elem_len);
1313 for (i = 0; i < priv->error->elem_len; i++)
1314 len += snprintf(buf + len, PAGE_SIZE - len,
1315 "\n%08X%08X%08X%08X%08X%08X%08X",
1316 priv->error->elem[i].time,
1317 priv->error->elem[i].desc,
1318 priv->error->elem[i].blink1,
1319 priv->error->elem[i].blink2,
1320 priv->error->elem[i].link1,
1321 priv->error->elem[i].link2,
1322 priv->error->elem[i].data);
1323
1324 len += snprintf(buf + len, PAGE_SIZE - len,
1325 "\n%08X", priv->error->log_len);
1326 for (i = 0; i < priv->error->log_len; i++)
1327 len += snprintf(buf + len, PAGE_SIZE - len,
1328 "\n%08X%08X%08X",
1329 priv->error->log[i].time,
1330 priv->error->log[i].event,
1331 priv->error->log[i].data);
1332 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1333 return len;
1334}
1335
1336static ssize_t clear_error(struct device *d,
1337 struct device_attribute *attr,
1338 const char *buf, size_t count)
1339{
1340 struct ipw_priv *priv = dev_get_drvdata(d);
8f760780
JJ		 1341
1342 kfree(priv->error);
1343 priv->error = NULL;
b39860c6
JK		 1344 return count;
1345}
43f66a6c 1346
b39860c6 1347static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
43f66a6c 1348
f6c5cb7c
JK		 1349static ssize_t show_cmd_log(struct device *d,
1350 struct device_attribute *attr, char *buf)
1351{
1352 struct ipw_priv *priv = dev_get_drvdata(d);
1353 u32 len = 0, i;
1354 if (!priv->cmdlog)
1355 return 0;
1356 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1357 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1358 i = (i + 1) % priv->cmdlog_len) {
1359 len +=
1360 snprintf(buf + len, PAGE_SIZE - len,
1361 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1362 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1363 priv->cmdlog[i].cmd.len);
1364 len +=
1365 snprintk_buf(buf + len, PAGE_SIZE - len,
1366 (u8 *) priv->cmdlog[i].cmd.param,
1367 priv->cmdlog[i].cmd.len);
1368 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1369 }
1370 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1371 return len;
43f66a6c 1372}
0edd5b44 1373
f6c5cb7c 1374static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
43f66a6c 1375
d685b8c2
ZY		 1376#ifdef CONFIG_IPW2200_PROMISCUOUS
1377static void ipw_prom_free(struct ipw_priv *priv);
1378static int ipw_prom_alloc(struct ipw_priv *priv);
1379static ssize_t store_rtap_iface(struct device *d,
1380 struct device_attribute *attr,
1381 const char *buf, size_t count)
1382{
1383 struct ipw_priv *priv = dev_get_drvdata(d);
1384 int rc = 0;
1385
1386 if (count < 1)
1387 return -EINVAL;
1388
1389 switch (buf[0]) {
1390 case '0':
1391 if (!rtap_iface)
1392 return count;
1393
1394 if (netif_running(priv->prom_net_dev)) {
1395 IPW_WARNING("Interface is up. Cannot unregister.\n");
1396 return count;
1397 }
1398
1399 ipw_prom_free(priv);
1400 rtap_iface = 0;
1401 break;
1402
1403 case '1':
1404 if (rtap_iface)
1405 return count;
1406
1407 rc = ipw_prom_alloc(priv);
1408 if (!rc)
1409 rtap_iface = 1;
1410 break;
1411
1412 default:
1413 return -EINVAL;
1414 }
1415
1416 if (rc) {
1417 IPW_ERROR("Failed to register promiscuous network "
1418 "device (error %d).\n", rc);
1419 }
1420
1421 return count;
1422}
1423
1424static ssize_t show_rtap_iface(struct device *d,
1425 struct device_attribute *attr,
1426 char *buf)
1427{
1428 struct ipw_priv *priv = dev_get_drvdata(d);
1429 if (rtap_iface)
1430 return sprintf(buf, "%s", priv->prom_net_dev->name);
1431 else {
1432 buf[0] = '-';
1433 buf[1] = '1';
1434 buf[2] = '\0';
1435 return 3;
1436 }
1437}
1438
1439static DEVICE_ATTR(rtap_iface, S_IWUSR | S_IRUSR, show_rtap_iface,
1440 store_rtap_iface);
1441
1442static ssize_t store_rtap_filter(struct device *d,
1443 struct device_attribute *attr,
1444 const char *buf, size_t count)
1445{
1446 struct ipw_priv *priv = dev_get_drvdata(d);
1447
1448 if (!priv->prom_priv) {
1449 IPW_ERROR("Attempting to set filter without "
1450 "rtap_iface enabled.\n");
1451 return -EPERM;
1452 }
1453
1454 priv->prom_priv->filter = simple_strtol(buf, NULL, 0);
1455
1456 IPW_DEBUG_INFO("Setting rtap filter to " BIT_FMT16 "\n",
1457 BIT_ARG16(priv->prom_priv->filter));
1458
1459 return count;
1460}
1461
1462static ssize_t show_rtap_filter(struct device *d,
1463 struct device_attribute *attr,
1464 char *buf)
1465{
1466 struct ipw_priv *priv = dev_get_drvdata(d);
1467 return sprintf(buf, "0x%04X",
1468 priv->prom_priv ? priv->prom_priv->filter : 0);
1469}
1470
1471static DEVICE_ATTR(rtap_filter, S_IWUSR | S_IRUSR, show_rtap_filter,
1472 store_rtap_filter);
1473#endif
1474
a613bffd
JK		 1475static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1476 char *buf)
43f66a6c 1477{
a613bffd
JK		 1478 struct ipw_priv *priv = dev_get_drvdata(d);
1479 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1480}
1481
1482static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1483 const char *buf, size_t count)
1484{
1485 struct ipw_priv *priv = dev_get_drvdata(d);
1486 struct net_device *dev = priv->net_dev;
1487 char buffer[] = "00000000";
1488 unsigned long len =
1489 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1490 unsigned long val;
1491 char *p = buffer;
1492
1493 IPW_DEBUG_INFO("enter\n");
1494
1495 strncpy(buffer, buf, len);
1496 buffer[len] = 0;
1497
1498 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1499 p++;
1500 if (p[0] == 'x' || p[0] == 'X')
1501 p++;
1502 val = simple_strtoul(p, &p, 16);
1503 } else
1504 val = simple_strtoul(p, &p, 10);
1505 if (p == buffer) {
1506 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1507 } else {
1508 priv->ieee->scan_age = val;
1509 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1510 }
1511
1512 IPW_DEBUG_INFO("exit\n");
1513 return len;
1514}
1515
1516static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1517
1518static ssize_t show_led(struct device *d, struct device_attribute *attr,
1519 char *buf)
1520{
1521 struct ipw_priv *priv = dev_get_drvdata(d);
1522 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1523}
1524
1525static ssize_t store_led(struct device *d, struct device_attribute *attr,
1526 const char *buf, size_t count)
1527{
1528 struct ipw_priv *priv = dev_get_drvdata(d);
1529
1530 IPW_DEBUG_INFO("enter\n");
1531
1532 if (count == 0)
1533 return 0;
1534
1535 if (*buf == 0) {
1536 IPW_DEBUG_LED("Disabling LED control.\n");
1537 priv->config |= CFG_NO_LED;
1538 ipw_led_shutdown(priv);
1539 } else {
1540 IPW_DEBUG_LED("Enabling LED control.\n");
1541 priv->config &= ~CFG_NO_LED;
1542 ipw_led_init(priv);
1543 }
1544
1545 IPW_DEBUG_INFO("exit\n");
1546 return count;
1547}
1548
1549static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1550
ad3fee56 1551static ssize_t show_status(struct device *d,
0edd5b44 1552 struct device_attribute *attr, char *buf)
43f66a6c 1553{
928841b1 1554 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1555 return sprintf(buf, "0x%08x\n", (int)p->status);
1556}
0edd5b44 1557
43f66a6c
JK		 1558static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1559
ad3fee56
AM		 1560static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1561 char *buf)
43f66a6c 1562{
928841b1 1563 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1564 return sprintf(buf, "0x%08x\n", (int)p->config);
1565}
0edd5b44 1566
43f66a6c
JK		 1567static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1568
ad3fee56 1569static ssize_t show_nic_type(struct device *d,
0edd5b44 1570 struct device_attribute *attr, char *buf)
43f66a6c 1571{
928841b1 1572 struct ipw_priv *priv = dev_get_drvdata(d);
a613bffd 1573 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
43f66a6c 1574}
0edd5b44 1575
43f66a6c
JK		 1576static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1577
ad3fee56 1578static ssize_t show_ucode_version(struct device *d,
0edd5b44 1579 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1580{
1581 u32 len = sizeof(u32), tmp = 0;
928841b1 1582 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c 1583
0edd5b44 1584 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
43f66a6c
JK		 1585 return 0;
1586
1587 return sprintf(buf, "0x%08x\n", tmp);
1588}
0edd5b44
JG		 1589
1590static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
43f66a6c 1591
ad3fee56
AM		 1592static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1593 char *buf)
43f66a6c
JK		 1594{
1595 u32 len = sizeof(u32), tmp = 0;
928841b1 1596 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c 1597
0edd5b44 1598 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
43f66a6c
JK		 1599 return 0;
1600
1601 return sprintf(buf, "0x%08x\n", tmp);
1602}
0edd5b44
JG		 1603
1604static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
43f66a6c
JK		 1605
1606/*
1607 * Add a device attribute to view/control the delay between eeprom
1608 * operations.
1609 */
ad3fee56 1610static ssize_t show_eeprom_delay(struct device *d,
0edd5b44 1611 struct device_attribute *attr, char *buf)
43f66a6c 1612{
928841b1
GKH		 1613 struct ipw_priv *p = dev_get_drvdata(d);
1614 int n = p->eeprom_delay;
43f66a6c
JK		 1615 return sprintf(buf, "%i\n", n);
1616}
ad3fee56 1617static ssize_t store_eeprom_delay(struct device *d,
0edd5b44
JG		 1618 struct device_attribute *attr,
1619 const char *buf, size_t count)
43f66a6c 1620{
928841b1 1621 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1622 sscanf(buf, "%i", &p->eeprom_delay);
1623 return strnlen(buf, count);
1624}
0edd5b44
JG		 1625
1626static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1627 show_eeprom_delay, store_eeprom_delay);
43f66a6c 1628
ad3fee56 1629static ssize_t show_command_event_reg(struct device *d,
0edd5b44 1630 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1631{
1632 u32 reg = 0;
928841b1 1633 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c 1634
b095c381 1635 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
43f66a6c
JK		 1636 return sprintf(buf, "0x%08x\n", reg);
1637}
ad3fee56 1638static ssize_t store_command_event_reg(struct device *d,
0edd5b44
JG		 1639 struct device_attribute *attr,
1640 const char *buf, size_t count)
43f66a6c
JK		 1641{
1642 u32 reg;
928841b1 1643 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1644
1645 sscanf(buf, "%x", &reg);
b095c381 1646 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
43f66a6c
JK		 1647 return strnlen(buf, count);
1648}
0edd5b44
JG		 1649
1650static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1651 show_command_event_reg, store_command_event_reg);
43f66a6c 1652
ad3fee56 1653static ssize_t show_mem_gpio_reg(struct device *d,
0edd5b44 1654 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1655{
1656 u32 reg = 0;
928841b1 1657 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1658
1659 reg = ipw_read_reg32(p, 0x301100);
1660 return sprintf(buf, "0x%08x\n", reg);
1661}
ad3fee56 1662static ssize_t store_mem_gpio_reg(struct device *d,
0edd5b44
JG		 1663 struct device_attribute *attr,
1664 const char *buf, size_t count)
43f66a6c
JK		 1665{
1666 u32 reg;
928841b1 1667 struct ipw_priv *p = dev_get_drvdata(d);
43f66a6c
JK		 1668
1669 sscanf(buf, "%x", &reg);
1670 ipw_write_reg32(p, 0x301100, reg);
1671 return strnlen(buf, count);
1672}
0edd5b44
JG		 1673
1674static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1675 show_mem_gpio_reg, store_mem_gpio_reg);
43f66a6c 1676
ad3fee56 1677static ssize_t show_indirect_dword(struct device *d,
0edd5b44 1678 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1679{
1680 u32 reg = 0;
928841b1 1681 struct ipw_priv *priv = dev_get_drvdata(d);
afbf30a2 1682
bf79451e 1683 if (priv->status & STATUS_INDIRECT_DWORD)
43f66a6c 1684 reg = ipw_read_reg32(priv, priv->indirect_dword);
bf79451e 1685 else
43f66a6c 1686 reg = 0;
bf79451e 1687
43f66a6c
JK		 1688 return sprintf(buf, "0x%08x\n", reg);
1689}
ad3fee56 1690static ssize_t store_indirect_dword(struct device *d,
0edd5b44
JG		 1691 struct device_attribute *attr,
1692 const char *buf, size_t count)
43f66a6c 1693{
928841b1 1694 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c
JK		 1695
1696 sscanf(buf, "%x", &priv->indirect_dword);
1697 priv->status |= STATUS_INDIRECT_DWORD;
1698 return strnlen(buf, count);
1699}
0edd5b44
JG		 1700
1701static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1702 show_indirect_dword, store_indirect_dword);
43f66a6c 1703
ad3fee56 1704static ssize_t show_indirect_byte(struct device *d,
0edd5b44 1705 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1706{
1707 u8 reg = 0;
928841b1 1708 struct ipw_priv *priv = dev_get_drvdata(d);
afbf30a2 1709
bf79451e 1710 if (priv->status & STATUS_INDIRECT_BYTE)
43f66a6c 1711 reg = ipw_read_reg8(priv, priv->indirect_byte);
bf79451e 1712 else
43f66a6c
JK		 1713 reg = 0;
1714
1715 return sprintf(buf, "0x%02x\n", reg);
1716}
ad3fee56 1717static ssize_t store_indirect_byte(struct device *d,
0edd5b44
JG		 1718 struct device_attribute *attr,
1719 const char *buf, size_t count)
43f66a6c 1720{
928841b1 1721 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c
JK		 1722
1723 sscanf(buf, "%x", &priv->indirect_byte);
1724 priv->status |= STATUS_INDIRECT_BYTE;
1725 return strnlen(buf, count);
1726}
0edd5b44
JG		 1727
1728static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
43f66a6c
JK		 1729 show_indirect_byte, store_indirect_byte);
1730
ad3fee56 1731static ssize_t show_direct_dword(struct device *d,
0edd5b44 1732 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1733{
1734 u32 reg = 0;
928841b1 1735 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c 1736
bf79451e 1737 if (priv->status & STATUS_DIRECT_DWORD)
43f66a6c 1738 reg = ipw_read32(priv, priv->direct_dword);
bf79451e 1739 else
43f66a6c
JK		 1740 reg = 0;
1741
1742 return sprintf(buf, "0x%08x\n", reg);
1743}
ad3fee56 1744static ssize_t store_direct_dword(struct device *d,
0edd5b44
JG		 1745 struct device_attribute *attr,
1746 const char *buf, size_t count)
43f66a6c 1747{
928841b1 1748 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c
JK		 1749
1750 sscanf(buf, "%x", &priv->direct_dword);
1751 priv->status |= STATUS_DIRECT_DWORD;
1752 return strnlen(buf, count);
1753}
43f66a6c 1754
0edd5b44
JG		 1755static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1756 show_direct_dword, store_direct_dword);
43f66a6c 1757
858119e1 1758static int rf_kill_active(struct ipw_priv *priv)
43f66a6c 1759{
25f94aea 1760 if (0 == (ipw_read32(priv, 0x30) & 0x10000)) {
43f66a6c 1761 priv->status |= STATUS_RF_KILL_HW;
25f94aea
MG		 1762 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1763 } else {
43f66a6c 1764 priv->status &= ~STATUS_RF_KILL_HW;
25f94aea
MG		 1765 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1766 }
43f66a6c
JK		 1767
1768 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1769}
1770
ad3fee56 1771static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
0edd5b44 1772 char *buf)
43f66a6c
JK		 1773{
1774 /* 0 - RF kill not enabled
bf79451e 1775 1 - SW based RF kill active (sysfs)
43f66a6c
JK		 1776 2 - HW based RF kill active
1777 3 - Both HW and SW baed RF kill active */
928841b1 1778 struct ipw_priv *priv = dev_get_drvdata(d);
43f66a6c 1779 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
0edd5b44 1780 (rf_kill_active(priv) ? 0x2 : 0x0);
43f66a6c
JK		 1781 return sprintf(buf, "%i\n", val);
1782}
1783
1784static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1785{
bf79451e 1786 if ((disable_radio ? 1 : 0) ==
ea2b26e0 1787 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
0edd5b44 1788 return 0;
43f66a6c
JK		 1789
1790 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1791 disable_radio ? "OFF" : "ON");
1792
1793 if (disable_radio) {
1794 priv->status |= STATUS_RF_KILL_SW;
1795
bcb6d916
TH		 1796 cancel_delayed_work(&priv->request_scan);
1797 cancel_delayed_work(&priv->request_direct_scan);
1798 cancel_delayed_work(&priv->request_passive_scan);
1799 cancel_delayed_work(&priv->scan_event);
1800 schedule_work(&priv->down);
43f66a6c
JK		 1801 } else {
1802 priv->status &= ~STATUS_RF_KILL_SW;
1803 if (rf_kill_active(priv)) {
1804 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1805 "disabled by HW switch\n");
1806 /* Make sure the RF_KILL check timer is running */
1807 cancel_delayed_work(&priv->rf_kill);
bcb6d916
TH		 1808 schedule_delayed_work(&priv->rf_kill,
1809 round_jiffies_relative(2 * HZ));
bf79451e 1810 } else
bcb6d916 1811 schedule_work(&priv->up);
43f66a6c
JK		 1812 }
1813
1814 return 1;
1815}
1816
0edd5b44
JG		 1817static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1818 const char *buf, size_t count)
43f66a6c 1819{
928841b1 1820 struct ipw_priv *priv = dev_get_drvdata(d);
bf79451e 1821
43f66a6c
JK		 1822 ipw_radio_kill_sw(priv, buf[0] == '1');
1823
1824 return count;
1825}
0edd5b44
JG		 1826
1827static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
43f66a6c 1828
b095c381
JK		 1829static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1830 char *buf)
1831{
928841b1 1832 struct ipw_priv *priv = dev_get_drvdata(d);
b095c381
JK		 1833 int pos = 0, len = 0;
1834 if (priv->config & CFG_SPEED_SCAN) {
1835 while (priv->speed_scan[pos] != 0)
1836 len += sprintf(&buf[len], "%d ",
1837 priv->speed_scan[pos++]);
1838 return len + sprintf(&buf[len], "\n");
1839 }
1840
1841 return sprintf(buf, "0\n");
1842}
1843
1844static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1845 const char *buf, size_t count)
1846{
928841b1 1847 struct ipw_priv *priv = dev_get_drvdata(d);
b095c381
JK		 1848 int channel, pos = 0;
1849 const char *p = buf;
1850
1851 /* list of space separated channels to scan, optionally ending with 0 */
1852 while ((channel = simple_strtol(p, NULL, 0))) {
1853 if (pos == MAX_SPEED_SCAN - 1) {
1854 priv->speed_scan[pos] = 0;
1855 break;
1856 }
1857
b0a4e7d8 1858 if (libipw_is_valid_channel(priv->ieee, channel))
b095c381
JK		 1859 priv->speed_scan[pos++] = channel;
1860 else
1861 IPW_WARNING("Skipping invalid channel request: %d\n",
1862 channel);
1863 p = strchr(p, ' ');
1864 if (!p)
1865 break;
1866 while (*p == ' ' || *p == '\t')
1867 p++;
1868 }
1869
1870 if (pos == 0)
1871 priv->config &= ~CFG_SPEED_SCAN;
1872 else {
1873 priv->speed_scan_pos = 0;
1874 priv->config |= CFG_SPEED_SCAN;
1875 }
1876
1877 return count;
1878}
1879
1880static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1881 store_speed_scan);
1882
1883static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1884 char *buf)
1885{
928841b1 1886 struct ipw_priv *priv = dev_get_drvdata(d);
b095c381
JK		 1887 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1888}
1889
1890static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1891 const char *buf, size_t count)
1892{
928841b1 1893 struct ipw_priv *priv = dev_get_drvdata(d);
b095c381
JK		 1894 if (buf[0] == '1')
1895 priv->config |= CFG_NET_STATS;
1896 else
1897 priv->config &= ~CFG_NET_STATS;
1898
1899 return count;
1900}
1901
afbf30a2
JK		 1902static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1903 show_net_stats, store_net_stats);
b095c381 1904
375dd244
ZY		 1905static ssize_t show_channels(struct device *d,
1906 struct device_attribute *attr,
1907 char *buf)
1908{
1909 struct ipw_priv *priv = dev_get_drvdata(d);
b0a4e7d8 1910 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
375dd244
ZY		 1911 int len = 0, i;
1912
1913 len = sprintf(&buf[len],
1914 "Displaying %d channels in 2.4Ghz band "
1915 "(802.11bg):\n", geo->bg_channels);
1916
1917 for (i = 0; i < geo->bg_channels; i++) {
1918 len += sprintf(&buf[len], "%d: BSS%s%s, %s, Band %s.\n",
1919 geo->bg[i].channel,
b0a4e7d8 1920 geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT ?
375dd244 1921 " (radar spectrum)" : "",
b0a4e7d8
JL		 1922 ((geo->bg[i].flags & LIBIPW_CH_NO_IBSS) ||
1923 (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT))
375dd244 1924 ? "" : ", IBSS",
b0a4e7d8 1925 geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
375dd244 1926 "passive only" : "active/passive",
b0a4e7d8 1927 geo->bg[i].flags & LIBIPW_CH_B_ONLY ?
375dd244
ZY		 1928 "B" : "B/G");
1929 }
1930
1931 len += sprintf(&buf[len],
1932 "Displaying %d channels in 5.2Ghz band "
1933 "(802.11a):\n", geo->a_channels);
1934 for (i = 0; i < geo->a_channels; i++) {
1935 len += sprintf(&buf[len], "%d: BSS%s%s, %s.\n",
1936 geo->a[i].channel,
b0a4e7d8 1937 geo->a[i].flags & LIBIPW_CH_RADAR_DETECT ?
375dd244 1938 " (radar spectrum)" : "",
b0a4e7d8
JL		 1939 ((geo->a[i].flags & LIBIPW_CH_NO_IBSS) ||
1940 (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT))
375dd244 1941 ? "" : ", IBSS",
b0a4e7d8 1942 geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
375dd244
ZY		 1943 "passive only" : "active/passive");
1944 }
1945
1946 return len;
1947}
1948
1949static DEVICE_ATTR(channels, S_IRUSR, show_channels, NULL);
1950
ea2b26e0
JK		 1951static void notify_wx_assoc_event(struct ipw_priv *priv)
1952{
1953 union iwreq_data wrqu;
1954 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1955 if (priv->status & STATUS_ASSOCIATED)
1956 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1957 else
1958 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1959 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1960}
1961
43f66a6c
JK		 1962static void ipw_irq_tasklet(struct ipw_priv *priv)
1963{
1964 u32 inta, inta_mask, handled = 0;
1965 unsigned long flags;
1966 int rc = 0;
1967
89c318ed 1968 spin_lock_irqsave(&priv->irq_lock, flags);
43f66a6c 1969
b095c381
JK		 1970 inta = ipw_read32(priv, IPW_INTA_RW);
1971 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
3c4a8cc4
IZ		 1972
1973 if (inta == 0xFFFFFFFF) {
1974 /* Hardware disappeared */
1975 IPW_WARNING("TASKLET INTA == 0xFFFFFFFF\n");
1976 /* Only handle the cached INTA values */
1977 inta = 0;
1978 }
b095c381 1979 inta &= (IPW_INTA_MASK_ALL & inta_mask);
43f66a6c
JK		 1980
1981 /* Add any cached INTA values that need to be handled */
1982 inta |= priv->isr_inta;
1983
89c318ed
ZY		 1984 spin_unlock_irqrestore(&priv->irq_lock, flags);
1985
1986 spin_lock_irqsave(&priv->lock, flags);
1987
43f66a6c 1988 /* handle all the justifications for the interrupt */
b095c381 1989 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
43f66a6c 1990 ipw_rx(priv);
b095c381 1991 handled |= IPW_INTA_BIT_RX_TRANSFER;
43f66a6c
JK		 1992 }
1993
b095c381 1994 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
43f66a6c 1995 IPW_DEBUG_HC("Command completed.\n");
0edd5b44 1996 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
43f66a6c
JK		 1997 priv->status &= ~STATUS_HCMD_ACTIVE;
1998 wake_up_interruptible(&priv->wait_command_queue);
b095c381 1999 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
43f66a6c
JK		 2000 }
2001
b095c381 2002 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
43f66a6c 2003 IPW_DEBUG_TX("TX_QUEUE_1\n");
0edd5b44 2004 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
b095c381 2005 handled |= IPW_INTA_BIT_TX_QUEUE_1;
43f66a6c
JK		 2006 }
2007
b095c381 2008 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
43f66a6c 2009 IPW_DEBUG_TX("TX_QUEUE_2\n");
0edd5b44 2010 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
b095c381 2011 handled |= IPW_INTA_BIT_TX_QUEUE_2;
43f66a6c
JK		 2012 }
2013
b095c381 2014 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
43f66a6c 2015 IPW_DEBUG_TX("TX_QUEUE_3\n");
0edd5b44 2016 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
b095c381 2017 handled |= IPW_INTA_BIT_TX_QUEUE_3;
43f66a6c
JK		 2018 }
2019
b095c381 2020 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
43f66a6c 2021 IPW_DEBUG_TX("TX_QUEUE_4\n");
0edd5b44 2022 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
b095c381 2023 handled |= IPW_INTA_BIT_TX_QUEUE_4;
43f66a6c
JK		 2024 }
2025
b095c381 2026 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
43f66a6c 2027 IPW_WARNING("STATUS_CHANGE\n");
b095c381 2028 handled |= IPW_INTA_BIT_STATUS_CHANGE;
43f66a6c
JK		 2029 }
2030
b095c381 2031 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
43f66a6c 2032 IPW_WARNING("TX_PERIOD_EXPIRED\n");
b095c381 2033 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
43f66a6c
JK		 2034 }
2035
b095c381 2036 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
43f66a6c 2037 IPW_WARNING("HOST_CMD_DONE\n");
b095c381 2038 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
43f66a6c
JK		 2039 }
2040
b095c381 2041 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
43f66a6c 2042 IPW_WARNING("FW_INITIALIZATION_DONE\n");
b095c381 2043 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
43f66a6c
JK		 2044 }
2045
b095c381 2046 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
43f66a6c 2047 IPW_WARNING("PHY_OFF_DONE\n");
b095c381 2048 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
43f66a6c
JK		 2049 }
2050
b095c381 2051 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
43f66a6c
JK		 2052 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
2053 priv->status |= STATUS_RF_KILL_HW;
25f94aea 2054 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
43f66a6c 2055 wake_up_interruptible(&priv->wait_command_queue);
ea2b26e0 2056 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
43f66a6c 2057 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 2058 cancel_delayed_work(&priv->request_direct_scan);
2059 cancel_delayed_work(&priv->request_passive_scan);
0b531676 2060 cancel_delayed_work(&priv->scan_event);
a613bffd 2061 schedule_work(&priv->link_down);
bcb6d916 2062 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
b095c381 2063 handled |= IPW_INTA_BIT_RF_KILL_DONE;
43f66a6c 2064 }
bf79451e 2065
b095c381 2066 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1d1b09eb 2067 IPW_WARNING("Firmware error detected. Restarting.\n");
b39860c6 2068 if (priv->error) {
1d1b09eb 2069 IPW_DEBUG_FW("Sysfs 'error' log already exists.\n");
b39860c6
JK		 2070 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
2071 struct ipw_fw_error *error =
2072 ipw_alloc_error_log(priv);
2073 ipw_dump_error_log(priv, error);
8f760780 2074 kfree(error);
b39860c6 2075 }
b39860c6
JK		 2076 } else {
2077 priv->error = ipw_alloc_error_log(priv);
2078 if (priv->error)
1d1b09eb 2079 IPW_DEBUG_FW("Sysfs 'error' log captured.\n");
b39860c6 2080 else
1d1b09eb
ZY		 2081 IPW_DEBUG_FW("Error allocating sysfs 'error' "
2082 "log.\n");
b39860c6
JK		 2083 if (ipw_debug_level & IPW_DL_FW_ERRORS)
2084 ipw_dump_error_log(priv, priv->error);
b39860c6
JK		 2085 }
2086
b095c381
JK		 2087 /* XXX: If hardware encryption is for WPA/WPA2,
2088 * we have to notify the supplicant. */
2089 if (priv->ieee->sec.encrypt) {
2090 priv->status &= ~STATUS_ASSOCIATED;
2091 notify_wx_assoc_event(priv);
2092 }
2093
2094 /* Keep the restart process from trying to send host
2095 * commands by clearing the INIT status bit */
2096 priv->status &= ~STATUS_INIT;
afbf30a2
JK		 2097
2098 /* Cancel currently queued command. */
2099 priv->status &= ~STATUS_HCMD_ACTIVE;
2100 wake_up_interruptible(&priv->wait_command_queue);
2101
bcb6d916 2102 schedule_work(&priv->adapter_restart);
b095c381 2103 handled |= IPW_INTA_BIT_FATAL_ERROR;
43f66a6c
JK		 2104 }
2105
b095c381 2106 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
43f66a6c 2107 IPW_ERROR("Parity error\n");
b095c381 2108 handled |= IPW_INTA_BIT_PARITY_ERROR;
43f66a6c
JK		 2109 }
2110
2111 if (handled != inta) {
0edd5b44 2112 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
43f66a6c
JK		 2113 }
2114
89c318ed
ZY		 2115 spin_unlock_irqrestore(&priv->lock, flags);
2116
43f66a6c
JK		 2117 /* enable all interrupts */
2118 ipw_enable_interrupts(priv);
43f66a6c 2119}
bf79451e 2120
43f66a6c
JK		 2121#define IPW_CMD(x) case IPW_CMD_ ## x : return #x
2122static char *get_cmd_string(u8 cmd)
2123{
2124 switch (cmd) {
2125 IPW_CMD(HOST_COMPLETE);
bf79451e
JG		 2126 IPW_CMD(POWER_DOWN);
2127 IPW_CMD(SYSTEM_CONFIG);
2128 IPW_CMD(MULTICAST_ADDRESS);
2129 IPW_CMD(SSID);
2130 IPW_CMD(ADAPTER_ADDRESS);
2131 IPW_CMD(PORT_TYPE);
2132 IPW_CMD(RTS_THRESHOLD);
2133 IPW_CMD(FRAG_THRESHOLD);
2134 IPW_CMD(POWER_MODE);
2135 IPW_CMD(WEP_KEY);
2136 IPW_CMD(TGI_TX_KEY);
2137 IPW_CMD(SCAN_REQUEST);
2138 IPW_CMD(SCAN_REQUEST_EXT);
2139 IPW_CMD(ASSOCIATE);
2140 IPW_CMD(SUPPORTED_RATES);
2141 IPW_CMD(SCAN_ABORT);
2142 IPW_CMD(TX_FLUSH);
2143 IPW_CMD(QOS_PARAMETERS);
2144 IPW_CMD(DINO_CONFIG);
2145 IPW_CMD(RSN_CAPABILITIES);
2146 IPW_CMD(RX_KEY);
2147 IPW_CMD(CARD_DISABLE);
2148 IPW_CMD(SEED_NUMBER);
2149 IPW_CMD(TX_POWER);
2150 IPW_CMD(COUNTRY_INFO);
2151 IPW_CMD(AIRONET_INFO);
2152 IPW_CMD(AP_TX_POWER);
2153 IPW_CMD(CCKM_INFO);
2154 IPW_CMD(CCX_VER_INFO);
2155 IPW_CMD(SET_CALIBRATION);
2156 IPW_CMD(SENSITIVITY_CALIB);
2157 IPW_CMD(RETRY_LIMIT);
2158 IPW_CMD(IPW_PRE_POWER_DOWN);
2159 IPW_CMD(VAP_BEACON_TEMPLATE);
2160 IPW_CMD(VAP_DTIM_PERIOD);
2161 IPW_CMD(EXT_SUPPORTED_RATES);
2162 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
2163 IPW_CMD(VAP_QUIET_INTERVALS);
2164 IPW_CMD(VAP_CHANNEL_SWITCH);
2165 IPW_CMD(VAP_MANDATORY_CHANNELS);
2166 IPW_CMD(VAP_CELL_PWR_LIMIT);
2167 IPW_CMD(VAP_CF_PARAM_SET);
2168 IPW_CMD(VAP_SET_BEACONING_STATE);
2169 IPW_CMD(MEASUREMENT);
2170 IPW_CMD(POWER_CAPABILITY);
2171 IPW_CMD(SUPPORTED_CHANNELS);
2172 IPW_CMD(TPC_REPORT);
2173 IPW_CMD(WME_INFO);
2174 IPW_CMD(PRODUCTION_COMMAND);
2175 default:
43f66a6c
JK		 2176 return "UNKNOWN";
2177 }
2178}
43f66a6c
JK		 2179
2180#define HOST_COMPLETE_TIMEOUT HZ
0a7bcf26
ZY		 2181
2182static int __ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
43f66a6c
JK		 2183{
2184 int rc = 0;
a613bffd 2185 unsigned long flags;
43f66a6c 2186
a613bffd 2187 spin_lock_irqsave(&priv->lock, flags);
43f66a6c 2188 if (priv->status & STATUS_HCMD_ACTIVE) {
9ddf84f6
JK		 2189 IPW_ERROR("Failed to send %s: Already sending a command.\n",
2190 get_cmd_string(cmd->cmd));
a613bffd 2191 spin_unlock_irqrestore(&priv->lock, flags);
9ddf84f6 2192 return -EAGAIN;
43f66a6c
JK		 2193 }
2194
2195 priv->status |= STATUS_HCMD_ACTIVE;
bf79451e 2196
f6c5cb7c
JK		 2197 if (priv->cmdlog) {
2198 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
2199 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
2200 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
2201 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
2202 cmd->len);
2203 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
2204 }
2205
b095c381
JK		 2206 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
2207 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
2208 priv->status);
f516dbcd
ZY		 2209
2210#ifndef DEBUG_CMD_WEP_KEY
2211 if (cmd->cmd == IPW_CMD_WEP_KEY)
2212 IPW_DEBUG_HC("WEP_KEY command masked out for secure.\n");
2213 else
2214#endif
2215 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
2216
0a7bcf26 2217 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
a613bffd
JK		 2218 if (rc) {
2219 priv->status &= ~STATUS_HCMD_ACTIVE;
9ddf84f6
JK		 2220 IPW_ERROR("Failed to send %s: Reason %d\n",
2221 get_cmd_string(cmd->cmd), rc);
a613bffd 2222 spin_unlock_irqrestore(&priv->lock, flags);
f6c5cb7c 2223 goto exit;
a613bffd
JK		 2224 }
2225 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 2226
0edd5b44
JG		 2227 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
2228 !(priv->
2229 status & STATUS_HCMD_ACTIVE),
2230 HOST_COMPLETE_TIMEOUT);
43f66a6c 2231 if (rc == 0) {
a613bffd
JK		 2232 spin_lock_irqsave(&priv->lock, flags);
2233 if (priv->status & STATUS_HCMD_ACTIVE) {
9ddf84f6
JK		 2234 IPW_ERROR("Failed to send %s: Command timed out.\n",
2235 get_cmd_string(cmd->cmd));
a613bffd
JK		 2236 priv->status &= ~STATUS_HCMD_ACTIVE;
2237 spin_unlock_irqrestore(&priv->lock, flags);
f6c5cb7c
JK		 2238 rc = -EIO;
2239 goto exit;
a613bffd
JK		 2240 }
2241 spin_unlock_irqrestore(&priv->lock, flags);
3b9990cb
JK		 2242 } else
2243 rc = 0;
a613bffd 2244
b095c381 2245 if (priv->status & STATUS_RF_KILL_HW) {
9ddf84f6
JK		 2246 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
2247 get_cmd_string(cmd->cmd));
f6c5cb7c
JK		 2248 rc = -EIO;
2249 goto exit;
43f66a6c
JK		 2250 }
2251
2638bc39 2252 exit:
f6c5cb7c
JK		 2253 if (priv->cmdlog) {
2254 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
2255 priv->cmdlog_pos %= priv->cmdlog_len;
2256 }
2257 return rc;
43f66a6c
JK		 2258}
2259
0a7bcf26
ZY		 2260static int ipw_send_cmd_simple(struct ipw_priv *priv, u8 command)
2261{
2262 struct host_cmd cmd = {
2263 .cmd = command,
2264 };
2265
2266 return __ipw_send_cmd(priv, &cmd);
2267}
2268
2269static int ipw_send_cmd_pdu(struct ipw_priv *priv, u8 command, u8 len,
2270 void *data)
43f66a6c
JK		 2271{
2272 struct host_cmd cmd = {
0a7bcf26
ZY		 2273 .cmd = command,
2274 .len = len,
2275 .param = data,
43f66a6c
JK		 2276 };
2277
0a7bcf26
ZY		 2278 return __ipw_send_cmd(priv, &cmd);
2279}
2280
2281static int ipw_send_host_complete(struct ipw_priv *priv)
2282{
43f66a6c
JK		 2283 if (!priv) {
2284 IPW_ERROR("Invalid args\n");
2285 return -1;
2286 }
2287
0a7bcf26 2288 return ipw_send_cmd_simple(priv, IPW_CMD_HOST_COMPLETE);
43f66a6c
JK		 2289}
2290
d685b8c2 2291static int ipw_send_system_config(struct ipw_priv *priv)
43f66a6c 2292{
d685b8c2
ZY		 2293 return ipw_send_cmd_pdu(priv, IPW_CMD_SYSTEM_CONFIG,
2294 sizeof(priv->sys_config),
2295 &priv->sys_config);
43f66a6c
JK		 2296}
2297
0edd5b44 2298static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
43f66a6c 2299{
43f66a6c
JK		 2300 if (!priv || !ssid) {
2301 IPW_ERROR("Invalid args\n");
2302 return -1;
2303 }
2304
0a7bcf26 2305 return ipw_send_cmd_pdu(priv, IPW_CMD_SSID, min(len, IW_ESSID_MAX_SIZE),
2638bc39 2306 ssid);
43f66a6c
JK		 2307}
2308
0edd5b44 2309static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
43f66a6c 2310{
43f66a6c
JK		 2311 if (!priv || !mac) {
2312 IPW_ERROR("Invalid args\n");
2313 return -1;
2314 }
2315
e174961c
JB		 2316 IPW_DEBUG_INFO("%s: Setting MAC to %pM\n",
2317 priv->net_dev->name, mac);
43f66a6c 2318
2638bc39 2319 return ipw_send_cmd_pdu(priv, IPW_CMD_ADAPTER_ADDRESS, ETH_ALEN, mac);
43f66a6c
JK		 2320}
2321
2322static void ipw_adapter_restart(void *adapter)
2323{
2324 struct ipw_priv *priv = adapter;
2325
2326 if (priv->status & STATUS_RF_KILL_MASK)
2327 return;
2328
2329 ipw_down(priv);
b095c381
JK		 2330
2331 if (priv->assoc_network &&
2332 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2333 ipw_remove_current_network(priv);
2334
43f66a6c
JK		 2335 if (ipw_up(priv)) {
2336 IPW_ERROR("Failed to up device\n");
2337 return;
2338 }
2339}
2340
c4028958 2341static void ipw_bg_adapter_restart(struct work_struct *work)
c848d0af 2342{
c4028958
DH		 2343 struct ipw_priv *priv =
2344 container_of(work, struct ipw_priv, adapter_restart);
4644151b 2345 mutex_lock(&priv->mutex);
c4028958 2346 ipw_adapter_restart(priv);
4644151b 2347 mutex_unlock(&priv->mutex);
c848d0af
JK		 2348}
2349
e65054b6
ZY		 2350static void ipw_abort_scan(struct ipw_priv *priv);
2351
2352#define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
43f66a6c
JK		 2353
2354static void ipw_scan_check(void *data)
2355{
2356 struct ipw_priv *priv = data;
e65054b6
ZY		 2357
2358 if (priv->status & STATUS_SCAN_ABORTING) {
43f66a6c 2359 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
c7b6a674
ZY		 2360 "adapter after (%dms).\n",
2361 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
bcb6d916 2362 schedule_work(&priv->adapter_restart);
e65054b6
ZY		 2363 } else if (priv->status & STATUS_SCANNING) {
2364 IPW_DEBUG_SCAN("Scan completion watchdog aborting scan "
2365 "after (%dms).\n",
2366 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2367 ipw_abort_scan(priv);
bcb6d916 2368 schedule_delayed_work(&priv->scan_check, HZ);
43f66a6c
JK		 2369 }
2370}
2371
c4028958 2372static void ipw_bg_scan_check(struct work_struct *work)
c848d0af 2373{
c4028958
DH		 2374 struct ipw_priv *priv =
2375 container_of(work, struct ipw_priv, scan_check.work);
4644151b 2376 mutex_lock(&priv->mutex);
c4028958 2377 ipw_scan_check(priv);
4644151b 2378 mutex_unlock(&priv->mutex);
c848d0af
JK		 2379}
2380
43f66a6c
JK		 2381static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2382 struct ipw_scan_request_ext *request)
2383{
0a7bcf26 2384 return ipw_send_cmd_pdu(priv, IPW_CMD_SCAN_REQUEST_EXT,
2638bc39 2385 sizeof(*request), request);
43f66a6c
JK		 2386}
2387
2388static int ipw_send_scan_abort(struct ipw_priv *priv)
2389{
43f66a6c
JK		 2390 if (!priv) {
2391 IPW_ERROR("Invalid args\n");
2392 return -1;
2393 }
2394
0a7bcf26 2395 return ipw_send_cmd_simple(priv, IPW_CMD_SCAN_ABORT);
43f66a6c
JK		 2396}
2397
2398static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2399{
0a7bcf26 2400 struct ipw_sensitivity_calib calib = {
851ca268 2401 .beacon_rssi_raw = cpu_to_le16(sens),
43f66a6c 2402 };
0a7bcf26
ZY		 2403
2404 return ipw_send_cmd_pdu(priv, IPW_CMD_SENSITIVITY_CALIB, sizeof(calib),
2638bc39 2405 &calib);
43f66a6c
JK		 2406}
2407
2408static int ipw_send_associate(struct ipw_priv *priv,
2409 struct ipw_associate *associate)
2410{
0a7bcf26
ZY		 2411 if (!priv || !associate) {
2412 IPW_ERROR("Invalid args\n");
2413 return -1;
2414 }
2415
5b5e807f
AV		 2416 return ipw_send_cmd_pdu(priv, IPW_CMD_ASSOCIATE, sizeof(*associate),
2417 associate);
43f66a6c
JK		 2418}
2419
2420static int ipw_send_supported_rates(struct ipw_priv *priv,
2421 struct ipw_supported_rates *rates)
2422{
43f66a6c
JK		 2423 if (!priv || !rates) {
2424 IPW_ERROR("Invalid args\n");
2425 return -1;
2426 }
2427
0a7bcf26 2428 return ipw_send_cmd_pdu(priv, IPW_CMD_SUPPORTED_RATES, sizeof(*rates),
2638bc39 2429 rates);
43f66a6c
JK		 2430}
2431
2432static int ipw_set_random_seed(struct ipw_priv *priv)
2433{
0a7bcf26 2434 u32 val;
43f66a6c
JK		 2435
2436 if (!priv) {
2437 IPW_ERROR("Invalid args\n");
2438 return -1;
2439 }
2440
0a7bcf26 2441 get_random_bytes(&val, sizeof(val));
43f66a6c 2442
0a7bcf26 2443 return ipw_send_cmd_pdu(priv, IPW_CMD_SEED_NUMBER, sizeof(val), &val);
43f66a6c
JK		 2444}
2445
43f66a6c
JK		 2446static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2447{
e62e1ee0 2448 __le32 v = cpu_to_le32(phy_off);
43f66a6c
JK		 2449 if (!priv) {
2450 IPW_ERROR("Invalid args\n");
2451 return -1;
2452 }
2453
e62e1ee0 2454 return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(v), &v);
43f66a6c 2455}
43f66a6c 2456
0edd5b44 2457static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
43f66a6c 2458{
43f66a6c
JK		 2459 if (!priv || !power) {
2460 IPW_ERROR("Invalid args\n");
2461 return -1;
2462 }
2463
2638bc39 2464 return ipw_send_cmd_pdu(priv, IPW_CMD_TX_POWER, sizeof(*power), power);
43f66a6c
JK		 2465}
2466
6de9f7f2
ZY		 2467static int ipw_set_tx_power(struct ipw_priv *priv)
2468{
b0a4e7d8 2469 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
6de9f7f2
ZY		 2470 struct ipw_tx_power tx_power;
2471 s8 max_power;
2472 int i;
2473
2474 memset(&tx_power, 0, sizeof(tx_power));
2475
2476 /* configure device for 'G' band */
2477 tx_power.ieee_mode = IPW_G_MODE;
2478 tx_power.num_channels = geo->bg_channels;
2479 for (i = 0; i < geo->bg_channels; i++) {
2480 max_power = geo->bg[i].max_power;
2481 tx_power.channels_tx_power[i].channel_number =
2482 geo->bg[i].channel;
2483 tx_power.channels_tx_power[i].tx_power = max_power ?
2484 min(max_power, priv->tx_power) : priv->tx_power;
43f66a6c 2485 }
6de9f7f2
ZY		 2486 if (ipw_send_tx_power(priv, &tx_power))
2487 return -EIO;
2488
2489 /* configure device to also handle 'B' band */
2490 tx_power.ieee_mode = IPW_B_MODE;
2491 if (ipw_send_tx_power(priv, &tx_power))
2492 return -EIO;
bf79451e 2493
6de9f7f2
ZY		 2494 /* configure device to also handle 'A' band */
2495 if (priv->ieee->abg_true) {
2496 tx_power.ieee_mode = IPW_A_MODE;
2497 tx_power.num_channels = geo->a_channels;
2498 for (i = 0; i < tx_power.num_channels; i++) {
2499 max_power = geo->a[i].max_power;
2500 tx_power.channels_tx_power[i].channel_number =
2501 geo->a[i].channel;
2502 tx_power.channels_tx_power[i].tx_power = max_power ?
2503 min(max_power, priv->tx_power) : priv->tx_power;
2504 }
2505 if (ipw_send_tx_power(priv, &tx_power))
2506 return -EIO;
2507 }
43f66a6c
JK		 2508 return 0;
2509}
2510
2511static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2512{
2513 struct ipw_rts_threshold rts_threshold = {
851ca268 2514 .rts_threshold = cpu_to_le16(rts),
43f66a6c 2515 };
43f66a6c
JK		 2516
2517 if (!priv) {
2518 IPW_ERROR("Invalid args\n");
2519 return -1;
2520 }
2521
0a7bcf26
ZY		 2522 return ipw_send_cmd_pdu(priv, IPW_CMD_RTS_THRESHOLD,
2523 sizeof(rts_threshold), &rts_threshold);
43f66a6c
JK		 2524}
2525
2526static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2527{
2528 struct ipw_frag_threshold frag_threshold = {
851ca268 2529 .frag_threshold = cpu_to_le16(frag),
43f66a6c 2530 };
43f66a6c
JK		 2531
2532 if (!priv) {
2533 IPW_ERROR("Invalid args\n");
2534 return -1;
2535 }
2536
0a7bcf26
ZY		 2537 return ipw_send_cmd_pdu(priv, IPW_CMD_FRAG_THRESHOLD,
2538 sizeof(frag_threshold), &frag_threshold);
43f66a6c
JK		 2539}
2540
2541static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2542{
e62e1ee0 2543 __le32 param;
43f66a6c
JK		 2544
2545 if (!priv) {
2546 IPW_ERROR("Invalid args\n");
2547 return -1;
2548 }
bf79451e 2549
43f66a6c
JK		 2550 /* If on battery, set to 3, if AC set to CAM, else user
2551 * level */
2552 switch (mode) {
2553 case IPW_POWER_BATTERY:
e62e1ee0 2554 param = cpu_to_le32(IPW_POWER_INDEX_3);
43f66a6c
JK		 2555 break;
2556 case IPW_POWER_AC:
e62e1ee0 2557 param = cpu_to_le32(IPW_POWER_MODE_CAM);
43f66a6c
JK		 2558 break;
2559 default:
e62e1ee0 2560 param = cpu_to_le32(mode);
43f66a6c
JK		 2561 break;
2562 }
2563
0a7bcf26 2564 return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
2638bc39 2565 &param);
43f66a6c
JK		 2566}
2567
afbf30a2
JK		 2568static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2569{
2570 struct ipw_retry_limit retry_limit = {
2571 .short_retry_limit = slimit,
2572 .long_retry_limit = llimit
2573 };
afbf30a2
JK		 2574
2575 if (!priv) {
2576 IPW_ERROR("Invalid args\n");
2577 return -1;
2578 }
2579
0a7bcf26 2580 return ipw_send_cmd_pdu(priv, IPW_CMD_RETRY_LIMIT, sizeof(retry_limit),
2638bc39 2581 &retry_limit);
afbf30a2
JK		 2582}
2583
43f66a6c
JK		 2584/*
2585 * The IPW device contains a Microwire compatible EEPROM that stores
2586 * various data like the MAC address. Usually the firmware has exclusive
2587 * access to the eeprom, but during device initialization (before the
2588 * device driver has sent the HostComplete command to the firmware) the
2589 * device driver has read access to the EEPROM by way of indirect addressing
2590 * through a couple of memory mapped registers.
2591 *
2592 * The following is a simplified implementation for pulling data out of the
2593 * the eeprom, along with some helper functions to find information in
2594 * the per device private data's copy of the eeprom.
2595 *
2596 * NOTE: To better understand how these functions work (i.e what is a chip
2597 * select and why do have to keep driving the eeprom clock?), read
2598 * just about any data sheet for a Microwire compatible EEPROM.
2599 */
2600
2601/* write a 32 bit value into the indirect accessor register */
2602static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2603{
2604 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
bf79451e 2605
43f66a6c
JK		 2606 /* the eeprom requires some time to complete the operation */
2607 udelay(p->eeprom_delay);
43f66a6c
JK		 2608}
2609
2610/* perform a chip select operation */
858119e1 2611static void eeprom_cs(struct ipw_priv *priv)
43f66a6c 2612{
0edd5b44
JG		 2613 eeprom_write_reg(priv, 0);
2614 eeprom_write_reg(priv, EEPROM_BIT_CS);
2615 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2616 eeprom_write_reg(priv, EEPROM_BIT_CS);
43f66a6c
JK		 2617}
2618
2619/* perform a chip select operation */
858119e1 2620static void eeprom_disable_cs(struct ipw_priv *priv)
43f66a6c 2621{
0edd5b44
JG		 2622 eeprom_write_reg(priv, EEPROM_BIT_CS);
2623 eeprom_write_reg(priv, 0);
2624 eeprom_write_reg(priv, EEPROM_BIT_SK);
43f66a6c
JK		 2625}
2626
2627/* push a single bit down to the eeprom */
0edd5b44 2628static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
43f66a6c 2629{
0edd5b44
JG		 2630 int d = (bit ? EEPROM_BIT_DI : 0);
2631 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2632 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
43f66a6c
JK		 2633}
2634
2635/* push an opcode followed by an address down to the eeprom */
0edd5b44 2636static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
43f66a6c
JK		 2637{
2638 int i;
2639
2640 eeprom_cs(priv);
0edd5b44
JG		 2641 eeprom_write_bit(priv, 1);
2642 eeprom_write_bit(priv, op & 2);
2643 eeprom_write_bit(priv, op & 1);
2644 for (i = 7; i >= 0; i--) {
2645 eeprom_write_bit(priv, addr & (1 << i));
43f66a6c
JK		 2646 }
2647}
2648
2649/* pull 16 bits off the eeprom, one bit at a time */
0edd5b44 2650static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
43f66a6c
JK		 2651{
2652 int i;
0edd5b44 2653 u16 r = 0;
bf79451e 2654
43f66a6c 2655 /* Send READ Opcode */
0edd5b44 2656 eeprom_op(priv, EEPROM_CMD_READ, addr);
43f66a6c
JK		 2657
2658 /* Send dummy bit */
0edd5b44 2659 eeprom_write_reg(priv, EEPROM_BIT_CS);
43f66a6c
JK		 2660
2661 /* Read the byte off the eeprom one bit at a time */
0edd5b44 2662 for (i = 0; i < 16; i++) {
43f66a6c 2663 u32 data = 0;
0edd5b44
JG		 2664 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2665 eeprom_write_reg(priv, EEPROM_BIT_CS);
2666 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2667 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
43f66a6c 2668 }
bf79451e 2669
43f66a6c 2670 /* Send another dummy bit */
0edd5b44 2671 eeprom_write_reg(priv, 0);
43f66a6c 2672 eeprom_disable_cs(priv);
bf79451e 2673
43f66a6c
JK		 2674 return r;
2675}
2676
2677/* helper function for pulling the mac address out of the private */
2678/* data's copy of the eeprom data */
0edd5b44 2679static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
43f66a6c 2680{
afbf30a2 2681 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
43f66a6c
JK		 2682}
2683
2684/*
2685 * Either the device driver (i.e. the host) or the firmware can
2686 * load eeprom data into the designated region in SRAM. If neither
2687 * happens then the FW will shutdown with a fatal error.
2688 *
2689 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2690 * bit needs region of shared SRAM needs to be non-zero.
2691 */
2692static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2693{
2694 int i;
e62e1ee0 2695 __le16 *eeprom = (__le16 *) priv->eeprom;
bf79451e 2696
43f66a6c
JK		 2697 IPW_DEBUG_TRACE(">>\n");
2698
2699 /* read entire contents of eeprom into private buffer */
0edd5b44 2700 for (i = 0; i < 128; i++)
e62e1ee0 2701 eeprom[i] = cpu_to_le16(eeprom_read_u16(priv, (u8) i));
43f66a6c 2702
bf79451e
JG		 2703 /*
2704 If the data looks correct, then copy it to our private
43f66a6c 2705 copy. Otherwise let the firmware know to perform the operation
c7b6a674 2706 on its own.
0edd5b44 2707 */
386093ef 2708 if (priv->eeprom[EEPROM_VERSION] != 0) {
43f66a6c
JK		 2709 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2710
2711 /* write the eeprom data to sram */
b095c381 2712 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
0edd5b44 2713 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
43f66a6c
JK		 2714
2715 /* Do not load eeprom data on fatal error or suspend */
2716 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2717 } else {
2718 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2719
2720 /* Load eeprom data on fatal error or suspend */
2721 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2722 }
2723
2724 IPW_DEBUG_TRACE("<<\n");
2725}
2726
858119e1 2727static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
43f66a6c
JK		 2728{
2729 count >>= 2;
0edd5b44
JG		 2730 if (!count)
2731 return;
b095c381 2732 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
bf79451e 2733 while (count--)
b095c381 2734 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
43f66a6c
JK		 2735}
2736
2737static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2738{
b095c381 2739 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
bf79451e 2740 CB_NUMBER_OF_ELEMENTS_SMALL *
43f66a6c
JK		 2741 sizeof(struct command_block));
2742}
2743
2744static int ipw_fw_dma_enable(struct ipw_priv *priv)
0edd5b44 2745{ /* start dma engine but no transfers yet */
43f66a6c 2746
9fd1ea42 2747 IPW_DEBUG_FW(">> :\n");
bf79451e 2748
43f66a6c
JK		 2749 /* Start the dma */
2750 ipw_fw_dma_reset_command_blocks(priv);
bf79451e 2751
43f66a6c 2752 /* Write CB base address */
b095c381 2753 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
43f66a6c 2754
9fd1ea42 2755 IPW_DEBUG_FW("<< :\n");
43f66a6c
JK		 2756 return 0;
2757}
2758
2759static void ipw_fw_dma_abort(struct ipw_priv *priv)
2760{
2761 u32 control = 0;
2762
2763 IPW_DEBUG_FW(">> :\n");
bf79451e 2764
67fd6b45 2765 /* set the Stop and Abort bit */
43f66a6c 2766 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
b095c381 2767 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
43f66a6c 2768 priv->sram_desc.last_cb_index = 0;
bf79451e 2769
9fd1ea42 2770 IPW_DEBUG_FW("<<\n");
43f66a6c
JK		 2771}
2772
0edd5b44
JG		 2773static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2774 struct command_block *cb)
43f66a6c 2775{
0edd5b44 2776 u32 address =
b095c381 2777 IPW_SHARED_SRAM_DMA_CONTROL +
0edd5b44 2778 (sizeof(struct command_block) * index);
43f66a6c
JK		 2779 IPW_DEBUG_FW(">> :\n");
2780
0edd5b44
JG		 2781 ipw_write_indirect(priv, address, (u8 *) cb,
2782 (int)sizeof(struct command_block));
43f66a6c
JK		 2783
2784 IPW_DEBUG_FW("<< :\n");
2785 return 0;
2786
2787}
2788
2789static int ipw_fw_dma_kick(struct ipw_priv *priv)
2790{
2791 u32 control = 0;
0edd5b44 2792 u32 index = 0;
43f66a6c
JK		 2793
2794 IPW_DEBUG_FW(">> :\n");
bf79451e 2795
43f66a6c 2796 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
0edd5b44
JG		 2797 ipw_fw_dma_write_command_block(priv, index,
2798 &priv->sram_desc.cb_list[index]);
43f66a6c
JK		 2799
2800 /* Enable the DMA in the CSR register */
b095c381
JK		 2801 ipw_clear_bit(priv, IPW_RESET_REG,
2802 IPW_RESET_REG_MASTER_DISABLED |
2803 IPW_RESET_REG_STOP_MASTER);
bf79451e 2804
0edd5b44 2805 /* Set the Start bit. */
43f66a6c 2806 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
b095c381 2807 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
43f66a6c
JK		 2808
2809 IPW_DEBUG_FW("<< :\n");
2810 return 0;
2811}
2812
2813static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2814{
2815 u32 address;
0edd5b44
JG		 2816 u32 register_value = 0;
2817 u32 cb_fields_address = 0;
43f66a6c
JK		 2818
2819 IPW_DEBUG_FW(">> :\n");
b095c381 2820 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
9fd1ea42 2821 IPW_DEBUG_FW_INFO("Current CB is 0x%x\n", address);
43f66a6c
JK		 2822
2823 /* Read the DMA Controlor register */
b095c381 2824 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
9fd1ea42 2825 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x\n", register_value);
43f66a6c 2826
0edd5b44 2827 /* Print the CB values */
43f66a6c
JK		 2828 cb_fields_address = address;
2829 register_value = ipw_read_reg32(priv, cb_fields_address);
9fd1ea42 2830 IPW_DEBUG_FW_INFO("Current CB Control Field is 0x%x\n", register_value);
43f66a6c
JK		 2831
2832 cb_fields_address += sizeof(u32);
2833 register_value = ipw_read_reg32(priv, cb_fields_address);
9fd1ea42 2834 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x\n", register_value);
43f66a6c
JK		 2835
2836 cb_fields_address += sizeof(u32);
2837 register_value = ipw_read_reg32(priv, cb_fields_address);
9fd1ea42 2838 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x\n",
43f66a6c
JK		 2839 register_value);
2840
2841 cb_fields_address += sizeof(u32);
2842 register_value = ipw_read_reg32(priv, cb_fields_address);
9fd1ea42 2843 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x\n", register_value);
43f66a6c
JK		 2844
2845 IPW_DEBUG_FW(">> :\n");
2846}
2847
2848static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2849{
2850 u32 current_cb_address = 0;
2851 u32 current_cb_index = 0;
2852
2853 IPW_DEBUG_FW("<< :\n");
b095c381 2854 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
bf79451e 2855
b095c381 2856 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
0edd5b44 2857 sizeof(struct command_block);
bf79451e 2858
9fd1ea42 2859 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X\n",
0edd5b44 2860 current_cb_index, current_cb_address);
43f66a6c
JK		 2861
2862 IPW_DEBUG_FW(">> :\n");
2863 return current_cb_index;
2864
2865}
2866
2867static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2868 u32 src_address,
2869 u32 dest_address,
2870 u32 length,
0edd5b44 2871 int interrupt_enabled, int is_last)
43f66a6c
JK		 2872{
2873
bf79451e 2874 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
0edd5b44
JG		 2875 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2876 CB_DEST_SIZE_LONG;
43f66a6c 2877 struct command_block *cb;
0edd5b44 2878 u32 last_cb_element = 0;
43f66a6c
JK		 2879
2880 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2881 src_address, dest_address, length);
2882
2883 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2884 return -1;
2885
2886 last_cb_element = priv->sram_desc.last_cb_index;
2887 cb = &priv->sram_desc.cb_list[last_cb_element];
2888 priv->sram_desc.last_cb_index++;
2889
2890 /* Calculate the new CB control word */
0edd5b44 2891 if (interrupt_enabled)
43f66a6c
JK		 2892 control |= CB_INT_ENABLED;
2893
2894 if (is_last)
2895 control |= CB_LAST_VALID;
bf79451e 2896
43f66a6c
JK		 2897 control |= length;
2898
2899 /* Calculate the CB Element's checksum value */
0edd5b44 2900 cb->status = control ^ src_address ^ dest_address;
43f66a6c
JK		 2901
2902 /* Copy the Source and Destination addresses */
2903 cb->dest_addr = dest_address;
2904 cb->source_addr = src_address;
2905
2906 /* Copy the Control Word last */
2907 cb->control = control;
2908
2909 return 0;
2910}
2911
11ebd1bf
ZY		 2912static int ipw_fw_dma_add_buffer(struct ipw_priv *priv, dma_addr_t *src_address,
2913 int nr, u32 dest_address, u32 len)
43f66a6c 2914{
11ebd1bf
ZY		 2915 int ret, i;
2916 u32 size;
2917
9fd1ea42 2918 IPW_DEBUG_FW(">>\n");
11ebd1bf
ZY		 2919 IPW_DEBUG_FW_INFO("nr=%d dest_address=0x%x len=0x%x\n",
2920 nr, dest_address, len);
2921
2922 for (i = 0; i < nr; i++) {
2923 size = min_t(u32, len - i * CB_MAX_LENGTH, CB_MAX_LENGTH);
2924 ret = ipw_fw_dma_add_command_block(priv, src_address[i],
2925 dest_address +
2926 i * CB_MAX_LENGTH, size,
2927 0, 0);
2928 if (ret) {
43f66a6c
JK		 2929 IPW_DEBUG_FW_INFO(": Failed\n");
2930 return -1;
bf79451e 2931 } else
43f66a6c 2932 IPW_DEBUG_FW_INFO(": Added new cb\n");
43f66a6c 2933 }
bf79451e 2934
9fd1ea42 2935 IPW_DEBUG_FW("<<\n");
43f66a6c
JK		 2936 return 0;
2937}
2938
2939static int ipw_fw_dma_wait(struct ipw_priv *priv)
2940{
397ae121 2941 u32 current_index = 0, previous_index;
43f66a6c
JK		 2942 u32 watchdog = 0;
2943
9fd1ea42 2944 IPW_DEBUG_FW(">> :\n");
43f66a6c
JK		 2945
2946 current_index = ipw_fw_dma_command_block_index(priv);
397ae121 2947 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%08X\n",
0edd5b44 2948 (int)priv->sram_desc.last_cb_index);
43f66a6c
JK		 2949
2950 while (current_index < priv->sram_desc.last_cb_index) {
2951 udelay(50);
397ae121 2952 previous_index = current_index;
43f66a6c
JK		 2953 current_index = ipw_fw_dma_command_block_index(priv);
2954
397ae121
ZY		 2955 if (previous_index < current_index) {
2956 watchdog = 0;
2957 continue;
2958 }
2959 if (++watchdog > 400) {
43f66a6c
JK		 2960 IPW_DEBUG_FW_INFO("Timeout\n");
2961 ipw_fw_dma_dump_command_block(priv);
2962 ipw_fw_dma_abort(priv);
2963 return -1;
2964 }
2965 }
2966
2967 ipw_fw_dma_abort(priv);
2968
0edd5b44 2969 /*Disable the DMA in the CSR register */
b095c381
JK		 2970 ipw_set_bit(priv, IPW_RESET_REG,
2971 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
43f66a6c 2972
9fd1ea42 2973 IPW_DEBUG_FW("<< dmaWaitSync\n");
43f66a6c
JK		 2974 return 0;
2975}
2976
bf79451e 2977static void ipw_remove_current_network(struct ipw_priv *priv)
43f66a6c
JK		 2978{
2979 struct list_head *element, *safe;
b0a4e7d8 2980 struct libipw_network *network = NULL;
a613bffd
JK		 2981 unsigned long flags;
2982
2983 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c 2984 list_for_each_safe(element, safe, &priv->ieee->network_list) {
b0a4e7d8 2985 network = list_entry(element, struct libipw_network, list);
43f66a6c
JK		 2986 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2987 list_del(element);
bf79451e 2988 list_add_tail(&network->list,
43f66a6c
JK		 2989 &priv->ieee->network_free_list);
2990 }
2991 }
a613bffd 2992 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c
JK		 2993}
2994
2995/**
bf79451e 2996 * Check that card is still alive.
43f66a6c
JK		 2997 * Reads debug register from domain0.
2998 * If card is present, pre-defined value should
2999 * be found there.
bf79451e 3000 *
43f66a6c
JK		 3001 * @param priv
3002 * @return 1 if card is present, 0 otherwise
3003 */
3004static inline int ipw_alive(struct ipw_priv *priv)
3005{
3006 return ipw_read32(priv, 0x90) == 0xd55555d5;
3007}
3008
c7b6a674 3009/* timeout in msec, attempted in 10-msec quanta */
858119e1 3010static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
43f66a6c
JK		 3011 int timeout)
3012{
3013 int i = 0;
3014
3015 do {
bf79451e 3016 if ((ipw_read32(priv, addr) & mask) == mask)
43f66a6c
JK		 3017 return i;
3018 mdelay(10);
3019 i += 10;
3020 } while (i < timeout);
bf79451e 3021
43f66a6c
JK		 3022 return -ETIME;
3023}
3024
bf79451e 3025/* These functions load the firmware and micro code for the operation of
43f66a6c
JK		 3026 * the ipw hardware. It assumes the buffer has all the bits for the
3027 * image and the caller is handling the memory allocation and clean up.
3028 */
3029
0edd5b44 3030static int ipw_stop_master(struct ipw_priv *priv)
43f66a6c
JK		 3031{
3032 int rc;
bf79451e 3033
9fd1ea42 3034 IPW_DEBUG_TRACE(">>\n");
43f66a6c 3035 /* stop master. typical delay - 0 */
b095c381 3036 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
43f66a6c 3037
c7b6a674 3038 /* timeout is in msec, polled in 10-msec quanta */
b095c381
JK		 3039 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3040 IPW_RESET_REG_MASTER_DISABLED, 100);
43f66a6c 3041 if (rc < 0) {
c7b6a674 3042 IPW_ERROR("wait for stop master failed after 100ms\n");
43f66a6c
JK		 3043 return -1;
3044 }
3045
3046 IPW_DEBUG_INFO("stop master %dms\n", rc);
3047
3048 return rc;
3049}
3050
3051static void ipw_arc_release(struct ipw_priv *priv)
3052{
9fd1ea42 3053 IPW_DEBUG_TRACE(">>\n");
43f66a6c
JK		 3054 mdelay(5);
3055
b095c381 3056 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
43f66a6c
JK		 3057
3058 /* no one knows timing, for safety add some delay */
3059 mdelay(5);
3060}
3061
43f66a6c 3062struct fw_chunk {
e62e1ee0
AV		 3063 __le32 address;
3064 __le32 length;
43f66a6c
JK		 3065};
3066
0edd5b44 3067static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
43f66a6c
JK		 3068{
3069 int rc = 0, i, addr;
3070 u8 cr = 0;
e62e1ee0 3071 __le16 *image;
43f66a6c 3072
e62e1ee0 3073 image = (__le16 *) data;
bf79451e 3074
9fd1ea42 3075 IPW_DEBUG_TRACE(">>\n");
43f66a6c
JK		 3076
3077 rc = ipw_stop_master(priv);
3078
3079 if (rc < 0)
3080 return rc;
bf79451e 3081
b095c381
JK		 3082 for (addr = IPW_SHARED_LOWER_BOUND;
3083 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
43f66a6c
JK		 3084 ipw_write32(priv, addr, 0);
3085 }
3086
3087 /* no ucode (yet) */
3088 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
3089 /* destroy DMA queues */
3090 /* reset sequence */
3091
b095c381 3092 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
43f66a6c 3093 ipw_arc_release(priv);
b095c381 3094 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
43f66a6c
JK		 3095 mdelay(1);
3096
3097 /* reset PHY */
b095c381 3098 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
43f66a6c 3099 mdelay(1);
bf79451e 3100
b095c381 3101 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
43f66a6c 3102 mdelay(1);
bf79451e 3103
43f66a6c 3104 /* enable ucode store */
c8fe6679
ZY		 3105 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
3106 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
43f66a6c
JK		 3107 mdelay(1);
3108
3109 /* write ucode */
3110 /**
3111 * @bug
3112 * Do NOT set indirect address register once and then
3113 * store data to indirect data register in the loop.
3114 * It seems very reasonable, but in this case DINO do not
3115 * accept ucode. It is essential to set address each time.
3116 */
3117 /* load new ipw uCode */
3118 for (i = 0; i < len / 2; i++)
b095c381 3119 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
e62e1ee0 3120 le16_to_cpu(image[i]));
43f66a6c 3121
43f66a6c 3122 /* enable DINO */
b095c381
JK		 3123 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3124 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
43f66a6c 3125
0edd5b44 3126 /* this is where the igx / win driver deveates from the VAP driver. */
43f66a6c
JK		 3127
3128 /* wait for alive response */
3129 for (i = 0; i < 100; i++) {
3130 /* poll for incoming data */
b095c381 3131 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
43f66a6c
JK		 3132 if (cr & DINO_RXFIFO_DATA)
3133 break;
3134 mdelay(1);
3135 }
3136
3137 if (cr & DINO_RXFIFO_DATA) {
3138 /* alive_command_responce size is NOT multiple of 4 */
e62e1ee0 3139 __le32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
bf79451e
JG		 3140
3141 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
43f66a6c 3142 response_buffer[i] =
e62e1ee0 3143 cpu_to_le32(ipw_read_reg32(priv,
b095c381 3144 IPW_BASEBAND_RX_FIFO_READ));
43f66a6c
JK		 3145 memcpy(&priv->dino_alive, response_buffer,
3146 sizeof(priv->dino_alive));
3147 if (priv->dino_alive.alive_command == 1
3148 && priv->dino_alive.ucode_valid == 1) {
3149 rc = 0;
0edd5b44
JG		 3150 IPW_DEBUG_INFO
3151 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
3152 "of %02d/%02d/%02d %02d:%02d\n",
3153 priv->dino_alive.software_revision,
3154 priv->dino_alive.software_revision,
3155 priv->dino_alive.device_identifier,
3156 priv->dino_alive.device_identifier,
3157 priv->dino_alive.time_stamp[0],
3158 priv->dino_alive.time_stamp[1],
3159 priv->dino_alive.time_stamp[2],
3160 priv->dino_alive.time_stamp[3],
3161 priv->dino_alive.time_stamp[4]);
43f66a6c
JK		 3162 } else {
3163 IPW_DEBUG_INFO("Microcode is not alive\n");
3164 rc = -EINVAL;
3165 }
3166 } else {
3167 IPW_DEBUG_INFO("No alive response from DINO\n");
3168 rc = -ETIME;
3169 }
3170
3171 /* disable DINO, otherwise for some reason
3172 firmware have problem getting alive resp. */
b095c381 3173 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
43f66a6c 3174
43f66a6c
JK		 3175 return rc;
3176}
3177
0edd5b44 3178static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
43f66a6c 3179{
11ebd1bf 3180 int ret = -1;
43f66a6c
JK		 3181 int offset = 0;
3182 struct fw_chunk *chunk;
11ebd1bf
ZY		 3183 int total_nr = 0;
3184 int i;
3185 struct pci_pool *pool;
41093167
ZY		 3186 void **virts;
3187 dma_addr_t *phys;
43f66a6c 3188
9fd1ea42 3189 IPW_DEBUG_TRACE("<< :\n");
43f66a6c 3190
41093167
ZY		 3191 virts = kmalloc(sizeof(void *) * CB_NUMBER_OF_ELEMENTS_SMALL,
3192 GFP_KERNEL);
3193 if (!virts)
3194 return -ENOMEM;
3195
3196 phys = kmalloc(sizeof(dma_addr_t) * CB_NUMBER_OF_ELEMENTS_SMALL,
3197 GFP_KERNEL);
3198 if (!phys) {
3199 kfree(virts);
3200 return -ENOMEM;
3201 }
11ebd1bf
ZY		 3202 pool = pci_pool_create("ipw2200", priv->pci_dev, CB_MAX_LENGTH, 0, 0);
3203 if (!pool) {
3204 IPW_ERROR("pci_pool_create failed\n");
41093167
ZY		 3205 kfree(phys);
3206 kfree(virts);
43f66a6c 3207 return -ENOMEM;
11ebd1bf 3208 }
43f66a6c
JK		 3209
3210 /* Start the Dma */
11ebd1bf 3211 ret = ipw_fw_dma_enable(priv);
43f66a6c 3212
0ee904c3
AB		 3213 /* the DMA is already ready this would be a bug. */
3214 BUG_ON(priv->sram_desc.last_cb_index > 0);
43f66a6c
JK		 3215
3216 do {
11ebd1bf
ZY		 3217 u32 chunk_len;
3218 u8 *start;
3219 int size;
3220 int nr = 0;
3221
43f66a6c
JK		 3222 chunk = (struct fw_chunk *)(data + offset);
3223 offset += sizeof(struct fw_chunk);
11ebd1bf
ZY		 3224 chunk_len = le32_to_cpu(chunk->length);
3225 start = data + offset;
3226
3227 nr = (chunk_len + CB_MAX_LENGTH - 1) / CB_MAX_LENGTH;
3228 for (i = 0; i < nr; i++) {
3229 virts[total_nr] = pci_pool_alloc(pool, GFP_KERNEL,
3230 &phys[total_nr]);
3231 if (!virts[total_nr]) {
3232 ret = -ENOMEM;
3233 goto out;
3234 }
3235 size = min_t(u32, chunk_len - i * CB_MAX_LENGTH,
3236 CB_MAX_LENGTH);
3237 memcpy(virts[total_nr], start, size);
3238 start += size;
3239 total_nr++;
3240 /* We don't support fw chunk larger than 64*8K */
3241 BUG_ON(total_nr > CB_NUMBER_OF_ELEMENTS_SMALL);
3242 }
3243
43f66a6c 3244 /* build DMA packet and queue up for sending */
bf79451e 3245 /* dma to chunk->address, the chunk->length bytes from data +
43f66a6c
JK		 3246 * offeset*/
3247 /* Dma loading */
11ebd1bf
ZY		 3248 ret = ipw_fw_dma_add_buffer(priv, &phys[total_nr - nr],
3249 nr, le32_to_cpu(chunk->address),
3250 chunk_len);
3251 if (ret) {
43f66a6c
JK		 3252 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3253 goto out;
3254 }
bf79451e 3255
11ebd1bf 3256 offset += chunk_len;
43f66a6c
JK		 3257 } while (offset < len);
3258
0edd5b44 3259 /* Run the DMA and wait for the answer */
11ebd1bf
ZY		 3260 ret = ipw_fw_dma_kick(priv);
3261 if (ret) {
43f66a6c
JK		 3262 IPW_ERROR("dmaKick Failed\n");
3263 goto out;
3264 }
3265
11ebd1bf
ZY		 3266 ret = ipw_fw_dma_wait(priv);
3267 if (ret) {
43f66a6c
JK		 3268 IPW_ERROR("dmaWaitSync Failed\n");
3269 goto out;
3270 }
11ebd1bf
ZY		 3271 out:
3272 for (i = 0; i < total_nr; i++)
3273 pci_pool_free(pool, virts[i], phys[i]);
3274
3275 pci_pool_destroy(pool);
41093167
ZY		 3276 kfree(phys);
3277 kfree(virts);
11ebd1bf
ZY		 3278
3279 return ret;
43f66a6c
JK		 3280}
3281
3282/* stop nic */
3283static int ipw_stop_nic(struct ipw_priv *priv)
3284{
3285 int rc = 0;
3286
0edd5b44 3287 /* stop */
b095c381 3288 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
bf79451e 3289
b095c381
JK		 3290 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3291 IPW_RESET_REG_MASTER_DISABLED, 500);
43f66a6c 3292 if (rc < 0) {
c7b6a674 3293 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
43f66a6c 3294 return rc;
bf79451e 3295 }
43f66a6c 3296
b095c381 3297 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
bf79451e 3298
43f66a6c
JK		 3299 return rc;
3300}
3301
3302static void ipw_start_nic(struct ipw_priv *priv)
3303{
3304 IPW_DEBUG_TRACE(">>\n");
3305
0edd5b44 3306 /* prvHwStartNic release ARC */
b095c381
JK		 3307 ipw_clear_bit(priv, IPW_RESET_REG,
3308 IPW_RESET_REG_MASTER_DISABLED |
3309 IPW_RESET_REG_STOP_MASTER |
43f66a6c 3310 CBD_RESET_REG_PRINCETON_RESET);
bf79451e 3311
43f66a6c 3312 /* enable power management */
b095c381
JK		 3313 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3314 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
43f66a6c
JK		 3315
3316 IPW_DEBUG_TRACE("<<\n");
3317}
bf79451e 3318
43f66a6c
JK		 3319static int ipw_init_nic(struct ipw_priv *priv)
3320{
3321 int rc;
3322
3323 IPW_DEBUG_TRACE(">>\n");
bf79451e 3324 /* reset */
43f66a6c
JK		 3325 /*prvHwInitNic */
3326 /* set "initialization complete" bit to move adapter to D0 state */
b095c381 3327 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
43f66a6c
JK		 3328
3329 /* low-level PLL activation */
b095c381
JK		 3330 ipw_write32(priv, IPW_READ_INT_REGISTER,
3331 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
43f66a6c
JK		 3332
3333 /* wait for clock stabilization */
b095c381
JK		 3334 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3335 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
0edd5b44 3336 if (rc < 0)
43f66a6c
JK		 3337 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3338
3339 /* assert SW reset */
b095c381 3340 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
43f66a6c
JK		 3341
3342 udelay(10);
3343
3344 /* set "initialization complete" bit to move adapter to D0 state */
b095c381 3345 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
43f66a6c
JK		 3346
3347 IPW_DEBUG_TRACE(">>\n");
3348 return 0;
3349}
3350
bf79451e 3351/* Call this function from process context, it will sleep in request_firmware.
43f66a6c
JK		 3352 * Probe is an ok place to call this from.
3353 */
3354static int ipw_reset_nic(struct ipw_priv *priv)
3355{
3356 int rc = 0;
a613bffd 3357 unsigned long flags;
43f66a6c
JK		 3358
3359 IPW_DEBUG_TRACE(">>\n");
bf79451e 3360
43f66a6c 3361 rc = ipw_init_nic(priv);
bf79451e 3362
a613bffd 3363 spin_lock_irqsave(&priv->lock, flags);
43f66a6c
JK		 3364 /* Clear the 'host command active' bit... */
3365 priv->status &= ~STATUS_HCMD_ACTIVE;
3366 wake_up_interruptible(&priv->wait_command_queue);
afbf30a2
JK		 3367 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3368 wake_up_interruptible(&priv->wait_state);
a613bffd 3369 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c
JK		 3370
3371 IPW_DEBUG_TRACE("<<\n");
3372 return rc;
bf79451e 3373}
43f66a6c 3374
9006ea75
JK		 3375
3376struct ipw_fw {
0070f8c7
ZY		 3377 __le32 ver;
3378 __le32 boot_size;
3379 __le32 ucode_size;
3380 __le32 fw_size;
9006ea75
JK		 3381 u8 data[0];
3382};
3383
bf79451e 3384static int ipw_get_fw(struct ipw_priv *priv,
9006ea75 3385 const struct firmware **raw, const char *name)
43f66a6c 3386{
9006ea75 3387 struct ipw_fw *fw;
43f66a6c
JK		 3388 int rc;
3389
3390 /* ask firmware_class module to get the boot firmware off disk */
9006ea75 3391 rc = request_firmware(raw, name, &priv->pci_dev->dev);
43f66a6c 3392 if (rc < 0) {
9006ea75 3393 IPW_ERROR("%s request_firmware failed: Reason %d\n", name, rc);
43f66a6c 3394 return rc;
bf79451e 3395 }
43f66a6c 3396
9006ea75
JK		 3397 if ((*raw)->size < sizeof(*fw)) {
3398 IPW_ERROR("%s is too small (%zd)\n", name, (*raw)->size);
3399 return -EINVAL;
3400 }
3401
3402 fw = (void *)(*raw)->data;
3403
0070f8c7
ZY		 3404 if ((*raw)->size < sizeof(*fw) + le32_to_cpu(fw->boot_size) +
3405 le32_to_cpu(fw->ucode_size) + le32_to_cpu(fw->fw_size)) {
9006ea75
JK		 3406 IPW_ERROR("%s is too small or corrupt (%zd)\n",
3407 name, (*raw)->size);
43f66a6c
JK		 3408 return -EINVAL;
3409 }
3410
9006ea75 3411 IPW_DEBUG_INFO("Read firmware '%s' image v%d.%d (%zd bytes)\n",
43f66a6c 3412 name,
9006ea75
JK		 3413 le32_to_cpu(fw->ver) >> 16,
3414 le32_to_cpu(fw->ver) & 0xff,
3415 (*raw)->size - sizeof(*fw));
43f66a6c
JK		 3416 return 0;
3417}
3418
b095c381 3419#define IPW_RX_BUF_SIZE (3000)
43f66a6c 3420
858119e1 3421static void ipw_rx_queue_reset(struct ipw_priv *priv,
43f66a6c
JK		 3422 struct ipw_rx_queue *rxq)
3423{
3424 unsigned long flags;
3425 int i;
3426
3427 spin_lock_irqsave(&rxq->lock, flags);
3428
3429 INIT_LIST_HEAD(&rxq->rx_free);
3430 INIT_LIST_HEAD(&rxq->rx_used);
3431
3432 /* Fill the rx_used queue with _all_ of the Rx buffers */
3433 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3434 /* In the reset function, these buffers may have been allocated
3435 * to an SKB, so we need to unmap and free potential storage */
3436 if (rxq->pool[i].skb != NULL) {
3437 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
b095c381 3438 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 3439 dev_kfree_skb(rxq->pool[i].skb);
a613bffd 3440 rxq->pool[i].skb = NULL;
43f66a6c
JK		 3441 }
3442 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3443 }
bf79451e 3444
43f66a6c
JK		 3445 /* Set us so that we have processed and used all buffers, but have
3446 * not restocked the Rx queue with fresh buffers */
3447 rxq->read = rxq->write = 0;
43f66a6c
JK		 3448 rxq->free_count = 0;
3449 spin_unlock_irqrestore(&rxq->lock, flags);
3450}
3451
3452#ifdef CONFIG_PM
3453static int fw_loaded = 0;
9006ea75 3454static const struct firmware *raw = NULL;
afbf30a2
JK		 3455
3456static void free_firmware(void)
3457{
3458 if (fw_loaded) {
9006ea75
JK		 3459 release_firmware(raw);
3460 raw = NULL;
afbf30a2
JK		 3461 fw_loaded = 0;
3462 }
3463}
3464#else
3465#define free_firmware() do {} while (0)
43f66a6c
JK		 3466#endif
3467
3468static int ipw_load(struct ipw_priv *priv)
3469{
3470#ifndef CONFIG_PM
9006ea75 3471 const struct firmware *raw = NULL;
43f66a6c 3472#endif
9006ea75
JK		 3473 struct ipw_fw *fw;
3474 u8 *boot_img, *ucode_img, *fw_img;
3475 u8 *name = NULL;
43f66a6c
JK		 3476 int rc = 0, retries = 3;
3477
397ae121
ZY		 3478 switch (priv->ieee->iw_mode) {
3479 case IW_MODE_ADHOC:
9006ea75 3480 name = "ipw2200-ibss.fw";
397ae121 3481 break;
b095c381 3482#ifdef CONFIG_IPW2200_MONITOR
397ae121 3483 case IW_MODE_MONITOR:
9006ea75 3484 name = "ipw2200-sniffer.fw";
397ae121 3485 break;
43f66a6c 3486#endif
397ae121 3487 case IW_MODE_INFRA:
9006ea75 3488 name = "ipw2200-bss.fw";
397ae121 3489 break;
9006ea75
JK		 3490 }
3491
3492 if (!name) {
397ae121 3493 rc = -EINVAL;
9006ea75
JK		 3494 goto error;
3495 }
3496
3497#ifdef CONFIG_PM
3498 if (!fw_loaded) {
3499#endif
3500 rc = ipw_get_fw(priv, &raw, name);
3501 if (rc < 0)
3502 goto error;
3503#ifdef CONFIG_PM
43f66a6c 3504 }
9006ea75
JK		 3505#endif
3506
3507 fw = (void *)raw->data;
3508 boot_img = &fw->data[0];
0070f8c7
ZY		 3509 ucode_img = &fw->data[le32_to_cpu(fw->boot_size)];
3510 fw_img = &fw->data[le32_to_cpu(fw->boot_size) +
3511 le32_to_cpu(fw->ucode_size)];
397ae121
ZY		 3512
3513 if (rc < 0)
3514 goto error;
43f66a6c
JK		 3515
3516 if (!priv->rxq)
3517 priv->rxq = ipw_rx_queue_alloc(priv);
3518 else
3519 ipw_rx_queue_reset(priv, priv->rxq);
3520 if (!priv->rxq) {
3521 IPW_ERROR("Unable to initialize Rx queue\n");
3522 goto error;
3523 }
3524
0edd5b44 3525 retry:
43f66a6c 3526 /* Ensure interrupts are disabled */
b095c381 3527 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
43f66a6c
JK		 3528 priv->status &= ~STATUS_INT_ENABLED;
3529
3530 /* ack pending interrupts */
b095c381 3531 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
bf79451e 3532
43f66a6c
JK		 3533 ipw_stop_nic(priv);
3534
3535 rc = ipw_reset_nic(priv);
397ae121 3536 if (rc < 0) {
43f66a6c
JK		 3537 IPW_ERROR("Unable to reset NIC\n");
3538 goto error;
3539 }
3540
b095c381
JK		 3541 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3542 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
43f66a6c
JK		 3543
3544 /* DMA the initial boot firmware into the device */
0070f8c7 3545 rc = ipw_load_firmware(priv, boot_img, le32_to_cpu(fw->boot_size));
43f66a6c 3546 if (rc < 0) {
a4f6bbb3 3547 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
43f66a6c
JK		 3548 goto error;
3549 }
3550
3551 /* kick start the device */
3552 ipw_start_nic(priv);
3553
c7b6a674 3554 /* wait for the device to finish its initial startup sequence */
b095c381
JK		 3555 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3556 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
43f66a6c
JK		 3557 if (rc < 0) {
3558 IPW_ERROR("device failed to boot initial fw image\n");
3559 goto error;
3560 }
3561 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3562
bf79451e 3563 /* ack fw init done interrupt */
b095c381 3564 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
43f66a6c
JK		 3565
3566 /* DMA the ucode into the device */
0070f8c7 3567 rc = ipw_load_ucode(priv, ucode_img, le32_to_cpu(fw->ucode_size));
43f66a6c 3568 if (rc < 0) {
a4f6bbb3 3569 IPW_ERROR("Unable to load ucode: %d\n", rc);
43f66a6c
JK		 3570 goto error;
3571 }
bf79451e 3572
43f66a6c
JK		 3573 /* stop nic */
3574 ipw_stop_nic(priv);
3575
3576 /* DMA bss firmware into the device */
0070f8c7 3577 rc = ipw_load_firmware(priv, fw_img, le32_to_cpu(fw->fw_size));
0edd5b44 3578 if (rc < 0) {
a4f6bbb3 3579 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 3580 goto error;
3581 }
397ae121
ZY		 3582#ifdef CONFIG_PM
3583 fw_loaded = 1;
3584#endif
3585
43f66a6c
JK		 3586 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3587
3588 rc = ipw_queue_reset(priv);
397ae121 3589 if (rc < 0) {
43f66a6c
JK		 3590 IPW_ERROR("Unable to initialize queues\n");
3591 goto error;
3592 }
3593
3594 /* Ensure interrupts are disabled */
b095c381 3595 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
c848d0af 3596 /* ack pending interrupts */
b095c381 3597 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
bf79451e 3598
43f66a6c
JK		 3599 /* kick start the device */
3600 ipw_start_nic(priv);
3601
b095c381 3602 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
43f66a6c
JK		 3603 if (retries > 0) {
3604 IPW_WARNING("Parity error. Retrying init.\n");
3605 retries--;
3606 goto retry;
3607 }
3608
3609 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3610 rc = -EIO;
3611 goto error;
3612 }
3613
3614 /* wait for the device */
b095c381
JK		 3615 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3616 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
43f66a6c 3617 if (rc < 0) {
c7b6a674 3618 IPW_ERROR("device failed to start within 500ms\n");
43f66a6c
JK		 3619 goto error;
3620 }
3621 IPW_DEBUG_INFO("device response after %dms\n", rc);
3622
3623 /* ack fw init done interrupt */
b095c381 3624 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
43f66a6c
JK		 3625
3626 /* read eeprom data and initialize the eeprom region of sram */
3627 priv->eeprom_delay = 1;
bf79451e 3628 ipw_eeprom_init_sram(priv);
43f66a6c
JK		 3629
3630 /* enable interrupts */
3631 ipw_enable_interrupts(priv);
3632
3633 /* Ensure our queue has valid packets */
3634 ipw_rx_queue_replenish(priv);
3635
b095c381 3636 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
43f66a6c
JK		 3637
3638 /* ack pending interrupts */
b095c381 3639 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
43f66a6c
JK		 3640
3641#ifndef CONFIG_PM
9006ea75 3642 release_firmware(raw);
43f66a6c
JK		 3643#endif
3644 return 0;
3645
0edd5b44 3646 error:
43f66a6c
JK		 3647 if (priv->rxq) {
3648 ipw_rx_queue_free(priv, priv->rxq);
3649 priv->rxq = NULL;
3650 }
3651 ipw_tx_queue_free(priv);
9006ea75
JK		 3652 if (raw)
3653 release_firmware(raw);
43f66a6c
JK		 3654#ifdef CONFIG_PM
3655 fw_loaded = 0;
9006ea75 3656 raw = NULL;
43f66a6c
JK		 3657#endif
3658
3659 return rc;
3660}
3661
bf79451e 3662/**
43f66a6c
JK		 3663 * DMA services
3664 *
3665 * Theory of operation
3666 *
3667 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3668 * 2 empty entries always kept in the buffer to protect from overflow.
3669 *
3670 * For Tx queue, there are low mark and high mark limits. If, after queuing
bf79451e
JG		 3671 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3672 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
43f66a6c
JK		 3673 * Tx queue resumed.
3674 *
3675 * The IPW operates with six queues, one receive queue in the device's
3676 * sram, one transmit queue for sending commands to the device firmware,
bf79451e 3677 * and four transmit queues for data.
43f66a6c 3678 *
bf79451e 3679 * The four transmit queues allow for performing quality of service (qos)
43f66a6c 3680 * transmissions as per the 802.11 protocol. Currently Linux does not
bf79451e 3681 * provide a mechanism to the user for utilizing prioritized queues, so
43f66a6c
JK		 3682 * we only utilize the first data transmit queue (queue1).
3683 */
3684
3685/**
3686 * Driver allocates buffers of this size for Rx
3687 */
3688
943dbef4
DW		 3689/**
3690 * ipw_rx_queue_space - Return number of free slots available in queue.
3691 */
3692static int ipw_rx_queue_space(const struct ipw_rx_queue *q)
3693{
3694 int s = q->read - q->write;
3695 if (s <= 0)
3696 s += RX_QUEUE_SIZE;
3697 /* keep some buffer to not confuse full and empty queue */
3698 s -= 2;
3699 if (s < 0)
3700 s = 0;
3701 return s;
3702}
3703
3704static inline int ipw_tx_queue_space(const struct clx2_queue *q)
43f66a6c
JK		 3705{
3706 int s = q->last_used - q->first_empty;
3707 if (s <= 0)
3708 s += q->n_bd;
3709 s -= 2; /* keep some reserve to not confuse empty and full situations */
3710 if (s < 0)
3711 s = 0;
3712 return s;
3713}
3714
3715static inline int ipw_queue_inc_wrap(int index, int n_bd)
3716{
3717 return (++index == n_bd) ? 0 : index;
3718}
3719
3720/**
3721 * Initialize common DMA queue structure
bf79451e 3722 *
43f66a6c
JK		 3723 * @param q queue to init
3724 * @param count Number of BD's to allocate. Should be power of 2
3725 * @param read_register Address for 'read' register
3726 * (not offset within BAR, full address)
3727 * @param write_register Address for 'write' register
3728 * (not offset within BAR, full address)
3729 * @param base_register Address for 'base' register
3730 * (not offset within BAR, full address)
3731 * @param size Address for 'size' register
3732 * (not offset within BAR, full address)
3733 */
bf79451e 3734static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
0edd5b44 3735 int count, u32 read, u32 write, u32 base, u32 size)
43f66a6c
JK		 3736{
3737 q->n_bd = count;
3738
3739 q->low_mark = q->n_bd / 4;
3740 if (q->low_mark < 4)
3741 q->low_mark = 4;
3742
3743 q->high_mark = q->n_bd / 8;
3744 if (q->high_mark < 2)
3745 q->high_mark = 2;
3746
3747 q->first_empty = q->last_used = 0;
3748 q->reg_r = read;
3749 q->reg_w = write;
3750
3751 ipw_write32(priv, base, q->dma_addr);
3752 ipw_write32(priv, size, count);
3753 ipw_write32(priv, read, 0);
3754 ipw_write32(priv, write, 0);
3755
3756 _ipw_read32(priv, 0x90);
3757}
3758
bf79451e 3759static int ipw_queue_tx_init(struct ipw_priv *priv,
43f66a6c 3760 struct clx2_tx_queue *q,
0edd5b44 3761 int count, u32 read, u32 write, u32 base, u32 size)
43f66a6c
JK		 3762{
3763 struct pci_dev *dev = priv->pci_dev;
3764
3765 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3766 if (!q->txb) {
25985edc 3767 IPW_ERROR("vmalloc for auxiliary BD structures failed\n");
43f66a6c
JK		 3768 return -ENOMEM;
3769 }
3770
0edd5b44
JG		 3771 q->bd =
3772 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
43f66a6c 3773 if (!q->bd) {
aaa4d308 3774 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
0edd5b44 3775 sizeof(q->bd[0]) * count);
43f66a6c
JK		 3776 kfree(q->txb);
3777 q->txb = NULL;
3778 return -ENOMEM;
3779 }
3780
3781 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3782 return 0;
3783}
3784
3785/**
3786 * Free one TFD, those at index [txq->q.last_used].
3787 * Do NOT advance any indexes
bf79451e 3788 *
43f66a6c
JK		 3789 * @param dev
3790 * @param txq
3791 */
3792static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3793 struct clx2_tx_queue *txq)
3794{
3795 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3796 struct pci_dev *dev = priv->pci_dev;
3797 int i;
bf79451e 3798
43f66a6c
JK		 3799 /* classify bd */
3800 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3801 /* nothing to cleanup after for host commands */
3802 return;
3803
3804 /* sanity check */
a613bffd
JK		 3805 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3806 IPW_ERROR("Too many chunks: %i\n",
3807 le32_to_cpu(bd->u.data.num_chunks));
43f66a6c
JK		 3808 /** @todo issue fatal error, it is quite serious situation */
3809 return;
3810 }
3811
3812 /* unmap chunks if any */
a613bffd
JK		 3813 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3814 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3815 le16_to_cpu(bd->u.data.chunk_len[i]),
3816 PCI_DMA_TODEVICE);
43f66a6c 3817 if (txq->txb[txq->q.last_used]) {
b0a4e7d8 3818 libipw_txb_free(txq->txb[txq->q.last_used]);
43f66a6c
JK		 3819 txq->txb[txq->q.last_used] = NULL;
3820 }
3821 }
3822}
3823
3824/**
3825 * Deallocate DMA queue.
bf79451e 3826 *
43f66a6c
JK		 3827 * Empty queue by removing and destroying all BD's.
3828 * Free all buffers.
bf79451e 3829 *
43f66a6c
JK		 3830 * @param dev
3831 * @param q
3832 */
0edd5b44 3833static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
43f66a6c
JK		 3834{
3835 struct clx2_queue *q = &txq->q;
3836 struct pci_dev *dev = priv->pci_dev;
3837
bf79451e
JG		 3838 if (q->n_bd == 0)
3839 return;
43f66a6c
JK		 3840
3841 /* first, empty all BD's */
3842 for (; q->first_empty != q->last_used;
3843 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3844 ipw_queue_tx_free_tfd(priv, txq);
3845 }
bf79451e 3846
43f66a6c 3847 /* free buffers belonging to queue itself */
0edd5b44 3848 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
43f66a6c
JK		 3849 q->dma_addr);
3850 kfree(txq->txb);
3851
3852 /* 0 fill whole structure */
3853 memset(txq, 0, sizeof(*txq));
3854}
3855
43f66a6c
JK		 3856/**
3857 * Destroy all DMA queues and structures
bf79451e 3858 *
43f66a6c
JK		 3859 * @param priv
3860 */
3861static void ipw_tx_queue_free(struct ipw_priv *priv)
3862{
3863 /* Tx CMD queue */
3864 ipw_queue_tx_free(priv, &priv->txq_cmd);
3865
3866 /* Tx queues */
3867 ipw_queue_tx_free(priv, &priv->txq[0]);
3868 ipw_queue_tx_free(priv, &priv->txq[1]);
3869 ipw_queue_tx_free(priv, &priv->txq[2]);
3870 ipw_queue_tx_free(priv, &priv->txq[3]);
3871}
3872
858119e1 3873static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3874{
3875 /* First 3 bytes are manufacturer */
3876 bssid[0] = priv->mac_addr[0];
3877 bssid[1] = priv->mac_addr[1];
3878 bssid[2] = priv->mac_addr[2];
3879
3880 /* Last bytes are random */
0edd5b44 3881 get_random_bytes(&bssid[3], ETH_ALEN - 3);
43f66a6c 3882
0edd5b44
JG		 3883 bssid[0] &= 0xfe; /* clear multicast bit */
3884 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
43f66a6c
JK		 3885}
3886
858119e1 3887static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3888{
3889 struct ipw_station_entry entry;
3890 int i;
3891
3892 for (i = 0; i < priv->num_stations; i++) {
3893 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3894 /* Another node is active in network */
3895 priv->missed_adhoc_beacons = 0;
3896 if (!(priv->config & CFG_STATIC_CHANNEL))
3897 /* when other nodes drop out, we drop out */
3898 priv->config &= ~CFG_ADHOC_PERSIST;
3899
3900 return i;
3901 }
3902 }
3903
3904 if (i == MAX_STATIONS)
3905 return IPW_INVALID_STATION;
3906
e174961c 3907 IPW_DEBUG_SCAN("Adding AdHoc station: %pM\n", bssid);
43f66a6c
JK		 3908
3909 entry.reserved = 0;
3910 entry.support_mode = 0;
3911 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3912 memcpy(priv->stations[i], bssid, ETH_ALEN);
3913 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
0edd5b44 3914 &entry, sizeof(entry));
43f66a6c
JK		 3915 priv->num_stations++;
3916
3917 return i;
3918}
3919
858119e1 3920static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3921{
3922 int i;
3923
bf79451e
JG		 3924 for (i = 0; i < priv->num_stations; i++)
3925 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
43f66a6c
JK		 3926 return i;
3927
3928 return IPW_INVALID_STATION;
3929}
3930
3931static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3932{
3933 int err;
3934
7b99659f
HL		 3935 if (priv->status & STATUS_ASSOCIATING) {
3936 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
bcb6d916 3937 schedule_work(&priv->disassociate);
7b99659f
HL		 3938 return;
3939 }
3940
3941 if (!(priv->status & STATUS_ASSOCIATED)) {
43f66a6c
JK		 3942 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3943 return;
3944 }
3945
e174961c 3946 IPW_DEBUG_ASSOC("Disassocation attempt from %pM "
43f66a6c 3947 "on channel %d.\n",
e174961c 3948 priv->assoc_request.bssid,
43f66a6c
JK		 3949 priv->assoc_request.channel);
3950
3951 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3952 priv->status |= STATUS_DISASSOCIATING;
3953
3954 if (quiet)
3955 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3956 else
3957 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
e6324726 3958
43f66a6c
JK		 3959 err = ipw_send_associate(priv, &priv->assoc_request);
3960 if (err) {
3961 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3962 "failed.\n");
3963 return;
3964 }
3965
3966}
3967
c848d0af 3968static int ipw_disassociate(void *data)
43f66a6c 3969{
c848d0af
JK		 3970 struct ipw_priv *priv = data;
3971 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3972 return 0;
43f66a6c 3973 ipw_send_disassociate(data, 0);
b8ddafd7 3974 netif_carrier_off(priv->net_dev);
c848d0af 3975 return 1;
43f66a6c
JK		 3976}
3977
c4028958 3978static void ipw_bg_disassociate(struct work_struct *work)
43f66a6c 3979{
c4028958
DH		 3980 struct ipw_priv *priv =
3981 container_of(work, struct ipw_priv, disassociate);
4644151b 3982 mutex_lock(&priv->mutex);
c4028958 3983 ipw_disassociate(priv);
4644151b 3984 mutex_unlock(&priv->mutex);
43f66a6c
JK		 3985}
3986
c4028958 3987static void ipw_system_config(struct work_struct *work)
d8bad6df 3988{
c4028958
DH		 3989 struct ipw_priv *priv =
3990 container_of(work, struct ipw_priv, system_config);
d685b8c2
ZY		 3991
3992#ifdef CONFIG_IPW2200_PROMISCUOUS
3993 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
3994 priv->sys_config.accept_all_data_frames = 1;
3995 priv->sys_config.accept_non_directed_frames = 1;
3996 priv->sys_config.accept_all_mgmt_bcpr = 1;
3997 priv->sys_config.accept_all_mgmt_frames = 1;
3998 }
3999#endif
4000
4001 ipw_send_system_config(priv);
43f66a6c
JK		 4002}
4003
4004struct ipw_status_code {
4005 u16 status;
4006 const char *reason;
4007};
4008
4009static const struct ipw_status_code ipw_status_codes[] = {
4010 {0x00, "Successful"},
4011 {0x01, "Unspecified failure"},
4012 {0x0A, "Cannot support all requested capabilities in the "
4013 "Capability information field"},
4014 {0x0B, "Reassociation denied due to inability to confirm that "
4015 "association exists"},
4016 {0x0C, "Association denied due to reason outside the scope of this "
4017 "standard"},
0edd5b44
JG		 4018 {0x0D,
4019 "Responding station does not support the specified authentication "
43f66a6c 4020 "algorithm"},
0edd5b44
JG		 4021 {0x0E,
4022 "Received an Authentication frame with authentication sequence "
43f66a6c
JK		 4023 "transaction sequence number out of expected sequence"},
4024 {0x0F, "Authentication rejected because of challenge failure"},
4025 {0x10, "Authentication rejected due to timeout waiting for next "
4026 "frame in sequence"},
4027 {0x11, "Association denied because AP is unable to handle additional "
4028 "associated stations"},
0edd5b44
JG		 4029 {0x12,
4030 "Association denied due to requesting station not supporting all "
43f66a6c 4031 "of the datarates in the BSSBasicServiceSet Parameter"},
0edd5b44
JG		 4032 {0x13,
4033 "Association denied due to requesting station not supporting "
43f66a6c 4034 "short preamble operation"},
0edd5b44
JG		 4035 {0x14,
4036 "Association denied due to requesting station not supporting "
43f66a6c 4037 "PBCC encoding"},
0edd5b44
JG		 4038 {0x15,
4039 "Association denied due to requesting station not supporting "
43f66a6c 4040 "channel agility"},
0edd5b44
JG		 4041 {0x19,
4042 "Association denied due to requesting station not supporting "
43f66a6c 4043 "short slot operation"},
0edd5b44
JG		 4044 {0x1A,
4045 "Association denied due to requesting station not supporting "
43f66a6c
JK		 4046 "DSSS-OFDM operation"},
4047 {0x28, "Invalid Information Element"},
4048 {0x29, "Group Cipher is not valid"},
4049 {0x2A, "Pairwise Cipher is not valid"},
4050 {0x2B, "AKMP is not valid"},
4051 {0x2C, "Unsupported RSN IE version"},
4052 {0x2D, "Invalid RSN IE Capabilities"},
4053 {0x2E, "Cipher suite is rejected per security policy"},
4054};
4055
bf79451e 4056static const char *ipw_get_status_code(u16 status)
43f66a6c
JK		 4057{
4058 int i;
bf79451e 4059 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
ea2b26e0 4060 if (ipw_status_codes[i].status == (status & 0xff))
43f66a6c
JK		 4061 return ipw_status_codes[i].reason;
4062 return "Unknown status value.";
4063}
43f66a6c
JK		 4064
4065static void inline average_init(struct average *avg)
4066{
4067 memset(avg, 0, sizeof(*avg));
4068}
4069
00d21de5
ZY		 4070#define DEPTH_RSSI 8
4071#define DEPTH_NOISE 16
4072static s16 exponential_average(s16 prev_avg, s16 val, u8 depth)
4073{
4074 return ((depth-1)*prev_avg + val)/depth;
4075}
4076
858119e1 4077static void average_add(struct average *avg, s16 val)
43f66a6c
JK		 4078{
4079 avg->sum -= avg->entries[avg->pos];
4080 avg->sum += val;
4081 avg->entries[avg->pos++] = val;
4082 if (unlikely(avg->pos == AVG_ENTRIES)) {
4083 avg->init = 1;
4084 avg->pos = 0;
4085 }
4086}
4087
858119e1 4088static s16 average_value(struct average *avg)
43f66a6c
JK		 4089{
4090 if (!unlikely(avg->init)) {
4091 if (avg->pos)
4092 return avg->sum / avg->pos;
4093 return 0;
4094 }
4095
4096 return avg->sum / AVG_ENTRIES;
4097}
4098
4099static void ipw_reset_stats(struct ipw_priv *priv)
4100{
4101 u32 len = sizeof(u32);
4102
4103 priv->quality = 0;
4104
4105 average_init(&priv->average_missed_beacons);
00d21de5
ZY		 4106 priv->exp_avg_rssi = -60;
4107 priv->exp_avg_noise = -85 + 0x100;
43f66a6c
JK		 4108
4109 priv->last_rate = 0;
4110 priv->last_missed_beacons = 0;
4111 priv->last_rx_packets = 0;
4112 priv->last_tx_packets = 0;
4113 priv->last_tx_failures = 0;
bf79451e 4114
43f66a6c
JK		 4115 /* Firmware managed, reset only when NIC is restarted, so we have to
4116 * normalize on the current value */
bf79451e 4117 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
43f66a6c 4118 &priv->last_rx_err, &len);
bf79451e 4119 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
43f66a6c
JK		 4120 &priv->last_tx_failures, &len);
4121
4122 /* Driver managed, reset with each association */
4123 priv->missed_adhoc_beacons = 0;
4124 priv->missed_beacons = 0;
4125 priv->tx_packets = 0;
4126 priv->rx_packets = 0;
4127
4128}
4129
858119e1 4130static u32 ipw_get_max_rate(struct ipw_priv *priv)
43f66a6c
JK		 4131{
4132 u32 i = 0x80000000;
4133 u32 mask = priv->rates_mask;
4134 /* If currently associated in B mode, restrict the maximum
4135 * rate match to B rates */
4136 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
b0a4e7d8 4137 mask &= LIBIPW_CCK_RATES_MASK;
43f66a6c
JK		 4138
4139 /* TODO: Verify that the rate is supported by the current rates
4140 * list. */
4141
0edd5b44
JG		 4142 while (i && !(mask & i))
4143 i >>= 1;
43f66a6c 4144 switch (i) {
b0a4e7d8 4145 case LIBIPW_CCK_RATE_1MB_MASK:
ea2b26e0 4146 return 1000000;
b0a4e7d8 4147 case LIBIPW_CCK_RATE_2MB_MASK:
ea2b26e0 4148 return 2000000;
b0a4e7d8 4149 case LIBIPW_CCK_RATE_5MB_MASK:
ea2b26e0 4150 return 5500000;
b0a4e7d8 4151 case LIBIPW_OFDM_RATE_6MB_MASK:
ea2b26e0 4152 return 6000000;
b0a4e7d8 4153 case LIBIPW_OFDM_RATE_9MB_MASK:
ea2b26e0 4154 return 9000000;
b0a4e7d8 4155 case LIBIPW_CCK_RATE_11MB_MASK:
ea2b26e0 4156 return 11000000;
b0a4e7d8 4157 case LIBIPW_OFDM_RATE_12MB_MASK:
ea2b26e0 4158 return 12000000;
b0a4e7d8 4159 case LIBIPW_OFDM_RATE_18MB_MASK:
ea2b26e0 4160 return 18000000;
b0a4e7d8 4161 case LIBIPW_OFDM_RATE_24MB_MASK:
ea2b26e0 4162 return 24000000;
b0a4e7d8 4163 case LIBIPW_OFDM_RATE_36MB_MASK:
ea2b26e0 4164 return 36000000;
b0a4e7d8 4165 case LIBIPW_OFDM_RATE_48MB_MASK:
ea2b26e0 4166 return 48000000;
b0a4e7d8 4167 case LIBIPW_OFDM_RATE_54MB_MASK:
ea2b26e0 4168 return 54000000;
43f66a6c
JK		 4169 }
4170
bf79451e 4171 if (priv->ieee->mode == IEEE_B)
43f66a6c
JK		 4172 return 11000000;
4173 else
4174 return 54000000;
4175}
4176
4177static u32 ipw_get_current_rate(struct ipw_priv *priv)
4178{
4179 u32 rate, len = sizeof(rate);
4180 int err;
4181
bf79451e 4182 if (!(priv->status & STATUS_ASSOCIATED))
43f66a6c
JK		 4183 return 0;
4184
4185 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
bf79451e 4186 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
43f66a6c
JK		 4187 &len);
4188 if (err) {
4189 IPW_DEBUG_INFO("failed querying ordinals.\n");
4190 return 0;
4191 }
bf79451e 4192 } else
43f66a6c
JK		 4193 return ipw_get_max_rate(priv);
4194
4195 switch (rate) {
ea2b26e0
JK		 4196 case IPW_TX_RATE_1MB:
4197 return 1000000;
4198 case IPW_TX_RATE_2MB:
4199 return 2000000;
4200 case IPW_TX_RATE_5MB:
4201 return 5500000;
4202 case IPW_TX_RATE_6MB:
4203 return 6000000;
4204 case IPW_TX_RATE_9MB:
4205 return 9000000;
4206 case IPW_TX_RATE_11MB:
4207 return 11000000;
4208 case IPW_TX_RATE_12MB:
4209 return 12000000;
4210 case IPW_TX_RATE_18MB:
4211 return 18000000;
4212 case IPW_TX_RATE_24MB:
4213 return 24000000;
4214 case IPW_TX_RATE_36MB:
4215 return 36000000;
4216 case IPW_TX_RATE_48MB:
4217 return 48000000;
4218 case IPW_TX_RATE_54MB:
4219 return 54000000;
43f66a6c
JK		 4220 }
4221
4222 return 0;
4223}
4224
43f66a6c
JK		 4225#define IPW_STATS_INTERVAL (2 * HZ)
4226static void ipw_gather_stats(struct ipw_priv *priv)
4227{
4228 u32 rx_err, rx_err_delta, rx_packets_delta;
4229 u32 tx_failures, tx_failures_delta, tx_packets_delta;
4230 u32 missed_beacons_percent, missed_beacons_delta;
4231 u32 quality = 0;
4232 u32 len = sizeof(u32);
4233 s16 rssi;
bf79451e 4234 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
0edd5b44 4235 rate_quality;
ea2b26e0 4236 u32 max_rate;
43f66a6c
JK		 4237
4238 if (!(priv->status & STATUS_ASSOCIATED)) {
4239 priv->quality = 0;
4240 return;
4241 }
4242
4243 /* Update the statistics */
bf79451e 4244 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
43f66a6c 4245 &priv->missed_beacons, &len);
0edd5b44 4246 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
43f66a6c
JK		 4247 priv->last_missed_beacons = priv->missed_beacons;
4248 if (priv->assoc_request.beacon_interval) {
4249 missed_beacons_percent = missed_beacons_delta *
5b5e807f 4250 (HZ * le16_to_cpu(priv->assoc_request.beacon_interval)) /
0edd5b44 4251 (IPW_STATS_INTERVAL * 10);
43f66a6c
JK		 4252 } else {
4253 missed_beacons_percent = 0;
4254 }
4255 average_add(&priv->average_missed_beacons, missed_beacons_percent);
4256
4257 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
4258 rx_err_delta = rx_err - priv->last_rx_err;
4259 priv->last_rx_err = rx_err;
4260
4261 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
4262 tx_failures_delta = tx_failures - priv->last_tx_failures;
4263 priv->last_tx_failures = tx_failures;
4264
4265 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4266 priv->last_rx_packets = priv->rx_packets;
4267
4268 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4269 priv->last_tx_packets = priv->tx_packets;
4270
4271 /* Calculate quality based on the following:
bf79451e 4272 *
43f66a6c
JK		 4273 * Missed beacon: 100% = 0, 0% = 70% missed
4274 * Rate: 60% = 1Mbs, 100% = Max
4275 * Rx and Tx errors represent a straight % of total Rx/Tx
4276 * RSSI: 100% = > -50, 0% = < -80
4277 * Rx errors: 100% = 0, 0% = 50% missed
bf79451e 4278 *
43f66a6c
JK		 4279 * The lowest computed quality is used.
4280 *
4281 */
4282#define BEACON_THRESHOLD 5
4283 beacon_quality = 100 - missed_beacons_percent;
4284 if (beacon_quality < BEACON_THRESHOLD)
4285 beacon_quality = 0;
4286 else
bf79451e 4287 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
0edd5b44 4288 (100 - BEACON_THRESHOLD);
bf79451e 4289 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
43f66a6c 4290 beacon_quality, missed_beacons_percent);
bf79451e 4291
43f66a6c 4292 priv->last_rate = ipw_get_current_rate(priv);
ea2b26e0
JK		 4293 max_rate = ipw_get_max_rate(priv);
4294 rate_quality = priv->last_rate * 40 / max_rate + 60;
43f66a6c
JK		 4295 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4296 rate_quality, priv->last_rate / 1000000);
bf79451e 4297
0edd5b44 4298 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
bf79451e 4299 rx_quality = 100 - (rx_err_delta * 100) /
0edd5b44 4300 (rx_packets_delta + rx_err_delta);
43f66a6c
JK		 4301 else
4302 rx_quality = 100;
4303 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4304 rx_quality, rx_err_delta, rx_packets_delta);
bf79451e 4305
0edd5b44 4306 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
bf79451e 4307 tx_quality = 100 - (tx_failures_delta * 100) /
0edd5b44 4308 (tx_packets_delta + tx_failures_delta);
43f66a6c
JK		 4309 else
4310 tx_quality = 100;
4311 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4312 tx_quality, tx_failures_delta, tx_packets_delta);
bf79451e 4313
00d21de5 4314 rssi = priv->exp_avg_rssi;
c848d0af
JK		 4315 signal_quality =
4316 (100 *
4317 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4318 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4319 (priv->ieee->perfect_rssi - rssi) *
4320 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4321 62 * (priv->ieee->perfect_rssi - rssi))) /
4322 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4323 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4324 if (signal_quality > 100)
43f66a6c 4325 signal_quality = 100;
c848d0af 4326 else if (signal_quality < 1)
43f66a6c 4327 signal_quality = 0;
ea2b26e0 4328
61fb9ed9 4329 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
43f66a6c 4330 signal_quality, rssi);
bf79451e 4331
21f8a73f
RC		 4332 quality = min(rx_quality, signal_quality);
4333 quality = min(tx_quality, quality);
4334 quality = min(rate_quality, quality);
4335 quality = min(beacon_quality, quality);
43f66a6c 4336 if (quality == beacon_quality)
0edd5b44
JG		 4337 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4338 quality);
43f66a6c 4339 if (quality == rate_quality)
0edd5b44
JG		 4340 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4341 quality);
43f66a6c 4342 if (quality == tx_quality)
0edd5b44
JG		 4343 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4344 quality);
43f66a6c 4345 if (quality == rx_quality)
0edd5b44
JG		 4346 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4347 quality);
43f66a6c 4348 if (quality == signal_quality)
0edd5b44
JG		 4349 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4350 quality);
43f66a6c
JK		 4351
4352 priv->quality = quality;
bf79451e 4353
bcb6d916 4354 schedule_delayed_work(&priv->gather_stats, IPW_STATS_INTERVAL);
43f66a6c
JK		 4355}
4356
c4028958 4357static void ipw_bg_gather_stats(struct work_struct *work)
c848d0af 4358{
c4028958
DH		 4359 struct ipw_priv *priv =
4360 container_of(work, struct ipw_priv, gather_stats.work);
4644151b 4361 mutex_lock(&priv->mutex);
c4028958 4362 ipw_gather_stats(priv);
4644151b 4363 mutex_unlock(&priv->mutex);
c848d0af
JK		 4364}
4365
e7582561
BC		 4366/* Missed beacon behavior:
4367 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4368 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4369 * Above disassociate threshold, give up and stop scanning.
4370 * Roaming is disabled if disassociate_threshold <= roaming_threshold */
858119e1 4371static void ipw_handle_missed_beacon(struct ipw_priv *priv,
ea2b26e0
JK		 4372 int missed_count)
4373{
4374 priv->notif_missed_beacons = missed_count;
4375
afbf30a2 4376 if (missed_count > priv->disassociate_threshold &&
ea2b26e0
JK		 4377 priv->status & STATUS_ASSOCIATED) {
4378 /* If associated and we've hit the missed
4379 * beacon threshold, disassociate, turn
4380 * off roaming, and abort any active scans */
4381 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
afbf30a2 4382 IPW_DL_STATE | IPW_DL_ASSOC,
ea2b26e0
JK		 4383 "Missed beacon: %d - disassociate\n", missed_count);
4384 priv->status &= ~STATUS_ROAMING;
a613bffd
JK		 4385 if (priv->status & STATUS_SCANNING) {
4386 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4387 IPW_DL_STATE,
4388 "Aborting scan with missed beacon.\n");
bcb6d916 4389 schedule_work(&priv->abort_scan);
a613bffd
JK		 4390 }
4391
bcb6d916 4392 schedule_work(&priv->disassociate);
ea2b26e0
JK		 4393 return;
4394 }
4395
4396 if (priv->status & STATUS_ROAMING) {
4397 /* If we are currently roaming, then just
4398 * print a debug statement... */
4399 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4400 "Missed beacon: %d - roam in progress\n",
4401 missed_count);
4402 return;
4403 }
4404
4bfdb91d
ZY		 4405 if (roaming &&
4406 (missed_count > priv->roaming_threshold &&
4407 missed_count <= priv->disassociate_threshold)) {
ea2b26e0 4408 /* If we are not already roaming, set the ROAM
e7582561
BC		 4409 * bit in the status and kick off a scan.
4410 * This can happen several times before we reach
4411 * disassociate_threshold. */
ea2b26e0
JK		 4412 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4413 "Missed beacon: %d - initiate "
4414 "roaming\n", missed_count);
4415 if (!(priv->status & STATUS_ROAMING)) {
4416 priv->status |= STATUS_ROAMING;
4417 if (!(priv->status & STATUS_SCANNING))
bcb6d916 4418 schedule_delayed_work(&priv->request_scan, 0);
ea2b26e0
JK		 4419 }
4420 return;
4421 }
4422
14a4dfe2
HS		 4423 if (priv->status & STATUS_SCANNING &&
4424 missed_count > IPW_MB_SCAN_CANCEL_THRESHOLD) {
ea2b26e0
JK		 4425 /* Stop scan to keep fw from getting
4426 * stuck (only if we aren't roaming --
4427 * otherwise we'll never scan more than 2 or 3
4428 * channels..) */
b095c381
JK		 4429 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4430 "Aborting scan with missed beacon.\n");
bcb6d916 4431 schedule_work(&priv->abort_scan);
ea2b26e0
JK		 4432 }
4433
4434 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
ea2b26e0
JK		 4435}
4436
0b531676
DW		 4437static void ipw_scan_event(struct work_struct *work)
4438{
4439 union iwreq_data wrqu;
4440
4441 struct ipw_priv *priv =
4442 container_of(work, struct ipw_priv, scan_event.work);
4443
4444 wrqu.data.length = 0;
4445 wrqu.data.flags = 0;
4446 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4447}
4448
4449static void handle_scan_event(struct ipw_priv *priv)
4450{
4451 /* Only userspace-requested scan completion events go out immediately */
4452 if (!priv->user_requested_scan) {
4453 if (!delayed_work_pending(&priv->scan_event))
bcb6d916
TH		 4454 schedule_delayed_work(&priv->scan_event,
4455 round_jiffies_relative(msecs_to_jiffies(4000)));
0b531676
DW		 4456 } else {
4457 union iwreq_data wrqu;
4458
4459 priv->user_requested_scan = 0;
4460 cancel_delayed_work(&priv->scan_event);
4461
4462 wrqu.data.length = 0;
4463 wrqu.data.flags = 0;
4464 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4465 }
4466}
4467
43f66a6c
JK		 4468/**
4469 * Handle host notification packet.
4470 * Called from interrupt routine
4471 */
858119e1 4472static void ipw_rx_notification(struct ipw_priv *priv,
43f66a6c
JK		 4473 struct ipw_rx_notification *notif)
4474{
9387b7ca 4475 DECLARE_SSID_BUF(ssid);
e62e1ee0 4476 u16 size = le16_to_cpu(notif->size);
a613bffd 4477
e62e1ee0 4478 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, size);
bf79451e 4479
43f66a6c 4480 switch (notif->subtype) {
0edd5b44
JG		 4481 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4482 struct notif_association *assoc = &notif->u.assoc;
4483
4484 switch (assoc->state) {
4485 case CMAS_ASSOCIATED:{
4486 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4487 IPW_DL_ASSOC,
9fd1ea42 4488 "associated: '%s' %pM\n",
9387b7ca
JL		 4489 print_ssid(ssid, priv->essid,
4490 priv->essid_len),
e174961c 4491 priv->bssid);
0edd5b44
JG		 4492
4493 switch (priv->ieee->iw_mode) {
4494 case IW_MODE_INFRA:
4495 memcpy(priv->ieee->bssid,
4496 priv->bssid, ETH_ALEN);
4497 break;
4498
4499 case IW_MODE_ADHOC:
4500 memcpy(priv->ieee->bssid,
4501 priv->bssid, ETH_ALEN);
4502
4503 /* clear out the station table */
4504 priv->num_stations = 0;
4505
4506 IPW_DEBUG_ASSOC
4507 ("queueing adhoc check\n");
bcb6d916
TH		 4508 schedule_delayed_work(
4509 &priv->adhoc_check,
4510 le16_to_cpu(priv->
4511 assoc_request.
4512 beacon_interval));
0edd5b44
JG		 4513 break;
4514 }
4515
4516 priv->status &= ~STATUS_ASSOCIATING;
4517 priv->status |= STATUS_ASSOCIATED;
bcb6d916 4518 schedule_work(&priv->system_config);
0edd5b44 4519
e43e3c1e 4520#ifdef CONFIG_IPW2200_QOS
afbf30a2 4521#define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
72118015 4522 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_control))
afbf30a2
JK		 4523 if ((priv->status & STATUS_AUTH) &&
4524 (IPW_GET_PACKET_STYPE(&notif->u.raw)
4525 == IEEE80211_STYPE_ASSOC_RESP)) {
b095c381
JK		 4526 if ((sizeof
4527 (struct
b0a4e7d8 4528 libipw_assoc_response)
e62e1ee0
AV		 4529 <= size)
4530 && (size <= 2314)) {
b095c381 4531 struct
b0a4e7d8 4532 libipw_rx_stats
b095c381 4533 stats = {
e62e1ee0 4534 .len = size - 1,
b095c381
JK		 4535 };
4536
4537 IPW_DEBUG_QOS
4538 ("QoS Associate "
e62e1ee0 4539 "size %d\n", size);
b0a4e7d8 4540 libipw_rx_mgt(priv->
b095c381
JK		 4541 ieee,
4542 (struct
b0a4e7d8 4543 libipw_hdr_4addr
b095c381
JK		 4544 *)
4545 &notif->u.raw, &stats);
4546 }
0edd5b44 4547 }
b095c381 4548#endif
0edd5b44 4549
a613bffd 4550 schedule_work(&priv->link_up);
43f66a6c 4551
0edd5b44
JG		 4552 break;
4553 }
bf79451e 4554
0edd5b44
JG		 4555 case CMAS_AUTHENTICATED:{
4556 if (priv->
4557 status & (STATUS_ASSOCIATED |
4558 STATUS_AUTH)) {
0edd5b44
JG		 4559 struct notif_authenticate *auth
4560 = &notif->u.auth;
4561 IPW_DEBUG(IPW_DL_NOTIF |
4562 IPW_DL_STATE |
4563 IPW_DL_ASSOC,
4564 "deauthenticated: '%s' "
e174961c 4565 "%pM"
9fd1ea42 4566 ": (0x%04X) - %s\n",
9387b7ca
JL		 4567 print_ssid(ssid,
4568 priv->
4569 essid,
4570 priv->
4571 essid_len),
e174961c 4572 priv->bssid,
83f7d57c 4573 le16_to_cpu(auth->status),
0edd5b44 4574 ipw_get_status_code
83f7d57c 4575 (le16_to_cpu
0edd5b44 4576 (auth->status)));
43f66a6c 4577
0edd5b44
JG		 4578 priv->status &=
4579 ~(STATUS_ASSOCIATING |
4580 STATUS_AUTH |
4581 STATUS_ASSOCIATED);
4582
a613bffd 4583 schedule_work(&priv->link_down);
0edd5b44
JG		 4584 break;
4585 }
4586
4587 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4588 IPW_DL_ASSOC,
e174961c 4589 "authenticated: '%s' %pM\n",
9387b7ca
JL		 4590 print_ssid(ssid, priv->essid,
4591 priv->essid_len),
e174961c 4592 priv->bssid);
0edd5b44
JG		 4593 break;
4594 }
4595
4596 case CMAS_INIT:{
ea2b26e0
JK		 4597 if (priv->status & STATUS_AUTH) {
4598 struct
b0a4e7d8 4599 libipw_assoc_response
ea2b26e0
JK		 4600 *resp;
4601 resp =
4602 (struct
b0a4e7d8 4603 libipw_assoc_response
ea2b26e0
JK		 4604 *)&notif->u.raw;
4605 IPW_DEBUG(IPW_DL_NOTIF |
4606 IPW_DL_STATE |
4607 IPW_DL_ASSOC,
4608 "association failed (0x%04X): %s\n",
83f7d57c 4609 le16_to_cpu(resp->status),
ea2b26e0 4610 ipw_get_status_code
83f7d57c 4611 (le16_to_cpu
ea2b26e0
JK		 4612 (resp->status)));
4613 }
4614
0edd5b44
JG		 4615 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4616 IPW_DL_ASSOC,
9fd1ea42 4617 "disassociated: '%s' %pM\n",
9387b7ca
JL		 4618 print_ssid(ssid, priv->essid,
4619 priv->essid_len),
e174961c 4620 priv->bssid);
0edd5b44
JG		 4621
4622 priv->status &=
4623 ~(STATUS_DISASSOCIATING |
4624 STATUS_ASSOCIATING |
4625 STATUS_ASSOCIATED | STATUS_AUTH);
b095c381
JK		 4626 if (priv->assoc_network
4627 && (priv->assoc_network->
4628 capability &
4629 WLAN_CAPABILITY_IBSS))
4630 ipw_remove_current_network
4631 (priv);
0edd5b44 4632
a613bffd 4633 schedule_work(&priv->link_down);
0edd5b44 4634
0edd5b44
JG		 4635 break;
4636 }
43f66a6c 4637
b095c381
JK		 4638 case CMAS_RX_ASSOC_RESP:
4639 break;
4640
0edd5b44
JG		 4641 default:
4642 IPW_ERROR("assoc: unknown (%d)\n",
4643 assoc->state);
43f66a6c 4644 break;
bf79451e 4645 }
43f66a6c 4646
43f66a6c
JK		 4647 break;
4648 }
bf79451e 4649
0edd5b44
JG		 4650 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4651 struct notif_authenticate *auth = &notif->u.auth;
4652 switch (auth->state) {
4653 case CMAS_AUTHENTICATED:
4654 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
9fd1ea42 4655 "authenticated: '%s' %pM\n",
9387b7ca
JL		 4656 print_ssid(ssid, priv->essid,
4657 priv->essid_len),
e174961c 4658 priv->bssid);
0edd5b44
JG		 4659 priv->status |= STATUS_AUTH;
4660 break;
43f66a6c 4661
0edd5b44
JG		 4662 case CMAS_INIT:
4663 if (priv->status & STATUS_AUTH) {
4664 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4665 IPW_DL_ASSOC,
4666 "authentication failed (0x%04X): %s\n",
83f7d57c
AV		 4667 le16_to_cpu(auth->status),
4668 ipw_get_status_code(le16_to_cpu
0edd5b44
JG		 4669 (auth->
4670 status)));
4671 }
4672 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4673 IPW_DL_ASSOC,
e174961c 4674 "deauthenticated: '%s' %pM\n",
9387b7ca
JL		 4675 print_ssid(ssid, priv->essid,
4676 priv->essid_len),
e174961c 4677 priv->bssid);
bf79451e 4678
0edd5b44
JG		 4679 priv->status &= ~(STATUS_ASSOCIATING |
4680 STATUS_AUTH |
4681 STATUS_ASSOCIATED);
43f66a6c 4682
a613bffd 4683 schedule_work(&priv->link_down);
0edd5b44 4684 break;
43f66a6c 4685
0edd5b44
JG		 4686 case CMAS_TX_AUTH_SEQ_1:
4687 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4688 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4689 break;
4690 case CMAS_RX_AUTH_SEQ_2:
4691 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4692 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4693 break;
4694 case CMAS_AUTH_SEQ_1_PASS:
4695 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4696 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4697 break;
4698 case CMAS_AUTH_SEQ_1_FAIL:
4699 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4700 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4701 break;
4702 case CMAS_TX_AUTH_SEQ_3:
4703 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4704 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4705 break;
4706 case CMAS_RX_AUTH_SEQ_4:
4707 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4708 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4709 break;
4710 case CMAS_AUTH_SEQ_2_PASS:
4711 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4712 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4713 break;
4714 case CMAS_AUTH_SEQ_2_FAIL:
4715 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4716 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4717 break;
4718 case CMAS_TX_ASSOC:
4719 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4720 IPW_DL_ASSOC, "TX_ASSOC\n");
4721 break;
4722 case CMAS_RX_ASSOC_RESP:
4723 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4724 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
b095c381 4725
0edd5b44
JG		 4726 break;
4727 case CMAS_ASSOCIATED:
4728 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4729 IPW_DL_ASSOC, "ASSOCIATED\n");
4730 break;
4731 default:
4732 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4733 auth->state);
4734 break;
43f66a6c 4735 }
43f66a6c
JK		 4736 break;
4737 }
4738
0edd5b44
JG		 4739 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4740 struct notif_channel_result *x =
4741 &notif->u.channel_result;
43f66a6c 4742
e62e1ee0 4743 if (size == sizeof(*x)) {
0edd5b44
JG		 4744 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4745 x->channel_num);
4746 } else {
4747 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4748 "(should be %zd)\n",
e62e1ee0 4749 size, sizeof(*x));
bf79451e 4750 }
43f66a6c
JK		 4751 break;
4752 }
43f66a6c 4753
0edd5b44
JG		 4754 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4755 struct notif_scan_complete *x = &notif->u.scan_complete;
e62e1ee0 4756 if (size == sizeof(*x)) {
0edd5b44
JG		 4757 IPW_DEBUG_SCAN
4758 ("Scan completed: type %d, %d channels, "
4759 "%d status\n", x->scan_type,
4760 x->num_channels, x->status);
4761 } else {
4762 IPW_ERROR("Scan completed of wrong size %d "
4763 "(should be %zd)\n",
e62e1ee0 4764 size, sizeof(*x));
0edd5b44 4765 }
43f66a6c 4766
0edd5b44
JG		 4767 priv->status &=
4768 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4769
a0e04ab3 4770 wake_up_interruptible(&priv->wait_state);
0edd5b44
JG		 4771 cancel_delayed_work(&priv->scan_check);
4772
b095c381
JK		 4773 if (priv->status & STATUS_EXIT_PENDING)
4774 break;
4775
4776 priv->ieee->scans++;
4777
4778#ifdef CONFIG_IPW2200_MONITOR
4779 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 4780 priv->status |= STATUS_SCAN_FORCED;
bcb6d916 4781 schedule_delayed_work(&priv->request_scan, 0);
b095c381
JK		 4782 break;
4783 }
afbf30a2 4784 priv->status &= ~STATUS_SCAN_FORCED;
b095c381
JK		 4785#endif /* CONFIG_IPW2200_MONITOR */
4786
ea177305 4787 /* Do queued direct scans first */
bcb6d916
TH		 4788 if (priv->status & STATUS_DIRECT_SCAN_PENDING)
4789 schedule_delayed_work(&priv->request_direct_scan, 0);
ea177305 4790
0edd5b44
JG		 4791 if (!(priv->status & (STATUS_ASSOCIATED |
4792 STATUS_ASSOCIATING |
4793 STATUS_ROAMING |
4794 STATUS_DISASSOCIATING)))
bcb6d916 4795 schedule_work(&priv->associate);
0edd5b44 4796 else if (priv->status & STATUS_ROAMING) {
e7582561
BC		 4797 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4798 /* If a scan completed and we are in roam mode, then
4799 * the scan that completed was the one requested as a
4800 * result of entering roam... so, schedule the
4801 * roam work */
bcb6d916 4802 schedule_work(&priv->roam);
e7582561
BC		 4803 else
4804 /* Don't schedule if we aborted the scan */
4805 priv->status &= ~STATUS_ROAMING;
0edd5b44 4806 } else if (priv->status & STATUS_SCAN_PENDING)
bcb6d916 4807 schedule_delayed_work(&priv->request_scan, 0);
a613bffd
JK		 4808 else if (priv->config & CFG_BACKGROUND_SCAN
4809 && priv->status & STATUS_ASSOCIATED)
bcb6d916
TH		 4810 schedule_delayed_work(&priv->request_scan,
4811 round_jiffies_relative(HZ));
07f02e46
ZY		 4812
4813 /* Send an empty event to user space.
4814 * We don't send the received data on the event because
4815 * it would require us to do complex transcoding, and
4816 * we want to minimise the work done in the irq handler
4817 * Use a request to extract the data.
4818 * Also, we generate this even for any scan, regardless
4819 * on how the scan was initiated. User space can just
4820 * sync on periodic scan to get fresh data...
4821 * Jean II */
0b531676
DW		 4822 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4823 handle_scan_event(priv);
0edd5b44 4824 break;
43f66a6c 4825 }
43f66a6c 4826
0edd5b44
JG		 4827 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4828 struct notif_frag_length *x = &notif->u.frag_len;
43f66a6c 4829
e62e1ee0 4830 if (size == sizeof(*x))
a613bffd
JK		 4831 IPW_ERROR("Frag length: %d\n",
4832 le16_to_cpu(x->frag_length));
4833 else
0edd5b44
JG		 4834 IPW_ERROR("Frag length of wrong size %d "
4835 "(should be %zd)\n",
e62e1ee0 4836 size, sizeof(*x));
0edd5b44 4837 break;
43f66a6c 4838 }
43f66a6c 4839
0edd5b44
JG		 4840 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4841 struct notif_link_deterioration *x =
4842 &notif->u.link_deterioration;
afbf30a2 4843
e62e1ee0 4844 if (size == sizeof(*x)) {
0edd5b44 4845 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
12977154
BC		 4846 "link deterioration: type %d, cnt %d\n",
4847 x->silence_notification_type,
4848 x->silence_count);
0edd5b44
JG		 4849 memcpy(&priv->last_link_deterioration, x,
4850 sizeof(*x));
4851 } else {
4852 IPW_ERROR("Link Deterioration of wrong size %d "
4853 "(should be %zd)\n",
e62e1ee0 4854 size, sizeof(*x));
0edd5b44 4855 }
43f66a6c
JK		 4856 break;
4857 }
4858
0edd5b44
JG		 4859 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4860 IPW_ERROR("Dino config\n");
4861 if (priv->hcmd
a613bffd 4862 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
0edd5b44 4863 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
a613bffd 4864
0edd5b44
JG		 4865 break;
4866 }
43f66a6c 4867
0edd5b44
JG		 4868 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4869 struct notif_beacon_state *x = &notif->u.beacon_state;
e62e1ee0 4870 if (size != sizeof(*x)) {
0edd5b44
JG		 4871 IPW_ERROR
4872 ("Beacon state of wrong size %d (should "
e62e1ee0 4873 "be %zd)\n", size, sizeof(*x));
0edd5b44 4874 break;
43f66a6c
JK		 4875 }
4876
a613bffd
JK		 4877 if (le32_to_cpu(x->state) ==
4878 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4879 ipw_handle_missed_beacon(priv,
4880 le32_to_cpu(x->
4881 number));
43f66a6c 4882
0edd5b44
JG		 4883 break;
4884 }
43f66a6c 4885
0edd5b44
JG		 4886 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4887 struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
e62e1ee0 4888 if (size == sizeof(*x)) {
0edd5b44
JG		 4889 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4890 "0x%02x station %d\n",
4891 x->key_state, x->security_type,
4892 x->station_index);
4893 break;
4894 }
43f66a6c 4895
0edd5b44
JG		 4896 IPW_ERROR
4897 ("TGi Tx Key of wrong size %d (should be %zd)\n",
e62e1ee0 4898 size, sizeof(*x));
43f66a6c 4899 break;
bf79451e 4900 }
43f66a6c 4901
0edd5b44
JG		 4902 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4903 struct notif_calibration *x = &notif->u.calibration;
43f66a6c 4904
e62e1ee0 4905 if (size == sizeof(*x)) {
0edd5b44
JG		 4906 memcpy(&priv->calib, x, sizeof(*x));
4907 IPW_DEBUG_INFO("TODO: Calibration\n");
4908 break;
4909 }
43f66a6c 4910
0edd5b44
JG		 4911 IPW_ERROR
4912 ("Calibration of wrong size %d (should be %zd)\n",
e62e1ee0 4913 size, sizeof(*x));
43f66a6c 4914 break;
bf79451e
JG		 4915 }
4916
0edd5b44 4917 case HOST_NOTIFICATION_NOISE_STATS:{
e62e1ee0 4918 if (size == sizeof(u32)) {
00d21de5
ZY		 4919 priv->exp_avg_noise =
4920 exponential_average(priv->exp_avg_noise,
4921 (u8) (le32_to_cpu(notif->u.noise.value) & 0xff),
4922 DEPTH_NOISE);
0edd5b44
JG		 4923 break;
4924 }
43f66a6c 4925
0edd5b44
JG		 4926 IPW_ERROR
4927 ("Noise stat is wrong size %d (should be %zd)\n",
e62e1ee0 4928 size, sizeof(u32));
43f66a6c
JK		 4929 break;
4930 }
4931
43f66a6c 4932 default:
1dd31b6c
ZY		 4933 IPW_DEBUG_NOTIF("Unknown notification: "
4934 "subtype=%d,flags=0x%2x,size=%d\n",
e62e1ee0 4935 notif->subtype, notif->flags, size);
43f66a6c
JK		 4936 }
4937}
4938
4939/**
4940 * Destroys all DMA structures and initialise them again
bf79451e 4941 *
43f66a6c
JK		 4942 * @param priv
4943 * @return error code
4944 */
4945static int ipw_queue_reset(struct ipw_priv *priv)
4946{
4947 int rc = 0;
4948 /** @todo customize queue sizes */
4949 int nTx = 64, nTxCmd = 8;
4950 ipw_tx_queue_free(priv);
4951 /* Tx CMD queue */
4952 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
b095c381
JK		 4953 IPW_TX_CMD_QUEUE_READ_INDEX,
4954 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4955 IPW_TX_CMD_QUEUE_BD_BASE,
4956 IPW_TX_CMD_QUEUE_BD_SIZE);
43f66a6c
JK		 4957 if (rc) {
4958 IPW_ERROR("Tx Cmd queue init failed\n");
4959 goto error;
4960 }
4961 /* Tx queue(s) */
4962 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
b095c381
JK		 4963 IPW_TX_QUEUE_0_READ_INDEX,
4964 IPW_TX_QUEUE_0_WRITE_INDEX,
4965 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
43f66a6c
JK		 4966 if (rc) {
4967 IPW_ERROR("Tx 0 queue init failed\n");
4968 goto error;
4969 }
4970 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
b095c381
JK		 4971 IPW_TX_QUEUE_1_READ_INDEX,
4972 IPW_TX_QUEUE_1_WRITE_INDEX,
4973 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
43f66a6c
JK		 4974 if (rc) {
4975 IPW_ERROR("Tx 1 queue init failed\n");
4976 goto error;
4977 }
4978 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
b095c381
JK		 4979 IPW_TX_QUEUE_2_READ_INDEX,
4980 IPW_TX_QUEUE_2_WRITE_INDEX,
4981 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
43f66a6c
JK		 4982 if (rc) {
4983 IPW_ERROR("Tx 2 queue init failed\n");
4984 goto error;
4985 }
4986 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
b095c381
JK		 4987 IPW_TX_QUEUE_3_READ_INDEX,
4988 IPW_TX_QUEUE_3_WRITE_INDEX,
4989 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
43f66a6c
JK		 4990 if (rc) {
4991 IPW_ERROR("Tx 3 queue init failed\n");
4992 goto error;
4993 }
4994 /* statistics */
4995 priv->rx_bufs_min = 0;
4996 priv->rx_pend_max = 0;
4997 return rc;
4998
0edd5b44 4999 error:
43f66a6c
JK		 5000 ipw_tx_queue_free(priv);
5001 return rc;
5002}
5003
5004/**
5005 * Reclaim Tx queue entries no more used by NIC.
bf79451e 5006 *
8ff9d21e 5007 * When FW advances 'R' index, all entries between old and
43f66a6c
JK		 5008 * new 'R' index need to be reclaimed. As result, some free space
5009 * forms. If there is enough free space (> low mark), wake Tx queue.
bf79451e 5010 *
43f66a6c
JK		 5011 * @note Need to protect against garbage in 'R' index
5012 * @param priv
5013 * @param txq
5014 * @param qindex
5015 * @return Number of used entries remains in the queue
5016 */
bf79451e 5017static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
43f66a6c
JK		 5018 struct clx2_tx_queue *txq, int qindex)
5019{
5020 u32 hw_tail;
5021 int used;
5022 struct clx2_queue *q = &txq->q;
5023
5024 hw_tail = ipw_read32(priv, q->reg_r);
5025 if (hw_tail >= q->n_bd) {
5026 IPW_ERROR
0edd5b44
JG		 5027 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
5028 hw_tail, q->n_bd);
43f66a6c
JK		 5029 goto done;
5030 }
5031 for (; q->last_used != hw_tail;
5032 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
5033 ipw_queue_tx_free_tfd(priv, txq);
5034 priv->tx_packets++;
5035 }
0edd5b44 5036 done:
943dbef4 5037 if ((ipw_tx_queue_space(q) > q->low_mark) &&
521c4d96 5038 (qindex >= 0))
9ddf84f6 5039 netif_wake_queue(priv->net_dev);
43f66a6c
JK		 5040 used = q->first_empty - q->last_used;
5041 if (used < 0)
5042 used += q->n_bd;
5043
5044 return used;
5045}
5046
5047static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
5048 int len, int sync)
5049{
5050 struct clx2_tx_queue *txq = &priv->txq_cmd;
5051 struct clx2_queue *q = &txq->q;
5052 struct tfd_frame *tfd;
5053
943dbef4 5054 if (ipw_tx_queue_space(q) < (sync ? 1 : 2)) {
43f66a6c
JK		 5055 IPW_ERROR("No space for Tx\n");
5056 return -EBUSY;
5057 }
5058
5059 tfd = &txq->bd[q->first_empty];
5060 txq->txb[q->first_empty] = NULL;
5061
5062 memset(tfd, 0, sizeof(*tfd));
5063 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
5064 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
5065 priv->hcmd_seq++;
5066 tfd->u.cmd.index = hcmd;
5067 tfd->u.cmd.length = len;
5068 memcpy(tfd->u.cmd.payload, buf, len);
5069 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
5070 ipw_write32(priv, q->reg_w, q->first_empty);
5071 _ipw_read32(priv, 0x90);
5072
5073 return 0;
5074}
5075
bf79451e 5076/*
43f66a6c
JK		 5077 * Rx theory of operation
5078 *
5079 * The host allocates 32 DMA target addresses and passes the host address
b095c381 5080 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
43f66a6c
JK		 5081 * 0 to 31
5082 *
5083 * Rx Queue Indexes
5084 * The host/firmware share two index registers for managing the Rx buffers.
5085 *
bf79451e
JG		 5086 * The READ index maps to the first position that the firmware may be writing
5087 * to -- the driver can read up to (but not including) this position and get
5088 * good data.
43f66a6c
JK		 5089 * The READ index is managed by the firmware once the card is enabled.
5090 *
5091 * The WRITE index maps to the last position the driver has read from -- the
5092 * position preceding WRITE is the last slot the firmware can place a packet.
5093 *
5094 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
bf79451e 5095 * WRITE = READ.
43f66a6c 5096 *
bf79451e 5097 * During initialization the host sets up the READ queue position to the first
43f66a6c
JK		 5098 * INDEX position, and WRITE to the last (READ - 1 wrapped)
5099 *
5100 * When the firmware places a packet in a buffer it will advance the READ index
5101 * and fire the RX interrupt. The driver can then query the READ index and
5102 * process as many packets as possible, moving the WRITE index forward as it
5103 * resets the Rx queue buffers with new memory.
bf79451e 5104 *
43f66a6c 5105 * The management in the driver is as follows:
bf79451e 5106 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
43f66a6c 5107 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
bf79451e 5108 * to replensish the ipw->rxq->rx_free.
43f66a6c
JK		 5109 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
5110 * ipw->rxq is replenished and the READ INDEX is updated (updating the
5111 * 'processed' and 'read' driver indexes as well)
5112 * + A received packet is processed and handed to the kernel network stack,
5113 * detached from the ipw->rxq. The driver 'processed' index is updated.
5114 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
bf79451e
JG		 5115 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
5116 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
43f66a6c
JK		 5117 * were enough free buffers and RX_STALLED is set it is cleared.
5118 *
5119 *
5120 * Driver sequence:
5121 *
bf79451e 5122 * ipw_rx_queue_alloc() Allocates rx_free
43f66a6c
JK		 5123 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
5124 * ipw_rx_queue_restock
5125 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
5126 * queue, updates firmware pointers, and updates
5127 * the WRITE index. If insufficient rx_free buffers
5128 * are available, schedules ipw_rx_queue_replenish
5129 *
5130 * -- enable interrupts --
5131 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
bf79451e 5132 * READ INDEX, detaching the SKB from the pool.
43f66a6c
JK		 5133 * Moves the packet buffer from queue to rx_used.
5134 * Calls ipw_rx_queue_restock to refill any empty
5135 * slots.
5136 * ...
5137 *
5138 */
5139
bf79451e 5140/*
43f66a6c
JK		 5141 * If there are slots in the RX queue that need to be restocked,
5142 * and we have free pre-allocated buffers, fill the ranks as much
5143 * as we can pulling from rx_free.
5144 *
5145 * This moves the 'write' index forward to catch up with 'processed', and
5146 * also updates the memory address in the firmware to reference the new
5147 * target buffer.
5148 */
5149static void ipw_rx_queue_restock(struct ipw_priv *priv)
5150{
5151 struct ipw_rx_queue *rxq = priv->rxq;
5152 struct list_head *element;
5153 struct ipw_rx_mem_buffer *rxb;
5154 unsigned long flags;
5155 int write;
5156
5157 spin_lock_irqsave(&rxq->lock, flags);
5158 write = rxq->write;
943dbef4 5159 while ((ipw_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
43f66a6c
JK		 5160 element = rxq->rx_free.next;
5161 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
5162 list_del(element);
5163
b095c381 5164 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
43f66a6c
JK		 5165 rxb->dma_addr);
5166 rxq->queue[rxq->write] = rxb;
5167 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
5168 rxq->free_count--;
5169 }
5170 spin_unlock_irqrestore(&rxq->lock, flags);
5171
bf79451e 5172 /* If the pre-allocated buffer pool is dropping low, schedule to
43f66a6c
JK		 5173 * refill it */
5174 if (rxq->free_count <= RX_LOW_WATERMARK)
bcb6d916 5175 schedule_work(&priv->rx_replenish);
43f66a6c
JK		 5176
5177 /* If we've added more space for the firmware to place data, tell it */
bf79451e 5178 if (write != rxq->write)
b095c381 5179 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
43f66a6c
JK		 5180}
5181
5182/*
5183 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
bf79451e
JG		 5184 * Also restock the Rx queue via ipw_rx_queue_restock.
5185 *
43f66a6c
JK		 5186 * This is called as a scheduled work item (except for during intialization)
5187 */
5188static void ipw_rx_queue_replenish(void *data)
5189{
5190 struct ipw_priv *priv = data;
5191 struct ipw_rx_queue *rxq = priv->rxq;
5192 struct list_head *element;
5193 struct ipw_rx_mem_buffer *rxb;
5194 unsigned long flags;
5195
5196 spin_lock_irqsave(&rxq->lock, flags);
5197 while (!list_empty(&rxq->rx_used)) {
5198 element = rxq->rx_used.next;
5199 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
b095c381 5200 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
43f66a6c
JK		 5201 if (!rxb->skb) {
5202 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
5203 priv->net_dev->name);
5204 /* We don't reschedule replenish work here -- we will
5205 * call the restock method and if it still needs
5206 * more buffers it will schedule replenish */
5207 break;
5208 }
5209 list_del(element);
bf79451e 5210
0edd5b44
JG		 5211 rxb->dma_addr =
5212 pci_map_single(priv->pci_dev, rxb->skb->data,
b095c381 5213 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
bf79451e 5214
43f66a6c
JK		 5215 list_add_tail(&rxb->list, &rxq->rx_free);
5216 rxq->free_count++;
5217 }
5218 spin_unlock_irqrestore(&rxq->lock, flags);
5219
5220 ipw_rx_queue_restock(priv);
5221}
5222
c4028958 5223static void ipw_bg_rx_queue_replenish(struct work_struct *work)
c848d0af 5224{
c4028958
DH		 5225 struct ipw_priv *priv =
5226 container_of(work, struct ipw_priv, rx_replenish);
4644151b 5227 mutex_lock(&priv->mutex);
c4028958 5228 ipw_rx_queue_replenish(priv);
4644151b 5229 mutex_unlock(&priv->mutex);
c848d0af
JK		 5230}
5231
43f66a6c 5232/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
c7b6a674 5233 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
bf79451e 5234 * This free routine walks the list of POOL entries and if SKB is set to
43f66a6c
JK		 5235 * non NULL it is unmapped and freed
5236 */
0edd5b44 5237static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
43f66a6c
JK		 5238{
5239 int i;
5240
5241 if (!rxq)
5242 return;
bf79451e 5243
43f66a6c
JK		 5244 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
5245 if (rxq->pool[i].skb != NULL) {
5246 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
b095c381 5247 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c
JK		 5248 dev_kfree_skb(rxq->pool[i].skb);
5249 }
5250 }
5251
5252 kfree(rxq);
5253}
5254
5255static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
5256{
5257 struct ipw_rx_queue *rxq;
5258 int i;
5259
c75f4742 5260 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
ad18b0ea
PI		 5261 if (unlikely(!rxq)) {
5262 IPW_ERROR("memory allocation failed\n");
5263 return NULL;
5264 }
43f66a6c
JK		 5265 spin_lock_init(&rxq->lock);
5266 INIT_LIST_HEAD(&rxq->rx_free);
5267 INIT_LIST_HEAD(&rxq->rx_used);
5268
5269 /* Fill the rx_used queue with _all_ of the Rx buffers */
bf79451e 5270 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
43f66a6c
JK		 5271 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
5272
5273 /* Set us so that we have processed and used all buffers, but have
5274 * not restocked the Rx queue with fresh buffers */
5275 rxq->read = rxq->write = 0;
43f66a6c
JK		 5276 rxq->free_count = 0;
5277
5278 return rxq;
5279}
5280
5281static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
5282{
b0a4e7d8 5283 rate &= ~LIBIPW_BASIC_RATE_MASK;
43f66a6c
JK		 5284 if (ieee_mode == IEEE_A) {
5285 switch (rate) {
b0a4e7d8
JL		 5286 case LIBIPW_OFDM_RATE_6MB:
5287 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ?
0edd5b44 5288 1 : 0;
b0a4e7d8
JL		 5289 case LIBIPW_OFDM_RATE_9MB:
5290 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ?
0edd5b44 5291 1 : 0;
b0a4e7d8 5292 case LIBIPW_OFDM_RATE_12MB:
0edd5b44 5293 return priv->
b0a4e7d8
JL		 5294 rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5295 case LIBIPW_OFDM_RATE_18MB:
0edd5b44 5296 return priv->
b0a4e7d8
JL		 5297 rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5298 case LIBIPW_OFDM_RATE_24MB:
0edd5b44 5299 return priv->
b0a4e7d8
JL		 5300 rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5301 case LIBIPW_OFDM_RATE_36MB:
0edd5b44 5302 return priv->
b0a4e7d8
JL		 5303 rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5304 case LIBIPW_OFDM_RATE_48MB:
0edd5b44 5305 return priv->
b0a4e7d8
JL		 5306 rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5307 case LIBIPW_OFDM_RATE_54MB:
0edd5b44 5308 return priv->
b0a4e7d8 5309 rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
43f66a6c
JK		 5310 default:
5311 return 0;
5312 }
5313 }
bf79451e 5314
43f66a6c
JK		 5315 /* B and G mixed */
5316 switch (rate) {
b0a4e7d8
JL		 5317 case LIBIPW_CCK_RATE_1MB:
5318 return priv->rates_mask & LIBIPW_CCK_RATE_1MB_MASK ? 1 : 0;
5319 case LIBIPW_CCK_RATE_2MB:
5320 return priv->rates_mask & LIBIPW_CCK_RATE_2MB_MASK ? 1 : 0;
5321 case LIBIPW_CCK_RATE_5MB:
5322 return priv->rates_mask & LIBIPW_CCK_RATE_5MB_MASK ? 1 : 0;
5323 case LIBIPW_CCK_RATE_11MB:
5324 return priv->rates_mask & LIBIPW_CCK_RATE_11MB_MASK ? 1 : 0;
43f66a6c
JK		 5325 }
5326
5327 /* If we are limited to B modulations, bail at this point */
5328 if (ieee_mode == IEEE_B)
5329 return 0;
5330
5331 /* G */
5332 switch (rate) {
b0a4e7d8
JL		 5333 case LIBIPW_OFDM_RATE_6MB:
5334 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ? 1 : 0;
5335 case LIBIPW_OFDM_RATE_9MB:
5336 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ? 1 : 0;
5337 case LIBIPW_OFDM_RATE_12MB:
5338 return priv->rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5339 case LIBIPW_OFDM_RATE_18MB:
5340 return priv->rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5341 case LIBIPW_OFDM_RATE_24MB:
5342 return priv->rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5343 case LIBIPW_OFDM_RATE_36MB:
5344 return priv->rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5345 case LIBIPW_OFDM_RATE_48MB:
5346 return priv->rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5347 case LIBIPW_OFDM_RATE_54MB:
5348 return priv->rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
43f66a6c
JK		 5349 }
5350
5351 return 0;
5352}
5353
bf79451e 5354static int ipw_compatible_rates(struct ipw_priv *priv,
b0a4e7d8 5355 const struct libipw_network *network,
43f66a6c
JK		 5356 struct ipw_supported_rates *rates)
5357{
5358 int num_rates, i;
5359
5360 memset(rates, 0, sizeof(*rates));
0edd5b44 5361 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
43f66a6c
JK		 5362 rates->num_rates = 0;
5363 for (i = 0; i < num_rates; i++) {
a613bffd
JK		 5364 if (!ipw_is_rate_in_mask(priv, network->mode,
5365 network->rates[i])) {
5366
b0a4e7d8 5367 if (network->rates[i] & LIBIPW_BASIC_RATE_MASK) {
a613bffd
JK		 5368 IPW_DEBUG_SCAN("Adding masked mandatory "
5369 "rate %02X\n",
5370 network->rates[i]);
5371 rates->supported_rates[rates->num_rates++] =
5372 network->rates[i];
5373 continue;
ea2b26e0
JK		 5374 }
5375
43f66a6c
JK		 5376 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5377 network->rates[i], priv->rates_mask);
5378 continue;
5379 }
bf79451e 5380
43f66a6c
JK		 5381 rates->supported_rates[rates->num_rates++] = network->rates[i];
5382 }
5383
a613bffd
JK		 5384 num_rates = min(network->rates_ex_len,
5385 (u8) (IPW_MAX_RATES - num_rates));
43f66a6c 5386 for (i = 0; i < num_rates; i++) {
a613bffd
JK		 5387 if (!ipw_is_rate_in_mask(priv, network->mode,
5388 network->rates_ex[i])) {
b0a4e7d8 5389 if (network->rates_ex[i] & LIBIPW_BASIC_RATE_MASK) {
a613bffd
JK		 5390 IPW_DEBUG_SCAN("Adding masked mandatory "
5391 "rate %02X\n",
5392 network->rates_ex[i]);
5393 rates->supported_rates[rates->num_rates++] =
5394 network->rates[i];
5395 continue;
ea2b26e0
JK		 5396 }
5397
43f66a6c
JK		 5398 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5399 network->rates_ex[i], priv->rates_mask);
5400 continue;
5401 }
bf79451e 5402
0edd5b44
JG		 5403 rates->supported_rates[rates->num_rates++] =
5404 network->rates_ex[i];
43f66a6c
JK		 5405 }
5406
ea2b26e0 5407 return 1;
43f66a6c
JK		 5408}
5409
858119e1 5410static void ipw_copy_rates(struct ipw_supported_rates *dest,
43f66a6c
JK		 5411 const struct ipw_supported_rates *src)
5412{
5413 u8 i;
5414 for (i = 0; i < src->num_rates; i++)
5415 dest->supported_rates[i] = src->supported_rates[i];
5416 dest->num_rates = src->num_rates;
5417}
5418
5419/* TODO: Look at sniffed packets in the air to determine if the basic rate
5420 * mask should ever be used -- right now all callers to add the scan rates are
5421 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5422static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
0edd5b44 5423 u8 modulation, u32 rate_mask)
43f66a6c 5424{
b0a4e7d8
JL		 5425 u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5426 LIBIPW_BASIC_RATE_MASK : 0;
bf79451e 5427
b0a4e7d8 5428 if (rate_mask & LIBIPW_CCK_RATE_1MB_MASK)
bf79451e 5429 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5430 LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_1MB;
43f66a6c 5431
b0a4e7d8 5432 if (rate_mask & LIBIPW_CCK_RATE_2MB_MASK)
bf79451e 5433 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5434 LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_2MB;
43f66a6c 5435
b0a4e7d8 5436 if (rate_mask & LIBIPW_CCK_RATE_5MB_MASK)
bf79451e 5437 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5438 LIBIPW_CCK_RATE_5MB;
43f66a6c 5439
b0a4e7d8 5440 if (rate_mask & LIBIPW_CCK_RATE_11MB_MASK)
bf79451e 5441 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5442 LIBIPW_CCK_RATE_11MB;
43f66a6c
JK		 5443}
5444
5445static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
0edd5b44 5446 u8 modulation, u32 rate_mask)
43f66a6c 5447{
b0a4e7d8
JL		 5448 u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5449 LIBIPW_BASIC_RATE_MASK : 0;
43f66a6c 5450
b0a4e7d8 5451 if (rate_mask & LIBIPW_OFDM_RATE_6MB_MASK)
bf79451e 5452 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5453 LIBIPW_OFDM_RATE_6MB;
43f66a6c 5454
b0a4e7d8 5455 if (rate_mask & LIBIPW_OFDM_RATE_9MB_MASK)
bf79451e 5456 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5457 LIBIPW_OFDM_RATE_9MB;
43f66a6c 5458
b0a4e7d8 5459 if (rate_mask & LIBIPW_OFDM_RATE_12MB_MASK)
bf79451e 5460 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5461 LIBIPW_OFDM_RATE_12MB;
43f66a6c 5462
b0a4e7d8 5463 if (rate_mask & LIBIPW_OFDM_RATE_18MB_MASK)
bf79451e 5464 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5465 LIBIPW_OFDM_RATE_18MB;
43f66a6c 5466
b0a4e7d8 5467 if (rate_mask & LIBIPW_OFDM_RATE_24MB_MASK)
bf79451e 5468 rates->supported_rates[rates->num_rates++] = basic_mask |
b0a4e7d8 5469 LIBIPW_OFDM_RATE_24MB;
43f66a6c 5470
b0a4e7d8 5471 if (rate_mask & LIBIPW_OFDM_RATE_36MB_MASK)
bf79451e 5472 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5473 LIBIPW_OFDM_RATE_36MB;
43f66a6c 5474
b0a4e7d8 5475 if (rate_mask & LIBIPW_OFDM_RATE_48MB_MASK)
bf79451e 5476 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5477 LIBIPW_OFDM_RATE_48MB;
43f66a6c 5478
b0a4e7d8 5479 if (rate_mask & LIBIPW_OFDM_RATE_54MB_MASK)
bf79451e 5480 rates->supported_rates[rates->num_rates++] =
b0a4e7d8 5481 LIBIPW_OFDM_RATE_54MB;
43f66a6c
JK		 5482}
5483
5484struct ipw_network_match {
b0a4e7d8 5485 struct libipw_network *network;
43f66a6c
JK		 5486 struct ipw_supported_rates rates;
5487};
5488
c848d0af
JK		 5489static int ipw_find_adhoc_network(struct ipw_priv *priv,
5490 struct ipw_network_match *match,
b0a4e7d8 5491 struct libipw_network *network,
c848d0af 5492 int roaming)
43f66a6c
JK		 5493{
5494 struct ipw_supported_rates rates;
9387b7ca 5495 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 5496
5497 /* Verify that this network's capability is compatible with the
5498 * current mode (AdHoc or Infrastructure) */
c848d0af 5499 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
43f66a6c 5500 !(network->capability & WLAN_CAPABILITY_IBSS))) {
e174961c 5501 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded due to "
bf79451e 5502 "capability mismatch.\n",
9387b7ca
JL		 5503 print_ssid(ssid, network->ssid,
5504 network->ssid_len),
e174961c 5505 network->bssid);
43f66a6c
JK		 5506 return 0;
5507 }
5508
43f66a6c
JK		 5509 if (unlikely(roaming)) {
5510 /* If we are roaming, then ensure check if this is a valid
5511 * network to try and roam to */
5512 if ((network->ssid_len != match->network->ssid_len) ||
bf79451e 5513 memcmp(network->ssid, match->network->ssid,
43f66a6c 5514 network->ssid_len)) {
e174961c 5515 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c 5516 "because of non-network ESSID.\n",
9387b7ca
JL		 5517 print_ssid(ssid, network->ssid,
5518 network->ssid_len),
e174961c 5519 network->bssid);
43f66a6c
JK		 5520 return 0;
5521 }
5522 } else {
bf79451e
JG		 5523 /* If an ESSID has been configured then compare the broadcast
5524 * ESSID to ours */
5525 if ((priv->config & CFG_STATIC_ESSID) &&
43f66a6c 5526 ((network->ssid_len != priv->essid_len) ||
bf79451e 5527 memcmp(network->ssid, priv->essid,
43f66a6c
JK		 5528 min(network->ssid_len, priv->essid_len)))) {
5529 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
afbf30a2 5530
0edd5b44 5531 strncpy(escaped,
9387b7ca
JL		 5532 print_ssid(ssid, network->ssid,
5533 network->ssid_len),
43f66a6c 5534 sizeof(escaped));
e174961c 5535 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
bf79451e 5536 "because of ESSID mismatch: '%s'.\n",
e174961c 5537 escaped, network->bssid,
9387b7ca
JL		 5538 print_ssid(ssid, priv->essid,
5539 priv->essid_len));
43f66a6c
JK		 5540 return 0;
5541 }
5542 }
5543
5544 /* If the old network rate is better than this one, don't bother
5545 * testing everything else. */
c848d0af
JK		 5546
5547 if (network->time_stamp[0] < match->network->time_stamp[0]) {
afbf30a2
JK		 5548 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5549 "current network.\n",
9387b7ca
JL		 5550 print_ssid(ssid, match->network->ssid,
5551 match->network->ssid_len));
43f66a6c 5552 return 0;
c848d0af 5553 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
afbf30a2
JK		 5554 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5555 "current network.\n",
9387b7ca
JL		 5556 print_ssid(ssid, match->network->ssid,
5557 match->network->ssid_len));
43f66a6c
JK		 5558 return 0;
5559 }
5560
5561 /* Now go through and see if the requested network is valid... */
bf79451e 5562 if (priv->ieee->scan_age != 0 &&
c848d0af 5563 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
e174961c 5564 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
c7b6a674 5565 "because of age: %ums.\n",
9387b7ca
JL		 5566 print_ssid(ssid, network->ssid,
5567 network->ssid_len),
e174961c 5568 network->bssid,
2638bc39
ZY		 5569 jiffies_to_msecs(jiffies -
5570 network->last_scanned));
43f66a6c 5571 return 0;
bf79451e 5572 }
43f66a6c 5573
bf79451e 5574 if ((priv->config & CFG_STATIC_CHANNEL) &&
43f66a6c 5575 (network->channel != priv->channel)) {
e174961c 5576 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c 5577 "because of channel mismatch: %d != %d.\n",
9387b7ca
JL		 5578 print_ssid(ssid, network->ssid,
5579 network->ssid_len),
e174961c 5580 network->bssid,
43f66a6c
JK		 5581 network->channel, priv->channel);
5582 return 0;
5583 }
bf79451e 5584
25985edc 5585 /* Verify privacy compatibility */
bf79451e 5586 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
43f66a6c 5587 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
e174961c 5588 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c 5589 "because of privacy mismatch: %s != %s.\n",
9387b7ca
JL		 5590 print_ssid(ssid, network->ssid,
5591 network->ssid_len),
e174961c 5592 network->bssid,
afbf30a2
JK		 5593 priv->
5594 capability & CAP_PRIVACY_ON ? "on" : "off",
5595 network->
5596 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5597 "off");
43f66a6c
JK		 5598 return 0;
5599 }
bf79451e 5600
c848d0af 5601 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
e174961c
JB		 5602 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
5603 "because of the same BSSID match: %pM"
9387b7ca
JL		 5604 ".\n", print_ssid(ssid, network->ssid,
5605 network->ssid_len),
e174961c
JB		 5606 network->bssid,
5607 priv->bssid);
43f66a6c
JK		 5608 return 0;
5609 }
bf79451e 5610
43f66a6c 5611 /* Filter out any incompatible freq / mode combinations */
b0a4e7d8 5612 if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
e174961c 5613 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c
JK		 5614 "because of invalid frequency/mode "
5615 "combination.\n",
9387b7ca
JL		 5616 print_ssid(ssid, network->ssid,
5617 network->ssid_len),
e174961c 5618 network->bssid);
43f66a6c
JK		 5619 return 0;
5620 }
bf79451e 5621
c848d0af
JK		 5622 /* Ensure that the rates supported by the driver are compatible with
5623 * this AP, including verification of basic rates (mandatory) */
5624 if (!ipw_compatible_rates(priv, network, &rates)) {
e174961c 5625 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
c848d0af
JK		 5626 "because configured rate mask excludes "
5627 "AP mandatory rate.\n",
9387b7ca
JL		 5628 print_ssid(ssid, network->ssid,
5629 network->ssid_len),
e174961c 5630 network->bssid);
c848d0af
JK		 5631 return 0;
5632 }
5633
43f66a6c 5634 if (rates.num_rates == 0) {
e174961c 5635 IPW_DEBUG_MERGE("Network '%s (%pM)' excluded "
43f66a6c 5636 "because of no compatible rates.\n",
9387b7ca
JL		 5637 print_ssid(ssid, network->ssid,
5638 network->ssid_len),
e174961c 5639 network->bssid);
43f66a6c
JK		 5640 return 0;
5641 }
bf79451e 5642
43f66a6c
JK		 5643 /* TODO: Perform any further minimal comparititive tests. We do not
5644 * want to put too much policy logic here; intelligent scan selection
5645 * should occur within a generic IEEE 802.11 user space tool. */
5646
5647 /* Set up 'new' AP to this network */
5648 ipw_copy_rates(&match->rates, &rates);
5649 match->network = network;
e174961c 5650 IPW_DEBUG_MERGE("Network '%s (%pM)' is a viable match.\n",
9387b7ca 5651 print_ssid(ssid, network->ssid, network->ssid_len),
e174961c 5652 network->bssid);
43f66a6c
JK		 5653
5654 return 1;
5655}
5656
c4028958 5657static void ipw_merge_adhoc_network(struct work_struct *work)
43f66a6c 5658{
9387b7ca 5659 DECLARE_SSID_BUF(ssid);
c4028958
DH		 5660 struct ipw_priv *priv =
5661 container_of(work, struct ipw_priv, merge_networks);
b0a4e7d8 5662 struct libipw_network *network = NULL;
c848d0af
JK		 5663 struct ipw_network_match match = {
5664 .network = priv->assoc_network
5665 };
5666
afbf30a2
JK		 5667 if ((priv->status & STATUS_ASSOCIATED) &&
5668 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
c848d0af
JK		 5669 /* First pass through ROAM process -- look for a better
5670 * network */
5671 unsigned long flags;
5672
5673 spin_lock_irqsave(&priv->ieee->lock, flags);
5674 list_for_each_entry(network, &priv->ieee->network_list, list) {
5675 if (network != priv->assoc_network)
5676 ipw_find_adhoc_network(priv, &match, network,
5677 1);
5678 }
5679 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5680
5681 if (match.network == priv->assoc_network) {
5682 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5683 "merge to.\n");
5684 return;
5685 }
5686
4644151b 5687 mutex_lock(&priv->mutex);
c848d0af
JK		 5688 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5689 IPW_DEBUG_MERGE("remove network %s\n",
9387b7ca
JL		 5690 print_ssid(ssid, priv->essid,
5691 priv->essid_len));
c848d0af 5692 ipw_remove_current_network(priv);
43f66a6c 5693 }
c848d0af
JK		 5694
5695 ipw_disassociate(priv);
5696 priv->assoc_network = match.network;
4644151b 5697 mutex_unlock(&priv->mutex);
c848d0af 5698 return;
43f66a6c 5699 }
c848d0af 5700}
43f66a6c 5701
0edd5b44
JG		 5702static int ipw_best_network(struct ipw_priv *priv,
5703 struct ipw_network_match *match,
b0a4e7d8 5704 struct libipw_network *network, int roaming)
43f66a6c
JK		 5705{
5706 struct ipw_supported_rates rates;
9387b7ca 5707 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 5708
5709 /* Verify that this network's capability is compatible with the
5710 * current mode (AdHoc or Infrastructure) */
5711 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
2474385e 5712 !(network->capability & WLAN_CAPABILITY_ESS)) ||
43f66a6c
JK		 5713 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5714 !(network->capability & WLAN_CAPABILITY_IBSS))) {
e174961c 5715 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded due to "
bf79451e 5716 "capability mismatch.\n",
9387b7ca
JL		 5717 print_ssid(ssid, network->ssid,
5718 network->ssid_len),
e174961c 5719 network->bssid);
43f66a6c
JK		 5720 return 0;
5721 }
5722
43f66a6c
JK		 5723 if (unlikely(roaming)) {
5724 /* If we are roaming, then ensure check if this is a valid
5725 * network to try and roam to */
5726 if ((network->ssid_len != match->network->ssid_len) ||
bf79451e 5727 memcmp(network->ssid, match->network->ssid,
43f66a6c 5728 network->ssid_len)) {
e174961c 5729 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c 5730 "because of non-network ESSID.\n",
9387b7ca
JL		 5731 print_ssid(ssid, network->ssid,
5732 network->ssid_len),
e174961c 5733 network->bssid);
43f66a6c
JK		 5734 return 0;
5735 }
5736 } else {
bf79451e
JG		 5737 /* If an ESSID has been configured then compare the broadcast
5738 * ESSID to ours */
5739 if ((priv->config & CFG_STATIC_ESSID) &&
43f66a6c 5740 ((network->ssid_len != priv->essid_len) ||
bf79451e 5741 memcmp(network->ssid, priv->essid,
43f66a6c
JK		 5742 min(network->ssid_len, priv->essid_len)))) {
5743 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
0edd5b44 5744 strncpy(escaped,
9387b7ca
JL		 5745 print_ssid(ssid, network->ssid,
5746 network->ssid_len),
43f66a6c 5747 sizeof(escaped));
e174961c 5748 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
bf79451e 5749 "because of ESSID mismatch: '%s'.\n",
e174961c 5750 escaped, network->bssid,
9387b7ca
JL		 5751 print_ssid(ssid, priv->essid,
5752 priv->essid_len));
43f66a6c
JK		 5753 return 0;
5754 }
5755 }
5756
5757 /* If the old network rate is better than this one, don't bother
5758 * testing everything else. */
0edd5b44 5759 if (match->network && match->network->stats.rssi > network->stats.rssi) {
43f66a6c 5760 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
bf79451e 5761 strncpy(escaped,
9387b7ca 5762 print_ssid(ssid, network->ssid, network->ssid_len),
43f66a6c 5763 sizeof(escaped));
e174961c
JB		 5764 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded because "
5765 "'%s (%pM)' has a stronger signal.\n",
5766 escaped, network->bssid,
9387b7ca
JL		 5767 print_ssid(ssid, match->network->ssid,
5768 match->network->ssid_len),
e174961c 5769 match->network->bssid);
43f66a6c
JK		 5770 return 0;
5771 }
bf79451e 5772
43f66a6c
JK		 5773 /* If this network has already had an association attempt within the
5774 * last 3 seconds, do not try and associate again... */
5775 if (network->last_associate &&
ea2b26e0 5776 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
e174961c 5777 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
c7b6a674 5778 "because of storming (%ums since last "
43f66a6c 5779 "assoc attempt).\n",
9387b7ca
JL		 5780 print_ssid(ssid, network->ssid,
5781 network->ssid_len),
e174961c 5782 network->bssid,
2638bc39
ZY		 5783 jiffies_to_msecs(jiffies -
5784 network->last_associate));
43f66a6c
JK		 5785 return 0;
5786 }
5787
5788 /* Now go through and see if the requested network is valid... */
bf79451e 5789 if (priv->ieee->scan_age != 0 &&
ea2b26e0 5790 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
e174961c 5791 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
c7b6a674 5792 "because of age: %ums.\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_scanned));
43f66a6c 5798 return 0;
bf79451e 5799 }
43f66a6c 5800
bf79451e 5801 if ((priv->config & CFG_STATIC_CHANNEL) &&
43f66a6c 5802 (network->channel != priv->channel)) {
e174961c 5803 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c 5804 "because of channel mismatch: %d != %d.\n",
9387b7ca
JL		 5805 print_ssid(ssid, network->ssid,
5806 network->ssid_len),
e174961c 5807 network->bssid,
43f66a6c
JK		 5808 network->channel, priv->channel);
5809 return 0;
5810 }
bf79451e 5811
25985edc 5812 /* Verify privacy compatibility */
bf79451e 5813 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
43f66a6c 5814 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
e174961c 5815 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c 5816 "because of privacy mismatch: %s != %s.\n",
9387b7ca
JL		 5817 print_ssid(ssid, network->ssid,
5818 network->ssid_len),
e174961c 5819 network->bssid,
bf79451e 5820 priv->capability & CAP_PRIVACY_ON ? "on" :
43f66a6c 5821 "off",
bf79451e 5822 network->capability &
0edd5b44 5823 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
43f66a6c
JK		 5824 return 0;
5825 }
bf79451e
JG		 5826
5827 if ((priv->config & CFG_STATIC_BSSID) &&
43f66a6c 5828 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
e174961c
JB		 5829 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
5830 "because of BSSID mismatch: %pM.\n",
9387b7ca
JL		 5831 print_ssid(ssid, network->ssid,
5832 network->ssid_len),
e174961c 5833 network->bssid, priv->bssid);
43f66a6c
JK		 5834 return 0;
5835 }
bf79451e 5836
43f66a6c 5837 /* Filter out any incompatible freq / mode combinations */
b0a4e7d8 5838 if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
e174961c 5839 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c
JK		 5840 "because of invalid frequency/mode "
5841 "combination.\n",
9387b7ca
JL		 5842 print_ssid(ssid, network->ssid,
5843 network->ssid_len),
e174961c 5844 network->bssid);
43f66a6c
JK		 5845 return 0;
5846 }
bf79451e 5847
1fe0adb4 5848 /* Filter out invalid channel in current GEO */
b0a4e7d8 5849 if (!libipw_is_valid_channel(priv->ieee, network->channel)) {
e174961c 5850 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
1fe0adb4 5851 "because of invalid channel in current GEO\n",
9387b7ca
JL		 5852 print_ssid(ssid, network->ssid,
5853 network->ssid_len),
e174961c 5854 network->bssid);
1fe0adb4
LH		 5855 return 0;
5856 }
5857
ea2b26e0
JK		 5858 /* Ensure that the rates supported by the driver are compatible with
5859 * this AP, including verification of basic rates (mandatory) */
5860 if (!ipw_compatible_rates(priv, network, &rates)) {
e174961c 5861 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
ea2b26e0
JK		 5862 "because configured rate mask excludes "
5863 "AP mandatory rate.\n",
9387b7ca
JL		 5864 print_ssid(ssid, network->ssid,
5865 network->ssid_len),
e174961c 5866 network->bssid);
ea2b26e0
JK		 5867 return 0;
5868 }
5869
43f66a6c 5870 if (rates.num_rates == 0) {
e174961c 5871 IPW_DEBUG_ASSOC("Network '%s (%pM)' excluded "
43f66a6c 5872 "because of no compatible rates.\n",
9387b7ca
JL		 5873 print_ssid(ssid, network->ssid,
5874 network->ssid_len),
e174961c 5875 network->bssid);
43f66a6c
JK		 5876 return 0;
5877 }
bf79451e 5878
43f66a6c
JK		 5879 /* TODO: Perform any further minimal comparititive tests. We do not
5880 * want to put too much policy logic here; intelligent scan selection
5881 * should occur within a generic IEEE 802.11 user space tool. */
5882
5883 /* Set up 'new' AP to this network */
5884 ipw_copy_rates(&match->rates, &rates);
5885 match->network = network;
5886
e174961c 5887 IPW_DEBUG_ASSOC("Network '%s (%pM)' is a viable match.\n",
9387b7ca 5888 print_ssid(ssid, network->ssid, network->ssid_len),
e174961c 5889 network->bssid);
43f66a6c
JK		 5890
5891 return 1;
5892}
5893
bf79451e 5894static void ipw_adhoc_create(struct ipw_priv *priv,
b0a4e7d8 5895 struct libipw_network *network)
43f66a6c 5896{
b0a4e7d8 5897 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
afbf30a2
JK		 5898 int i;
5899
43f66a6c
JK		 5900 /*
5901 * For the purposes of scanning, we can set our wireless mode
5902 * to trigger scans across combinations of bands, but when it
5903 * comes to creating a new ad-hoc network, we have tell the FW
5904 * exactly which band to use.
5905 *
bf79451e 5906 * We also have the possibility of an invalid channel for the
43f66a6c
JK		 5907 * chossen band. Attempting to create a new ad-hoc network
5908 * with an invalid channel for wireless mode will trigger a
5909 * FW fatal error.
afbf30a2 5910 *
43f66a6c 5911 */
b0a4e7d8
JL		 5912 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
5913 case LIBIPW_52GHZ_BAND:
afbf30a2 5914 network->mode = IEEE_A;
b0a4e7d8 5915 i = libipw_channel_to_index(priv->ieee, priv->channel);
5d9428de 5916 BUG_ON(i == -1);
b0a4e7d8 5917 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
afbf30a2
JK		 5918 IPW_WARNING("Overriding invalid channel\n");
5919 priv->channel = geo->a[0].channel;
5920 }
5921 break;
5922
b0a4e7d8 5923 case LIBIPW_24GHZ_BAND:
afbf30a2
JK		 5924 if (priv->ieee->mode & IEEE_G)
5925 network->mode = IEEE_G;
5926 else
5927 network->mode = IEEE_B;
b0a4e7d8 5928 i = libipw_channel_to_index(priv->ieee, priv->channel);
5d9428de 5929 BUG_ON(i == -1);
b0a4e7d8 5930 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
1fe0adb4
LH		 5931 IPW_WARNING("Overriding invalid channel\n");
5932 priv->channel = geo->bg[0].channel;
5933 }
afbf30a2
JK		 5934 break;
5935
5936 default:
43f66a6c
JK		 5937 IPW_WARNING("Overriding invalid channel\n");
5938 if (priv->ieee->mode & IEEE_A) {
5939 network->mode = IEEE_A;
b095c381 5940 priv->channel = geo->a[0].channel;
43f66a6c
JK		 5941 } else if (priv->ieee->mode & IEEE_G) {
5942 network->mode = IEEE_G;
b095c381 5943 priv->channel = geo->bg[0].channel;
43f66a6c
JK		 5944 } else {
5945 network->mode = IEEE_B;
b095c381 5946 priv->channel = geo->bg[0].channel;
43f66a6c 5947 }
afbf30a2
JK		 5948 break;
5949 }
43f66a6c
JK		 5950
5951 network->channel = priv->channel;
5952 priv->config |= CFG_ADHOC_PERSIST;
5953 ipw_create_bssid(priv, network->bssid);
5954 network->ssid_len = priv->essid_len;
5955 memcpy(network->ssid, priv->essid, priv->essid_len);
5956 memset(&network->stats, 0, sizeof(network->stats));
5957 network->capability = WLAN_CAPABILITY_IBSS;
ea2b26e0
JK		 5958 if (!(priv->config & CFG_PREAMBLE_LONG))
5959 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
43f66a6c
JK		 5960 if (priv->capability & CAP_PRIVACY_ON)
5961 network->capability |= WLAN_CAPABILITY_PRIVACY;
5962 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
0edd5b44 5963 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
43f66a6c 5964 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
bf79451e 5965 memcpy(network->rates_ex,
43f66a6c
JK		 5966 &priv->rates.supported_rates[network->rates_len],
5967 network->rates_ex_len);
5968 network->last_scanned = 0;
5969 network->flags = 0;
5970 network->last_associate = 0;
5971 network->time_stamp[0] = 0;
5972 network->time_stamp[1] = 0;
0edd5b44
JG		 5973 network->beacon_interval = 100; /* Default */
5974 network->listen_interval = 10; /* Default */
5975 network->atim_window = 0; /* Default */
43f66a6c
JK		 5976 network->wpa_ie_len = 0;
5977 network->rsn_ie_len = 0;
43f66a6c
JK		 5978}
5979
b095c381
JK		 5980static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5981{
0a7bcf26 5982 struct ipw_tgi_tx_key key;
b095c381
JK		 5983
5984 if (!(priv->ieee->sec.flags & (1 << index)))
5985 return;
5986
0a7bcf26
ZY		 5987 key.key_id = index;
5988 memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5989 key.security_type = type;
5990 key.station_index = 0; /* always 0 for BSS */
5991 key.flags = 0;
b095c381 5992 /* 0 for new key; previous value of counter (after fatal error) */
851ca268
ZY		 5993 key.tx_counter[0] = cpu_to_le32(0);
5994 key.tx_counter[1] = cpu_to_le32(0);
b095c381 5995
0a7bcf26 5996 ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
b095c381
JK		 5997}
5998
5999static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
43f66a6c 6000{
0a7bcf26 6001 struct ipw_wep_key key;
43f66a6c 6002 int i;
43f66a6c 6003
0a7bcf26
ZY		 6004 key.cmd_id = DINO_CMD_WEP_KEY;
6005 key.seq_num = 0;
43f66a6c 6006
b095c381
JK		 6007 /* Note: AES keys cannot be set for multiple times.
6008 * Only set it at the first time. */
bf79451e 6009 for (i = 0; i < 4; i++) {
0a7bcf26 6010 key.key_index = i | type;
b095c381 6011 if (!(priv->ieee->sec.flags & (1 << i))) {
0a7bcf26 6012 key.key_size = 0;
b095c381 6013 continue;
43f66a6c
JK		 6014 }
6015
0a7bcf26
ZY		 6016 key.key_size = priv->ieee->sec.key_sizes[i];
6017 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
b095c381 6018
0a7bcf26 6019 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
bf79451e 6020 }
43f66a6c
JK		 6021}
6022
1fbfea54 6023static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
43f66a6c 6024{
1fbfea54 6025 if (priv->ieee->host_encrypt)
43f66a6c 6026 return;
43f66a6c 6027
1fbfea54
ZY		 6028 switch (level) {
6029 case SEC_LEVEL_3:
6030 priv->sys_config.disable_unicast_decryption = 0;
6031 priv->ieee->host_decrypt = 0;
6032 break;
6033 case SEC_LEVEL_2:
6034 priv->sys_config.disable_unicast_decryption = 1;
6035 priv->ieee->host_decrypt = 1;
6036 break;
6037 case SEC_LEVEL_1:
6038 priv->sys_config.disable_unicast_decryption = 0;
6039 priv->ieee->host_decrypt = 0;
6040 break;
6041 case SEC_LEVEL_0:
6042 priv->sys_config.disable_unicast_decryption = 1;
6043 break;
6044 default:
6045 break;
6046 }
6047}
6048
6049static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
6050{
6051 if (priv->ieee->host_encrypt)
6052 return;
6053
6054 switch (level) {
6055 case SEC_LEVEL_3:
6056 priv->sys_config.disable_multicast_decryption = 0;
6057 break;
6058 case SEC_LEVEL_2:
6059 priv->sys_config.disable_multicast_decryption = 1;
6060 break;
6061 case SEC_LEVEL_1:
6062 priv->sys_config.disable_multicast_decryption = 0;
6063 break;
6064 case SEC_LEVEL_0:
6065 priv->sys_config.disable_multicast_decryption = 1;
6066 break;
6067 default:
6068 break;
6069 }
6070}
6071
b095c381
JK		 6072static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
6073{
6074 switch (priv->ieee->sec.level) {
6075 case SEC_LEVEL_3:
d8bad6df
ZY		 6076 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
6077 ipw_send_tgi_tx_key(priv,
6078 DCT_FLAG_EXT_SECURITY_CCM,
6079 priv->ieee->sec.active_key);
afbf30a2 6080
567deaf6
HL		 6081 if (!priv->ieee->host_mc_decrypt)
6082 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
b095c381
JK		 6083 break;
6084 case SEC_LEVEL_2:
d8bad6df
ZY		 6085 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
6086 ipw_send_tgi_tx_key(priv,
6087 DCT_FLAG_EXT_SECURITY_TKIP,
6088 priv->ieee->sec.active_key);
b095c381
JK		 6089 break;
6090 case SEC_LEVEL_1:
6091 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
29cb843e
HL		 6092 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
6093 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
b095c381
JK		 6094 break;
6095 case SEC_LEVEL_0:
6096 default:
6097 break;
6098 }
6099}
6100
43f66a6c
JK		 6101static void ipw_adhoc_check(void *data)
6102{
6103 struct ipw_priv *priv = data;
bf79451e 6104
afbf30a2 6105 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
43f66a6c 6106 !(priv->config & CFG_ADHOC_PERSIST)) {
afbf30a2
JK		 6107 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
6108 IPW_DL_STATE | IPW_DL_ASSOC,
6109 "Missed beacon: %d - disassociate\n",
6110 priv->missed_adhoc_beacons);
43f66a6c
JK		 6111 ipw_remove_current_network(priv);
6112 ipw_disassociate(priv);
6113 return;
6114 }
6115
bcb6d916
TH		 6116 schedule_delayed_work(&priv->adhoc_check,
6117 le16_to_cpu(priv->assoc_request.beacon_interval));
43f66a6c
JK		 6118}
6119
c4028958 6120static void ipw_bg_adhoc_check(struct work_struct *work)
c848d0af 6121{
c4028958
DH		 6122 struct ipw_priv *priv =
6123 container_of(work, struct ipw_priv, adhoc_check.work);
4644151b 6124 mutex_lock(&priv->mutex);
c4028958 6125 ipw_adhoc_check(priv);
4644151b 6126 mutex_unlock(&priv->mutex);
c848d0af
JK		 6127}
6128
43f66a6c
JK		 6129static void ipw_debug_config(struct ipw_priv *priv)
6130{
9387b7ca 6131 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 6132 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
6133 "[CFG 0x%08X]\n", priv->config);
6134 if (priv->config & CFG_STATIC_CHANNEL)
0edd5b44 6135 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
43f66a6c
JK		 6136 else
6137 IPW_DEBUG_INFO("Channel unlocked.\n");
6138 if (priv->config & CFG_STATIC_ESSID)
bf79451e 6139 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
9387b7ca 6140 print_ssid(ssid, priv->essid, priv->essid_len));
43f66a6c
JK		 6141 else
6142 IPW_DEBUG_INFO("ESSID unlocked.\n");
6143 if (priv->config & CFG_STATIC_BSSID)
e174961c 6144 IPW_DEBUG_INFO("BSSID locked to %pM\n", priv->bssid);
43f66a6c
JK		 6145 else
6146 IPW_DEBUG_INFO("BSSID unlocked.\n");
6147 if (priv->capability & CAP_PRIVACY_ON)
6148 IPW_DEBUG_INFO("PRIVACY on\n");
6149 else
6150 IPW_DEBUG_INFO("PRIVACY off\n");
6151 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
6152}
43f66a6c 6153
858119e1 6154static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
43f66a6c
JK		 6155{
6156 /* TODO: Verify that this works... */
21f8a73f 6157 struct ipw_fixed_rate fr;
43f66a6c
JK		 6158 u32 reg;
6159 u16 mask = 0;
21f8a73f 6160 u16 new_tx_rates = priv->rates_mask;
43f66a6c 6161
bf79451e 6162 /* Identify 'current FW band' and match it with the fixed
43f66a6c 6163 * Tx rates */
bf79451e 6164
43f66a6c 6165 switch (priv->ieee->freq_band) {
b0a4e7d8 6166 case LIBIPW_52GHZ_BAND: /* A only */
43f66a6c 6167 /* IEEE_A */
b0a4e7d8 6168 if (priv->rates_mask & ~LIBIPW_OFDM_RATES_MASK) {
43f66a6c 6169 /* Invalid fixed rate mask */
ea2b26e0
JK		 6170 IPW_DEBUG_WX
6171 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
21f8a73f 6172 new_tx_rates = 0;
43f66a6c
JK		 6173 break;
6174 }
bf79451e 6175
b0a4e7d8 6176 new_tx_rates >>= LIBIPW_OFDM_SHIFT_MASK_A;
43f66a6c
JK		 6177 break;
6178
0edd5b44 6179 default: /* 2.4Ghz or Mixed */
43f66a6c 6180 /* IEEE_B */
b095c381 6181 if (mode == IEEE_B) {
b0a4e7d8 6182 if (new_tx_rates & ~LIBIPW_CCK_RATES_MASK) {
43f66a6c 6183 /* Invalid fixed rate mask */
ea2b26e0
JK		 6184 IPW_DEBUG_WX
6185 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
21f8a73f 6186 new_tx_rates = 0;
43f66a6c
JK		 6187 }
6188 break;
bf79451e 6189 }
43f66a6c
JK		 6190
6191 /* IEEE_G */
b0a4e7d8
JL		 6192 if (new_tx_rates & ~(LIBIPW_CCK_RATES_MASK |
6193 LIBIPW_OFDM_RATES_MASK)) {
43f66a6c 6194 /* Invalid fixed rate mask */
ea2b26e0
JK		 6195 IPW_DEBUG_WX
6196 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
21f8a73f 6197 new_tx_rates = 0;
43f66a6c
JK		 6198 break;
6199 }
bf79451e 6200
b0a4e7d8
JL		 6201 if (LIBIPW_OFDM_RATE_6MB_MASK & new_tx_rates) {
6202 mask |= (LIBIPW_OFDM_RATE_6MB_MASK >> 1);
6203 new_tx_rates &= ~LIBIPW_OFDM_RATE_6MB_MASK;
43f66a6c 6204 }
bf79451e 6205
b0a4e7d8
JL		 6206 if (LIBIPW_OFDM_RATE_9MB_MASK & new_tx_rates) {
6207 mask |= (LIBIPW_OFDM_RATE_9MB_MASK >> 1);
6208 new_tx_rates &= ~LIBIPW_OFDM_RATE_9MB_MASK;
43f66a6c 6209 }
bf79451e 6210
b0a4e7d8
JL		 6211 if (LIBIPW_OFDM_RATE_12MB_MASK & new_tx_rates) {
6212 mask |= (LIBIPW_OFDM_RATE_12MB_MASK >> 1);
6213 new_tx_rates &= ~LIBIPW_OFDM_RATE_12MB_MASK;
43f66a6c 6214 }
bf79451e 6215
21f8a73f 6216 new_tx_rates |= mask;
43f66a6c
JK		 6217 break;
6218 }
6219
21f8a73f
RC		 6220 fr.tx_rates = cpu_to_le16(new_tx_rates);
6221
43f66a6c 6222 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
0edd5b44 6223 ipw_write_reg32(priv, reg, *(u32 *) & fr);
43f66a6c
JK		 6224}
6225
ea2b26e0 6226static void ipw_abort_scan(struct ipw_priv *priv)
43f66a6c
JK		 6227{
6228 int err;
6229
ea2b26e0
JK		 6230 if (priv->status & STATUS_SCAN_ABORTING) {
6231 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
6232 return;
6233 }
6234 priv->status |= STATUS_SCAN_ABORTING;
43f66a6c 6235
ea2b26e0
JK		 6236 err = ipw_send_scan_abort(priv);
6237 if (err)
6238 IPW_DEBUG_HC("Request to abort scan failed.\n");
6239}
6240
afbf30a2
JK		 6241static void ipw_add_scan_channels(struct ipw_priv *priv,
6242 struct ipw_scan_request_ext *scan,
6243 int scan_type)
ea2b26e0 6244{
ea2b26e0 6245 int channel_index = 0;
b0a4e7d8 6246 const struct libipw_geo *geo;
afbf30a2 6247 int i;
b095c381 6248
b0a4e7d8 6249 geo = libipw_get_geo(priv->ieee);
43f66a6c 6250
b0a4e7d8 6251 if (priv->ieee->freq_band & LIBIPW_52GHZ_BAND) {
afbf30a2
JK		 6252 int start = channel_index;
6253 for (i = 0; i < geo->a_channels; i++) {
6254 if ((priv->status & STATUS_ASSOCIATED) &&
6255 geo->a[i].channel == priv->channel)
6256 continue;
6257 channel_index++;
6258 scan->channels_list[channel_index] = geo->a[i].channel;
1fe0adb4
LH		 6259 ipw_set_scan_type(scan, channel_index,
6260 geo->a[i].
b0a4e7d8 6261 flags & LIBIPW_CH_PASSIVE_ONLY ?
1fe0adb4
LH		 6262 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
6263 scan_type);
afbf30a2
JK		 6264 }
6265
6266 if (start != channel_index) {
6267 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
6268 (channel_index - start);
6269 channel_index++;
6270 }
6271 }
6272
b0a4e7d8 6273 if (priv->ieee->freq_band & LIBIPW_24GHZ_BAND) {
afbf30a2
JK		 6274 int start = channel_index;
6275 if (priv->config & CFG_SPEED_SCAN) {
1fe0adb4 6276 int index;
b0a4e7d8 6277 u8 channels[LIBIPW_24GHZ_CHANNELS] = {
afbf30a2
JK		 6278 /* nop out the list */
6279 [0] = 0
6280 };
6281
6282 u8 channel;
7dd2459d 6283 while (channel_index < IPW_SCAN_CHANNELS - 1) {
afbf30a2
JK		 6284 channel =
6285 priv->speed_scan[priv->speed_scan_pos];
6286 if (channel == 0) {
6287 priv->speed_scan_pos = 0;
6288 channel = priv->speed_scan[0];
6289 }
6290 if ((priv->status & STATUS_ASSOCIATED) &&
6291 channel == priv->channel) {
6292 priv->speed_scan_pos++;
6293 continue;
6294 }
6295
6296 /* If this channel has already been
6297 * added in scan, break from loop
6298 * and this will be the first channel
6299 * in the next scan.
6300 */
6301 if (channels[channel - 1] != 0)
6302 break;
6303
6304 channels[channel - 1] = 1;
6305 priv->speed_scan_pos++;
6306 channel_index++;
6307 scan->channels_list[channel_index] = channel;
1fe0adb4 6308 index =
b0a4e7d8 6309 libipw_channel_to_index(priv->ieee, channel);
afbf30a2 6310 ipw_set_scan_type(scan, channel_index,
1fe0adb4
LH		 6311 geo->bg[index].
6312 flags &
b0a4e7d8 6313 LIBIPW_CH_PASSIVE_ONLY ?
1fe0adb4
LH		 6314 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6315 : scan_type);
afbf30a2
JK		 6316 }
6317 } else {
6318 for (i = 0; i < geo->bg_channels; i++) {
6319 if ((priv->status & STATUS_ASSOCIATED) &&
6320 geo->bg[i].channel == priv->channel)
6321 continue;
6322 channel_index++;
6323 scan->channels_list[channel_index] =
6324 geo->bg[i].channel;
6325 ipw_set_scan_type(scan, channel_index,
1fe0adb4
LH		 6326 geo->bg[i].
6327 flags &
b0a4e7d8 6328 LIBIPW_CH_PASSIVE_ONLY ?
1fe0adb4
LH		 6329 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6330 : scan_type);
afbf30a2
JK		 6331 }
6332 }
6333
6334 if (start != channel_index) {
6335 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6336 (channel_index - start);
6337 }
6338 }
6339}
6340
14a4dfe2
HS		 6341static int ipw_passive_dwell_time(struct ipw_priv *priv)
6342{
6343 /* staying on passive channels longer than the DTIM interval during a
6344 * scan, while associated, causes the firmware to cancel the scan
6345 * without notification. Hence, don't stay on passive channels longer
6346 * than the beacon interval.
6347 */
6348 if (priv->status & STATUS_ASSOCIATED
6349 && priv->assoc_network->beacon_interval > 10)
6350 return priv->assoc_network->beacon_interval - 10;
6351 else
6352 return 120;
6353}
6354
ea177305 6355static int ipw_request_scan_helper(struct ipw_priv *priv, int type, int direct)
afbf30a2
JK		 6356{
6357 struct ipw_scan_request_ext scan;
6358 int err = 0, scan_type;
6359
6360 if (!(priv->status & STATUS_INIT) ||
6361 (priv->status & STATUS_EXIT_PENDING))
6362 return 0;
6363
4644151b 6364 mutex_lock(&priv->mutex);
afbf30a2 6365
ea177305
DW		 6366 if (direct && (priv->direct_scan_ssid_len == 0)) {
6367 IPW_DEBUG_HC("Direct scan requested but no SSID to scan for\n");
6368 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6369 goto done;
6370 }
6371
ea2b26e0 6372 if (priv->status & STATUS_SCANNING) {
ea177305
DW		 6373 IPW_DEBUG_HC("Concurrent scan requested. Queuing.\n");
6374 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6375 STATUS_SCAN_PENDING;
b095c381 6376 goto done;
ea2b26e0 6377 }
43f66a6c 6378
afbf30a2
JK		 6379 if (!(priv->status & STATUS_SCAN_FORCED) &&
6380 priv->status & STATUS_SCAN_ABORTING) {
ea2b26e0 6381 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
ea177305
DW		 6382 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6383 STATUS_SCAN_PENDING;
b095c381 6384 goto done;
43f66a6c
JK		 6385 }
6386
ea2b26e0 6387 if (priv->status & STATUS_RF_KILL_MASK) {
ea177305
DW		 6388 IPW_DEBUG_HC("Queuing scan due to RF Kill activation\n");
6389 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6390 STATUS_SCAN_PENDING;
b095c381 6391 goto done;
ea2b26e0 6392 }
43f66a6c 6393
ea2b26e0 6394 memset(&scan, 0, sizeof(scan));
b0a4e7d8 6395 scan.full_scan_index = cpu_to_le32(libipw_get_scans(priv->ieee));
43f66a6c 6396
094c4d2d 6397 if (type == IW_SCAN_TYPE_PASSIVE) {
14a4dfe2
HS		 6398 IPW_DEBUG_WX("use passive scanning\n");
6399 scan_type = IPW_SCAN_PASSIVE_FULL_DWELL_SCAN;
094c4d2d 6400 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
14a4dfe2 6401 cpu_to_le16(ipw_passive_dwell_time(priv));
094c4d2d
ZY		 6402 ipw_add_scan_channels(priv, &scan, scan_type);
6403 goto send_request;
6404 }
6405
6406 /* Use active scan by default. */
14a4dfe2 6407 if (priv->config & CFG_SPEED_SCAN)
b095c381 6408 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
094c4d2d 6409 cpu_to_le16(30);
b095c381
JK		 6410 else
6411 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
094c4d2d 6412 cpu_to_le16(20);
b095c381 6413
a613bffd 6414 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
094c4d2d 6415 cpu_to_le16(20);
43f66a6c 6416
14a4dfe2
HS		 6417 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6418 cpu_to_le16(ipw_passive_dwell_time(priv));
ea177305 6419 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
43f66a6c 6420
b095c381 6421#ifdef CONFIG_IPW2200_MONITOR
ea2b26e0 6422 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 6423 u8 channel;
b095c381 6424 u8 band = 0;
43f66a6c 6425
b0a4e7d8
JL		 6426 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
6427 case LIBIPW_52GHZ_BAND:
ea2b26e0 6428 band = (u8) (IPW_A_MODE << 6) | 1;
b095c381
JK		 6429 channel = priv->channel;
6430 break;
ea2b26e0 6431
b0a4e7d8 6432 case LIBIPW_24GHZ_BAND:
ea2b26e0 6433 band = (u8) (IPW_B_MODE << 6) | 1;
b095c381
JK		 6434 channel = priv->channel;
6435 break;
ea2b26e0 6436
b095c381 6437 default:
ea2b26e0
JK		 6438 band = (u8) (IPW_B_MODE << 6) | 1;
6439 channel = 9;
b095c381 6440 break;
ea2b26e0
JK		 6441 }
6442
b095c381
JK		 6443 scan.channels_list[0] = band;
6444 scan.channels_list[1] = channel;
6445 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
ea2b26e0 6446
b095c381
JK		 6447 /* NOTE: The card will sit on this channel for this time
6448 * period. Scan aborts are timing sensitive and frequently
6449 * result in firmware restarts. As such, it is best to
6450 * set a small dwell_time here and just keep re-issuing
6451 * scans. Otherwise fast channel hopping will not actually
6452 * hop channels.
6453 *
6454 * TODO: Move SPEED SCAN support to all modes and bands */
a613bffd 6455 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
094c4d2d 6456 cpu_to_le16(2000);
43f66a6c 6457 } else {
b095c381 6458#endif /* CONFIG_IPW2200_MONITOR */
ea177305
DW		 6459 /* Honor direct scans first, otherwise if we are roaming make
6460 * this a direct scan for the current network. Finally,
6461 * ensure that every other scan is a fast channel hop scan */
6462 if (direct) {
6463 err = ipw_send_ssid(priv, priv->direct_scan_ssid,
6464 priv->direct_scan_ssid_len);
6465 if (err) {
6466 IPW_DEBUG_HC("Attempt to send SSID command "
6467 "failed\n");
6468 goto done;
6469 }
6470
6471 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6472 } else if ((priv->status & STATUS_ROAMING)
6473 || (!(priv->status & STATUS_ASSOCIATED)
6474 && (priv->config & CFG_STATIC_ESSID)
6475 && (le32_to_cpu(scan.full_scan_index) % 2))) {
ea2b26e0
JK		 6476 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6477 if (err) {
b095c381
JK		 6478 IPW_DEBUG_HC("Attempt to send SSID command "
6479 "failed.\n");
6480 goto done;
ea2b26e0 6481 }
43f66a6c 6482
ea2b26e0 6483 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
afbf30a2 6484 } else
ea2b26e0 6485 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
ea2b26e0 6486
afbf30a2 6487 ipw_add_scan_channels(priv, &scan, scan_type);
b095c381 6488#ifdef CONFIG_IPW2200_MONITOR
43f66a6c 6489 }
ea2b26e0 6490#endif
bf79451e 6491
094c4d2d 6492send_request:
ea2b26e0 6493 err = ipw_send_scan_request_ext(priv, &scan);
43f66a6c 6494 if (err) {
ea2b26e0 6495 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
b095c381 6496 goto done;
43f66a6c
JK		 6497 }
6498
ea2b26e0 6499 priv->status |= STATUS_SCANNING;
ea177305
DW		 6500 if (direct) {
6501 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6502 priv->direct_scan_ssid_len = 0;
6503 } else
6504 priv->status &= ~STATUS_SCAN_PENDING;
6505
bcb6d916 6506 schedule_delayed_work(&priv->scan_check, IPW_SCAN_CHECK_WATCHDOG);
094c4d2d 6507done:
4644151b 6508 mutex_unlock(&priv->mutex);
b095c381 6509 return err;
c848d0af
JK		 6510}
6511
c4028958
DH		 6512static void ipw_request_passive_scan(struct work_struct *work)
6513{
6514 struct ipw_priv *priv =
ea177305
DW		 6515 container_of(work, struct ipw_priv, request_passive_scan.work);
6516 ipw_request_scan_helper(priv, IW_SCAN_TYPE_PASSIVE, 0);
094c4d2d
ZY		 6517}
6518
c4028958
DH		 6519static void ipw_request_scan(struct work_struct *work)
6520{
6521 struct ipw_priv *priv =
6522 container_of(work, struct ipw_priv, request_scan.work);
ea177305
DW		 6523 ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 0);
6524}
6525
6526static void ipw_request_direct_scan(struct work_struct *work)
6527{
6528 struct ipw_priv *priv =
6529 container_of(work, struct ipw_priv, request_direct_scan.work);
6530 ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 1);
094c4d2d
ZY		 6531}
6532
c4028958 6533static void ipw_bg_abort_scan(struct work_struct *work)
c848d0af 6534{
c4028958
DH		 6535 struct ipw_priv *priv =
6536 container_of(work, struct ipw_priv, abort_scan);
4644151b 6537 mutex_lock(&priv->mutex);
c4028958 6538 ipw_abort_scan(priv);
4644151b 6539 mutex_unlock(&priv->mutex);
c848d0af
JK		 6540}
6541
ea2b26e0
JK		 6542static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6543{
b095c381
JK		 6544 /* This is called when wpa_supplicant loads and closes the driver
6545 * interface. */
cdd1fa1e 6546 priv->ieee->wpa_enabled = value;
b095c381 6547 return 0;
ea2b26e0
JK		 6548}
6549
ea2b26e0
JK		 6550static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6551{
b0a4e7d8
JL		 6552 struct libipw_device *ieee = priv->ieee;
6553 struct libipw_security sec = {
ea2b26e0
JK		 6554 .flags = SEC_AUTH_MODE,
6555 };
6556 int ret = 0;
6557
afbf30a2 6558 if (value & IW_AUTH_ALG_SHARED_KEY) {
ea2b26e0
JK		 6559 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6560 ieee->open_wep = 0;
afbf30a2 6561 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
ea2b26e0
JK		 6562 sec.auth_mode = WLAN_AUTH_OPEN;
6563 ieee->open_wep = 1;
3e234b4e
ZY		 6564 } else if (value & IW_AUTH_ALG_LEAP) {
6565 sec.auth_mode = WLAN_AUTH_LEAP;
6566 ieee->open_wep = 1;
afbf30a2
JK		 6567 } else
6568 return -EINVAL;
ea2b26e0
JK		 6569
6570 if (ieee->set_security)
6571 ieee->set_security(ieee->dev, &sec);
6572 else
6573 ret = -EOPNOTSUPP;
6574
6575 return ret;
6576}
6577
a73e22b2
AB		 6578static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6579 int wpa_ie_len)
afbf30a2
JK		 6580{
6581 /* make sure WPA is enabled */
6582 ipw_wpa_enable(priv, 1);
afbf30a2
JK		 6583}
6584
6585static int ipw_set_rsn_capa(struct ipw_priv *priv,
6586 char *capabilities, int length)
6587{
afbf30a2
JK		 6588 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6589
0a7bcf26 6590 return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
2638bc39 6591 capabilities);
afbf30a2
JK		 6592}
6593
b095c381 6594/*
afbf30a2
JK		 6595 * WE-18 support
6596 */
6597
6598/* SIOCSIWGENIE */
6599static int ipw_wx_set_genie(struct net_device *dev,
6600 struct iw_request_info *info,
6601 union iwreq_data *wrqu, char *extra)
ea2b26e0 6602{
b0a4e7d8
JL		 6603 struct ipw_priv *priv = libipw_priv(dev);
6604 struct libipw_device *ieee = priv->ieee;
afbf30a2
JK		 6605 u8 *buf;
6606 int err = 0;
ea2b26e0 6607
afbf30a2
JK		 6608 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6609 (wrqu->data.length && extra == NULL))
6610 return -EINVAL;
ea2b26e0 6611
afbf30a2 6612 if (wrqu->data.length) {
d3e5033d 6613 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
afbf30a2
JK		 6614 if (buf == NULL) {
6615 err = -ENOMEM;
6616 goto out;
6617 }
6618
afbf30a2
JK		 6619 kfree(ieee->wpa_ie);
6620 ieee->wpa_ie = buf;
6621 ieee->wpa_ie_len = wrqu->data.length;
b095c381 6622 } else {
afbf30a2
JK		 6623 kfree(ieee->wpa_ie);
6624 ieee->wpa_ie = NULL;
6625 ieee->wpa_ie_len = 0;
ea2b26e0 6626 }
afbf30a2
JK		 6627
6628 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6629 out:
afbf30a2
JK		 6630 return err;
6631}
6632
6633/* SIOCGIWGENIE */
6634static int ipw_wx_get_genie(struct net_device *dev,
6635 struct iw_request_info *info,
6636 union iwreq_data *wrqu, char *extra)
6637{
b0a4e7d8
JL		 6638 struct ipw_priv *priv = libipw_priv(dev);
6639 struct libipw_device *ieee = priv->ieee;
afbf30a2
JK		 6640 int err = 0;
6641
afbf30a2
JK		 6642 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6643 wrqu->data.length = 0;
6644 goto out;
6645 }
6646
6647 if (wrqu->data.length < ieee->wpa_ie_len) {
6648 err = -E2BIG;
6649 goto out;
6650 }
6651
6652 wrqu->data.length = ieee->wpa_ie_len;
6653 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6654
6655 out:
afbf30a2
JK		 6656 return err;
6657}
6658
1fbfea54
ZY		 6659static int wext_cipher2level(int cipher)
6660{
6661 switch (cipher) {
6662 case IW_AUTH_CIPHER_NONE:
6663 return SEC_LEVEL_0;
6664 case IW_AUTH_CIPHER_WEP40:
6665 case IW_AUTH_CIPHER_WEP104:
6666 return SEC_LEVEL_1;
6667 case IW_AUTH_CIPHER_TKIP:
6668 return SEC_LEVEL_2;
6669 case IW_AUTH_CIPHER_CCMP:
6670 return SEC_LEVEL_3;
6671 default:
6672 return -1;
6673 }
6674}
6675
afbf30a2
JK		 6676/* SIOCSIWAUTH */
6677static int ipw_wx_set_auth(struct net_device *dev,
6678 struct iw_request_info *info,
6679 union iwreq_data *wrqu, char *extra)
6680{
b0a4e7d8
JL		 6681 struct ipw_priv *priv = libipw_priv(dev);
6682 struct libipw_device *ieee = priv->ieee;
afbf30a2 6683 struct iw_param *param = &wrqu->param;
274bfb8d 6684 struct lib80211_crypt_data *crypt;
afbf30a2
JK		 6685 unsigned long flags;
6686 int ret = 0;
6687
6688 switch (param->flags & IW_AUTH_INDEX) {
6689 case IW_AUTH_WPA_VERSION:
1fbfea54 6690 break;
afbf30a2 6691 case IW_AUTH_CIPHER_PAIRWISE:
1fbfea54
ZY		 6692 ipw_set_hw_decrypt_unicast(priv,
6693 wext_cipher2level(param->value));
6694 break;
afbf30a2 6695 case IW_AUTH_CIPHER_GROUP:
1fbfea54
ZY		 6696 ipw_set_hw_decrypt_multicast(priv,
6697 wext_cipher2level(param->value));
6698 break;
afbf30a2
JK		 6699 case IW_AUTH_KEY_MGMT:
6700 /*
6701 * ipw2200 does not use these parameters
6702 */
6703 break;
6704
6705 case IW_AUTH_TKIP_COUNTERMEASURES:
274bfb8d 6706 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
991d1cc5 6707 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
afbf30a2 6708 break;
afbf30a2
JK		 6709
6710 flags = crypt->ops->get_flags(crypt->priv);
6711
6712 if (param->value)
6713 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6714 else
6715 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6716
6717 crypt->ops->set_flags(flags, crypt->priv);
6718
6719 break;
6720
6721 case IW_AUTH_DROP_UNENCRYPTED:{
6722 /* HACK:
6723 *
6724 * wpa_supplicant calls set_wpa_enabled when the driver
6725 * is loaded and unloaded, regardless of if WPA is being
6726 * used. No other calls are made which can be used to
6727 * determine if encryption will be used or not prior to
6728 * association being expected. If encryption is not being
6729 * used, drop_unencrypted is set to false, else true -- we
6730 * can use this to determine if the CAP_PRIVACY_ON bit should
6731 * be set.
6732 */
b0a4e7d8 6733 struct libipw_security sec = {
afbf30a2
JK		 6734 .flags = SEC_ENABLED,
6735 .enabled = param->value,
6736 };
6737 priv->ieee->drop_unencrypted = param->value;
6738 /* We only change SEC_LEVEL for open mode. Others
6739 * are set by ipw_wpa_set_encryption.
6740 */
6741 if (!param->value) {
6742 sec.flags |= SEC_LEVEL;
6743 sec.level = SEC_LEVEL_0;
6744 } else {
6745 sec.flags |= SEC_LEVEL;
6746 sec.level = SEC_LEVEL_1;
6747 }
6748 if (priv->ieee->set_security)
6749 priv->ieee->set_security(priv->ieee->dev, &sec);
6750 break;
6751 }
6752
6753 case IW_AUTH_80211_AUTH_ALG:
6754 ret = ipw_wpa_set_auth_algs(priv, param->value);
6755 break;
6756
6757 case IW_AUTH_WPA_ENABLED:
6758 ret = ipw_wpa_enable(priv, param->value);
e3c5a64e 6759 ipw_disassociate(priv);
afbf30a2
JK		 6760 break;
6761
6762 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6763 ieee->ieee802_1x = param->value;
6764 break;
6765
afbf30a2
JK		 6766 case IW_AUTH_PRIVACY_INVOKED:
6767 ieee->privacy_invoked = param->value;
6768 break;
6769
6770 default:
6771 return -EOPNOTSUPP;
6772 }
6773 return ret;
6774}
6775
6776/* SIOCGIWAUTH */
6777static int ipw_wx_get_auth(struct net_device *dev,
6778 struct iw_request_info *info,
6779 union iwreq_data *wrqu, char *extra)
6780{
b0a4e7d8
JL		 6781 struct ipw_priv *priv = libipw_priv(dev);
6782 struct libipw_device *ieee = priv->ieee;
274bfb8d 6783 struct lib80211_crypt_data *crypt;
afbf30a2
JK		 6784 struct iw_param *param = &wrqu->param;
6785 int ret = 0;
6786
6787 switch (param->flags & IW_AUTH_INDEX) {
6788 case IW_AUTH_WPA_VERSION:
6789 case IW_AUTH_CIPHER_PAIRWISE:
6790 case IW_AUTH_CIPHER_GROUP:
6791 case IW_AUTH_KEY_MGMT:
6792 /*
6793 * wpa_supplicant will control these internally
6794 */
6795 ret = -EOPNOTSUPP;
6796 break;
6797
6798 case IW_AUTH_TKIP_COUNTERMEASURES:
274bfb8d 6799 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
991d1cc5 6800 if (!crypt || !crypt->ops->get_flags)
afbf30a2 6801 break;
afbf30a2
JK		 6802
6803 param->value = (crypt->ops->get_flags(crypt->priv) &
6804 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6805
6806 break;
6807
6808 case IW_AUTH_DROP_UNENCRYPTED:
6809 param->value = ieee->drop_unencrypted;
6810 break;
6811
6812 case IW_AUTH_80211_AUTH_ALG:
6813 param->value = ieee->sec.auth_mode;
6814 break;
6815
6816 case IW_AUTH_WPA_ENABLED:
6817 param->value = ieee->wpa_enabled;
6818 break;
6819
6820 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6821 param->value = ieee->ieee802_1x;
6822 break;
6823
6824 case IW_AUTH_ROAMING_CONTROL:
6825 case IW_AUTH_PRIVACY_INVOKED:
6826 param->value = ieee->privacy_invoked;
6827 break;
6828
6829 default:
6830 return -EOPNOTSUPP;
6831 }
6832 return 0;
6833}
6834
6835/* SIOCSIWENCODEEXT */
6836static int ipw_wx_set_encodeext(struct net_device *dev,
6837 struct iw_request_info *info,
6838 union iwreq_data *wrqu, char *extra)
6839{
b0a4e7d8 6840 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2
JK		 6841 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6842
6843 if (hwcrypto) {
afbf30a2 6844 if (ext->alg == IW_ENCODE_ALG_TKIP) {
567deaf6
HL		 6845 /* IPW HW can't build TKIP MIC,
6846 host decryption still needed */
6847 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6848 priv->ieee->host_mc_decrypt = 1;
6849 else {
6850 priv->ieee->host_encrypt = 0;
6851 priv->ieee->host_encrypt_msdu = 1;
6852 priv->ieee->host_decrypt = 1;
6853 }
afbf30a2
JK		 6854 } else {
6855 priv->ieee->host_encrypt = 0;
6856 priv->ieee->host_encrypt_msdu = 0;
6857 priv->ieee->host_decrypt = 0;
567deaf6 6858 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 6859 }
6860 }
6861
b0a4e7d8 6862 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
afbf30a2
JK		 6863}
6864
6865/* SIOCGIWENCODEEXT */
6866static int ipw_wx_get_encodeext(struct net_device *dev,
6867 struct iw_request_info *info,
6868 union iwreq_data *wrqu, char *extra)
6869{
b0a4e7d8
JL		 6870 struct ipw_priv *priv = libipw_priv(dev);
6871 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
afbf30a2
JK		 6872}
6873
6874/* SIOCSIWMLME */
6875static int ipw_wx_set_mlme(struct net_device *dev,
6876 struct iw_request_info *info,
6877 union iwreq_data *wrqu, char *extra)
6878{
b0a4e7d8 6879 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 6880 struct iw_mlme *mlme = (struct iw_mlme *)extra;
e62e1ee0 6881 __le16 reason;
afbf30a2
JK		 6882
6883 reason = cpu_to_le16(mlme->reason_code);
6884
6885 switch (mlme->cmd) {
6886 case IW_MLME_DEAUTH:
67fd6b45 6887 /* silently ignore */
afbf30a2
JK		 6888 break;
6889
6890 case IW_MLME_DISASSOC:
6891 ipw_disassociate(priv);
6892 break;
6893
6894 default:
6895 return -EOPNOTSUPP;
6896 }
6897 return 0;
6898}
afbf30a2 6899
e43e3c1e 6900#ifdef CONFIG_IPW2200_QOS
afbf30a2
JK		 6901
6902/* QoS */
6903/*
6904* get the modulation type of the current network or
6905* the card current mode
6906*/
53d0bcf8 6907static u8 ipw_qos_current_mode(struct ipw_priv * priv)
afbf30a2
JK		 6908{
6909 u8 mode = 0;
6910
6911 if (priv->status & STATUS_ASSOCIATED) {
6912 unsigned long flags;
6913
6914 spin_lock_irqsave(&priv->ieee->lock, flags);
6915 mode = priv->assoc_network->mode;
6916 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6917 } else {
6918 mode = priv->ieee->mode;
6919 }
9fd1ea42 6920 IPW_DEBUG_QOS("QoS network/card mode %d\n", mode);
afbf30a2 6921 return mode;
b095c381 6922}
ea2b26e0 6923
b095c381
JK		 6924/*
6925* Handle management frame beacon and probe response
6926*/
3b9990cb
JK		 6927static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6928 int active_network,
b0a4e7d8 6929 struct libipw_network *network)
b095c381 6930{
b0a4e7d8 6931 u32 size = sizeof(struct libipw_qos_parameters);
b095c381 6932
afbf30a2 6933 if (network->capability & WLAN_CAPABILITY_IBSS)
b095c381
JK		 6934 network->qos_data.active = network->qos_data.supported;
6935
6936 if (network->flags & NETWORK_HAS_QOS_MASK) {
afbf30a2
JK		 6937 if (active_network &&
6938 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
b095c381
JK		 6939 network->qos_data.active = network->qos_data.supported;
6940
6941 if ((network->qos_data.active == 1) && (active_network == 1) &&
6942 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6943 (network->qos_data.old_param_count !=
6944 network->qos_data.param_count)) {
6945 network->qos_data.old_param_count =
6946 network->qos_data.param_count;
6947 schedule_work(&priv->qos_activate);
afbf30a2
JK		 6948 IPW_DEBUG_QOS("QoS parameters change call "
6949 "qos_activate\n");
b095c381 6950 }
ea2b26e0 6951 } else {
afbf30a2
JK		 6952 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6953 memcpy(&network->qos_data.parameters,
b095c381 6954 &def_parameters_CCK, size);
afbf30a2
JK		 6955 else
6956 memcpy(&network->qos_data.parameters,
b095c381 6957 &def_parameters_OFDM, size);
afbf30a2 6958
b095c381 6959 if ((network->qos_data.active == 1) && (active_network == 1)) {
9fd1ea42 6960 IPW_DEBUG_QOS("QoS was disabled call qos_activate\n");
b095c381
JK		 6961 schedule_work(&priv->qos_activate);
6962 }
6963
6964 network->qos_data.active = 0;
6965 network->qos_data.supported = 0;
ea2b26e0 6966 }
afbf30a2
JK		 6967 if ((priv->status & STATUS_ASSOCIATED) &&
6968 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6969 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
c5d3dce8 6970 if (network->capability & WLAN_CAPABILITY_IBSS)
b095c381 6971 if ((network->ssid_len ==
afbf30a2
JK		 6972 priv->assoc_network->ssid_len) &&
6973 !memcmp(network->ssid,
6974 priv->assoc_network->ssid,
6975 network->ssid_len)) {
bcb6d916 6976 schedule_work(&priv->merge_networks);
b095c381 6977 }
b095c381 6978 }
ea2b26e0 6979
b095c381
JK		 6980 return 0;
6981}
6982
6983/*
6984* This function set up the firmware to support QoS. It sends
6985* IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6986*/
6987static int ipw_qos_activate(struct ipw_priv *priv,
b0a4e7d8 6988 struct libipw_qos_data *qos_network_data)
b095c381
JK		 6989{
6990 int err;
b0a4e7d8
JL		 6991 struct libipw_qos_parameters qos_parameters[QOS_QOS_SETS];
6992 struct libipw_qos_parameters *active_one = NULL;
6993 u32 size = sizeof(struct libipw_qos_parameters);
b095c381
JK		 6994 u32 burst_duration;
6995 int i;
6996 u8 type;
6997
6998 type = ipw_qos_current_mode(priv);
6999
7000 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
7001 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
7002 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
7003 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
7004
7005 if (qos_network_data == NULL) {
7006 if (type == IEEE_B) {
7007 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
7008 active_one = &def_parameters_CCK;
7009 } else
7010 active_one = &def_parameters_OFDM;
7011
afbf30a2 7012 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7013 burst_duration = ipw_qos_get_burst_duration(priv);
7014 for (i = 0; i < QOS_QUEUE_NUM; i++)
afbf30a2 7015 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
8fffc15d 7016 cpu_to_le16(burst_duration);
afbf30a2 7017 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
b095c381
JK		 7018 if (type == IEEE_B) {
7019 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
7020 type);
7021 if (priv->qos_data.qos_enable == 0)
7022 active_one = &def_parameters_CCK;
7023 else
7024 active_one = priv->qos_data.def_qos_parm_CCK;
7025 } else {
7026 if (priv->qos_data.qos_enable == 0)
7027 active_one = &def_parameters_OFDM;
7028 else
7029 active_one = priv->qos_data.def_qos_parm_OFDM;
7030 }
afbf30a2 7031 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7032 } else {
7033 unsigned long flags;
7034 int active;
7035
7036 spin_lock_irqsave(&priv->ieee->lock, flags);
7037 active_one = &(qos_network_data->parameters);
7038 qos_network_data->old_param_count =
7039 qos_network_data->param_count;
afbf30a2 7040 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 7041 active = qos_network_data->supported;
7042 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7043
7044 if (active == 0) {
7045 burst_duration = ipw_qos_get_burst_duration(priv);
7046 for (i = 0; i < QOS_QUEUE_NUM; i++)
7047 qos_parameters[QOS_PARAM_SET_ACTIVE].
8fffc15d 7048 tx_op_limit[i] = cpu_to_le16(burst_duration);
b095c381
JK		 7049 }
7050 }
7051
7052 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
afbf30a2 7053 err = ipw_send_qos_params_command(priv,
b0a4e7d8 7054 (struct libipw_qos_parameters *)
afbf30a2 7055 &(qos_parameters[0]));
b095c381
JK		 7056 if (err)
7057 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
7058
7059 return err;
7060}
7061
7062/*
7063* send IPW_CMD_WME_INFO to the firmware
7064*/
7065static int ipw_qos_set_info_element(struct ipw_priv *priv)
7066{
7067 int ret = 0;
b0a4e7d8 7068 struct libipw_qos_information_element qos_info;
b095c381
JK		 7069
7070 if (priv == NULL)
7071 return -1;
7072
7073 qos_info.elementID = QOS_ELEMENT_ID;
b0a4e7d8 7074 qos_info.length = sizeof(struct libipw_qos_information_element) - 2;
b095c381
JK		 7075
7076 qos_info.version = QOS_VERSION_1;
7077 qos_info.ac_info = 0;
7078
7079 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
7080 qos_info.qui_type = QOS_OUI_TYPE;
7081 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
7082
7083 ret = ipw_send_qos_info_command(priv, &qos_info);
7084 if (ret != 0) {
7085 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
7086 }
7087 return ret;
7088}
7089
7090/*
7091* Set the QoS parameter with the association request structure
7092*/
7093static int ipw_qos_association(struct ipw_priv *priv,
b0a4e7d8 7094 struct libipw_network *network)
b095c381
JK		 7095{
7096 int err = 0;
b0a4e7d8
JL		 7097 struct libipw_qos_data *qos_data = NULL;
7098 struct libipw_qos_data ibss_data = {
b095c381
JK		 7099 .supported = 1,
7100 .active = 1,
7101 };
7102
7103 switch (priv->ieee->iw_mode) {
7104 case IW_MODE_ADHOC:
5d9428de 7105 BUG_ON(!(network->capability & WLAN_CAPABILITY_IBSS));
b095c381
JK		 7106
7107 qos_data = &ibss_data;
7108 break;
7109
7110 case IW_MODE_INFRA:
7111 qos_data = &network->qos_data;
7112 break;
7113
7114 default:
7115 BUG();
7116 break;
7117 }
7118
7119 err = ipw_qos_activate(priv, qos_data);
7120 if (err) {
7121 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
7122 return err;
7123 }
7124
7125 if (priv->qos_data.qos_enable && qos_data->supported) {
7126 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
7127 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
7128 return ipw_qos_set_info_element(priv);
7129 }
7130
7131 return 0;
7132}
7133
7134/*
0779bf2d
ML		 7135* handling the beaconing responses. if we get different QoS setting
7136* off the network from the associated setting, adjust the QoS
b095c381
JK		 7137* setting
7138*/
7139static int ipw_qos_association_resp(struct ipw_priv *priv,
b0a4e7d8 7140 struct libipw_network *network)
b095c381
JK		 7141{
7142 int ret = 0;
7143 unsigned long flags;
b0a4e7d8 7144 u32 size = sizeof(struct libipw_qos_parameters);
b095c381
JK		 7145 int set_qos_param = 0;
7146
afbf30a2
JK		 7147 if ((priv == NULL) || (network == NULL) ||
7148 (priv->assoc_network == NULL))
b095c381
JK		 7149 return ret;
7150
7151 if (!(priv->status & STATUS_ASSOCIATED))
7152 return ret;
7153
afbf30a2 7154 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
b095c381 7155 return ret;
b095c381
JK		 7156
7157 spin_lock_irqsave(&priv->ieee->lock, flags);
7158 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
afbf30a2 7159 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
b0a4e7d8 7160 sizeof(struct libipw_qos_data));
b095c381
JK		 7161 priv->assoc_network->qos_data.active = 1;
7162 if ((network->qos_data.old_param_count !=
7163 network->qos_data.param_count)) {
7164 set_qos_param = 1;
7165 network->qos_data.old_param_count =
7166 network->qos_data.param_count;
7167 }
7168
7169 } else {
afbf30a2
JK		 7170 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7171 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 7172 &def_parameters_CCK, size);
afbf30a2
JK		 7173 else
7174 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 7175 &def_parameters_OFDM, size);
b095c381
JK		 7176 priv->assoc_network->qos_data.active = 0;
7177 priv->assoc_network->qos_data.supported = 0;
7178 set_qos_param = 1;
7179 }
7180
7181 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7182
7183 if (set_qos_param == 1)
7184 schedule_work(&priv->qos_activate);
7185
7186 return ret;
7187}
7188
7189static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
7190{
7191 u32 ret = 0;
7192
7193 if ((priv == NULL))
7194 return 0;
7195
b0a4e7d8 7196 if (!(priv->ieee->modulation & LIBIPW_OFDM_MODULATION))
b095c381 7197 ret = priv->qos_data.burst_duration_CCK;
afbf30a2 7198 else
b095c381 7199 ret = priv->qos_data.burst_duration_OFDM;
afbf30a2 7200
b095c381
JK		 7201 return ret;
7202}
7203
7204/*
7205* Initialize the setting of QoS global
7206*/
7207static void ipw_qos_init(struct ipw_priv *priv, int enable,
7208 int burst_enable, u32 burst_duration_CCK,
7209 u32 burst_duration_OFDM)
7210{
7211 priv->qos_data.qos_enable = enable;
7212
7213 if (priv->qos_data.qos_enable) {
7214 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7215 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7216 IPW_DEBUG_QOS("QoS is enabled\n");
7217 } else {
7218 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7219 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7220 IPW_DEBUG_QOS("QoS is not enabled\n");
7221 }
7222
7223 priv->qos_data.burst_enable = burst_enable;
7224
7225 if (burst_enable) {
7226 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7227 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7228 } else {
7229 priv->qos_data.burst_duration_CCK = 0;
7230 priv->qos_data.burst_duration_OFDM = 0;
7231 }
7232}
7233
7234/*
7235* map the packet priority to the right TX Queue
7236*/
7237static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
7238{
7239 if (priority > 7 || !priv->qos_data.qos_enable)
7240 priority = 0;
7241
7242 return from_priority_to_tx_queue[priority] - 1;
7243}
7244
a5cf4fe6
ZY		 7245static int ipw_is_qos_active(struct net_device *dev,
7246 struct sk_buff *skb)
b095c381 7247{
b0a4e7d8
JL		 7248 struct ipw_priv *priv = libipw_priv(dev);
7249 struct libipw_qos_data *qos_data = NULL;
b095c381 7250 int active, supported;
a5cf4fe6
ZY		 7251 u8 *daddr = skb->data + ETH_ALEN;
7252 int unicast = !is_multicast_ether_addr(daddr);
b095c381
JK		 7253
7254 if (!(priv->status & STATUS_ASSOCIATED))
7255 return 0;
7256
7257 qos_data = &priv->assoc_network->qos_data;
7258
b095c381
JK		 7259 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7260 if (unicast == 0)
7261 qos_data->active = 0;
7262 else
7263 qos_data->active = qos_data->supported;
7264 }
b095c381
JK		 7265 active = qos_data->active;
7266 supported = qos_data->supported;
afbf30a2
JK		 7267 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
7268 "unicast %d\n",
7269 priv->qos_data.qos_enable, active, supported, unicast);
a5cf4fe6
ZY		 7270 if (active && priv->qos_data.qos_enable)
7271 return 1;
b095c381 7272
a5cf4fe6
ZY		 7273 return 0;
7274
7275}
7276/*
7277* add QoS parameter to the TX command
7278*/
7279static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
7280 u16 priority,
7281 struct tfd_data *tfd)
7282{
7283 int tx_queue_id = 0;
7284
7285
7286 tx_queue_id = from_priority_to_tx_queue[priority] - 1;
7287 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7288
7289 if (priv->qos_data.qos_no_ack_mask & (1UL << tx_queue_id)) {
7290 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
851ca268 7291 tfd->tfd.tfd_26.mchdr.qos_ctrl |= cpu_to_le16(CTRL_QOS_NO_ACK);
a5cf4fe6
ZY		 7292 }
7293 return 0;
b095c381
JK		 7294}
7295
7296/*
7297* background support to run QoS activate functionality
7298*/
c4028958 7299static void ipw_bg_qos_activate(struct work_struct *work)
b095c381 7300{
c4028958
DH		 7301 struct ipw_priv *priv =
7302 container_of(work, struct ipw_priv, qos_activate);
b095c381 7303
4644151b 7304 mutex_lock(&priv->mutex);
b095c381
JK		 7305
7306 if (priv->status & STATUS_ASSOCIATED)
7307 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7308
4644151b 7309 mutex_unlock(&priv->mutex);
b095c381
JK		 7310}
7311
3b9990cb 7312static int ipw_handle_probe_response(struct net_device *dev,
b0a4e7d8
JL		 7313 struct libipw_probe_response *resp,
7314 struct libipw_network *network)
b095c381 7315{
b0a4e7d8 7316 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7317 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7318 (network == priv->assoc_network));
43f66a6c 7319
3b9990cb 7320 ipw_qos_handle_probe_response(priv, active_network, network);
43f66a6c 7321
3b9990cb
JK		 7322 return 0;
7323}
43f66a6c 7324
3b9990cb 7325static int ipw_handle_beacon(struct net_device *dev,
b0a4e7d8
JL		 7326 struct libipw_beacon *resp,
7327 struct libipw_network *network)
3b9990cb 7328{
b0a4e7d8 7329 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7330 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7331 (network == priv->assoc_network));
bf79451e 7332
3b9990cb 7333 ipw_qos_handle_probe_response(priv, active_network, network);
bf79451e 7334
b095c381
JK		 7335 return 0;
7336}
bf79451e 7337
3b9990cb 7338static int ipw_handle_assoc_response(struct net_device *dev,
b0a4e7d8
JL		 7339 struct libipw_assoc_response *resp,
7340 struct libipw_network *network)
3b9990cb 7341{
b0a4e7d8 7342 struct ipw_priv *priv = libipw_priv(dev);
3b9990cb
JK		 7343 ipw_qos_association_resp(priv, network);
7344 return 0;
7345}
43f66a6c 7346
b0a4e7d8 7347static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
b095c381
JK		 7348 *qos_param)
7349{
4e22699f
ZY		 7350 return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7351 sizeof(*qos_param) * 3, qos_param);
b095c381
JK		 7352}
7353
b0a4e7d8 7354static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
b095c381
JK		 7355 *qos_param)
7356{
4e22699f
ZY		 7357 return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7358 qos_param);
43f66a6c
JK		 7359}
7360
e43e3c1e 7361#endif /* CONFIG_IPW2200_QOS */
b095c381 7362
43f66a6c 7363static int ipw_associate_network(struct ipw_priv *priv,
b0a4e7d8 7364 struct libipw_network *network,
0edd5b44 7365 struct ipw_supported_rates *rates, int roaming)
43f66a6c
JK		 7366{
7367 int err;
9387b7ca 7368 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 7369
7370 if (priv->config & CFG_FIXED_RATE)
b095c381 7371 ipw_set_fixed_rate(priv, network->mode);
43f66a6c
JK		 7372
7373 if (!(priv->config & CFG_STATIC_ESSID)) {
bf79451e 7374 priv->essid_len = min(network->ssid_len,
0edd5b44 7375 (u8) IW_ESSID_MAX_SIZE);
43f66a6c
JK		 7376 memcpy(priv->essid, network->ssid, priv->essid_len);
7377 }
7378
7379 network->last_associate = jiffies;
7380
7381 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7382 priv->assoc_request.channel = network->channel;
3e234b4e
ZY		 7383 priv->assoc_request.auth_key = 0;
7384
43f66a6c 7385 if ((priv->capability & CAP_PRIVACY_ON) &&
3e234b4e 7386 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
43f66a6c 7387 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
b095c381
JK		 7388 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7389
1ba61e05 7390 if (priv->ieee->sec.level == SEC_LEVEL_1)
b095c381 7391 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
3e234b4e
ZY		 7392
7393 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7394 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7395 priv->assoc_request.auth_type = AUTH_LEAP;
7396 else
43f66a6c 7397 priv->assoc_request.auth_type = AUTH_OPEN;
43f66a6c 7398
b095c381 7399 if (priv->ieee->wpa_ie_len) {
5b5e807f 7400 priv->assoc_request.policy_support = cpu_to_le16(0x02); /* RSN active */
ea2b26e0
JK		 7401 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7402 priv->ieee->wpa_ie_len);
7403 }
43f66a6c 7404
bf79451e
JG		 7405 /*
7406 * It is valid for our ieee device to support multiple modes, but
7407 * when it comes to associating to a given network we have to choose
43f66a6c
JK		 7408 * just one mode.
7409 */
7410 if (network->mode & priv->ieee->mode & IEEE_A)
7411 priv->assoc_request.ieee_mode = IPW_A_MODE;
7412 else if (network->mode & priv->ieee->mode & IEEE_G)
7413 priv->assoc_request.ieee_mode = IPW_G_MODE;
7414 else if (network->mode & priv->ieee->mode & IEEE_B)
7415 priv->assoc_request.ieee_mode = IPW_B_MODE;
7416
5b5e807f 7417 priv->assoc_request.capability = cpu_to_le16(network->capability);
ea2b26e0
JK		 7418 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7419 && !(priv->config & CFG_PREAMBLE_LONG)) {
7420 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7421 } else {
7422 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7423
7424 /* Clear the short preamble if we won't be supporting it */
7425 priv->assoc_request.capability &=
5b5e807f 7426 ~cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
ea2b26e0
JK		 7427 }
7428
afbf30a2
JK		 7429 /* Clear capability bits that aren't used in Ad Hoc */
7430 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7431 priv->assoc_request.capability &=
5b5e807f 7432 ~cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME);
afbf30a2 7433
70f23fd6 7434 IPW_DEBUG_ASSOC("%ssociation attempt: '%s', channel %d, "
ea2b26e0 7435 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
43f66a6c 7436 roaming ? "Rea" : "A",
9387b7ca 7437 print_ssid(ssid, priv->essid, priv->essid_len),
bf79451e
JG		 7438 network->channel,
7439 ipw_modes[priv->assoc_request.ieee_mode],
7440 rates->num_rates,
ea2b26e0
JK		 7441 (priv->assoc_request.preamble_length ==
7442 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7443 network->capability &
7444 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
43f66a6c 7445 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
bf79451e
JG		 7446 priv->capability & CAP_PRIVACY_ON ?
7447 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
43f66a6c
JK		 7448 "(open)") : "",
7449 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
bf79451e 7450 priv->capability & CAP_PRIVACY_ON ?
b095c381 7451 '1' + priv->ieee->sec.active_key : '.',
0edd5b44 7452 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
43f66a6c 7453
5b5e807f 7454 priv->assoc_request.beacon_interval = cpu_to_le16(network->beacon_interval);
43f66a6c 7455 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
0edd5b44 7456 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
43f66a6c
JK		 7457 priv->assoc_request.assoc_type = HC_IBSS_START;
7458 priv->assoc_request.assoc_tsf_msw = 0;
7459 priv->assoc_request.assoc_tsf_lsw = 0;
7460 } else {
7461 if (unlikely(roaming))
7462 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7463 else
7464 priv->assoc_request.assoc_type = HC_ASSOCIATE;
5b5e807f
AV		 7465 priv->assoc_request.assoc_tsf_msw = cpu_to_le32(network->time_stamp[1]);
7466 priv->assoc_request.assoc_tsf_lsw = cpu_to_le32(network->time_stamp[0]);
43f66a6c
JK		 7467 }
7468
afbf30a2 7469 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
43f66a6c
JK		 7470
7471 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7472 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
5b5e807f 7473 priv->assoc_request.atim_window = cpu_to_le16(network->atim_window);
43f66a6c 7474 } else {
afbf30a2 7475 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
43f66a6c
JK		 7476 priv->assoc_request.atim_window = 0;
7477 }
7478
5b5e807f 7479 priv->assoc_request.listen_interval = cpu_to_le16(network->listen_interval);
bf79451e 7480
43f66a6c
JK		 7481 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7482 if (err) {
7483 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7484 return err;
7485 }
7486
7487 rates->ieee_mode = priv->assoc_request.ieee_mode;
7488 rates->purpose = IPW_RATE_CONNECT;
7489 ipw_send_supported_rates(priv, rates);
bf79451e 7490
43f66a6c
JK		 7491 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7492 priv->sys_config.dot11g_auto_detection = 1;
7493 else
7494 priv->sys_config.dot11g_auto_detection = 0;
c848d0af
JK		 7495
7496 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7497 priv->sys_config.answer_broadcast_ssid_probe = 1;
7498 else
7499 priv->sys_config.answer_broadcast_ssid_probe = 0;
7500
d685b8c2 7501 err = ipw_send_system_config(priv);
43f66a6c
JK		 7502 if (err) {
7503 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7504 return err;
7505 }
bf79451e 7506
43f66a6c 7507 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
ea2b26e0 7508 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
43f66a6c
JK		 7509 if (err) {
7510 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7511 return err;
7512 }
7513
7514 /*
7515 * If preemption is enabled, it is possible for the association
7516 * to complete before we return from ipw_send_associate. Therefore
7517 * we have to be sure and update our priviate data first.
7518 */
7519 priv->channel = network->channel;
7520 memcpy(priv->bssid, network->bssid, ETH_ALEN);
bf79451e 7521 priv->status |= STATUS_ASSOCIATING;
43f66a6c
JK		 7522 priv->status &= ~STATUS_SECURITY_UPDATED;
7523
7524 priv->assoc_network = network;
7525
e43e3c1e 7526#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 7527 ipw_qos_association(priv, network);
7528#endif
7529
43f66a6c
JK		 7530 err = ipw_send_associate(priv, &priv->assoc_request);
7531 if (err) {
7532 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7533 return err;
7534 }
bf79451e 7535
9fd1ea42 7536 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' %pM\n",
9387b7ca 7537 print_ssid(ssid, priv->essid, priv->essid_len),
e174961c 7538 priv->bssid);
43f66a6c
JK		 7539
7540 return 0;
7541}
7542
7543static void ipw_roam(void *data)
7544{
7545 struct ipw_priv *priv = data;
b0a4e7d8 7546 struct libipw_network *network = NULL;
43f66a6c
JK		 7547 struct ipw_network_match match = {
7548 .network = priv->assoc_network
7549 };
7550
7551 /* The roaming process is as follows:
bf79451e
JG		 7552 *
7553 * 1. Missed beacon threshold triggers the roaming process by
43f66a6c
JK		 7554 * setting the status ROAM bit and requesting a scan.
7555 * 2. When the scan completes, it schedules the ROAM work
7556 * 3. The ROAM work looks at all of the known networks for one that
7557 * is a better network than the currently associated. If none
7558 * found, the ROAM process is over (ROAM bit cleared)
7559 * 4. If a better network is found, a disassociation request is
7560 * sent.
7561 * 5. When the disassociation completes, the roam work is again
7562 * scheduled. The second time through, the driver is no longer
7563 * associated, and the newly selected network is sent an
bf79451e 7564 * association request.
43f66a6c
JK		 7565 * 6. At this point ,the roaming process is complete and the ROAM
7566 * status bit is cleared.
7567 */
7568
7569 /* If we are no longer associated, and the roaming bit is no longer
7570 * set, then we are not actively roaming, so just return */
7571 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7572 return;
bf79451e 7573
43f66a6c 7574 if (priv->status & STATUS_ASSOCIATED) {
bf79451e 7575 /* First pass through ROAM process -- look for a better
43f66a6c 7576 * network */
a613bffd 7577 unsigned long flags;
43f66a6c
JK		 7578 u8 rssi = priv->assoc_network->stats.rssi;
7579 priv->assoc_network->stats.rssi = -128;
a613bffd 7580 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c
JK		 7581 list_for_each_entry(network, &priv->ieee->network_list, list) {
7582 if (network != priv->assoc_network)
7583 ipw_best_network(priv, &match, network, 1);
7584 }
a613bffd 7585 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c 7586 priv->assoc_network->stats.rssi = rssi;
bf79451e 7587
43f66a6c
JK		 7588 if (match.network == priv->assoc_network) {
7589 IPW_DEBUG_ASSOC("No better APs in this network to "
7590 "roam to.\n");
7591 priv->status &= ~STATUS_ROAMING;
7592 ipw_debug_config(priv);
7593 return;
7594 }
bf79451e 7595
43f66a6c
JK		 7596 ipw_send_disassociate(priv, 1);
7597 priv->assoc_network = match.network;
7598
7599 return;
bf79451e 7600 }
43f66a6c
JK		 7601
7602 /* Second pass through ROAM process -- request association */
7603 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7604 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7605 priv->status &= ~STATUS_ROAMING;
7606}
7607
c4028958 7608static void ipw_bg_roam(struct work_struct *work)
c848d0af 7609{
c4028958
DH		 7610 struct ipw_priv *priv =
7611 container_of(work, struct ipw_priv, roam);
4644151b 7612 mutex_lock(&priv->mutex);
c4028958 7613 ipw_roam(priv);
4644151b 7614 mutex_unlock(&priv->mutex);
c848d0af
JK		 7615}
7616
7617static int ipw_associate(void *data)
43f66a6c
JK		 7618{
7619 struct ipw_priv *priv = data;
7620
b0a4e7d8 7621 struct libipw_network *network = NULL;
43f66a6c
JK		 7622 struct ipw_network_match match = {
7623 .network = NULL
7624 };
7625 struct ipw_supported_rates *rates;
7626 struct list_head *element;
a613bffd 7627 unsigned long flags;
9387b7ca 7628 DECLARE_SSID_BUF(ssid);
43f66a6c 7629
b095c381
JK		 7630 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7631 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7632 return 0;
7633 }
7634
c848d0af 7635 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
afbf30a2
JK		 7636 IPW_DEBUG_ASSOC("Not attempting association (already in "
7637 "progress)\n");
c848d0af
JK		 7638 return 0;
7639 }
7640
e6324726
HL		 7641 if (priv->status & STATUS_DISASSOCIATING) {
7642 IPW_DEBUG_ASSOC("Not attempting association (in "
7643 "disassociating)\n ");
bcb6d916 7644 schedule_work(&priv->associate);
e6324726
HL		 7645 return 0;
7646 }
7647
c848d0af 7648 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
afbf30a2
JK		 7649 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7650 "initialized)\n");
c848d0af
JK		 7651 return 0;
7652 }
43f66a6c
JK		 7653
7654 if (!(priv->config & CFG_ASSOCIATE) &&
3e4127fa 7655 !(priv->config & (CFG_STATIC_ESSID | CFG_STATIC_BSSID))) {
43f66a6c 7656 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
c848d0af 7657 return 0;
43f66a6c
JK		 7658 }
7659
a613bffd
JK		 7660 /* Protect our use of the network_list */
7661 spin_lock_irqsave(&priv->ieee->lock, flags);
bf79451e 7662 list_for_each_entry(network, &priv->ieee->network_list, list)
0edd5b44 7663 ipw_best_network(priv, &match, network, 0);
43f66a6c
JK		 7664
7665 network = match.network;
7666 rates = &match.rates;
7667
7668 if (network == NULL &&
7669 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7670 priv->config & CFG_ADHOC_CREATE &&
7671 priv->config & CFG_STATIC_ESSID &&
a6d4eae8
DW		 7672 priv->config & CFG_STATIC_CHANNEL) {
7673 /* Use oldest network if the free list is empty */
7674 if (list_empty(&priv->ieee->network_free_list)) {
b0a4e7d8
JL		 7675 struct libipw_network *oldest = NULL;
7676 struct libipw_network *target;
a6d4eae8
DW		 7677
7678 list_for_each_entry(target, &priv->ieee->network_list, list) {
7679 if ((oldest == NULL) ||
7680 (target->last_scanned < oldest->last_scanned))
7681 oldest = target;
7682 }
7683
7684 /* If there are no more slots, expire the oldest */
7685 list_del(&oldest->list);
7686 target = oldest;
e174961c 7687 IPW_DEBUG_ASSOC("Expired '%s' (%pM) from "
a6d4eae8 7688 "network list.\n",
9387b7ca
JL		 7689 print_ssid(ssid, target->ssid,
7690 target->ssid_len),
e174961c 7691 target->bssid);
a6d4eae8
DW		 7692 list_add_tail(&target->list,
7693 &priv->ieee->network_free_list);
7694 }
7695
43f66a6c 7696 element = priv->ieee->network_free_list.next;
b0a4e7d8 7697 network = list_entry(element, struct libipw_network, list);
43f66a6c
JK		 7698 ipw_adhoc_create(priv, network);
7699 rates = &priv->rates;
7700 list_del(element);
7701 list_add_tail(&network->list, &priv->ieee->network_list);
7702 }
a613bffd 7703 spin_unlock_irqrestore(&priv->ieee->lock, flags);
bf79451e 7704
43f66a6c
JK		 7705 /* If we reached the end of the list, then we don't have any valid
7706 * matching APs */
7707 if (!network) {
7708 ipw_debug_config(priv);
7709
b095c381
JK		 7710 if (!(priv->status & STATUS_SCANNING)) {
7711 if (!(priv->config & CFG_SPEED_SCAN))
bcb6d916
TH		 7712 schedule_delayed_work(&priv->request_scan,
7713 SCAN_INTERVAL);
b095c381 7714 else
bcb6d916 7715 schedule_delayed_work(&priv->request_scan, 0);
b095c381 7716 }
bf79451e 7717
c848d0af 7718 return 0;
43f66a6c
JK		 7719 }
7720
7721 ipw_associate_network(priv, network, rates, 0);
c848d0af
JK		 7722
7723 return 1;
7724}
7725
c4028958 7726static void ipw_bg_associate(struct work_struct *work)
c848d0af 7727{
c4028958
DH		 7728 struct ipw_priv *priv =
7729 container_of(work, struct ipw_priv, associate);
4644151b 7730 mutex_lock(&priv->mutex);
c4028958 7731 ipw_associate(priv);
4644151b 7732 mutex_unlock(&priv->mutex);
43f66a6c 7733}
bf79451e 7734
b095c381
JK		 7735static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7736 struct sk_buff *skb)
7737{
7738 struct ieee80211_hdr *hdr;
7739 u16 fc;
7740
7741 hdr = (struct ieee80211_hdr *)skb->data;
72118015 7742 fc = le16_to_cpu(hdr->frame_control);
b095c381
JK		 7743 if (!(fc & IEEE80211_FCTL_PROTECTED))
7744 return;
7745
7746 fc &= ~IEEE80211_FCTL_PROTECTED;
72118015 7747 hdr->frame_control = cpu_to_le16(fc);
b095c381
JK		 7748 switch (priv->ieee->sec.level) {
7749 case SEC_LEVEL_3:
7750 /* Remove CCMP HDR */
b0a4e7d8
JL		 7751 memmove(skb->data + LIBIPW_3ADDR_LEN,
7752 skb->data + LIBIPW_3ADDR_LEN + 8,
7753 skb->len - LIBIPW_3ADDR_LEN - 8);
f4ff497d 7754 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
b095c381
JK		 7755 break;
7756 case SEC_LEVEL_2:
7757 break;
7758 case SEC_LEVEL_1:
7759 /* Remove IV */
b0a4e7d8
JL		 7760 memmove(skb->data + LIBIPW_3ADDR_LEN,
7761 skb->data + LIBIPW_3ADDR_LEN + 4,
7762 skb->len - LIBIPW_3ADDR_LEN - 4);
f4ff497d 7763 skb_trim(skb, skb->len - 8); /* IV + ICV */
b095c381
JK		 7764 break;
7765 case SEC_LEVEL_0:
7766 break;
7767 default:
af901ca1 7768 printk(KERN_ERR "Unknown security level %d\n",
b095c381
JK		 7769 priv->ieee->sec.level);
7770 break;
7771 }
43f66a6c 7772}
bf79451e 7773
b095c381
JK		 7774static void ipw_handle_data_packet(struct ipw_priv *priv,
7775 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 7776 struct libipw_rx_stats *stats)
43f66a6c 7777{
ce55cbaf 7778 struct net_device *dev = priv->net_dev;
b0a4e7d8 7779 struct libipw_hdr_4addr *hdr;
43f66a6c
JK		 7780 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7781
7782 /* We received data from the HW, so stop the watchdog */
ce55cbaf 7783 dev->trans_start = jiffies;
43f66a6c 7784
bf79451e 7785 /* We only process data packets if the
43f66a6c 7786 * interface is open */
a613bffd 7787 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
43f66a6c 7788 skb_tailroom(rxb->skb))) {
ce55cbaf 7789 dev->stats.rx_errors++;
43f66a6c
JK		 7790 priv->wstats.discard.misc++;
7791 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7792 return;
7793 } else if (unlikely(!netif_running(priv->net_dev))) {
ce55cbaf 7794 dev->stats.rx_dropped++;
43f66a6c
JK		 7795 priv->wstats.discard.misc++;
7796 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7797 return;
7798 }
7799
7800 /* Advance skb->data to the start of the actual payload */
aaa4d308 7801 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
43f66a6c
JK		 7802
7803 /* Set the size of the skb to the size of the frame */
a613bffd 7804 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
43f66a6c
JK		 7805
7806 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7807
b095c381 7808 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
b0a4e7d8 7809 hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
567deaf6 7810 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
3c19065a 7811 (is_multicast_ether_addr(hdr->addr1) ?
567deaf6 7812 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
b095c381
JK		 7813 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7814
b0a4e7d8 7815 if (!libipw_rx(priv->ieee, rxb->skb, stats))
ce55cbaf 7816 dev->stats.rx_errors++;
b0a4e7d8 7817 else { /* libipw_rx succeeded, so it now owns the SKB */
43f66a6c 7818 rxb->skb = NULL;
b095c381 7819 __ipw_led_activity_on(priv);
a613bffd 7820 }
43f66a6c
JK		 7821}
7822
459d4087 7823#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 7824static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7825 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 7826 struct libipw_rx_stats *stats)
24a47dbd 7827{
ce55cbaf 7828 struct net_device *dev = priv->net_dev;
24a47dbd
MK		 7829 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7830 struct ipw_rx_frame *frame = &pkt->u.frame;
7831
7832 /* initial pull of some data */
7833 u16 received_channel = frame->received_channel;
7834 u8 antennaAndPhy = frame->antennaAndPhy;
7835 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7836 u16 pktrate = frame->rate;
7837
7838 /* Magic struct that slots into the radiotap header -- no reason
7839 * to build this manually element by element, we can write it much
7840 * more efficiently than we can parse it. ORDER MATTERS HERE */
d685b8c2 7841 struct ipw_rt_hdr *ipw_rt;
24a47dbd
MK		 7842
7843 short len = le16_to_cpu(pkt->u.frame.length);
7844
7845 /* We received data from the HW, so stop the watchdog */
ce55cbaf 7846 dev->trans_start = jiffies;
24a47dbd
MK		 7847
7848 /* We only process data packets if the
7849 * interface is open */
7850 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7851 skb_tailroom(rxb->skb))) {
ce55cbaf 7852 dev->stats.rx_errors++;
24a47dbd
MK		 7853 priv->wstats.discard.misc++;
7854 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7855 return;
7856 } else if (unlikely(!netif_running(priv->net_dev))) {
ce55cbaf 7857 dev->stats.rx_dropped++;
24a47dbd
MK		 7858 priv->wstats.discard.misc++;
7859 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7860 return;
7861 }
7862
7863 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7864 * that now */
7865 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7866 /* FIXME: Should alloc bigger skb instead */
ce55cbaf 7867 dev->stats.rx_dropped++;
24a47dbd
MK		 7868 priv->wstats.discard.misc++;
7869 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7870 return;
7871 }
7872
7873 /* copy the frame itself */
7874 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7875 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7876
24a47dbd
MK		 7877 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7878
7879 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7880 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
743b84d2 7881 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total header+data */
24a47dbd
MK		 7882
7883 /* Big bitfield of all the fields we provide in radiotap */
743b84d2
AV		 7884 ipw_rt->rt_hdr.it_present = cpu_to_le32(
7885 (1 << IEEE80211_RADIOTAP_TSFT) |
4b1f8a99 7886 (1 << IEEE80211_RADIOTAP_FLAGS) |
24a47dbd
MK		 7887 (1 << IEEE80211_RADIOTAP_RATE) |
7888 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7889 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
d685b8c2 7890 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
24a47dbd
MK		 7891 (1 << IEEE80211_RADIOTAP_ANTENNA));
7892
7893 /* Zero the flags, we'll add to them as we go */
7894 ipw_rt->rt_flags = 0;
4b1f8a99
ZY		 7895 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7896 frame->parent_tsf[2] << 16 |
7897 frame->parent_tsf[1] << 8 |
7898 frame->parent_tsf[0]);
24a47dbd
MK		 7899
7900 /* Convert signal to DBM */
7901 ipw_rt->rt_dbmsignal = antsignal;
21f8a73f 7902 ipw_rt->rt_dbmnoise = (s8) le16_to_cpu(frame->noise);
24a47dbd
MK		 7903
7904 /* Convert the channel data and set the flags */
7905 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7906 if (received_channel > 14) { /* 802.11a */
7907 ipw_rt->rt_chbitmask =
7908 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7909 } else if (antennaAndPhy & 32) { /* 802.11b */
7910 ipw_rt->rt_chbitmask =
7911 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7912 } else { /* 802.11g */
7913 ipw_rt->rt_chbitmask =
472caf8c 7914 cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
24a47dbd
MK		 7915 }
7916
7917 /* set the rate in multiples of 500k/s */
7918 switch (pktrate) {
7919 case IPW_TX_RATE_1MB:
7920 ipw_rt->rt_rate = 2;
7921 break;
7922 case IPW_TX_RATE_2MB:
7923 ipw_rt->rt_rate = 4;
7924 break;
7925 case IPW_TX_RATE_5MB:
7926 ipw_rt->rt_rate = 10;
7927 break;
7928 case IPW_TX_RATE_6MB:
7929 ipw_rt->rt_rate = 12;
7930 break;
7931 case IPW_TX_RATE_9MB:
7932 ipw_rt->rt_rate = 18;
7933 break;
7934 case IPW_TX_RATE_11MB:
7935 ipw_rt->rt_rate = 22;
7936 break;
7937 case IPW_TX_RATE_12MB:
7938 ipw_rt->rt_rate = 24;
7939 break;
7940 case IPW_TX_RATE_18MB:
7941 ipw_rt->rt_rate = 36;
7942 break;
7943 case IPW_TX_RATE_24MB:
7944 ipw_rt->rt_rate = 48;
7945 break;
7946 case IPW_TX_RATE_36MB:
7947 ipw_rt->rt_rate = 72;
7948 break;
7949 case IPW_TX_RATE_48MB:
7950 ipw_rt->rt_rate = 96;
7951 break;
7952 case IPW_TX_RATE_54MB:
7953 ipw_rt->rt_rate = 108;
7954 break;
7955 default:
7956 ipw_rt->rt_rate = 0;
7957 break;
7958 }
7959
7960 /* antenna number */
7961 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7962
7963 /* set the preamble flag if we have it */
7964 if ((antennaAndPhy & 64))
7965 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7966
7967 /* Set the size of the skb to the size of the frame */
7968 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
43f66a6c
JK		 7969
7970 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7971
b0a4e7d8 7972 if (!libipw_rx(priv->ieee, rxb->skb, stats))
ce55cbaf 7973 dev->stats.rx_errors++;
b0a4e7d8 7974 else { /* libipw_rx succeeded, so it now owns the SKB */
24a47dbd
MK		 7975 rxb->skb = NULL;
7976 /* no LED during capture */
7977 }
7978}
7979#endif
7980
d685b8c2 7981#ifdef CONFIG_IPW2200_PROMISCUOUS
b0a4e7d8 7982#define libipw_is_probe_response(fc) \
d685b8c2
ZY		 7983 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT && \
7984 (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP )
7985
b0a4e7d8 7986#define libipw_is_management(fc) \
d685b8c2
ZY		 7987 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT)
7988
b0a4e7d8 7989#define libipw_is_control(fc) \
d685b8c2
ZY		 7990 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL)
7991
b0a4e7d8 7992#define libipw_is_data(fc) \
d685b8c2
ZY		 7993 ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA)
7994
b0a4e7d8 7995#define libipw_is_assoc_request(fc) \
d685b8c2
ZY		 7996 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_ASSOC_REQ)
7997
b0a4e7d8 7998#define libipw_is_reassoc_request(fc) \
d685b8c2
ZY		 7999 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_REASSOC_REQ)
8000
8001static void ipw_handle_promiscuous_rx(struct ipw_priv *priv,
8002 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 8003 struct libipw_rx_stats *stats)
d685b8c2 8004{
ce55cbaf 8005 struct net_device *dev = priv->prom_net_dev;
d685b8c2
ZY		 8006 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
8007 struct ipw_rx_frame *frame = &pkt->u.frame;
8008 struct ipw_rt_hdr *ipw_rt;
8009
8010 /* First cache any information we need before we overwrite
8011 * the information provided in the skb from the hardware */
8012 struct ieee80211_hdr *hdr;
8013 u16 channel = frame->received_channel;
8014 u8 phy_flags = frame->antennaAndPhy;
8015 s8 signal = frame->rssi_dbm - IPW_RSSI_TO_DBM;
21f8a73f 8016 s8 noise = (s8) le16_to_cpu(frame->noise);
d685b8c2
ZY		 8017 u8 rate = frame->rate;
8018 short len = le16_to_cpu(pkt->u.frame.length);
d685b8c2
ZY		 8019 struct sk_buff *skb;
8020 int hdr_only = 0;
8021 u16 filter = priv->prom_priv->filter;
8022
8023 /* If the filter is set to not include Rx frames then return */
8024 if (filter & IPW_PROM_NO_RX)
8025 return;
8026
d685b8c2 8027 /* We received data from the HW, so stop the watchdog */
ce55cbaf 8028 dev->trans_start = jiffies;
d685b8c2
ZY		 8029
8030 if (unlikely((len + IPW_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) {
ce55cbaf 8031 dev->stats.rx_errors++;
d685b8c2
ZY		 8032 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
8033 return;
8034 }
8035
8036 /* We only process data packets if the interface is open */
ce55cbaf
SH		 8037 if (unlikely(!netif_running(dev))) {
8038 dev->stats.rx_dropped++;
d685b8c2
ZY		 8039 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
8040 return;
8041 }
8042
8043 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
8044 * that now */
8045 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
8046 /* FIXME: Should alloc bigger skb instead */
ce55cbaf 8047 dev->stats.rx_dropped++;
d685b8c2
ZY		 8048 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
8049 return;
8050 }
8051
8052 hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
b0a4e7d8 8053 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8054 if (filter & IPW_PROM_NO_MGMT)
8055 return;
8056 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
8057 hdr_only = 1;
b0a4e7d8 8058 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8059 if (filter & IPW_PROM_NO_CTL)
8060 return;
8061 if (filter & IPW_PROM_CTL_HEADER_ONLY)
8062 hdr_only = 1;
b0a4e7d8 8063 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 8064 if (filter & IPW_PROM_NO_DATA)
8065 return;
8066 if (filter & IPW_PROM_DATA_HEADER_ONLY)
8067 hdr_only = 1;
8068 }
8069
8070 /* Copy the SKB since this is for the promiscuous side */
8071 skb = skb_copy(rxb->skb, GFP_ATOMIC);
8072 if (skb == NULL) {
8073 IPW_ERROR("skb_clone failed for promiscuous copy.\n");
8074 return;
8075 }
8076
8077 /* copy the frame data to write after where the radiotap header goes */
8078 ipw_rt = (void *)skb->data;
8079
8080 if (hdr_only)
b0a4e7d8 8081 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
d685b8c2
ZY		 8082
8083 memcpy(ipw_rt->payload, hdr, len);
8084
d685b8c2
ZY		 8085 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
8086 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
743b84d2 8087 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt)); /* total header+data */
d685b8c2
ZY		 8088
8089 /* Set the size of the skb to the size of the frame */
743b84d2 8090 skb_put(skb, sizeof(*ipw_rt) + len);
d685b8c2
ZY		 8091
8092 /* Big bitfield of all the fields we provide in radiotap */
743b84d2
AV		 8093 ipw_rt->rt_hdr.it_present = cpu_to_le32(
8094 (1 << IEEE80211_RADIOTAP_TSFT) |
4b1f8a99 8095 (1 << IEEE80211_RADIOTAP_FLAGS) |
d685b8c2
ZY		 8096 (1 << IEEE80211_RADIOTAP_RATE) |
8097 (1 << IEEE80211_RADIOTAP_CHANNEL) |
8098 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
8099 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
8100 (1 << IEEE80211_RADIOTAP_ANTENNA));
8101
8102 /* Zero the flags, we'll add to them as we go */
8103 ipw_rt->rt_flags = 0;
4b1f8a99
ZY		 8104 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
8105 frame->parent_tsf[2] << 16 |
8106 frame->parent_tsf[1] << 8 |
8107 frame->parent_tsf[0]);
d685b8c2
ZY		 8108
8109 /* Convert to DBM */
8110 ipw_rt->rt_dbmsignal = signal;
8111 ipw_rt->rt_dbmnoise = noise;
8112
8113 /* Convert the channel data and set the flags */
8114 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(channel));
8115 if (channel > 14) { /* 802.11a */
8116 ipw_rt->rt_chbitmask =
8117 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
8118 } else if (phy_flags & (1 << 5)) { /* 802.11b */
8119 ipw_rt->rt_chbitmask =
8120 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
8121 } else { /* 802.11g */
8122 ipw_rt->rt_chbitmask =
472caf8c 8123 cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
d685b8c2
ZY		 8124 }
8125
8126 /* set the rate in multiples of 500k/s */
8127 switch (rate) {
8128 case IPW_TX_RATE_1MB:
8129 ipw_rt->rt_rate = 2;
8130 break;
8131 case IPW_TX_RATE_2MB:
8132 ipw_rt->rt_rate = 4;
8133 break;
8134 case IPW_TX_RATE_5MB:
8135 ipw_rt->rt_rate = 10;
8136 break;
8137 case IPW_TX_RATE_6MB:
8138 ipw_rt->rt_rate = 12;
8139 break;
8140 case IPW_TX_RATE_9MB:
8141 ipw_rt->rt_rate = 18;
8142 break;
8143 case IPW_TX_RATE_11MB:
8144 ipw_rt->rt_rate = 22;
8145 break;
8146 case IPW_TX_RATE_12MB:
8147 ipw_rt->rt_rate = 24;
8148 break;
8149 case IPW_TX_RATE_18MB:
8150 ipw_rt->rt_rate = 36;
8151 break;
8152 case IPW_TX_RATE_24MB:
8153 ipw_rt->rt_rate = 48;
8154 break;
8155 case IPW_TX_RATE_36MB:
8156 ipw_rt->rt_rate = 72;
8157 break;
8158 case IPW_TX_RATE_48MB:
8159 ipw_rt->rt_rate = 96;
8160 break;
8161 case IPW_TX_RATE_54MB:
8162 ipw_rt->rt_rate = 108;
8163 break;
8164 default:
8165 ipw_rt->rt_rate = 0;
8166 break;
8167 }
8168
8169 /* antenna number */
8170 ipw_rt->rt_antenna = (phy_flags & 3);
8171
8172 /* set the preamble flag if we have it */
8173 if (phy_flags & (1 << 6))
8174 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8175
8176 IPW_DEBUG_RX("Rx packet of %d bytes.\n", skb->len);
8177
b0a4e7d8 8178 if (!libipw_rx(priv->prom_priv->ieee, skb, stats)) {
ce55cbaf 8179 dev->stats.rx_errors++;
d685b8c2
ZY		 8180 dev_kfree_skb_any(skb);
8181 }
8182}
8183#endif
8184
858119e1 8185static int is_network_packet(struct ipw_priv *priv,
b0a4e7d8 8186 struct libipw_hdr_4addr *header)
ea2b26e0 8187{
25985edc 8188 /* Filter incoming packets to determine if they are targeted toward
ea2b26e0
JK		 8189 * this network, discarding packets coming from ourselves */
8190 switch (priv->ieee->iw_mode) {
a613bffd 8191 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
c848d0af
JK		 8192 /* packets from our adapter are dropped (echo) */
8193 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
8194 return 0;
8195
90700fd9 8196 /* {broad,multi}cast packets to our BSSID go through */
3c19065a 8197 if (is_multicast_ether_addr(header->addr1))
ea2b26e0 8198 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
a613bffd
JK		 8199
8200 /* packets to our adapter go through */
8201 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8202 ETH_ALEN);
a613bffd 8203
90700fd9 8204 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
c848d0af
JK		 8205 /* packets from our adapter are dropped (echo) */
8206 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
8207 return 0;
8208
90700fd9 8209 /* {broad,multi}cast packets to our BSS go through */
3c19065a 8210 if (is_multicast_ether_addr(header->addr1))
a613bffd
JK		 8211 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
8212
8213 /* packets to our adapter go through */
8214 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8215 ETH_ALEN);
ea2b26e0 8216 }
a613bffd 8217
ea2b26e0
JK		 8218 return 1;
8219}
8220
afbf30a2
JK		 8221#define IPW_PACKET_RETRY_TIME HZ
8222
858119e1 8223static int is_duplicate_packet(struct ipw_priv *priv,
b0a4e7d8 8224 struct libipw_hdr_4addr *header)
afbf30a2 8225{
afbf30a2
JK		 8226 u16 sc = le16_to_cpu(header->seq_ctl);
8227 u16 seq = WLAN_GET_SEQ_SEQ(sc);
8228 u16 frag = WLAN_GET_SEQ_FRAG(sc);
8229 u16 *last_seq, *last_frag;
8230 unsigned long *last_time;
8231
8232 switch (priv->ieee->iw_mode) {
8233 case IW_MODE_ADHOC:
8234 {
8235 struct list_head *p;
8236 struct ipw_ibss_seq *entry = NULL;
8237 u8 *mac = header->addr2;
8238 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
8239
8240 __list_for_each(p, &priv->ibss_mac_hash[index]) {
8241 entry =
8242 list_entry(p, struct ipw_ibss_seq, list);
8243 if (!memcmp(entry->mac, mac, ETH_ALEN))
8244 break;
8245 }
8246 if (p == &priv->ibss_mac_hash[index]) {
8247 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
8248 if (!entry) {
8249 IPW_ERROR
8250 ("Cannot malloc new mac entry\n");
8251 return 0;
8252 }
8253 memcpy(entry->mac, mac, ETH_ALEN);
8254 entry->seq_num = seq;
8255 entry->frag_num = frag;
8256 entry->packet_time = jiffies;
8257 list_add(&entry->list,
8258 &priv->ibss_mac_hash[index]);
8259 return 0;
8260 }
8261 last_seq = &entry->seq_num;
8262 last_frag = &entry->frag_num;
8263 last_time = &entry->packet_time;
8264 break;
8265 }
8266 case IW_MODE_INFRA:
8267 last_seq = &priv->last_seq_num;
8268 last_frag = &priv->last_frag_num;
8269 last_time = &priv->last_packet_time;
8270 break;
8271 default:
8272 return 0;
8273 }
8274 if ((*last_seq == seq) &&
8275 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
8276 if (*last_frag == frag)
8277 goto drop;
8278 if (*last_frag + 1 != frag)
8279 /* out-of-order fragment */
8280 goto drop;
afbf30a2
JK		 8281 } else
8282 *last_seq = seq;
8283
f57ce7ce 8284 *last_frag = frag;
afbf30a2
JK		 8285 *last_time = jiffies;
8286 return 0;
8287
8288 drop:
87b016cb
ZY		 8289 /* Comment this line now since we observed the card receives
8290 * duplicate packets but the FCTL_RETRY bit is not set in the
8291 * IBSS mode with fragmentation enabled.
72118015 8292 BUG_ON(!(le16_to_cpu(header->frame_control) & IEEE80211_FCTL_RETRY)); */
afbf30a2
JK		 8293 return 1;
8294}
8295
b095c381
JK		 8296static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
8297 struct ipw_rx_mem_buffer *rxb,
b0a4e7d8 8298 struct libipw_rx_stats *stats)
b095c381
JK		 8299{
8300 struct sk_buff *skb = rxb->skb;
8301 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
b0a4e7d8 8302 struct libipw_hdr_4addr *header = (struct libipw_hdr_4addr *)
b095c381
JK		 8303 (skb->data + IPW_RX_FRAME_SIZE);
8304
b0a4e7d8 8305 libipw_rx_mgt(priv->ieee, header, stats);
b095c381
JK		 8306
8307 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8308 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8309 IEEE80211_STYPE_PROBE_RESP) ||
8310 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8311 IEEE80211_STYPE_BEACON))) {
8312 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
8313 ipw_add_station(priv, header->addr2);
8314 }
8315
8316 if (priv->config & CFG_NET_STATS) {
8317 IPW_DEBUG_HC("sending stat packet\n");
8318
8319 /* Set the size of the skb to the size of the full
8320 * ipw header and 802.11 frame */
8321 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8322 IPW_RX_FRAME_SIZE);
8323
8324 /* Advance past the ipw packet header to the 802.11 frame */
8325 skb_pull(skb, IPW_RX_FRAME_SIZE);
8326
b0a4e7d8 8327 /* Push the libipw_rx_stats before the 802.11 frame */
b095c381
JK		 8328 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
8329
8330 skb->dev = priv->ieee->dev;
8331
b0a4e7d8 8332 /* Point raw at the libipw_stats */
459a98ed 8333 skb_reset_mac_header(skb);
b095c381
JK		 8334
8335 skb->pkt_type = PACKET_OTHERHOST;
c1b4aa3f 8336 skb->protocol = cpu_to_be16(ETH_P_80211_STATS);
b095c381
JK		 8337 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8338 netif_rx(skb);
43f66a6c 8339 rxb->skb = NULL;
b095c381 8340 }
43f66a6c
JK		 8341}
8342
43f66a6c 8343/*
25985edc 8344 * Main entry function for receiving a packet with 80211 headers. This
43f66a6c 8345 * should be called when ever the FW has notified us that there is a new
25985edc 8346 * skb in the receive queue.
43f66a6c
JK		 8347 */
8348static void ipw_rx(struct ipw_priv *priv)
8349{
8350 struct ipw_rx_mem_buffer *rxb;
8351 struct ipw_rx_packet *pkt;
b0a4e7d8 8352 struct libipw_hdr_4addr *header;
43f66a6c
JK		 8353 u32 r, w, i;
8354 u8 network_packet;
943dbef4 8355 u8 fill_rx = 0;
43f66a6c 8356
b095c381
JK		 8357 r = ipw_read32(priv, IPW_RX_READ_INDEX);
8358 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
943dbef4
DW		 8359 i = priv->rxq->read;
8360
8361 if (ipw_rx_queue_space (priv->rxq) > (RX_QUEUE_SIZE / 2))
8362 fill_rx = 1;
43f66a6c
JK		 8363
8364 while (i != r) {
8365 rxb = priv->rxq->queue[i];
43f66a6c
JK		 8366 if (unlikely(rxb == NULL)) {
8367 printk(KERN_CRIT "Queue not allocated!\n");
8368 break;
8369 }
43f66a6c
JK		 8370 priv->rxq->queue[i] = NULL;
8371
8372 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
b095c381 8373 IPW_RX_BUF_SIZE,
43f66a6c
JK		 8374 PCI_DMA_FROMDEVICE);
8375
8376 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8377 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
8378 pkt->header.message_type,
0edd5b44 8379 pkt->header.rx_seq_num, pkt->header.control_bits);
43f66a6c
JK		 8380
8381 switch (pkt->header.message_type) {
0edd5b44 8382 case RX_FRAME_TYPE: /* 802.11 frame */ {
b0a4e7d8 8383 struct libipw_rx_stats stats = {
851ca268 8384 .rssi = pkt->u.frame.rssi_dbm -
0edd5b44 8385 IPW_RSSI_TO_DBM,
c848d0af 8386 .signal =
21f8a73f 8387 pkt->u.frame.rssi_dbm -
b191608a 8388 IPW_RSSI_TO_DBM + 0x100,
c848d0af
JK		 8389 .noise =
8390 le16_to_cpu(pkt->u.frame.noise),
0edd5b44
JG		 8391 .rate = pkt->u.frame.rate,
8392 .mac_time = jiffies,
8393 .received_channel =
8394 pkt->u.frame.received_channel,
8395 .freq =
8396 (pkt->u.frame.
8397 control & (1 << 0)) ?
b0a4e7d8
JL		 8398 LIBIPW_24GHZ_BAND :
8399 LIBIPW_52GHZ_BAND,
a613bffd 8400 .len = le16_to_cpu(pkt->u.frame.length),
0edd5b44
JG		 8401 };
8402
8403 if (stats.rssi != 0)
b0a4e7d8 8404 stats.mask |= LIBIPW_STATMASK_RSSI;
0edd5b44 8405 if (stats.signal != 0)
b0a4e7d8 8406 stats.mask |= LIBIPW_STATMASK_SIGNAL;
c848d0af 8407 if (stats.noise != 0)
b0a4e7d8 8408 stats.mask |= LIBIPW_STATMASK_NOISE;
0edd5b44 8409 if (stats.rate != 0)
b0a4e7d8 8410 stats.mask |= LIBIPW_STATMASK_RATE;
0edd5b44
JG		 8411
8412 priv->rx_packets++;
43f66a6c 8413
d685b8c2
ZY		 8414#ifdef CONFIG_IPW2200_PROMISCUOUS
8415 if (priv->prom_net_dev && netif_running(priv->prom_net_dev))
8416 ipw_handle_promiscuous_rx(priv, rxb, &stats);
8417#endif
8418
b095c381 8419#ifdef CONFIG_IPW2200_MONITOR
0edd5b44 8420 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
459d4087 8421#ifdef CONFIG_IPW2200_RADIOTAP
d685b8c2
ZY		 8422
8423 ipw_handle_data_packet_monitor(priv,
8424 rxb,
8425 &stats);
24a47dbd 8426#else
d685b8c2
ZY		 8427 ipw_handle_data_packet(priv, rxb,
8428 &stats);
24a47dbd 8429#endif
0edd5b44
JG		 8430 break;
8431 }
43f66a6c 8432#endif
bf79451e 8433
0edd5b44 8434 header =
b0a4e7d8 8435 (struct libipw_hdr_4addr *)(rxb->skb->
0dacca1f
JK		 8436 data +
8437 IPW_RX_FRAME_SIZE);
43f66a6c
JK		 8438 /* TODO: Check Ad-Hoc dest/source and make sure
8439 * that we are actually parsing these packets
bf79451e 8440 * correctly -- we should probably use the
43f66a6c
JK		 8441 * frame control of the packet and disregard
8442 * the current iw_mode */
0edd5b44 8443
ea2b26e0
JK		 8444 network_packet =
8445 is_network_packet(priv, header);
0edd5b44
JG		 8446 if (network_packet && priv->assoc_network) {
8447 priv->assoc_network->stats.rssi =
8448 stats.rssi;
00d21de5
ZY		 8449 priv->exp_avg_rssi =
8450 exponential_average(priv->exp_avg_rssi,
8451 stats.rssi, DEPTH_RSSI);
0edd5b44
JG		 8452 }
8453
8454 IPW_DEBUG_RX("Frame: len=%u\n",
a613bffd 8455 le16_to_cpu(pkt->u.frame.length));
0edd5b44 8456
a613bffd 8457 if (le16_to_cpu(pkt->u.frame.length) <
b0a4e7d8 8458 libipw_get_hdrlen(le16_to_cpu(
9d0be03a 8459 header->frame_ctl))) {
0edd5b44
JG		 8460 IPW_DEBUG_DROP
8461 ("Received packet is too small. "
8462 "Dropping.\n");
ce55cbaf 8463 priv->net_dev->stats.rx_errors++;
0edd5b44
JG		 8464 priv->wstats.discard.misc++;
8465 break;
8466 }
8467
a613bffd
JK		 8468 switch (WLAN_FC_GET_TYPE
8469 (le16_to_cpu(header->frame_ctl))) {
b095c381 8470
0edd5b44 8471 case IEEE80211_FTYPE_MGMT:
b095c381
JK		 8472 ipw_handle_mgmt_packet(priv, rxb,
8473 &stats);
0edd5b44
JG		 8474 break;
8475
8476 case IEEE80211_FTYPE_CTL:
8477 break;
8478
8479 case IEEE80211_FTYPE_DATA:
afbf30a2
JK		 8480 if (unlikely(!network_packet ||
8481 is_duplicate_packet(priv,
8482 header)))
8483 {
0edd5b44 8484 IPW_DEBUG_DROP("Dropping: "
e174961c
JB		 8485 "%pM, "
8486 "%pM, "
8487 "%pM\n",
8488 header->addr1,
8489 header->addr2,
8490 header->addr3);
b095c381
JK		 8491 break;
8492 }
8493
8494 ipw_handle_data_packet(priv, rxb,
8495 &stats);
8496
0edd5b44
JG		 8497 break;
8498 }
43f66a6c
JK		 8499 break;
8500 }
bf79451e 8501
0edd5b44
JG		 8502 case RX_HOST_NOTIFICATION_TYPE:{
8503 IPW_DEBUG_RX
8504 ("Notification: subtype=%02X flags=%02X size=%d\n",
43f66a6c
JK		 8505 pkt->u.notification.subtype,
8506 pkt->u.notification.flags,
720eeb43 8507 le16_to_cpu(pkt->u.notification.size));
0edd5b44
JG		 8508 ipw_rx_notification(priv, &pkt->u.notification);
8509 break;
8510 }
43f66a6c
JK		 8511
8512 default:
8513 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8514 pkt->header.message_type);
8515 break;
8516 }
bf79451e
JG		 8517
8518 /* For now we just don't re-use anything. We can tweak this
8519 * later to try and re-use notification packets and SKBs that
43f66a6c
JK		 8520 * fail to Rx correctly */
8521 if (rxb->skb != NULL) {
8522 dev_kfree_skb_any(rxb->skb);
8523 rxb->skb = NULL;
8524 }
bf79451e 8525
43f66a6c 8526 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
b095c381 8527 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 8528 list_add_tail(&rxb->list, &priv->rxq->rx_used);
bf79451e 8529
43f66a6c 8530 i = (i + 1) % RX_QUEUE_SIZE;
943dbef4
DW		 8531
8532 /* If there are a lot of unsued frames, restock the Rx queue
8533 * so the ucode won't assert */
8534 if (fill_rx) {
8535 priv->rxq->read = i;
8536 ipw_rx_queue_replenish(priv);
8537 }
43f66a6c
JK		 8538 }
8539
8540 /* Backtrack one entry */
943dbef4 8541 priv->rxq->read = i;
43f66a6c
JK		 8542 ipw_rx_queue_restock(priv);
8543}
8544
afbf30a2
JK		 8545#define DEFAULT_RTS_THRESHOLD 2304U
8546#define MIN_RTS_THRESHOLD 1U
8547#define MAX_RTS_THRESHOLD 2304U
8548#define DEFAULT_BEACON_INTERVAL 100U
8549#define DEFAULT_SHORT_RETRY_LIMIT 7U
8550#define DEFAULT_LONG_RETRY_LIMIT 4U
8551
d6d5b5c1
ZY		 8552/**
8553 * ipw_sw_reset
8554 * @option: options to control different reset behaviour
8555 * 0 = reset everything except the 'disable' module_param
8556 * 1 = reset everything and print out driver info (for probe only)
8557 * 2 = reset everything
8558 */
8559static int ipw_sw_reset(struct ipw_priv *priv, int option)
43f66a6c 8560{
afbf30a2
JK		 8561 int band, modulation;
8562 int old_mode = priv->ieee->iw_mode;
43f66a6c 8563
afbf30a2
JK		 8564 /* Initialize module parameter values here */
8565 priv->config = 0;
43f66a6c 8566
afbf30a2
JK		 8567 /* We default to disabling the LED code as right now it causes
8568 * too many systems to lock up... */
21f8a73f 8569 if (!led_support)
afbf30a2 8570 priv->config |= CFG_NO_LED;
43f66a6c 8571
afbf30a2
JK		 8572 if (associate)
8573 priv->config |= CFG_ASSOCIATE;
8574 else
8575 IPW_DEBUG_INFO("Auto associate disabled.\n");
bf79451e 8576
afbf30a2
JK		 8577 if (auto_create)
8578 priv->config |= CFG_ADHOC_CREATE;
8579 else
8580 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
43f66a6c 8581
17ed081d
ZY		 8582 priv->config &= ~CFG_STATIC_ESSID;
8583 priv->essid_len = 0;
8584 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8585
d6d5b5c1 8586 if (disable && option) {
afbf30a2
JK		 8587 priv->status |= STATUS_RF_KILL_SW;
8588 IPW_DEBUG_INFO("Radio disabled.\n");
43f66a6c 8589 }
bf79451e 8590
21f8a73f 8591 if (default_channel != 0) {
afbf30a2 8592 priv->config |= CFG_STATIC_CHANNEL;
21f8a73f
RC		 8593 priv->channel = default_channel;
8594 IPW_DEBUG_INFO("Bind to static channel %d\n", default_channel);
afbf30a2 8595 /* TODO: Validate that provided channel is in range */
43f66a6c 8596 }
e43e3c1e 8597#ifdef CONFIG_IPW2200_QOS
afbf30a2
JK		 8598 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8599 burst_duration_CCK, burst_duration_OFDM);
e43e3c1e 8600#endif /* CONFIG_IPW2200_QOS */
43f66a6c 8601
21f8a73f 8602 switch (network_mode) {
afbf30a2
JK		 8603 case 1:
8604 priv->ieee->iw_mode = IW_MODE_ADHOC;
8605 priv->net_dev->type = ARPHRD_ETHER;
8606
8607 break;
8608#ifdef CONFIG_IPW2200_MONITOR
8609 case 2:
8610 priv->ieee->iw_mode = IW_MODE_MONITOR;
459d4087 8611#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 8612 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8613#else
afbf30a2 8614 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8615#endif
afbf30a2
JK		 8616 break;
8617#endif
8618 default:
8619 case 0:
8620 priv->net_dev->type = ARPHRD_ETHER;
8621 priv->ieee->iw_mode = IW_MODE_INFRA;
8622 break;
43f66a6c
JK		 8623 }
8624
afbf30a2
JK		 8625 if (hwcrypto) {
8626 priv->ieee->host_encrypt = 0;
8627 priv->ieee->host_encrypt_msdu = 0;
8628 priv->ieee->host_decrypt = 0;
567deaf6 8629 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 8630 }
8631 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
43f66a6c 8632
e402c937
ZY		 8633 /* IPW2200/2915 is abled to do hardware fragmentation. */
8634 priv->ieee->host_open_frag = 0;
bf79451e 8635
afbf30a2
JK		 8636 if ((priv->pci_dev->device == 0x4223) ||
8637 (priv->pci_dev->device == 0x4224)) {
e8c69e27 8638 if (option == 1)
afbf30a2
JK		 8639 printk(KERN_INFO DRV_NAME
8640 ": Detected Intel PRO/Wireless 2915ABG Network "
8641 "Connection\n");
8642 priv->ieee->abg_true = 1;
b0a4e7d8
JL		 8643 band = LIBIPW_52GHZ_BAND | LIBIPW_24GHZ_BAND;
8644 modulation = LIBIPW_OFDM_MODULATION |
8645 LIBIPW_CCK_MODULATION;
afbf30a2
JK		 8646 priv->adapter = IPW_2915ABG;
8647 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
43f66a6c 8648 } else {
e8c69e27 8649 if (option == 1)
afbf30a2
JK		 8650 printk(KERN_INFO DRV_NAME
8651 ": Detected Intel PRO/Wireless 2200BG Network "
8652 "Connection\n");
bf79451e 8653
afbf30a2 8654 priv->ieee->abg_true = 0;
b0a4e7d8
JL		 8655 band = LIBIPW_24GHZ_BAND;
8656 modulation = LIBIPW_OFDM_MODULATION |
8657 LIBIPW_CCK_MODULATION;
afbf30a2
JK		 8658 priv->adapter = IPW_2200BG;
8659 priv->ieee->mode = IEEE_G | IEEE_B;
43f66a6c
JK		 8660 }
8661
afbf30a2
JK		 8662 priv->ieee->freq_band = band;
8663 priv->ieee->modulation = modulation;
43f66a6c 8664
b0a4e7d8 8665 priv->rates_mask = LIBIPW_DEFAULT_RATES_MASK;
bf79451e 8666
afbf30a2
JK		 8667 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8668 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
43f66a6c 8669
afbf30a2
JK		 8670 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8671 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8672 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
43f66a6c 8673
afbf30a2
JK		 8674 /* If power management is turned on, default to AC mode */
8675 priv->power_mode = IPW_POWER_AC;
8676 priv->tx_power = IPW_TX_POWER_DEFAULT;
8677
0ece35b5 8678 return old_mode == priv->ieee->iw_mode;
43f66a6c
JK		 8679}
8680
8681/*
8682 * This file defines the Wireless Extension handlers. It does not
8683 * define any methods of hardware manipulation and relies on the
8684 * functions defined in ipw_main to provide the HW interaction.
bf79451e
JG		 8685 *
8686 * The exception to this is the use of the ipw_get_ordinal()
25985edc 8687 * function used to poll the hardware vs. making unnecessary calls.
43f66a6c
JK		 8688 *
8689 */
8690
43f66a6c
JK		 8691static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8692{
8693 if (channel == 0) {
8694 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8695 priv->config &= ~CFG_STATIC_CHANNEL;
c848d0af
JK		 8696 IPW_DEBUG_ASSOC("Attempting to associate with new "
8697 "parameters.\n");
8698 ipw_associate(priv);
43f66a6c
JK		 8699 return 0;
8700 }
8701
8702 priv->config |= CFG_STATIC_CHANNEL;
8703
8704 if (priv->channel == channel) {
0edd5b44
JG		 8705 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8706 channel);
43f66a6c
JK		 8707 return 0;
8708 }
8709
8710 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8711 priv->channel = channel;
8712
b095c381
JK		 8713#ifdef CONFIG_IPW2200_MONITOR
8714 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 8715 int i;
b095c381 8716 if (priv->status & STATUS_SCANNING) {
afbf30a2 8717 IPW_DEBUG_SCAN("Scan abort triggered due to "
b095c381 8718 "channel change.\n");
afbf30a2 8719 ipw_abort_scan(priv);
b095c381
JK		 8720 }
8721
8722 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8723 udelay(10);
8724
8725 if (priv->status & STATUS_SCANNING)
8726 IPW_DEBUG_SCAN("Still scanning...\n");
8727 else
8728 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8729 1000 - i);
8730
8731 return 0;
43f66a6c 8732 }
b095c381
JK		 8733#endif /* CONFIG_IPW2200_MONITOR */
8734
c848d0af
JK		 8735 /* Network configuration changed -- force [re]association */
8736 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8737 if (!ipw_disassociate(priv))
43f66a6c 8738 ipw_associate(priv);
43f66a6c
JK		 8739
8740 return 0;
8741}
8742
bf79451e
JG		 8743static int ipw_wx_set_freq(struct net_device *dev,
8744 struct iw_request_info *info,
8745 union iwreq_data *wrqu, char *extra)
43f66a6c 8746{
b0a4e7d8
JL		 8747 struct ipw_priv *priv = libipw_priv(dev);
8748 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
43f66a6c 8749 struct iw_freq *fwrq = &wrqu->freq;
afbf30a2 8750 int ret = 0, i;
1fe0adb4
LH		 8751 u8 channel, flags;
8752 int band;
b095c381
JK		 8753
8754 if (fwrq->m == 0) {
8755 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
4644151b 8756 mutex_lock(&priv->mutex);
b095c381 8757 ret = ipw_set_channel(priv, 0);
4644151b 8758 mutex_unlock(&priv->mutex);
b095c381
JK		 8759 return ret;
8760 }
43f66a6c
JK		 8761 /* if setting by freq convert to channel */
8762 if (fwrq->e == 1) {
b0a4e7d8 8763 channel = libipw_freq_to_channel(priv->ieee, fwrq->m);
b095c381
JK		 8764 if (channel == 0)
8765 return -EINVAL;
8766 } else
8767 channel = fwrq->m;
bf79451e 8768
b0a4e7d8 8769 if (!(band = libipw_is_valid_channel(priv->ieee, channel)))
b095c381 8770 return -EINVAL;
43f66a6c 8771
1fe0adb4 8772 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
b0a4e7d8 8773 i = libipw_channel_to_index(priv->ieee, channel);
afbf30a2
JK		 8774 if (i == -1)
8775 return -EINVAL;
bf79451e 8776
b0a4e7d8 8777 flags = (band == LIBIPW_24GHZ_BAND) ?
1fe0adb4 8778 geo->bg[i].flags : geo->a[i].flags;
b0a4e7d8 8779 if (flags & LIBIPW_CH_PASSIVE_ONLY) {
afbf30a2
JK		 8780 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8781 return -EINVAL;
43f66a6c
JK		 8782 }
8783 }
bf79451e 8784
9fd1ea42 8785 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
4644151b 8786 mutex_lock(&priv->mutex);
b095c381 8787 ret = ipw_set_channel(priv, channel);
4644151b 8788 mutex_unlock(&priv->mutex);
c848d0af 8789 return ret;
43f66a6c
JK		 8790}
8791
bf79451e
JG		 8792static int ipw_wx_get_freq(struct net_device *dev,
8793 struct iw_request_info *info,
43f66a6c
JK		 8794 union iwreq_data *wrqu, char *extra)
8795{
b0a4e7d8 8796 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 8797
8798 wrqu->freq.e = 0;
8799
8800 /* If we are associated, trying to associate, or have a statically
8801 * configured CHANNEL then return that; otherwise return ANY */
4644151b 8802 mutex_lock(&priv->mutex);
43f66a6c 8803 if (priv->config & CFG_STATIC_CHANNEL ||
c580f67f
ZY		 8804 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) {
8805 int i;
8806
b0a4e7d8 8807 i = libipw_channel_to_index(priv->ieee, priv->channel);
c580f67f
ZY		 8808 BUG_ON(i == -1);
8809 wrqu->freq.e = 1;
8810
b0a4e7d8
JL		 8811 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
8812 case LIBIPW_52GHZ_BAND:
c580f67f
ZY		 8813 wrqu->freq.m = priv->ieee->geo.a[i].freq * 100000;
8814 break;
8815
b0a4e7d8 8816 case LIBIPW_24GHZ_BAND:
c580f67f
ZY		 8817 wrqu->freq.m = priv->ieee->geo.bg[i].freq * 100000;
8818 break;
8819
8820 default:
8821 BUG();
8822 }
8823 } else
43f66a6c
JK		 8824 wrqu->freq.m = 0;
8825
4644151b 8826 mutex_unlock(&priv->mutex);
9fd1ea42 8827 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
43f66a6c
JK		 8828 return 0;
8829}
8830
bf79451e
JG		 8831static int ipw_wx_set_mode(struct net_device *dev,
8832 struct iw_request_info *info,
43f66a6c
JK		 8833 union iwreq_data *wrqu, char *extra)
8834{
b0a4e7d8 8835 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 8836 int err = 0;
8837
8838 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8839
43f66a6c 8840 switch (wrqu->mode) {
b095c381 8841#ifdef CONFIG_IPW2200_MONITOR
43f66a6c
JK		 8842 case IW_MODE_MONITOR:
8843#endif
8844 case IW_MODE_ADHOC:
8845 case IW_MODE_INFRA:
8846 break;
8847 case IW_MODE_AUTO:
8848 wrqu->mode = IW_MODE_INFRA;
8849 break;
8850 default:
8851 return -EINVAL;
8852 }
b095c381
JK		 8853 if (wrqu->mode == priv->ieee->iw_mode)
8854 return 0;
43f66a6c 8855
4644151b 8856 mutex_lock(&priv->mutex);
43f66a6c 8857
afbf30a2
JK		 8858 ipw_sw_reset(priv, 0);
8859
b095c381 8860#ifdef CONFIG_IPW2200_MONITOR
bf79451e 8861 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
43f66a6c 8862 priv->net_dev->type = ARPHRD_ETHER;
bf79451e
JG		 8863
8864 if (wrqu->mode == IW_MODE_MONITOR)
459d4087 8865#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 8866 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8867#else
43f66a6c 8868 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8869#endif
b095c381 8870#endif /* CONFIG_IPW2200_MONITOR */
bf79451e 8871
bf79451e 8872 /* Free the existing firmware and reset the fw_loaded
877d0310 8873 * flag so ipw_load() will bring in the new firmware */
afbf30a2 8874 free_firmware();
43f66a6c
JK		 8875
8876 priv->ieee->iw_mode = wrqu->mode;
bf79451e 8877
bcb6d916 8878 schedule_work(&priv->adapter_restart);
4644151b 8879 mutex_unlock(&priv->mutex);
0edd5b44 8880 return err;
43f66a6c
JK		 8881}
8882
bf79451e 8883static int ipw_wx_get_mode(struct net_device *dev,
0edd5b44
JG		 8884 struct iw_request_info *info,
8885 union iwreq_data *wrqu, char *extra)
43f66a6c 8886{
b0a4e7d8 8887 struct ipw_priv *priv = libipw_priv(dev);
4644151b 8888 mutex_lock(&priv->mutex);
43f66a6c
JK		 8889 wrqu->mode = priv->ieee->iw_mode;
8890 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
4644151b 8891 mutex_unlock(&priv->mutex);
43f66a6c
JK		 8892 return 0;
8893}
8894
43f66a6c
JK		 8895/* Values are in microsecond */
8896static const s32 timeout_duration[] = {
8897 350000,
8898 250000,
8899 75000,
8900 37000,
8901 25000,
8902};
8903
8904static const s32 period_duration[] = {
8905 400000,
8906 700000,
8907 1000000,
8908 1000000,
8909 1000000
8910};
8911
bf79451e
JG		 8912static int ipw_wx_get_range(struct net_device *dev,
8913 struct iw_request_info *info,
43f66a6c
JK		 8914 union iwreq_data *wrqu, char *extra)
8915{
b0a4e7d8 8916 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 8917 struct iw_range *range = (struct iw_range *)extra;
b0a4e7d8 8918 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
b095c381 8919 int i = 0, j;
43f66a6c
JK		 8920
8921 wrqu->data.length = sizeof(*range);
8922 memset(range, 0, sizeof(*range));
8923
8924 /* 54Mbs == ~27 Mb/s real (802.11g) */
bf79451e 8925 range->throughput = 27 * 1000 * 1000;
43f66a6c
JK		 8926
8927 range->max_qual.qual = 100;
8928 /* TODO: Find real max RSSI and stick here */
8929 range->max_qual.level = 0;
b191608a 8930 range->max_qual.noise = 0;
0edd5b44 8931 range->max_qual.updated = 7; /* Updated all three */
43f66a6c
JK		 8932
8933 range->avg_qual.qual = 70;
af901ca1 8934 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
0edd5b44 8935 range->avg_qual.level = 0; /* FIXME to real average level */
43f66a6c 8936 range->avg_qual.noise = 0;
0edd5b44 8937 range->avg_qual.updated = 7; /* Updated all three */
4644151b 8938 mutex_lock(&priv->mutex);
0edd5b44 8939 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
43f66a6c 8940
bf79451e
JG		 8941 for (i = 0; i < range->num_bitrates; i++)
8942 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
0edd5b44 8943 500000;
bf79451e 8944
43f66a6c
JK		 8945 range->max_rts = DEFAULT_RTS_THRESHOLD;
8946 range->min_frag = MIN_FRAG_THRESHOLD;
8947 range->max_frag = MAX_FRAG_THRESHOLD;
8948
8949 range->encoding_size[0] = 5;
bf79451e 8950 range->encoding_size[1] = 13;
43f66a6c
JK		 8951 range->num_encoding_sizes = 2;
8952 range->max_encoding_tokens = WEP_KEYS;
8953
8954 /* Set the Wireless Extension versions */
8955 range->we_version_compiled = WIRELESS_EXT;
f1b50863 8956 range->we_version_source = 18;
43f66a6c 8957
b095c381
JK		 8958 i = 0;
8959 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
e815de42
ZY		 8960 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8961 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
b0a4e7d8 8962 (geo->bg[j].flags & LIBIPW_CH_PASSIVE_ONLY))
e815de42
ZY		 8963 continue;
8964
b095c381
JK		 8965 range->freq[i].i = geo->bg[j].channel;
8966 range->freq[i].m = geo->bg[j].freq * 100000;
8967 range->freq[i].e = 1;
e815de42 8968 i++;
b095c381
JK		 8969 }
8970 }
43f66a6c 8971
b095c381 8972 if (priv->ieee->mode & IEEE_A) {
e815de42
ZY		 8973 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8974 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
b0a4e7d8 8975 (geo->a[j].flags & LIBIPW_CH_PASSIVE_ONLY))
e815de42
ZY		 8976 continue;
8977
b095c381
JK		 8978 range->freq[i].i = geo->a[j].channel;
8979 range->freq[i].m = geo->a[j].freq * 100000;
8980 range->freq[i].e = 1;
e815de42 8981 i++;
b095c381 8982 }
43f66a6c 8983 }
b095c381
JK		 8984
8985 range->num_channels = i;
8986 range->num_frequency = i;
8987
4644151b 8988 mutex_unlock(&priv->mutex);
97a78ca9
BB		 8989
8990 /* Event capability (kernel + driver) */
8991 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8992 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
07f02e46
ZY		 8993 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
8994 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
97a78ca9 8995 range->event_capa[1] = IW_EVENT_CAPA_K_1;
43f66a6c 8996
f1b50863
DW		 8997 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8998 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8999
374fdfbc
DW		 9000 range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
9001
43f66a6c
JK		 9002 IPW_DEBUG_WX("GET Range\n");
9003 return 0;
9004}
9005
bf79451e
JG		 9006static int ipw_wx_set_wap(struct net_device *dev,
9007 struct iw_request_info *info,
43f66a6c
JK		 9008 union iwreq_data *wrqu, char *extra)
9009{
b0a4e7d8 9010 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9011
9012 static const unsigned char any[] = {
9013 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
9014 };
9015 static const unsigned char off[] = {
9016 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
9017 };
9018
bf79451e 9019 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
43f66a6c 9020 return -EINVAL;
4644151b 9021 mutex_lock(&priv->mutex);
43f66a6c
JK		 9022 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
9023 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
9024 /* we disable mandatory BSSID association */
9025 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
9026 priv->config &= ~CFG_STATIC_BSSID;
c848d0af
JK		 9027 IPW_DEBUG_ASSOC("Attempting to associate with new "
9028 "parameters.\n");
9029 ipw_associate(priv);
4644151b 9030 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9031 return 0;
9032 }
9033
9034 priv->config |= CFG_STATIC_BSSID;
9035 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
9036 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
4644151b 9037 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9038 return 0;
9039 }
9040
e174961c
JB		 9041 IPW_DEBUG_WX("Setting mandatory BSSID to %pM\n",
9042 wrqu->ap_addr.sa_data);
43f66a6c
JK		 9043
9044 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
9045
c848d0af
JK		 9046 /* Network configuration changed -- force [re]association */
9047 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
9048 if (!ipw_disassociate(priv))
43f66a6c 9049 ipw_associate(priv);
43f66a6c 9050
4644151b 9051 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9052 return 0;
9053}
9054
bf79451e
JG		 9055static int ipw_wx_get_wap(struct net_device *dev,
9056 struct iw_request_info *info,
43f66a6c
JK		 9057 union iwreq_data *wrqu, char *extra)
9058{
b0a4e7d8 9059 struct ipw_priv *priv = libipw_priv(dev);
0795af57 9060
43f66a6c
JK		 9061 /* If we are associated, trying to associate, or have a statically
9062 * configured BSSID then return that; otherwise return ANY */
4644151b 9063 mutex_lock(&priv->mutex);
bf79451e 9064 if (priv->config & CFG_STATIC_BSSID ||
43f66a6c
JK		 9065 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9066 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
afbf30a2 9067 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
43f66a6c
JK		 9068 } else
9069 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
9070
e174961c
JB		 9071 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n",
9072 wrqu->ap_addr.sa_data);
4644151b 9073 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9074 return 0;
9075}
9076
bf79451e
JG		 9077static int ipw_wx_set_essid(struct net_device *dev,
9078 struct iw_request_info *info,
43f66a6c
JK		 9079 union iwreq_data *wrqu, char *extra)
9080{
b0a4e7d8 9081 struct ipw_priv *priv = libipw_priv(dev);
ab644b0b 9082 int length;
9387b7ca 9083 DECLARE_SSID_BUF(ssid);
ab644b0b
ZY		 9084
9085 mutex_lock(&priv->mutex);
43f66a6c 9086
ab644b0b
ZY		 9087 if (!wrqu->essid.flags)
9088 {
9089 IPW_DEBUG_WX("Setting ESSID to ANY\n");
9090 ipw_disassociate(priv);
9091 priv->config &= ~CFG_STATIC_ESSID;
9092 ipw_associate(priv);
9093 mutex_unlock(&priv->mutex);
9094 return 0;
9095 }
43f66a6c 9096
a9f0d423 9097 length = min((int)wrqu->essid.length, IW_ESSID_MAX_SIZE);
43f66a6c
JK		 9098
9099 priv->config |= CFG_STATIC_ESSID;
9100
a9f0d423
ZY		 9101 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)
9102 && (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) {
43f66a6c 9103 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
4644151b 9104 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9105 return 0;
9106 }
9107
9387b7ca
JL		 9108 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n",
9109 print_ssid(ssid, extra, length), length);
43f66a6c
JK		 9110
9111 priv->essid_len = length;
a9f0d423 9112 memcpy(priv->essid, extra, priv->essid_len);
bf79451e 9113
c848d0af
JK		 9114 /* Network configuration changed -- force [re]association */
9115 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
9116 if (!ipw_disassociate(priv))
43f66a6c 9117 ipw_associate(priv);
43f66a6c 9118
4644151b 9119 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9120 return 0;
9121}
9122
bf79451e
JG		 9123static int ipw_wx_get_essid(struct net_device *dev,
9124 struct iw_request_info *info,
43f66a6c
JK		 9125 union iwreq_data *wrqu, char *extra)
9126{
b0a4e7d8 9127 struct ipw_priv *priv = libipw_priv(dev);
9387b7ca 9128 DECLARE_SSID_BUF(ssid);
43f66a6c
JK		 9129
9130 /* If we are associated, trying to associate, or have a statically
9131 * configured ESSID then return that; otherwise return ANY */
4644151b 9132 mutex_lock(&priv->mutex);
43f66a6c 9133 if (priv->config & CFG_STATIC_ESSID ||
bf79451e
JG		 9134 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9135 IPW_DEBUG_WX("Getting essid: '%s'\n",
9387b7ca 9136 print_ssid(ssid, priv->essid, priv->essid_len));
bf79451e 9137 memcpy(extra, priv->essid, priv->essid_len);
43f66a6c 9138 wrqu->essid.length = priv->essid_len;
0edd5b44 9139 wrqu->essid.flags = 1; /* active */
43f66a6c
JK		 9140 } else {
9141 IPW_DEBUG_WX("Getting essid: ANY\n");
9142 wrqu->essid.length = 0;
0edd5b44 9143 wrqu->essid.flags = 0; /* active */
43f66a6c 9144 }
4644151b 9145 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9146 return 0;
9147}
9148
bf79451e
JG		 9149static int ipw_wx_set_nick(struct net_device *dev,
9150 struct iw_request_info *info,
43f66a6c 9151 union iwreq_data *wrqu, char *extra)
bf79451e 9152{
b0a4e7d8 9153 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9154
9155 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
9156 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9157 return -E2BIG;
4644151b 9158 mutex_lock(&priv->mutex);
0edd5b44 9159 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
43f66a6c 9160 memset(priv->nick, 0, sizeof(priv->nick));
0edd5b44 9161 memcpy(priv->nick, extra, wrqu->data.length);
43f66a6c 9162 IPW_DEBUG_TRACE("<<\n");
4644151b 9163 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9164 return 0;
9165
9166}
9167
bf79451e
JG		 9168static int ipw_wx_get_nick(struct net_device *dev,
9169 struct iw_request_info *info,
43f66a6c 9170 union iwreq_data *wrqu, char *extra)
bf79451e 9171{
b0a4e7d8 9172 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9173 IPW_DEBUG_WX("Getting nick\n");
4644151b 9174 mutex_lock(&priv->mutex);
919ee6dd 9175 wrqu->data.length = strlen(priv->nick);
43f66a6c 9176 memcpy(extra, priv->nick, wrqu->data.length);
0edd5b44 9177 wrqu->data.flags = 1; /* active */
4644151b 9178 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9179 return 0;
9180}
9181
651be26f
OH		 9182static int ipw_wx_set_sens(struct net_device *dev,
9183 struct iw_request_info *info,
9184 union iwreq_data *wrqu, char *extra)
9185{
b0a4e7d8 9186 struct ipw_priv *priv = libipw_priv(dev);
651be26f
OH		 9187 int err = 0;
9188
9189 IPW_DEBUG_WX("Setting roaming threshold to %d\n", wrqu->sens.value);
9190 IPW_DEBUG_WX("Setting disassociate threshold to %d\n", 3*wrqu->sens.value);
9191 mutex_lock(&priv->mutex);
9192
9193 if (wrqu->sens.fixed == 0)
9194 {
9195 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
9196 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
9197 goto out;
9198 }
9199 if ((wrqu->sens.value > IPW_MB_ROAMING_THRESHOLD_MAX) ||
9200 (wrqu->sens.value < IPW_MB_ROAMING_THRESHOLD_MIN)) {
9201 err = -EINVAL;
9202 goto out;
9203 }
9204
9205 priv->roaming_threshold = wrqu->sens.value;
9206 priv->disassociate_threshold = 3*wrqu->sens.value;
9207 out:
9208 mutex_unlock(&priv->mutex);
9209 return err;
9210}
9211
9212static int ipw_wx_get_sens(struct net_device *dev,
9213 struct iw_request_info *info,
9214 union iwreq_data *wrqu, char *extra)
9215{
b0a4e7d8 9216 struct ipw_priv *priv = libipw_priv(dev);
651be26f
OH		 9217 mutex_lock(&priv->mutex);
9218 wrqu->sens.fixed = 1;
9219 wrqu->sens.value = priv->roaming_threshold;
9220 mutex_unlock(&priv->mutex);
9221
9fd1ea42 9222 IPW_DEBUG_WX("GET roaming threshold -> %s %d\n",
651be26f
OH		 9223 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9224
9225 return 0;
9226}
9227
43f66a6c
JK		 9228static int ipw_wx_set_rate(struct net_device *dev,
9229 struct iw_request_info *info,
9230 union iwreq_data *wrqu, char *extra)
bf79451e 9231{
ea2b26e0 9232 /* TODO: We should use semaphores or locks for access to priv */
b0a4e7d8 9233 struct ipw_priv *priv = libipw_priv(dev);
ea2b26e0
JK		 9234 u32 target_rate = wrqu->bitrate.value;
9235 u32 fixed, mask;
9236
9237 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
9238 /* value = X, fixed = 1 means only rate X */
9239 /* value = X, fixed = 0 means all rates lower equal X */
9240
9241 if (target_rate == -1) {
9242 fixed = 0;
b0a4e7d8 9243 mask = LIBIPW_DEFAULT_RATES_MASK;
ea2b26e0
JK		 9244 /* Now we should reassociate */
9245 goto apply;
9246 }
9247
9248 mask = 0;
9249 fixed = wrqu->bitrate.fixed;
9250
9251 if (target_rate == 1000000 || !fixed)
b0a4e7d8 9252 mask |= LIBIPW_CCK_RATE_1MB_MASK;
ea2b26e0
JK		 9253 if (target_rate == 1000000)
9254 goto apply;
9255
9256 if (target_rate == 2000000 || !fixed)
b0a4e7d8 9257 mask |= LIBIPW_CCK_RATE_2MB_MASK;
ea2b26e0
JK		 9258 if (target_rate == 2000000)
9259 goto apply;
9260
9261 if (target_rate == 5500000 || !fixed)
b0a4e7d8 9262 mask |= LIBIPW_CCK_RATE_5MB_MASK;
ea2b26e0
JK		 9263 if (target_rate == 5500000)
9264 goto apply;
9265
9266 if (target_rate == 6000000 || !fixed)
b0a4e7d8 9267 mask |= LIBIPW_OFDM_RATE_6MB_MASK;
ea2b26e0
JK		 9268 if (target_rate == 6000000)
9269 goto apply;
9270
9271 if (target_rate == 9000000 || !fixed)
b0a4e7d8 9272 mask |= LIBIPW_OFDM_RATE_9MB_MASK;
ea2b26e0
JK		 9273 if (target_rate == 9000000)
9274 goto apply;
9275
9276 if (target_rate == 11000000 || !fixed)
b0a4e7d8 9277 mask |= LIBIPW_CCK_RATE_11MB_MASK;
ea2b26e0
JK		 9278 if (target_rate == 11000000)
9279 goto apply;
9280
9281 if (target_rate == 12000000 || !fixed)
b0a4e7d8 9282 mask |= LIBIPW_OFDM_RATE_12MB_MASK;
ea2b26e0
JK		 9283 if (target_rate == 12000000)
9284 goto apply;
9285
9286 if (target_rate == 18000000 || !fixed)
b0a4e7d8 9287 mask |= LIBIPW_OFDM_RATE_18MB_MASK;
ea2b26e0
JK		 9288 if (target_rate == 18000000)
9289 goto apply;
9290
9291 if (target_rate == 24000000 || !fixed)
b0a4e7d8 9292 mask |= LIBIPW_OFDM_RATE_24MB_MASK;
ea2b26e0
JK		 9293 if (target_rate == 24000000)
9294 goto apply;
9295
9296 if (target_rate == 36000000 || !fixed)
b0a4e7d8 9297 mask |= LIBIPW_OFDM_RATE_36MB_MASK;
ea2b26e0
JK		 9298 if (target_rate == 36000000)
9299 goto apply;
9300
9301 if (target_rate == 48000000 || !fixed)
b0a4e7d8 9302 mask |= LIBIPW_OFDM_RATE_48MB_MASK;
ea2b26e0
JK		 9303 if (target_rate == 48000000)
9304 goto apply;
9305
9306 if (target_rate == 54000000 || !fixed)
b0a4e7d8 9307 mask |= LIBIPW_OFDM_RATE_54MB_MASK;
ea2b26e0
JK		 9308 if (target_rate == 54000000)
9309 goto apply;
9310
9311 IPW_DEBUG_WX("invalid rate specified, returning error\n");
9312 return -EINVAL;
9313
9314 apply:
9315 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
9316 mask, fixed ? "fixed" : "sub-rates");
4644151b 9317 mutex_lock(&priv->mutex);
b0a4e7d8 9318 if (mask == LIBIPW_DEFAULT_RATES_MASK) {
ea2b26e0 9319 priv->config &= ~CFG_FIXED_RATE;
b095c381
JK		 9320 ipw_set_fixed_rate(priv, priv->ieee->mode);
9321 } else
ea2b26e0
JK		 9322 priv->config |= CFG_FIXED_RATE;
9323
c848d0af
JK		 9324 if (priv->rates_mask == mask) {
9325 IPW_DEBUG_WX("Mask set to current mask.\n");
4644151b 9326 mutex_unlock(&priv->mutex);
c848d0af 9327 return 0;
ea2b26e0
JK		 9328 }
9329
c848d0af
JK		 9330 priv->rates_mask = mask;
9331
9332 /* Network configuration changed -- force [re]association */
9333 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
9334 if (!ipw_disassociate(priv))
9335 ipw_associate(priv);
9336
4644151b 9337 mutex_unlock(&priv->mutex);
ea2b26e0 9338 return 0;
43f66a6c
JK		 9339}
9340
bf79451e
JG		 9341static int ipw_wx_get_rate(struct net_device *dev,
9342 struct iw_request_info *info,
43f66a6c 9343 union iwreq_data *wrqu, char *extra)
bf79451e 9344{
b0a4e7d8 9345 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9346 mutex_lock(&priv->mutex);
43f66a6c 9347 wrqu->bitrate.value = priv->last_rate;
455936c7 9348 wrqu->bitrate.fixed = (priv->config & CFG_FIXED_RATE) ? 1 : 0;
4644151b 9349 mutex_unlock(&priv->mutex);
9fd1ea42 9350 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
43f66a6c
JK		 9351 return 0;
9352}
9353
bf79451e
JG		 9354static int ipw_wx_set_rts(struct net_device *dev,
9355 struct iw_request_info *info,
43f66a6c 9356 union iwreq_data *wrqu, char *extra)
bf79451e 9357{
b0a4e7d8 9358 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9359 mutex_lock(&priv->mutex);
ea8862dc 9360 if (wrqu->rts.disabled || !wrqu->rts.fixed)
43f66a6c
JK		 9361 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9362 else {
9363 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
c848d0af 9364 wrqu->rts.value > MAX_RTS_THRESHOLD) {
4644151b 9365 mutex_unlock(&priv->mutex);
43f66a6c 9366 return -EINVAL;
c848d0af 9367 }
43f66a6c
JK		 9368 priv->rts_threshold = wrqu->rts.value;
9369 }
9370
9371 ipw_send_rts_threshold(priv, priv->rts_threshold);
4644151b 9372 mutex_unlock(&priv->mutex);
9fd1ea42 9373 IPW_DEBUG_WX("SET RTS Threshold -> %d\n", priv->rts_threshold);
43f66a6c
JK		 9374 return 0;
9375}
9376
bf79451e
JG		 9377static int ipw_wx_get_rts(struct net_device *dev,
9378 struct iw_request_info *info,
43f66a6c 9379 union iwreq_data *wrqu, char *extra)
bf79451e 9380{
b0a4e7d8 9381 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9382 mutex_lock(&priv->mutex);
43f66a6c
JK		 9383 wrqu->rts.value = priv->rts_threshold;
9384 wrqu->rts.fixed = 0; /* no auto select */
0edd5b44 9385 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
4644151b 9386 mutex_unlock(&priv->mutex);
9fd1ea42 9387 IPW_DEBUG_WX("GET RTS Threshold -> %d\n", wrqu->rts.value);
43f66a6c
JK		 9388 return 0;
9389}
9390
bf79451e
JG		 9391static int ipw_wx_set_txpow(struct net_device *dev,
9392 struct iw_request_info *info,
43f66a6c 9393 union iwreq_data *wrqu, char *extra)
bf79451e 9394{
b0a4e7d8 9395 struct ipw_priv *priv = libipw_priv(dev);
6de9f7f2 9396 int err = 0;
43f66a6c 9397
4644151b 9398 mutex_lock(&priv->mutex);
c848d0af 9399 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
6de9f7f2
ZY		 9400 err = -EINPROGRESS;
9401 goto out;
43f66a6c 9402 }
43f66a6c 9403
b095c381
JK		 9404 if (!wrqu->power.fixed)
9405 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9406
c848d0af 9407 if (wrqu->power.flags != IW_TXPOW_DBM) {
6de9f7f2
ZY		 9408 err = -EINVAL;
9409 goto out;
c848d0af 9410 }
43f66a6c 9411
b095c381 9412 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
afbf30a2 9413 (wrqu->power.value < IPW_TX_POWER_MIN)) {
6de9f7f2
ZY		 9414 err = -EINVAL;
9415 goto out;
c848d0af 9416 }
43f66a6c 9417
43f66a6c 9418 priv->tx_power = wrqu->power.value;
6de9f7f2
ZY		 9419 err = ipw_set_tx_power(priv);
9420 out:
4644151b 9421 mutex_unlock(&priv->mutex);
6de9f7f2 9422 return err;
43f66a6c
JK		 9423}
9424
bf79451e
JG		 9425static int ipw_wx_get_txpow(struct net_device *dev,
9426 struct iw_request_info *info,
43f66a6c 9427 union iwreq_data *wrqu, char *extra)
bf79451e 9428{
b0a4e7d8 9429 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9430 mutex_lock(&priv->mutex);
43f66a6c
JK		 9431 wrqu->power.value = priv->tx_power;
9432 wrqu->power.fixed = 1;
9433 wrqu->power.flags = IW_TXPOW_DBM;
9434 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
4644151b 9435 mutex_unlock(&priv->mutex);
43f66a6c 9436
9fd1ea42 9437 IPW_DEBUG_WX("GET TX Power -> %s %d\n",
22501c8e 9438 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
43f66a6c
JK		 9439
9440 return 0;
9441}
9442
bf79451e 9443static int ipw_wx_set_frag(struct net_device *dev,
0edd5b44
JG		 9444 struct iw_request_info *info,
9445 union iwreq_data *wrqu, char *extra)
43f66a6c 9446{
b0a4e7d8 9447 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9448 mutex_lock(&priv->mutex);
ea8862dc 9449 if (wrqu->frag.disabled || !wrqu->frag.fixed)
43f66a6c
JK		 9450 priv->ieee->fts = DEFAULT_FTS;
9451 else {
9452 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
b095c381 9453 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
4644151b 9454 mutex_unlock(&priv->mutex);
43f66a6c 9455 return -EINVAL;
b095c381 9456 }
bf79451e 9457
43f66a6c
JK		 9458 priv->ieee->fts = wrqu->frag.value & ~0x1;
9459 }
9460
9461 ipw_send_frag_threshold(priv, wrqu->frag.value);
4644151b 9462 mutex_unlock(&priv->mutex);
9fd1ea42 9463 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", wrqu->frag.value);
43f66a6c
JK		 9464 return 0;
9465}
9466
bf79451e 9467static int ipw_wx_get_frag(struct net_device *dev,
0edd5b44
JG		 9468 struct iw_request_info *info,
9469 union iwreq_data *wrqu, char *extra)
43f66a6c 9470{
b0a4e7d8 9471 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9472 mutex_lock(&priv->mutex);
43f66a6c
JK		 9473 wrqu->frag.value = priv->ieee->fts;
9474 wrqu->frag.fixed = 0; /* no auto select */
0edd5b44 9475 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
4644151b 9476 mutex_unlock(&priv->mutex);
9fd1ea42 9477 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
43f66a6c
JK		 9478
9479 return 0;
9480}
9481
bf79451e
JG		 9482static int ipw_wx_set_retry(struct net_device *dev,
9483 struct iw_request_info *info,
43f66a6c 9484 union iwreq_data *wrqu, char *extra)
bf79451e 9485{
b0a4e7d8 9486 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2
JK		 9487
9488 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9489 return -EINVAL;
9490
9491 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9492 return 0;
9493
d5f7ac20 9494 if (wrqu->retry.value < 0 || wrqu->retry.value >= 255)
afbf30a2
JK		 9495 return -EINVAL;
9496
4644151b 9497 mutex_lock(&priv->mutex);
919ee6dd 9498 if (wrqu->retry.flags & IW_RETRY_SHORT)
afbf30a2 9499 priv->short_retry_limit = (u8) wrqu->retry.value;
919ee6dd 9500 else if (wrqu->retry.flags & IW_RETRY_LONG)
afbf30a2
JK		 9501 priv->long_retry_limit = (u8) wrqu->retry.value;
9502 else {
9503 priv->short_retry_limit = (u8) wrqu->retry.value;
9504 priv->long_retry_limit = (u8) wrqu->retry.value;
9505 }
9506
9507 ipw_send_retry_limit(priv, priv->short_retry_limit,
9508 priv->long_retry_limit);
4644151b 9509 mutex_unlock(&priv->mutex);
afbf30a2
JK		 9510 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9511 priv->short_retry_limit, priv->long_retry_limit);
9512 return 0;
43f66a6c
JK		 9513}
9514
bf79451e
JG		 9515static int ipw_wx_get_retry(struct net_device *dev,
9516 struct iw_request_info *info,
43f66a6c 9517 union iwreq_data *wrqu, char *extra)
bf79451e 9518{
b0a4e7d8 9519 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 9520
4644151b 9521 mutex_lock(&priv->mutex);
afbf30a2
JK		 9522 wrqu->retry.disabled = 0;
9523
9524 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
4644151b 9525 mutex_unlock(&priv->mutex);
afbf30a2
JK		 9526 return -EINVAL;
9527 }
9528
919ee6dd
JT		 9529 if (wrqu->retry.flags & IW_RETRY_LONG) {
9530 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
afbf30a2 9531 wrqu->retry.value = priv->long_retry_limit;
919ee6dd
JT		 9532 } else if (wrqu->retry.flags & IW_RETRY_SHORT) {
9533 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
afbf30a2
JK		 9534 wrqu->retry.value = priv->short_retry_limit;
9535 } else {
9536 wrqu->retry.flags = IW_RETRY_LIMIT;
9537 wrqu->retry.value = priv->short_retry_limit;
9538 }
4644151b 9539 mutex_unlock(&priv->mutex);
afbf30a2 9540
9fd1ea42 9541 IPW_DEBUG_WX("GET retry -> %d\n", wrqu->retry.value);
afbf30a2
JK		 9542
9543 return 0;
9544}
9545
bf79451e
JG		 9546static int ipw_wx_set_scan(struct net_device *dev,
9547 struct iw_request_info *info,
43f66a6c
JK		 9548 union iwreq_data *wrqu, char *extra)
9549{
b0a4e7d8 9550 struct ipw_priv *priv = libipw_priv(dev);
094c4d2d 9551 struct iw_scan_req *req = (struct iw_scan_req *)extra;
ea177305 9552 struct delayed_work *work = NULL;
094c4d2d 9553
0b531676 9554 mutex_lock(&priv->mutex);
ea177305 9555
0b531676 9556 priv->user_requested_scan = 1;
0b531676 9557
094c4d2d 9558 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
afbf30a2 9559 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
ea177305
DW		 9560 int len = min((int)req->essid_len,
9561 (int)sizeof(priv->direct_scan_ssid));
9562 memcpy(priv->direct_scan_ssid, req->essid, len);
9563 priv->direct_scan_ssid_len = len;
9564 work = &priv->request_direct_scan;
9565 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
9566 work = &priv->request_passive_scan;
094c4d2d 9567 }
ea177305
DW		 9568 } else {
9569 /* Normal active broadcast scan */
9570 work = &priv->request_scan;
afbf30a2 9571 }
8935f39e 9572
ea177305
DW		 9573 mutex_unlock(&priv->mutex);
9574
43f66a6c 9575 IPW_DEBUG_WX("Start scan\n");
b095c381 9576
bcb6d916 9577 schedule_delayed_work(work, 0);
b095c381 9578
43f66a6c
JK		 9579 return 0;
9580}
9581
bf79451e
JG		 9582static int ipw_wx_get_scan(struct net_device *dev,
9583 struct iw_request_info *info,
43f66a6c 9584 union iwreq_data *wrqu, char *extra)
bf79451e 9585{
b0a4e7d8
JL		 9586 struct ipw_priv *priv = libipw_priv(dev);
9587 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
43f66a6c
JK		 9588}
9589
bf79451e 9590static int ipw_wx_set_encode(struct net_device *dev,
0edd5b44
JG		 9591 struct iw_request_info *info,
9592 union iwreq_data *wrqu, char *key)
43f66a6c 9593{
b0a4e7d8 9594 struct ipw_priv *priv = libipw_priv(dev);
afbf30a2 9595 int ret;
caeff81b 9596 u32 cap = priv->capability;
afbf30a2 9597
4644151b 9598 mutex_lock(&priv->mutex);
b0a4e7d8 9599 ret = libipw_wx_set_encode(priv->ieee, info, wrqu, key);
afbf30a2 9600
caeff81b
HL		 9601 /* In IBSS mode, we need to notify the firmware to update
9602 * the beacon info after we changed the capability. */
9603 if (cap != priv->capability &&
9604 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9605 priv->status & STATUS_ASSOCIATED)
9606 ipw_disassociate(priv);
9607
4644151b 9608 mutex_unlock(&priv->mutex);
afbf30a2 9609 return ret;
43f66a6c
JK		 9610}
9611
bf79451e 9612static int ipw_wx_get_encode(struct net_device *dev,
0edd5b44
JG		 9613 struct iw_request_info *info,
9614 union iwreq_data *wrqu, char *key)
43f66a6c 9615{
b0a4e7d8
JL		 9616 struct ipw_priv *priv = libipw_priv(dev);
9617 return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
43f66a6c
JK		 9618}
9619
bf79451e 9620static int ipw_wx_set_power(struct net_device *dev,
0edd5b44
JG		 9621 struct iw_request_info *info,
9622 union iwreq_data *wrqu, char *extra)
43f66a6c 9623{
b0a4e7d8 9624 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9625 int err;
4644151b 9626 mutex_lock(&priv->mutex);
43f66a6c
JK		 9627 if (wrqu->power.disabled) {
9628 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9629 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9630 if (err) {
9631 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9632 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9633 return err;
9634 }
43f66a6c 9635 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
4644151b 9636 mutex_unlock(&priv->mutex);
43f66a6c 9637 return 0;
bf79451e 9638 }
43f66a6c
JK		 9639
9640 switch (wrqu->power.flags & IW_POWER_MODE) {
0edd5b44
JG		 9641 case IW_POWER_ON: /* If not specified */
9642 case IW_POWER_MODE: /* If set all mask */
c03983ac 9643 case IW_POWER_ALL_R: /* If explicitly state all */
43f66a6c 9644 break;
0edd5b44 9645 default: /* Otherwise we don't support it */
43f66a6c
JK		 9646 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9647 wrqu->power.flags);
4644151b 9648 mutex_unlock(&priv->mutex);
bf79451e 9649 return -EOPNOTSUPP;
43f66a6c 9650 }
bf79451e 9651
43f66a6c
JK		 9652 /* If the user hasn't specified a power management mode yet, default
9653 * to BATTERY */
0edd5b44 9654 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
43f66a6c 9655 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
bf79451e 9656 else
43f66a6c 9657 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
4e157f08 9658
43f66a6c
JK		 9659 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9660 if (err) {
9661 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9662 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9663 return err;
9664 }
9665
0edd5b44 9666 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
4644151b 9667 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9668 return 0;
9669}
9670
bf79451e 9671static int ipw_wx_get_power(struct net_device *dev,
0edd5b44
JG		 9672 struct iw_request_info *info,
9673 union iwreq_data *wrqu, char *extra)
43f66a6c 9674{
b0a4e7d8 9675 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9676 mutex_lock(&priv->mutex);
a613bffd 9677 if (!(priv->power_mode & IPW_POWER_ENABLED))
43f66a6c 9678 wrqu->power.disabled = 1;
a613bffd 9679 else
43f66a6c 9680 wrqu->power.disabled = 0;
43f66a6c 9681
4644151b 9682 mutex_unlock(&priv->mutex);
43f66a6c 9683 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
bf79451e 9684
43f66a6c
JK		 9685 return 0;
9686}
9687
bf79451e 9688static int ipw_wx_set_powermode(struct net_device *dev,
0edd5b44
JG		 9689 struct iw_request_info *info,
9690 union iwreq_data *wrqu, char *extra)
43f66a6c 9691{
b0a4e7d8 9692 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9693 int mode = *(int *)extra;
9694 int err;
4e157f08 9695
4644151b 9696 mutex_lock(&priv->mutex);
4e157f08 9697 if ((mode < 1) || (mode > IPW_POWER_LIMIT))
43f66a6c 9698 mode = IPW_POWER_AC;
bf79451e 9699
4e157f08 9700 if (IPW_POWER_LEVEL(priv->power_mode) != mode) {
43f66a6c 9701 err = ipw_send_power_mode(priv, mode);
43f66a6c
JK		 9702 if (err) {
9703 IPW_DEBUG_WX("failed setting power mode.\n");
4644151b 9704 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9705 return err;
9706 }
4e157f08 9707 priv->power_mode = IPW_POWER_ENABLED | mode;
43f66a6c 9708 }
4644151b 9709 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9710 return 0;
9711}
9712
9713#define MAX_WX_STRING 80
bf79451e 9714static int ipw_wx_get_powermode(struct net_device *dev,
0edd5b44
JG		 9715 struct iw_request_info *info,
9716 union iwreq_data *wrqu, char *extra)
43f66a6c 9717{
b0a4e7d8 9718 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9719 int level = IPW_POWER_LEVEL(priv->power_mode);
9720 char *p = extra;
9721
9722 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9723
9724 switch (level) {
9725 case IPW_POWER_AC:
9726 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9727 break;
9728 case IPW_POWER_BATTERY:
9729 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9730 break;
9731 default:
9732 p += snprintf(p, MAX_WX_STRING - (p - extra),
bf79451e 9733 "(Timeout %dms, Period %dms)",
43f66a6c
JK		 9734 timeout_duration[level - 1] / 1000,
9735 period_duration[level - 1] / 1000);
9736 }
9737
9738 if (!(priv->power_mode & IPW_POWER_ENABLED))
0edd5b44 9739 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
43f66a6c
JK		 9740
9741 wrqu->data.length = p - extra + 1;
9742
9743 return 0;
9744}
9745
9746static int ipw_wx_set_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9747 struct iw_request_info *info,
9748 union iwreq_data *wrqu, char *extra)
43f66a6c 9749{
b0a4e7d8 9750 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9751 int mode = *(int *)extra;
9752 u8 band = 0, modulation = 0;
9753
9754 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
0edd5b44 9755 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
43f66a6c
JK		 9756 return -EINVAL;
9757 }
4644151b 9758 mutex_lock(&priv->mutex);
43f66a6c 9759 if (priv->adapter == IPW_2915ABG) {
a33a1982 9760 priv->ieee->abg_true = 1;
43f66a6c 9761 if (mode & IEEE_A) {
b0a4e7d8
JL		 9762 band |= LIBIPW_52GHZ_BAND;
9763 modulation |= LIBIPW_OFDM_MODULATION;
43f66a6c 9764 } else
a33a1982 9765 priv->ieee->abg_true = 0;
43f66a6c
JK		 9766 } else {
9767 if (mode & IEEE_A) {
9768 IPW_WARNING("Attempt to set 2200BG into "
9769 "802.11a mode\n");
4644151b 9770 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9771 return -EINVAL;
9772 }
9773
a33a1982 9774 priv->ieee->abg_true = 0;
43f66a6c
JK		 9775 }
9776
9777 if (mode & IEEE_B) {
b0a4e7d8
JL		 9778 band |= LIBIPW_24GHZ_BAND;
9779 modulation |= LIBIPW_CCK_MODULATION;
43f66a6c 9780 } else
a33a1982 9781 priv->ieee->abg_true = 0;
bf79451e 9782
43f66a6c 9783 if (mode & IEEE_G) {
b0a4e7d8
JL		 9784 band |= LIBIPW_24GHZ_BAND;
9785 modulation |= LIBIPW_OFDM_MODULATION;
43f66a6c 9786 } else
a33a1982 9787 priv->ieee->abg_true = 0;
43f66a6c
JK		 9788
9789 priv->ieee->mode = mode;
9790 priv->ieee->freq_band = band;
9791 priv->ieee->modulation = modulation;
0edd5b44 9792 init_supported_rates(priv, &priv->rates);
43f66a6c 9793
c848d0af
JK		 9794 /* Network configuration changed -- force [re]association */
9795 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9796 if (!ipw_disassociate(priv)) {
43f66a6c 9797 ipw_send_supported_rates(priv, &priv->rates);
c848d0af
JK		 9798 ipw_associate(priv);
9799 }
43f66a6c 9800
a613bffd
JK		 9801 /* Update the band LEDs */
9802 ipw_led_band_on(priv);
43f66a6c 9803
bf79451e 9804 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
43f66a6c 9805 mode & IEEE_A ? 'a' : '.',
0edd5b44 9806 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
4644151b 9807 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9808 return 0;
9809}
9810
9811static int ipw_wx_get_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9812 struct iw_request_info *info,
9813 union iwreq_data *wrqu, char *extra)
43f66a6c 9814{
b0a4e7d8 9815 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9816 mutex_lock(&priv->mutex);
ea2b26e0
JK		 9817 switch (priv->ieee->mode) {
9818 case IEEE_A:
43f66a6c
JK		 9819 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9820 break;
ea2b26e0
JK		 9821 case IEEE_B:
9822 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9823 break;
9824 case IEEE_A | IEEE_B:
9825 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9826 break;
9827 case IEEE_G:
9828 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9829 break;
9830 case IEEE_A | IEEE_G:
9831 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9832 break;
9833 case IEEE_B | IEEE_G:
9834 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9835 break;
9836 case IEEE_A | IEEE_B | IEEE_G:
9837 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9838 break;
9839 default:
9840 strncpy(extra, "unknown", MAX_WX_STRING);
43f66a6c 9841 break;
bf79451e
JG		 9842 }
9843
43f66a6c
JK		 9844 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9845
0edd5b44 9846 wrqu->data.length = strlen(extra) + 1;
4644151b 9847 mutex_unlock(&priv->mutex);
b095c381
JK		 9848
9849 return 0;
9850}
9851
9852static int ipw_wx_set_preamble(struct net_device *dev,
9853 struct iw_request_info *info,
9854 union iwreq_data *wrqu, char *extra)
9855{
b0a4e7d8 9856 struct ipw_priv *priv = libipw_priv(dev);
b095c381 9857 int mode = *(int *)extra;
4644151b 9858 mutex_lock(&priv->mutex);
b095c381
JK		 9859 /* Switching from SHORT -> LONG requires a disassociation */
9860 if (mode == 1) {
9861 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9862 priv->config |= CFG_PREAMBLE_LONG;
9863
9864 /* Network configuration changed -- force [re]association */
9865 IPW_DEBUG_ASSOC
9866 ("[re]association triggered due to preamble change.\n");
9867 if (!ipw_disassociate(priv))
9868 ipw_associate(priv);
9869 }
9870 goto done;
9871 }
43f66a6c 9872
b095c381
JK		 9873 if (mode == 0) {
9874 priv->config &= ~CFG_PREAMBLE_LONG;
9875 goto done;
9876 }
4644151b 9877 mutex_unlock(&priv->mutex);
b095c381
JK		 9878 return -EINVAL;
9879
9880 done:
4644151b 9881 mutex_unlock(&priv->mutex);
b095c381
JK		 9882 return 0;
9883}
9884
9885static int ipw_wx_get_preamble(struct net_device *dev,
9886 struct iw_request_info *info,
9887 union iwreq_data *wrqu, char *extra)
9888{
b0a4e7d8 9889 struct ipw_priv *priv = libipw_priv(dev);
4644151b 9890 mutex_lock(&priv->mutex);
b095c381
JK		 9891 if (priv->config & CFG_PREAMBLE_LONG)
9892 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9893 else
9894 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
4644151b 9895 mutex_unlock(&priv->mutex);
0edd5b44 9896 return 0;
43f66a6c
JK		 9897}
9898
b095c381
JK		 9899#ifdef CONFIG_IPW2200_MONITOR
9900static int ipw_wx_set_monitor(struct net_device *dev,
bf79451e 9901 struct iw_request_info *info,
43f66a6c 9902 union iwreq_data *wrqu, char *extra)
bf79451e 9903{
b0a4e7d8 9904 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 9905 int *parms = (int *)extra;
9906 int enable = (parms[0] > 0);
4644151b 9907 mutex_lock(&priv->mutex);
b095c381 9908 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
43f66a6c
JK		 9909 if (enable) {
9910 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
459d4087 9911#ifdef CONFIG_IPW2200_RADIOTAP
24a47dbd
MK		 9912 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9913#else
43f66a6c 9914 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 9915#endif
bcb6d916 9916 schedule_work(&priv->adapter_restart);
43f66a6c 9917 }
bf79451e 9918
43f66a6c
JK		 9919 ipw_set_channel(priv, parms[1]);
9920 } else {
b095c381 9921 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
4644151b 9922 mutex_unlock(&priv->mutex);
43f66a6c 9923 return 0;
b095c381 9924 }
43f66a6c 9925 priv->net_dev->type = ARPHRD_ETHER;
bcb6d916 9926 schedule_work(&priv->adapter_restart);
43f66a6c 9927 }
4644151b 9928 mutex_unlock(&priv->mutex);
43f66a6c
JK		 9929 return 0;
9930}
9931
67fd6b45 9932#endif /* CONFIG_IPW2200_MONITOR */
b095c381 9933
bf79451e
JG		 9934static int ipw_wx_reset(struct net_device *dev,
9935 struct iw_request_info *info,
43f66a6c 9936 union iwreq_data *wrqu, char *extra)
bf79451e 9937{
b0a4e7d8 9938 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 9939 IPW_DEBUG_WX("RESET\n");
bcb6d916 9940 schedule_work(&priv->adapter_restart);
b095c381
JK		 9941 return 0;
9942}
9943
b095c381
JK		 9944static int ipw_wx_sw_reset(struct net_device *dev,
9945 struct iw_request_info *info,
9946 union iwreq_data *wrqu, char *extra)
ea2b26e0 9947{
b0a4e7d8 9948 struct ipw_priv *priv = libipw_priv(dev);
b095c381
JK		 9949 union iwreq_data wrqu_sec = {
9950 .encoding = {
9951 .flags = IW_ENCODE_DISABLED,
9952 },
9953 };
afbf30a2 9954 int ret;
c848d0af 9955
b095c381 9956 IPW_DEBUG_WX("SW_RESET\n");
ea2b26e0 9957
4644151b 9958 mutex_lock(&priv->mutex);
ea2b26e0 9959
d6d5b5c1 9960 ret = ipw_sw_reset(priv, 2);
afbf30a2
JK		 9961 if (!ret) {
9962 free_firmware();
9963 ipw_adapter_restart(priv);
9964 }
ea2b26e0 9965
b095c381
JK		 9966 /* The SW reset bit might have been toggled on by the 'disable'
9967 * module parameter, so take appropriate action */
9968 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
ea2b26e0 9969
4644151b 9970 mutex_unlock(&priv->mutex);
b0a4e7d8 9971 libipw_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
4644151b 9972 mutex_lock(&priv->mutex);
bf79451e 9973
b095c381
JK		 9974 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9975 /* Configuration likely changed -- force [re]association */
9976 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9977 "reset.\n");
9978 if (!ipw_disassociate(priv))
9979 ipw_associate(priv);
43f66a6c 9980 }
b095c381 9981
4644151b 9982 mutex_unlock(&priv->mutex);
43f66a6c 9983
43f66a6c
JK		 9984 return 0;
9985}
43f66a6c
JK		 9986
9987/* Rebase the WE IOCTLs to zero for the handler array */
0edd5b44 9988static iw_handler ipw_wx_handlers[] = {
56b632e8
JP		 9989 IW_HANDLER(SIOCGIWNAME, (iw_handler)cfg80211_wext_giwname),
9990 IW_HANDLER(SIOCSIWFREQ, ipw_wx_set_freq),
9991 IW_HANDLER(SIOCGIWFREQ, ipw_wx_get_freq),
9992 IW_HANDLER(SIOCSIWMODE, ipw_wx_set_mode),
9993 IW_HANDLER(SIOCGIWMODE, ipw_wx_get_mode),
9994 IW_HANDLER(SIOCSIWSENS, ipw_wx_set_sens),
9995 IW_HANDLER(SIOCGIWSENS, ipw_wx_get_sens),
9996 IW_HANDLER(SIOCGIWRANGE, ipw_wx_get_range),
9997 IW_HANDLER(SIOCSIWAP, ipw_wx_set_wap),
9998 IW_HANDLER(SIOCGIWAP, ipw_wx_get_wap),
9999 IW_HANDLER(SIOCSIWSCAN, ipw_wx_set_scan),
10000 IW_HANDLER(SIOCGIWSCAN, ipw_wx_get_scan),
10001 IW_HANDLER(SIOCSIWESSID, ipw_wx_set_essid),
10002 IW_HANDLER(SIOCGIWESSID, ipw_wx_get_essid),
10003 IW_HANDLER(SIOCSIWNICKN, ipw_wx_set_nick),
10004 IW_HANDLER(SIOCGIWNICKN, ipw_wx_get_nick),
10005 IW_HANDLER(SIOCSIWRATE, ipw_wx_set_rate),
10006 IW_HANDLER(SIOCGIWRATE, ipw_wx_get_rate),
10007 IW_HANDLER(SIOCSIWRTS, ipw_wx_set_rts),
10008 IW_HANDLER(SIOCGIWRTS, ipw_wx_get_rts),
10009 IW_HANDLER(SIOCSIWFRAG, ipw_wx_set_frag),
10010 IW_HANDLER(SIOCGIWFRAG, ipw_wx_get_frag),
10011 IW_HANDLER(SIOCSIWTXPOW, ipw_wx_set_txpow),
10012 IW_HANDLER(SIOCGIWTXPOW, ipw_wx_get_txpow),
10013 IW_HANDLER(SIOCSIWRETRY, ipw_wx_set_retry),
10014 IW_HANDLER(SIOCGIWRETRY, ipw_wx_get_retry),
10015 IW_HANDLER(SIOCSIWENCODE, ipw_wx_set_encode),
10016 IW_HANDLER(SIOCGIWENCODE, ipw_wx_get_encode),
10017 IW_HANDLER(SIOCSIWPOWER, ipw_wx_set_power),
10018 IW_HANDLER(SIOCGIWPOWER, ipw_wx_get_power),
10019 IW_HANDLER(SIOCSIWSPY, iw_handler_set_spy),
10020 IW_HANDLER(SIOCGIWSPY, iw_handler_get_spy),
10021 IW_HANDLER(SIOCSIWTHRSPY, iw_handler_set_thrspy),
10022 IW_HANDLER(SIOCGIWTHRSPY, iw_handler_get_thrspy),
10023 IW_HANDLER(SIOCSIWGENIE, ipw_wx_set_genie),
10024 IW_HANDLER(SIOCGIWGENIE, ipw_wx_get_genie),
10025 IW_HANDLER(SIOCSIWMLME, ipw_wx_set_mlme),
10026 IW_HANDLER(SIOCSIWAUTH, ipw_wx_set_auth),
10027 IW_HANDLER(SIOCGIWAUTH, ipw_wx_get_auth),
10028 IW_HANDLER(SIOCSIWENCODEEXT, ipw_wx_set_encodeext),
10029 IW_HANDLER(SIOCGIWENCODEEXT, ipw_wx_get_encodeext),
43f66a6c
JK		 10030};
10031
b095c381
JK		 10032enum {
10033 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
10034 IPW_PRIV_GET_POWER,
10035 IPW_PRIV_SET_MODE,
10036 IPW_PRIV_GET_MODE,
10037 IPW_PRIV_SET_PREAMBLE,
10038 IPW_PRIV_GET_PREAMBLE,
10039 IPW_PRIV_RESET,
10040 IPW_PRIV_SW_RESET,
10041#ifdef CONFIG_IPW2200_MONITOR
10042 IPW_PRIV_SET_MONITOR,
10043#endif
10044};
43f66a6c 10045
bf79451e 10046static struct iw_priv_args ipw_priv_args[] = {
43f66a6c 10047 {
0edd5b44
JG		 10048 .cmd = IPW_PRIV_SET_POWER,
10049 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10050 .name = "set_power"},
43f66a6c 10051 {
0edd5b44
JG		 10052 .cmd = IPW_PRIV_GET_POWER,
10053 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
10054 .name = "get_power"},
43f66a6c 10055 {
0edd5b44
JG		 10056 .cmd = IPW_PRIV_SET_MODE,
10057 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10058 .name = "set_mode"},
43f66a6c 10059 {
0edd5b44
JG		 10060 .cmd = IPW_PRIV_GET_MODE,
10061 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
10062 .name = "get_mode"},
43f66a6c 10063 {
ea2b26e0
JK		 10064 .cmd = IPW_PRIV_SET_PREAMBLE,
10065 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
10066 .name = "set_preamble"},
10067 {
10068 .cmd = IPW_PRIV_GET_PREAMBLE,
10069 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
10070 .name = "get_preamble"},
43f66a6c 10071 {
0edd5b44
JG		 10072 IPW_PRIV_RESET,
10073 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
b095c381
JK		 10074 {
10075 IPW_PRIV_SW_RESET,
10076 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
10077#ifdef CONFIG_IPW2200_MONITOR
10078 {
10079 IPW_PRIV_SET_MONITOR,
10080 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
10081#endif /* CONFIG_IPW2200_MONITOR */
43f66a6c
JK		 10082};
10083
10084static iw_handler ipw_priv_handler[] = {
10085 ipw_wx_set_powermode,
10086 ipw_wx_get_powermode,
10087 ipw_wx_set_wireless_mode,
10088 ipw_wx_get_wireless_mode,
ea2b26e0
JK		 10089 ipw_wx_set_preamble,
10090 ipw_wx_get_preamble,
bf79451e 10091 ipw_wx_reset,
b095c381
JK		 10092 ipw_wx_sw_reset,
10093#ifdef CONFIG_IPW2200_MONITOR
10094 ipw_wx_set_monitor,
43f66a6c
JK		 10095#endif
10096};
10097
0edd5b44 10098static struct iw_handler_def ipw_wx_handler_def = {
ea2b26e0
JK		 10099 .standard = ipw_wx_handlers,
10100 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
10101 .num_private = ARRAY_SIZE(ipw_priv_handler),
10102 .num_private_args = ARRAY_SIZE(ipw_priv_args),
10103 .private = ipw_priv_handler,
10104 .private_args = ipw_priv_args,
97a78ca9 10105 .get_wireless_stats = ipw_get_wireless_stats,
43f66a6c
JK		 10106};
10107
43f66a6c
JK		 10108/*
10109 * Get wireless statistics.
10110 * Called by /proc/net/wireless
10111 * Also called by SIOCGIWSTATS
10112 */
0edd5b44 10113static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
43f66a6c 10114{
b0a4e7d8 10115 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10116 struct iw_statistics *wstats;
bf79451e 10117
43f66a6c
JK		 10118 wstats = &priv->wstats;
10119
ea2b26e0 10120 /* if hw is disabled, then ipw_get_ordinal() can't be called.
afbf30a2 10121 * netdev->get_wireless_stats seems to be called before fw is
43f66a6c
JK		 10122 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
10123 * and associated; if not associcated, the values are all meaningless
10124 * anyway, so set them all to NULL and INVALID */
10125 if (!(priv->status & STATUS_ASSOCIATED)) {
10126 wstats->miss.beacon = 0;
10127 wstats->discard.retries = 0;
10128 wstats->qual.qual = 0;
10129 wstats->qual.level = 0;
10130 wstats->qual.noise = 0;
10131 wstats->qual.updated = 7;
10132 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
0edd5b44 10133 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
43f66a6c 10134 return wstats;
bf79451e 10135 }
43f66a6c
JK		 10136
10137 wstats->qual.qual = priv->quality;
00d21de5
ZY		 10138 wstats->qual.level = priv->exp_avg_rssi;
10139 wstats->qual.noise = priv->exp_avg_noise;
43f66a6c 10140 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
b191608a 10141 IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
43f66a6c
JK		 10142
10143 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
10144 wstats->discard.retries = priv->last_tx_failures;
10145 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
bf79451e 10146
43f66a6c
JK		 10147/* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
10148 goto fail_get_ordinal;
10149 wstats->discard.retries += tx_retry; */
bf79451e 10150
43f66a6c
JK		 10151 return wstats;
10152}
10153
43f66a6c
JK		 10154/* net device stuff */
10155
858119e1 10156static void init_sys_config(struct ipw_sys_config *sys_config)
43f66a6c 10157{
0edd5b44 10158 memset(sys_config, 0, sizeof(struct ipw_sys_config));
810dabd4 10159 sys_config->bt_coexistence = 0;
43f66a6c
JK		 10160 sys_config->answer_broadcast_ssid_probe = 0;
10161 sys_config->accept_all_data_frames = 0;
10162 sys_config->accept_non_directed_frames = 1;
10163 sys_config->exclude_unicast_unencrypted = 0;
10164 sys_config->disable_unicast_decryption = 1;
10165 sys_config->exclude_multicast_unencrypted = 0;
10166 sys_config->disable_multicast_decryption = 1;
d2b83e12
ZY		 10167 if (antenna < CFG_SYS_ANTENNA_BOTH || antenna > CFG_SYS_ANTENNA_B)
10168 antenna = CFG_SYS_ANTENNA_BOTH;
10169 sys_config->antenna_diversity = antenna;
0edd5b44 10170 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
43f66a6c 10171 sys_config->dot11g_auto_detection = 0;
bf79451e 10172 sys_config->enable_cts_to_self = 0;
43f66a6c 10173 sys_config->bt_coexist_collision_thr = 0;
67fd6b45 10174 sys_config->pass_noise_stats_to_host = 1; /* 1 -- fix for 256 */
12977154 10175 sys_config->silence_threshold = 0x1e;
43f66a6c
JK		 10176}
10177
10178static int ipw_net_open(struct net_device *dev)
10179{
43f66a6c 10180 IPW_DEBUG_INFO("dev->open\n");
521c4d96 10181 netif_start_queue(dev);
43f66a6c
JK		 10182 return 0;
10183}
10184
10185static int ipw_net_stop(struct net_device *dev)
10186{
10187 IPW_DEBUG_INFO("dev->close\n");
10188 netif_stop_queue(dev);
10189 return 0;
10190}
10191
10192/*
10193todo:
10194
10195modify to send one tfd per fragment instead of using chunking. otherwise
b0a4e7d8 10196we need to heavily modify the libipw_skb_to_txb.
43f66a6c
JK		 10197*/
10198
b0a4e7d8 10199static int ipw_tx_skb(struct ipw_priv *priv, struct libipw_txb *txb,
227d2dc1 10200 int pri)
43f66a6c 10201{
b0a4e7d8 10202 struct libipw_hdr_3addrqos *hdr = (struct libipw_hdr_3addrqos *)
0edd5b44 10203 txb->fragments[0]->data;
43f66a6c
JK		 10204 int i = 0;
10205 struct tfd_frame *tfd;
e43e3c1e 10206#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 10207 int tx_id = ipw_get_tx_queue_number(priv, pri);
10208 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10209#else
43f66a6c 10210 struct clx2_tx_queue *txq = &priv->txq[0];
b095c381 10211#endif
43f66a6c
JK		 10212 struct clx2_queue *q = &txq->q;
10213 u8 id, hdr_len, unicast;
c848d0af 10214 int fc;
43f66a6c 10215
b8ddafd7
ZY		 10216 if (!(priv->status & STATUS_ASSOCIATED))
10217 goto drop;
10218
b0a4e7d8 10219 hdr_len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
43f66a6c
JK		 10220 switch (priv->ieee->iw_mode) {
10221 case IW_MODE_ADHOC:
3c19065a 10222 unicast = !is_multicast_ether_addr(hdr->addr1);
43f66a6c
JK		 10223 id = ipw_find_station(priv, hdr->addr1);
10224 if (id == IPW_INVALID_STATION) {
10225 id = ipw_add_station(priv, hdr->addr1);
10226 if (id == IPW_INVALID_STATION) {
10227 IPW_WARNING("Attempt to send data to "
e174961c
JB		 10228 "invalid cell: %pM\n",
10229 hdr->addr1);
43f66a6c
JK		 10230 goto drop;
10231 }
10232 }
10233 break;
10234
10235 case IW_MODE_INFRA:
10236 default:
3c19065a 10237 unicast = !is_multicast_ether_addr(hdr->addr3);
43f66a6c
JK		 10238 id = 0;
10239 break;
10240 }
10241
10242 tfd = &txq->bd[q->first_empty];
10243 txq->txb[q->first_empty] = txb;
10244 memset(tfd, 0, sizeof(*tfd));
10245 tfd->u.data.station_number = id;
10246
10247 tfd->control_flags.message_type = TX_FRAME_TYPE;
10248 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10249
10250 tfd->u.data.cmd_id = DINO_CMD_TX;
a613bffd 10251 tfd->u.data.len = cpu_to_le16(txb->payload_size);
bf79451e 10252
43f66a6c 10253 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
b095c381 10254 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
43f66a6c 10255 else
b095c381 10256 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
43f66a6c 10257
ea2b26e0
JK		 10258 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10259 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
43f66a6c 10260
c848d0af
JK		 10261 fc = le16_to_cpu(hdr->frame_ctl);
10262 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
43f66a6c
JK		 10263
10264 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10265
b095c381
JK		 10266 if (likely(unicast))
10267 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10268
10269 if (txb->encrypted && !priv->ieee->host_encrypt) {
10270 switch (priv->ieee->sec.level) {
10271 case SEC_LEVEL_3:
10272 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10273 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
b095c381
JK		 10274 /* XXX: ACK flag must be set for CCMP even if it
10275 * is a multicast/broadcast packet, because CCMP
10276 * group communication encrypted by GTK is
10277 * actually done by the AP. */
10278 if (!unicast)
10279 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10280
10281 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10282 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10283 tfd->u.data.key_index = 0;
10284 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10285 break;
10286 case SEC_LEVEL_2:
10287 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10288 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
b095c381
JK		 10289 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10290 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10291 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10292 break;
10293 case SEC_LEVEL_1:
10294 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
851ca268 10295 cpu_to_le16(IEEE80211_FCTL_PROTECTED);
274bfb8d
JL		 10296 tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10297 if (priv->ieee->sec.key_sizes[priv->ieee->crypt_info.tx_keyidx] <=
b095c381
JK		 10298 40)
10299 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10300 else
10301 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10302 break;
10303 case SEC_LEVEL_0:
10304 break;
10305 default:
af901ca1 10306 printk(KERN_ERR "Unknown security level %d\n",
b095c381
JK		 10307 priv->ieee->sec.level);
10308 break;
10309 }
10310 } else
10311 /* No hardware encryption */
10312 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10313
e43e3c1e 10314#ifdef CONFIG_IPW2200_QOS
a5cf4fe6
ZY		 10315 if (fc & IEEE80211_STYPE_QOS_DATA)
10316 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
e43e3c1e 10317#endif /* CONFIG_IPW2200_QOS */
b095c381 10318
43f66a6c 10319 /* payload */
a613bffd
JK		 10320 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10321 txb->nr_frags));
10322 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
10323 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10324 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10325 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
10326 i, le32_to_cpu(tfd->u.data.num_chunks),
10327 txb->fragments[i]->len - hdr_len);
bf79451e 10328 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
43f66a6c
JK		 10329 i, tfd->u.data.num_chunks,
10330 txb->fragments[i]->len - hdr_len);
bf79451e 10331 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
43f66a6c
JK		 10332 txb->fragments[i]->len - hdr_len);
10333
0edd5b44 10334 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 10335 cpu_to_le32(pci_map_single
10336 (priv->pci_dev,
10337 txb->fragments[i]->data + hdr_len,
10338 txb->fragments[i]->len - hdr_len,
10339 PCI_DMA_TODEVICE));
10340 tfd->u.data.chunk_len[i] =
10341 cpu_to_le16(txb->fragments[i]->len - hdr_len);
43f66a6c
JK		 10342 }
10343
10344 if (i != txb->nr_frags) {
10345 struct sk_buff *skb;
10346 u16 remaining_bytes = 0;
10347 int j;
10348
10349 for (j = i; j < txb->nr_frags; j++)
10350 remaining_bytes += txb->fragments[j]->len - hdr_len;
10351
10352 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
10353 remaining_bytes);
10354 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
10355 if (skb != NULL) {
a613bffd 10356 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
43f66a6c
JK		 10357 for (j = i; j < txb->nr_frags; j++) {
10358 int size = txb->fragments[j]->len - hdr_len;
afbf30a2 10359
43f66a6c 10360 printk(KERN_INFO "Adding frag %d %d...\n",
0edd5b44 10361 j, size);
43f66a6c 10362 memcpy(skb_put(skb, size),
0edd5b44 10363 txb->fragments[j]->data + hdr_len, size);
43f66a6c
JK		 10364 }
10365 dev_kfree_skb_any(txb->fragments[i]);
10366 txb->fragments[i] = skb;
0edd5b44 10367 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 10368 cpu_to_le32(pci_map_single
10369 (priv->pci_dev, skb->data,
4958730e 10370 remaining_bytes,
a613bffd
JK		 10371 PCI_DMA_TODEVICE));
10372
5c05863d 10373 le32_add_cpu(&tfd->u.data.num_chunks, 1);
bf79451e 10374 }
43f66a6c
JK		 10375 }
10376
10377 /* kick DMA */
10378 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10379 ipw_write32(priv, q->reg_w, q->first_empty);
10380
943dbef4 10381 if (ipw_tx_queue_space(q) < q->high_mark)
f697014a
JK		 10382 netif_stop_queue(priv->net_dev);
10383
227d2dc1 10384 return NETDEV_TX_OK;
43f66a6c 10385
0edd5b44 10386 drop:
43f66a6c 10387 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
b0a4e7d8 10388 libipw_txb_free(txb);
227d2dc1
JK		 10389 return NETDEV_TX_OK;
10390}
10391
10392static int ipw_net_is_queue_full(struct net_device *dev, int pri)
10393{
b0a4e7d8 10394 struct ipw_priv *priv = libipw_priv(dev);
e43e3c1e 10395#ifdef CONFIG_IPW2200_QOS
227d2dc1
JK		 10396 int tx_id = ipw_get_tx_queue_number(priv, pri);
10397 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10398#else
10399 struct clx2_tx_queue *txq = &priv->txq[0];
e43e3c1e 10400#endif /* CONFIG_IPW2200_QOS */
227d2dc1 10401
943dbef4 10402 if (ipw_tx_queue_space(&txq->q) < txq->q.high_mark)
227d2dc1
JK		 10403 return 1;
10404
10405 return 0;
43f66a6c
JK		 10406}
10407
d685b8c2
ZY		 10408#ifdef CONFIG_IPW2200_PROMISCUOUS
10409static void ipw_handle_promiscuous_tx(struct ipw_priv *priv,
b0a4e7d8 10410 struct libipw_txb *txb)
d685b8c2 10411{
b0a4e7d8 10412 struct libipw_rx_stats dummystats;
d685b8c2
ZY		 10413 struct ieee80211_hdr *hdr;
10414 u8 n;
10415 u16 filter = priv->prom_priv->filter;
10416 int hdr_only = 0;
10417
10418 if (filter & IPW_PROM_NO_TX)
10419 return;
10420
10421 memset(&dummystats, 0, sizeof(dummystats));
10422
25985edc 10423 /* Filtering of fragment chains is done against the first fragment */
d685b8c2 10424 hdr = (void *)txb->fragments[0]->data;
b0a4e7d8 10425 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10426 if (filter & IPW_PROM_NO_MGMT)
10427 return;
10428 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
10429 hdr_only = 1;
b0a4e7d8 10430 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10431 if (filter & IPW_PROM_NO_CTL)
10432 return;
10433 if (filter & IPW_PROM_CTL_HEADER_ONLY)
10434 hdr_only = 1;
b0a4e7d8 10435 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
d685b8c2
ZY		 10436 if (filter & IPW_PROM_NO_DATA)
10437 return;
10438 if (filter & IPW_PROM_DATA_HEADER_ONLY)
10439 hdr_only = 1;
10440 }
10441
10442 for(n=0; n<txb->nr_frags; ++n) {
10443 struct sk_buff *src = txb->fragments[n];
10444 struct sk_buff *dst;
10445 struct ieee80211_radiotap_header *rt_hdr;
10446 int len;
10447
10448 if (hdr_only) {
10449 hdr = (void *)src->data;
b0a4e7d8 10450 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
d685b8c2
ZY		 10451 } else
10452 len = src->len;
10453
007e5ddd
JB		 10454 dst = alloc_skb(len + sizeof(*rt_hdr), GFP_ATOMIC);
10455 if (!dst)
10456 continue;
d685b8c2
ZY		 10457
10458 rt_hdr = (void *)skb_put(dst, sizeof(*rt_hdr));
10459
10460 rt_hdr->it_version = PKTHDR_RADIOTAP_VERSION;
10461 rt_hdr->it_pad = 0;
10462 rt_hdr->it_present = 0; /* after all, it's just an idea */
743b84d2 10463 rt_hdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_CHANNEL);
d685b8c2 10464
e62e1ee0 10465 *(__le16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(
d685b8c2
ZY		 10466 ieee80211chan2mhz(priv->channel));
10467 if (priv->channel > 14) /* 802.11a */
e62e1ee0 10468 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10469 cpu_to_le16(IEEE80211_CHAN_OFDM |
10470 IEEE80211_CHAN_5GHZ);
10471 else if (priv->ieee->mode == IEEE_B) /* 802.11b */
e62e1ee0 10472 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10473 cpu_to_le16(IEEE80211_CHAN_CCK |
10474 IEEE80211_CHAN_2GHZ);
10475 else /* 802.11g */
e62e1ee0 10476 *(__le16*)skb_put(dst, sizeof(u16)) =
d685b8c2
ZY		 10477 cpu_to_le16(IEEE80211_CHAN_OFDM |
10478 IEEE80211_CHAN_2GHZ);
10479
743b84d2 10480 rt_hdr->it_len = cpu_to_le16(dst->len);
d685b8c2 10481
d626f62b 10482 skb_copy_from_linear_data(src, skb_put(dst, len), len);
d685b8c2 10483
b0a4e7d8 10484 if (!libipw_rx(priv->prom_priv->ieee, dst, &dummystats))
d685b8c2
ZY		 10485 dev_kfree_skb_any(dst);
10486 }
10487}
10488#endif
10489
d0cf9c0d
SH		 10490static netdev_tx_t ipw_net_hard_start_xmit(struct libipw_txb *txb,
10491 struct net_device *dev, int pri)
43f66a6c 10492{
b0a4e7d8 10493 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10494 unsigned long flags;
d0cf9c0d 10495 netdev_tx_t ret;
43f66a6c
JK		 10496
10497 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
43f66a6c
JK		 10498 spin_lock_irqsave(&priv->lock, flags);
10499
d685b8c2
ZY		 10500#ifdef CONFIG_IPW2200_PROMISCUOUS
10501 if (rtap_iface && netif_running(priv->prom_net_dev))
10502 ipw_handle_promiscuous_tx(priv, txb);
10503#endif
10504
227d2dc1
JK		 10505 ret = ipw_tx_skb(priv, txb, pri);
10506 if (ret == NETDEV_TX_OK)
10507 __ipw_led_activity_on(priv);
43f66a6c 10508 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 10509
227d2dc1 10510 return ret;
43f66a6c
JK		 10511}
10512
43f66a6c
JK		 10513static void ipw_net_set_multicast_list(struct net_device *dev)
10514{
10515
10516}
10517
10518static int ipw_net_set_mac_address(struct net_device *dev, void *p)
10519{
b0a4e7d8 10520 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10521 struct sockaddr *addr = p;
0795af57 10522
43f66a6c
JK		 10523 if (!is_valid_ether_addr(addr->sa_data))
10524 return -EADDRNOTAVAIL;
4644151b 10525 mutex_lock(&priv->mutex);
43f66a6c
JK		 10526 priv->config |= CFG_CUSTOM_MAC;
10527 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
e174961c
JB		 10528 printk(KERN_INFO "%s: Setting MAC to %pM\n",
10529 priv->net_dev->name, priv->mac_addr);
bcb6d916 10530 schedule_work(&priv->adapter_restart);
4644151b 10531 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10532 return 0;
10533}
10534
bf79451e 10535static void ipw_ethtool_get_drvinfo(struct net_device *dev,
43f66a6c
JK		 10536 struct ethtool_drvinfo *info)
10537{
b0a4e7d8 10538 struct ipw_priv *p = libipw_priv(dev);
43f66a6c
JK		 10539 char vers[64];
10540 char date[32];
10541 u32 len;
10542
10543 strcpy(info->driver, DRV_NAME);
10544 strcpy(info->version, DRV_VERSION);
10545
10546 len = sizeof(vers);
10547 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
10548 len = sizeof(date);
10549 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
10550
0edd5b44 10551 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
43f66a6c
JK		 10552 vers, date);
10553 strcpy(info->bus_info, pci_name(p->pci_dev));
b095c381 10554 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 10555}
10556
10557static u32 ipw_ethtool_get_link(struct net_device *dev)
10558{
b0a4e7d8 10559 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c
JK		 10560 return (priv->status & STATUS_ASSOCIATED) != 0;
10561}
10562
10563static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10564{
b095c381 10565 return IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 10566}
10567
10568static int ipw_ethtool_get_eeprom(struct net_device *dev,
0edd5b44 10569 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c 10570{
b0a4e7d8 10571 struct ipw_priv *p = libipw_priv(dev);
43f66a6c 10572
b095c381 10573 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 10574 return -EINVAL;
4644151b 10575 mutex_lock(&p->mutex);
afbf30a2 10576 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
4644151b 10577 mutex_unlock(&p->mutex);
43f66a6c
JK		 10578 return 0;
10579}
10580
10581static int ipw_ethtool_set_eeprom(struct net_device *dev,
0edd5b44 10582 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c 10583{
b0a4e7d8 10584 struct ipw_priv *p = libipw_priv(dev);
43f66a6c
JK		 10585 int i;
10586
b095c381 10587 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 10588 return -EINVAL;
4644151b 10589 mutex_lock(&p->mutex);
afbf30a2 10590 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
71e585fc
AB		 10591 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
10592 ipw_write8(p, i + IPW_EEPROM_DATA, p->eeprom[i]);
4644151b 10593 mutex_unlock(&p->mutex);
43f66a6c
JK		 10594 return 0;
10595}
10596
7282d491 10597static const struct ethtool_ops ipw_ethtool_ops = {
ea2b26e0
JK		 10598 .get_link = ipw_ethtool_get_link,
10599 .get_drvinfo = ipw_ethtool_get_drvinfo,
10600 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10601 .get_eeprom = ipw_ethtool_get_eeprom,
10602 .set_eeprom = ipw_ethtool_set_eeprom,
43f66a6c
JK		 10603};
10604
7d12e780 10605static irqreturn_t ipw_isr(int irq, void *data)
43f66a6c
JK		 10606{
10607 struct ipw_priv *priv = data;
10608 u32 inta, inta_mask;
bf79451e 10609
43f66a6c
JK		 10610 if (!priv)
10611 return IRQ_NONE;
10612
89c318ed 10613 spin_lock(&priv->irq_lock);
43f66a6c
JK		 10614
10615 if (!(priv->status & STATUS_INT_ENABLED)) {
d00d0121 10616 /* IRQ is disabled */
43f66a6c
JK		 10617 goto none;
10618 }
10619
b095c381
JK		 10620 inta = ipw_read32(priv, IPW_INTA_RW);
10621 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
bf79451e 10622
43f66a6c
JK		 10623 if (inta == 0xFFFFFFFF) {
10624 /* Hardware disappeared */
10625 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10626 goto none;
10627 }
10628
b095c381 10629 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
43f66a6c
JK		 10630 /* Shared interrupt */
10631 goto none;
10632 }
10633
10634 /* tell the device to stop sending interrupts */
89c318ed 10635 __ipw_disable_interrupts(priv);
bf79451e 10636
43f66a6c 10637 /* ack current interrupts */
b095c381
JK		 10638 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10639 ipw_write32(priv, IPW_INTA_RW, inta);
bf79451e 10640
43f66a6c
JK		 10641 /* Cache INTA value for our tasklet */
10642 priv->isr_inta = inta;
10643
10644 tasklet_schedule(&priv->irq_tasklet);
10645
89c318ed 10646 spin_unlock(&priv->irq_lock);
43f66a6c
JK		 10647
10648 return IRQ_HANDLED;
0edd5b44 10649 none:
89c318ed 10650 spin_unlock(&priv->irq_lock);
43f66a6c
JK		 10651 return IRQ_NONE;
10652}
10653
10654static void ipw_rf_kill(void *adapter)
10655{
10656 struct ipw_priv *priv = adapter;
10657 unsigned long flags;
bf79451e 10658
43f66a6c
JK		 10659 spin_lock_irqsave(&priv->lock, flags);
10660
10661 if (rf_kill_active(priv)) {
10662 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
bcb6d916 10663 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
43f66a6c
JK		 10664 goto exit_unlock;
10665 }
10666
10667 /* RF Kill is now disabled, so bring the device back up */
10668
10669 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10670 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10671 "device\n");
10672
10673 /* we can not do an adapter restart while inside an irq lock */
bcb6d916 10674 schedule_work(&priv->adapter_restart);
bf79451e 10675 } else
43f66a6c
JK		 10676 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10677 "enabled\n");
10678
0edd5b44 10679 exit_unlock:
43f66a6c
JK		 10680 spin_unlock_irqrestore(&priv->lock, flags);
10681}
10682
c4028958 10683static void ipw_bg_rf_kill(struct work_struct *work)
c848d0af 10684{
c4028958
DH		 10685 struct ipw_priv *priv =
10686 container_of(work, struct ipw_priv, rf_kill.work);
4644151b 10687 mutex_lock(&priv->mutex);
c4028958 10688 ipw_rf_kill(priv);
4644151b 10689 mutex_unlock(&priv->mutex);
c848d0af
JK		 10690}
10691
a73e22b2 10692static void ipw_link_up(struct ipw_priv *priv)
a613bffd 10693{
afbf30a2
JK		 10694 priv->last_seq_num = -1;
10695 priv->last_frag_num = -1;
10696 priv->last_packet_time = 0;
10697
a613bffd 10698 netif_carrier_on(priv->net_dev);
a613bffd 10699
c848d0af 10700 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 10701 cancel_delayed_work(&priv->request_direct_scan);
10702 cancel_delayed_work(&priv->request_passive_scan);
0b531676 10703 cancel_delayed_work(&priv->scan_event);
a613bffd
JK		 10704 ipw_reset_stats(priv);
10705 /* Ensure the rate is updated immediately */
10706 priv->last_rate = ipw_get_current_rate(priv);
10707 ipw_gather_stats(priv);
10708 ipw_led_link_up(priv);
10709 notify_wx_assoc_event(priv);
10710
10711 if (priv->config & CFG_BACKGROUND_SCAN)
bcb6d916 10712 schedule_delayed_work(&priv->request_scan, HZ);
a613bffd
JK		 10713}
10714
c4028958 10715static void ipw_bg_link_up(struct work_struct *work)
c848d0af 10716{
c4028958
DH		 10717 struct ipw_priv *priv =
10718 container_of(work, struct ipw_priv, link_up);
4644151b 10719 mutex_lock(&priv->mutex);
c4028958 10720 ipw_link_up(priv);
4644151b 10721 mutex_unlock(&priv->mutex);
c848d0af
JK		 10722}
10723
a73e22b2 10724static void ipw_link_down(struct ipw_priv *priv)
a613bffd
JK		 10725{
10726 ipw_led_link_down(priv);
10727 netif_carrier_off(priv->net_dev);
a613bffd
JK		 10728 notify_wx_assoc_event(priv);
10729
10730 /* Cancel any queued work ... */
10731 cancel_delayed_work(&priv->request_scan);
ea177305
DW		 10732 cancel_delayed_work(&priv->request_direct_scan);
10733 cancel_delayed_work(&priv->request_passive_scan);
a613bffd
JK		 10734 cancel_delayed_work(&priv->adhoc_check);
10735 cancel_delayed_work(&priv->gather_stats);
10736
10737 ipw_reset_stats(priv);
10738
afbf30a2
JK		 10739 if (!(priv->status & STATUS_EXIT_PENDING)) {
10740 /* Queue up another scan... */
bcb6d916 10741 schedule_delayed_work(&priv->request_scan, 0);
0b531676
DW		 10742 } else
10743 cancel_delayed_work(&priv->scan_event);
a613bffd
JK		 10744}
10745
c4028958 10746static void ipw_bg_link_down(struct work_struct *work)
c848d0af 10747{
c4028958
DH		 10748 struct ipw_priv *priv =
10749 container_of(work, struct ipw_priv, link_down);
4644151b 10750 mutex_lock(&priv->mutex);
c4028958 10751 ipw_link_down(priv);
4644151b 10752 mutex_unlock(&priv->mutex);
43f66a6c
JK		 10753}
10754
2ef19e63 10755static int __devinit ipw_setup_deferred_work(struct ipw_priv *priv)
43f66a6c
JK		 10756{
10757 int ret = 0;
10758
43f66a6c 10759 init_waitqueue_head(&priv->wait_command_queue);
afbf30a2 10760 init_waitqueue_head(&priv->wait_state);
43f66a6c 10761
c4028958
DH		 10762 INIT_DELAYED_WORK(&priv->adhoc_check, ipw_bg_adhoc_check);
10763 INIT_WORK(&priv->associate, ipw_bg_associate);
10764 INIT_WORK(&priv->disassociate, ipw_bg_disassociate);
10765 INIT_WORK(&priv->system_config, ipw_system_config);
10766 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish);
10767 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart);
10768 INIT_DELAYED_WORK(&priv->rf_kill, ipw_bg_rf_kill);
10769 INIT_WORK(&priv->up, ipw_bg_up);
10770 INIT_WORK(&priv->down, ipw_bg_down);
10771 INIT_DELAYED_WORK(&priv->request_scan, ipw_request_scan);
ea177305
DW		 10772 INIT_DELAYED_WORK(&priv->request_direct_scan, ipw_request_direct_scan);
10773 INIT_DELAYED_WORK(&priv->request_passive_scan, ipw_request_passive_scan);
0b531676 10774 INIT_DELAYED_WORK(&priv->scan_event, ipw_scan_event);
c4028958
DH		 10775 INIT_DELAYED_WORK(&priv->gather_stats, ipw_bg_gather_stats);
10776 INIT_WORK(&priv->abort_scan, ipw_bg_abort_scan);
10777 INIT_WORK(&priv->roam, ipw_bg_roam);
10778 INIT_DELAYED_WORK(&priv->scan_check, ipw_bg_scan_check);
10779 INIT_WORK(&priv->link_up, ipw_bg_link_up);
10780 INIT_WORK(&priv->link_down, ipw_bg_link_down);
10781 INIT_DELAYED_WORK(&priv->led_link_on, ipw_bg_led_link_on);
10782 INIT_DELAYED_WORK(&priv->led_link_off, ipw_bg_led_link_off);
10783 INIT_DELAYED_WORK(&priv->led_act_off, ipw_bg_led_activity_off);
10784 INIT_WORK(&priv->merge_networks, ipw_merge_adhoc_network);
43f66a6c 10785
e43e3c1e 10786#ifdef CONFIG_IPW2200_QOS
c4028958 10787 INIT_WORK(&priv->qos_activate, ipw_bg_qos_activate);
e43e3c1e 10788#endif /* CONFIG_IPW2200_QOS */
43f66a6c
JK		 10789
10790 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10791 ipw_irq_tasklet, (unsigned long)priv);
10792
10793 return ret;
10794}
10795
43f66a6c 10796static void shim__set_security(struct net_device *dev,
b0a4e7d8 10797 struct libipw_security *sec)
43f66a6c 10798{
b0a4e7d8 10799 struct ipw_priv *priv = libipw_priv(dev);
43f66a6c 10800 int i;
bf79451e 10801 for (i = 0; i < 4; i++) {
43f66a6c 10802 if (sec->flags & (1 << i)) {
afbf30a2 10803 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
b095c381 10804 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
43f66a6c 10805 if (sec->key_sizes[i] == 0)
b095c381
JK		 10806 priv->ieee->sec.flags &= ~(1 << i);
10807 else {
10808 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
43f66a6c 10809 sec->key_sizes[i]);
b095c381
JK		 10810 priv->ieee->sec.flags |= (1 << i);
10811 }
43f66a6c 10812 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10813 } else if (sec->level != SEC_LEVEL_1)
10814 priv->ieee->sec.flags &= ~(1 << i);
43f66a6c
JK		 10815 }
10816
b095c381 10817 if (sec->flags & SEC_ACTIVE_KEY) {
43f66a6c 10818 if (sec->active_key <= 3) {
b095c381
JK		 10819 priv->ieee->sec.active_key = sec->active_key;
10820 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
bf79451e 10821 } else
b095c381 10822 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c 10823 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10824 } else
10825 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c
JK		 10826
10827 if ((sec->flags & SEC_AUTH_MODE) &&
b095c381
JK		 10828 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10829 priv->ieee->sec.auth_mode = sec->auth_mode;
10830 priv->ieee->sec.flags |= SEC_AUTH_MODE;
43f66a6c
JK		 10831 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10832 priv->capability |= CAP_SHARED_KEY;
10833 else
10834 priv->capability &= ~CAP_SHARED_KEY;
10835 priv->status |= STATUS_SECURITY_UPDATED;
10836 }
bf79451e 10837
b095c381
JK		 10838 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10839 priv->ieee->sec.flags |= SEC_ENABLED;
10840 priv->ieee->sec.enabled = sec->enabled;
43f66a6c 10841 priv->status |= STATUS_SECURITY_UPDATED;
bf79451e 10842 if (sec->enabled)
43f66a6c
JK		 10843 priv->capability |= CAP_PRIVACY_ON;
10844 else
10845 priv->capability &= ~CAP_PRIVACY_ON;
10846 }
bf79451e 10847
afbf30a2
JK		 10848 if (sec->flags & SEC_ENCRYPT)
10849 priv->ieee->sec.encrypt = sec->encrypt;
bf79451e 10850
b095c381
JK		 10851 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10852 priv->ieee->sec.level = sec->level;
10853 priv->ieee->sec.flags |= SEC_LEVEL;
43f66a6c
JK		 10854 priv->status |= STATUS_SECURITY_UPDATED;
10855 }
10856
1fbfea54
ZY		 10857 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10858 ipw_set_hwcrypto_keys(priv);
10859
bf79451e
JG		 10860 /* To match current functionality of ipw2100 (which works well w/
10861 * various supplicants, we don't force a disassociate if the
43f66a6c
JK		 10862 * privacy capability changes ... */
10863#if 0
10864 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
bf79451e 10865 (((priv->assoc_request.capability &
5b5e807f 10866 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && !sec->enabled) ||
bf79451e 10867 (!(priv->assoc_request.capability &
5b5e807f 10868 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && sec->enabled))) {
43f66a6c
JK		 10869 IPW_DEBUG_ASSOC("Disassociating due to capability "
10870 "change.\n");
10871 ipw_disassociate(priv);
10872 }
10873#endif
10874}
10875
bf79451e 10876static int init_supported_rates(struct ipw_priv *priv,
43f66a6c
JK		 10877 struct ipw_supported_rates *rates)
10878{
10879 /* TODO: Mask out rates based on priv->rates_mask */
10880
10881 memset(rates, 0, sizeof(*rates));
0edd5b44 10882 /* configure supported rates */
43f66a6c 10883 switch (priv->ieee->freq_band) {
b0a4e7d8 10884 case LIBIPW_52GHZ_BAND:
43f66a6c
JK		 10885 rates->ieee_mode = IPW_A_MODE;
10886 rates->purpose = IPW_RATE_CAPABILITIES;
b0a4e7d8
JL		 10887 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10888 LIBIPW_OFDM_DEFAULT_RATES_MASK);
43f66a6c
JK		 10889 break;
10890
0edd5b44 10891 default: /* Mixed or 2.4Ghz */
43f66a6c
JK		 10892 rates->ieee_mode = IPW_G_MODE;
10893 rates->purpose = IPW_RATE_CAPABILITIES;
b0a4e7d8
JL		 10894 ipw_add_cck_scan_rates(rates, LIBIPW_CCK_MODULATION,
10895 LIBIPW_CCK_DEFAULT_RATES_MASK);
10896 if (priv->ieee->modulation & LIBIPW_OFDM_MODULATION) {
10897 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10898 LIBIPW_OFDM_DEFAULT_RATES_MASK);
43f66a6c
JK		 10899 }
10900 break;
10901 }
10902
10903 return 0;
10904}
10905
bf79451e 10906static int ipw_config(struct ipw_priv *priv)
43f66a6c 10907{
43f66a6c
JK		 10908 /* This is only called from ipw_up, which resets/reloads the firmware
10909 so, we don't need to first disable the card before we configure
10910 it */
6de9f7f2 10911 if (ipw_set_tx_power(priv))
43f66a6c
JK		 10912 goto error;
10913
10914 /* initialize adapter address */
10915 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10916 goto error;
10917
10918 /* set basic system config settings */
10919 init_sys_config(&priv->sys_config);
810dabd4
ZY		 10920
10921 /* Support Bluetooth if we have BT h/w on board, and user wants to.
10922 * Does not support BT priority yet (don't abort or defer our Tx) */
10923 if (bt_coexist) {
2638bc39 10924 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
810dabd4
ZY		 10925
10926 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10927 priv->sys_config.bt_coexistence
2638bc39 10928 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
810dabd4
ZY		 10929 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10930 priv->sys_config.bt_coexistence
2638bc39 10931 |= CFG_BT_COEXISTENCE_OOB;
810dabd4
ZY		 10932 }
10933
d685b8c2
ZY		 10934#ifdef CONFIG_IPW2200_PROMISCUOUS
10935 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
10936 priv->sys_config.accept_all_data_frames = 1;
10937 priv->sys_config.accept_non_directed_frames = 1;
10938 priv->sys_config.accept_all_mgmt_bcpr = 1;
10939 priv->sys_config.accept_all_mgmt_frames = 1;
10940 }
10941#endif
10942
c848d0af
JK		 10943 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10944 priv->sys_config.answer_broadcast_ssid_probe = 1;
10945 else
10946 priv->sys_config.answer_broadcast_ssid_probe = 0;
10947
d685b8c2 10948 if (ipw_send_system_config(priv))
43f66a6c
JK		 10949 goto error;
10950
0edd5b44
JG		 10951 init_supported_rates(priv, &priv->rates);
10952 if (ipw_send_supported_rates(priv, &priv->rates))
43f66a6c
JK		 10953 goto error;
10954
10955 /* Set request-to-send threshold */
10956 if (priv->rts_threshold) {
10957 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10958 goto error;
10959 }
e43e3c1e 10960#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 10961 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10962 ipw_qos_activate(priv, NULL);
e43e3c1e 10963#endif /* CONFIG_IPW2200_QOS */
43f66a6c
JK		 10964
10965 if (ipw_set_random_seed(priv))
10966 goto error;
bf79451e 10967
43f66a6c
JK		 10968 /* final state transition to the RUN state */
10969 if (ipw_send_host_complete(priv))
10970 goto error;
10971
e666619e
JK		 10972 priv->status |= STATUS_INIT;
10973
10974 ipw_led_init(priv);
10975 ipw_led_radio_on(priv);
10976 priv->notif_missed_beacons = 0;
10977
10978 /* Set hardware WEP key if it is configured. */
10979 if ((priv->capability & CAP_PRIVACY_ON) &&
10980 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10981 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10982 ipw_set_hwcrypto_keys(priv);
43f66a6c
JK		 10983
10984 return 0;
bf79451e 10985
0edd5b44 10986 error:
43f66a6c
JK		 10987 return -EIO;
10988}
10989
4f36f808
JK		 10990/*
10991 * NOTE:
10992 *
10993 * These tables have been tested in conjunction with the
10994 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10995 *
10996 * Altering this values, using it on other hardware, or in geographies
10997 * not intended for resale of the above mentioned Intel adapters has
10998 * not been tested.
10999 *
48a84770
HBA		 11000 * Remember to update the table in README.ipw2200 when changing this
11001 * table.
11002 *
4f36f808 11003 */
b0a4e7d8 11004static const struct libipw_geo ipw_geos[] = {
4f36f808
JK		 11005 { /* Restricted */
11006 "---",
11007 .bg_channels = 11,
11008 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11009 {2427, 4}, {2432, 5}, {2437, 6},
11010 {2442, 7}, {2447, 8}, {2452, 9},
11011 {2457, 10}, {2462, 11}},
11012 },
11013
11014 { /* Custom US/Canada */
11015 "ZZF",
11016 .bg_channels = 11,
11017 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11018 {2427, 4}, {2432, 5}, {2437, 6},
11019 {2442, 7}, {2447, 8}, {2452, 9},
11020 {2457, 10}, {2462, 11}},
11021 .a_channels = 8,
11022 .a = {{5180, 36},
11023 {5200, 40},
11024 {5220, 44},
11025 {5240, 48},
b0a4e7d8
JL		 11026 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11027 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11028 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11029 {5320, 64, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11030 },
11031
11032 { /* Rest of World */
11033 "ZZD",
11034 .bg_channels = 13,
11035 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11036 {2427, 4}, {2432, 5}, {2437, 6},
11037 {2442, 7}, {2447, 8}, {2452, 9},
11038 {2457, 10}, {2462, 11}, {2467, 12},
11039 {2472, 13}},
11040 },
11041
11042 { /* Custom USA & Europe & High */
11043 "ZZA",
11044 .bg_channels = 11,
11045 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11046 {2427, 4}, {2432, 5}, {2437, 6},
11047 {2442, 7}, {2447, 8}, {2452, 9},
11048 {2457, 10}, {2462, 11}},
11049 .a_channels = 13,
11050 .a = {{5180, 36},
11051 {5200, 40},
11052 {5220, 44},
11053 {5240, 48},
b0a4e7d8
JL		 11054 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11055 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11056 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11057 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
4f36f808
JK		 11058 {5745, 149},
11059 {5765, 153},
11060 {5785, 157},
11061 {5805, 161},
11062 {5825, 165}},
11063 },
11064
11065 { /* Custom NA & Europe */
11066 "ZZB",
11067 .bg_channels = 11,
11068 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11069 {2427, 4}, {2432, 5}, {2437, 6},
11070 {2442, 7}, {2447, 8}, {2452, 9},
11071 {2457, 10}, {2462, 11}},
11072 .a_channels = 13,
11073 .a = {{5180, 36},
11074 {5200, 40},
11075 {5220, 44},
11076 {5240, 48},
b0a4e7d8
JL		 11077 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11078 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11079 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11080 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11081 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11082 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11083 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11084 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11085 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11086 },
11087
11088 { /* Custom Japan */
11089 "ZZC",
11090 .bg_channels = 11,
11091 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11092 {2427, 4}, {2432, 5}, {2437, 6},
11093 {2442, 7}, {2447, 8}, {2452, 9},
11094 {2457, 10}, {2462, 11}},
11095 .a_channels = 4,
11096 .a = {{5170, 34}, {5190, 38},
11097 {5210, 42}, {5230, 46}},
11098 },
11099
11100 { /* Custom */
11101 "ZZM",
11102 .bg_channels = 11,
11103 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11104 {2427, 4}, {2432, 5}, {2437, 6},
11105 {2442, 7}, {2447, 8}, {2452, 9},
11106 {2457, 10}, {2462, 11}},
11107 },
11108
11109 { /* Europe */
11110 "ZZE",
11111 .bg_channels = 13,
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}, {2467, 12},
11116 {2472, 13}},
11117 .a_channels = 19,
11118 .a = {{5180, 36},
11119 {5200, 40},
11120 {5220, 44},
11121 {5240, 48},
b0a4e7d8
JL		 11122 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11123 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11124 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11125 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11126 {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11127 {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11128 {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11129 {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11130 {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11131 {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11132 {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11133 {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11134 {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11135 {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11136 {5700, 140, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11137 },
11138
11139 { /* Custom Japan */
11140 "ZZJ",
11141 .bg_channels = 14,
11142 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11143 {2427, 4}, {2432, 5}, {2437, 6},
11144 {2442, 7}, {2447, 8}, {2452, 9},
11145 {2457, 10}, {2462, 11}, {2467, 12},
b0a4e7d8 11146 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY}},
4f36f808
JK		 11147 .a_channels = 4,
11148 .a = {{5170, 34}, {5190, 38},
11149 {5210, 42}, {5230, 46}},
11150 },
11151
03520576
JK		 11152 { /* Rest of World */
11153 "ZZR",
11154 .bg_channels = 14,
11155 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11156 {2427, 4}, {2432, 5}, {2437, 6},
11157 {2442, 7}, {2447, 8}, {2452, 9},
11158 {2457, 10}, {2462, 11}, {2467, 12},
b0a4e7d8
JL		 11159 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY |
11160 LIBIPW_CH_PASSIVE_ONLY}},
03520576
JK		 11161 },
11162
4f36f808
JK		 11163 { /* High Band */
11164 "ZZH",
11165 .bg_channels = 13,
11166 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11167 {2427, 4}, {2432, 5}, {2437, 6},
11168 {2442, 7}, {2447, 8}, {2452, 9},
11169 {2457, 10}, {2462, 11},
b0a4e7d8
JL		 11170 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11171 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11172 .a_channels = 4,
11173 .a = {{5745, 149}, {5765, 153},
11174 {5785, 157}, {5805, 161}},
11175 },
11176
11177 { /* Custom Europe */
11178 "ZZG",
11179 .bg_channels = 13,
11180 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11181 {2427, 4}, {2432, 5}, {2437, 6},
11182 {2442, 7}, {2447, 8}, {2452, 9},
11183 {2457, 10}, {2462, 11},
11184 {2467, 12}, {2472, 13}},
11185 .a_channels = 4,
11186 .a = {{5180, 36}, {5200, 40},
11187 {5220, 44}, {5240, 48}},
11188 },
11189
11190 { /* Europe */
11191 "ZZK",
11192 .bg_channels = 13,
11193 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11194 {2427, 4}, {2432, 5}, {2437, 6},
11195 {2442, 7}, {2447, 8}, {2452, 9},
11196 {2457, 10}, {2462, 11},
b0a4e7d8
JL		 11197 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11198 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808 11199 .a_channels = 24,
b0a4e7d8
JL		 11200 .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11201 {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11202 {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11203 {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11204 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11205 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11206 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11207 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11208 {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11209 {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11210 {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11211 {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11212 {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11213 {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11214 {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11215 {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11216 {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11217 {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11218 {5700, 140, LIBIPW_CH_PASSIVE_ONLY},
11219 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11220 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11221 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11222 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11223 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808
JK		 11224 },
11225
11226 { /* Europe */
11227 "ZZL",
11228 .bg_channels = 11,
11229 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11230 {2427, 4}, {2432, 5}, {2437, 6},
11231 {2442, 7}, {2447, 8}, {2452, 9},
11232 {2457, 10}, {2462, 11}},
11233 .a_channels = 13,
b0a4e7d8
JL		 11234 .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11235 {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11236 {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11237 {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11238 {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11239 {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11240 {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11241 {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11242 {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11243 {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11244 {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11245 {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11246 {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
4f36f808 11247 }
afbf30a2
JK		 11248};
11249
43f66a6c
JK		 11250#define MAX_HW_RESTARTS 5
11251static int ipw_up(struct ipw_priv *priv)
11252{
4f36f808 11253 int rc, i, j;
43f66a6c 11254
c3d72b96
DW		 11255 /* Age scan list entries found before suspend */
11256 if (priv->suspend_time) {
b0a4e7d8 11257 libipw_networks_age(priv->ieee, priv->suspend_time);
c3d72b96
DW		 11258 priv->suspend_time = 0;
11259 }
11260
43f66a6c
JK		 11261 if (priv->status & STATUS_EXIT_PENDING)
11262 return -EIO;
11263
f6c5cb7c 11264 if (cmdlog && !priv->cmdlog) {
e6e3f12a 11265 priv->cmdlog = kcalloc(cmdlog, sizeof(*priv->cmdlog),
f6c5cb7c
JK		 11266 GFP_KERNEL);
11267 if (priv->cmdlog == NULL) {
11268 IPW_ERROR("Error allocating %d command log entries.\n",
11269 cmdlog);
d0b526b7 11270 return -ENOMEM;
f6c5cb7c 11271 } else {
f6c5cb7c
JK		 11272 priv->cmdlog_len = cmdlog;
11273 }
11274 }
11275
0edd5b44 11276 for (i = 0; i < MAX_HW_RESTARTS; i++) {
bf79451e 11277 /* Load the microcode, firmware, and eeprom.
43f66a6c
JK		 11278 * Also start the clocks. */
11279 rc = ipw_load(priv);
11280 if (rc) {
a4f6bbb3 11281 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 11282 return rc;
11283 }
11284
11285 ipw_init_ordinals(priv);
11286 if (!(priv->config & CFG_CUSTOM_MAC))
11287 eeprom_parse_mac(priv, priv->mac_addr);
11288 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
5e5eab5d 11289 memcpy(priv->net_dev->perm_addr, priv->mac_addr, ETH_ALEN);
43f66a6c 11290
4f36f808
JK		 11291 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
11292 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11293 ipw_geos[j].name, 3))
11294 break;
11295 }
03520576
JK		 11296 if (j == ARRAY_SIZE(ipw_geos)) {
11297 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
11298 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
11299 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
11300 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
4f36f808 11301 j = 0;
03520576 11302 }
b0a4e7d8 11303 if (libipw_set_geo(priv->ieee, &ipw_geos[j])) {
4f36f808
JK		 11304 IPW_WARNING("Could not set geography.");
11305 return 0;
11306 }
11307
b095c381
JK		 11308 if (priv->status & STATUS_RF_KILL_SW) {
11309 IPW_WARNING("Radio disabled by module parameter.\n");
11310 return 0;
11311 } else if (rf_kill_active(priv)) {
11312 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
11313 "Kill switch must be turned off for "
11314 "wireless networking to work.\n");
bcb6d916 11315 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
43f66a6c 11316 return 0;
c848d0af 11317 }
43f66a6c
JK		 11318
11319 rc = ipw_config(priv);
11320 if (!rc) {
11321 IPW_DEBUG_INFO("Configured device on count %i\n", i);
e666619e
JK		 11322
11323 /* If configure to try and auto-associate, kick
11324 * off a scan. */
bcb6d916 11325 schedule_delayed_work(&priv->request_scan, 0);
afbf30a2 11326
43f66a6c 11327 return 0;
43f66a6c 11328 }
bf79451e 11329
c848d0af 11330 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
43f66a6c
JK		 11331 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
11332 i, MAX_HW_RESTARTS);
11333
11334 /* We had an error bringing up the hardware, so take it
11335 * all the way back down so we can try again */
11336 ipw_down(priv);
11337 }
11338
bf79451e 11339 /* tried to restart and config the device for as long as our
43f66a6c 11340 * patience could withstand */
0edd5b44 11341 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
c848d0af 11342
43f66a6c
JK		 11343 return -EIO;
11344}
11345
c4028958 11346static void ipw_bg_up(struct work_struct *work)
c848d0af 11347{
c4028958
DH		 11348 struct ipw_priv *priv =
11349 container_of(work, struct ipw_priv, up);
4644151b 11350 mutex_lock(&priv->mutex);
c4028958 11351 ipw_up(priv);
4644151b 11352 mutex_unlock(&priv->mutex);
c848d0af
JK		 11353}
11354
b095c381 11355static void ipw_deinit(struct ipw_priv *priv)
43f66a6c 11356{
b095c381
JK		 11357 int i;
11358
11359 if (priv->status & STATUS_SCANNING) {
11360 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
11361 ipw_abort_scan(priv);
11362 }
11363
11364 if (priv->status & STATUS_ASSOCIATED) {
11365 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
11366 ipw_disassociate(priv);
11367 }
11368
11369 ipw_led_shutdown(priv);
11370
11371 /* Wait up to 1s for status to change to not scanning and not
11372 * associated (disassociation can take a while for a ful 802.11
11373 * exchange */
11374 for (i = 1000; i && (priv->status &
11375 (STATUS_DISASSOCIATING |
11376 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11377 udelay(10);
11378
11379 if (priv->status & (STATUS_DISASSOCIATING |
11380 STATUS_ASSOCIATED | STATUS_SCANNING))
11381 IPW_DEBUG_INFO("Still associated or scanning...\n");
11382 else
11383 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11384
43f66a6c 11385 /* Attempt to disable the card */
43f66a6c 11386 ipw_send_card_disable(priv, 0);
b095c381
JK		 11387
11388 priv->status &= ~STATUS_INIT;
11389}
11390
11391static void ipw_down(struct ipw_priv *priv)
11392{
11393 int exit_pending = priv->status & STATUS_EXIT_PENDING;
11394
11395 priv->status |= STATUS_EXIT_PENDING;
11396
11397 if (ipw_is_init(priv))
11398 ipw_deinit(priv);
11399
11400 /* Wipe out the EXIT_PENDING status bit if we are not actually
11401 * exiting the module */
11402 if (!exit_pending)
11403 priv->status &= ~STATUS_EXIT_PENDING;
43f66a6c
JK		 11404
11405 /* tell the device to stop sending interrupts */
11406 ipw_disable_interrupts(priv);
11407
11408 /* Clear all bits but the RF Kill */
b095c381 11409 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
43f66a6c 11410 netif_carrier_off(priv->net_dev);
43f66a6c
JK		 11411
11412 ipw_stop_nic(priv);
a613bffd
JK		 11413
11414 ipw_led_radio_off(priv);
43f66a6c
JK		 11415}
11416
c4028958 11417static void ipw_bg_down(struct work_struct *work)
c848d0af 11418{
c4028958
DH		 11419 struct ipw_priv *priv =
11420 container_of(work, struct ipw_priv, down);
4644151b 11421 mutex_lock(&priv->mutex);
c4028958 11422 ipw_down(priv);
4644151b 11423 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11424}
11425
11426/* Called by register_netdev() */
11427static int ipw_net_init(struct net_device *dev)
11428{
a3caa99e 11429 int i, rc = 0;
b0a4e7d8 11430 struct ipw_priv *priv = libipw_priv(dev);
a3caa99e
JL		 11431 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
11432 struct wireless_dev *wdev = &priv->ieee->wdev;
4644151b 11433 mutex_lock(&priv->mutex);
43f66a6c 11434
c848d0af 11435 if (ipw_up(priv)) {
a3caa99e
JL		 11436 rc = -EIO;
11437 goto out;
b8ecd988
JL		 11438 }
11439
a3caa99e
JL		 11440 memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
11441
11442 /* fill-out priv->ieee->bg_band */
11443 if (geo->bg_channels) {
11444 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
11445
11446 bg_band->band = IEEE80211_BAND_2GHZ;
11447 bg_band->n_channels = geo->bg_channels;
baeb2ffa
JP		 11448 bg_band->channels = kcalloc(geo->bg_channels,
11449 sizeof(struct ieee80211_channel),
11450 GFP_KERNEL);
2ee4e27c
DC		 11451 if (!bg_band->channels) {
11452 rc = -ENOMEM;
11453 goto out;
11454 }
a3caa99e
JL		 11455 /* translate geo->bg to bg_band.channels */
11456 for (i = 0; i < geo->bg_channels; i++) {
11457 bg_band->channels[i].band = IEEE80211_BAND_2GHZ;
11458 bg_band->channels[i].center_freq = geo->bg[i].freq;
11459 bg_band->channels[i].hw_value = geo->bg[i].channel;
11460 bg_band->channels[i].max_power = geo->bg[i].max_power;
11461 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11462 bg_band->channels[i].flags |=
11463 IEEE80211_CHAN_PASSIVE_SCAN;
11464 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
11465 bg_band->channels[i].flags |=
11466 IEEE80211_CHAN_NO_IBSS;
11467 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
11468 bg_band->channels[i].flags |=
11469 IEEE80211_CHAN_RADAR;
11470 /* No equivalent for LIBIPW_CH_80211H_RULES,
11471 LIBIPW_CH_UNIFORM_SPREADING, or
11472 LIBIPW_CH_B_ONLY... */
11473 }
11474 /* point at bitrate info */
11475 bg_band->bitrates = ipw2200_bg_rates;
11476 bg_band->n_bitrates = ipw2200_num_bg_rates;
11477
11478 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = bg_band;
b8ecd988
JL		 11479 }
11480
a3caa99e
JL		 11481 /* fill-out priv->ieee->a_band */
11482 if (geo->a_channels) {
11483 struct ieee80211_supported_band *a_band = &priv->ieee->a_band;
11484
11485 a_band->band = IEEE80211_BAND_5GHZ;
11486 a_band->n_channels = geo->a_channels;
baeb2ffa
JP		 11487 a_band->channels = kcalloc(geo->a_channels,
11488 sizeof(struct ieee80211_channel),
11489 GFP_KERNEL);
2ee4e27c
DC		 11490 if (!a_band->channels) {
11491 rc = -ENOMEM;
11492 goto out;
11493 }
a3caa99e
JL		 11494 /* translate geo->bg to a_band.channels */
11495 for (i = 0; i < geo->a_channels; i++) {
11496 a_band->channels[i].band = IEEE80211_BAND_2GHZ;
11497 a_band->channels[i].center_freq = geo->a[i].freq;
11498 a_band->channels[i].hw_value = geo->a[i].channel;
11499 a_band->channels[i].max_power = geo->a[i].max_power;
11500 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11501 a_band->channels[i].flags |=
11502 IEEE80211_CHAN_PASSIVE_SCAN;
11503 if (geo->a[i].flags & LIBIPW_CH_NO_IBSS)
11504 a_band->channels[i].flags |=
11505 IEEE80211_CHAN_NO_IBSS;
11506 if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)
11507 a_band->channels[i].flags |=
11508 IEEE80211_CHAN_RADAR;
11509 /* No equivalent for LIBIPW_CH_80211H_RULES,
11510 LIBIPW_CH_UNIFORM_SPREADING, or
11511 LIBIPW_CH_B_ONLY... */
11512 }
11513 /* point at bitrate info */
11514 a_band->bitrates = ipw2200_a_rates;
11515 a_band->n_bitrates = ipw2200_num_a_rates;
11516
11517 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = a_band;
11518 }
11519
11520 set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
11521
11522 /* With that information in place, we can now register the wiphy... */
11523 if (wiphy_register(wdev->wiphy)) {
11524 rc = -EIO;
11525 goto out;
11526 }
11527
11528out:
4644151b 11529 mutex_unlock(&priv->mutex);
a3caa99e 11530 return rc;
43f66a6c
JK		 11531}
11532
11533/* PCI driver stuff */
a3aa1884 11534static DEFINE_PCI_DEVICE_TABLE(card_ids) = {
43f66a6c
JK		 11535 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
11536 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
11537 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
11538 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
11539 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
11540 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
11541 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
11542 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
11543 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
11544 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
11545 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
11546 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
11547 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
11548 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
11549 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
11550 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
11551 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
8ab0ea77
JP		 11552 {PCI_VDEVICE(INTEL, 0x104f), 0},
11553 {PCI_VDEVICE(INTEL, 0x4220), 0}, /* BG */
11554 {PCI_VDEVICE(INTEL, 0x4221), 0}, /* BG */
11555 {PCI_VDEVICE(INTEL, 0x4223), 0}, /* ABG */
11556 {PCI_VDEVICE(INTEL, 0x4224), 0}, /* ABG */
bf79451e 11557
43f66a6c
JK		 11558 /* required last entry */
11559 {0,}
11560};
11561
11562MODULE_DEVICE_TABLE(pci, card_ids);
11563
11564static struct attribute *ipw_sysfs_entries[] = {
11565 &dev_attr_rf_kill.attr,
11566 &dev_attr_direct_dword.attr,
11567 &dev_attr_indirect_byte.attr,
11568 &dev_attr_indirect_dword.attr,
11569 &dev_attr_mem_gpio_reg.attr,
11570 &dev_attr_command_event_reg.attr,
11571 &dev_attr_nic_type.attr,
11572 &dev_attr_status.attr,
11573 &dev_attr_cfg.attr,
b39860c6
JK		 11574 &dev_attr_error.attr,
11575 &dev_attr_event_log.attr,
f6c5cb7c 11576 &dev_attr_cmd_log.attr,
43f66a6c
JK		 11577 &dev_attr_eeprom_delay.attr,
11578 &dev_attr_ucode_version.attr,
11579 &dev_attr_rtc.attr,
a613bffd
JK		 11580 &dev_attr_scan_age.attr,
11581 &dev_attr_led.attr,
b095c381
JK		 11582 &dev_attr_speed_scan.attr,
11583 &dev_attr_net_stats.attr,
375dd244 11584 &dev_attr_channels.attr,
d685b8c2
ZY		 11585#ifdef CONFIG_IPW2200_PROMISCUOUS
11586 &dev_attr_rtap_iface.attr,
11587 &dev_attr_rtap_filter.attr,
11588#endif
43f66a6c
JK		 11589 NULL
11590};
11591
11592static struct attribute_group ipw_attribute_group = {
11593 .name = NULL, /* put in device directory */
0edd5b44 11594 .attrs = ipw_sysfs_entries,
43f66a6c
JK		 11595};
11596
d685b8c2
ZY		 11597#ifdef CONFIG_IPW2200_PROMISCUOUS
11598static int ipw_prom_open(struct net_device *dev)
11599{
b0a4e7d8 11600 struct ipw_prom_priv *prom_priv = libipw_priv(dev);
d685b8c2
ZY		 11601 struct ipw_priv *priv = prom_priv->priv;
11602
11603 IPW_DEBUG_INFO("prom dev->open\n");
11604 netif_carrier_off(dev);
d685b8c2
ZY		 11605
11606 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11607 priv->sys_config.accept_all_data_frames = 1;
11608 priv->sys_config.accept_non_directed_frames = 1;
11609 priv->sys_config.accept_all_mgmt_bcpr = 1;
11610 priv->sys_config.accept_all_mgmt_frames = 1;
11611
11612 ipw_send_system_config(priv);
11613 }
11614
11615 return 0;
11616}
11617
11618static int ipw_prom_stop(struct net_device *dev)
11619{
b0a4e7d8 11620 struct ipw_prom_priv *prom_priv = libipw_priv(dev);
d685b8c2
ZY		 11621 struct ipw_priv *priv = prom_priv->priv;
11622
11623 IPW_DEBUG_INFO("prom dev->stop\n");
11624
11625 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11626 priv->sys_config.accept_all_data_frames = 0;
11627 priv->sys_config.accept_non_directed_frames = 0;
11628 priv->sys_config.accept_all_mgmt_bcpr = 0;
11629 priv->sys_config.accept_all_mgmt_frames = 0;
11630
11631 ipw_send_system_config(priv);
11632 }
11633
11634 return 0;
11635}
11636
d0cf9c0d
SH		 11637static netdev_tx_t ipw_prom_hard_start_xmit(struct sk_buff *skb,
11638 struct net_device *dev)
d685b8c2
ZY		 11639{
11640 IPW_DEBUG_INFO("prom dev->xmit\n");
4153e775
PM		 11641 dev_kfree_skb(skb);
11642 return NETDEV_TX_OK;
d685b8c2
ZY		 11643}
11644
44e9ad0b
SH		 11645static const struct net_device_ops ipw_prom_netdev_ops = {
11646 .ndo_open = ipw_prom_open,
11647 .ndo_stop = ipw_prom_stop,
11648 .ndo_start_xmit = ipw_prom_hard_start_xmit,
b0a4e7d8 11649 .ndo_change_mtu = libipw_change_mtu,
44e9ad0b
SH		 11650 .ndo_set_mac_address = eth_mac_addr,
11651 .ndo_validate_addr = eth_validate_addr,
11652};
11653
d685b8c2
ZY		 11654static int ipw_prom_alloc(struct ipw_priv *priv)
11655{
11656 int rc = 0;
11657
11658 if (priv->prom_net_dev)
11659 return -EPERM;
11660
27ae60f8 11661 priv->prom_net_dev = alloc_libipw(sizeof(struct ipw_prom_priv), 1);
d685b8c2
ZY		 11662 if (priv->prom_net_dev == NULL)
11663 return -ENOMEM;
11664
b0a4e7d8 11665 priv->prom_priv = libipw_priv(priv->prom_net_dev);
d685b8c2
ZY		 11666 priv->prom_priv->ieee = netdev_priv(priv->prom_net_dev);
11667 priv->prom_priv->priv = priv;
11668
11669 strcpy(priv->prom_net_dev->name, "rtap%d");
3f2eeac9 11670 memcpy(priv->prom_net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
d685b8c2
ZY		 11671
11672 priv->prom_net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
44e9ad0b 11673 priv->prom_net_dev->netdev_ops = &ipw_prom_netdev_ops;
d685b8c2
ZY		 11674
11675 priv->prom_priv->ieee->iw_mode = IW_MODE_MONITOR;
229ce3ab 11676 SET_NETDEV_DEV(priv->prom_net_dev, &priv->pci_dev->dev);
d685b8c2
ZY		 11677
11678 rc = register_netdev(priv->prom_net_dev);
11679 if (rc) {
27ae60f8 11680 free_libipw(priv->prom_net_dev, 1);
d685b8c2
ZY		 11681 priv->prom_net_dev = NULL;
11682 return rc;
11683 }
11684
11685 return 0;
11686}
11687
11688static void ipw_prom_free(struct ipw_priv *priv)
11689{
11690 if (!priv->prom_net_dev)
11691 return;
11692
11693 unregister_netdev(priv->prom_net_dev);
27ae60f8 11694 free_libipw(priv->prom_net_dev, 1);
d685b8c2
ZY		 11695
11696 priv->prom_net_dev = NULL;
11697}
11698
11699#endif
11700
44e9ad0b
SH		 11701static const struct net_device_ops ipw_netdev_ops = {
11702 .ndo_init = ipw_net_init,
11703 .ndo_open = ipw_net_open,
11704 .ndo_stop = ipw_net_stop,
11705 .ndo_set_multicast_list = ipw_net_set_multicast_list,
11706 .ndo_set_mac_address = ipw_net_set_mac_address,
b0a4e7d8
JL		 11707 .ndo_start_xmit = libipw_xmit,
11708 .ndo_change_mtu = libipw_change_mtu,
44e9ad0b
SH		 11709 .ndo_validate_addr = eth_validate_addr,
11710};
d685b8c2 11711
2ef19e63
AB		 11712static int __devinit ipw_pci_probe(struct pci_dev *pdev,
11713 const struct pci_device_id *ent)
43f66a6c
JK		 11714{
11715 int err = 0;
11716 struct net_device *net_dev;
11717 void __iomem *base;
11718 u32 length, val;
11719 struct ipw_priv *priv;
afbf30a2 11720 int i;
43f66a6c 11721
27ae60f8 11722 net_dev = alloc_libipw(sizeof(struct ipw_priv), 0);
43f66a6c
JK		 11723 if (net_dev == NULL) {
11724 err = -ENOMEM;
11725 goto out;
11726 }
11727
b0a4e7d8 11728 priv = libipw_priv(net_dev);
43f66a6c 11729 priv->ieee = netdev_priv(net_dev);
a613bffd 11730
43f66a6c
JK		 11731 priv->net_dev = net_dev;
11732 priv->pci_dev = pdev;
43f66a6c 11733 ipw_debug_level = debug;
89c318ed 11734 spin_lock_init(&priv->irq_lock);
43f66a6c 11735 spin_lock_init(&priv->lock);
afbf30a2
JK		 11736 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11737 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
43f66a6c 11738
4644151b 11739 mutex_init(&priv->mutex);
43f66a6c
JK		 11740 if (pci_enable_device(pdev)) {
11741 err = -ENODEV;
27ae60f8 11742 goto out_free_libipw;
43f66a6c
JK		 11743 }
11744
11745 pci_set_master(pdev);
11746
284901a9 11747 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
bf79451e 11748 if (!err)
284901a9 11749 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
43f66a6c
JK		 11750 if (err) {
11751 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11752 goto out_pci_disable_device;
11753 }
11754
11755 pci_set_drvdata(pdev, priv);
11756
11757 err = pci_request_regions(pdev, DRV_NAME);
bf79451e 11758 if (err)
43f66a6c
JK		 11759 goto out_pci_disable_device;
11760
bf79451e 11761 /* We disable the RETRY_TIMEOUT register (0x41) to keep
43f66a6c 11762 * PCI Tx retries from interfering with C3 CPU state */
bf79451e
JG		 11763 pci_read_config_dword(pdev, 0x40, &val);
11764 if ((val & 0x0000ff00) != 0)
43f66a6c 11765 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
bf79451e 11766
43f66a6c
JK		 11767 length = pci_resource_len(pdev, 0);
11768 priv->hw_len = length;
bf79451e 11769
275f165f 11770 base = pci_ioremap_bar(pdev, 0);
43f66a6c
JK		 11771 if (!base) {
11772 err = -ENODEV;
11773 goto out_pci_release_regions;
11774 }
11775
11776 priv->hw_base = base;
11777 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11778 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11779
11780 err = ipw_setup_deferred_work(priv);
11781 if (err) {
11782 IPW_ERROR("Unable to setup deferred work\n");
11783 goto out_iounmap;
11784 }
11785
b095c381 11786 ipw_sw_reset(priv, 1);
43f66a6c 11787
1fb9df5d 11788 err = request_irq(pdev->irq, ipw_isr, IRQF_SHARED, DRV_NAME, priv);
43f66a6c
JK		 11789 if (err) {
11790 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
bcb6d916 11791 goto out_iounmap;
43f66a6c
JK		 11792 }
11793
43f66a6c
JK		 11794 SET_NETDEV_DEV(net_dev, &pdev->dev);
11795
4644151b 11796 mutex_lock(&priv->mutex);
c848d0af 11797
43f66a6c
JK		 11798 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11799 priv->ieee->set_security = shim__set_security;
227d2dc1 11800 priv->ieee->is_queue_full = ipw_net_is_queue_full;
43f66a6c 11801
e43e3c1e 11802#ifdef CONFIG_IPW2200_QOS
a5cf4fe6 11803 priv->ieee->is_qos_active = ipw_is_qos_active;
3b9990cb
JK		 11804 priv->ieee->handle_probe_response = ipw_handle_beacon;
11805 priv->ieee->handle_beacon = ipw_handle_probe_response;
11806 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
e43e3c1e 11807#endif /* CONFIG_IPW2200_QOS */
b095c381 11808
c848d0af
JK		 11809 priv->ieee->perfect_rssi = -20;
11810 priv->ieee->worst_rssi = -85;
43f66a6c 11811
44e9ad0b 11812 net_dev->netdev_ops = &ipw_netdev_ops;
97a78ca9 11813 priv->wireless_data.spy_data = &priv->ieee->spy_data;
97a78ca9 11814 net_dev->wireless_data = &priv->wireless_data;
43f66a6c
JK		 11815 net_dev->wireless_handlers = &ipw_wx_handler_def;
11816 net_dev->ethtool_ops = &ipw_ethtool_ops;
11817 net_dev->irq = pdev->irq;
0edd5b44 11818 net_dev->base_addr = (unsigned long)priv->hw_base;
43f66a6c
JK		 11819 net_dev->mem_start = pci_resource_start(pdev, 0);
11820 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11821
11822 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11823 if (err) {
11824 IPW_ERROR("failed to create sysfs device attributes\n");
4644151b 11825 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11826 goto out_release_irq;
11827 }
11828
4644151b 11829 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11830 err = register_netdev(net_dev);
11831 if (err) {
11832 IPW_ERROR("failed to register network device\n");
a613bffd 11833 goto out_remove_sysfs;
43f66a6c 11834 }
48a84770 11835
d685b8c2
ZY		 11836#ifdef CONFIG_IPW2200_PROMISCUOUS
11837 if (rtap_iface) {
11838 err = ipw_prom_alloc(priv);
11839 if (err) {
11840 IPW_ERROR("Failed to register promiscuous network "
11841 "device (error %d).\n", err);
11842 unregister_netdev(priv->net_dev);
11843 goto out_remove_sysfs;
11844 }
11845 }
11846#endif
11847
48a84770
HBA		 11848 printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
11849 "channels, %d 802.11a channels)\n",
11850 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
11851 priv->ieee->geo.a_channels);
11852
43f66a6c
JK		 11853 return 0;
11854
a613bffd 11855 out_remove_sysfs:
43f66a6c 11856 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
0edd5b44 11857 out_release_irq:
43f66a6c 11858 free_irq(pdev->irq, priv);
0edd5b44 11859 out_iounmap:
43f66a6c 11860 iounmap(priv->hw_base);
0edd5b44 11861 out_pci_release_regions:
43f66a6c 11862 pci_release_regions(pdev);
0edd5b44 11863 out_pci_disable_device:
43f66a6c
JK		 11864 pci_disable_device(pdev);
11865 pci_set_drvdata(pdev, NULL);
27ae60f8
PR		 11866 out_free_libipw:
11867 free_libipw(priv->net_dev, 0);
0edd5b44 11868 out:
43f66a6c
JK		 11869 return err;
11870}
11871
2ef19e63 11872static void __devexit ipw_pci_remove(struct pci_dev *pdev)
43f66a6c
JK		 11873{
11874 struct ipw_priv *priv = pci_get_drvdata(pdev);
afbf30a2
JK		 11875 struct list_head *p, *q;
11876 int i;
b095c381 11877
43f66a6c
JK		 11878 if (!priv)
11879 return;
11880
4644151b 11881 mutex_lock(&priv->mutex);
43f66a6c 11882
afbf30a2 11883 priv->status |= STATUS_EXIT_PENDING;
43f66a6c 11884 ipw_down(priv);
43f66a6c
JK		 11885 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11886
4644151b 11887 mutex_unlock(&priv->mutex);
43f66a6c
JK		 11888
11889 unregister_netdev(priv->net_dev);
11890
11891 if (priv->rxq) {
11892 ipw_rx_queue_free(priv, priv->rxq);
11893 priv->rxq = NULL;
11894 }
11895 ipw_tx_queue_free(priv);
11896
f6c5cb7c
JK		 11897 if (priv->cmdlog) {
11898 kfree(priv->cmdlog);
11899 priv->cmdlog = NULL;
11900 }
bcb6d916
TH		 11901
11902 /* make sure all works are inactive */
11903 cancel_delayed_work_sync(&priv->adhoc_check);
11904 cancel_work_sync(&priv->associate);
11905 cancel_work_sync(&priv->disassociate);
11906 cancel_work_sync(&priv->system_config);
11907 cancel_work_sync(&priv->rx_replenish);
11908 cancel_work_sync(&priv->adapter_restart);
11909 cancel_delayed_work_sync(&priv->rf_kill);
11910 cancel_work_sync(&priv->up);
11911 cancel_work_sync(&priv->down);
11912 cancel_delayed_work_sync(&priv->request_scan);
11913 cancel_delayed_work_sync(&priv->request_direct_scan);
11914 cancel_delayed_work_sync(&priv->request_passive_scan);
11915 cancel_delayed_work_sync(&priv->scan_event);
11916 cancel_delayed_work_sync(&priv->gather_stats);
11917 cancel_work_sync(&priv->abort_scan);
11918 cancel_work_sync(&priv->roam);
11919 cancel_delayed_work_sync(&priv->scan_check);
11920 cancel_work_sync(&priv->link_up);
11921 cancel_work_sync(&priv->link_down);
11922 cancel_delayed_work_sync(&priv->led_link_on);
11923 cancel_delayed_work_sync(&priv->led_link_off);
11924 cancel_delayed_work_sync(&priv->led_act_off);
11925 cancel_work_sync(&priv->merge_networks);
43f66a6c 11926
afbf30a2
JK		 11927 /* Free MAC hash list for ADHOC */
11928 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11929 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
afbf30a2 11930 list_del(p);
489f4458 11931 kfree(list_entry(p, struct ipw_ibss_seq, list));
afbf30a2
JK		 11932 }
11933 }
11934
8f760780
JJ		 11935 kfree(priv->error);
11936 priv->error = NULL;
43f66a6c 11937
d685b8c2
ZY		 11938#ifdef CONFIG_IPW2200_PROMISCUOUS
11939 ipw_prom_free(priv);
11940#endif
11941
43f66a6c
JK		 11942 free_irq(pdev->irq, priv);
11943 iounmap(priv->hw_base);
11944 pci_release_regions(pdev);
11945 pci_disable_device(pdev);
11946 pci_set_drvdata(pdev, NULL);
27ae60f8 11947 /* wiphy_unregister needs to be here, before free_libipw */
a3caa99e
JL		 11948 wiphy_unregister(priv->ieee->wdev.wiphy);
11949 kfree(priv->ieee->a_band.channels);
11950 kfree(priv->ieee->bg_band.channels);
27ae60f8 11951 free_libipw(priv->net_dev, 0);
afbf30a2 11952 free_firmware();
43f66a6c
JK		 11953}
11954
43f66a6c 11955#ifdef CONFIG_PM
583a4e88 11956static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
43f66a6c
JK		 11957{
11958 struct ipw_priv *priv = pci_get_drvdata(pdev);
11959 struct net_device *dev = priv->net_dev;
11960
11961 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11962
0edd5b44 11963 /* Take down the device; powers it off, etc. */
43f66a6c
JK		 11964 ipw_down(priv);
11965
11966 /* Remove the PRESENT state of the device */
11967 netif_device_detach(dev);
11968
43f66a6c 11969 pci_save_state(pdev);
43f66a6c 11970 pci_disable_device(pdev);
583a4e88 11971 pci_set_power_state(pdev, pci_choose_state(pdev, state));
bf79451e 11972
c3d72b96
DW		 11973 priv->suspend_at = get_seconds();
11974
43f66a6c
JK		 11975 return 0;
11976}
11977
11978static int ipw_pci_resume(struct pci_dev *pdev)
11979{
11980 struct ipw_priv *priv = pci_get_drvdata(pdev);
11981 struct net_device *dev = priv->net_dev;
02e0e5e9 11982 int err;
43f66a6c 11983 u32 val;
bf79451e 11984
43f66a6c
JK		 11985 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11986
ea2b26e0 11987 pci_set_power_state(pdev, PCI_D0);
02e0e5e9
JL		 11988 err = pci_enable_device(pdev);
11989 if (err) {
11990 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
11991 dev->name);
11992 return err;
11993 }
43f66a6c 11994 pci_restore_state(pdev);
ea2b26e0 11995
43f66a6c
JK		 11996 /*
11997 * Suspend/Resume resets the PCI configuration space, so we have to
11998 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11999 * from interfering with C3 CPU state. pci_restore_state won't help
12000 * here since it only restores the first 64 bytes pci config header.
12001 */
bf79451e
JG		 12002 pci_read_config_dword(pdev, 0x40, &val);
12003 if ((val & 0x0000ff00) != 0)
43f66a6c
JK		 12004 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
12005
12006 /* Set the device back into the PRESENT state; this will also wake
12007 * the queue of needed */
12008 netif_device_attach(dev);
12009
c3d72b96
DW		 12010 priv->suspend_time = get_seconds() - priv->suspend_at;
12011
43f66a6c 12012 /* Bring the device back up */
bcb6d916 12013 schedule_work(&priv->up);
bf79451e 12014
43f66a6c
JK		 12015 return 0;
12016}
12017#endif
12018
c8c22c94
ZY		 12019static void ipw_pci_shutdown(struct pci_dev *pdev)
12020{
12021 struct ipw_priv *priv = pci_get_drvdata(pdev);
12022
12023 /* Take down the device; powers it off, etc. */
12024 ipw_down(priv);
12025
12026 pci_disable_device(pdev);
12027}
12028
43f66a6c
JK		 12029/* driver initialization stuff */
12030static struct pci_driver ipw_driver = {
12031 .name = DRV_NAME,
12032 .id_table = card_ids,
12033 .probe = ipw_pci_probe,
12034 .remove = __devexit_p(ipw_pci_remove),
12035#ifdef CONFIG_PM
12036 .suspend = ipw_pci_suspend,
12037 .resume = ipw_pci_resume,
12038#endif
c8c22c94 12039 .shutdown = ipw_pci_shutdown,
43f66a6c
JK		 12040};
12041
12042static int __init ipw_init(void)
12043{
12044 int ret;
12045
12046 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
12047 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
12048
29917620 12049 ret = pci_register_driver(&ipw_driver);
43f66a6c
JK		 12050 if (ret) {
12051 IPW_ERROR("Unable to initialize PCI module\n");
12052 return ret;
12053 }
12054
0edd5b44 12055 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
43f66a6c
JK		 12056 if (ret) {
12057 IPW_ERROR("Unable to create driver sysfs file\n");
12058 pci_unregister_driver(&ipw_driver);
12059 return ret;
12060 }
12061
12062 return ret;
12063}
12064
12065static void __exit ipw_exit(void)
12066{
12067 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
12068 pci_unregister_driver(&ipw_driver);
12069}
12070
12071module_param(disable, int, 0444);
12072MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
12073
12074module_param(associate, int, 0444);
5c7f9b73 12075MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
43f66a6c
JK		 12076
12077module_param(auto_create, int, 0444);
12078MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
12079
21f8a73f 12080module_param_named(led, led_support, int, 0444);
c086abae 12081MODULE_PARM_DESC(led, "enable led control on some systems (default 1 on)");
a613bffd 12082
43f66a6c
JK		 12083module_param(debug, int, 0444);
12084MODULE_PARM_DESC(debug, "debug output mask");
12085
21f8a73f 12086module_param_named(channel, default_channel, int, 0444);
bf79451e 12087MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
43f66a6c 12088
d685b8c2
ZY		 12089#ifdef CONFIG_IPW2200_PROMISCUOUS
12090module_param(rtap_iface, int, 0444);
12091MODULE_PARM_DESC(rtap_iface, "create the rtap interface (1 - create, default 0)");
12092#endif
12093
e43e3c1e 12094#ifdef CONFIG_IPW2200_QOS
b095c381
JK		 12095module_param(qos_enable, int, 0444);
12096MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
12097
12098module_param(qos_burst_enable, int, 0444);
12099MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
12100
12101module_param(qos_no_ack_mask, int, 0444);
12102MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
43f66a6c 12103
b095c381
JK		 12104module_param(burst_duration_CCK, int, 0444);
12105MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
12106
12107module_param(burst_duration_OFDM, int, 0444);
12108MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
e43e3c1e 12109#endif /* CONFIG_IPW2200_QOS */
b095c381
JK		 12110
12111#ifdef CONFIG_IPW2200_MONITOR
21f8a73f 12112module_param_named(mode, network_mode, int, 0444);
43f66a6c
JK		 12113MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
12114#else
21f8a73f 12115module_param_named(mode, network_mode, int, 0444);
43f66a6c
JK		 12116MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
12117#endif
12118
810dabd4
ZY		 12119module_param(bt_coexist, int, 0444);
12120MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
12121
b095c381 12122module_param(hwcrypto, int, 0444);
bde37d03 12123MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
b095c381 12124
f6c5cb7c
JK		 12125module_param(cmdlog, int, 0444);
12126MODULE_PARM_DESC(cmdlog,
12127 "allocate a ring buffer for logging firmware commands");
12128
4bfdb91d
ZY		 12129module_param(roaming, int, 0444);
12130MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
12131
d2b83e12
ZY		 12132module_param(antenna, int, 0444);
12133MODULE_PARM_DESC(antenna, "select antenna 1=Main, 3=Aux, default 0 [both], 2=slow_diversity (choose the one with lower background noise)");
12134
43f66a6c
JK		 12135module_exit(ipw_exit);
12136module_init(ipw_init);
ubuntu-bionic-kernel mirror