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