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