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