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