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