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