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