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