?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'upstream-fixes'
[linux-2.6/libata-dev.git] / drivers / net / wireless / ipw2200.c
blob44024c76d1871a3bb6696227b2def267ac475231
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 && (network->wpa_ie_len > 0 ||
5537 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 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
7066 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7067
7068 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7069 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7070 priv->assoc_request.auth_type = AUTH_LEAP;
7071 else
7072 priv->assoc_request.auth_type = AUTH_OPEN;
7073
7074 if (priv->ieee->wpa_ie_len) {
7075 priv->assoc_request.policy_support = 0x02; /* RSN active */
7076 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7077 priv->ieee->wpa_ie_len);
7078 }
7079
7080 /*
7081 * It is valid for our ieee device to support multiple modes, but
7082 * when it comes to associating to a given network we have to choose
7083 * just one mode.
7084 */
7085 if (network->mode & priv->ieee->mode & IEEE_A)
7086 priv->assoc_request.ieee_mode = IPW_A_MODE;
7087 else if (network->mode & priv->ieee->mode & IEEE_G)
7088 priv->assoc_request.ieee_mode = IPW_G_MODE;
7089 else if (network->mode & priv->ieee->mode & IEEE_B)
7090 priv->assoc_request.ieee_mode = IPW_B_MODE;
7091
7092 priv->assoc_request.capability = network->capability;
7093 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7094 && !(priv->config & CFG_PREAMBLE_LONG)) {
7095 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7096 } else {
7097 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7098
7099 /* Clear the short preamble if we won't be supporting it */
7100 priv->assoc_request.capability &=
7101 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7102 }
7103
7104 /* Clear capability bits that aren't used in Ad Hoc */
7105 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7106 priv->assoc_request.capability &=
7107 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7108
7109 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7110 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7111 roaming ? "Rea" : "A",
7112 escape_essid(priv->essid, priv->essid_len),
7113 network->channel,
7114 ipw_modes[priv->assoc_request.ieee_mode],
7115 rates->num_rates,
7116 (priv->assoc_request.preamble_length ==
7117 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7118 network->capability &
7119 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7120 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7121 priv->capability & CAP_PRIVACY_ON ?
7122 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7123 "(open)") : "",
7124 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7125 priv->capability & CAP_PRIVACY_ON ?
7126 '1' + priv->ieee->sec.active_key : '.',
7127 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7128
7129 priv->assoc_request.beacon_interval = network->beacon_interval;
7130 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7131 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7132 priv->assoc_request.assoc_type = HC_IBSS_START;
7133 priv->assoc_request.assoc_tsf_msw = 0;
7134 priv->assoc_request.assoc_tsf_lsw = 0;
7135 } else {
7136 if (unlikely(roaming))
7137 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7138 else
7139 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7140 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7141 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7142 }
7143
7144 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7145
7146 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7147 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7148 priv->assoc_request.atim_window = network->atim_window;
7149 } else {
7150 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7151 priv->assoc_request.atim_window = 0;
7152 }
7153
7154 priv->assoc_request.listen_interval = network->listen_interval;
7155
7156 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7157 if (err) {
7158 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7159 return err;
7160 }
7161
7162 rates->ieee_mode = priv->assoc_request.ieee_mode;
7163 rates->purpose = IPW_RATE_CONNECT;
7164 ipw_send_supported_rates(priv, rates);
7165
7166 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7167 priv->sys_config.dot11g_auto_detection = 1;
7168 else
7169 priv->sys_config.dot11g_auto_detection = 0;
7170
7171 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7172 priv->sys_config.answer_broadcast_ssid_probe = 1;
7173 else
7174 priv->sys_config.answer_broadcast_ssid_probe = 0;
7175
7176 err = ipw_send_system_config(priv, &priv->sys_config);
7177 if (err) {
7178 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7179 return err;
7180 }
7181
7182 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7183 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7184 if (err) {
7185 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7186 return err;
7187 }
7188
7189 /*
7190 * If preemption is enabled, it is possible for the association
7191 * to complete before we return from ipw_send_associate. Therefore
7192 * we have to be sure and update our priviate data first.
7193 */
7194 priv->channel = network->channel;
7195 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7196 priv->status |= STATUS_ASSOCIATING;
7197 priv->status &= ~STATUS_SECURITY_UPDATED;
7198
7199 priv->assoc_network = network;
7200
7201 #ifdef CONFIG_IPW_QOS
7202 ipw_qos_association(priv, network);
7203 #endif
7204
7205 err = ipw_send_associate(priv, &priv->assoc_request);
7206 if (err) {
7207 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7208 return err;
7209 }
7210
7211 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7212 escape_essid(priv->essid, priv->essid_len),
7213 MAC_ARG(priv->bssid));
7214
7215 return 0;
7216 }
7217
7218 static void ipw_roam(void *data)
7219 {
7220 struct ipw_priv *priv = data;
7221 struct ieee80211_network *network = NULL;
7222 struct ipw_network_match match = {
7223 .network = priv->assoc_network
7224 };
7225
7226 /* The roaming process is as follows:
7227 *
7228 * 1. Missed beacon threshold triggers the roaming process by
7229 * setting the status ROAM bit and requesting a scan.
7230 * 2. When the scan completes, it schedules the ROAM work
7231 * 3. The ROAM work looks at all of the known networks for one that
7232 * is a better network than the currently associated. If none
7233 * found, the ROAM process is over (ROAM bit cleared)
7234 * 4. If a better network is found, a disassociation request is
7235 * sent.
7236 * 5. When the disassociation completes, the roam work is again
7237 * scheduled. The second time through, the driver is no longer
7238 * associated, and the newly selected network is sent an
7239 * association request.
7240 * 6. At this point ,the roaming process is complete and the ROAM
7241 * status bit is cleared.
7242 */
7243
7244 /* If we are no longer associated, and the roaming bit is no longer
7245 * set, then we are not actively roaming, so just return */
7246 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7247 return;
7248
7249 if (priv->status & STATUS_ASSOCIATED) {
7250 /* First pass through ROAM process -- look for a better
7251 * network */
7252 unsigned long flags;
7253 u8 rssi = priv->assoc_network->stats.rssi;
7254 priv->assoc_network->stats.rssi = -128;
7255 spin_lock_irqsave(&priv->ieee->lock, flags);
7256 list_for_each_entry(network, &priv->ieee->network_list, list) {
7257 if (network != priv->assoc_network)
7258 ipw_best_network(priv, &match, network, 1);
7259 }
7260 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7261 priv->assoc_network->stats.rssi = rssi;
7262
7263 if (match.network == priv->assoc_network) {
7264 IPW_DEBUG_ASSOC("No better APs in this network to "
7265 "roam to.\n");
7266 priv->status &= ~STATUS_ROAMING;
7267 ipw_debug_config(priv);
7268 return;
7269 }
7270
7271 ipw_send_disassociate(priv, 1);
7272 priv->assoc_network = match.network;
7273
7274 return;
7275 }
7276
7277 /* Second pass through ROAM process -- request association */
7278 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7279 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7280 priv->status &= ~STATUS_ROAMING;
7281 }
7282
7283 static void ipw_bg_roam(void *data)
7284 {
7285 struct ipw_priv *priv = data;
7286 mutex_lock(&priv->mutex);
7287 ipw_roam(data);
7288 mutex_unlock(&priv->mutex);
7289 }
7290
7291 static int ipw_associate(void *data)
7292 {
7293 struct ipw_priv *priv = data;
7294
7295 struct ieee80211_network *network = NULL;
7296 struct ipw_network_match match = {
7297 .network = NULL
7298 };
7299 struct ipw_supported_rates *rates;
7300 struct list_head *element;
7301 unsigned long flags;
7302
7303 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7304 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7305 return 0;
7306 }
7307
7308 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7309 IPW_DEBUG_ASSOC("Not attempting association (already in "
7310 "progress)\n");
7311 return 0;
7312 }
7313
7314 if (priv->status & STATUS_DISASSOCIATING) {
7315 IPW_DEBUG_ASSOC("Not attempting association (in "
7316 "disassociating)\n ");
7317 queue_work(priv->workqueue, &priv->associate);
7318 return 0;
7319 }
7320
7321 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7322 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7323 "initialized)\n");
7324 return 0;
7325 }
7326
7327 if (!(priv->config & CFG_ASSOCIATE) &&
7328 !(priv->config & (CFG_STATIC_ESSID |
7329 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7330 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7331 return 0;
7332 }
7333
7334 /* Protect our use of the network_list */
7335 spin_lock_irqsave(&priv->ieee->lock, flags);
7336 list_for_each_entry(network, &priv->ieee->network_list, list)
7337 ipw_best_network(priv, &match, network, 0);
7338
7339 network = match.network;
7340 rates = &match.rates;
7341
7342 if (network == NULL &&
7343 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7344 priv->config & CFG_ADHOC_CREATE &&
7345 priv->config & CFG_STATIC_ESSID &&
7346 priv->config & CFG_STATIC_CHANNEL &&
7347 !list_empty(&priv->ieee->network_free_list)) {
7348 element = priv->ieee->network_free_list.next;
7349 network = list_entry(element, struct ieee80211_network, list);
7350 ipw_adhoc_create(priv, network);
7351 rates = &priv->rates;
7352 list_del(element);
7353 list_add_tail(&network->list, &priv->ieee->network_list);
7354 }
7355 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7356
7357 /* If we reached the end of the list, then we don't have any valid
7358 * matching APs */
7359 if (!network) {
7360 ipw_debug_config(priv);
7361
7362 if (!(priv->status & STATUS_SCANNING)) {
7363 if (!(priv->config & CFG_SPEED_SCAN))
7364 queue_delayed_work(priv->workqueue,
7365 &priv->request_scan,
7366 SCAN_INTERVAL);
7367 else
7368 queue_work(priv->workqueue,
7369 &priv->request_scan);
7370 }
7371
7372 return 0;
7373 }
7374
7375 ipw_associate_network(priv, network, rates, 0);
7376
7377 return 1;
7378 }
7379
7380 static void ipw_bg_associate(void *data)
7381 {
7382 struct ipw_priv *priv = data;
7383 mutex_lock(&priv->mutex);
7384 ipw_associate(data);
7385 mutex_unlock(&priv->mutex);
7386 }
7387
7388 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7389 struct sk_buff *skb)
7390 {
7391 struct ieee80211_hdr *hdr;
7392 u16 fc;
7393
7394 hdr = (struct ieee80211_hdr *)skb->data;
7395 fc = le16_to_cpu(hdr->frame_ctl);
7396 if (!(fc & IEEE80211_FCTL_PROTECTED))
7397 return;
7398
7399 fc &= ~IEEE80211_FCTL_PROTECTED;
7400 hdr->frame_ctl = cpu_to_le16(fc);
7401 switch (priv->ieee->sec.level) {
7402 case SEC_LEVEL_3:
7403 /* Remove CCMP HDR */
7404 memmove(skb->data + IEEE80211_3ADDR_LEN,
7405 skb->data + IEEE80211_3ADDR_LEN + 8,
7406 skb->len - IEEE80211_3ADDR_LEN - 8);
7407 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7408 break;
7409 case SEC_LEVEL_2:
7410 break;
7411 case SEC_LEVEL_1:
7412 /* Remove IV */
7413 memmove(skb->data + IEEE80211_3ADDR_LEN,
7414 skb->data + IEEE80211_3ADDR_LEN + 4,
7415 skb->len - IEEE80211_3ADDR_LEN - 4);
7416 skb_trim(skb, skb->len - 8); /* IV + ICV */
7417 break;
7418 case SEC_LEVEL_0:
7419 break;
7420 default:
7421 printk(KERN_ERR "Unknow security level %d\n",
7422 priv->ieee->sec.level);
7423 break;
7424 }
7425 }
7426
7427 static void ipw_handle_data_packet(struct ipw_priv *priv,
7428 struct ipw_rx_mem_buffer *rxb,
7429 struct ieee80211_rx_stats *stats)
7430 {
7431 struct ieee80211_hdr_4addr *hdr;
7432 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7433
7434 /* We received data from the HW, so stop the watchdog */
7435 priv->net_dev->trans_start = jiffies;
7436
7437 /* We only process data packets if the
7438 * interface is open */
7439 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7440 skb_tailroom(rxb->skb))) {
7441 priv->ieee->stats.rx_errors++;
7442 priv->wstats.discard.misc++;
7443 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7444 return;
7445 } else if (unlikely(!netif_running(priv->net_dev))) {
7446 priv->ieee->stats.rx_dropped++;
7447 priv->wstats.discard.misc++;
7448 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7449 return;
7450 }
7451
7452 /* Advance skb->data to the start of the actual payload */
7453 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7454
7455 /* Set the size of the skb to the size of the frame */
7456 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7457
7458 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7459
7460 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7461 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7462 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7463 (is_multicast_ether_addr(hdr->addr1) ?
7464 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7465 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7466
7467 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7468 priv->ieee->stats.rx_errors++;
7469 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7470 rxb->skb = NULL;
7471 __ipw_led_activity_on(priv);
7472 }
7473 }
7474
7475 #ifdef CONFIG_IEEE80211_RADIOTAP
7476 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7477 struct ipw_rx_mem_buffer *rxb,
7478 struct ieee80211_rx_stats *stats)
7479 {
7480 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7481 struct ipw_rx_frame *frame = &pkt->u.frame;
7482
7483 /* initial pull of some data */
7484 u16 received_channel = frame->received_channel;
7485 u8 antennaAndPhy = frame->antennaAndPhy;
7486 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7487 u16 pktrate = frame->rate;
7488
7489 /* Magic struct that slots into the radiotap header -- no reason
7490 * to build this manually element by element, we can write it much
7491 * more efficiently than we can parse it. ORDER MATTERS HERE */
7492 struct ipw_rt_hdr {
7493 struct ieee80211_radiotap_header rt_hdr;
7494 u8 rt_flags; /* radiotap packet flags */
7495 u8 rt_rate; /* rate in 500kb/s */
7496 u16 rt_channel; /* channel in mhz */
7497 u16 rt_chbitmask; /* channel bitfield */
7498 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7499 u8 rt_antenna; /* antenna number */
7500 } *ipw_rt;
7501
7502 short len = le16_to_cpu(pkt->u.frame.length);
7503
7504 /* We received data from the HW, so stop the watchdog */
7505 priv->net_dev->trans_start = jiffies;
7506
7507 /* We only process data packets if the
7508 * interface is open */
7509 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7510 skb_tailroom(rxb->skb))) {
7511 priv->ieee->stats.rx_errors++;
7512 priv->wstats.discard.misc++;
7513 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7514 return;
7515 } else if (unlikely(!netif_running(priv->net_dev))) {
7516 priv->ieee->stats.rx_dropped++;
7517 priv->wstats.discard.misc++;
7518 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7519 return;
7520 }
7521
7522 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7523 * that now */
7524 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7525 /* FIXME: Should alloc bigger skb instead */
7526 priv->ieee->stats.rx_dropped++;
7527 priv->wstats.discard.misc++;
7528 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7529 return;
7530 }
7531
7532 /* copy the frame itself */
7533 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7534 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7535
7536 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7537 * part of our real header, saves a little time.
7538 *
7539 * No longer necessary since we fill in all our data. Purge before merging
7540 * patch officially.
7541 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7542 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7543 */
7544
7545 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7546
7547 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7548 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7549 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7550
7551 /* Big bitfield of all the fields we provide in radiotap */
7552 ipw_rt->rt_hdr.it_present =
7553 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7554 (1 << IEEE80211_RADIOTAP_RATE) |
7555 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7556 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7557 (1 << IEEE80211_RADIOTAP_ANTENNA));
7558
7559 /* Zero the flags, we'll add to them as we go */
7560 ipw_rt->rt_flags = 0;
7561
7562 /* Convert signal to DBM */
7563 ipw_rt->rt_dbmsignal = antsignal;
7564
7565 /* Convert the channel data and set the flags */
7566 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7567 if (received_channel > 14) { /* 802.11a */
7568 ipw_rt->rt_chbitmask =
7569 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7570 } else if (antennaAndPhy & 32) { /* 802.11b */
7571 ipw_rt->rt_chbitmask =
7572 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7573 } else { /* 802.11g */
7574 ipw_rt->rt_chbitmask =
7575 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7576 }
7577
7578 /* set the rate in multiples of 500k/s */
7579 switch (pktrate) {
7580 case IPW_TX_RATE_1MB:
7581 ipw_rt->rt_rate = 2;
7582 break;
7583 case IPW_TX_RATE_2MB:
7584 ipw_rt->rt_rate = 4;
7585 break;
7586 case IPW_TX_RATE_5MB:
7587 ipw_rt->rt_rate = 10;
7588 break;
7589 case IPW_TX_RATE_6MB:
7590 ipw_rt->rt_rate = 12;
7591 break;
7592 case IPW_TX_RATE_9MB:
7593 ipw_rt->rt_rate = 18;
7594 break;
7595 case IPW_TX_RATE_11MB:
7596 ipw_rt->rt_rate = 22;
7597 break;
7598 case IPW_TX_RATE_12MB:
7599 ipw_rt->rt_rate = 24;
7600 break;
7601 case IPW_TX_RATE_18MB:
7602 ipw_rt->rt_rate = 36;
7603 break;
7604 case IPW_TX_RATE_24MB:
7605 ipw_rt->rt_rate = 48;
7606 break;
7607 case IPW_TX_RATE_36MB:
7608 ipw_rt->rt_rate = 72;
7609 break;
7610 case IPW_TX_RATE_48MB:
7611 ipw_rt->rt_rate = 96;
7612 break;
7613 case IPW_TX_RATE_54MB:
7614 ipw_rt->rt_rate = 108;
7615 break;
7616 default:
7617 ipw_rt->rt_rate = 0;
7618 break;
7619 }
7620
7621 /* antenna number */
7622 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7623
7624 /* set the preamble flag if we have it */
7625 if ((antennaAndPhy & 64))
7626 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7627
7628 /* Set the size of the skb to the size of the frame */
7629 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7630
7631 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7632
7633 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7634 priv->ieee->stats.rx_errors++;
7635 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7636 rxb->skb = NULL;
7637 /* no LED during capture */
7638 }
7639 }
7640 #endif
7641
7642 static int is_network_packet(struct ipw_priv *priv,
7643 struct ieee80211_hdr_4addr *header)
7644 {
7645 /* Filter incoming packets to determine if they are targetted toward
7646 * this network, discarding packets coming from ourselves */
7647 switch (priv->ieee->iw_mode) {
7648 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
7649 /* packets from our adapter are dropped (echo) */
7650 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7651 return 0;
7652
7653 /* {broad,multi}cast packets to our BSSID go through */
7654 if (is_multicast_ether_addr(header->addr1))
7655 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
7656
7657 /* packets to our adapter go through */
7658 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7659 ETH_ALEN);
7660
7661 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
7662 /* packets from our adapter are dropped (echo) */
7663 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7664 return 0;
7665
7666 /* {broad,multi}cast packets to our BSS go through */
7667 if (is_multicast_ether_addr(header->addr1))
7668 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7669
7670 /* packets to our adapter go through */
7671 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7672 ETH_ALEN);
7673 }
7674
7675 return 1;
7676 }
7677
7678 #define IPW_PACKET_RETRY_TIME HZ
7679
7680 static int is_duplicate_packet(struct ipw_priv *priv,
7681 struct ieee80211_hdr_4addr *header)
7682 {
7683 u16 sc = le16_to_cpu(header->seq_ctl);
7684 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7685 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7686 u16 *last_seq, *last_frag;
7687 unsigned long *last_time;
7688
7689 switch (priv->ieee->iw_mode) {
7690 case IW_MODE_ADHOC:
7691 {
7692 struct list_head *p;
7693 struct ipw_ibss_seq *entry = NULL;
7694 u8 *mac = header->addr2;
7695 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7696
7697 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7698 entry =
7699 list_entry(p, struct ipw_ibss_seq, list);
7700 if (!memcmp(entry->mac, mac, ETH_ALEN))
7701 break;
7702 }
7703 if (p == &priv->ibss_mac_hash[index]) {
7704 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7705 if (!entry) {
7706 IPW_ERROR
7707 ("Cannot malloc new mac entry\n");
7708 return 0;
7709 }
7710 memcpy(entry->mac, mac, ETH_ALEN);
7711 entry->seq_num = seq;
7712 entry->frag_num = frag;
7713 entry->packet_time = jiffies;
7714 list_add(&entry->list,
7715 &priv->ibss_mac_hash[index]);
7716 return 0;
7717 }
7718 last_seq = &entry->seq_num;
7719 last_frag = &entry->frag_num;
7720 last_time = &entry->packet_time;
7721 break;
7722 }
7723 case IW_MODE_INFRA:
7724 last_seq = &priv->last_seq_num;
7725 last_frag = &priv->last_frag_num;
7726 last_time = &priv->last_packet_time;
7727 break;
7728 default:
7729 return 0;
7730 }
7731 if ((*last_seq == seq) &&
7732 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7733 if (*last_frag == frag)
7734 goto drop;
7735 if (*last_frag + 1 != frag)
7736 /* out-of-order fragment */
7737 goto drop;
7738 } else
7739 *last_seq = seq;
7740
7741 *last_frag = frag;
7742 *last_time = jiffies;
7743 return 0;
7744
7745 drop:
7746 /* Comment this line now since we observed the card receives
7747 * duplicate packets but the FCTL_RETRY bit is not set in the
7748 * IBSS mode with fragmentation enabled.
7749 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
7750 return 1;
7751 }
7752
7753 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7754 struct ipw_rx_mem_buffer *rxb,
7755 struct ieee80211_rx_stats *stats)
7756 {
7757 struct sk_buff *skb = rxb->skb;
7758 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7759 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7760 (skb->data + IPW_RX_FRAME_SIZE);
7761
7762 ieee80211_rx_mgt(priv->ieee, header, stats);
7763
7764 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7765 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7766 IEEE80211_STYPE_PROBE_RESP) ||
7767 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7768 IEEE80211_STYPE_BEACON))) {
7769 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7770 ipw_add_station(priv, header->addr2);
7771 }
7772
7773 if (priv->config & CFG_NET_STATS) {
7774 IPW_DEBUG_HC("sending stat packet\n");
7775
7776 /* Set the size of the skb to the size of the full
7777 * ipw header and 802.11 frame */
7778 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7779 IPW_RX_FRAME_SIZE);
7780
7781 /* Advance past the ipw packet header to the 802.11 frame */
7782 skb_pull(skb, IPW_RX_FRAME_SIZE);
7783
7784 /* Push the ieee80211_rx_stats before the 802.11 frame */
7785 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7786
7787 skb->dev = priv->ieee->dev;
7788
7789 /* Point raw at the ieee80211_stats */
7790 skb->mac.raw = skb->data;
7791
7792 skb->pkt_type = PACKET_OTHERHOST;
7793 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7794 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7795 netif_rx(skb);
7796 rxb->skb = NULL;
7797 }
7798 }
7799
7800 /*
7801 * Main entry function for recieving a packet with 80211 headers. This
7802 * should be called when ever the FW has notified us that there is a new
7803 * skb in the recieve queue.
7804 */
7805 static void ipw_rx(struct ipw_priv *priv)
7806 {
7807 struct ipw_rx_mem_buffer *rxb;
7808 struct ipw_rx_packet *pkt;
7809 struct ieee80211_hdr_4addr *header;
7810 u32 r, w, i;
7811 u8 network_packet;
7812
7813 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7814 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
7815 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7816
7817 while (i != r) {
7818 rxb = priv->rxq->queue[i];
7819 #ifdef CONFIG_IPW2200_DEBUG
7820 if (unlikely(rxb == NULL)) {
7821 printk(KERN_CRIT "Queue not allocated!\n");
7822 break;
7823 }
7824 #endif
7825 priv->rxq->queue[i] = NULL;
7826
7827 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
7828 IPW_RX_BUF_SIZE,
7829 PCI_DMA_FROMDEVICE);
7830
7831 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7832 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7833 pkt->header.message_type,
7834 pkt->header.rx_seq_num, pkt->header.control_bits);
7835
7836 switch (pkt->header.message_type) {
7837 case RX_FRAME_TYPE: /* 802.11 frame */ {
7838 struct ieee80211_rx_stats stats = {
7839 .rssi =
7840 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7841 IPW_RSSI_TO_DBM,
7842 .signal =
7843 le16_to_cpu(pkt->u.frame.signal),
7844 .noise =
7845 le16_to_cpu(pkt->u.frame.noise),
7846 .rate = pkt->u.frame.rate,
7847 .mac_time = jiffies,
7848 .received_channel =
7849 pkt->u.frame.received_channel,
7850 .freq =
7851 (pkt->u.frame.
7852 control & (1 << 0)) ?
7853 IEEE80211_24GHZ_BAND :
7854 IEEE80211_52GHZ_BAND,
7855 .len = le16_to_cpu(pkt->u.frame.length),
7856 };
7857
7858 if (stats.rssi != 0)
7859 stats.mask |= IEEE80211_STATMASK_RSSI;
7860 if (stats.signal != 0)
7861 stats.mask |= IEEE80211_STATMASK_SIGNAL;
7862 if (stats.noise != 0)
7863 stats.mask |= IEEE80211_STATMASK_NOISE;
7864 if (stats.rate != 0)
7865 stats.mask |= IEEE80211_STATMASK_RATE;
7866
7867 priv->rx_packets++;
7868
7869 #ifdef CONFIG_IPW2200_MONITOR
7870 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7871 #ifdef CONFIG_IEEE80211_RADIOTAP
7872 ipw_handle_data_packet_monitor(priv,
7873 rxb,
7874 &stats);
7875 #else
7876 ipw_handle_data_packet(priv, rxb,
7877 &stats);
7878 #endif
7879 break;
7880 }
7881 #endif
7882
7883 header =
7884 (struct ieee80211_hdr_4addr *)(rxb->skb->
7885 data +
7886 IPW_RX_FRAME_SIZE);
7887 /* TODO: Check Ad-Hoc dest/source and make sure
7888 * that we are actually parsing these packets
7889 * correctly -- we should probably use the
7890 * frame control of the packet and disregard
7891 * the current iw_mode */
7892
7893 network_packet =
7894 is_network_packet(priv, header);
7895 if (network_packet && priv->assoc_network) {
7896 priv->assoc_network->stats.rssi =
7897 stats.rssi;
7898 average_add(&priv->average_rssi,
7899 stats.rssi);
7900 priv->last_rx_rssi = stats.rssi;
7901 }
7902
7903 IPW_DEBUG_RX("Frame: len=%u\n",
7904 le16_to_cpu(pkt->u.frame.length));
7905
7906 if (le16_to_cpu(pkt->u.frame.length) <
7907 frame_hdr_len(header)) {
7908 IPW_DEBUG_DROP
7909 ("Received packet is too small. "
7910 "Dropping.\n");
7911 priv->ieee->stats.rx_errors++;
7912 priv->wstats.discard.misc++;
7913 break;
7914 }
7915
7916 switch (WLAN_FC_GET_TYPE
7917 (le16_to_cpu(header->frame_ctl))) {
7918
7919 case IEEE80211_FTYPE_MGMT:
7920 ipw_handle_mgmt_packet(priv, rxb,
7921 &stats);
7922 break;
7923
7924 case IEEE80211_FTYPE_CTL:
7925 break;
7926
7927 case IEEE80211_FTYPE_DATA:
7928 if (unlikely(!network_packet ||
7929 is_duplicate_packet(priv,
7930 header)))
7931 {
7932 IPW_DEBUG_DROP("Dropping: "
7933 MAC_FMT ", "
7934 MAC_FMT ", "
7935 MAC_FMT "\n",
7936 MAC_ARG(header->
7937 addr1),
7938 MAC_ARG(header->
7939 addr2),
7940 MAC_ARG(header->
7941 addr3));
7942 break;
7943 }
7944
7945 ipw_handle_data_packet(priv, rxb,
7946 &stats);
7947
7948 break;
7949 }
7950 break;
7951 }
7952
7953 case RX_HOST_NOTIFICATION_TYPE:{
7954 IPW_DEBUG_RX
7955 ("Notification: subtype=%02X flags=%02X size=%d\n",
7956 pkt->u.notification.subtype,
7957 pkt->u.notification.flags,
7958 pkt->u.notification.size);
7959 ipw_rx_notification(priv, &pkt->u.notification);
7960 break;
7961 }
7962
7963 default:
7964 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7965 pkt->header.message_type);
7966 break;
7967 }
7968
7969 /* For now we just don't re-use anything. We can tweak this
7970 * later to try and re-use notification packets and SKBs that
7971 * fail to Rx correctly */
7972 if (rxb->skb != NULL) {
7973 dev_kfree_skb_any(rxb->skb);
7974 rxb->skb = NULL;
7975 }
7976
7977 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
7978 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
7979 list_add_tail(&rxb->list, &priv->rxq->rx_used);
7980
7981 i = (i + 1) % RX_QUEUE_SIZE;
7982 }
7983
7984 /* Backtrack one entry */
7985 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7986
7987 ipw_rx_queue_restock(priv);
7988 }
7989
7990 #define DEFAULT_RTS_THRESHOLD 2304U
7991 #define MIN_RTS_THRESHOLD 1U
7992 #define MAX_RTS_THRESHOLD 2304U
7993 #define DEFAULT_BEACON_INTERVAL 100U
7994 #define DEFAULT_SHORT_RETRY_LIMIT 7U
7995 #define DEFAULT_LONG_RETRY_LIMIT 4U
7996
7997 static int ipw_sw_reset(struct ipw_priv *priv, int init)
7998 {
7999 int band, modulation;
8000 int old_mode = priv->ieee->iw_mode;
8001
8002 /* Initialize module parameter values here */
8003 priv->config = 0;
8004
8005 /* We default to disabling the LED code as right now it causes
8006 * too many systems to lock up... */
8007 if (!led)
8008 priv->config |= CFG_NO_LED;
8009
8010 if (associate)
8011 priv->config |= CFG_ASSOCIATE;
8012 else
8013 IPW_DEBUG_INFO("Auto associate disabled.\n");
8014
8015 if (auto_create)
8016 priv->config |= CFG_ADHOC_CREATE;
8017 else
8018 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8019
8020 priv->config &= ~CFG_STATIC_ESSID;
8021 priv->essid_len = 0;
8022 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8023
8024 if (disable) {
8025 priv->status |= STATUS_RF_KILL_SW;
8026 IPW_DEBUG_INFO("Radio disabled.\n");
8027 }
8028
8029 if (channel != 0) {
8030 priv->config |= CFG_STATIC_CHANNEL;
8031 priv->channel = channel;
8032 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8033 /* TODO: Validate that provided channel is in range */
8034 }
8035 #ifdef CONFIG_IPW_QOS
8036 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8037 burst_duration_CCK, burst_duration_OFDM);
8038 #endif /* CONFIG_IPW_QOS */
8039
8040 switch (mode) {
8041 case 1:
8042 priv->ieee->iw_mode = IW_MODE_ADHOC;
8043 priv->net_dev->type = ARPHRD_ETHER;
8044
8045 break;
8046 #ifdef CONFIG_IPW2200_MONITOR
8047 case 2:
8048 priv->ieee->iw_mode = IW_MODE_MONITOR;
8049 #ifdef CONFIG_IEEE80211_RADIOTAP
8050 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8051 #else
8052 priv->net_dev->type = ARPHRD_IEEE80211;
8053 #endif
8054 break;
8055 #endif
8056 default:
8057 case 0:
8058 priv->net_dev->type = ARPHRD_ETHER;
8059 priv->ieee->iw_mode = IW_MODE_INFRA;
8060 break;
8061 }
8062
8063 if (hwcrypto) {
8064 priv->ieee->host_encrypt = 0;
8065 priv->ieee->host_encrypt_msdu = 0;
8066 priv->ieee->host_decrypt = 0;
8067 priv->ieee->host_mc_decrypt = 0;
8068 }
8069 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8070
8071 /* IPW2200/2915 is abled to do hardware fragmentation. */
8072 priv->ieee->host_open_frag = 0;
8073
8074 if ((priv->pci_dev->device == 0x4223) ||
8075 (priv->pci_dev->device == 0x4224)) {
8076 if (init)
8077 printk(KERN_INFO DRV_NAME
8078 ": Detected Intel PRO/Wireless 2915ABG Network "
8079 "Connection\n");
8080 priv->ieee->abg_true = 1;
8081 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8082 modulation = IEEE80211_OFDM_MODULATION |
8083 IEEE80211_CCK_MODULATION;
8084 priv->adapter = IPW_2915ABG;
8085 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8086 } else {
8087 if (init)
8088 printk(KERN_INFO DRV_NAME
8089 ": Detected Intel PRO/Wireless 2200BG Network "
8090 "Connection\n");
8091
8092 priv->ieee->abg_true = 0;
8093 band = IEEE80211_24GHZ_BAND;
8094 modulation = IEEE80211_OFDM_MODULATION |
8095 IEEE80211_CCK_MODULATION;
8096 priv->adapter = IPW_2200BG;
8097 priv->ieee->mode = IEEE_G | IEEE_B;
8098 }
8099
8100 priv->ieee->freq_band = band;
8101 priv->ieee->modulation = modulation;
8102
8103 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8104
8105 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8106 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8107
8108 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8109 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8110 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8111
8112 /* If power management is turned on, default to AC mode */
8113 priv->power_mode = IPW_POWER_AC;
8114 priv->tx_power = IPW_TX_POWER_DEFAULT;
8115
8116 return old_mode == priv->ieee->iw_mode;
8117 }
8118
8119 /*
8120 * This file defines the Wireless Extension handlers. It does not
8121 * define any methods of hardware manipulation and relies on the
8122 * functions defined in ipw_main to provide the HW interaction.
8123 *
8124 * The exception to this is the use of the ipw_get_ordinal()
8125 * function used to poll the hardware vs. making unecessary calls.
8126 *
8127 */
8128
8129 static int ipw_wx_get_name(struct net_device *dev,
8130 struct iw_request_info *info,
8131 union iwreq_data *wrqu, char *extra)
8132 {
8133 struct ipw_priv *priv = ieee80211_priv(dev);
8134 mutex_lock(&priv->mutex);
8135 if (priv->status & STATUS_RF_KILL_MASK)
8136 strcpy(wrqu->name, "radio off");
8137 else if (!(priv->status & STATUS_ASSOCIATED))
8138 strcpy(wrqu->name, "unassociated");
8139 else
8140 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8141 ipw_modes[priv->assoc_request.ieee_mode]);
8142 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8143 mutex_unlock(&priv->mutex);
8144 return 0;
8145 }
8146
8147 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8148 {
8149 if (channel == 0) {
8150 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8151 priv->config &= ~CFG_STATIC_CHANNEL;
8152 IPW_DEBUG_ASSOC("Attempting to associate with new "
8153 "parameters.\n");
8154 ipw_associate(priv);
8155 return 0;
8156 }
8157
8158 priv->config |= CFG_STATIC_CHANNEL;
8159
8160 if (priv->channel == channel) {
8161 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8162 channel);
8163 return 0;
8164 }
8165
8166 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8167 priv->channel = channel;
8168
8169 #ifdef CONFIG_IPW2200_MONITOR
8170 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8171 int i;
8172 if (priv->status & STATUS_SCANNING) {
8173 IPW_DEBUG_SCAN("Scan abort triggered due to "
8174 "channel change.\n");
8175 ipw_abort_scan(priv);
8176 }
8177
8178 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8179 udelay(10);
8180
8181 if (priv->status & STATUS_SCANNING)
8182 IPW_DEBUG_SCAN("Still scanning...\n");
8183 else
8184 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8185 1000 - i);
8186
8187 return 0;
8188 }
8189 #endif /* CONFIG_IPW2200_MONITOR */
8190
8191 /* Network configuration changed -- force [re]association */
8192 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8193 if (!ipw_disassociate(priv))
8194 ipw_associate(priv);
8195
8196 return 0;
8197 }
8198
8199 static int ipw_wx_set_freq(struct net_device *dev,
8200 struct iw_request_info *info,
8201 union iwreq_data *wrqu, char *extra)
8202 {
8203 struct ipw_priv *priv = ieee80211_priv(dev);
8204 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8205 struct iw_freq *fwrq = &wrqu->freq;
8206 int ret = 0, i;
8207 u8 channel, flags;
8208 int band;
8209
8210 if (fwrq->m == 0) {
8211 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8212 mutex_lock(&priv->mutex);
8213 ret = ipw_set_channel(priv, 0);
8214 mutex_unlock(&priv->mutex);
8215 return ret;
8216 }
8217 /* if setting by freq convert to channel */
8218 if (fwrq->e == 1) {
8219 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
8220 if (channel == 0)
8221 return -EINVAL;
8222 } else
8223 channel = fwrq->m;
8224
8225 if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8226 return -EINVAL;
8227
8228 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8229 i = ipw_channel_to_index(priv->ieee, channel);
8230 if (i == -1)
8231 return -EINVAL;
8232
8233 flags = (band == IEEE80211_24GHZ_BAND) ?
8234 geo->bg[i].flags : geo->a[i].flags;
8235 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8236 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8237 return -EINVAL;
8238 }
8239 }
8240
8241 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8242 mutex_lock(&priv->mutex);
8243 ret = ipw_set_channel(priv, channel);
8244 mutex_unlock(&priv->mutex);
8245 return ret;
8246 }
8247
8248 static int ipw_wx_get_freq(struct net_device *dev,
8249 struct iw_request_info *info,
8250 union iwreq_data *wrqu, char *extra)
8251 {
8252 struct ipw_priv *priv = ieee80211_priv(dev);
8253
8254 wrqu->freq.e = 0;
8255
8256 /* If we are associated, trying to associate, or have a statically
8257 * configured CHANNEL then return that; otherwise return ANY */
8258 mutex_lock(&priv->mutex);
8259 if (priv->config & CFG_STATIC_CHANNEL ||
8260 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8261 wrqu->freq.m = priv->channel;
8262 else
8263 wrqu->freq.m = 0;
8264
8265 mutex_unlock(&priv->mutex);
8266 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8267 return 0;
8268 }
8269
8270 static int ipw_wx_set_mode(struct net_device *dev,
8271 struct iw_request_info *info,
8272 union iwreq_data *wrqu, char *extra)
8273 {
8274 struct ipw_priv *priv = ieee80211_priv(dev);
8275 int err = 0;
8276
8277 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8278
8279 switch (wrqu->mode) {
8280 #ifdef CONFIG_IPW2200_MONITOR
8281 case IW_MODE_MONITOR:
8282 #endif
8283 case IW_MODE_ADHOC:
8284 case IW_MODE_INFRA:
8285 break;
8286 case IW_MODE_AUTO:
8287 wrqu->mode = IW_MODE_INFRA;
8288 break;
8289 default:
8290 return -EINVAL;
8291 }
8292 if (wrqu->mode == priv->ieee->iw_mode)
8293 return 0;
8294
8295 mutex_lock(&priv->mutex);
8296
8297 ipw_sw_reset(priv, 0);
8298
8299 #ifdef CONFIG_IPW2200_MONITOR
8300 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8301 priv->net_dev->type = ARPHRD_ETHER;
8302
8303 if (wrqu->mode == IW_MODE_MONITOR)
8304 #ifdef CONFIG_IEEE80211_RADIOTAP
8305 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8306 #else
8307 priv->net_dev->type = ARPHRD_IEEE80211;
8308 #endif
8309 #endif /* CONFIG_IPW2200_MONITOR */
8310
8311 /* Free the existing firmware and reset the fw_loaded
8312 * flag so ipw_load() will bring in the new firmawre */
8313 free_firmware();
8314
8315 priv->ieee->iw_mode = wrqu->mode;
8316
8317 queue_work(priv->workqueue, &priv->adapter_restart);
8318 mutex_unlock(&priv->mutex);
8319 return err;
8320 }
8321
8322 static int ipw_wx_get_mode(struct net_device *dev,
8323 struct iw_request_info *info,
8324 union iwreq_data *wrqu, char *extra)
8325 {
8326 struct ipw_priv *priv = ieee80211_priv(dev);
8327 mutex_lock(&priv->mutex);
8328 wrqu->mode = priv->ieee->iw_mode;
8329 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8330 mutex_unlock(&priv->mutex);
8331 return 0;
8332 }
8333
8334 /* Values are in microsecond */
8335 static const s32 timeout_duration[] = {
8336 350000,
8337 250000,
8338 75000,
8339 37000,
8340 25000,
8341 };
8342
8343 static const s32 period_duration[] = {
8344 400000,
8345 700000,
8346 1000000,
8347 1000000,
8348 1000000
8349 };
8350
8351 static int ipw_wx_get_range(struct net_device *dev,
8352 struct iw_request_info *info,
8353 union iwreq_data *wrqu, char *extra)
8354 {
8355 struct ipw_priv *priv = ieee80211_priv(dev);
8356 struct iw_range *range = (struct iw_range *)extra;
8357 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8358 int i = 0, j;
8359
8360 wrqu->data.length = sizeof(*range);
8361 memset(range, 0, sizeof(*range));
8362
8363 /* 54Mbs == ~27 Mb/s real (802.11g) */
8364 range->throughput = 27 * 1000 * 1000;
8365
8366 range->max_qual.qual = 100;
8367 /* TODO: Find real max RSSI and stick here */
8368 range->max_qual.level = 0;
8369 range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
8370 range->max_qual.updated = 7; /* Updated all three */
8371
8372 range->avg_qual.qual = 70;
8373 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8374 range->avg_qual.level = 0; /* FIXME to real average level */
8375 range->avg_qual.noise = 0;
8376 range->avg_qual.updated = 7; /* Updated all three */
8377 mutex_lock(&priv->mutex);
8378 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8379
8380 for (i = 0; i < range->num_bitrates; i++)
8381 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8382 500000;
8383
8384 range->max_rts = DEFAULT_RTS_THRESHOLD;
8385 range->min_frag = MIN_FRAG_THRESHOLD;
8386 range->max_frag = MAX_FRAG_THRESHOLD;
8387
8388 range->encoding_size[0] = 5;
8389 range->encoding_size[1] = 13;
8390 range->num_encoding_sizes = 2;
8391 range->max_encoding_tokens = WEP_KEYS;
8392
8393 /* Set the Wireless Extension versions */
8394 range->we_version_compiled = WIRELESS_EXT;
8395 range->we_version_source = 18;
8396
8397 i = 0;
8398 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8399 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8400 i++, j++) {
8401 range->freq[i].i = geo->bg[j].channel;
8402 range->freq[i].m = geo->bg[j].freq * 100000;
8403 range->freq[i].e = 1;
8404 }
8405 }
8406
8407 if (priv->ieee->mode & IEEE_A) {
8408 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8409 i++, j++) {
8410 range->freq[i].i = geo->a[j].channel;
8411 range->freq[i].m = geo->a[j].freq * 100000;
8412 range->freq[i].e = 1;
8413 }
8414 }
8415
8416 range->num_channels = i;
8417 range->num_frequency = i;
8418
8419 mutex_unlock(&priv->mutex);
8420
8421 /* Event capability (kernel + driver) */
8422 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8423 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8424 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8425 range->event_capa[1] = IW_EVENT_CAPA_K_1;
8426
8427 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8428 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8429
8430 IPW_DEBUG_WX("GET Range\n");
8431 return 0;
8432 }
8433
8434 static int ipw_wx_set_wap(struct net_device *dev,
8435 struct iw_request_info *info,
8436 union iwreq_data *wrqu, char *extra)
8437 {
8438 struct ipw_priv *priv = ieee80211_priv(dev);
8439
8440 static const unsigned char any[] = {
8441 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8442 };
8443 static const unsigned char off[] = {
8444 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8445 };
8446
8447 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8448 return -EINVAL;
8449 mutex_lock(&priv->mutex);
8450 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8451 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8452 /* we disable mandatory BSSID association */
8453 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8454 priv->config &= ~CFG_STATIC_BSSID;
8455 IPW_DEBUG_ASSOC("Attempting to associate with new "
8456 "parameters.\n");
8457 ipw_associate(priv);
8458 mutex_unlock(&priv->mutex);
8459 return 0;
8460 }
8461
8462 priv->config |= CFG_STATIC_BSSID;
8463 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8464 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8465 mutex_unlock(&priv->mutex);
8466 return 0;
8467 }
8468
8469 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8470 MAC_ARG(wrqu->ap_addr.sa_data));
8471
8472 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8473
8474 /* Network configuration changed -- force [re]association */
8475 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8476 if (!ipw_disassociate(priv))
8477 ipw_associate(priv);
8478
8479 mutex_unlock(&priv->mutex);
8480 return 0;
8481 }
8482
8483 static int ipw_wx_get_wap(struct net_device *dev,
8484 struct iw_request_info *info,
8485 union iwreq_data *wrqu, char *extra)
8486 {
8487 struct ipw_priv *priv = ieee80211_priv(dev);
8488 /* If we are associated, trying to associate, or have a statically
8489 * configured BSSID then return that; otherwise return ANY */
8490 mutex_lock(&priv->mutex);
8491 if (priv->config & CFG_STATIC_BSSID ||
8492 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8493 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8494 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8495 } else
8496 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8497
8498 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8499 MAC_ARG(wrqu->ap_addr.sa_data));
8500 mutex_unlock(&priv->mutex);
8501 return 0;
8502 }
8503
8504 static int ipw_wx_set_essid(struct net_device *dev,
8505 struct iw_request_info *info,
8506 union iwreq_data *wrqu, char *extra)
8507 {
8508 struct ipw_priv *priv = ieee80211_priv(dev);
8509 char *essid = ""; /* ANY */
8510 int length = 0;
8511 mutex_lock(&priv->mutex);
8512 if (wrqu->essid.flags && wrqu->essid.length) {
8513 length = wrqu->essid.length - 1;
8514 essid = extra;
8515 }
8516 if (length == 0) {
8517 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8518 if ((priv->config & CFG_STATIC_ESSID) &&
8519 !(priv->status & (STATUS_ASSOCIATED |
8520 STATUS_ASSOCIATING))) {
8521 IPW_DEBUG_ASSOC("Attempting to associate with new "
8522 "parameters.\n");
8523 priv->config &= ~CFG_STATIC_ESSID;
8524 ipw_associate(priv);
8525 }
8526 mutex_unlock(&priv->mutex);
8527 return 0;
8528 }
8529
8530 length = min(length, IW_ESSID_MAX_SIZE);
8531
8532 priv->config |= CFG_STATIC_ESSID;
8533
8534 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8535 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8536 mutex_unlock(&priv->mutex);
8537 return 0;
8538 }
8539
8540 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8541 length);
8542
8543 priv->essid_len = length;
8544 memcpy(priv->essid, essid, priv->essid_len);
8545
8546 /* Network configuration changed -- force [re]association */
8547 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8548 if (!ipw_disassociate(priv))
8549 ipw_associate(priv);
8550
8551 mutex_unlock(&priv->mutex);
8552 return 0;
8553 }
8554
8555 static int ipw_wx_get_essid(struct net_device *dev,
8556 struct iw_request_info *info,
8557 union iwreq_data *wrqu, char *extra)
8558 {
8559 struct ipw_priv *priv = ieee80211_priv(dev);
8560
8561 /* If we are associated, trying to associate, or have a statically
8562 * configured ESSID then return that; otherwise return ANY */
8563 mutex_lock(&priv->mutex);
8564 if (priv->config & CFG_STATIC_ESSID ||
8565 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8566 IPW_DEBUG_WX("Getting essid: '%s'\n",
8567 escape_essid(priv->essid, priv->essid_len));
8568 memcpy(extra, priv->essid, priv->essid_len);
8569 wrqu->essid.length = priv->essid_len;
8570 wrqu->essid.flags = 1; /* active */
8571 } else {
8572 IPW_DEBUG_WX("Getting essid: ANY\n");
8573 wrqu->essid.length = 0;
8574 wrqu->essid.flags = 0; /* active */
8575 }
8576 mutex_unlock(&priv->mutex);
8577 return 0;
8578 }
8579
8580 static int ipw_wx_set_nick(struct net_device *dev,
8581 struct iw_request_info *info,
8582 union iwreq_data *wrqu, char *extra)
8583 {
8584 struct ipw_priv *priv = ieee80211_priv(dev);
8585
8586 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8587 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8588 return -E2BIG;
8589 mutex_lock(&priv->mutex);
8590 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
8591 memset(priv->nick, 0, sizeof(priv->nick));
8592 memcpy(priv->nick, extra, wrqu->data.length);
8593 IPW_DEBUG_TRACE("<<\n");
8594 mutex_unlock(&priv->mutex);
8595 return 0;
8596
8597 }
8598
8599 static int ipw_wx_get_nick(struct net_device *dev,
8600 struct iw_request_info *info,
8601 union iwreq_data *wrqu, char *extra)
8602 {
8603 struct ipw_priv *priv = ieee80211_priv(dev);
8604 IPW_DEBUG_WX("Getting nick\n");
8605 mutex_lock(&priv->mutex);
8606 wrqu->data.length = strlen(priv->nick) + 1;
8607 memcpy(extra, priv->nick, wrqu->data.length);
8608 wrqu->data.flags = 1; /* active */
8609 mutex_unlock(&priv->mutex);
8610 return 0;
8611 }
8612
8613 static int ipw_wx_set_rate(struct net_device *dev,
8614 struct iw_request_info *info,
8615 union iwreq_data *wrqu, char *extra)
8616 {
8617 /* TODO: We should use semaphores or locks for access to priv */
8618 struct ipw_priv *priv = ieee80211_priv(dev);
8619 u32 target_rate = wrqu->bitrate.value;
8620 u32 fixed, mask;
8621
8622 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8623 /* value = X, fixed = 1 means only rate X */
8624 /* value = X, fixed = 0 means all rates lower equal X */
8625
8626 if (target_rate == -1) {
8627 fixed = 0;
8628 mask = IEEE80211_DEFAULT_RATES_MASK;
8629 /* Now we should reassociate */
8630 goto apply;
8631 }
8632
8633 mask = 0;
8634 fixed = wrqu->bitrate.fixed;
8635
8636 if (target_rate == 1000000 || !fixed)
8637 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8638 if (target_rate == 1000000)
8639 goto apply;
8640
8641 if (target_rate == 2000000 || !fixed)
8642 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8643 if (target_rate == 2000000)
8644 goto apply;
8645
8646 if (target_rate == 5500000 || !fixed)
8647 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8648 if (target_rate == 5500000)
8649 goto apply;
8650
8651 if (target_rate == 6000000 || !fixed)
8652 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8653 if (target_rate == 6000000)
8654 goto apply;
8655
8656 if (target_rate == 9000000 || !fixed)
8657 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8658 if (target_rate == 9000000)
8659 goto apply;
8660
8661 if (target_rate == 11000000 || !fixed)
8662 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8663 if (target_rate == 11000000)
8664 goto apply;
8665
8666 if (target_rate == 12000000 || !fixed)
8667 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8668 if (target_rate == 12000000)
8669 goto apply;
8670
8671 if (target_rate == 18000000 || !fixed)
8672 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8673 if (target_rate == 18000000)
8674 goto apply;
8675
8676 if (target_rate == 24000000 || !fixed)
8677 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8678 if (target_rate == 24000000)
8679 goto apply;
8680
8681 if (target_rate == 36000000 || !fixed)
8682 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8683 if (target_rate == 36000000)
8684 goto apply;
8685
8686 if (target_rate == 48000000 || !fixed)
8687 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8688 if (target_rate == 48000000)
8689 goto apply;
8690
8691 if (target_rate == 54000000 || !fixed)
8692 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8693 if (target_rate == 54000000)
8694 goto apply;
8695
8696 IPW_DEBUG_WX("invalid rate specified, returning error\n");
8697 return -EINVAL;
8698
8699 apply:
8700 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8701 mask, fixed ? "fixed" : "sub-rates");
8702 mutex_lock(&priv->mutex);
8703 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
8704 priv->config &= ~CFG_FIXED_RATE;
8705 ipw_set_fixed_rate(priv, priv->ieee->mode);
8706 } else
8707 priv->config |= CFG_FIXED_RATE;
8708
8709 if (priv->rates_mask == mask) {
8710 IPW_DEBUG_WX("Mask set to current mask.\n");
8711 mutex_unlock(&priv->mutex);
8712 return 0;
8713 }
8714
8715 priv->rates_mask = mask;
8716
8717 /* Network configuration changed -- force [re]association */
8718 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8719 if (!ipw_disassociate(priv))
8720 ipw_associate(priv);
8721
8722 mutex_unlock(&priv->mutex);
8723 return 0;
8724 }
8725
8726 static int ipw_wx_get_rate(struct net_device *dev,
8727 struct iw_request_info *info,
8728 union iwreq_data *wrqu, char *extra)
8729 {
8730 struct ipw_priv *priv = ieee80211_priv(dev);
8731 mutex_lock(&priv->mutex);
8732 wrqu->bitrate.value = priv->last_rate;
8733 mutex_unlock(&priv->mutex);
8734 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8735 return 0;
8736 }
8737
8738 static int ipw_wx_set_rts(struct net_device *dev,
8739 struct iw_request_info *info,
8740 union iwreq_data *wrqu, char *extra)
8741 {
8742 struct ipw_priv *priv = ieee80211_priv(dev);
8743 mutex_lock(&priv->mutex);
8744 if (wrqu->rts.disabled)
8745 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8746 else {
8747 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
8748 wrqu->rts.value > MAX_RTS_THRESHOLD) {
8749 mutex_unlock(&priv->mutex);
8750 return -EINVAL;
8751 }
8752 priv->rts_threshold = wrqu->rts.value;
8753 }
8754
8755 ipw_send_rts_threshold(priv, priv->rts_threshold);
8756 mutex_unlock(&priv->mutex);
8757 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8758 return 0;
8759 }
8760
8761 static int ipw_wx_get_rts(struct net_device *dev,
8762 struct iw_request_info *info,
8763 union iwreq_data *wrqu, char *extra)
8764 {
8765 struct ipw_priv *priv = ieee80211_priv(dev);
8766 mutex_lock(&priv->mutex);
8767 wrqu->rts.value = priv->rts_threshold;
8768 wrqu->rts.fixed = 0; /* no auto select */
8769 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
8770 mutex_unlock(&priv->mutex);
8771 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8772 return 0;
8773 }
8774
8775 static int ipw_wx_set_txpow(struct net_device *dev,
8776 struct iw_request_info *info,
8777 union iwreq_data *wrqu, char *extra)
8778 {
8779 struct ipw_priv *priv = ieee80211_priv(dev);
8780 int err = 0;
8781
8782 mutex_lock(&priv->mutex);
8783 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
8784 err = -EINPROGRESS;
8785 goto out;
8786 }
8787
8788 if (!wrqu->power.fixed)
8789 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8790
8791 if (wrqu->power.flags != IW_TXPOW_DBM) {
8792 err = -EINVAL;
8793 goto out;
8794 }
8795
8796 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
8797 (wrqu->power.value < IPW_TX_POWER_MIN)) {
8798 err = -EINVAL;
8799 goto out;
8800 }
8801
8802 priv->tx_power = wrqu->power.value;
8803 err = ipw_set_tx_power(priv);
8804 out:
8805 mutex_unlock(&priv->mutex);
8806 return err;
8807 }
8808
8809 static int ipw_wx_get_txpow(struct net_device *dev,
8810 struct iw_request_info *info,
8811 union iwreq_data *wrqu, char *extra)
8812 {
8813 struct ipw_priv *priv = ieee80211_priv(dev);
8814 mutex_lock(&priv->mutex);
8815 wrqu->power.value = priv->tx_power;
8816 wrqu->power.fixed = 1;
8817 wrqu->power.flags = IW_TXPOW_DBM;
8818 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
8819 mutex_unlock(&priv->mutex);
8820
8821 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
8822 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
8823
8824 return 0;
8825 }
8826
8827 static int ipw_wx_set_frag(struct net_device *dev,
8828 struct iw_request_info *info,
8829 union iwreq_data *wrqu, char *extra)
8830 {
8831 struct ipw_priv *priv = ieee80211_priv(dev);
8832 mutex_lock(&priv->mutex);
8833 if (wrqu->frag.disabled)
8834 priv->ieee->fts = DEFAULT_FTS;
8835 else {
8836 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
8837 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8838 mutex_unlock(&priv->mutex);
8839 return -EINVAL;
8840 }
8841
8842 priv->ieee->fts = wrqu->frag.value & ~0x1;
8843 }
8844
8845 ipw_send_frag_threshold(priv, wrqu->frag.value);
8846 mutex_unlock(&priv->mutex);
8847 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8848 return 0;
8849 }
8850
8851 static int ipw_wx_get_frag(struct net_device *dev,
8852 struct iw_request_info *info,
8853 union iwreq_data *wrqu, char *extra)
8854 {
8855 struct ipw_priv *priv = ieee80211_priv(dev);
8856 mutex_lock(&priv->mutex);
8857 wrqu->frag.value = priv->ieee->fts;
8858 wrqu->frag.fixed = 0; /* no auto select */
8859 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
8860 mutex_unlock(&priv->mutex);
8861 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8862
8863 return 0;
8864 }
8865
8866 static int ipw_wx_set_retry(struct net_device *dev,
8867 struct iw_request_info *info,
8868 union iwreq_data *wrqu, char *extra)
8869 {
8870 struct ipw_priv *priv = ieee80211_priv(dev);
8871
8872 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8873 return -EINVAL;
8874
8875 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8876 return 0;
8877
8878 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8879 return -EINVAL;
8880
8881 mutex_lock(&priv->mutex);
8882 if (wrqu->retry.flags & IW_RETRY_MIN)
8883 priv->short_retry_limit = (u8) wrqu->retry.value;
8884 else if (wrqu->retry.flags & IW_RETRY_MAX)
8885 priv->long_retry_limit = (u8) wrqu->retry.value;
8886 else {
8887 priv->short_retry_limit = (u8) wrqu->retry.value;
8888 priv->long_retry_limit = (u8) wrqu->retry.value;
8889 }
8890
8891 ipw_send_retry_limit(priv, priv->short_retry_limit,
8892 priv->long_retry_limit);
8893 mutex_unlock(&priv->mutex);
8894 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8895 priv->short_retry_limit, priv->long_retry_limit);
8896 return 0;
8897 }
8898
8899 static int ipw_wx_get_retry(struct net_device *dev,
8900 struct iw_request_info *info,
8901 union iwreq_data *wrqu, char *extra)
8902 {
8903 struct ipw_priv *priv = ieee80211_priv(dev);
8904
8905 mutex_lock(&priv->mutex);
8906 wrqu->retry.disabled = 0;
8907
8908 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
8909 mutex_unlock(&priv->mutex);
8910 return -EINVAL;
8911 }
8912
8913 if (wrqu->retry.flags & IW_RETRY_MAX) {
8914 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8915 wrqu->retry.value = priv->long_retry_limit;
8916 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8917 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8918 wrqu->retry.value = priv->short_retry_limit;
8919 } else {
8920 wrqu->retry.flags = IW_RETRY_LIMIT;
8921 wrqu->retry.value = priv->short_retry_limit;
8922 }
8923 mutex_unlock(&priv->mutex);
8924
8925 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8926
8927 return 0;
8928 }
8929
8930 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8931 int essid_len)
8932 {
8933 struct ipw_scan_request_ext scan;
8934 int err = 0, scan_type;
8935
8936 if (!(priv->status & STATUS_INIT) ||
8937 (priv->status & STATUS_EXIT_PENDING))
8938 return 0;
8939
8940 mutex_lock(&priv->mutex);
8941
8942 if (priv->status & STATUS_RF_KILL_MASK) {
8943 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8944 priv->status |= STATUS_SCAN_PENDING;
8945 goto done;
8946 }
8947
8948 IPW_DEBUG_HC("starting request direct scan!\n");
8949
8950 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
8951 /* We should not sleep here; otherwise we will block most
8952 * of the system (for instance, we hold rtnl_lock when we
8953 * get here).
8954 */
8955 err = -EAGAIN;
8956 goto done;
8957 }
8958 memset(&scan, 0, sizeof(scan));
8959
8960 if (priv->config & CFG_SPEED_SCAN)
8961 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8962 cpu_to_le16(30);
8963 else
8964 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8965 cpu_to_le16(20);
8966
8967 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8968 cpu_to_le16(20);
8969 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8970 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8971
8972 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8973
8974 err = ipw_send_ssid(priv, essid, essid_len);
8975 if (err) {
8976 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8977 goto done;
8978 }
8979 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8980
8981 ipw_add_scan_channels(priv, &scan, scan_type);
8982
8983 err = ipw_send_scan_request_ext(priv, &scan);
8984 if (err) {
8985 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8986 goto done;
8987 }
8988
8989 priv->status |= STATUS_SCANNING;
8990
8991 done:
8992 mutex_unlock(&priv->mutex);
8993 return err;
8994 }
8995
8996 static int ipw_wx_set_scan(struct net_device *dev,
8997 struct iw_request_info *info,
8998 union iwreq_data *wrqu, char *extra)
8999 {
9000 struct ipw_priv *priv = ieee80211_priv(dev);
9001 struct iw_scan_req *req = NULL;
9002 if (wrqu->data.length
9003 && wrqu->data.length == sizeof(struct iw_scan_req)) {
9004 req = (struct iw_scan_req *)extra;
9005 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9006 ipw_request_direct_scan(priv, req->essid,
9007 req->essid_len);
9008 return 0;
9009 }
9010 }
9011
9012 IPW_DEBUG_WX("Start scan\n");
9013
9014 queue_work(priv->workqueue, &priv->request_scan);
9015
9016 return 0;
9017 }
9018
9019 static int ipw_wx_get_scan(struct net_device *dev,
9020 struct iw_request_info *info,
9021 union iwreq_data *wrqu, char *extra)
9022 {
9023 struct ipw_priv *priv = ieee80211_priv(dev);
9024 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9025 }
9026
9027 static int ipw_wx_set_encode(struct net_device *dev,
9028 struct iw_request_info *info,
9029 union iwreq_data *wrqu, char *key)
9030 {
9031 struct ipw_priv *priv = ieee80211_priv(dev);
9032 int ret;
9033 u32 cap = priv->capability;
9034
9035 mutex_lock(&priv->mutex);
9036 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9037
9038 /* In IBSS mode, we need to notify the firmware to update
9039 * the beacon info after we changed the capability. */
9040 if (cap != priv->capability &&
9041 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9042 priv->status & STATUS_ASSOCIATED)
9043 ipw_disassociate(priv);
9044
9045 mutex_unlock(&priv->mutex);
9046 return ret;
9047 }
9048
9049 static int ipw_wx_get_encode(struct net_device *dev,
9050 struct iw_request_info *info,
9051 union iwreq_data *wrqu, char *key)
9052 {
9053 struct ipw_priv *priv = ieee80211_priv(dev);
9054 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9055 }
9056
9057 static int ipw_wx_set_power(struct net_device *dev,
9058 struct iw_request_info *info,
9059 union iwreq_data *wrqu, char *extra)
9060 {
9061 struct ipw_priv *priv = ieee80211_priv(dev);
9062 int err;
9063 mutex_lock(&priv->mutex);
9064 if (wrqu->power.disabled) {
9065 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9066 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9067 if (err) {
9068 IPW_DEBUG_WX("failed setting power mode.\n");
9069 mutex_unlock(&priv->mutex);
9070 return err;
9071 }
9072 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9073 mutex_unlock(&priv->mutex);
9074 return 0;
9075 }
9076
9077 switch (wrqu->power.flags & IW_POWER_MODE) {
9078 case IW_POWER_ON: /* If not specified */
9079 case IW_POWER_MODE: /* If set all mask */
9080 case IW_POWER_ALL_R: /* If explicitely state all */
9081 break;
9082 default: /* Otherwise we don't support it */
9083 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9084 wrqu->power.flags);
9085 mutex_unlock(&priv->mutex);
9086 return -EOPNOTSUPP;
9087 }
9088
9089 /* If the user hasn't specified a power management mode yet, default
9090 * to BATTERY */
9091 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9092 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9093 else
9094 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9095 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9096 if (err) {
9097 IPW_DEBUG_WX("failed setting power mode.\n");
9098 mutex_unlock(&priv->mutex);
9099 return err;
9100 }
9101
9102 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9103 mutex_unlock(&priv->mutex);
9104 return 0;
9105 }
9106
9107 static int ipw_wx_get_power(struct net_device *dev,
9108 struct iw_request_info *info,
9109 union iwreq_data *wrqu, char *extra)
9110 {
9111 struct ipw_priv *priv = ieee80211_priv(dev);
9112 mutex_lock(&priv->mutex);
9113 if (!(priv->power_mode & IPW_POWER_ENABLED))
9114 wrqu->power.disabled = 1;
9115 else
9116 wrqu->power.disabled = 0;
9117
9118 mutex_unlock(&priv->mutex);
9119 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9120
9121 return 0;
9122 }
9123
9124 static int ipw_wx_set_powermode(struct net_device *dev,
9125 struct iw_request_info *info,
9126 union iwreq_data *wrqu, char *extra)
9127 {
9128 struct ipw_priv *priv = ieee80211_priv(dev);
9129 int mode = *(int *)extra;
9130 int err;
9131 mutex_lock(&priv->mutex);
9132 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9133 mode = IPW_POWER_AC;
9134 priv->power_mode = mode;
9135 } else {
9136 priv->power_mode = IPW_POWER_ENABLED | mode;
9137 }
9138
9139 if (priv->power_mode != mode) {
9140 err = ipw_send_power_mode(priv, mode);
9141
9142 if (err) {
9143 IPW_DEBUG_WX("failed setting power mode.\n");
9144 mutex_unlock(&priv->mutex);
9145 return err;
9146 }
9147 }
9148 mutex_unlock(&priv->mutex);
9149 return 0;
9150 }
9151
9152 #define MAX_WX_STRING 80
9153 static int ipw_wx_get_powermode(struct net_device *dev,
9154 struct iw_request_info *info,
9155 union iwreq_data *wrqu, char *extra)
9156 {
9157 struct ipw_priv *priv = ieee80211_priv(dev);
9158 int level = IPW_POWER_LEVEL(priv->power_mode);
9159 char *p = extra;
9160
9161 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9162
9163 switch (level) {
9164 case IPW_POWER_AC:
9165 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9166 break;
9167 case IPW_POWER_BATTERY:
9168 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9169 break;
9170 default:
9171 p += snprintf(p, MAX_WX_STRING - (p - extra),
9172 "(Timeout %dms, Period %dms)",
9173 timeout_duration[level - 1] / 1000,
9174 period_duration[level - 1] / 1000);
9175 }
9176
9177 if (!(priv->power_mode & IPW_POWER_ENABLED))
9178 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9179
9180 wrqu->data.length = p - extra + 1;
9181
9182 return 0;
9183 }
9184
9185 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9186 struct iw_request_info *info,
9187 union iwreq_data *wrqu, char *extra)
9188 {
9189 struct ipw_priv *priv = ieee80211_priv(dev);
9190 int mode = *(int *)extra;
9191 u8 band = 0, modulation = 0;
9192
9193 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9194 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9195 return -EINVAL;
9196 }
9197 mutex_lock(&priv->mutex);
9198 if (priv->adapter == IPW_2915ABG) {
9199 priv->ieee->abg_true = 1;
9200 if (mode & IEEE_A) {
9201 band |= IEEE80211_52GHZ_BAND;
9202 modulation |= IEEE80211_OFDM_MODULATION;
9203 } else
9204 priv->ieee->abg_true = 0;
9205 } else {
9206 if (mode & IEEE_A) {
9207 IPW_WARNING("Attempt to set 2200BG into "
9208 "802.11a mode\n");
9209 mutex_unlock(&priv->mutex);
9210 return -EINVAL;
9211 }
9212
9213 priv->ieee->abg_true = 0;
9214 }
9215
9216 if (mode & IEEE_B) {
9217 band |= IEEE80211_24GHZ_BAND;
9218 modulation |= IEEE80211_CCK_MODULATION;
9219 } else
9220 priv->ieee->abg_true = 0;
9221
9222 if (mode & IEEE_G) {
9223 band |= IEEE80211_24GHZ_BAND;
9224 modulation |= IEEE80211_OFDM_MODULATION;
9225 } else
9226 priv->ieee->abg_true = 0;
9227
9228 priv->ieee->mode = mode;
9229 priv->ieee->freq_band = band;
9230 priv->ieee->modulation = modulation;
9231 init_supported_rates(priv, &priv->rates);
9232
9233 /* Network configuration changed -- force [re]association */
9234 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9235 if (!ipw_disassociate(priv)) {
9236 ipw_send_supported_rates(priv, &priv->rates);
9237 ipw_associate(priv);
9238 }
9239
9240 /* Update the band LEDs */
9241 ipw_led_band_on(priv);
9242
9243 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9244 mode & IEEE_A ? 'a' : '.',
9245 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9246 mutex_unlock(&priv->mutex);
9247 return 0;
9248 }
9249
9250 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9251 struct iw_request_info *info,
9252 union iwreq_data *wrqu, char *extra)
9253 {
9254 struct ipw_priv *priv = ieee80211_priv(dev);
9255 mutex_lock(&priv->mutex);
9256 switch (priv->ieee->mode) {
9257 case IEEE_A:
9258 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9259 break;
9260 case IEEE_B:
9261 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9262 break;
9263 case IEEE_A | IEEE_B:
9264 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9265 break;
9266 case IEEE_G:
9267 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9268 break;
9269 case IEEE_A | IEEE_G:
9270 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9271 break;
9272 case IEEE_B | IEEE_G:
9273 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9274 break;
9275 case IEEE_A | IEEE_B | IEEE_G:
9276 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9277 break;
9278 default:
9279 strncpy(extra, "unknown", MAX_WX_STRING);
9280 break;
9281 }
9282
9283 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9284
9285 wrqu->data.length = strlen(extra) + 1;
9286 mutex_unlock(&priv->mutex);
9287
9288 return 0;
9289 }
9290
9291 static int ipw_wx_set_preamble(struct net_device *dev,
9292 struct iw_request_info *info,
9293 union iwreq_data *wrqu, char *extra)
9294 {
9295 struct ipw_priv *priv = ieee80211_priv(dev);
9296 int mode = *(int *)extra;
9297 mutex_lock(&priv->mutex);
9298 /* Switching from SHORT -> LONG requires a disassociation */
9299 if (mode == 1) {
9300 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9301 priv->config |= CFG_PREAMBLE_LONG;
9302
9303 /* Network configuration changed -- force [re]association */
9304 IPW_DEBUG_ASSOC
9305 ("[re]association triggered due to preamble change.\n");
9306 if (!ipw_disassociate(priv))
9307 ipw_associate(priv);
9308 }
9309 goto done;
9310 }
9311
9312 if (mode == 0) {
9313 priv->config &= ~CFG_PREAMBLE_LONG;
9314 goto done;
9315 }
9316 mutex_unlock(&priv->mutex);
9317 return -EINVAL;
9318
9319 done:
9320 mutex_unlock(&priv->mutex);
9321 return 0;
9322 }
9323
9324 static int ipw_wx_get_preamble(struct net_device *dev,
9325 struct iw_request_info *info,
9326 union iwreq_data *wrqu, char *extra)
9327 {
9328 struct ipw_priv *priv = ieee80211_priv(dev);
9329 mutex_lock(&priv->mutex);
9330 if (priv->config & CFG_PREAMBLE_LONG)
9331 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9332 else
9333 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9334 mutex_unlock(&priv->mutex);
9335 return 0;
9336 }
9337
9338 #ifdef CONFIG_IPW2200_MONITOR
9339 static int ipw_wx_set_monitor(struct net_device *dev,
9340 struct iw_request_info *info,
9341 union iwreq_data *wrqu, char *extra)
9342 {
9343 struct ipw_priv *priv = ieee80211_priv(dev);
9344 int *parms = (int *)extra;
9345 int enable = (parms[0] > 0);
9346 mutex_lock(&priv->mutex);
9347 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9348 if (enable) {
9349 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9350 #ifdef CONFIG_IEEE80211_RADIOTAP
9351 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9352 #else
9353 priv->net_dev->type = ARPHRD_IEEE80211;
9354 #endif
9355 queue_work(priv->workqueue, &priv->adapter_restart);
9356 }
9357
9358 ipw_set_channel(priv, parms[1]);
9359 } else {
9360 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9361 mutex_unlock(&priv->mutex);
9362 return 0;
9363 }
9364 priv->net_dev->type = ARPHRD_ETHER;
9365 queue_work(priv->workqueue, &priv->adapter_restart);
9366 }
9367 mutex_unlock(&priv->mutex);
9368 return 0;
9369 }
9370
9371 #endif // CONFIG_IPW2200_MONITOR
9372
9373 static int ipw_wx_reset(struct net_device *dev,
9374 struct iw_request_info *info,
9375 union iwreq_data *wrqu, char *extra)
9376 {
9377 struct ipw_priv *priv = ieee80211_priv(dev);
9378 IPW_DEBUG_WX("RESET\n");
9379 queue_work(priv->workqueue, &priv->adapter_restart);
9380 return 0;
9381 }
9382
9383 static int ipw_wx_sw_reset(struct net_device *dev,
9384 struct iw_request_info *info,
9385 union iwreq_data *wrqu, char *extra)
9386 {
9387 struct ipw_priv *priv = ieee80211_priv(dev);
9388 union iwreq_data wrqu_sec = {
9389 .encoding = {
9390 .flags = IW_ENCODE_DISABLED,
9391 },
9392 };
9393 int ret;
9394
9395 IPW_DEBUG_WX("SW_RESET\n");
9396
9397 mutex_lock(&priv->mutex);
9398
9399 ret = ipw_sw_reset(priv, 0);
9400 if (!ret) {
9401 free_firmware();
9402 ipw_adapter_restart(priv);
9403 }
9404
9405 /* The SW reset bit might have been toggled on by the 'disable'
9406 * module parameter, so take appropriate action */
9407 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9408
9409 mutex_unlock(&priv->mutex);
9410 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9411 mutex_lock(&priv->mutex);
9412
9413 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9414 /* Configuration likely changed -- force [re]association */
9415 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9416 "reset.\n");
9417 if (!ipw_disassociate(priv))
9418 ipw_associate(priv);
9419 }
9420
9421 mutex_unlock(&priv->mutex);
9422
9423 return 0;
9424 }
9425
9426 /* Rebase the WE IOCTLs to zero for the handler array */
9427 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9428 static iw_handler ipw_wx_handlers[] = {
9429 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9430 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9431 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9432 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9433 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9434 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9435 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9436 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9437 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9438 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9439 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9440 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9441 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9442 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9443 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9444 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9445 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9446 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9447 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9448 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9449 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9450 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9451 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9452 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9453 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9454 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9455 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9456 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9457 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9458 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9459 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9460 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9461 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9462 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9463 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9464 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9465 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9466 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9467 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9468 };
9469
9470 enum {
9471 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9472 IPW_PRIV_GET_POWER,
9473 IPW_PRIV_SET_MODE,
9474 IPW_PRIV_GET_MODE,
9475 IPW_PRIV_SET_PREAMBLE,
9476 IPW_PRIV_GET_PREAMBLE,
9477 IPW_PRIV_RESET,
9478 IPW_PRIV_SW_RESET,
9479 #ifdef CONFIG_IPW2200_MONITOR
9480 IPW_PRIV_SET_MONITOR,
9481 #endif
9482 };
9483
9484 static struct iw_priv_args ipw_priv_args[] = {
9485 {
9486 .cmd = IPW_PRIV_SET_POWER,
9487 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9488 .name = "set_power"},
9489 {
9490 .cmd = IPW_PRIV_GET_POWER,
9491 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9492 .name = "get_power"},
9493 {
9494 .cmd = IPW_PRIV_SET_MODE,
9495 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9496 .name = "set_mode"},
9497 {
9498 .cmd = IPW_PRIV_GET_MODE,
9499 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9500 .name = "get_mode"},
9501 {
9502 .cmd = IPW_PRIV_SET_PREAMBLE,
9503 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9504 .name = "set_preamble"},
9505 {
9506 .cmd = IPW_PRIV_GET_PREAMBLE,
9507 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9508 .name = "get_preamble"},
9509 {
9510 IPW_PRIV_RESET,
9511 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9512 {
9513 IPW_PRIV_SW_RESET,
9514 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9515 #ifdef CONFIG_IPW2200_MONITOR
9516 {
9517 IPW_PRIV_SET_MONITOR,
9518 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9519 #endif /* CONFIG_IPW2200_MONITOR */
9520 };
9521
9522 static iw_handler ipw_priv_handler[] = {
9523 ipw_wx_set_powermode,
9524 ipw_wx_get_powermode,
9525 ipw_wx_set_wireless_mode,
9526 ipw_wx_get_wireless_mode,
9527 ipw_wx_set_preamble,
9528 ipw_wx_get_preamble,
9529 ipw_wx_reset,
9530 ipw_wx_sw_reset,
9531 #ifdef CONFIG_IPW2200_MONITOR
9532 ipw_wx_set_monitor,
9533 #endif
9534 };
9535
9536 static struct iw_handler_def ipw_wx_handler_def = {
9537 .standard = ipw_wx_handlers,
9538 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9539 .num_private = ARRAY_SIZE(ipw_priv_handler),
9540 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9541 .private = ipw_priv_handler,
9542 .private_args = ipw_priv_args,
9543 .get_wireless_stats = ipw_get_wireless_stats,
9544 };
9545
9546 /*
9547 * Get wireless statistics.
9548 * Called by /proc/net/wireless
9549 * Also called by SIOCGIWSTATS
9550 */
9551 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9552 {
9553 struct ipw_priv *priv = ieee80211_priv(dev);
9554 struct iw_statistics *wstats;
9555
9556 wstats = &priv->wstats;
9557
9558 /* if hw is disabled, then ipw_get_ordinal() can't be called.
9559 * netdev->get_wireless_stats seems to be called before fw is
9560 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9561 * and associated; if not associcated, the values are all meaningless
9562 * anyway, so set them all to NULL and INVALID */
9563 if (!(priv->status & STATUS_ASSOCIATED)) {
9564 wstats->miss.beacon = 0;
9565 wstats->discard.retries = 0;
9566 wstats->qual.qual = 0;
9567 wstats->qual.level = 0;
9568 wstats->qual.noise = 0;
9569 wstats->qual.updated = 7;
9570 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9571 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9572 return wstats;
9573 }
9574
9575 wstats->qual.qual = priv->quality;
9576 wstats->qual.level = average_value(&priv->average_rssi);
9577 wstats->qual.noise = average_value(&priv->average_noise);
9578 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9579 IW_QUAL_NOISE_UPDATED;
9580
9581 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9582 wstats->discard.retries = priv->last_tx_failures;
9583 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9584
9585 /* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9586 goto fail_get_ordinal;
9587 wstats->discard.retries += tx_retry; */
9588
9589 return wstats;
9590 }
9591
9592 /* net device stuff */
9593
9594 static void init_sys_config(struct ipw_sys_config *sys_config)
9595 {
9596 memset(sys_config, 0, sizeof(struct ipw_sys_config));
9597 sys_config->bt_coexistence = 0;
9598 sys_config->answer_broadcast_ssid_probe = 0;
9599 sys_config->accept_all_data_frames = 0;
9600 sys_config->accept_non_directed_frames = 1;
9601 sys_config->exclude_unicast_unencrypted = 0;
9602 sys_config->disable_unicast_decryption = 1;
9603 sys_config->exclude_multicast_unencrypted = 0;
9604 sys_config->disable_multicast_decryption = 1;
9605 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
9606 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
9607 sys_config->dot11g_auto_detection = 0;
9608 sys_config->enable_cts_to_self = 0;
9609 sys_config->bt_coexist_collision_thr = 0;
9610 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
9611 }
9612
9613 static int ipw_net_open(struct net_device *dev)
9614 {
9615 struct ipw_priv *priv = ieee80211_priv(dev);
9616 IPW_DEBUG_INFO("dev->open\n");
9617 /* we should be verifying the device is ready to be opened */
9618 mutex_lock(&priv->mutex);
9619 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9620 (priv->status & STATUS_ASSOCIATED))
9621 netif_start_queue(dev);
9622 mutex_unlock(&priv->mutex);
9623 return 0;
9624 }
9625
9626 static int ipw_net_stop(struct net_device *dev)
9627 {
9628 IPW_DEBUG_INFO("dev->close\n");
9629 netif_stop_queue(dev);
9630 return 0;
9631 }
9632
9633 /*
9634 todo:
9635
9636 modify to send one tfd per fragment instead of using chunking. otherwise
9637 we need to heavily modify the ieee80211_skb_to_txb.
9638 */
9639
9640 static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9641 int pri)
9642 {
9643 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9644 txb->fragments[0]->data;
9645 int i = 0;
9646 struct tfd_frame *tfd;
9647 #ifdef CONFIG_IPW_QOS
9648 int tx_id = ipw_get_tx_queue_number(priv, pri);
9649 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9650 #else
9651 struct clx2_tx_queue *txq = &priv->txq[0];
9652 #endif
9653 struct clx2_queue *q = &txq->q;
9654 u8 id, hdr_len, unicast;
9655 u16 remaining_bytes;
9656 int fc;
9657
9658 /* If there isn't room in the queue, we return busy and let the
9659 * network stack requeue the packet for us */
9660 if (ipw_queue_space(q) < q->high_mark)
9661 return NETDEV_TX_BUSY;
9662
9663 switch (priv->ieee->iw_mode) {
9664 case IW_MODE_ADHOC:
9665 hdr_len = IEEE80211_3ADDR_LEN;
9666 unicast = !is_multicast_ether_addr(hdr->addr1);
9667 id = ipw_find_station(priv, hdr->addr1);
9668 if (id == IPW_INVALID_STATION) {
9669 id = ipw_add_station(priv, hdr->addr1);
9670 if (id == IPW_INVALID_STATION) {
9671 IPW_WARNING("Attempt to send data to "
9672 "invalid cell: " MAC_FMT "\n",
9673 MAC_ARG(hdr->addr1));
9674 goto drop;
9675 }
9676 }
9677 break;
9678
9679 case IW_MODE_INFRA:
9680 default:
9681 unicast = !is_multicast_ether_addr(hdr->addr3);
9682 hdr_len = IEEE80211_3ADDR_LEN;
9683 id = 0;
9684 break;
9685 }
9686
9687 tfd = &txq->bd[q->first_empty];
9688 txq->txb[q->first_empty] = txb;
9689 memset(tfd, 0, sizeof(*tfd));
9690 tfd->u.data.station_number = id;
9691
9692 tfd->control_flags.message_type = TX_FRAME_TYPE;
9693 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9694
9695 tfd->u.data.cmd_id = DINO_CMD_TX;
9696 tfd->u.data.len = cpu_to_le16(txb->payload_size);
9697 remaining_bytes = txb->payload_size;
9698
9699 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9700 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9701 else
9702 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9703
9704 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9705 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9706
9707 fc = le16_to_cpu(hdr->frame_ctl);
9708 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9709
9710 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9711
9712 if (likely(unicast))
9713 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9714
9715 if (txb->encrypted && !priv->ieee->host_encrypt) {
9716 switch (priv->ieee->sec.level) {
9717 case SEC_LEVEL_3:
9718 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9719 IEEE80211_FCTL_PROTECTED;
9720 /* XXX: ACK flag must be set for CCMP even if it
9721 * is a multicast/broadcast packet, because CCMP
9722 * group communication encrypted by GTK is
9723 * actually done by the AP. */
9724 if (!unicast)
9725 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9726
9727 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9728 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9729 tfd->u.data.key_index = 0;
9730 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9731 break;
9732 case SEC_LEVEL_2:
9733 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9734 IEEE80211_FCTL_PROTECTED;
9735 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9736 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9737 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9738 break;
9739 case SEC_LEVEL_1:
9740 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9741 IEEE80211_FCTL_PROTECTED;
9742 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9743 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9744 40)
9745 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9746 else
9747 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9748 break;
9749 case SEC_LEVEL_0:
9750 break;
9751 default:
9752 printk(KERN_ERR "Unknow security level %d\n",
9753 priv->ieee->sec.level);
9754 break;
9755 }
9756 } else
9757 /* No hardware encryption */
9758 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9759
9760 #ifdef CONFIG_IPW_QOS
9761 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9762 #endif /* CONFIG_IPW_QOS */
9763
9764 /* payload */
9765 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9766 txb->nr_frags));
9767 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9768 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9769 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9770 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9771 i, le32_to_cpu(tfd->u.data.num_chunks),
9772 txb->fragments[i]->len - hdr_len);
9773 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9774 i, tfd->u.data.num_chunks,
9775 txb->fragments[i]->len - hdr_len);
9776 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9777 txb->fragments[i]->len - hdr_len);
9778
9779 tfd->u.data.chunk_ptr[i] =
9780 cpu_to_le32(pci_map_single
9781 (priv->pci_dev,
9782 txb->fragments[i]->data + hdr_len,
9783 txb->fragments[i]->len - hdr_len,
9784 PCI_DMA_TODEVICE));
9785 tfd->u.data.chunk_len[i] =
9786 cpu_to_le16(txb->fragments[i]->len - hdr_len);
9787 }
9788
9789 if (i != txb->nr_frags) {
9790 struct sk_buff *skb;
9791 u16 remaining_bytes = 0;
9792 int j;
9793
9794 for (j = i; j < txb->nr_frags; j++)
9795 remaining_bytes += txb->fragments[j]->len - hdr_len;
9796
9797 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9798 remaining_bytes);
9799 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9800 if (skb != NULL) {
9801 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9802 for (j = i; j < txb->nr_frags; j++) {
9803 int size = txb->fragments[j]->len - hdr_len;
9804
9805 printk(KERN_INFO "Adding frag %d %d...\n",
9806 j, size);
9807 memcpy(skb_put(skb, size),
9808 txb->fragments[j]->data + hdr_len, size);
9809 }
9810 dev_kfree_skb_any(txb->fragments[i]);
9811 txb->fragments[i] = skb;
9812 tfd->u.data.chunk_ptr[i] =
9813 cpu_to_le32(pci_map_single
9814 (priv->pci_dev, skb->data,
9815 tfd->u.data.chunk_len[i],
9816 PCI_DMA_TODEVICE));
9817
9818 tfd->u.data.num_chunks =
9819 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9820 1);
9821 }
9822 }
9823
9824 /* kick DMA */
9825 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9826 ipw_write32(priv, q->reg_w, q->first_empty);
9827
9828 return NETDEV_TX_OK;
9829
9830 drop:
9831 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9832 ieee80211_txb_free(txb);
9833 return NETDEV_TX_OK;
9834 }
9835
9836 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9837 {
9838 struct ipw_priv *priv = ieee80211_priv(dev);
9839 #ifdef CONFIG_IPW_QOS
9840 int tx_id = ipw_get_tx_queue_number(priv, pri);
9841 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9842 #else
9843 struct clx2_tx_queue *txq = &priv->txq[0];
9844 #endif /* CONFIG_IPW_QOS */
9845
9846 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9847 return 1;
9848
9849 return 0;
9850 }
9851
9852 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9853 struct net_device *dev, int pri)
9854 {
9855 struct ipw_priv *priv = ieee80211_priv(dev);
9856 unsigned long flags;
9857 int ret;
9858
9859 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9860 spin_lock_irqsave(&priv->lock, flags);
9861
9862 if (!(priv->status & STATUS_ASSOCIATED)) {
9863 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9864 priv->ieee->stats.tx_carrier_errors++;
9865 netif_stop_queue(dev);
9866 goto fail_unlock;
9867 }
9868
9869 ret = ipw_tx_skb(priv, txb, pri);
9870 if (ret == NETDEV_TX_OK)
9871 __ipw_led_activity_on(priv);
9872 spin_unlock_irqrestore(&priv->lock, flags);
9873
9874 return ret;
9875
9876 fail_unlock:
9877 spin_unlock_irqrestore(&priv->lock, flags);
9878 return 1;
9879 }
9880
9881 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9882 {
9883 struct ipw_priv *priv = ieee80211_priv(dev);
9884
9885 priv->ieee->stats.tx_packets = priv->tx_packets;
9886 priv->ieee->stats.rx_packets = priv->rx_packets;
9887 return &priv->ieee->stats;
9888 }
9889
9890 static void ipw_net_set_multicast_list(struct net_device *dev)
9891 {
9892
9893 }
9894
9895 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9896 {
9897 struct ipw_priv *priv = ieee80211_priv(dev);
9898 struct sockaddr *addr = p;
9899 if (!is_valid_ether_addr(addr->sa_data))
9900 return -EADDRNOTAVAIL;
9901 mutex_lock(&priv->mutex);
9902 priv->config |= CFG_CUSTOM_MAC;
9903 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9904 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9905 priv->net_dev->name, MAC_ARG(priv->mac_addr));
9906 queue_work(priv->workqueue, &priv->adapter_restart);
9907 mutex_unlock(&priv->mutex);
9908 return 0;
9909 }
9910
9911 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9912 struct ethtool_drvinfo *info)
9913 {
9914 struct ipw_priv *p = ieee80211_priv(dev);
9915 char vers[64];
9916 char date[32];
9917 u32 len;
9918
9919 strcpy(info->driver, DRV_NAME);
9920 strcpy(info->version, DRV_VERSION);
9921
9922 len = sizeof(vers);
9923 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9924 len = sizeof(date);
9925 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9926
9927 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9928 vers, date);
9929 strcpy(info->bus_info, pci_name(p->pci_dev));
9930 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9931 }
9932
9933 static u32 ipw_ethtool_get_link(struct net_device *dev)
9934 {
9935 struct ipw_priv *priv = ieee80211_priv(dev);
9936 return (priv->status & STATUS_ASSOCIATED) != 0;
9937 }
9938
9939 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9940 {
9941 return IPW_EEPROM_IMAGE_SIZE;
9942 }
9943
9944 static int ipw_ethtool_get_eeprom(struct net_device *dev,
9945 struct ethtool_eeprom *eeprom, u8 * bytes)
9946 {
9947 struct ipw_priv *p = ieee80211_priv(dev);
9948
9949 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9950 return -EINVAL;
9951 mutex_lock(&p->mutex);
9952 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9953 mutex_unlock(&p->mutex);
9954 return 0;
9955 }
9956
9957 static int ipw_ethtool_set_eeprom(struct net_device *dev,
9958 struct ethtool_eeprom *eeprom, u8 * bytes)
9959 {
9960 struct ipw_priv *p = ieee80211_priv(dev);
9961 int i;
9962
9963 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9964 return -EINVAL;
9965 mutex_lock(&p->mutex);
9966 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
9967 for (i = IPW_EEPROM_DATA;
9968 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
9969 ipw_write8(p, i, p->eeprom[i]);
9970 mutex_unlock(&p->mutex);
9971 return 0;
9972 }
9973
9974 static struct ethtool_ops ipw_ethtool_ops = {
9975 .get_link = ipw_ethtool_get_link,
9976 .get_drvinfo = ipw_ethtool_get_drvinfo,
9977 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9978 .get_eeprom = ipw_ethtool_get_eeprom,
9979 .set_eeprom = ipw_ethtool_set_eeprom,
9980 };
9981
9982 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9983 {
9984 struct ipw_priv *priv = data;
9985 u32 inta, inta_mask;
9986
9987 if (!priv)
9988 return IRQ_NONE;
9989
9990 spin_lock(&priv->lock);
9991
9992 if (!(priv->status & STATUS_INT_ENABLED)) {
9993 /* Shared IRQ */
9994 goto none;
9995 }
9996
9997 inta = ipw_read32(priv, IPW_INTA_RW);
9998 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
9999
10000 if (inta == 0xFFFFFFFF) {
10001 /* Hardware disappeared */
10002 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10003 goto none;
10004 }
10005
10006 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10007 /* Shared interrupt */
10008 goto none;
10009 }
10010
10011 /* tell the device to stop sending interrupts */
10012 ipw_disable_interrupts(priv);
10013
10014 /* ack current interrupts */
10015 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10016 ipw_write32(priv, IPW_INTA_RW, inta);
10017
10018 /* Cache INTA value for our tasklet */
10019 priv->isr_inta = inta;
10020
10021 tasklet_schedule(&priv->irq_tasklet);
10022
10023 spin_unlock(&priv->lock);
10024
10025 return IRQ_HANDLED;
10026 none:
10027 spin_unlock(&priv->lock);
10028 return IRQ_NONE;
10029 }
10030
10031 static void ipw_rf_kill(void *adapter)
10032 {
10033 struct ipw_priv *priv = adapter;
10034 unsigned long flags;
10035
10036 spin_lock_irqsave(&priv->lock, flags);
10037
10038 if (rf_kill_active(priv)) {
10039 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10040 if (priv->workqueue)
10041 queue_delayed_work(priv->workqueue,
10042 &priv->rf_kill, 2 * HZ);
10043 goto exit_unlock;
10044 }
10045
10046 /* RF Kill is now disabled, so bring the device back up */
10047
10048 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10049 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10050 "device\n");
10051
10052 /* we can not do an adapter restart while inside an irq lock */
10053 queue_work(priv->workqueue, &priv->adapter_restart);
10054 } else
10055 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10056 "enabled\n");
10057
10058 exit_unlock:
10059 spin_unlock_irqrestore(&priv->lock, flags);
10060 }
10061
10062 static void ipw_bg_rf_kill(void *data)
10063 {
10064 struct ipw_priv *priv = data;
10065 mutex_lock(&priv->mutex);
10066 ipw_rf_kill(data);
10067 mutex_unlock(&priv->mutex);
10068 }
10069
10070 static void ipw_link_up(struct ipw_priv *priv)
10071 {
10072 priv->last_seq_num = -1;
10073 priv->last_frag_num = -1;
10074 priv->last_packet_time = 0;
10075
10076 netif_carrier_on(priv->net_dev);
10077 if (netif_queue_stopped(priv->net_dev)) {
10078 IPW_DEBUG_NOTIF("waking queue\n");
10079 netif_wake_queue(priv->net_dev);
10080 } else {
10081 IPW_DEBUG_NOTIF("starting queue\n");
10082 netif_start_queue(priv->net_dev);
10083 }
10084
10085 cancel_delayed_work(&priv->request_scan);
10086 ipw_reset_stats(priv);
10087 /* Ensure the rate is updated immediately */
10088 priv->last_rate = ipw_get_current_rate(priv);
10089 ipw_gather_stats(priv);
10090 ipw_led_link_up(priv);
10091 notify_wx_assoc_event(priv);
10092
10093 if (priv->config & CFG_BACKGROUND_SCAN)
10094 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10095 }
10096
10097 static void ipw_bg_link_up(void *data)
10098 {
10099 struct ipw_priv *priv = data;
10100 mutex_lock(&priv->mutex);
10101 ipw_link_up(data);
10102 mutex_unlock(&priv->mutex);
10103 }
10104
10105 static void ipw_link_down(struct ipw_priv *priv)
10106 {
10107 ipw_led_link_down(priv);
10108 netif_carrier_off(priv->net_dev);
10109 netif_stop_queue(priv->net_dev);
10110 notify_wx_assoc_event(priv);
10111
10112 /* Cancel any queued work ... */
10113 cancel_delayed_work(&priv->request_scan);
10114 cancel_delayed_work(&priv->adhoc_check);
10115 cancel_delayed_work(&priv->gather_stats);
10116
10117 ipw_reset_stats(priv);
10118
10119 if (!(priv->status & STATUS_EXIT_PENDING)) {
10120 /* Queue up another scan... */
10121 queue_work(priv->workqueue, &priv->request_scan);
10122 }
10123 }
10124
10125 static void ipw_bg_link_down(void *data)
10126 {
10127 struct ipw_priv *priv = data;
10128 mutex_lock(&priv->mutex);
10129 ipw_link_down(data);
10130 mutex_unlock(&priv->mutex);
10131 }
10132
10133 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10134 {
10135 int ret = 0;
10136
10137 priv->workqueue = create_workqueue(DRV_NAME);
10138 init_waitqueue_head(&priv->wait_command_queue);
10139 init_waitqueue_head(&priv->wait_state);
10140
10141 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10142 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10143 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10144 INIT_WORK(&priv->system_config, ipw_system_config, priv);
10145 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10146 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10147 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10148 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10149 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10150 INIT_WORK(&priv->request_scan,
10151 (void (*)(void *))ipw_request_scan, priv);
10152 INIT_WORK(&priv->gather_stats,
10153 (void (*)(void *))ipw_bg_gather_stats, priv);
10154 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10155 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10156 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10157 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10158 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10159 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10160 priv);
10161 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10162 priv);
10163 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10164 priv);
10165 INIT_WORK(&priv->merge_networks,
10166 (void (*)(void *))ipw_merge_adhoc_network, priv);
10167
10168 #ifdef CONFIG_IPW_QOS
10169 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10170 priv);
10171 #endif /* CONFIG_IPW_QOS */
10172
10173 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10174 ipw_irq_tasklet, (unsigned long)priv);
10175
10176 return ret;
10177 }
10178
10179 static void shim__set_security(struct net_device *dev,
10180 struct ieee80211_security *sec)
10181 {
10182 struct ipw_priv *priv = ieee80211_priv(dev);
10183 int i;
10184 for (i = 0; i < 4; i++) {
10185 if (sec->flags & (1 << i)) {
10186 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10187 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10188 if (sec->key_sizes[i] == 0)
10189 priv->ieee->sec.flags &= ~(1 << i);
10190 else {
10191 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10192 sec->key_sizes[i]);
10193 priv->ieee->sec.flags |= (1 << i);
10194 }
10195 priv->status |= STATUS_SECURITY_UPDATED;
10196 } else if (sec->level != SEC_LEVEL_1)
10197 priv->ieee->sec.flags &= ~(1 << i);
10198 }
10199
10200 if (sec->flags & SEC_ACTIVE_KEY) {
10201 if (sec->active_key <= 3) {
10202 priv->ieee->sec.active_key = sec->active_key;
10203 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10204 } else
10205 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10206 priv->status |= STATUS_SECURITY_UPDATED;
10207 } else
10208 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10209
10210 if ((sec->flags & SEC_AUTH_MODE) &&
10211 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10212 priv->ieee->sec.auth_mode = sec->auth_mode;
10213 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10214 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10215 priv->capability |= CAP_SHARED_KEY;
10216 else
10217 priv->capability &= ~CAP_SHARED_KEY;
10218 priv->status |= STATUS_SECURITY_UPDATED;
10219 }
10220
10221 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10222 priv->ieee->sec.flags |= SEC_ENABLED;
10223 priv->ieee->sec.enabled = sec->enabled;
10224 priv->status |= STATUS_SECURITY_UPDATED;
10225 if (sec->enabled)
10226 priv->capability |= CAP_PRIVACY_ON;
10227 else
10228 priv->capability &= ~CAP_PRIVACY_ON;
10229 }
10230
10231 if (sec->flags & SEC_ENCRYPT)
10232 priv->ieee->sec.encrypt = sec->encrypt;
10233
10234 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10235 priv->ieee->sec.level = sec->level;
10236 priv->ieee->sec.flags |= SEC_LEVEL;
10237 priv->status |= STATUS_SECURITY_UPDATED;
10238 }
10239
10240 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10241 ipw_set_hwcrypto_keys(priv);
10242
10243 /* To match current functionality of ipw2100 (which works well w/
10244 * various supplicants, we don't force a disassociate if the
10245 * privacy capability changes ... */
10246 #if 0
10247 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10248 (((priv->assoc_request.capability &
10249 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10250 (!(priv->assoc_request.capability &
10251 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10252 IPW_DEBUG_ASSOC("Disassociating due to capability "
10253 "change.\n");
10254 ipw_disassociate(priv);
10255 }
10256 #endif
10257 }
10258
10259 static int init_supported_rates(struct ipw_priv *priv,
10260 struct ipw_supported_rates *rates)
10261 {
10262 /* TODO: Mask out rates based on priv->rates_mask */
10263
10264 memset(rates, 0, sizeof(*rates));
10265 /* configure supported rates */
10266 switch (priv->ieee->freq_band) {
10267 case IEEE80211_52GHZ_BAND:
10268 rates->ieee_mode = IPW_A_MODE;
10269 rates->purpose = IPW_RATE_CAPABILITIES;
10270 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10271 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10272 break;
10273
10274 default: /* Mixed or 2.4Ghz */
10275 rates->ieee_mode = IPW_G_MODE;
10276 rates->purpose = IPW_RATE_CAPABILITIES;
10277 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10278 IEEE80211_CCK_DEFAULT_RATES_MASK);
10279 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10280 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10281 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10282 }
10283 break;
10284 }
10285
10286 return 0;
10287 }
10288
10289 static int ipw_config(struct ipw_priv *priv)
10290 {
10291 /* This is only called from ipw_up, which resets/reloads the firmware
10292 so, we don't need to first disable the card before we configure
10293 it */
10294 if (ipw_set_tx_power(priv))
10295 goto error;
10296
10297 /* initialize adapter address */
10298 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10299 goto error;
10300
10301 /* set basic system config settings */
10302 init_sys_config(&priv->sys_config);
10303
10304 /* Support Bluetooth if we have BT h/w on board, and user wants to.
10305 * Does not support BT priority yet (don't abort or defer our Tx) */
10306 if (bt_coexist) {
10307 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10308
10309 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10310 priv->sys_config.bt_coexistence
10311 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
10312 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10313 priv->sys_config.bt_coexistence
10314 |= CFG_BT_COEXISTENCE_OOB;
10315 }
10316
10317 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10318 priv->sys_config.answer_broadcast_ssid_probe = 1;
10319 else
10320 priv->sys_config.answer_broadcast_ssid_probe = 0;
10321
10322 if (ipw_send_system_config(priv, &priv->sys_config))
10323 goto error;
10324
10325 init_supported_rates(priv, &priv->rates);
10326 if (ipw_send_supported_rates(priv, &priv->rates))
10327 goto error;
10328
10329 /* Set request-to-send threshold */
10330 if (priv->rts_threshold) {
10331 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10332 goto error;
10333 }
10334 #ifdef CONFIG_IPW_QOS
10335 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10336 ipw_qos_activate(priv, NULL);
10337 #endif /* CONFIG_IPW_QOS */
10338
10339 if (ipw_set_random_seed(priv))
10340 goto error;
10341
10342 /* final state transition to the RUN state */
10343 if (ipw_send_host_complete(priv))
10344 goto error;
10345
10346 priv->status |= STATUS_INIT;
10347
10348 ipw_led_init(priv);
10349 ipw_led_radio_on(priv);
10350 priv->notif_missed_beacons = 0;
10351
10352 /* Set hardware WEP key if it is configured. */
10353 if ((priv->capability & CAP_PRIVACY_ON) &&
10354 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10355 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10356 ipw_set_hwcrypto_keys(priv);
10357
10358 return 0;
10359
10360 error:
10361 return -EIO;
10362 }
10363
10364 /*
10365 * NOTE:
10366 *
10367 * These tables have been tested in conjunction with the
10368 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10369 *
10370 * Altering this values, using it on other hardware, or in geographies
10371 * not intended for resale of the above mentioned Intel adapters has
10372 * not been tested.
10373 *
10374 */
10375 static const struct ieee80211_geo ipw_geos[] = {
10376 { /* Restricted */
10377 "---",
10378 .bg_channels = 11,
10379 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10380 {2427, 4}, {2432, 5}, {2437, 6},
10381 {2442, 7}, {2447, 8}, {2452, 9},
10382 {2457, 10}, {2462, 11}},
10383 },
10384
10385 { /* Custom US/Canada */
10386 "ZZF",
10387 .bg_channels = 11,
10388 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10389 {2427, 4}, {2432, 5}, {2437, 6},
10390 {2442, 7}, {2447, 8}, {2452, 9},
10391 {2457, 10}, {2462, 11}},
10392 .a_channels = 8,
10393 .a = {{5180, 36},
10394 {5200, 40},
10395 {5220, 44},
10396 {5240, 48},
10397 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10398 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10399 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10400 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10401 },
10402
10403 { /* Rest of World */
10404 "ZZD",
10405 .bg_channels = 13,
10406 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10407 {2427, 4}, {2432, 5}, {2437, 6},
10408 {2442, 7}, {2447, 8}, {2452, 9},
10409 {2457, 10}, {2462, 11}, {2467, 12},
10410 {2472, 13}},
10411 },
10412
10413 { /* Custom USA & Europe & High */
10414 "ZZA",
10415 .bg_channels = 11,
10416 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10417 {2427, 4}, {2432, 5}, {2437, 6},
10418 {2442, 7}, {2447, 8}, {2452, 9},
10419 {2457, 10}, {2462, 11}},
10420 .a_channels = 13,
10421 .a = {{5180, 36},
10422 {5200, 40},
10423 {5220, 44},
10424 {5240, 48},
10425 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10426 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10427 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10428 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10429 {5745, 149},
10430 {5765, 153},
10431 {5785, 157},
10432 {5805, 161},
10433 {5825, 165}},
10434 },
10435
10436 { /* Custom NA & Europe */
10437 "ZZB",
10438 .bg_channels = 11,
10439 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10440 {2427, 4}, {2432, 5}, {2437, 6},
10441 {2442, 7}, {2447, 8}, {2452, 9},
10442 {2457, 10}, {2462, 11}},
10443 .a_channels = 13,
10444 .a = {{5180, 36},
10445 {5200, 40},
10446 {5220, 44},
10447 {5240, 48},
10448 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10449 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10450 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10451 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10452 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10453 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10454 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10455 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10456 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10457 },
10458
10459 { /* Custom Japan */
10460 "ZZC",
10461 .bg_channels = 11,
10462 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10463 {2427, 4}, {2432, 5}, {2437, 6},
10464 {2442, 7}, {2447, 8}, {2452, 9},
10465 {2457, 10}, {2462, 11}},
10466 .a_channels = 4,
10467 .a = {{5170, 34}, {5190, 38},
10468 {5210, 42}, {5230, 46}},
10469 },
10470
10471 { /* Custom */
10472 "ZZM",
10473 .bg_channels = 11,
10474 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10475 {2427, 4}, {2432, 5}, {2437, 6},
10476 {2442, 7}, {2447, 8}, {2452, 9},
10477 {2457, 10}, {2462, 11}},
10478 },
10479
10480 { /* Europe */
10481 "ZZE",
10482 .bg_channels = 13,
10483 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10484 {2427, 4}, {2432, 5}, {2437, 6},
10485 {2442, 7}, {2447, 8}, {2452, 9},
10486 {2457, 10}, {2462, 11}, {2467, 12},
10487 {2472, 13}},
10488 .a_channels = 19,
10489 .a = {{5180, 36},
10490 {5200, 40},
10491 {5220, 44},
10492 {5240, 48},
10493 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10494 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10495 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10496 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10497 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10498 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10499 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10500 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10501 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10502 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10503 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10504 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10505 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10506 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10507 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10508 },
10509
10510 { /* Custom Japan */
10511 "ZZJ",
10512 .bg_channels = 14,
10513 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10514 {2427, 4}, {2432, 5}, {2437, 6},
10515 {2442, 7}, {2447, 8}, {2452, 9},
10516 {2457, 10}, {2462, 11}, {2467, 12},
10517 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10518 .a_channels = 4,
10519 .a = {{5170, 34}, {5190, 38},
10520 {5210, 42}, {5230, 46}},
10521 },
10522
10523 { /* Rest of World */
10524 "ZZR",
10525 .bg_channels = 14,
10526 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10527 {2427, 4}, {2432, 5}, {2437, 6},
10528 {2442, 7}, {2447, 8}, {2452, 9},
10529 {2457, 10}, {2462, 11}, {2467, 12},
10530 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10531 IEEE80211_CH_PASSIVE_ONLY}},
10532 },
10533
10534 { /* High Band */
10535 "ZZH",
10536 .bg_channels = 13,
10537 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10538 {2427, 4}, {2432, 5}, {2437, 6},
10539 {2442, 7}, {2447, 8}, {2452, 9},
10540 {2457, 10}, {2462, 11},
10541 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10542 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10543 .a_channels = 4,
10544 .a = {{5745, 149}, {5765, 153},
10545 {5785, 157}, {5805, 161}},
10546 },
10547
10548 { /* Custom Europe */
10549 "ZZG",
10550 .bg_channels = 13,
10551 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10552 {2427, 4}, {2432, 5}, {2437, 6},
10553 {2442, 7}, {2447, 8}, {2452, 9},
10554 {2457, 10}, {2462, 11},
10555 {2467, 12}, {2472, 13}},
10556 .a_channels = 4,
10557 .a = {{5180, 36}, {5200, 40},
10558 {5220, 44}, {5240, 48}},
10559 },
10560
10561 { /* Europe */
10562 "ZZK",
10563 .bg_channels = 13,
10564 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10565 {2427, 4}, {2432, 5}, {2437, 6},
10566 {2442, 7}, {2447, 8}, {2452, 9},
10567 {2457, 10}, {2462, 11},
10568 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10569 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10570 .a_channels = 24,
10571 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10572 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10573 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10574 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10575 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10576 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10577 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10578 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10579 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10580 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10581 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10582 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10583 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10584 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10585 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10586 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10587 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10588 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10589 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10590 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10591 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10592 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10593 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10594 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10595 },
10596
10597 { /* Europe */
10598 "ZZL",
10599 .bg_channels = 11,
10600 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10601 {2427, 4}, {2432, 5}, {2437, 6},
10602 {2442, 7}, {2447, 8}, {2452, 9},
10603 {2457, 10}, {2462, 11}},
10604 .a_channels = 13,
10605 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10606 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10607 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10608 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10609 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10610 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10611 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10612 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10613 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10614 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10615 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10616 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10617 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10618 }
10619 };
10620
10621 /* GEO code borrowed from ieee80211_geo.c */
10622 static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
10623 {
10624 int i;
10625
10626 /* Driver needs to initialize the geography map before using
10627 * these helper functions */
10628 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10629
10630 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10631 for (i = 0; i < ieee->geo.bg_channels; i++)
10632 /* NOTE: If G mode is currently supported but
10633 * this is a B only channel, we don't see it
10634 * as valid. */
10635 if ((ieee->geo.bg[i].channel == channel) &&
10636 (!(ieee->mode & IEEE_G) ||
10637 !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
10638 return IEEE80211_24GHZ_BAND;
10639
10640 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10641 for (i = 0; i < ieee->geo.a_channels; i++)
10642 if (ieee->geo.a[i].channel == channel)
10643 return IEEE80211_52GHZ_BAND;
10644
10645 return 0;
10646 }
10647
10648 static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
10649 {
10650 int i;
10651
10652 /* Driver needs to initialize the geography map before using
10653 * these helper functions */
10654 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10655
10656 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10657 for (i = 0; i < ieee->geo.bg_channels; i++)
10658 if (ieee->geo.bg[i].channel == channel)
10659 return i;
10660
10661 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10662 for (i = 0; i < ieee->geo.a_channels; i++)
10663 if (ieee->geo.a[i].channel == channel)
10664 return i;
10665
10666 return -1;
10667 }
10668
10669 static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
10670 {
10671 int i;
10672
10673 /* Driver needs to initialize the geography map before using
10674 * these helper functions */
10675 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10676
10677 freq /= 100000;
10678
10679 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10680 for (i = 0; i < ieee->geo.bg_channels; i++)
10681 if (ieee->geo.bg[i].freq == freq)
10682 return ieee->geo.bg[i].channel;
10683
10684 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10685 for (i = 0; i < ieee->geo.a_channels; i++)
10686 if (ieee->geo.a[i].freq == freq)
10687 return ieee->geo.a[i].channel;
10688
10689 return 0;
10690 }
10691
10692 static int ipw_set_geo(struct ieee80211_device *ieee,
10693 const struct ieee80211_geo *geo)
10694 {
10695 memcpy(ieee->geo.name, geo->name, 3);
10696 ieee->geo.name[3] = '\0';
10697 ieee->geo.bg_channels = geo->bg_channels;
10698 ieee->geo.a_channels = geo->a_channels;
10699 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
10700 sizeof(struct ieee80211_channel));
10701 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
10702 sizeof(struct ieee80211_channel));
10703 return 0;
10704 }
10705
10706 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
10707 {
10708 return &ieee->geo;
10709 }
10710
10711 #define MAX_HW_RESTARTS 5
10712 static int ipw_up(struct ipw_priv *priv)
10713 {
10714 int rc, i, j;
10715
10716 if (priv->status & STATUS_EXIT_PENDING)
10717 return -EIO;
10718
10719 if (cmdlog && !priv->cmdlog) {
10720 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10721 GFP_KERNEL);
10722 if (priv->cmdlog == NULL) {
10723 IPW_ERROR("Error allocating %d command log entries.\n",
10724 cmdlog);
10725 } else {
10726 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10727 priv->cmdlog_len = cmdlog;
10728 }
10729 }
10730
10731 for (i = 0; i < MAX_HW_RESTARTS; i++) {
10732 /* Load the microcode, firmware, and eeprom.
10733 * Also start the clocks. */
10734 rc = ipw_load(priv);
10735 if (rc) {
10736 IPW_ERROR("Unable to load firmware: %d\n", rc);
10737 return rc;
10738 }
10739
10740 ipw_init_ordinals(priv);
10741 if (!(priv->config & CFG_CUSTOM_MAC))
10742 eeprom_parse_mac(priv, priv->mac_addr);
10743 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10744
10745 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10746 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10747 ipw_geos[j].name, 3))
10748 break;
10749 }
10750 if (j == ARRAY_SIZE(ipw_geos)) {
10751 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10752 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10753 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10754 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10755 j = 0;
10756 }
10757 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
10758 IPW_WARNING("Could not set geography.");
10759 return 0;
10760 }
10761
10762 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
10763 j, priv->ieee->geo.name);
10764
10765 if (priv->status & STATUS_RF_KILL_SW) {
10766 IPW_WARNING("Radio disabled by module parameter.\n");
10767 return 0;
10768 } else if (rf_kill_active(priv)) {
10769 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10770 "Kill switch must be turned off for "
10771 "wireless networking to work.\n");
10772 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10773 2 * HZ);
10774 return 0;
10775 }
10776
10777 rc = ipw_config(priv);
10778 if (!rc) {
10779 IPW_DEBUG_INFO("Configured device on count %i\n", i);
10780
10781 /* If configure to try and auto-associate, kick
10782 * off a scan. */
10783 queue_work(priv->workqueue, &priv->request_scan);
10784
10785 return 0;
10786 }
10787
10788 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10789 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10790 i, MAX_HW_RESTARTS);
10791
10792 /* We had an error bringing up the hardware, so take it
10793 * all the way back down so we can try again */
10794 ipw_down(priv);
10795 }
10796
10797 /* tried to restart and config the device for as long as our
10798 * patience could withstand */
10799 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10800
10801 return -EIO;
10802 }
10803
10804 static void ipw_bg_up(void *data)
10805 {
10806 struct ipw_priv *priv = data;
10807 mutex_lock(&priv->mutex);
10808 ipw_up(data);
10809 mutex_unlock(&priv->mutex);
10810 }
10811
10812 static void ipw_deinit(struct ipw_priv *priv)
10813 {
10814 int i;
10815
10816 if (priv->status & STATUS_SCANNING) {
10817 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10818 ipw_abort_scan(priv);
10819 }
10820
10821 if (priv->status & STATUS_ASSOCIATED) {
10822 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10823 ipw_disassociate(priv);
10824 }
10825
10826 ipw_led_shutdown(priv);
10827
10828 /* Wait up to 1s for status to change to not scanning and not
10829 * associated (disassociation can take a while for a ful 802.11
10830 * exchange */
10831 for (i = 1000; i && (priv->status &
10832 (STATUS_DISASSOCIATING |
10833 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10834 udelay(10);
10835
10836 if (priv->status & (STATUS_DISASSOCIATING |
10837 STATUS_ASSOCIATED | STATUS_SCANNING))
10838 IPW_DEBUG_INFO("Still associated or scanning...\n");
10839 else
10840 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10841
10842 /* Attempt to disable the card */
10843 ipw_send_card_disable(priv, 0);
10844
10845 priv->status &= ~STATUS_INIT;
10846 }
10847
10848 static void ipw_down(struct ipw_priv *priv)
10849 {
10850 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10851
10852 priv->status |= STATUS_EXIT_PENDING;
10853
10854 if (ipw_is_init(priv))
10855 ipw_deinit(priv);
10856
10857 /* Wipe out the EXIT_PENDING status bit if we are not actually
10858 * exiting the module */
10859 if (!exit_pending)
10860 priv->status &= ~STATUS_EXIT_PENDING;
10861
10862 /* tell the device to stop sending interrupts */
10863 ipw_disable_interrupts(priv);
10864
10865 /* Clear all bits but the RF Kill */
10866 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10867 netif_carrier_off(priv->net_dev);
10868 netif_stop_queue(priv->net_dev);
10869
10870 ipw_stop_nic(priv);
10871
10872 ipw_led_radio_off(priv);
10873 }
10874
10875 static void ipw_bg_down(void *data)
10876 {
10877 struct ipw_priv *priv = data;
10878 mutex_lock(&priv->mutex);
10879 ipw_down(data);
10880 mutex_unlock(&priv->mutex);
10881 }
10882
10883 /* Called by register_netdev() */
10884 static int ipw_net_init(struct net_device *dev)
10885 {
10886 struct ipw_priv *priv = ieee80211_priv(dev);
10887 mutex_lock(&priv->mutex);
10888
10889 if (ipw_up(priv)) {
10890 mutex_unlock(&priv->mutex);
10891 return -EIO;
10892 }
10893
10894 mutex_unlock(&priv->mutex);
10895 return 0;
10896 }
10897
10898 /* PCI driver stuff */
10899 static struct pci_device_id card_ids[] = {
10900 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10901 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10902 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10903 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10904 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10905 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10906 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10907 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10908 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10909 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10910 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10911 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10912 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10913 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10914 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10915 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10916 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10917 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10918 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10919 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10920 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10921 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10922
10923 /* required last entry */
10924 {0,}
10925 };
10926
10927 MODULE_DEVICE_TABLE(pci, card_ids);
10928
10929 static struct attribute *ipw_sysfs_entries[] = {
10930 &dev_attr_rf_kill.attr,
10931 &dev_attr_direct_dword.attr,
10932 &dev_attr_indirect_byte.attr,
10933 &dev_attr_indirect_dword.attr,
10934 &dev_attr_mem_gpio_reg.attr,
10935 &dev_attr_command_event_reg.attr,
10936 &dev_attr_nic_type.attr,
10937 &dev_attr_status.attr,
10938 &dev_attr_cfg.attr,
10939 &dev_attr_error.attr,
10940 &dev_attr_event_log.attr,
10941 &dev_attr_cmd_log.attr,
10942 &dev_attr_eeprom_delay.attr,
10943 &dev_attr_ucode_version.attr,
10944 &dev_attr_rtc.attr,
10945 &dev_attr_scan_age.attr,
10946 &dev_attr_led.attr,
10947 &dev_attr_speed_scan.attr,
10948 &dev_attr_net_stats.attr,
10949 NULL
10950 };
10951
10952 static struct attribute_group ipw_attribute_group = {
10953 .name = NULL, /* put in device directory */
10954 .attrs = ipw_sysfs_entries,
10955 };
10956
10957 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
10958 {
10959 int err = 0;
10960 struct net_device *net_dev;
10961 void __iomem *base;
10962 u32 length, val;
10963 struct ipw_priv *priv;
10964 int i;
10965
10966 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10967 if (net_dev == NULL) {
10968 err = -ENOMEM;
10969 goto out;
10970 }
10971
10972 priv = ieee80211_priv(net_dev);
10973 priv->ieee = netdev_priv(net_dev);
10974
10975 priv->net_dev = net_dev;
10976 priv->pci_dev = pdev;
10977 #ifdef CONFIG_IPW2200_DEBUG
10978 ipw_debug_level = debug;
10979 #endif
10980 spin_lock_init(&priv->lock);
10981 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10982 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
10983
10984 mutex_init(&priv->mutex);
10985 if (pci_enable_device(pdev)) {
10986 err = -ENODEV;
10987 goto out_free_ieee80211;
10988 }
10989
10990 pci_set_master(pdev);
10991
10992 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
10993 if (!err)
10994 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
10995 if (err) {
10996 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10997 goto out_pci_disable_device;
10998 }
10999
11000 pci_set_drvdata(pdev, priv);
11001
11002 err = pci_request_regions(pdev, DRV_NAME);
11003 if (err)
11004 goto out_pci_disable_device;
11005
11006 /* We disable the RETRY_TIMEOUT register (0x41) to keep
11007 * PCI Tx retries from interfering with C3 CPU state */
11008 pci_read_config_dword(pdev, 0x40, &val);
11009 if ((val & 0x0000ff00) != 0)
11010 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11011
11012 length = pci_resource_len(pdev, 0);
11013 priv->hw_len = length;
11014
11015 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
11016 if (!base) {
11017 err = -ENODEV;
11018 goto out_pci_release_regions;
11019 }
11020
11021 priv->hw_base = base;
11022 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11023 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11024
11025 err = ipw_setup_deferred_work(priv);
11026 if (err) {
11027 IPW_ERROR("Unable to setup deferred work\n");
11028 goto out_iounmap;
11029 }
11030
11031 ipw_sw_reset(priv, 1);
11032
11033 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
11034 if (err) {
11035 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11036 goto out_destroy_workqueue;
11037 }
11038
11039 SET_MODULE_OWNER(net_dev);
11040 SET_NETDEV_DEV(net_dev, &pdev->dev);
11041
11042 mutex_lock(&priv->mutex);
11043
11044 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11045 priv->ieee->set_security = shim__set_security;
11046 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11047
11048 #ifdef CONFIG_IPW_QOS
11049 priv->ieee->handle_probe_response = ipw_handle_beacon;
11050 priv->ieee->handle_beacon = ipw_handle_probe_response;
11051 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11052 #endif /* CONFIG_IPW_QOS */
11053
11054 priv->ieee->perfect_rssi = -20;
11055 priv->ieee->worst_rssi = -85;
11056
11057 net_dev->open = ipw_net_open;
11058 net_dev->stop = ipw_net_stop;
11059 net_dev->init = ipw_net_init;
11060 net_dev->get_stats = ipw_net_get_stats;
11061 net_dev->set_multicast_list = ipw_net_set_multicast_list;
11062 net_dev->set_mac_address = ipw_net_set_mac_address;
11063 priv->wireless_data.spy_data = &priv->ieee->spy_data;
11064 net_dev->wireless_data = &priv->wireless_data;
11065 net_dev->wireless_handlers = &ipw_wx_handler_def;
11066 net_dev->ethtool_ops = &ipw_ethtool_ops;
11067 net_dev->irq = pdev->irq;
11068 net_dev->base_addr = (unsigned long)priv->hw_base;
11069 net_dev->mem_start = pci_resource_start(pdev, 0);
11070 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11071
11072 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11073 if (err) {
11074 IPW_ERROR("failed to create sysfs device attributes\n");
11075 mutex_unlock(&priv->mutex);
11076 goto out_release_irq;
11077 }
11078
11079 mutex_unlock(&priv->mutex);
11080 err = register_netdev(net_dev);
11081 if (err) {
11082 IPW_ERROR("failed to register network device\n");
11083 goto out_remove_sysfs;
11084 }
11085 return 0;
11086
11087 out_remove_sysfs:
11088 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11089 out_release_irq:
11090 free_irq(pdev->irq, priv);
11091 out_destroy_workqueue:
11092 destroy_workqueue(priv->workqueue);
11093 priv->workqueue = NULL;
11094 out_iounmap:
11095 iounmap(priv->hw_base);
11096 out_pci_release_regions:
11097 pci_release_regions(pdev);
11098 out_pci_disable_device:
11099 pci_disable_device(pdev);
11100 pci_set_drvdata(pdev, NULL);
11101 out_free_ieee80211:
11102 free_ieee80211(priv->net_dev);
11103 out:
11104 return err;
11105 }
11106
11107 static void ipw_pci_remove(struct pci_dev *pdev)
11108 {
11109 struct ipw_priv *priv = pci_get_drvdata(pdev);
11110 struct list_head *p, *q;
11111 int i;
11112
11113 if (!priv)
11114 return;
11115
11116 mutex_lock(&priv->mutex);
11117
11118 priv->status |= STATUS_EXIT_PENDING;
11119 ipw_down(priv);
11120 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11121
11122 mutex_unlock(&priv->mutex);
11123
11124 unregister_netdev(priv->net_dev);
11125
11126 if (priv->rxq) {
11127 ipw_rx_queue_free(priv, priv->rxq);
11128 priv->rxq = NULL;
11129 }
11130 ipw_tx_queue_free(priv);
11131
11132 if (priv->cmdlog) {
11133 kfree(priv->cmdlog);
11134 priv->cmdlog = NULL;
11135 }
11136 /* ipw_down will ensure that there is no more pending work
11137 * in the workqueue's, so we can safely remove them now. */
11138 cancel_delayed_work(&priv->adhoc_check);
11139 cancel_delayed_work(&priv->gather_stats);
11140 cancel_delayed_work(&priv->request_scan);
11141 cancel_delayed_work(&priv->rf_kill);
11142 cancel_delayed_work(&priv->scan_check);
11143 destroy_workqueue(priv->workqueue);
11144 priv->workqueue = NULL;
11145
11146 /* Free MAC hash list for ADHOC */
11147 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11148 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11149 list_del(p);
11150 kfree(list_entry(p, struct ipw_ibss_seq, list));
11151 }
11152 }
11153
11154 if (priv->error) {
11155 ipw_free_error_log(priv->error);
11156 priv->error = NULL;
11157 }
11158
11159 free_irq(pdev->irq, priv);
11160 iounmap(priv->hw_base);
11161 pci_release_regions(pdev);
11162 pci_disable_device(pdev);
11163 pci_set_drvdata(pdev, NULL);
11164 free_ieee80211(priv->net_dev);
11165 free_firmware();
11166 }
11167
11168 #ifdef CONFIG_PM
11169 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11170 {
11171 struct ipw_priv *priv = pci_get_drvdata(pdev);
11172 struct net_device *dev = priv->net_dev;
11173
11174 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11175
11176 /* Take down the device; powers it off, etc. */
11177 ipw_down(priv);
11178
11179 /* Remove the PRESENT state of the device */
11180 netif_device_detach(dev);
11181
11182 pci_save_state(pdev);
11183 pci_disable_device(pdev);
11184 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11185
11186 return 0;
11187 }
11188
11189 static int ipw_pci_resume(struct pci_dev *pdev)
11190 {
11191 struct ipw_priv *priv = pci_get_drvdata(pdev);
11192 struct net_device *dev = priv->net_dev;
11193 u32 val;
11194
11195 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11196
11197 pci_set_power_state(pdev, PCI_D0);
11198 pci_enable_device(pdev);
11199 pci_restore_state(pdev);
11200
11201 /*
11202 * Suspend/Resume resets the PCI configuration space, so we have to
11203 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11204 * from interfering with C3 CPU state. pci_restore_state won't help
11205 * here since it only restores the first 64 bytes pci config header.
11206 */
11207 pci_read_config_dword(pdev, 0x40, &val);
11208 if ((val & 0x0000ff00) != 0)
11209 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11210
11211 /* Set the device back into the PRESENT state; this will also wake
11212 * the queue of needed */
11213 netif_device_attach(dev);
11214
11215 /* Bring the device back up */
11216 queue_work(priv->workqueue, &priv->up);
11217
11218 return 0;
11219 }
11220 #endif
11221
11222 /* driver initialization stuff */
11223 static struct pci_driver ipw_driver = {
11224 .name = DRV_NAME,
11225 .id_table = card_ids,
11226 .probe = ipw_pci_probe,
11227 .remove = __devexit_p(ipw_pci_remove),
11228 #ifdef CONFIG_PM
11229 .suspend = ipw_pci_suspend,
11230 .resume = ipw_pci_resume,
11231 #endif
11232 };
11233
11234 static int __init ipw_init(void)
11235 {
11236 int ret;
11237
11238 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11239 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11240
11241 ret = pci_module_init(&ipw_driver);
11242 if (ret) {
11243 IPW_ERROR("Unable to initialize PCI module\n");
11244 return ret;
11245 }
11246
11247 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11248 if (ret) {
11249 IPW_ERROR("Unable to create driver sysfs file\n");
11250 pci_unregister_driver(&ipw_driver);
11251 return ret;
11252 }
11253
11254 return ret;
11255 }
11256
11257 static void __exit ipw_exit(void)
11258 {
11259 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11260 pci_unregister_driver(&ipw_driver);
11261 }
11262
11263 module_param(disable, int, 0444);
11264 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11265
11266 module_param(associate, int, 0444);
11267 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11268
11269 module_param(auto_create, int, 0444);
11270 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11271
11272 module_param(led, int, 0444);
11273 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11274
11275 module_param(debug, int, 0444);
11276 MODULE_PARM_DESC(debug, "debug output mask");
11277
11278 module_param(channel, int, 0444);
11279 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11280
11281 #ifdef CONFIG_IPW_QOS
11282 module_param(qos_enable, int, 0444);
11283 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11284
11285 module_param(qos_burst_enable, int, 0444);
11286 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11287
11288 module_param(qos_no_ack_mask, int, 0444);
11289 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11290
11291 module_param(burst_duration_CCK, int, 0444);
11292 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11293
11294 module_param(burst_duration_OFDM, int, 0444);
11295 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11296 #endif /* CONFIG_IPW_QOS */
11297
11298 #ifdef CONFIG_IPW2200_MONITOR
11299 module_param(mode, int, 0444);
11300 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11301 #else
11302 module_param(mode, int, 0444);
11303 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11304 #endif
11305
11306 module_param(bt_coexist, int, 0444);
11307 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
11308
11309 module_param(hwcrypto, int, 0444);
11310 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
11311
11312 module_param(cmdlog, int, 0444);
11313 MODULE_PARM_DESC(cmdlog,
11314 "allocate a ring buffer for logging firmware commands");
11315
11316 module_param(roaming, int, 0444);
11317 MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
11318
11319 module_exit(ipw_exit);
11320 module_init(ipw_init);
Linux 2.6 libata-dev (mirror)