1 /******************************************************************************
3 Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
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
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.
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
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.
24 The full GNU General Public License is included in this distribution in the
28 James P. Ketrenos <ipw2100-admin@linux.intel.com>
29 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
31 ******************************************************************************/
34 #include <linux/version.h>
36 #define IPW2200_VERSION "git-1.0.10"
37 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
38 #define DRV_COPYRIGHT "Copyright(c) 2003-2005 Intel Corporation"
39 #define DRV_VERSION IPW2200_VERSION
41 #define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
43 MODULE_DESCRIPTION(DRV_DESCRIPTION);
44 MODULE_VERSION(DRV_VERSION);
45 MODULE_AUTHOR(DRV_COPYRIGHT);
46 MODULE_LICENSE("GPL");
48 static int cmdlog = 0;
50 static int channel = 0;
53 static u32 ipw_debug_level;
54 static int associate = 1;
55 static int auto_create = 1;
57 static int disable = 0;
58 static int bt_coexist = 0;
59 static int hwcrypto = 0;
60 static int roaming = 1;
61 static const char ipw_modes[] = {
66 static int qos_enable = 0;
67 static int qos_burst_enable = 0;
68 static int qos_no_ack_mask = 0;
69 static int burst_duration_CCK = 0;
70 static int burst_duration_OFDM = 0;
72 static struct ieee80211_qos_parameters def_qos_parameters_OFDM = {
73 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
75 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
77 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
78 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
79 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
80 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
83 static struct ieee80211_qos_parameters def_qos_parameters_CCK = {
84 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
86 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
88 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
89 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
90 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
91 QOS_TX3_TXOP_LIMIT_CCK}
94 static struct ieee80211_qos_parameters def_parameters_OFDM = {
95 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
97 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
99 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
100 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
101 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
102 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
105 static struct ieee80211_qos_parameters def_parameters_CCK = {
106 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
108 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
110 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
111 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
112 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
113 DEF_TX3_TXOP_LIMIT_CCK}
116 static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
118 static int from_priority_to_tx_queue[] = {
119 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
120 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
123 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
125 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
127 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
129 #endif /* CONFIG_IPW_QOS */
131 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
132 static void ipw_remove_current_network(struct ipw_priv *priv);
133 static void ipw_rx(struct ipw_priv *priv);
134 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
135 struct clx2_tx_queue *txq, int qindex);
136 static int ipw_queue_reset(struct ipw_priv *priv);
138 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
141 static void ipw_tx_queue_free(struct ipw_priv *);
143 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
144 static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
145 static void ipw_rx_queue_replenish(void *);
146 static int ipw_up(struct ipw_priv *);
147 static void ipw_bg_up(void *);
148 static void ipw_down(struct ipw_priv *);
149 static void ipw_bg_down(void *);
150 static int ipw_config(struct ipw_priv *);
151 static int init_supported_rates(struct ipw_priv *priv,
152 struct ipw_supported_rates *prates);
153 static void ipw_set_hwcrypto_keys(struct ipw_priv *);
154 static void ipw_send_wep_keys(struct ipw_priv *, int);
156 static int snprint_line(char *buf, size_t count,
157 const u8 * data, u32 len, u32 ofs)
162 out = snprintf(buf, count, "%08X", ofs);
164 for (l = 0, i = 0; i < 2; i++) {
165 out += snprintf(buf + out, count - out, " ");
166 for (j = 0; j < 8 && l < len; j++, l++)
167 out += snprintf(buf + out, count - out, "%02X ",
170 out += snprintf(buf + out, count - out, " ");
173 out += snprintf(buf + out, count - out, " ");
174 for (l = 0, i = 0; i < 2; i++) {
175 out += snprintf(buf + out, count - out, " ");
176 for (j = 0; j < 8 && l < len; j++, l++) {
177 c = data[(i * 8 + j)];
178 if (!isascii(c) || !isprint(c))
181 out += snprintf(buf + out, count - out, "%c", c);
185 out += snprintf(buf + out, count - out, " ");
191 static void printk_buf(int level, const u8 * data, u32 len)
195 if (!(ipw_debug_level & level))
199 snprint_line(line, sizeof(line), &data[ofs],
201 printk(KERN_DEBUG "%s\n", line);
203 len -= min(len, 16U);
207 static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
213 while (size && len) {
214 out = snprint_line(output, size, &data[ofs],
215 min_t(size_t, len, 16U), ofs);
220 len -= min_t(size_t, len, 16U);
226 /* alias for 32-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
227 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
228 #define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
230 /* alias for 8-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
231 static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
232 #define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
234 /* 8-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
235 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
236 static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
238 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
239 __LINE__, (u32) (b), (u32) (c));
240 _ipw_write_reg8(a, b, c);
243 /* 16-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
244 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
245 static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
247 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
248 __LINE__, (u32) (b), (u32) (c));
249 _ipw_write_reg16(a, b, c);
252 /* 32-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
253 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
254 static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
256 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
257 __LINE__, (u32) (b), (u32) (c));
258 _ipw_write_reg32(a, b, c);
261 /* 8-bit direct write (low 4K) */
262 #define _ipw_write8(ipw, ofs, val) writeb((val), (ipw)->hw_base + (ofs))
264 /* 8-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
265 #define ipw_write8(ipw, ofs, val) \
266 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
267 _ipw_write8(ipw, ofs, val)
269 /* 16-bit direct write (low 4K) */
270 #define _ipw_write16(ipw, ofs, val) writew((val), (ipw)->hw_base + (ofs))
272 /* 16-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
273 #define ipw_write16(ipw, ofs, val) \
274 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
275 _ipw_write16(ipw, ofs, val)
277 /* 32-bit direct write (low 4K) */
278 #define _ipw_write32(ipw, ofs, val) writel((val), (ipw)->hw_base + (ofs))
280 /* 32-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
281 #define ipw_write32(ipw, ofs, val) \
282 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
283 _ipw_write32(ipw, ofs, val)
285 /* 8-bit direct read (low 4K) */
286 #define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
288 /* 8-bit direct read (low 4K), with debug wrapper */
289 static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
291 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
292 return _ipw_read8(ipw, ofs);
295 /* alias to 8-bit direct read (low 4K of SRAM/regs), with debug wrapper */
296 #define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)
298 /* 16-bit direct read (low 4K) */
299 #define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
301 /* 16-bit direct read (low 4K), with debug wrapper */
302 static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
304 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
305 return _ipw_read16(ipw, ofs);
308 /* alias to 16-bit direct read (low 4K of SRAM/regs), with debug wrapper */
309 #define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)
311 /* 32-bit direct read (low 4K) */
312 #define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
314 /* 32-bit direct read (low 4K), with debug wrapper */
315 static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
317 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
318 return _ipw_read32(ipw, ofs);
321 /* alias to 32-bit direct read (low 4K of SRAM/regs), with debug wrapper */
322 #define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
324 /* multi-byte read (above 4K), with debug wrapper */
325 static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
326 static inline void __ipw_read_indirect(const char *f, int l,
327 struct ipw_priv *a, u32 b, u8 * c, int d)
329 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
331 _ipw_read_indirect(a, b, c, d);
334 /* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
335 #define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
337 /* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
338 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
340 #define ipw_write_indirect(a, b, c, d) \
341 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
342 _ipw_write_indirect(a, b, c, d)
344 /* 32-bit indirect write (above 4K) */
345 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
347 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
348 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
349 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
352 /* 8-bit indirect write (above 4K) */
353 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
355 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
356 u32 dif_len = reg - aligned_addr;
358 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
359 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
360 _ipw_write8(priv, IPW_INDIRECT_DATA + dif_len, value);
363 /* 16-bit indirect write (above 4K) */
364 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
366 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
367 u32 dif_len = (reg - aligned_addr) & (~0x1ul);
369 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
370 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
371 _ipw_write16(priv, IPW_INDIRECT_DATA + dif_len, value);
374 /* 8-bit indirect read (above 4K) */
375 static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
378 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
379 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
380 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
381 return (word >> ((reg & 0x3) * 8)) & 0xff;
384 /* 32-bit indirect read (above 4K) */
385 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
389 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
391 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
392 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
393 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
397 /* General purpose, no alignment requirement, iterative (multi-byte) read, */
398 /* for area above 1st 4K of SRAM/reg space */
399 static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
402 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
403 u32 dif_len = addr - aligned_addr;
406 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
412 /* Read the first dword (or portion) byte by byte */
413 if (unlikely(dif_len)) {
414 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
415 /* Start reading at aligned_addr + dif_len */
416 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
417 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
421 /* Read all of the middle dwords as dwords, with auto-increment */
422 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
423 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
424 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
426 /* Read the last dword (or portion) byte by byte */
428 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
429 for (i = 0; num > 0; i++, num--)
430 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
434 /* General purpose, no alignment requirement, iterative (multi-byte) write, */
435 /* for area above 1st 4K of SRAM/reg space */
436 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
439 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
440 u32 dif_len = addr - aligned_addr;
443 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
449 /* Write the first dword (or portion) byte by byte */
450 if (unlikely(dif_len)) {
451 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
452 /* Start writing at aligned_addr + dif_len */
453 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
454 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
458 /* Write all of the middle dwords as dwords, with auto-increment */
459 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
460 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
461 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
463 /* Write the last dword (or portion) byte by byte */
465 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
466 for (i = 0; num > 0; i++, num--, buf++)
467 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
471 /* General purpose, no alignment requirement, iterative (multi-byte) write, */
472 /* for 1st 4K of SRAM/regs space */
473 static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
476 memcpy_toio((priv->hw_base + addr), buf, num);
479 /* Set bit(s) in low 4K of SRAM/regs */
480 static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
482 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
485 /* Clear bit(s) in low 4K of SRAM/regs */
486 static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
488 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
491 static inline void ipw_enable_interrupts(struct ipw_priv *priv)
493 if (priv->status & STATUS_INT_ENABLED)
495 priv->status |= STATUS_INT_ENABLED;
496 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
499 static inline void ipw_disable_interrupts(struct ipw_priv *priv)
501 if (!(priv->status & STATUS_INT_ENABLED))
503 priv->status &= ~STATUS_INT_ENABLED;
504 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
507 #ifdef CONFIG_IPW2200_DEBUG
508 static char *ipw_error_desc(u32 val)
511 case IPW_FW_ERROR_OK:
513 case IPW_FW_ERROR_FAIL:
515 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
516 return "MEMORY_UNDERFLOW";
517 case IPW_FW_ERROR_MEMORY_OVERFLOW:
518 return "MEMORY_OVERFLOW";
519 case IPW_FW_ERROR_BAD_PARAM:
521 case IPW_FW_ERROR_BAD_CHECKSUM:
522 return "BAD_CHECKSUM";
523 case IPW_FW_ERROR_NMI_INTERRUPT:
524 return "NMI_INTERRUPT";
525 case IPW_FW_ERROR_BAD_DATABASE:
526 return "BAD_DATABASE";
527 case IPW_FW_ERROR_ALLOC_FAIL:
529 case IPW_FW_ERROR_DMA_UNDERRUN:
530 return "DMA_UNDERRUN";
531 case IPW_FW_ERROR_DMA_STATUS:
533 case IPW_FW_ERROR_DINO_ERROR:
535 case IPW_FW_ERROR_EEPROM_ERROR:
536 return "EEPROM_ERROR";
537 case IPW_FW_ERROR_SYSASSERT:
539 case IPW_FW_ERROR_FATAL_ERROR:
540 return "FATAL_ERROR";
542 return "UNKNOWN_ERROR";
546 static void ipw_dump_error_log(struct ipw_priv *priv,
547 struct ipw_fw_error *error)
552 IPW_ERROR("Error allocating and capturing error log. "
553 "Nothing to dump.\n");
557 IPW_ERROR("Start IPW Error Log Dump:\n");
558 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
559 error->status, error->config);
561 for (i = 0; i < error->elem_len; i++)
562 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
563 ipw_error_desc(error->elem[i].desc),
565 error->elem[i].blink1,
566 error->elem[i].blink2,
567 error->elem[i].link1,
568 error->elem[i].link2, error->elem[i].data);
569 for (i = 0; i < error->log_len; i++)
570 IPW_ERROR("%i\t0x%08x\t%i\n",
572 error->log[i].data, error->log[i].event);
576 static inline int ipw_is_init(struct ipw_priv *priv)
578 return (priv->status & STATUS_INIT) ? 1 : 0;
581 static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
583 u32 addr, field_info, field_len, field_count, total_len;
585 IPW_DEBUG_ORD("ordinal = %i\n", ord);
587 if (!priv || !val || !len) {
588 IPW_DEBUG_ORD("Invalid argument\n");
592 /* verify device ordinal tables have been initialized */
593 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
594 IPW_DEBUG_ORD("Access ordinals before initialization\n");
598 switch (IPW_ORD_TABLE_ID_MASK & ord) {
599 case IPW_ORD_TABLE_0_MASK:
601 * TABLE 0: Direct access to a table of 32 bit values
603 * This is a very simple table with the data directly
604 * read from the table
607 /* remove the table id from the ordinal */
608 ord &= IPW_ORD_TABLE_VALUE_MASK;
611 if (ord > priv->table0_len) {
612 IPW_DEBUG_ORD("ordinal value (%i) longer then "
613 "max (%i)\n", ord, priv->table0_len);
617 /* verify we have enough room to store the value */
618 if (*len < sizeof(u32)) {
619 IPW_DEBUG_ORD("ordinal buffer length too small, "
620 "need %zd\n", sizeof(u32));
624 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
625 ord, priv->table0_addr + (ord << 2));
629 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
632 case IPW_ORD_TABLE_1_MASK:
634 * TABLE 1: Indirect access to a table of 32 bit values
636 * This is a fairly large table of u32 values each
637 * representing starting addr for the data (which is
641 /* remove the table id from the ordinal */
642 ord &= IPW_ORD_TABLE_VALUE_MASK;
645 if (ord > priv->table1_len) {
646 IPW_DEBUG_ORD("ordinal value too long\n");
650 /* verify we have enough room to store the value */
651 if (*len < sizeof(u32)) {
652 IPW_DEBUG_ORD("ordinal buffer length too small, "
653 "need %zd\n", sizeof(u32));
658 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
662 case IPW_ORD_TABLE_2_MASK:
664 * TABLE 2: Indirect access to a table of variable sized values
666 * This table consist of six values, each containing
667 * - dword containing the starting offset of the data
668 * - dword containing the lengh in the first 16bits
669 * and the count in the second 16bits
672 /* remove the table id from the ordinal */
673 ord &= IPW_ORD_TABLE_VALUE_MASK;
676 if (ord > priv->table2_len) {
677 IPW_DEBUG_ORD("ordinal value too long\n");
681 /* get the address of statistic */
682 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
684 /* get the second DW of statistics ;
685 * two 16-bit words - first is length, second is count */
688 priv->table2_addr + (ord << 3) +
691 /* get each entry length */
692 field_len = *((u16 *) & field_info);
694 /* get number of entries */
695 field_count = *(((u16 *) & field_info) + 1);
697 /* abort if not enought memory */
698 total_len = field_len * field_count;
699 if (total_len > *len) {
708 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
709 "field_info = 0x%08x\n",
710 addr, total_len, field_info);
711 ipw_read_indirect(priv, addr, val, total_len);
715 IPW_DEBUG_ORD("Invalid ordinal!\n");
723 static void ipw_init_ordinals(struct ipw_priv *priv)
725 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
726 priv->table0_len = ipw_read32(priv, priv->table0_addr);
728 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
729 priv->table0_addr, priv->table0_len);
731 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
732 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
734 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
735 priv->table1_addr, priv->table1_len);
737 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
738 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
739 priv->table2_len &= 0x0000ffff; /* use first two bytes */
741 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
742 priv->table2_addr, priv->table2_len);
746 static u32 ipw_register_toggle(u32 reg)
748 reg &= ~IPW_START_STANDBY;
749 if (reg & IPW_GATE_ODMA)
750 reg &= ~IPW_GATE_ODMA;
751 if (reg & IPW_GATE_IDMA)
752 reg &= ~IPW_GATE_IDMA;
753 if (reg & IPW_GATE_ADMA)
754 reg &= ~IPW_GATE_ADMA;
760 * - On radio ON, turn on any LEDs that require to be on during start
761 * - On initialization, start unassociated blink
762 * - On association, disable unassociated blink
763 * - On disassociation, start unassociated blink
764 * - On radio OFF, turn off any LEDs started during radio on
767 #define LD_TIME_LINK_ON msecs_to_jiffies(300)
768 #define LD_TIME_LINK_OFF msecs_to_jiffies(2700)
769 #define LD_TIME_ACT_ON msecs_to_jiffies(250)
771 static void ipw_led_link_on(struct ipw_priv *priv)
776 /* If configured to not use LEDs, or nic_type is 1,
777 * then we don't toggle a LINK led */
778 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
781 spin_lock_irqsave(&priv->lock, flags);
783 if (!(priv->status & STATUS_RF_KILL_MASK) &&
784 !(priv->status & STATUS_LED_LINK_ON)) {
785 IPW_DEBUG_LED("Link LED On\n");
786 led = ipw_read_reg32(priv, IPW_EVENT_REG);
787 led |= priv->led_association_on;
789 led = ipw_register_toggle(led);
791 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
792 ipw_write_reg32(priv, IPW_EVENT_REG, led);
794 priv->status |= STATUS_LED_LINK_ON;
796 /* If we aren't associated, schedule turning the LED off */
797 if (!(priv->status & STATUS_ASSOCIATED))
798 queue_delayed_work(priv->workqueue,
803 spin_unlock_irqrestore(&priv->lock, flags);
806 static void ipw_bg_led_link_on(void *data)
808 struct ipw_priv *priv = data;
809 mutex_lock(&priv->mutex);
810 ipw_led_link_on(data);
811 mutex_unlock(&priv->mutex);
814 static void ipw_led_link_off(struct ipw_priv *priv)
819 /* If configured not to use LEDs, or nic type is 1,
820 * then we don't goggle the LINK led. */
821 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
824 spin_lock_irqsave(&priv->lock, flags);
826 if (priv->status & STATUS_LED_LINK_ON) {
827 led = ipw_read_reg32(priv, IPW_EVENT_REG);
828 led &= priv->led_association_off;
829 led = ipw_register_toggle(led);
831 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
832 ipw_write_reg32(priv, IPW_EVENT_REG, led);
834 IPW_DEBUG_LED("Link LED Off\n");
836 priv->status &= ~STATUS_LED_LINK_ON;
838 /* If we aren't associated and the radio is on, schedule
839 * turning the LED on (blink while unassociated) */
840 if (!(priv->status & STATUS_RF_KILL_MASK) &&
841 !(priv->status & STATUS_ASSOCIATED))
842 queue_delayed_work(priv->workqueue, &priv->led_link_on,
847 spin_unlock_irqrestore(&priv->lock, flags);
850 static void ipw_bg_led_link_off(void *data)
852 struct ipw_priv *priv = data;
853 mutex_lock(&priv->mutex);
854 ipw_led_link_off(data);
855 mutex_unlock(&priv->mutex);
858 static void __ipw_led_activity_on(struct ipw_priv *priv)
862 if (priv->config & CFG_NO_LED)
865 if (priv->status & STATUS_RF_KILL_MASK)
868 if (!(priv->status & STATUS_LED_ACT_ON)) {
869 led = ipw_read_reg32(priv, IPW_EVENT_REG);
870 led |= priv->led_activity_on;
872 led = ipw_register_toggle(led);
874 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
875 ipw_write_reg32(priv, IPW_EVENT_REG, led);
877 IPW_DEBUG_LED("Activity LED On\n");
879 priv->status |= STATUS_LED_ACT_ON;
881 cancel_delayed_work(&priv->led_act_off);
882 queue_delayed_work(priv->workqueue, &priv->led_act_off,
885 /* Reschedule LED off for full time period */
886 cancel_delayed_work(&priv->led_act_off);
887 queue_delayed_work(priv->workqueue, &priv->led_act_off,
893 void ipw_led_activity_on(struct ipw_priv *priv)
896 spin_lock_irqsave(&priv->lock, flags);
897 __ipw_led_activity_on(priv);
898 spin_unlock_irqrestore(&priv->lock, flags);
902 static void ipw_led_activity_off(struct ipw_priv *priv)
907 if (priv->config & CFG_NO_LED)
910 spin_lock_irqsave(&priv->lock, flags);
912 if (priv->status & STATUS_LED_ACT_ON) {
913 led = ipw_read_reg32(priv, IPW_EVENT_REG);
914 led &= priv->led_activity_off;
916 led = ipw_register_toggle(led);
918 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
919 ipw_write_reg32(priv, IPW_EVENT_REG, led);
921 IPW_DEBUG_LED("Activity LED Off\n");
923 priv->status &= ~STATUS_LED_ACT_ON;
926 spin_unlock_irqrestore(&priv->lock, flags);
929 static void ipw_bg_led_activity_off(void *data)
931 struct ipw_priv *priv = data;
932 mutex_lock(&priv->mutex);
933 ipw_led_activity_off(data);
934 mutex_unlock(&priv->mutex);
937 static void ipw_led_band_on(struct ipw_priv *priv)
942 /* Only nic type 1 supports mode LEDs */
943 if (priv->config & CFG_NO_LED ||
944 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
947 spin_lock_irqsave(&priv->lock, flags);
949 led = ipw_read_reg32(priv, IPW_EVENT_REG);
950 if (priv->assoc_network->mode == IEEE_A) {
951 led |= priv->led_ofdm_on;
952 led &= priv->led_association_off;
953 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
954 } else if (priv->assoc_network->mode == IEEE_G) {
955 led |= priv->led_ofdm_on;
956 led |= priv->led_association_on;
957 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
959 led &= priv->led_ofdm_off;
960 led |= priv->led_association_on;
961 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
964 led = ipw_register_toggle(led);
966 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
967 ipw_write_reg32(priv, IPW_EVENT_REG, led);
969 spin_unlock_irqrestore(&priv->lock, flags);
972 static void ipw_led_band_off(struct ipw_priv *priv)
977 /* Only nic type 1 supports mode LEDs */
978 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
981 spin_lock_irqsave(&priv->lock, flags);
983 led = ipw_read_reg32(priv, IPW_EVENT_REG);
984 led &= priv->led_ofdm_off;
985 led &= priv->led_association_off;
987 led = ipw_register_toggle(led);
989 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
990 ipw_write_reg32(priv, IPW_EVENT_REG, led);
992 spin_unlock_irqrestore(&priv->lock, flags);
995 static void ipw_led_radio_on(struct ipw_priv *priv)
997 ipw_led_link_on(priv);
1000 static void ipw_led_radio_off(struct ipw_priv *priv)
1002 ipw_led_activity_off(priv);
1003 ipw_led_link_off(priv);
1006 static void ipw_led_link_up(struct ipw_priv *priv)
1008 /* Set the Link Led on for all nic types */
1009 ipw_led_link_on(priv);
1012 static void ipw_led_link_down(struct ipw_priv *priv)
1014 ipw_led_activity_off(priv);
1015 ipw_led_link_off(priv);
1017 if (priv->status & STATUS_RF_KILL_MASK)
1018 ipw_led_radio_off(priv);
1021 static void ipw_led_init(struct ipw_priv *priv)
1023 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1025 /* Set the default PINs for the link and activity leds */
1026 priv->led_activity_on = IPW_ACTIVITY_LED;
1027 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
1029 priv->led_association_on = IPW_ASSOCIATED_LED;
1030 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
1032 /* Set the default PINs for the OFDM leds */
1033 priv->led_ofdm_on = IPW_OFDM_LED;
1034 priv->led_ofdm_off = ~(IPW_OFDM_LED);
1036 switch (priv->nic_type) {
1037 case EEPROM_NIC_TYPE_1:
1038 /* In this NIC type, the LEDs are reversed.... */
1039 priv->led_activity_on = IPW_ASSOCIATED_LED;
1040 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1041 priv->led_association_on = IPW_ACTIVITY_LED;
1042 priv->led_association_off = ~(IPW_ACTIVITY_LED);
1044 if (!(priv->config & CFG_NO_LED))
1045 ipw_led_band_on(priv);
1047 /* And we don't blink link LEDs for this nic, so
1048 * just return here */
1051 case EEPROM_NIC_TYPE_3:
1052 case EEPROM_NIC_TYPE_2:
1053 case EEPROM_NIC_TYPE_4:
1054 case EEPROM_NIC_TYPE_0:
1058 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1060 priv->nic_type = EEPROM_NIC_TYPE_0;
1064 if (!(priv->config & CFG_NO_LED)) {
1065 if (priv->status & STATUS_ASSOCIATED)
1066 ipw_led_link_on(priv);
1068 ipw_led_link_off(priv);
1072 static void ipw_led_shutdown(struct ipw_priv *priv)
1074 ipw_led_activity_off(priv);
1075 ipw_led_link_off(priv);
1076 ipw_led_band_off(priv);
1077 cancel_delayed_work(&priv->led_link_on);
1078 cancel_delayed_work(&priv->led_link_off);
1079 cancel_delayed_work(&priv->led_act_off);
1083 * The following adds a new attribute to the sysfs representation
1084 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1085 * used for controling the debug level.
1087 * See the level definitions in ipw for details.
1089 static ssize_t show_debug_level(struct device_driver *d, char *buf)
1091 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1094 static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1097 char *p = (char *)buf;
1100 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1102 if (p[0] == 'x' || p[0] == 'X')
1104 val = simple_strtoul(p, &p, 16);
1106 val = simple_strtoul(p, &p, 10);
1108 printk(KERN_INFO DRV_NAME
1109 ": %s is not in hex or decimal form.\n", buf);
1111 ipw_debug_level = val;
1113 return strnlen(buf, count);
1116 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
1117 show_debug_level, store_debug_level);
1119 static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
1121 /* length = 1st dword in log */
1122 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
1125 static void ipw_capture_event_log(struct ipw_priv *priv,
1126 u32 log_len, struct ipw_event *log)
1131 base = ipw_read32(priv, IPW_EVENT_LOG);
1132 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1133 (u8 *) log, sizeof(*log) * log_len);
1137 static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
1139 struct ipw_fw_error *error;
1140 u32 log_len = ipw_get_event_log_len(priv);
1141 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1142 u32 elem_len = ipw_read_reg32(priv, base);
1144 error = kmalloc(sizeof(*error) +
1145 sizeof(*error->elem) * elem_len +
1146 sizeof(*error->log) * log_len, GFP_ATOMIC);
1148 IPW_ERROR("Memory allocation for firmware error log "
1152 error->jiffies = jiffies;
1153 error->status = priv->status;
1154 error->config = priv->config;
1155 error->elem_len = elem_len;
1156 error->log_len = log_len;
1157 error->elem = (struct ipw_error_elem *)error->payload;
1158 error->log = (struct ipw_event *)(error->elem + elem_len);
1160 ipw_capture_event_log(priv, log_len, error->log);
1163 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1164 sizeof(*error->elem) * elem_len);
1169 static void ipw_free_error_log(struct ipw_fw_error *error)
1175 static ssize_t show_event_log(struct device *d,
1176 struct device_attribute *attr, char *buf)
1178 struct ipw_priv *priv = dev_get_drvdata(d);
1179 u32 log_len = ipw_get_event_log_len(priv);
1180 struct ipw_event log[log_len];
1183 ipw_capture_event_log(priv, log_len, log);
1185 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1186 for (i = 0; i < log_len; i++)
1187 len += snprintf(buf + len, PAGE_SIZE - len,
1189 log[i].time, log[i].event, log[i].data);
1190 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1194 static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
1196 static ssize_t show_error(struct device *d,
1197 struct device_attribute *attr, char *buf)
1199 struct ipw_priv *priv = dev_get_drvdata(d);
1203 len += snprintf(buf + len, PAGE_SIZE - len,
1204 "%08lX%08X%08X%08X",
1205 priv->error->jiffies,
1206 priv->error->status,
1207 priv->error->config, priv->error->elem_len);
1208 for (i = 0; i < priv->error->elem_len; i++)
1209 len += snprintf(buf + len, PAGE_SIZE - len,
1210 "\n%08X%08X%08X%08X%08X%08X%08X",
1211 priv->error->elem[i].time,
1212 priv->error->elem[i].desc,
1213 priv->error->elem[i].blink1,
1214 priv->error->elem[i].blink2,
1215 priv->error->elem[i].link1,
1216 priv->error->elem[i].link2,
1217 priv->error->elem[i].data);
1219 len += snprintf(buf + len, PAGE_SIZE - len,
1220 "\n%08X", priv->error->log_len);
1221 for (i = 0; i < priv->error->log_len; i++)
1222 len += snprintf(buf + len, PAGE_SIZE - len,
1224 priv->error->log[i].time,
1225 priv->error->log[i].event,
1226 priv->error->log[i].data);
1227 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1231 static ssize_t clear_error(struct device *d,
1232 struct device_attribute *attr,
1233 const char *buf, size_t count)
1235 struct ipw_priv *priv = dev_get_drvdata(d);
1237 ipw_free_error_log(priv->error);
1243 static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
1245 static ssize_t show_cmd_log(struct device *d,
1246 struct device_attribute *attr, char *buf)
1248 struct ipw_priv *priv = dev_get_drvdata(d);
1252 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1253 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1254 i = (i + 1) % priv->cmdlog_len) {
1256 snprintf(buf + len, PAGE_SIZE - len,
1257 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1258 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1259 priv->cmdlog[i].cmd.len);
1261 snprintk_buf(buf + len, PAGE_SIZE - len,
1262 (u8 *) priv->cmdlog[i].cmd.param,
1263 priv->cmdlog[i].cmd.len);
1264 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1266 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1270 static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
1272 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1275 struct ipw_priv *priv = dev_get_drvdata(d);
1276 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1279 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1280 const char *buf, size_t count)
1282 struct ipw_priv *priv = dev_get_drvdata(d);
1283 #ifdef CONFIG_IPW2200_DEBUG
1284 struct net_device *dev = priv->net_dev;
1286 char buffer[] = "00000000";
1288 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1292 IPW_DEBUG_INFO("enter\n");
1294 strncpy(buffer, buf, len);
1297 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1299 if (p[0] == 'x' || p[0] == 'X')
1301 val = simple_strtoul(p, &p, 16);
1303 val = simple_strtoul(p, &p, 10);
1305 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1307 priv->ieee->scan_age = val;
1308 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1311 IPW_DEBUG_INFO("exit\n");
1315 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1317 static ssize_t show_led(struct device *d, struct device_attribute *attr,
1320 struct ipw_priv *priv = dev_get_drvdata(d);
1321 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1324 static ssize_t store_led(struct device *d, struct device_attribute *attr,
1325 const char *buf, size_t count)
1327 struct ipw_priv *priv = dev_get_drvdata(d);
1329 IPW_DEBUG_INFO("enter\n");
1335 IPW_DEBUG_LED("Disabling LED control.\n");
1336 priv->config |= CFG_NO_LED;
1337 ipw_led_shutdown(priv);
1339 IPW_DEBUG_LED("Enabling LED control.\n");
1340 priv->config &= ~CFG_NO_LED;
1344 IPW_DEBUG_INFO("exit\n");
1348 static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1350 static ssize_t show_status(struct device *d,
1351 struct device_attribute *attr, char *buf)
1353 struct ipw_priv *p = d->driver_data;
1354 return sprintf(buf, "0x%08x\n", (int)p->status);
1357 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1359 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1362 struct ipw_priv *p = d->driver_data;
1363 return sprintf(buf, "0x%08x\n", (int)p->config);
1366 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1368 static ssize_t show_nic_type(struct device *d,
1369 struct device_attribute *attr, char *buf)
1371 struct ipw_priv *priv = d->driver_data;
1372 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1375 static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1377 static ssize_t show_ucode_version(struct device *d,
1378 struct device_attribute *attr, char *buf)
1380 u32 len = sizeof(u32), tmp = 0;
1381 struct ipw_priv *p = d->driver_data;
1383 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
1386 return sprintf(buf, "0x%08x\n", tmp);
1389 static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
1391 static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1394 u32 len = sizeof(u32), tmp = 0;
1395 struct ipw_priv *p = d->driver_data;
1397 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
1400 return sprintf(buf, "0x%08x\n", tmp);
1403 static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
1406 * Add a device attribute to view/control the delay between eeprom
1409 static ssize_t show_eeprom_delay(struct device *d,
1410 struct device_attribute *attr, char *buf)
1412 int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
1413 return sprintf(buf, "%i\n", n);
1415 static ssize_t store_eeprom_delay(struct device *d,
1416 struct device_attribute *attr,
1417 const char *buf, size_t count)
1419 struct ipw_priv *p = d->driver_data;
1420 sscanf(buf, "%i", &p->eeprom_delay);
1421 return strnlen(buf, count);
1424 static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1425 show_eeprom_delay, store_eeprom_delay);
1427 static ssize_t show_command_event_reg(struct device *d,
1428 struct device_attribute *attr, char *buf)
1431 struct ipw_priv *p = d->driver_data;
1433 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
1434 return sprintf(buf, "0x%08x\n", reg);
1436 static ssize_t store_command_event_reg(struct device *d,
1437 struct device_attribute *attr,
1438 const char *buf, size_t count)
1441 struct ipw_priv *p = d->driver_data;
1443 sscanf(buf, "%x", ®);
1444 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
1445 return strnlen(buf, count);
1448 static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1449 show_command_event_reg, store_command_event_reg);
1451 static ssize_t show_mem_gpio_reg(struct device *d,
1452 struct device_attribute *attr, char *buf)
1455 struct ipw_priv *p = d->driver_data;
1457 reg = ipw_read_reg32(p, 0x301100);
1458 return sprintf(buf, "0x%08x\n", reg);
1460 static ssize_t store_mem_gpio_reg(struct device *d,
1461 struct device_attribute *attr,
1462 const char *buf, size_t count)
1465 struct ipw_priv *p = d->driver_data;
1467 sscanf(buf, "%x", ®);
1468 ipw_write_reg32(p, 0x301100, reg);
1469 return strnlen(buf, count);
1472 static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1473 show_mem_gpio_reg, store_mem_gpio_reg);
1475 static ssize_t show_indirect_dword(struct device *d,
1476 struct device_attribute *attr, char *buf)
1479 struct ipw_priv *priv = d->driver_data;
1481 if (priv->status & STATUS_INDIRECT_DWORD)
1482 reg = ipw_read_reg32(priv, priv->indirect_dword);
1486 return sprintf(buf, "0x%08x\n", reg);
1488 static ssize_t store_indirect_dword(struct device *d,
1489 struct device_attribute *attr,
1490 const char *buf, size_t count)
1492 struct ipw_priv *priv = d->driver_data;
1494 sscanf(buf, "%x", &priv->indirect_dword);
1495 priv->status |= STATUS_INDIRECT_DWORD;
1496 return strnlen(buf, count);
1499 static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1500 show_indirect_dword, store_indirect_dword);
1502 static ssize_t show_indirect_byte(struct device *d,
1503 struct device_attribute *attr, char *buf)
1506 struct ipw_priv *priv = d->driver_data;
1508 if (priv->status & STATUS_INDIRECT_BYTE)
1509 reg = ipw_read_reg8(priv, priv->indirect_byte);
1513 return sprintf(buf, "0x%02x\n", reg);
1515 static ssize_t store_indirect_byte(struct device *d,
1516 struct device_attribute *attr,
1517 const char *buf, size_t count)
1519 struct ipw_priv *priv = d->driver_data;
1521 sscanf(buf, "%x", &priv->indirect_byte);
1522 priv->status |= STATUS_INDIRECT_BYTE;
1523 return strnlen(buf, count);
1526 static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
1527 show_indirect_byte, store_indirect_byte);
1529 static ssize_t show_direct_dword(struct device *d,
1530 struct device_attribute *attr, char *buf)
1533 struct ipw_priv *priv = d->driver_data;
1535 if (priv->status & STATUS_DIRECT_DWORD)
1536 reg = ipw_read32(priv, priv->direct_dword);
1540 return sprintf(buf, "0x%08x\n", reg);
1542 static ssize_t store_direct_dword(struct device *d,
1543 struct device_attribute *attr,
1544 const char *buf, size_t count)
1546 struct ipw_priv *priv = d->driver_data;
1548 sscanf(buf, "%x", &priv->direct_dword);
1549 priv->status |= STATUS_DIRECT_DWORD;
1550 return strnlen(buf, count);
1553 static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1554 show_direct_dword, store_direct_dword);
1556 static int rf_kill_active(struct ipw_priv *priv)
1558 if (0 == (ipw_read32(priv, 0x30) & 0x10000))
1559 priv->status |= STATUS_RF_KILL_HW;
1561 priv->status &= ~STATUS_RF_KILL_HW;
1563 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1566 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
1569 /* 0 - RF kill not enabled
1570 1 - SW based RF kill active (sysfs)
1571 2 - HW based RF kill active
1572 3 - Both HW and SW baed RF kill active */
1573 struct ipw_priv *priv = d->driver_data;
1574 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1575 (rf_kill_active(priv) ? 0x2 : 0x0);
1576 return sprintf(buf, "%i\n", val);
1579 static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1581 if ((disable_radio ? 1 : 0) ==
1582 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1585 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1586 disable_radio ? "OFF" : "ON");
1588 if (disable_radio) {
1589 priv->status |= STATUS_RF_KILL_SW;
1591 if (priv->workqueue)
1592 cancel_delayed_work(&priv->request_scan);
1593 queue_work(priv->workqueue, &priv->down);
1595 priv->status &= ~STATUS_RF_KILL_SW;
1596 if (rf_kill_active(priv)) {
1597 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1598 "disabled by HW switch\n");
1599 /* Make sure the RF_KILL check timer is running */
1600 cancel_delayed_work(&priv->rf_kill);
1601 queue_delayed_work(priv->workqueue, &priv->rf_kill,
1604 queue_work(priv->workqueue, &priv->up);
1610 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1611 const char *buf, size_t count)
1613 struct ipw_priv *priv = d->driver_data;
1615 ipw_radio_kill_sw(priv, buf[0] == '1');
1620 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
1622 static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1625 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1626 int pos = 0, len = 0;
1627 if (priv->config & CFG_SPEED_SCAN) {
1628 while (priv->speed_scan[pos] != 0)
1629 len += sprintf(&buf[len], "%d ",
1630 priv->speed_scan[pos++]);
1631 return len + sprintf(&buf[len], "\n");
1634 return sprintf(buf, "0\n");
1637 static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1638 const char *buf, size_t count)
1640 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1641 int channel, pos = 0;
1642 const char *p = buf;
1644 /* list of space separated channels to scan, optionally ending with 0 */
1645 while ((channel = simple_strtol(p, NULL, 0))) {
1646 if (pos == MAX_SPEED_SCAN - 1) {
1647 priv->speed_scan[pos] = 0;
1651 if (ieee80211_is_valid_channel(priv->ieee, channel))
1652 priv->speed_scan[pos++] = channel;
1654 IPW_WARNING("Skipping invalid channel request: %d\n",
1659 while (*p == ' ' || *p == '\t')
1664 priv->config &= ~CFG_SPEED_SCAN;
1666 priv->speed_scan_pos = 0;
1667 priv->config |= CFG_SPEED_SCAN;
1673 static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1676 static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1679 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1680 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1683 static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1684 const char *buf, size_t count)
1686 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1688 priv->config |= CFG_NET_STATS;
1690 priv->config &= ~CFG_NET_STATS;
1695 static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1696 show_net_stats, store_net_stats);
1698 static void notify_wx_assoc_event(struct ipw_priv *priv)
1700 union iwreq_data wrqu;
1701 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1702 if (priv->status & STATUS_ASSOCIATED)
1703 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1705 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1706 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1709 static void ipw_irq_tasklet(struct ipw_priv *priv)
1711 u32 inta, inta_mask, handled = 0;
1712 unsigned long flags;
1715 spin_lock_irqsave(&priv->lock, flags);
1717 inta = ipw_read32(priv, IPW_INTA_RW);
1718 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1719 inta &= (IPW_INTA_MASK_ALL & inta_mask);
1721 /* Add any cached INTA values that need to be handled */
1722 inta |= priv->isr_inta;
1724 /* handle all the justifications for the interrupt */
1725 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1727 handled |= IPW_INTA_BIT_RX_TRANSFER;
1730 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1731 IPW_DEBUG_HC("Command completed.\n");
1732 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1733 priv->status &= ~STATUS_HCMD_ACTIVE;
1734 wake_up_interruptible(&priv->wait_command_queue);
1735 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1738 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
1739 IPW_DEBUG_TX("TX_QUEUE_1\n");
1740 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1741 handled |= IPW_INTA_BIT_TX_QUEUE_1;
1744 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
1745 IPW_DEBUG_TX("TX_QUEUE_2\n");
1746 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1747 handled |= IPW_INTA_BIT_TX_QUEUE_2;
1750 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
1751 IPW_DEBUG_TX("TX_QUEUE_3\n");
1752 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1753 handled |= IPW_INTA_BIT_TX_QUEUE_3;
1756 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
1757 IPW_DEBUG_TX("TX_QUEUE_4\n");
1758 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
1759 handled |= IPW_INTA_BIT_TX_QUEUE_4;
1762 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
1763 IPW_WARNING("STATUS_CHANGE\n");
1764 handled |= IPW_INTA_BIT_STATUS_CHANGE;
1767 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
1768 IPW_WARNING("TX_PERIOD_EXPIRED\n");
1769 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
1772 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
1773 IPW_WARNING("HOST_CMD_DONE\n");
1774 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
1777 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
1778 IPW_WARNING("FW_INITIALIZATION_DONE\n");
1779 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
1782 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
1783 IPW_WARNING("PHY_OFF_DONE\n");
1784 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
1787 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
1788 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1789 priv->status |= STATUS_RF_KILL_HW;
1790 wake_up_interruptible(&priv->wait_command_queue);
1791 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1792 cancel_delayed_work(&priv->request_scan);
1793 schedule_work(&priv->link_down);
1794 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
1795 handled |= IPW_INTA_BIT_RF_KILL_DONE;
1798 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1799 IPW_WARNING("Firmware error detected. Restarting.\n");
1801 IPW_DEBUG_FW("Sysfs 'error' log already exists.\n");
1802 #ifdef CONFIG_IPW2200_DEBUG
1803 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1804 struct ipw_fw_error *error =
1805 ipw_alloc_error_log(priv);
1806 ipw_dump_error_log(priv, error);
1808 ipw_free_error_log(error);
1812 priv->error = ipw_alloc_error_log(priv);
1814 IPW_DEBUG_FW("Sysfs 'error' log captured.\n");
1816 IPW_DEBUG_FW("Error allocating sysfs 'error' "
1818 #ifdef CONFIG_IPW2200_DEBUG
1819 if (ipw_debug_level & IPW_DL_FW_ERRORS)
1820 ipw_dump_error_log(priv, priv->error);
1824 /* XXX: If hardware encryption is for WPA/WPA2,
1825 * we have to notify the supplicant. */
1826 if (priv->ieee->sec.encrypt) {
1827 priv->status &= ~STATUS_ASSOCIATED;
1828 notify_wx_assoc_event(priv);
1831 /* Keep the restart process from trying to send host
1832 * commands by clearing the INIT status bit */
1833 priv->status &= ~STATUS_INIT;
1835 /* Cancel currently queued command. */
1836 priv->status &= ~STATUS_HCMD_ACTIVE;
1837 wake_up_interruptible(&priv->wait_command_queue);
1839 queue_work(priv->workqueue, &priv->adapter_restart);
1840 handled |= IPW_INTA_BIT_FATAL_ERROR;
1843 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
1844 IPW_ERROR("Parity error\n");
1845 handled |= IPW_INTA_BIT_PARITY_ERROR;
1848 if (handled != inta) {
1849 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
1852 /* enable all interrupts */
1853 ipw_enable_interrupts(priv);
1855 spin_unlock_irqrestore(&priv->lock, flags);
1858 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1859 static char *get_cmd_string(u8 cmd)
1862 IPW_CMD(HOST_COMPLETE);
1863 IPW_CMD(POWER_DOWN);
1864 IPW_CMD(SYSTEM_CONFIG);
1865 IPW_CMD(MULTICAST_ADDRESS);
1867 IPW_CMD(ADAPTER_ADDRESS);
1869 IPW_CMD(RTS_THRESHOLD);
1870 IPW_CMD(FRAG_THRESHOLD);
1871 IPW_CMD(POWER_MODE);
1873 IPW_CMD(TGI_TX_KEY);
1874 IPW_CMD(SCAN_REQUEST);
1875 IPW_CMD(SCAN_REQUEST_EXT);
1877 IPW_CMD(SUPPORTED_RATES);
1878 IPW_CMD(SCAN_ABORT);
1880 IPW_CMD(QOS_PARAMETERS);
1881 IPW_CMD(DINO_CONFIG);
1882 IPW_CMD(RSN_CAPABILITIES);
1884 IPW_CMD(CARD_DISABLE);
1885 IPW_CMD(SEED_NUMBER);
1887 IPW_CMD(COUNTRY_INFO);
1888 IPW_CMD(AIRONET_INFO);
1889 IPW_CMD(AP_TX_POWER);
1891 IPW_CMD(CCX_VER_INFO);
1892 IPW_CMD(SET_CALIBRATION);
1893 IPW_CMD(SENSITIVITY_CALIB);
1894 IPW_CMD(RETRY_LIMIT);
1895 IPW_CMD(IPW_PRE_POWER_DOWN);
1896 IPW_CMD(VAP_BEACON_TEMPLATE);
1897 IPW_CMD(VAP_DTIM_PERIOD);
1898 IPW_CMD(EXT_SUPPORTED_RATES);
1899 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1900 IPW_CMD(VAP_QUIET_INTERVALS);
1901 IPW_CMD(VAP_CHANNEL_SWITCH);
1902 IPW_CMD(VAP_MANDATORY_CHANNELS);
1903 IPW_CMD(VAP_CELL_PWR_LIMIT);
1904 IPW_CMD(VAP_CF_PARAM_SET);
1905 IPW_CMD(VAP_SET_BEACONING_STATE);
1906 IPW_CMD(MEASUREMENT);
1907 IPW_CMD(POWER_CAPABILITY);
1908 IPW_CMD(SUPPORTED_CHANNELS);
1909 IPW_CMD(TPC_REPORT);
1911 IPW_CMD(PRODUCTION_COMMAND);
1917 #define HOST_COMPLETE_TIMEOUT HZ
1919 static int __ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
1922 unsigned long flags;
1924 spin_lock_irqsave(&priv->lock, flags);
1925 if (priv->status & STATUS_HCMD_ACTIVE) {
1926 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1927 get_cmd_string(cmd->cmd));
1928 spin_unlock_irqrestore(&priv->lock, flags);
1932 priv->status |= STATUS_HCMD_ACTIVE;
1935 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1936 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1937 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1938 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1940 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1943 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1944 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1947 #ifndef DEBUG_CMD_WEP_KEY
1948 if (cmd->cmd == IPW_CMD_WEP_KEY)
1949 IPW_DEBUG_HC("WEP_KEY command masked out for secure.\n");
1952 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1954 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
1956 priv->status &= ~STATUS_HCMD_ACTIVE;
1957 IPW_ERROR("Failed to send %s: Reason %d\n",
1958 get_cmd_string(cmd->cmd), rc);
1959 spin_unlock_irqrestore(&priv->lock, flags);
1962 spin_unlock_irqrestore(&priv->lock, flags);
1964 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1966 status & STATUS_HCMD_ACTIVE),
1967 HOST_COMPLETE_TIMEOUT);
1969 spin_lock_irqsave(&priv->lock, flags);
1970 if (priv->status & STATUS_HCMD_ACTIVE) {
1971 IPW_ERROR("Failed to send %s: Command timed out.\n",
1972 get_cmd_string(cmd->cmd));
1973 priv->status &= ~STATUS_HCMD_ACTIVE;
1974 spin_unlock_irqrestore(&priv->lock, flags);
1978 spin_unlock_irqrestore(&priv->lock, flags);
1982 if (priv->status & STATUS_RF_KILL_HW) {
1983 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1984 get_cmd_string(cmd->cmd));
1991 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1992 priv->cmdlog_pos %= priv->cmdlog_len;
1997 static int ipw_send_cmd_simple(struct ipw_priv *priv, u8 command)
1999 struct host_cmd cmd = {
2003 return __ipw_send_cmd(priv, &cmd);
2006 static int ipw_send_cmd_pdu(struct ipw_priv *priv, u8 command, u8 len,
2009 struct host_cmd cmd = {
2015 return __ipw_send_cmd(priv, &cmd);
2018 static int ipw_send_host_complete(struct ipw_priv *priv)
2021 IPW_ERROR("Invalid args\n");
2025 return ipw_send_cmd_simple(priv, IPW_CMD_HOST_COMPLETE);
2028 static int ipw_send_system_config(struct ipw_priv *priv,
2029 struct ipw_sys_config *config)
2031 if (!priv || !config) {
2032 IPW_ERROR("Invalid args\n");
2036 return ipw_send_cmd_pdu(priv, IPW_CMD_SYSTEM_CONFIG, sizeof(*config),
2040 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
2042 if (!priv || !ssid) {
2043 IPW_ERROR("Invalid args\n");
2047 return ipw_send_cmd_pdu(priv, IPW_CMD_SSID, min(len, IW_ESSID_MAX_SIZE),
2051 static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
2053 if (!priv || !mac) {
2054 IPW_ERROR("Invalid args\n");
2058 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2059 priv->net_dev->name, MAC_ARG(mac));
2061 return ipw_send_cmd_pdu(priv, IPW_CMD_ADAPTER_ADDRESS, ETH_ALEN, mac);
2065 * NOTE: This must be executed from our workqueue as it results in udelay
2066 * being called which may corrupt the keyboard if executed on default
2069 static void ipw_adapter_restart(void *adapter)
2071 struct ipw_priv *priv = adapter;
2073 if (priv->status & STATUS_RF_KILL_MASK)
2078 if (priv->assoc_network &&
2079 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2080 ipw_remove_current_network(priv);
2083 IPW_ERROR("Failed to up device\n");
2088 static void ipw_bg_adapter_restart(void *data)
2090 struct ipw_priv *priv = data;
2091 mutex_lock(&priv->mutex);
2092 ipw_adapter_restart(data);
2093 mutex_unlock(&priv->mutex);
2096 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2098 static void ipw_scan_check(void *data)
2100 struct ipw_priv *priv = data;
2101 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2102 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2103 "adapter after (%dms).\n",
2104 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2105 queue_work(priv->workqueue, &priv->adapter_restart);
2109 static void ipw_bg_scan_check(void *data)
2111 struct ipw_priv *priv = data;
2112 mutex_lock(&priv->mutex);
2113 ipw_scan_check(data);
2114 mutex_unlock(&priv->mutex);
2117 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2118 struct ipw_scan_request_ext *request)
2120 return ipw_send_cmd_pdu(priv, IPW_CMD_SCAN_REQUEST_EXT,
2121 sizeof(*request), request);
2124 static int ipw_send_scan_abort(struct ipw_priv *priv)
2127 IPW_ERROR("Invalid args\n");
2131 return ipw_send_cmd_simple(priv, IPW_CMD_SCAN_ABORT);
2134 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2136 struct ipw_sensitivity_calib calib = {
2137 .beacon_rssi_raw = sens,
2140 return ipw_send_cmd_pdu(priv, IPW_CMD_SENSITIVITY_CALIB, sizeof(calib),
2144 static int ipw_send_associate(struct ipw_priv *priv,
2145 struct ipw_associate *associate)
2147 struct ipw_associate tmp_associate;
2149 if (!priv || !associate) {
2150 IPW_ERROR("Invalid args\n");
2154 memcpy(&tmp_associate, associate, sizeof(*associate));
2155 tmp_associate.policy_support =
2156 cpu_to_le16(tmp_associate.policy_support);
2157 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2158 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2159 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2160 tmp_associate.listen_interval =
2161 cpu_to_le16(tmp_associate.listen_interval);
2162 tmp_associate.beacon_interval =
2163 cpu_to_le16(tmp_associate.beacon_interval);
2164 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2166 return ipw_send_cmd_pdu(priv, IPW_CMD_ASSOCIATE, sizeof(tmp_associate),
2170 static int ipw_send_supported_rates(struct ipw_priv *priv,
2171 struct ipw_supported_rates *rates)
2173 if (!priv || !rates) {
2174 IPW_ERROR("Invalid args\n");
2178 return ipw_send_cmd_pdu(priv, IPW_CMD_SUPPORTED_RATES, sizeof(*rates),
2182 static int ipw_set_random_seed(struct ipw_priv *priv)
2187 IPW_ERROR("Invalid args\n");
2191 get_random_bytes(&val, sizeof(val));
2193 return ipw_send_cmd_pdu(priv, IPW_CMD_SEED_NUMBER, sizeof(val), &val);
2196 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2199 IPW_ERROR("Invalid args\n");
2203 return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(phy_off),
2207 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2209 if (!priv || !power) {
2210 IPW_ERROR("Invalid args\n");
2214 return ipw_send_cmd_pdu(priv, IPW_CMD_TX_POWER, sizeof(*power), power);
2217 static int ipw_set_tx_power(struct ipw_priv *priv)
2219 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
2220 struct ipw_tx_power tx_power;
2224 memset(&tx_power, 0, sizeof(tx_power));
2226 /* configure device for 'G' band */
2227 tx_power.ieee_mode = IPW_G_MODE;
2228 tx_power.num_channels = geo->bg_channels;
2229 for (i = 0; i < geo->bg_channels; i++) {
2230 max_power = geo->bg[i].max_power;
2231 tx_power.channels_tx_power[i].channel_number =
2233 tx_power.channels_tx_power[i].tx_power = max_power ?
2234 min(max_power, priv->tx_power) : priv->tx_power;
2236 if (ipw_send_tx_power(priv, &tx_power))
2239 /* configure device to also handle 'B' band */
2240 tx_power.ieee_mode = IPW_B_MODE;
2241 if (ipw_send_tx_power(priv, &tx_power))
2244 /* configure device to also handle 'A' band */
2245 if (priv->ieee->abg_true) {
2246 tx_power.ieee_mode = IPW_A_MODE;
2247 tx_power.num_channels = geo->a_channels;
2248 for (i = 0; i < tx_power.num_channels; i++) {
2249 max_power = geo->a[i].max_power;
2250 tx_power.channels_tx_power[i].channel_number =
2252 tx_power.channels_tx_power[i].tx_power = max_power ?
2253 min(max_power, priv->tx_power) : priv->tx_power;
2255 if (ipw_send_tx_power(priv, &tx_power))
2261 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2263 struct ipw_rts_threshold rts_threshold = {
2264 .rts_threshold = rts,
2268 IPW_ERROR("Invalid args\n");
2272 return ipw_send_cmd_pdu(priv, IPW_CMD_RTS_THRESHOLD,
2273 sizeof(rts_threshold), &rts_threshold);
2276 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2278 struct ipw_frag_threshold frag_threshold = {
2279 .frag_threshold = frag,
2283 IPW_ERROR("Invalid args\n");
2287 return ipw_send_cmd_pdu(priv, IPW_CMD_FRAG_THRESHOLD,
2288 sizeof(frag_threshold), &frag_threshold);
2291 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2296 IPW_ERROR("Invalid args\n");
2300 /* If on battery, set to 3, if AC set to CAM, else user
2303 case IPW_POWER_BATTERY:
2304 param = IPW_POWER_INDEX_3;
2307 param = IPW_POWER_MODE_CAM;
2314 return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
2318 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2320 struct ipw_retry_limit retry_limit = {
2321 .short_retry_limit = slimit,
2322 .long_retry_limit = llimit
2326 IPW_ERROR("Invalid args\n");
2330 return ipw_send_cmd_pdu(priv, IPW_CMD_RETRY_LIMIT, sizeof(retry_limit),
2335 * The IPW device contains a Microwire compatible EEPROM that stores
2336 * various data like the MAC address. Usually the firmware has exclusive
2337 * access to the eeprom, but during device initialization (before the
2338 * device driver has sent the HostComplete command to the firmware) the
2339 * device driver has read access to the EEPROM by way of indirect addressing
2340 * through a couple of memory mapped registers.
2342 * The following is a simplified implementation for pulling data out of the
2343 * the eeprom, along with some helper functions to find information in
2344 * the per device private data's copy of the eeprom.
2346 * NOTE: To better understand how these functions work (i.e what is a chip
2347 * select and why do have to keep driving the eeprom clock?), read
2348 * just about any data sheet for a Microwire compatible EEPROM.
2351 /* write a 32 bit value into the indirect accessor register */
2352 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2354 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2356 /* the eeprom requires some time to complete the operation */
2357 udelay(p->eeprom_delay);
2362 /* perform a chip select operation */
2363 static void eeprom_cs(struct ipw_priv *priv)
2365 eeprom_write_reg(priv, 0);
2366 eeprom_write_reg(priv, EEPROM_BIT_CS);
2367 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2368 eeprom_write_reg(priv, EEPROM_BIT_CS);
2371 /* perform a chip select operation */
2372 static void eeprom_disable_cs(struct ipw_priv *priv)
2374 eeprom_write_reg(priv, EEPROM_BIT_CS);
2375 eeprom_write_reg(priv, 0);
2376 eeprom_write_reg(priv, EEPROM_BIT_SK);
2379 /* push a single bit down to the eeprom */
2380 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2382 int d = (bit ? EEPROM_BIT_DI : 0);
2383 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2384 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2387 /* push an opcode followed by an address down to the eeprom */
2388 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2393 eeprom_write_bit(priv, 1);
2394 eeprom_write_bit(priv, op & 2);
2395 eeprom_write_bit(priv, op & 1);
2396 for (i = 7; i >= 0; i--) {
2397 eeprom_write_bit(priv, addr & (1 << i));
2401 /* pull 16 bits off the eeprom, one bit at a time */
2402 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2407 /* Send READ Opcode */
2408 eeprom_op(priv, EEPROM_CMD_READ, addr);
2410 /* Send dummy bit */
2411 eeprom_write_reg(priv, EEPROM_BIT_CS);
2413 /* Read the byte off the eeprom one bit at a time */
2414 for (i = 0; i < 16; i++) {
2416 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2417 eeprom_write_reg(priv, EEPROM_BIT_CS);
2418 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2419 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2422 /* Send another dummy bit */
2423 eeprom_write_reg(priv, 0);
2424 eeprom_disable_cs(priv);
2429 /* helper function for pulling the mac address out of the private */
2430 /* data's copy of the eeprom data */
2431 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2433 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
2437 * Either the device driver (i.e. the host) or the firmware can
2438 * load eeprom data into the designated region in SRAM. If neither
2439 * happens then the FW will shutdown with a fatal error.
2441 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2442 * bit needs region of shared SRAM needs to be non-zero.
2444 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2447 u16 *eeprom = (u16 *) priv->eeprom;
2449 IPW_DEBUG_TRACE(">>\n");
2451 /* read entire contents of eeprom into private buffer */
2452 for (i = 0; i < 128; i++)
2453 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
2456 If the data looks correct, then copy it to our private
2457 copy. Otherwise let the firmware know to perform the operation
2460 if (priv->eeprom[EEPROM_VERSION] != 0) {
2461 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2463 /* write the eeprom data to sram */
2464 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2465 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2467 /* Do not load eeprom data on fatal error or suspend */
2468 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2470 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2472 /* Load eeprom data on fatal error or suspend */
2473 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2476 IPW_DEBUG_TRACE("<<\n");
2479 static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2484 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2486 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2489 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2491 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2492 CB_NUMBER_OF_ELEMENTS_SMALL *
2493 sizeof(struct command_block));
2496 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2497 { /* start dma engine but no transfers yet */
2499 IPW_DEBUG_FW(">> : \n");
2502 ipw_fw_dma_reset_command_blocks(priv);
2504 /* Write CB base address */
2505 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2507 IPW_DEBUG_FW("<< : \n");
2511 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2515 IPW_DEBUG_FW(">> :\n");
2517 //set the Stop and Abort bit
2518 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2519 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2520 priv->sram_desc.last_cb_index = 0;
2522 IPW_DEBUG_FW("<< \n");
2525 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2526 struct command_block *cb)
2529 IPW_SHARED_SRAM_DMA_CONTROL +
2530 (sizeof(struct command_block) * index);
2531 IPW_DEBUG_FW(">> :\n");
2533 ipw_write_indirect(priv, address, (u8 *) cb,
2534 (int)sizeof(struct command_block));
2536 IPW_DEBUG_FW("<< :\n");
2541 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2546 IPW_DEBUG_FW(">> :\n");
2548 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2549 ipw_fw_dma_write_command_block(priv, index,
2550 &priv->sram_desc.cb_list[index]);
2552 /* Enable the DMA in the CSR register */
2553 ipw_clear_bit(priv, IPW_RESET_REG,
2554 IPW_RESET_REG_MASTER_DISABLED |
2555 IPW_RESET_REG_STOP_MASTER);
2557 /* Set the Start bit. */
2558 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2559 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2561 IPW_DEBUG_FW("<< :\n");
2565 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2568 u32 register_value = 0;
2569 u32 cb_fields_address = 0;
2571 IPW_DEBUG_FW(">> :\n");
2572 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2573 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
2575 /* Read the DMA Controlor register */
2576 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2577 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
2579 /* Print the CB values */
2580 cb_fields_address = address;
2581 register_value = ipw_read_reg32(priv, cb_fields_address);
2582 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
2584 cb_fields_address += sizeof(u32);
2585 register_value = ipw_read_reg32(priv, cb_fields_address);
2586 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
2588 cb_fields_address += sizeof(u32);
2589 register_value = ipw_read_reg32(priv, cb_fields_address);
2590 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2593 cb_fields_address += sizeof(u32);
2594 register_value = ipw_read_reg32(priv, cb_fields_address);
2595 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
2597 IPW_DEBUG_FW(">> :\n");
2600 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2602 u32 current_cb_address = 0;
2603 u32 current_cb_index = 0;
2605 IPW_DEBUG_FW("<< :\n");
2606 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2608 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2609 sizeof(struct command_block);
2611 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
2612 current_cb_index, current_cb_address);
2614 IPW_DEBUG_FW(">> :\n");
2615 return current_cb_index;
2619 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2623 int interrupt_enabled, int is_last)
2626 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2627 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2629 struct command_block *cb;
2630 u32 last_cb_element = 0;
2632 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2633 src_address, dest_address, length);
2635 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2638 last_cb_element = priv->sram_desc.last_cb_index;
2639 cb = &priv->sram_desc.cb_list[last_cb_element];
2640 priv->sram_desc.last_cb_index++;
2642 /* Calculate the new CB control word */
2643 if (interrupt_enabled)
2644 control |= CB_INT_ENABLED;
2647 control |= CB_LAST_VALID;
2651 /* Calculate the CB Element's checksum value */
2652 cb->status = control ^ src_address ^ dest_address;
2654 /* Copy the Source and Destination addresses */
2655 cb->dest_addr = dest_address;
2656 cb->source_addr = src_address;
2658 /* Copy the Control Word last */
2659 cb->control = control;
2664 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
2665 u32 src_phys, u32 dest_address, u32 length)
2667 u32 bytes_left = length;
2669 u32 dest_offset = 0;
2671 IPW_DEBUG_FW(">> \n");
2672 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2673 src_phys, dest_address, length);
2674 while (bytes_left > CB_MAX_LENGTH) {
2675 status = ipw_fw_dma_add_command_block(priv,
2676 src_phys + src_offset,
2679 CB_MAX_LENGTH, 0, 0);
2681 IPW_DEBUG_FW_INFO(": Failed\n");
2684 IPW_DEBUG_FW_INFO(": Added new cb\n");
2686 src_offset += CB_MAX_LENGTH;
2687 dest_offset += CB_MAX_LENGTH;
2688 bytes_left -= CB_MAX_LENGTH;
2691 /* add the buffer tail */
2692 if (bytes_left > 0) {
2694 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2695 dest_address + dest_offset,
2698 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2702 (": Adding new cb - the buffer tail\n");
2705 IPW_DEBUG_FW("<< \n");
2709 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2711 u32 current_index = 0, previous_index;
2714 IPW_DEBUG_FW(">> : \n");
2716 current_index = ipw_fw_dma_command_block_index(priv);
2717 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%08X\n",
2718 (int)priv->sram_desc.last_cb_index);
2720 while (current_index < priv->sram_desc.last_cb_index) {
2722 previous_index = current_index;
2723 current_index = ipw_fw_dma_command_block_index(priv);
2725 if (previous_index < current_index) {
2729 if (++watchdog > 400) {
2730 IPW_DEBUG_FW_INFO("Timeout\n");
2731 ipw_fw_dma_dump_command_block(priv);
2732 ipw_fw_dma_abort(priv);
2737 ipw_fw_dma_abort(priv);
2739 /*Disable the DMA in the CSR register */
2740 ipw_set_bit(priv, IPW_RESET_REG,
2741 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2743 IPW_DEBUG_FW("<< dmaWaitSync \n");
2747 static void ipw_remove_current_network(struct ipw_priv *priv)
2749 struct list_head *element, *safe;
2750 struct ieee80211_network *network = NULL;
2751 unsigned long flags;
2753 spin_lock_irqsave(&priv->ieee->lock, flags);
2754 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2755 network = list_entry(element, struct ieee80211_network, list);
2756 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2758 list_add_tail(&network->list,
2759 &priv->ieee->network_free_list);
2762 spin_unlock_irqrestore(&priv->ieee->lock, flags);
2766 * Check that card is still alive.
2767 * Reads debug register from domain0.
2768 * If card is present, pre-defined value should
2772 * @return 1 if card is present, 0 otherwise
2774 static inline int ipw_alive(struct ipw_priv *priv)
2776 return ipw_read32(priv, 0x90) == 0xd55555d5;
2779 /* timeout in msec, attempted in 10-msec quanta */
2780 static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2786 if ((ipw_read32(priv, addr) & mask) == mask)
2790 } while (i < timeout);
2795 /* These functions load the firmware and micro code for the operation of
2796 * the ipw hardware. It assumes the buffer has all the bits for the
2797 * image and the caller is handling the memory allocation and clean up.
2800 static int ipw_stop_master(struct ipw_priv *priv)
2804 IPW_DEBUG_TRACE(">> \n");
2805 /* stop master. typical delay - 0 */
2806 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2808 /* timeout is in msec, polled in 10-msec quanta */
2809 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2810 IPW_RESET_REG_MASTER_DISABLED, 100);
2812 IPW_ERROR("wait for stop master failed after 100ms\n");
2816 IPW_DEBUG_INFO("stop master %dms\n", rc);
2821 static void ipw_arc_release(struct ipw_priv *priv)
2823 IPW_DEBUG_TRACE(">> \n");
2826 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2828 /* no one knows timing, for safety add some delay */
2842 #define IPW_FW_MAJOR_VERSION 2
2843 #define IPW_FW_MINOR_VERSION 4
2845 #define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2846 #define IPW_FW_MAJOR(x) (x & 0xff)
2848 #define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2850 #define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2851 "." __stringify(IPW_FW_MINOR_VERSION) "-"
2853 #if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2854 #define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2856 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2859 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2861 int rc = 0, i, addr;
2865 image = (u16 *) data;
2867 IPW_DEBUG_TRACE(">> \n");
2869 rc = ipw_stop_master(priv);
2874 // spin_lock_irqsave(&priv->lock, flags);
2876 for (addr = IPW_SHARED_LOWER_BOUND;
2877 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2878 ipw_write32(priv, addr, 0);
2881 /* no ucode (yet) */
2882 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2883 /* destroy DMA queues */
2884 /* reset sequence */
2886 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2887 ipw_arc_release(priv);
2888 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2892 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2895 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2898 /* enable ucode store */
2899 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
2900 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
2906 * Do NOT set indirect address register once and then
2907 * store data to indirect data register in the loop.
2908 * It seems very reasonable, but in this case DINO do not
2909 * accept ucode. It is essential to set address each time.
2911 /* load new ipw uCode */
2912 for (i = 0; i < len / 2; i++)
2913 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2914 cpu_to_le16(image[i]));
2917 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2918 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2920 /* this is where the igx / win driver deveates from the VAP driver. */
2922 /* wait for alive response */
2923 for (i = 0; i < 100; i++) {
2924 /* poll for incoming data */
2925 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2926 if (cr & DINO_RXFIFO_DATA)
2931 if (cr & DINO_RXFIFO_DATA) {
2932 /* alive_command_responce size is NOT multiple of 4 */
2933 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2935 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2936 response_buffer[i] =
2937 le32_to_cpu(ipw_read_reg32(priv,
2938 IPW_BASEBAND_RX_FIFO_READ));
2939 memcpy(&priv->dino_alive, response_buffer,
2940 sizeof(priv->dino_alive));
2941 if (priv->dino_alive.alive_command == 1
2942 && priv->dino_alive.ucode_valid == 1) {
2945 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2946 "of %02d/%02d/%02d %02d:%02d\n",
2947 priv->dino_alive.software_revision,
2948 priv->dino_alive.software_revision,
2949 priv->dino_alive.device_identifier,
2950 priv->dino_alive.device_identifier,
2951 priv->dino_alive.time_stamp[0],
2952 priv->dino_alive.time_stamp[1],
2953 priv->dino_alive.time_stamp[2],
2954 priv->dino_alive.time_stamp[3],
2955 priv->dino_alive.time_stamp[4]);
2957 IPW_DEBUG_INFO("Microcode is not alive\n");
2961 IPW_DEBUG_INFO("No alive response from DINO\n");
2965 /* disable DINO, otherwise for some reason
2966 firmware have problem getting alive resp. */
2967 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2969 // spin_unlock_irqrestore(&priv->lock, flags);
2974 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
2978 struct fw_chunk *chunk;
2979 dma_addr_t shared_phys;
2982 IPW_DEBUG_TRACE("<< : \n");
2983 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2988 memmove(shared_virt, data, len);
2991 rc = ipw_fw_dma_enable(priv);
2993 if (priv->sram_desc.last_cb_index > 0) {
2994 /* the DMA is already ready this would be a bug. */
3000 chunk = (struct fw_chunk *)(data + offset);
3001 offset += sizeof(struct fw_chunk);
3002 /* build DMA packet and queue up for sending */
3003 /* dma to chunk->address, the chunk->length bytes from data +
3006 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3007 le32_to_cpu(chunk->address),
3008 le32_to_cpu(chunk->length));
3010 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3014 offset += le32_to_cpu(chunk->length);
3015 } while (offset < len);
3017 /* Run the DMA and wait for the answer */
3018 rc = ipw_fw_dma_kick(priv);
3020 IPW_ERROR("dmaKick Failed\n");
3024 rc = ipw_fw_dma_wait(priv);
3026 IPW_ERROR("dmaWaitSync Failed\n");
3030 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
3035 static int ipw_stop_nic(struct ipw_priv *priv)
3040 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3042 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3043 IPW_RESET_REG_MASTER_DISABLED, 500);
3045 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
3049 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3054 static void ipw_start_nic(struct ipw_priv *priv)
3056 IPW_DEBUG_TRACE(">>\n");
3058 /* prvHwStartNic release ARC */
3059 ipw_clear_bit(priv, IPW_RESET_REG,
3060 IPW_RESET_REG_MASTER_DISABLED |
3061 IPW_RESET_REG_STOP_MASTER |
3062 CBD_RESET_REG_PRINCETON_RESET);
3064 /* enable power management */
3065 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3066 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3068 IPW_DEBUG_TRACE("<<\n");
3071 static int ipw_init_nic(struct ipw_priv *priv)
3075 IPW_DEBUG_TRACE(">>\n");
3078 /* set "initialization complete" bit to move adapter to D0 state */
3079 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3081 /* low-level PLL activation */
3082 ipw_write32(priv, IPW_READ_INT_REGISTER,
3083 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3085 /* wait for clock stabilization */
3086 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3087 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3089 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3091 /* assert SW reset */
3092 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3096 /* set "initialization complete" bit to move adapter to D0 state */
3097 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3099 IPW_DEBUG_TRACE(">>\n");
3103 /* Call this function from process context, it will sleep in request_firmware.
3104 * Probe is an ok place to call this from.
3106 static int ipw_reset_nic(struct ipw_priv *priv)
3109 unsigned long flags;
3111 IPW_DEBUG_TRACE(">>\n");
3113 rc = ipw_init_nic(priv);
3115 spin_lock_irqsave(&priv->lock, flags);
3116 /* Clear the 'host command active' bit... */
3117 priv->status &= ~STATUS_HCMD_ACTIVE;
3118 wake_up_interruptible(&priv->wait_command_queue);
3119 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3120 wake_up_interruptible(&priv->wait_state);
3121 spin_unlock_irqrestore(&priv->lock, flags);
3123 IPW_DEBUG_TRACE("<<\n");
3127 static int ipw_get_fw(struct ipw_priv *priv,
3128 const struct firmware **fw, const char *name)
3130 struct fw_header *header;
3133 /* ask firmware_class module to get the boot firmware off disk */
3134 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3136 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3140 header = (struct fw_header *)(*fw)->data;
3141 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
3142 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3144 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3145 IPW_FW_MAJOR_VERSION);
3149 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
3151 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3152 IPW_FW_MINOR(le32_to_cpu(header->version)),
3153 (*fw)->size - sizeof(struct fw_header));
3157 #define IPW_RX_BUF_SIZE (3000)
3159 static void ipw_rx_queue_reset(struct ipw_priv *priv,
3160 struct ipw_rx_queue *rxq)
3162 unsigned long flags;
3165 spin_lock_irqsave(&rxq->lock, flags);
3167 INIT_LIST_HEAD(&rxq->rx_free);
3168 INIT_LIST_HEAD(&rxq->rx_used);
3170 /* Fill the rx_used queue with _all_ of the Rx buffers */
3171 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3172 /* In the reset function, these buffers may have been allocated
3173 * to an SKB, so we need to unmap and free potential storage */
3174 if (rxq->pool[i].skb != NULL) {
3175 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3176 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3177 dev_kfree_skb(rxq->pool[i].skb);
3178 rxq->pool[i].skb = NULL;
3180 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3183 /* Set us so that we have processed and used all buffers, but have
3184 * not restocked the Rx queue with fresh buffers */
3185 rxq->read = rxq->write = 0;
3186 rxq->processed = RX_QUEUE_SIZE - 1;
3187 rxq->free_count = 0;
3188 spin_unlock_irqrestore(&rxq->lock, flags);
3192 static int fw_loaded = 0;
3193 static const struct firmware *bootfw = NULL;
3194 static const struct firmware *firmware = NULL;
3195 static const struct firmware *ucode = NULL;
3197 static void free_firmware(void)
3200 release_firmware(bootfw);
3201 release_firmware(ucode);
3202 release_firmware(firmware);
3203 bootfw = ucode = firmware = NULL;
3208 #define free_firmware() do {} while (0)
3211 static int ipw_load(struct ipw_priv *priv)
3214 const struct firmware *bootfw = NULL;
3215 const struct firmware *firmware = NULL;
3216 const struct firmware *ucode = NULL;
3220 int rc = 0, retries = 3;
3222 switch (priv->ieee->iw_mode) {
3224 ucode_name = IPW_FW_NAME("ibss_ucode");
3225 fw_name = IPW_FW_NAME("ibss");
3227 #ifdef CONFIG_IPW2200_MONITOR
3228 case IW_MODE_MONITOR:
3229 ucode_name = IPW_FW_NAME("sniffer_ucode");
3230 fw_name = IPW_FW_NAME("sniffer");
3234 ucode_name = IPW_FW_NAME("bss_ucode");
3235 fw_name = IPW_FW_NAME("bss");
3245 priv->rxq = ipw_rx_queue_alloc(priv);
3247 ipw_rx_queue_reset(priv, priv->rxq);
3249 IPW_ERROR("Unable to initialize Rx queue\n");
3254 /* Ensure interrupts are disabled */
3255 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3256 priv->status &= ~STATUS_INT_ENABLED;
3258 /* ack pending interrupts */
3259 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3263 rc = ipw_reset_nic(priv);
3265 IPW_ERROR("Unable to reset NIC\n");
3269 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3270 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3275 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3281 /* DMA the initial boot firmware into the device */
3282 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
3283 bootfw->size - sizeof(struct fw_header));
3285 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3289 /* kick start the device */
3290 ipw_start_nic(priv);
3292 /* wait for the device to finish its initial startup sequence */
3293 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3294 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3296 IPW_ERROR("device failed to boot initial fw image\n");
3299 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3301 /* ack fw init done interrupt */
3302 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3307 rc = ipw_get_fw(priv, &ucode, ucode_name);
3314 /* DMA the ucode into the device */
3315 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
3316 ucode->size - sizeof(struct fw_header));
3318 IPW_ERROR("Unable to load ucode: %d\n", rc);
3328 rc = ipw_get_fw(priv, &firmware, fw_name);
3335 /* DMA bss firmware into the device */
3336 rc = ipw_load_firmware(priv, firmware->data +
3337 sizeof(struct fw_header),
3338 firmware->size - sizeof(struct fw_header));
3340 IPW_ERROR("Unable to load firmware: %d\n", rc);
3347 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3349 rc = ipw_queue_reset(priv);
3351 IPW_ERROR("Unable to initialize queues\n");
3355 /* Ensure interrupts are disabled */
3356 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3357 /* ack pending interrupts */
3358 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3360 /* kick start the device */
3361 ipw_start_nic(priv);
3363 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3365 IPW_WARNING("Parity error. Retrying init.\n");
3370 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3375 /* wait for the device */
3376 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3377 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3379 IPW_ERROR("device failed to start within 500ms\n");
3382 IPW_DEBUG_INFO("device response after %dms\n", rc);
3384 /* ack fw init done interrupt */
3385 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3387 /* read eeprom data and initialize the eeprom region of sram */
3388 priv->eeprom_delay = 1;
3389 ipw_eeprom_init_sram(priv);
3391 /* enable interrupts */
3392 ipw_enable_interrupts(priv);
3394 /* Ensure our queue has valid packets */
3395 ipw_rx_queue_replenish(priv);
3397 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3399 /* ack pending interrupts */
3400 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3403 release_firmware(bootfw);
3404 release_firmware(ucode);
3405 release_firmware(firmware);
3411 ipw_rx_queue_free(priv, priv->rxq);
3414 ipw_tx_queue_free(priv);
3416 release_firmware(bootfw);
3418 release_firmware(ucode);
3420 release_firmware(firmware);
3423 bootfw = ucode = firmware = NULL;
3432 * Theory of operation
3434 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3435 * 2 empty entries always kept in the buffer to protect from overflow.
3437 * For Tx queue, there are low mark and high mark limits. If, after queuing
3438 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3439 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3442 * The IPW operates with six queues, one receive queue in the device's
3443 * sram, one transmit queue for sending commands to the device firmware,
3444 * and four transmit queues for data.
3446 * The four transmit queues allow for performing quality of service (qos)
3447 * transmissions as per the 802.11 protocol. Currently Linux does not
3448 * provide a mechanism to the user for utilizing prioritized queues, so
3449 * we only utilize the first data transmit queue (queue1).
3453 * Driver allocates buffers of this size for Rx
3456 static inline int ipw_queue_space(const struct clx2_queue *q)
3458 int s = q->last_used - q->first_empty;
3461 s -= 2; /* keep some reserve to not confuse empty and full situations */
3467 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3469 return (++index == n_bd) ? 0 : index;
3473 * Initialize common DMA queue structure
3475 * @param q queue to init
3476 * @param count Number of BD's to allocate. Should be power of 2
3477 * @param read_register Address for 'read' register
3478 * (not offset within BAR, full address)
3479 * @param write_register Address for 'write' register
3480 * (not offset within BAR, full address)
3481 * @param base_register Address for 'base' register
3482 * (not offset within BAR, full address)
3483 * @param size Address for 'size' register
3484 * (not offset within BAR, full address)
3486 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3487 int count, u32 read, u32 write, u32 base, u32 size)
3491 q->low_mark = q->n_bd / 4;
3492 if (q->low_mark < 4)
3495 q->high_mark = q->n_bd / 8;
3496 if (q->high_mark < 2)
3499 q->first_empty = q->last_used = 0;
3503 ipw_write32(priv, base, q->dma_addr);
3504 ipw_write32(priv, size, count);
3505 ipw_write32(priv, read, 0);
3506 ipw_write32(priv, write, 0);
3508 _ipw_read32(priv, 0x90);
3511 static int ipw_queue_tx_init(struct ipw_priv *priv,
3512 struct clx2_tx_queue *q,
3513 int count, u32 read, u32 write, u32 base, u32 size)
3515 struct pci_dev *dev = priv->pci_dev;
3517 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3519 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3524 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3526 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3527 sizeof(q->bd[0]) * count);
3533 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3538 * Free one TFD, those at index [txq->q.last_used].
3539 * Do NOT advance any indexes
3544 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3545 struct clx2_tx_queue *txq)
3547 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3548 struct pci_dev *dev = priv->pci_dev;
3552 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3553 /* nothing to cleanup after for host commands */
3557 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3558 IPW_ERROR("Too many chunks: %i\n",
3559 le32_to_cpu(bd->u.data.num_chunks));
3560 /** @todo issue fatal error, it is quite serious situation */
3564 /* unmap chunks if any */
3565 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3566 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3567 le16_to_cpu(bd->u.data.chunk_len[i]),
3569 if (txq->txb[txq->q.last_used]) {
3570 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3571 txq->txb[txq->q.last_used] = NULL;
3577 * Deallocate DMA queue.
3579 * Empty queue by removing and destroying all BD's.
3585 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3587 struct clx2_queue *q = &txq->q;
3588 struct pci_dev *dev = priv->pci_dev;
3593 /* first, empty all BD's */
3594 for (; q->first_empty != q->last_used;
3595 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3596 ipw_queue_tx_free_tfd(priv, txq);
3599 /* free buffers belonging to queue itself */
3600 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3604 /* 0 fill whole structure */
3605 memset(txq, 0, sizeof(*txq));
3609 * Destroy all DMA queues and structures
3613 static void ipw_tx_queue_free(struct ipw_priv *priv)
3616 ipw_queue_tx_free(priv, &priv->txq_cmd);
3619 ipw_queue_tx_free(priv, &priv->txq[0]);
3620 ipw_queue_tx_free(priv, &priv->txq[1]);
3621 ipw_queue_tx_free(priv, &priv->txq[2]);
3622 ipw_queue_tx_free(priv, &priv->txq[3]);
3625 static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3627 /* First 3 bytes are manufacturer */
3628 bssid[0] = priv->mac_addr[0];
3629 bssid[1] = priv->mac_addr[1];
3630 bssid[2] = priv->mac_addr[2];
3632 /* Last bytes are random */
3633 get_random_bytes(&bssid[3], ETH_ALEN - 3);
3635 bssid[0] &= 0xfe; /* clear multicast bit */
3636 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
3639 static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3641 struct ipw_station_entry entry;
3644 for (i = 0; i < priv->num_stations; i++) {
3645 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3646 /* Another node is active in network */
3647 priv->missed_adhoc_beacons = 0;
3648 if (!(priv->config & CFG_STATIC_CHANNEL))
3649 /* when other nodes drop out, we drop out */
3650 priv->config &= ~CFG_ADHOC_PERSIST;
3656 if (i == MAX_STATIONS)
3657 return IPW_INVALID_STATION;
3659 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3662 entry.support_mode = 0;
3663 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3664 memcpy(priv->stations[i], bssid, ETH_ALEN);
3665 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3666 &entry, sizeof(entry));
3667 priv->num_stations++;
3672 static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3676 for (i = 0; i < priv->num_stations; i++)
3677 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3680 return IPW_INVALID_STATION;
3683 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3687 if (priv->status & STATUS_ASSOCIATING) {
3688 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3689 queue_work(priv->workqueue, &priv->disassociate);
3693 if (!(priv->status & STATUS_ASSOCIATED)) {
3694 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3698 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3700 MAC_ARG(priv->assoc_request.bssid),
3701 priv->assoc_request.channel);
3703 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3704 priv->status |= STATUS_DISASSOCIATING;
3707 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3709 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3711 err = ipw_send_associate(priv, &priv->assoc_request);
3713 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3720 static int ipw_disassociate(void *data)
3722 struct ipw_priv *priv = data;
3723 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3725 ipw_send_disassociate(data, 0);
3729 static void ipw_bg_disassociate(void *data)
3731 struct ipw_priv *priv = data;
3732 mutex_lock(&priv->mutex);
3733 ipw_disassociate(data);
3734 mutex_unlock(&priv->mutex);
3737 static void ipw_system_config(void *data)
3739 struct ipw_priv *priv = data;
3740 ipw_send_system_config(priv, &priv->sys_config);
3743 struct ipw_status_code {
3748 static const struct ipw_status_code ipw_status_codes[] = {
3749 {0x00, "Successful"},
3750 {0x01, "Unspecified failure"},
3751 {0x0A, "Cannot support all requested capabilities in the "
3752 "Capability information field"},
3753 {0x0B, "Reassociation denied due to inability to confirm that "
3754 "association exists"},
3755 {0x0C, "Association denied due to reason outside the scope of this "
3758 "Responding station does not support the specified authentication "
3761 "Received an Authentication frame with authentication sequence "
3762 "transaction sequence number out of expected sequence"},
3763 {0x0F, "Authentication rejected because of challenge failure"},
3764 {0x10, "Authentication rejected due to timeout waiting for next "
3765 "frame in sequence"},
3766 {0x11, "Association denied because AP is unable to handle additional "
3767 "associated stations"},
3769 "Association denied due to requesting station not supporting all "
3770 "of the datarates in the BSSBasicServiceSet Parameter"},
3772 "Association denied due to requesting station not supporting "
3773 "short preamble operation"},
3775 "Association denied due to requesting station not supporting "
3778 "Association denied due to requesting station not supporting "
3781 "Association denied due to requesting station not supporting "
3782 "short slot operation"},
3784 "Association denied due to requesting station not supporting "
3785 "DSSS-OFDM operation"},
3786 {0x28, "Invalid Information Element"},
3787 {0x29, "Group Cipher is not valid"},
3788 {0x2A, "Pairwise Cipher is not valid"},
3789 {0x2B, "AKMP is not valid"},
3790 {0x2C, "Unsupported RSN IE version"},
3791 {0x2D, "Invalid RSN IE Capabilities"},
3792 {0x2E, "Cipher suite is rejected per security policy"},
3795 #ifdef CONFIG_IPW2200_DEBUG
3796 static const char *ipw_get_status_code(u16 status)
3799 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3800 if (ipw_status_codes[i].status == (status & 0xff))
3801 return ipw_status_codes[i].reason;
3802 return "Unknown status value.";
3806 static void inline average_init(struct average *avg)
3808 memset(avg, 0, sizeof(*avg));
3811 static void average_add(struct average *avg, s16 val)
3813 avg->sum -= avg->entries[avg->pos];
3815 avg->entries[avg->pos++] = val;
3816 if (unlikely(avg->pos == AVG_ENTRIES)) {
3822 static s16 average_value(struct average *avg)
3824 if (!unlikely(avg->init)) {
3826 return avg->sum / avg->pos;
3830 return avg->sum / AVG_ENTRIES;
3833 static void ipw_reset_stats(struct ipw_priv *priv)
3835 u32 len = sizeof(u32);
3839 average_init(&priv->average_missed_beacons);
3840 average_init(&priv->average_rssi);
3841 average_init(&priv->average_noise);
3843 priv->last_rate = 0;
3844 priv->last_missed_beacons = 0;
3845 priv->last_rx_packets = 0;
3846 priv->last_tx_packets = 0;
3847 priv->last_tx_failures = 0;
3849 /* Firmware managed, reset only when NIC is restarted, so we have to
3850 * normalize on the current value */
3851 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
3852 &priv->last_rx_err, &len);
3853 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
3854 &priv->last_tx_failures, &len);
3856 /* Driver managed, reset with each association */
3857 priv->missed_adhoc_beacons = 0;
3858 priv->missed_beacons = 0;
3859 priv->tx_packets = 0;
3860 priv->rx_packets = 0;
3864 static u32 ipw_get_max_rate(struct ipw_priv *priv)
3867 u32 mask = priv->rates_mask;
3868 /* If currently associated in B mode, restrict the maximum
3869 * rate match to B rates */
3870 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3871 mask &= IEEE80211_CCK_RATES_MASK;
3873 /* TODO: Verify that the rate is supported by the current rates
3876 while (i && !(mask & i))
3879 case IEEE80211_CCK_RATE_1MB_MASK:
3881 case IEEE80211_CCK_RATE_2MB_MASK:
3883 case IEEE80211_CCK_RATE_5MB_MASK:
3885 case IEEE80211_OFDM_RATE_6MB_MASK:
3887 case IEEE80211_OFDM_RATE_9MB_MASK:
3889 case IEEE80211_CCK_RATE_11MB_MASK:
3891 case IEEE80211_OFDM_RATE_12MB_MASK:
3893 case IEEE80211_OFDM_RATE_18MB_MASK:
3895 case IEEE80211_OFDM_RATE_24MB_MASK:
3897 case IEEE80211_OFDM_RATE_36MB_MASK:
3899 case IEEE80211_OFDM_RATE_48MB_MASK:
3901 case IEEE80211_OFDM_RATE_54MB_MASK:
3905 if (priv->ieee->mode == IEEE_B)
3911 static u32 ipw_get_current_rate(struct ipw_priv *priv)
3913 u32 rate, len = sizeof(rate);
3916 if (!(priv->status & STATUS_ASSOCIATED))
3919 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3920 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
3923 IPW_DEBUG_INFO("failed querying ordinals.\n");
3927 return ipw_get_max_rate(priv);
3930 case IPW_TX_RATE_1MB:
3932 case IPW_TX_RATE_2MB:
3934 case IPW_TX_RATE_5MB:
3936 case IPW_TX_RATE_6MB:
3938 case IPW_TX_RATE_9MB:
3940 case IPW_TX_RATE_11MB:
3942 case IPW_TX_RATE_12MB:
3944 case IPW_TX_RATE_18MB:
3946 case IPW_TX_RATE_24MB:
3948 case IPW_TX_RATE_36MB:
3950 case IPW_TX_RATE_48MB:
3952 case IPW_TX_RATE_54MB:
3959 #define IPW_STATS_INTERVAL (2 * HZ)
3960 static void ipw_gather_stats(struct ipw_priv *priv)
3962 u32 rx_err, rx_err_delta, rx_packets_delta;
3963 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3964 u32 missed_beacons_percent, missed_beacons_delta;
3966 u32 len = sizeof(u32);
3968 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3972 if (!(priv->status & STATUS_ASSOCIATED)) {
3977 /* Update the statistics */
3978 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
3979 &priv->missed_beacons, &len);
3980 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
3981 priv->last_missed_beacons = priv->missed_beacons;
3982 if (priv->assoc_request.beacon_interval) {
3983 missed_beacons_percent = missed_beacons_delta *
3984 (HZ * priv->assoc_request.beacon_interval) /
3985 (IPW_STATS_INTERVAL * 10);
3987 missed_beacons_percent = 0;
3989 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3991 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3992 rx_err_delta = rx_err - priv->last_rx_err;
3993 priv->last_rx_err = rx_err;
3995 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3996 tx_failures_delta = tx_failures - priv->last_tx_failures;
3997 priv->last_tx_failures = tx_failures;
3999 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4000 priv->last_rx_packets = priv->rx_packets;
4002 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4003 priv->last_tx_packets = priv->tx_packets;
4005 /* Calculate quality based on the following:
4007 * Missed beacon: 100% = 0, 0% = 70% missed
4008 * Rate: 60% = 1Mbs, 100% = Max
4009 * Rx and Tx errors represent a straight % of total Rx/Tx
4010 * RSSI: 100% = > -50, 0% = < -80
4011 * Rx errors: 100% = 0, 0% = 50% missed
4013 * The lowest computed quality is used.
4016 #define BEACON_THRESHOLD 5
4017 beacon_quality = 100 - missed_beacons_percent;
4018 if (beacon_quality < BEACON_THRESHOLD)
4021 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4022 (100 - BEACON_THRESHOLD);
4023 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4024 beacon_quality, missed_beacons_percent);
4026 priv->last_rate = ipw_get_current_rate(priv);
4027 max_rate = ipw_get_max_rate(priv);
4028 rate_quality = priv->last_rate * 40 / max_rate + 60;
4029 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4030 rate_quality, priv->last_rate / 1000000);
4032 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4033 rx_quality = 100 - (rx_err_delta * 100) /
4034 (rx_packets_delta + rx_err_delta);
4037 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4038 rx_quality, rx_err_delta, rx_packets_delta);
4040 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4041 tx_quality = 100 - (tx_failures_delta * 100) /
4042 (tx_packets_delta + tx_failures_delta);
4045 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4046 tx_quality, tx_failures_delta, tx_packets_delta);
4048 rssi = average_value(&priv->average_rssi);
4051 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4052 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4053 (priv->ieee->perfect_rssi - rssi) *
4054 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4055 62 * (priv->ieee->perfect_rssi - rssi))) /
4056 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4057 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4058 if (signal_quality > 100)
4059 signal_quality = 100;
4060 else if (signal_quality < 1)
4063 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4064 signal_quality, rssi);
4066 quality = min(beacon_quality,
4068 min(tx_quality, min(rx_quality, signal_quality))));
4069 if (quality == beacon_quality)
4070 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4072 if (quality == rate_quality)
4073 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4075 if (quality == tx_quality)
4076 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4078 if (quality == rx_quality)
4079 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4081 if (quality == signal_quality)
4082 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4085 priv->quality = quality;
4087 queue_delayed_work(priv->workqueue, &priv->gather_stats,
4088 IPW_STATS_INTERVAL);
4091 static void ipw_bg_gather_stats(void *data)
4093 struct ipw_priv *priv = data;
4094 mutex_lock(&priv->mutex);
4095 ipw_gather_stats(data);
4096 mutex_unlock(&priv->mutex);
4099 /* Missed beacon behavior:
4100 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4101 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4102 * Above disassociate threshold, give up and stop scanning.
4103 * Roaming is disabled if disassociate_threshold <= roaming_threshold */
4104 static void ipw_handle_missed_beacon(struct ipw_priv *priv,
4107 priv->notif_missed_beacons = missed_count;
4109 if (missed_count > priv->disassociate_threshold &&
4110 priv->status & STATUS_ASSOCIATED) {
4111 /* If associated and we've hit the missed
4112 * beacon threshold, disassociate, turn
4113 * off roaming, and abort any active scans */
4114 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4115 IPW_DL_STATE | IPW_DL_ASSOC,
4116 "Missed beacon: %d - disassociate\n", missed_count);
4117 priv->status &= ~STATUS_ROAMING;
4118 if (priv->status & STATUS_SCANNING) {
4119 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4121 "Aborting scan with missed beacon.\n");
4122 queue_work(priv->workqueue, &priv->abort_scan);
4125 queue_work(priv->workqueue, &priv->disassociate);
4129 if (priv->status & STATUS_ROAMING) {
4130 /* If we are currently roaming, then just
4131 * print a debug statement... */
4132 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4133 "Missed beacon: %d - roam in progress\n",
4139 (missed_count > priv->roaming_threshold &&
4140 missed_count <= priv->disassociate_threshold)) {
4141 /* If we are not already roaming, set the ROAM
4142 * bit in the status and kick off a scan.
4143 * This can happen several times before we reach
4144 * disassociate_threshold. */
4145 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4146 "Missed beacon: %d - initiate "
4147 "roaming\n", missed_count);
4148 if (!(priv->status & STATUS_ROAMING)) {
4149 priv->status |= STATUS_ROAMING;
4150 if (!(priv->status & STATUS_SCANNING))
4151 queue_work(priv->workqueue,
4152 &priv->request_scan);
4157 if (priv->status & STATUS_SCANNING) {
4158 /* Stop scan to keep fw from getting
4159 * stuck (only if we aren't roaming --
4160 * otherwise we'll never scan more than 2 or 3
4162 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4163 "Aborting scan with missed beacon.\n");
4164 queue_work(priv->workqueue, &priv->abort_scan);
4167 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4171 * Handle host notification packet.
4172 * Called from interrupt routine
4174 static void ipw_rx_notification(struct ipw_priv *priv,
4175 struct ipw_rx_notification *notif)
4177 notif->size = le16_to_cpu(notif->size);
4179 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4181 switch (notif->subtype) {
4182 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4183 struct notif_association *assoc = ¬if->u.assoc;
4185 switch (assoc->state) {
4186 case CMAS_ASSOCIATED:{
4187 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4189 "associated: '%s' " MAC_FMT
4191 escape_essid(priv->essid,
4193 MAC_ARG(priv->bssid));
4195 switch (priv->ieee->iw_mode) {
4197 memcpy(priv->ieee->bssid,
4198 priv->bssid, ETH_ALEN);
4202 memcpy(priv->ieee->bssid,
4203 priv->bssid, ETH_ALEN);
4205 /* clear out the station table */
4206 priv->num_stations = 0;
4209 ("queueing adhoc check\n");
4210 queue_delayed_work(priv->
4220 priv->status &= ~STATUS_ASSOCIATING;
4221 priv->status |= STATUS_ASSOCIATED;
4222 queue_work(priv->workqueue,
4223 &priv->system_config);
4225 #ifdef CONFIG_IPW_QOS
4226 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4227 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4228 if ((priv->status & STATUS_AUTH) &&
4229 (IPW_GET_PACKET_STYPE(¬if->u.raw)
4230 == IEEE80211_STYPE_ASSOC_RESP)) {
4233 ieee80211_assoc_response)
4235 && (notif->size <= 2314)) {
4248 ieee80211_rx_mgt(priv->
4253 ¬if->u.raw, &stats);
4258 schedule_work(&priv->link_up);
4263 case CMAS_AUTHENTICATED:{
4265 status & (STATUS_ASSOCIATED |
4267 #ifdef CONFIG_IPW2200_DEBUG
4268 struct notif_authenticate *auth
4270 IPW_DEBUG(IPW_DL_NOTIF |
4273 "deauthenticated: '%s' "
4275 ": (0x%04X) - %s \n",
4280 MAC_ARG(priv->bssid),
4281 ntohs(auth->status),
4288 ~(STATUS_ASSOCIATING |
4292 schedule_work(&priv->link_down);
4296 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4298 "authenticated: '%s' " MAC_FMT
4300 escape_essid(priv->essid,
4302 MAC_ARG(priv->bssid));
4307 if (priv->status & STATUS_AUTH) {
4309 ieee80211_assoc_response
4313 ieee80211_assoc_response
4315 IPW_DEBUG(IPW_DL_NOTIF |
4318 "association failed (0x%04X): %s\n",
4319 ntohs(resp->status),
4325 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4327 "disassociated: '%s' " MAC_FMT
4329 escape_essid(priv->essid,
4331 MAC_ARG(priv->bssid));
4334 ~(STATUS_DISASSOCIATING |
4335 STATUS_ASSOCIATING |
4336 STATUS_ASSOCIATED | STATUS_AUTH);
4337 if (priv->assoc_network
4338 && (priv->assoc_network->
4340 WLAN_CAPABILITY_IBSS))
4341 ipw_remove_current_network
4344 schedule_work(&priv->link_down);
4349 case CMAS_RX_ASSOC_RESP:
4353 IPW_ERROR("assoc: unknown (%d)\n",
4361 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4362 struct notif_authenticate *auth = ¬if->u.auth;
4363 switch (auth->state) {
4364 case CMAS_AUTHENTICATED:
4365 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4366 "authenticated: '%s' " MAC_FMT " \n",
4367 escape_essid(priv->essid,
4369 MAC_ARG(priv->bssid));
4370 priv->status |= STATUS_AUTH;
4374 if (priv->status & STATUS_AUTH) {
4375 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4377 "authentication failed (0x%04X): %s\n",
4378 ntohs(auth->status),
4379 ipw_get_status_code(ntohs
4383 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4385 "deauthenticated: '%s' " MAC_FMT "\n",
4386 escape_essid(priv->essid,
4388 MAC_ARG(priv->bssid));
4390 priv->status &= ~(STATUS_ASSOCIATING |
4394 schedule_work(&priv->link_down);
4397 case CMAS_TX_AUTH_SEQ_1:
4398 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4399 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4401 case CMAS_RX_AUTH_SEQ_2:
4402 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4403 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4405 case CMAS_AUTH_SEQ_1_PASS:
4406 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4407 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4409 case CMAS_AUTH_SEQ_1_FAIL:
4410 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4411 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4413 case CMAS_TX_AUTH_SEQ_3:
4414 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4415 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4417 case CMAS_RX_AUTH_SEQ_4:
4418 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4419 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4421 case CMAS_AUTH_SEQ_2_PASS:
4422 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4423 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4425 case CMAS_AUTH_SEQ_2_FAIL:
4426 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4427 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4430 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4431 IPW_DL_ASSOC, "TX_ASSOC\n");
4433 case CMAS_RX_ASSOC_RESP:
4434 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4435 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4438 case CMAS_ASSOCIATED:
4439 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4440 IPW_DL_ASSOC, "ASSOCIATED\n");
4443 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4450 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4451 struct notif_channel_result *x =
4452 ¬if->u.channel_result;
4454 if (notif->size == sizeof(*x)) {
4455 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4458 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4459 "(should be %zd)\n",
4460 notif->size, sizeof(*x));
4465 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4466 struct notif_scan_complete *x = ¬if->u.scan_complete;
4467 if (notif->size == sizeof(*x)) {
4469 ("Scan completed: type %d, %d channels, "
4470 "%d status\n", x->scan_type,
4471 x->num_channels, x->status);
4473 IPW_ERROR("Scan completed of wrong size %d "
4474 "(should be %zd)\n",
4475 notif->size, sizeof(*x));
4479 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4481 wake_up_interruptible(&priv->wait_state);
4482 cancel_delayed_work(&priv->scan_check);
4484 if (priv->status & STATUS_EXIT_PENDING)
4487 priv->ieee->scans++;
4489 #ifdef CONFIG_IPW2200_MONITOR
4490 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4491 priv->status |= STATUS_SCAN_FORCED;
4492 queue_work(priv->workqueue,
4493 &priv->request_scan);
4496 priv->status &= ~STATUS_SCAN_FORCED;
4497 #endif /* CONFIG_IPW2200_MONITOR */
4499 if (!(priv->status & (STATUS_ASSOCIATED |
4500 STATUS_ASSOCIATING |
4502 STATUS_DISASSOCIATING)))
4503 queue_work(priv->workqueue, &priv->associate);
4504 else if (priv->status & STATUS_ROAMING) {
4505 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4506 /* If a scan completed and we are in roam mode, then
4507 * the scan that completed was the one requested as a
4508 * result of entering roam... so, schedule the
4510 queue_work(priv->workqueue,
4513 /* Don't schedule if we aborted the scan */
4514 priv->status &= ~STATUS_ROAMING;
4515 } else if (priv->status & STATUS_SCAN_PENDING)
4516 queue_work(priv->workqueue,
4517 &priv->request_scan);
4518 else if (priv->config & CFG_BACKGROUND_SCAN
4519 && priv->status & STATUS_ASSOCIATED)
4520 queue_delayed_work(priv->workqueue,
4521 &priv->request_scan, HZ);
4525 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4526 struct notif_frag_length *x = ¬if->u.frag_len;
4528 if (notif->size == sizeof(*x))
4529 IPW_ERROR("Frag length: %d\n",
4530 le16_to_cpu(x->frag_length));
4532 IPW_ERROR("Frag length of wrong size %d "
4533 "(should be %zd)\n",
4534 notif->size, sizeof(*x));
4538 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4539 struct notif_link_deterioration *x =
4540 ¬if->u.link_deterioration;
4542 if (notif->size == sizeof(*x)) {
4543 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4544 "link deterioration: type %d, cnt %d\n",
4545 x->silence_notification_type,
4547 memcpy(&priv->last_link_deterioration, x,
4550 IPW_ERROR("Link Deterioration of wrong size %d "
4551 "(should be %zd)\n",
4552 notif->size, sizeof(*x));
4557 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4558 IPW_ERROR("Dino config\n");
4560 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4561 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4566 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4567 struct notif_beacon_state *x = ¬if->u.beacon_state;
4568 if (notif->size != sizeof(*x)) {
4570 ("Beacon state of wrong size %d (should "
4571 "be %zd)\n", notif->size, sizeof(*x));
4575 if (le32_to_cpu(x->state) ==
4576 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4577 ipw_handle_missed_beacon(priv,
4584 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4585 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4586 if (notif->size == sizeof(*x)) {
4587 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4588 "0x%02x station %d\n",
4589 x->key_state, x->security_type,
4595 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4596 notif->size, sizeof(*x));
4600 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4601 struct notif_calibration *x = ¬if->u.calibration;
4603 if (notif->size == sizeof(*x)) {
4604 memcpy(&priv->calib, x, sizeof(*x));
4605 IPW_DEBUG_INFO("TODO: Calibration\n");
4610 ("Calibration of wrong size %d (should be %zd)\n",
4611 notif->size, sizeof(*x));
4615 case HOST_NOTIFICATION_NOISE_STATS:{
4616 if (notif->size == sizeof(u32)) {
4618 (u8) (le32_to_cpu(notif->u.noise.value) &
4620 average_add(&priv->average_noise,
4626 ("Noise stat is wrong size %d (should be %zd)\n",
4627 notif->size, sizeof(u32));
4632 IPW_DEBUG_NOTIF("Unknown notification: "
4633 "subtype=%d,flags=0x%2x,size=%d\n",
4634 notif->subtype, notif->flags, notif->size);
4639 * Destroys all DMA structures and initialise them again
4642 * @return error code
4644 static int ipw_queue_reset(struct ipw_priv *priv)
4647 /** @todo customize queue sizes */
4648 int nTx = 64, nTxCmd = 8;
4649 ipw_tx_queue_free(priv);
4651 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4652 IPW_TX_CMD_QUEUE_READ_INDEX,
4653 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4654 IPW_TX_CMD_QUEUE_BD_BASE,
4655 IPW_TX_CMD_QUEUE_BD_SIZE);
4657 IPW_ERROR("Tx Cmd queue init failed\n");
4661 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4662 IPW_TX_QUEUE_0_READ_INDEX,
4663 IPW_TX_QUEUE_0_WRITE_INDEX,
4664 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4666 IPW_ERROR("Tx 0 queue init failed\n");
4669 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4670 IPW_TX_QUEUE_1_READ_INDEX,
4671 IPW_TX_QUEUE_1_WRITE_INDEX,
4672 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4674 IPW_ERROR("Tx 1 queue init failed\n");
4677 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4678 IPW_TX_QUEUE_2_READ_INDEX,
4679 IPW_TX_QUEUE_2_WRITE_INDEX,
4680 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4682 IPW_ERROR("Tx 2 queue init failed\n");
4685 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4686 IPW_TX_QUEUE_3_READ_INDEX,
4687 IPW_TX_QUEUE_3_WRITE_INDEX,
4688 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4690 IPW_ERROR("Tx 3 queue init failed\n");
4694 priv->rx_bufs_min = 0;
4695 priv->rx_pend_max = 0;
4699 ipw_tx_queue_free(priv);
4704 * Reclaim Tx queue entries no more used by NIC.
4706 * When FW adwances 'R' index, all entries between old and
4707 * new 'R' index need to be reclaimed. As result, some free space
4708 * forms. If there is enough free space (> low mark), wake Tx queue.
4710 * @note Need to protect against garbage in 'R' index
4714 * @return Number of used entries remains in the queue
4716 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4717 struct clx2_tx_queue *txq, int qindex)
4721 struct clx2_queue *q = &txq->q;
4723 hw_tail = ipw_read32(priv, q->reg_r);
4724 if (hw_tail >= q->n_bd) {
4726 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4730 for (; q->last_used != hw_tail;
4731 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4732 ipw_queue_tx_free_tfd(priv, txq);
4736 if ((ipw_queue_space(q) > q->low_mark) &&
4738 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4739 netif_wake_queue(priv->net_dev);
4740 used = q->first_empty - q->last_used;
4747 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4750 struct clx2_tx_queue *txq = &priv->txq_cmd;
4751 struct clx2_queue *q = &txq->q;
4752 struct tfd_frame *tfd;
4754 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4755 IPW_ERROR("No space for Tx\n");
4759 tfd = &txq->bd[q->first_empty];
4760 txq->txb[q->first_empty] = NULL;
4762 memset(tfd, 0, sizeof(*tfd));
4763 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4764 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4766 tfd->u.cmd.index = hcmd;
4767 tfd->u.cmd.length = len;
4768 memcpy(tfd->u.cmd.payload, buf, len);
4769 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4770 ipw_write32(priv, q->reg_w, q->first_empty);
4771 _ipw_read32(priv, 0x90);
4777 * Rx theory of operation
4779 * The host allocates 32 DMA target addresses and passes the host address
4780 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4784 * The host/firmware share two index registers for managing the Rx buffers.
4786 * The READ index maps to the first position that the firmware may be writing
4787 * to -- the driver can read up to (but not including) this position and get
4789 * The READ index is managed by the firmware once the card is enabled.
4791 * The WRITE index maps to the last position the driver has read from -- the
4792 * position preceding WRITE is the last slot the firmware can place a packet.
4794 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4797 * During initialization the host sets up the READ queue position to the first
4798 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4800 * When the firmware places a packet in a buffer it will advance the READ index
4801 * and fire the RX interrupt. The driver can then query the READ index and
4802 * process as many packets as possible, moving the WRITE index forward as it
4803 * resets the Rx queue buffers with new memory.
4805 * The management in the driver is as follows:
4806 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
4807 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4808 * to replensish the ipw->rxq->rx_free.
4809 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4810 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4811 * 'processed' and 'read' driver indexes as well)
4812 * + A received packet is processed and handed to the kernel network stack,
4813 * detached from the ipw->rxq. The driver 'processed' index is updated.
4814 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4815 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4816 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
4817 * were enough free buffers and RX_STALLED is set it is cleared.
4822 * ipw_rx_queue_alloc() Allocates rx_free
4823 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4824 * ipw_rx_queue_restock
4825 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4826 * queue, updates firmware pointers, and updates
4827 * the WRITE index. If insufficient rx_free buffers
4828 * are available, schedules ipw_rx_queue_replenish
4830 * -- enable interrupts --
4831 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
4832 * READ INDEX, detaching the SKB from the pool.
4833 * Moves the packet buffer from queue to rx_used.
4834 * Calls ipw_rx_queue_restock to refill any empty
4841 * If there are slots in the RX queue that need to be restocked,
4842 * and we have free pre-allocated buffers, fill the ranks as much
4843 * as we can pulling from rx_free.
4845 * This moves the 'write' index forward to catch up with 'processed', and
4846 * also updates the memory address in the firmware to reference the new
4849 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4851 struct ipw_rx_queue *rxq = priv->rxq;
4852 struct list_head *element;
4853 struct ipw_rx_mem_buffer *rxb;
4854 unsigned long flags;
4857 spin_lock_irqsave(&rxq->lock, flags);
4859 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4860 element = rxq->rx_free.next;
4861 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4864 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4866 rxq->queue[rxq->write] = rxb;
4867 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4870 spin_unlock_irqrestore(&rxq->lock, flags);
4872 /* If the pre-allocated buffer pool is dropping low, schedule to
4874 if (rxq->free_count <= RX_LOW_WATERMARK)
4875 queue_work(priv->workqueue, &priv->rx_replenish);
4877 /* If we've added more space for the firmware to place data, tell it */
4878 if (write != rxq->write)
4879 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4883 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4884 * Also restock the Rx queue via ipw_rx_queue_restock.
4886 * This is called as a scheduled work item (except for during intialization)
4888 static void ipw_rx_queue_replenish(void *data)
4890 struct ipw_priv *priv = data;
4891 struct ipw_rx_queue *rxq = priv->rxq;
4892 struct list_head *element;
4893 struct ipw_rx_mem_buffer *rxb;
4894 unsigned long flags;
4896 spin_lock_irqsave(&rxq->lock, flags);
4897 while (!list_empty(&rxq->rx_used)) {
4898 element = rxq->rx_used.next;
4899 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4900 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4902 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4903 priv->net_dev->name);
4904 /* We don't reschedule replenish work here -- we will
4905 * call the restock method and if it still needs
4906 * more buffers it will schedule replenish */
4911 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4913 pci_map_single(priv->pci_dev, rxb->skb->data,
4914 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4916 list_add_tail(&rxb->list, &rxq->rx_free);
4919 spin_unlock_irqrestore(&rxq->lock, flags);
4921 ipw_rx_queue_restock(priv);
4924 static void ipw_bg_rx_queue_replenish(void *data)
4926 struct ipw_priv *priv = data;
4927 mutex_lock(&priv->mutex);
4928 ipw_rx_queue_replenish(data);
4929 mutex_unlock(&priv->mutex);
4932 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4933 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
4934 * This free routine walks the list of POOL entries and if SKB is set to
4935 * non NULL it is unmapped and freed
4937 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4944 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4945 if (rxq->pool[i].skb != NULL) {
4946 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4947 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4948 dev_kfree_skb(rxq->pool[i].skb);
4955 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4957 struct ipw_rx_queue *rxq;
4960 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
4961 if (unlikely(!rxq)) {
4962 IPW_ERROR("memory allocation failed\n");
4965 spin_lock_init(&rxq->lock);
4966 INIT_LIST_HEAD(&rxq->rx_free);
4967 INIT_LIST_HEAD(&rxq->rx_used);
4969 /* Fill the rx_used queue with _all_ of the Rx buffers */
4970 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
4971 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4973 /* Set us so that we have processed and used all buffers, but have
4974 * not restocked the Rx queue with fresh buffers */
4975 rxq->read = rxq->write = 0;
4976 rxq->processed = RX_QUEUE_SIZE - 1;
4977 rxq->free_count = 0;
4982 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4984 rate &= ~IEEE80211_BASIC_RATE_MASK;
4985 if (ieee_mode == IEEE_A) {
4987 case IEEE80211_OFDM_RATE_6MB:
4988 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4990 case IEEE80211_OFDM_RATE_9MB:
4991 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4993 case IEEE80211_OFDM_RATE_12MB:
4995 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4996 case IEEE80211_OFDM_RATE_18MB:
4998 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
4999 case IEEE80211_OFDM_RATE_24MB:
5001 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5002 case IEEE80211_OFDM_RATE_36MB:
5004 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5005 case IEEE80211_OFDM_RATE_48MB:
5007 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5008 case IEEE80211_OFDM_RATE_54MB:
5010 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5018 case IEEE80211_CCK_RATE_1MB:
5019 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5020 case IEEE80211_CCK_RATE_2MB:
5021 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5022 case IEEE80211_CCK_RATE_5MB:
5023 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5024 case IEEE80211_CCK_RATE_11MB:
5025 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5028 /* If we are limited to B modulations, bail at this point */
5029 if (ieee_mode == IEEE_B)
5034 case IEEE80211_OFDM_RATE_6MB:
5035 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5036 case IEEE80211_OFDM_RATE_9MB:
5037 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5038 case IEEE80211_OFDM_RATE_12MB:
5039 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5040 case IEEE80211_OFDM_RATE_18MB:
5041 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5042 case IEEE80211_OFDM_RATE_24MB:
5043 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5044 case IEEE80211_OFDM_RATE_36MB:
5045 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5046 case IEEE80211_OFDM_RATE_48MB:
5047 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5048 case IEEE80211_OFDM_RATE_54MB:
5049 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5055 static int ipw_compatible_rates(struct ipw_priv *priv,
5056 const struct ieee80211_network *network,
5057 struct ipw_supported_rates *rates)
5061 memset(rates, 0, sizeof(*rates));
5062 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5063 rates->num_rates = 0;
5064 for (i = 0; i < num_rates; i++) {
5065 if (!ipw_is_rate_in_mask(priv, network->mode,
5066 network->rates[i])) {
5068 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5069 IPW_DEBUG_SCAN("Adding masked mandatory "
5072 rates->supported_rates[rates->num_rates++] =
5077 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5078 network->rates[i], priv->rates_mask);
5082 rates->supported_rates[rates->num_rates++] = network->rates[i];
5085 num_rates = min(network->rates_ex_len,
5086 (u8) (IPW_MAX_RATES - num_rates));
5087 for (i = 0; i < num_rates; i++) {
5088 if (!ipw_is_rate_in_mask(priv, network->mode,
5089 network->rates_ex[i])) {
5090 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5091 IPW_DEBUG_SCAN("Adding masked mandatory "
5093 network->rates_ex[i]);
5094 rates->supported_rates[rates->num_rates++] =
5099 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5100 network->rates_ex[i], priv->rates_mask);
5104 rates->supported_rates[rates->num_rates++] =
5105 network->rates_ex[i];
5111 static void ipw_copy_rates(struct ipw_supported_rates *dest,
5112 const struct ipw_supported_rates *src)
5115 for (i = 0; i < src->num_rates; i++)
5116 dest->supported_rates[i] = src->supported_rates[i];
5117 dest->num_rates = src->num_rates;
5120 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5121 * mask should ever be used -- right now all callers to add the scan rates are
5122 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5123 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5124 u8 modulation, u32 rate_mask)
5126 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5127 IEEE80211_BASIC_RATE_MASK : 0;
5129 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5130 rates->supported_rates[rates->num_rates++] =
5131 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5133 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5134 rates->supported_rates[rates->num_rates++] =
5135 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5137 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5138 rates->supported_rates[rates->num_rates++] = basic_mask |
5139 IEEE80211_CCK_RATE_5MB;
5141 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5142 rates->supported_rates[rates->num_rates++] = basic_mask |
5143 IEEE80211_CCK_RATE_11MB;
5146 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5147 u8 modulation, u32 rate_mask)
5149 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5150 IEEE80211_BASIC_RATE_MASK : 0;
5152 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5153 rates->supported_rates[rates->num_rates++] = basic_mask |
5154 IEEE80211_OFDM_RATE_6MB;
5156 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5157 rates->supported_rates[rates->num_rates++] =
5158 IEEE80211_OFDM_RATE_9MB;
5160 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5161 rates->supported_rates[rates->num_rates++] = basic_mask |
5162 IEEE80211_OFDM_RATE_12MB;
5164 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5165 rates->supported_rates[rates->num_rates++] =
5166 IEEE80211_OFDM_RATE_18MB;
5168 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5169 rates->supported_rates[rates->num_rates++] = basic_mask |
5170 IEEE80211_OFDM_RATE_24MB;
5172 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5173 rates->supported_rates[rates->num_rates++] =
5174 IEEE80211_OFDM_RATE_36MB;
5176 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5177 rates->supported_rates[rates->num_rates++] =
5178 IEEE80211_OFDM_RATE_48MB;
5180 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5181 rates->supported_rates[rates->num_rates++] =
5182 IEEE80211_OFDM_RATE_54MB;
5185 struct ipw_network_match {
5186 struct ieee80211_network *network;
5187 struct ipw_supported_rates rates;
5190 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5191 struct ipw_network_match *match,
5192 struct ieee80211_network *network,
5195 struct ipw_supported_rates rates;
5197 /* Verify that this network's capability is compatible with the
5198 * current mode (AdHoc or Infrastructure) */
5199 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5200 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5201 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5202 "capability mismatch.\n",
5203 escape_essid(network->ssid, network->ssid_len),
5204 MAC_ARG(network->bssid));
5208 /* If we do not have an ESSID for this AP, we can not associate with
5210 if (network->flags & NETWORK_EMPTY_ESSID) {
5211 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5212 "because of hidden ESSID.\n",
5213 escape_essid(network->ssid, network->ssid_len),
5214 MAC_ARG(network->bssid));
5218 if (unlikely(roaming)) {
5219 /* If we are roaming, then ensure check if this is a valid
5220 * network to try and roam to */
5221 if ((network->ssid_len != match->network->ssid_len) ||
5222 memcmp(network->ssid, match->network->ssid,
5223 network->ssid_len)) {
5224 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5225 "because of non-network ESSID.\n",
5226 escape_essid(network->ssid,
5228 MAC_ARG(network->bssid));
5232 /* If an ESSID has been configured then compare the broadcast
5234 if ((priv->config & CFG_STATIC_ESSID) &&
5235 ((network->ssid_len != priv->essid_len) ||
5236 memcmp(network->ssid, priv->essid,
5237 min(network->ssid_len, priv->essid_len)))) {
5238 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5241 escape_essid(network->ssid, network->ssid_len),
5243 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5244 "because of ESSID mismatch: '%s'.\n",
5245 escaped, MAC_ARG(network->bssid),
5246 escape_essid(priv->essid,
5252 /* If the old network rate is better than this one, don't bother
5253 * testing everything else. */
5255 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5256 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5257 "current network.\n",
5258 escape_essid(match->network->ssid,
5259 match->network->ssid_len));
5261 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5262 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5263 "current network.\n",
5264 escape_essid(match->network->ssid,
5265 match->network->ssid_len));
5269 /* Now go through and see if the requested network is valid... */
5270 if (priv->ieee->scan_age != 0 &&
5271 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5272 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5273 "because of age: %ums.\n",
5274 escape_essid(network->ssid, network->ssid_len),
5275 MAC_ARG(network->bssid),
5276 jiffies_to_msecs(jiffies -
5277 network->last_scanned));
5281 if ((priv->config & CFG_STATIC_CHANNEL) &&
5282 (network->channel != priv->channel)) {
5283 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5284 "because of channel mismatch: %d != %d.\n",
5285 escape_essid(network->ssid, network->ssid_len),
5286 MAC_ARG(network->bssid),
5287 network->channel, priv->channel);
5291 /* Verify privacy compatability */
5292 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5293 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5294 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5295 "because of privacy mismatch: %s != %s.\n",
5296 escape_essid(network->ssid, network->ssid_len),
5297 MAC_ARG(network->bssid),
5299 capability & CAP_PRIVACY_ON ? "on" : "off",
5301 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5306 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5307 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5308 "because of the same BSSID match: " MAC_FMT
5309 ".\n", escape_essid(network->ssid,
5311 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5315 /* Filter out any incompatible freq / mode combinations */
5316 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5317 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5318 "because of invalid frequency/mode "
5320 escape_essid(network->ssid, network->ssid_len),
5321 MAC_ARG(network->bssid));
5325 /* Ensure that the rates supported by the driver are compatible with
5326 * this AP, including verification of basic rates (mandatory) */
5327 if (!ipw_compatible_rates(priv, network, &rates)) {
5328 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5329 "because configured rate mask excludes "
5330 "AP mandatory rate.\n",
5331 escape_essid(network->ssid, network->ssid_len),
5332 MAC_ARG(network->bssid));
5336 if (rates.num_rates == 0) {
5337 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5338 "because of no compatible rates.\n",
5339 escape_essid(network->ssid, network->ssid_len),
5340 MAC_ARG(network->bssid));
5344 /* TODO: Perform any further minimal comparititive tests. We do not
5345 * want to put too much policy logic here; intelligent scan selection
5346 * should occur within a generic IEEE 802.11 user space tool. */
5348 /* Set up 'new' AP to this network */
5349 ipw_copy_rates(&match->rates, &rates);
5350 match->network = network;
5351 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5352 escape_essid(network->ssid, network->ssid_len),
5353 MAC_ARG(network->bssid));
5358 static void ipw_merge_adhoc_network(void *data)
5360 struct ipw_priv *priv = data;
5361 struct ieee80211_network *network = NULL;
5362 struct ipw_network_match match = {
5363 .network = priv->assoc_network
5366 if ((priv->status & STATUS_ASSOCIATED) &&
5367 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5368 /* First pass through ROAM process -- look for a better
5370 unsigned long flags;
5372 spin_lock_irqsave(&priv->ieee->lock, flags);
5373 list_for_each_entry(network, &priv->ieee->network_list, list) {
5374 if (network != priv->assoc_network)
5375 ipw_find_adhoc_network(priv, &match, network,
5378 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5380 if (match.network == priv->assoc_network) {
5381 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5386 mutex_lock(&priv->mutex);
5387 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5388 IPW_DEBUG_MERGE("remove network %s\n",
5389 escape_essid(priv->essid,
5391 ipw_remove_current_network(priv);
5394 ipw_disassociate(priv);
5395 priv->assoc_network = match.network;
5396 mutex_unlock(&priv->mutex);
5401 static int ipw_best_network(struct ipw_priv *priv,
5402 struct ipw_network_match *match,
5403 struct ieee80211_network *network, int roaming)
5405 struct ipw_supported_rates rates;
5407 /* Verify that this network's capability is compatible with the
5408 * current mode (AdHoc or Infrastructure) */
5409 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5410 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5411 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5412 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5413 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5414 "capability mismatch.\n",
5415 escape_essid(network->ssid, network->ssid_len),
5416 MAC_ARG(network->bssid));
5420 /* If we do not have an ESSID for this AP, we can not associate with
5422 if (network->flags & NETWORK_EMPTY_ESSID) {
5423 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5424 "because of hidden ESSID.\n",
5425 escape_essid(network->ssid, network->ssid_len),
5426 MAC_ARG(network->bssid));
5430 if (unlikely(roaming)) {
5431 /* If we are roaming, then ensure check if this is a valid
5432 * network to try and roam to */
5433 if ((network->ssid_len != match->network->ssid_len) ||
5434 memcmp(network->ssid, match->network->ssid,
5435 network->ssid_len)) {
5436 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5437 "because of non-network ESSID.\n",
5438 escape_essid(network->ssid,
5440 MAC_ARG(network->bssid));
5444 /* If an ESSID has been configured then compare the broadcast
5446 if ((priv->config & CFG_STATIC_ESSID) &&
5447 ((network->ssid_len != priv->essid_len) ||
5448 memcmp(network->ssid, priv->essid,
5449 min(network->ssid_len, priv->essid_len)))) {
5450 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5452 escape_essid(network->ssid, network->ssid_len),
5454 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5455 "because of ESSID mismatch: '%s'.\n",
5456 escaped, MAC_ARG(network->bssid),
5457 escape_essid(priv->essid,
5463 /* If the old network rate is better than this one, don't bother
5464 * testing everything else. */
5465 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5466 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5468 escape_essid(network->ssid, network->ssid_len),
5470 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5471 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5472 escaped, MAC_ARG(network->bssid),
5473 escape_essid(match->network->ssid,
5474 match->network->ssid_len),
5475 MAC_ARG(match->network->bssid));
5479 /* If this network has already had an association attempt within the
5480 * last 3 seconds, do not try and associate again... */
5481 if (network->last_associate &&
5482 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5483 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5484 "because of storming (%ums since last "
5485 "assoc attempt).\n",
5486 escape_essid(network->ssid, network->ssid_len),
5487 MAC_ARG(network->bssid),
5488 jiffies_to_msecs(jiffies -
5489 network->last_associate));
5493 /* Now go through and see if the requested network is valid... */
5494 if (priv->ieee->scan_age != 0 &&
5495 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5496 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5497 "because of age: %ums.\n",
5498 escape_essid(network->ssid, network->ssid_len),
5499 MAC_ARG(network->bssid),
5500 jiffies_to_msecs(jiffies -
5501 network->last_scanned));
5505 if ((priv->config & CFG_STATIC_CHANNEL) &&
5506 (network->channel != priv->channel)) {
5507 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5508 "because of channel mismatch: %d != %d.\n",
5509 escape_essid(network->ssid, network->ssid_len),
5510 MAC_ARG(network->bssid),
5511 network->channel, priv->channel);
5515 /* Verify privacy compatability */
5516 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5517 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5518 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5519 "because of privacy mismatch: %s != %s.\n",
5520 escape_essid(network->ssid, network->ssid_len),
5521 MAC_ARG(network->bssid),
5522 priv->capability & CAP_PRIVACY_ON ? "on" :
5524 network->capability &
5525 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5529 if ((priv->config & CFG_STATIC_BSSID) &&
5530 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5531 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5532 "because of BSSID mismatch: " MAC_FMT ".\n",
5533 escape_essid(network->ssid, network->ssid_len),
5534 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5538 /* Filter out any incompatible freq / mode combinations */
5539 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5540 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5541 "because of invalid frequency/mode "
5543 escape_essid(network->ssid, network->ssid_len),
5544 MAC_ARG(network->bssid));
5548 /* Filter out invalid channel in current GEO */
5549 if (!ieee80211_is_valid_channel(priv->ieee, network->channel)) {
5550 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5551 "because of invalid channel in current GEO\n",
5552 escape_essid(network->ssid, network->ssid_len),
5553 MAC_ARG(network->bssid));
5557 /* Ensure that the rates supported by the driver are compatible with
5558 * this AP, including verification of basic rates (mandatory) */
5559 if (!ipw_compatible_rates(priv, network, &rates)) {
5560 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5561 "because configured rate mask excludes "
5562 "AP mandatory rate.\n",
5563 escape_essid(network->ssid, network->ssid_len),
5564 MAC_ARG(network->bssid));
5568 if (rates.num_rates == 0) {
5569 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5570 "because of no compatible rates.\n",
5571 escape_essid(network->ssid, network->ssid_len),
5572 MAC_ARG(network->bssid));
5576 /* TODO: Perform any further minimal comparititive tests. We do not
5577 * want to put too much policy logic here; intelligent scan selection
5578 * should occur within a generic IEEE 802.11 user space tool. */
5580 /* Set up 'new' AP to this network */
5581 ipw_copy_rates(&match->rates, &rates);
5582 match->network = network;
5584 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5585 escape_essid(network->ssid, network->ssid_len),
5586 MAC_ARG(network->bssid));
5591 static void ipw_adhoc_create(struct ipw_priv *priv,
5592 struct ieee80211_network *network)
5594 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
5598 * For the purposes of scanning, we can set our wireless mode
5599 * to trigger scans across combinations of bands, but when it
5600 * comes to creating a new ad-hoc network, we have tell the FW
5601 * exactly which band to use.
5603 * We also have the possibility of an invalid channel for the
5604 * chossen band. Attempting to create a new ad-hoc network
5605 * with an invalid channel for wireless mode will trigger a
5609 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
5610 case IEEE80211_52GHZ_BAND:
5611 network->mode = IEEE_A;
5612 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
5615 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5616 IPW_WARNING("Overriding invalid channel\n");
5617 priv->channel = geo->a[0].channel;
5621 case IEEE80211_24GHZ_BAND:
5622 if (priv->ieee->mode & IEEE_G)
5623 network->mode = IEEE_G;
5625 network->mode = IEEE_B;
5626 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
5629 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5630 IPW_WARNING("Overriding invalid channel\n");
5631 priv->channel = geo->bg[0].channel;
5636 IPW_WARNING("Overriding invalid channel\n");
5637 if (priv->ieee->mode & IEEE_A) {
5638 network->mode = IEEE_A;
5639 priv->channel = geo->a[0].channel;
5640 } else if (priv->ieee->mode & IEEE_G) {
5641 network->mode = IEEE_G;
5642 priv->channel = geo->bg[0].channel;
5644 network->mode = IEEE_B;
5645 priv->channel = geo->bg[0].channel;
5650 network->channel = priv->channel;
5651 priv->config |= CFG_ADHOC_PERSIST;
5652 ipw_create_bssid(priv, network->bssid);
5653 network->ssid_len = priv->essid_len;
5654 memcpy(network->ssid, priv->essid, priv->essid_len);
5655 memset(&network->stats, 0, sizeof(network->stats));
5656 network->capability = WLAN_CAPABILITY_IBSS;
5657 if (!(priv->config & CFG_PREAMBLE_LONG))
5658 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5659 if (priv->capability & CAP_PRIVACY_ON)
5660 network->capability |= WLAN_CAPABILITY_PRIVACY;
5661 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5662 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5663 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5664 memcpy(network->rates_ex,
5665 &priv->rates.supported_rates[network->rates_len],
5666 network->rates_ex_len);
5667 network->last_scanned = 0;
5669 network->last_associate = 0;
5670 network->time_stamp[0] = 0;
5671 network->time_stamp[1] = 0;
5672 network->beacon_interval = 100; /* Default */
5673 network->listen_interval = 10; /* Default */
5674 network->atim_window = 0; /* Default */
5675 network->wpa_ie_len = 0;
5676 network->rsn_ie_len = 0;
5679 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5681 struct ipw_tgi_tx_key key;
5683 if (!(priv->ieee->sec.flags & (1 << index)))
5687 memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5688 key.security_type = type;
5689 key.station_index = 0; /* always 0 for BSS */
5691 /* 0 for new key; previous value of counter (after fatal error) */
5692 key.tx_counter[0] = 0;
5693 key.tx_counter[1] = 0;
5695 ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
5698 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5700 struct ipw_wep_key key;
5703 key.cmd_id = DINO_CMD_WEP_KEY;
5706 /* Note: AES keys cannot be set for multiple times.
5707 * Only set it at the first time. */
5708 for (i = 0; i < 4; i++) {
5709 key.key_index = i | type;
5710 if (!(priv->ieee->sec.flags & (1 << i))) {
5715 key.key_size = priv->ieee->sec.key_sizes[i];
5716 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
5718 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
5722 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5724 if (priv->ieee->host_encrypt)
5729 priv->sys_config.disable_unicast_decryption = 0;
5730 priv->ieee->host_decrypt = 0;
5733 priv->sys_config.disable_unicast_decryption = 1;
5734 priv->ieee->host_decrypt = 1;
5737 priv->sys_config.disable_unicast_decryption = 0;
5738 priv->ieee->host_decrypt = 0;
5741 priv->sys_config.disable_unicast_decryption = 1;
5748 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5750 if (priv->ieee->host_encrypt)
5755 priv->sys_config.disable_multicast_decryption = 0;
5758 priv->sys_config.disable_multicast_decryption = 1;
5761 priv->sys_config.disable_multicast_decryption = 0;
5764 priv->sys_config.disable_multicast_decryption = 1;
5771 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5773 switch (priv->ieee->sec.level) {
5775 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5776 ipw_send_tgi_tx_key(priv,
5777 DCT_FLAG_EXT_SECURITY_CCM,
5778 priv->ieee->sec.active_key);
5780 if (!priv->ieee->host_mc_decrypt)
5781 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5784 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5785 ipw_send_tgi_tx_key(priv,
5786 DCT_FLAG_EXT_SECURITY_TKIP,
5787 priv->ieee->sec.active_key);
5790 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5791 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5792 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5800 static void ipw_adhoc_check(void *data)
5802 struct ipw_priv *priv = data;
5804 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5805 !(priv->config & CFG_ADHOC_PERSIST)) {
5806 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5807 IPW_DL_STATE | IPW_DL_ASSOC,
5808 "Missed beacon: %d - disassociate\n",
5809 priv->missed_adhoc_beacons);
5810 ipw_remove_current_network(priv);
5811 ipw_disassociate(priv);
5815 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5816 priv->assoc_request.beacon_interval);
5819 static void ipw_bg_adhoc_check(void *data)
5821 struct ipw_priv *priv = data;
5822 mutex_lock(&priv->mutex);
5823 ipw_adhoc_check(data);
5824 mutex_unlock(&priv->mutex);
5827 #ifdef CONFIG_IPW2200_DEBUG
5828 static void ipw_debug_config(struct ipw_priv *priv)
5830 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5831 "[CFG 0x%08X]\n", priv->config);
5832 if (priv->config & CFG_STATIC_CHANNEL)
5833 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5835 IPW_DEBUG_INFO("Channel unlocked.\n");
5836 if (priv->config & CFG_STATIC_ESSID)
5837 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5838 escape_essid(priv->essid, priv->essid_len));
5840 IPW_DEBUG_INFO("ESSID unlocked.\n");
5841 if (priv->config & CFG_STATIC_BSSID)
5842 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5843 MAC_ARG(priv->bssid));
5845 IPW_DEBUG_INFO("BSSID unlocked.\n");
5846 if (priv->capability & CAP_PRIVACY_ON)
5847 IPW_DEBUG_INFO("PRIVACY on\n");
5849 IPW_DEBUG_INFO("PRIVACY off\n");
5850 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5853 #define ipw_debug_config(x) do {} while (0)
5856 static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5858 /* TODO: Verify that this works... */
5859 struct ipw_fixed_rate fr = {
5860 .tx_rates = priv->rates_mask
5865 /* Identify 'current FW band' and match it with the fixed
5868 switch (priv->ieee->freq_band) {
5869 case IEEE80211_52GHZ_BAND: /* A only */
5871 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5872 /* Invalid fixed rate mask */
5874 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5879 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5882 default: /* 2.4Ghz or Mixed */
5884 if (mode == IEEE_B) {
5885 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5886 /* Invalid fixed rate mask */
5888 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5895 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5896 IEEE80211_OFDM_RATES_MASK)) {
5897 /* Invalid fixed rate mask */
5899 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5904 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5905 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5906 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5909 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5910 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5911 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5914 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5915 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5916 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5919 fr.tx_rates |= mask;
5923 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5924 ipw_write_reg32(priv, reg, *(u32 *) & fr);
5927 static void ipw_abort_scan(struct ipw_priv *priv)
5931 if (priv->status & STATUS_SCAN_ABORTING) {
5932 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5935 priv->status |= STATUS_SCAN_ABORTING;
5937 err = ipw_send_scan_abort(priv);
5939 IPW_DEBUG_HC("Request to abort scan failed.\n");
5942 static void ipw_add_scan_channels(struct ipw_priv *priv,
5943 struct ipw_scan_request_ext *scan,
5946 int channel_index = 0;
5947 const struct ieee80211_geo *geo;
5950 geo = ieee80211_get_geo(priv->ieee);
5952 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5953 int start = channel_index;
5954 for (i = 0; i < geo->a_channels; i++) {
5955 if ((priv->status & STATUS_ASSOCIATED) &&
5956 geo->a[i].channel == priv->channel)
5959 scan->channels_list[channel_index] = geo->a[i].channel;
5960 ipw_set_scan_type(scan, channel_index,
5962 flags & IEEE80211_CH_PASSIVE_ONLY ?
5963 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5967 if (start != channel_index) {
5968 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5969 (channel_index - start);
5974 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5975 int start = channel_index;
5976 if (priv->config & CFG_SPEED_SCAN) {
5978 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5979 /* nop out the list */
5984 while (channel_index < IPW_SCAN_CHANNELS) {
5986 priv->speed_scan[priv->speed_scan_pos];
5988 priv->speed_scan_pos = 0;
5989 channel = priv->speed_scan[0];
5991 if ((priv->status & STATUS_ASSOCIATED) &&
5992 channel == priv->channel) {
5993 priv->speed_scan_pos++;
5997 /* If this channel has already been
5998 * added in scan, break from loop
5999 * and this will be the first channel
6002 if (channels[channel - 1] != 0)
6005 channels[channel - 1] = 1;
6006 priv->speed_scan_pos++;
6008 scan->channels_list[channel_index] = channel;
6010 ieee80211_channel_to_index(priv->ieee, channel);
6011 ipw_set_scan_type(scan, channel_index,
6014 IEEE80211_CH_PASSIVE_ONLY ?
6015 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6019 for (i = 0; i < geo->bg_channels; i++) {
6020 if ((priv->status & STATUS_ASSOCIATED) &&
6021 geo->bg[i].channel == priv->channel)
6024 scan->channels_list[channel_index] =
6026 ipw_set_scan_type(scan, channel_index,
6029 IEEE80211_CH_PASSIVE_ONLY ?
6030 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6035 if (start != channel_index) {
6036 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6037 (channel_index - start);
6042 static int ipw_request_scan(struct ipw_priv *priv)
6044 struct ipw_scan_request_ext scan;
6045 int err = 0, scan_type;
6047 if (!(priv->status & STATUS_INIT) ||
6048 (priv->status & STATUS_EXIT_PENDING))
6051 mutex_lock(&priv->mutex);
6053 if (priv->status & STATUS_SCANNING) {
6054 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
6055 priv->status |= STATUS_SCAN_PENDING;
6059 if (!(priv->status & STATUS_SCAN_FORCED) &&
6060 priv->status & STATUS_SCAN_ABORTING) {
6061 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6062 priv->status |= STATUS_SCAN_PENDING;
6066 if (priv->status & STATUS_RF_KILL_MASK) {
6067 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6068 priv->status |= STATUS_SCAN_PENDING;
6072 memset(&scan, 0, sizeof(scan));
6074 if (priv->config & CFG_SPEED_SCAN)
6075 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6078 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6081 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6083 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6085 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6087 #ifdef CONFIG_IPW2200_MONITOR
6088 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6092 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
6093 case IEEE80211_52GHZ_BAND:
6094 band = (u8) (IPW_A_MODE << 6) | 1;
6095 channel = priv->channel;
6098 case IEEE80211_24GHZ_BAND:
6099 band = (u8) (IPW_B_MODE << 6) | 1;
6100 channel = priv->channel;
6104 band = (u8) (IPW_B_MODE << 6) | 1;
6109 scan.channels_list[0] = band;
6110 scan.channels_list[1] = channel;
6111 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6113 /* NOTE: The card will sit on this channel for this time
6114 * period. Scan aborts are timing sensitive and frequently
6115 * result in firmware restarts. As such, it is best to
6116 * set a small dwell_time here and just keep re-issuing
6117 * scans. Otherwise fast channel hopping will not actually
6120 * TODO: Move SPEED SCAN support to all modes and bands */
6121 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6124 #endif /* CONFIG_IPW2200_MONITOR */
6125 /* If we are roaming, then make this a directed scan for the
6126 * current network. Otherwise, ensure that every other scan
6127 * is a fast channel hop scan */
6128 if ((priv->status & STATUS_ROAMING)
6129 || (!(priv->status & STATUS_ASSOCIATED)
6130 && (priv->config & CFG_STATIC_ESSID)
6131 && (le32_to_cpu(scan.full_scan_index) % 2))) {
6132 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6134 IPW_DEBUG_HC("Attempt to send SSID command "
6139 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6141 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6143 ipw_add_scan_channels(priv, &scan, scan_type);
6144 #ifdef CONFIG_IPW2200_MONITOR
6148 err = ipw_send_scan_request_ext(priv, &scan);
6150 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6154 priv->status |= STATUS_SCANNING;
6155 priv->status &= ~STATUS_SCAN_PENDING;
6156 queue_delayed_work(priv->workqueue, &priv->scan_check,
6157 IPW_SCAN_CHECK_WATCHDOG);
6159 mutex_unlock(&priv->mutex);
6163 static void ipw_bg_abort_scan(void *data)
6165 struct ipw_priv *priv = data;
6166 mutex_lock(&priv->mutex);
6167 ipw_abort_scan(data);
6168 mutex_unlock(&priv->mutex);
6171 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6173 /* This is called when wpa_supplicant loads and closes the driver
6175 priv->ieee->wpa_enabled = value;
6179 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6181 struct ieee80211_device *ieee = priv->ieee;
6182 struct ieee80211_security sec = {
6183 .flags = SEC_AUTH_MODE,
6187 if (value & IW_AUTH_ALG_SHARED_KEY) {
6188 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6190 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6191 sec.auth_mode = WLAN_AUTH_OPEN;
6193 } else if (value & IW_AUTH_ALG_LEAP) {
6194 sec.auth_mode = WLAN_AUTH_LEAP;
6199 if (ieee->set_security)
6200 ieee->set_security(ieee->dev, &sec);
6207 static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6210 /* make sure WPA is enabled */
6211 ipw_wpa_enable(priv, 1);
6213 ipw_disassociate(priv);
6216 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6217 char *capabilities, int length)
6219 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6221 return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
6230 static int ipw_wx_set_genie(struct net_device *dev,
6231 struct iw_request_info *info,
6232 union iwreq_data *wrqu, char *extra)
6234 struct ipw_priv *priv = ieee80211_priv(dev);
6235 struct ieee80211_device *ieee = priv->ieee;
6239 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6240 (wrqu->data.length && extra == NULL))
6243 //mutex_lock(&priv->mutex);
6245 //if (!ieee->wpa_enabled) {
6246 // err = -EOPNOTSUPP;
6250 if (wrqu->data.length) {
6251 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6257 memcpy(buf, extra, wrqu->data.length);
6258 kfree(ieee->wpa_ie);
6260 ieee->wpa_ie_len = wrqu->data.length;
6262 kfree(ieee->wpa_ie);
6263 ieee->wpa_ie = NULL;
6264 ieee->wpa_ie_len = 0;
6267 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6269 //mutex_unlock(&priv->mutex);
6274 static int ipw_wx_get_genie(struct net_device *dev,
6275 struct iw_request_info *info,
6276 union iwreq_data *wrqu, char *extra)
6278 struct ipw_priv *priv = ieee80211_priv(dev);
6279 struct ieee80211_device *ieee = priv->ieee;
6282 //mutex_lock(&priv->mutex);
6284 //if (!ieee->wpa_enabled) {
6285 // err = -EOPNOTSUPP;
6289 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6290 wrqu->data.length = 0;
6294 if (wrqu->data.length < ieee->wpa_ie_len) {
6299 wrqu->data.length = ieee->wpa_ie_len;
6300 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6303 //mutex_unlock(&priv->mutex);
6307 static int wext_cipher2level(int cipher)
6310 case IW_AUTH_CIPHER_NONE:
6312 case IW_AUTH_CIPHER_WEP40:
6313 case IW_AUTH_CIPHER_WEP104:
6315 case IW_AUTH_CIPHER_TKIP:
6317 case IW_AUTH_CIPHER_CCMP:
6325 static int ipw_wx_set_auth(struct net_device *dev,
6326 struct iw_request_info *info,
6327 union iwreq_data *wrqu, char *extra)
6329 struct ipw_priv *priv = ieee80211_priv(dev);
6330 struct ieee80211_device *ieee = priv->ieee;
6331 struct iw_param *param = &wrqu->param;
6332 struct ieee80211_crypt_data *crypt;
6333 unsigned long flags;
6336 switch (param->flags & IW_AUTH_INDEX) {
6337 case IW_AUTH_WPA_VERSION:
6339 case IW_AUTH_CIPHER_PAIRWISE:
6340 ipw_set_hw_decrypt_unicast(priv,
6341 wext_cipher2level(param->value));
6343 case IW_AUTH_CIPHER_GROUP:
6344 ipw_set_hw_decrypt_multicast(priv,
6345 wext_cipher2level(param->value));
6347 case IW_AUTH_KEY_MGMT:
6349 * ipw2200 does not use these parameters
6353 case IW_AUTH_TKIP_COUNTERMEASURES:
6354 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6355 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6358 flags = crypt->ops->get_flags(crypt->priv);
6361 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6363 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6365 crypt->ops->set_flags(flags, crypt->priv);
6369 case IW_AUTH_DROP_UNENCRYPTED:{
6372 * wpa_supplicant calls set_wpa_enabled when the driver
6373 * is loaded and unloaded, regardless of if WPA is being
6374 * used. No other calls are made which can be used to
6375 * determine if encryption will be used or not prior to
6376 * association being expected. If encryption is not being
6377 * used, drop_unencrypted is set to false, else true -- we
6378 * can use this to determine if the CAP_PRIVACY_ON bit should
6381 struct ieee80211_security sec = {
6382 .flags = SEC_ENABLED,
6383 .enabled = param->value,
6385 priv->ieee->drop_unencrypted = param->value;
6386 /* We only change SEC_LEVEL for open mode. Others
6387 * are set by ipw_wpa_set_encryption.
6389 if (!param->value) {
6390 sec.flags |= SEC_LEVEL;
6391 sec.level = SEC_LEVEL_0;
6393 sec.flags |= SEC_LEVEL;
6394 sec.level = SEC_LEVEL_1;
6396 if (priv->ieee->set_security)
6397 priv->ieee->set_security(priv->ieee->dev, &sec);
6401 case IW_AUTH_80211_AUTH_ALG:
6402 ret = ipw_wpa_set_auth_algs(priv, param->value);
6405 case IW_AUTH_WPA_ENABLED:
6406 ret = ipw_wpa_enable(priv, param->value);
6409 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6410 ieee->ieee802_1x = param->value;
6413 //case IW_AUTH_ROAMING_CONTROL:
6414 case IW_AUTH_PRIVACY_INVOKED:
6415 ieee->privacy_invoked = param->value;
6425 static int ipw_wx_get_auth(struct net_device *dev,
6426 struct iw_request_info *info,
6427 union iwreq_data *wrqu, char *extra)
6429 struct ipw_priv *priv = ieee80211_priv(dev);
6430 struct ieee80211_device *ieee = priv->ieee;
6431 struct ieee80211_crypt_data *crypt;
6432 struct iw_param *param = &wrqu->param;
6435 switch (param->flags & IW_AUTH_INDEX) {
6436 case IW_AUTH_WPA_VERSION:
6437 case IW_AUTH_CIPHER_PAIRWISE:
6438 case IW_AUTH_CIPHER_GROUP:
6439 case IW_AUTH_KEY_MGMT:
6441 * wpa_supplicant will control these internally
6446 case IW_AUTH_TKIP_COUNTERMEASURES:
6447 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6448 if (!crypt || !crypt->ops->get_flags)
6451 param->value = (crypt->ops->get_flags(crypt->priv) &
6452 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6456 case IW_AUTH_DROP_UNENCRYPTED:
6457 param->value = ieee->drop_unencrypted;
6460 case IW_AUTH_80211_AUTH_ALG:
6461 param->value = ieee->sec.auth_mode;
6464 case IW_AUTH_WPA_ENABLED:
6465 param->value = ieee->wpa_enabled;
6468 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6469 param->value = ieee->ieee802_1x;
6472 case IW_AUTH_ROAMING_CONTROL:
6473 case IW_AUTH_PRIVACY_INVOKED:
6474 param->value = ieee->privacy_invoked;
6483 /* SIOCSIWENCODEEXT */
6484 static int ipw_wx_set_encodeext(struct net_device *dev,
6485 struct iw_request_info *info,
6486 union iwreq_data *wrqu, char *extra)
6488 struct ipw_priv *priv = ieee80211_priv(dev);
6489 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6492 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6493 /* IPW HW can't build TKIP MIC,
6494 host decryption still needed */
6495 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6496 priv->ieee->host_mc_decrypt = 1;
6498 priv->ieee->host_encrypt = 0;
6499 priv->ieee->host_encrypt_msdu = 1;
6500 priv->ieee->host_decrypt = 1;
6503 priv->ieee->host_encrypt = 0;
6504 priv->ieee->host_encrypt_msdu = 0;
6505 priv->ieee->host_decrypt = 0;
6506 priv->ieee->host_mc_decrypt = 0;
6510 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6513 /* SIOCGIWENCODEEXT */
6514 static int ipw_wx_get_encodeext(struct net_device *dev,
6515 struct iw_request_info *info,
6516 union iwreq_data *wrqu, char *extra)
6518 struct ipw_priv *priv = ieee80211_priv(dev);
6519 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6523 static int ipw_wx_set_mlme(struct net_device *dev,
6524 struct iw_request_info *info,
6525 union iwreq_data *wrqu, char *extra)
6527 struct ipw_priv *priv = ieee80211_priv(dev);
6528 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6531 reason = cpu_to_le16(mlme->reason_code);
6533 switch (mlme->cmd) {
6534 case IW_MLME_DEAUTH:
6538 case IW_MLME_DISASSOC:
6539 ipw_disassociate(priv);
6548 #ifdef CONFIG_IPW_QOS
6552 * get the modulation type of the current network or
6553 * the card current mode
6555 static u8 ipw_qos_current_mode(struct ipw_priv * priv)
6559 if (priv->status & STATUS_ASSOCIATED) {
6560 unsigned long flags;
6562 spin_lock_irqsave(&priv->ieee->lock, flags);
6563 mode = priv->assoc_network->mode;
6564 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6566 mode = priv->ieee->mode;
6568 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6573 * Handle management frame beacon and probe response
6575 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6577 struct ieee80211_network *network)
6579 u32 size = sizeof(struct ieee80211_qos_parameters);
6581 if (network->capability & WLAN_CAPABILITY_IBSS)
6582 network->qos_data.active = network->qos_data.supported;
6584 if (network->flags & NETWORK_HAS_QOS_MASK) {
6585 if (active_network &&
6586 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6587 network->qos_data.active = network->qos_data.supported;
6589 if ((network->qos_data.active == 1) && (active_network == 1) &&
6590 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6591 (network->qos_data.old_param_count !=
6592 network->qos_data.param_count)) {
6593 network->qos_data.old_param_count =
6594 network->qos_data.param_count;
6595 schedule_work(&priv->qos_activate);
6596 IPW_DEBUG_QOS("QoS parameters change call "
6600 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6601 memcpy(&network->qos_data.parameters,
6602 &def_parameters_CCK, size);
6604 memcpy(&network->qos_data.parameters,
6605 &def_parameters_OFDM, size);
6607 if ((network->qos_data.active == 1) && (active_network == 1)) {
6608 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6609 schedule_work(&priv->qos_activate);
6612 network->qos_data.active = 0;
6613 network->qos_data.supported = 0;
6615 if ((priv->status & STATUS_ASSOCIATED) &&
6616 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6617 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6618 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6619 !(network->flags & NETWORK_EMPTY_ESSID))
6620 if ((network->ssid_len ==
6621 priv->assoc_network->ssid_len) &&
6622 !memcmp(network->ssid,
6623 priv->assoc_network->ssid,
6624 network->ssid_len)) {
6625 queue_work(priv->workqueue,
6626 &priv->merge_networks);
6634 * This function set up the firmware to support QoS. It sends
6635 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6637 static int ipw_qos_activate(struct ipw_priv *priv,
6638 struct ieee80211_qos_data *qos_network_data)
6641 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6642 struct ieee80211_qos_parameters *active_one = NULL;
6643 u32 size = sizeof(struct ieee80211_qos_parameters);
6648 type = ipw_qos_current_mode(priv);
6650 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6651 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6652 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6653 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6655 if (qos_network_data == NULL) {
6656 if (type == IEEE_B) {
6657 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6658 active_one = &def_parameters_CCK;
6660 active_one = &def_parameters_OFDM;
6662 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6663 burst_duration = ipw_qos_get_burst_duration(priv);
6664 for (i = 0; i < QOS_QUEUE_NUM; i++)
6665 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6666 (u16) burst_duration;
6667 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6668 if (type == IEEE_B) {
6669 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6671 if (priv->qos_data.qos_enable == 0)
6672 active_one = &def_parameters_CCK;
6674 active_one = priv->qos_data.def_qos_parm_CCK;
6676 if (priv->qos_data.qos_enable == 0)
6677 active_one = &def_parameters_OFDM;
6679 active_one = priv->qos_data.def_qos_parm_OFDM;
6681 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6683 unsigned long flags;
6686 spin_lock_irqsave(&priv->ieee->lock, flags);
6687 active_one = &(qos_network_data->parameters);
6688 qos_network_data->old_param_count =
6689 qos_network_data->param_count;
6690 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6691 active = qos_network_data->supported;
6692 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6695 burst_duration = ipw_qos_get_burst_duration(priv);
6696 for (i = 0; i < QOS_QUEUE_NUM; i++)
6697 qos_parameters[QOS_PARAM_SET_ACTIVE].
6698 tx_op_limit[i] = (u16) burst_duration;
6702 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6703 err = ipw_send_qos_params_command(priv,
6704 (struct ieee80211_qos_parameters *)
6705 &(qos_parameters[0]));
6707 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6713 * send IPW_CMD_WME_INFO to the firmware
6715 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6718 struct ieee80211_qos_information_element qos_info;
6723 qos_info.elementID = QOS_ELEMENT_ID;
6724 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6726 qos_info.version = QOS_VERSION_1;
6727 qos_info.ac_info = 0;
6729 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6730 qos_info.qui_type = QOS_OUI_TYPE;
6731 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6733 ret = ipw_send_qos_info_command(priv, &qos_info);
6735 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6741 * Set the QoS parameter with the association request structure
6743 static int ipw_qos_association(struct ipw_priv *priv,
6744 struct ieee80211_network *network)
6747 struct ieee80211_qos_data *qos_data = NULL;
6748 struct ieee80211_qos_data ibss_data = {
6753 switch (priv->ieee->iw_mode) {
6755 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6758 qos_data = &ibss_data;
6762 qos_data = &network->qos_data;
6770 err = ipw_qos_activate(priv, qos_data);
6772 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6776 if (priv->qos_data.qos_enable && qos_data->supported) {
6777 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6778 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6779 return ipw_qos_set_info_element(priv);
6786 * handling the beaconing responces. if we get different QoS setting
6787 * of the network from the the associated setting adjust the QoS
6790 static int ipw_qos_association_resp(struct ipw_priv *priv,
6791 struct ieee80211_network *network)
6794 unsigned long flags;
6795 u32 size = sizeof(struct ieee80211_qos_parameters);
6796 int set_qos_param = 0;
6798 if ((priv == NULL) || (network == NULL) ||
6799 (priv->assoc_network == NULL))
6802 if (!(priv->status & STATUS_ASSOCIATED))
6805 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
6808 spin_lock_irqsave(&priv->ieee->lock, flags);
6809 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
6810 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
6811 sizeof(struct ieee80211_qos_data));
6812 priv->assoc_network->qos_data.active = 1;
6813 if ((network->qos_data.old_param_count !=
6814 network->qos_data.param_count)) {
6816 network->qos_data.old_param_count =
6817 network->qos_data.param_count;
6821 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6822 memcpy(&priv->assoc_network->qos_data.parameters,
6823 &def_parameters_CCK, size);
6825 memcpy(&priv->assoc_network->qos_data.parameters,
6826 &def_parameters_OFDM, size);
6827 priv->assoc_network->qos_data.active = 0;
6828 priv->assoc_network->qos_data.supported = 0;
6832 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6834 if (set_qos_param == 1)
6835 schedule_work(&priv->qos_activate);
6840 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6847 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
6848 ret = priv->qos_data.burst_duration_CCK;
6850 ret = priv->qos_data.burst_duration_OFDM;
6856 * Initialize the setting of QoS global
6858 static void ipw_qos_init(struct ipw_priv *priv, int enable,
6859 int burst_enable, u32 burst_duration_CCK,
6860 u32 burst_duration_OFDM)
6862 priv->qos_data.qos_enable = enable;
6864 if (priv->qos_data.qos_enable) {
6865 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6866 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6867 IPW_DEBUG_QOS("QoS is enabled\n");
6869 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6870 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6871 IPW_DEBUG_QOS("QoS is not enabled\n");
6874 priv->qos_data.burst_enable = burst_enable;
6877 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6878 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6880 priv->qos_data.burst_duration_CCK = 0;
6881 priv->qos_data.burst_duration_OFDM = 0;
6886 * map the packet priority to the right TX Queue
6888 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6890 if (priority > 7 || !priv->qos_data.qos_enable)
6893 return from_priority_to_tx_queue[priority] - 1;
6897 * add QoS parameter to the TX command
6899 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6901 struct tfd_data *tfd, u8 unicast)
6904 int tx_queue_id = 0;
6905 struct ieee80211_qos_data *qos_data = NULL;
6906 int active, supported;
6907 unsigned long flags;
6909 if (!(priv->status & STATUS_ASSOCIATED))
6912 qos_data = &priv->assoc_network->qos_data;
6914 spin_lock_irqsave(&priv->ieee->lock, flags);
6916 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6918 qos_data->active = 0;
6920 qos_data->active = qos_data->supported;
6923 active = qos_data->active;
6924 supported = qos_data->supported;
6926 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6928 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
6930 priv->qos_data.qos_enable, active, supported, unicast);
6931 if (active && priv->qos_data.qos_enable) {
6932 ret = from_priority_to_tx_queue[priority];
6933 tx_queue_id = ret - 1;
6934 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6935 if (priority <= 7) {
6936 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6937 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6938 tfd->tfd.tfd_26.mchdr.frame_ctl |=
6939 IEEE80211_STYPE_QOS_DATA;
6941 if (priv->qos_data.qos_no_ack_mask &
6942 (1UL << tx_queue_id)) {
6943 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6944 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6954 * background support to run QoS activate functionality
6956 static void ipw_bg_qos_activate(void *data)
6958 struct ipw_priv *priv = data;
6963 mutex_lock(&priv->mutex);
6965 if (priv->status & STATUS_ASSOCIATED)
6966 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6968 mutex_unlock(&priv->mutex);
6971 static int ipw_handle_probe_response(struct net_device *dev,
6972 struct ieee80211_probe_response *resp,
6973 struct ieee80211_network *network)
6975 struct ipw_priv *priv = ieee80211_priv(dev);
6976 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6977 (network == priv->assoc_network));
6979 ipw_qos_handle_probe_response(priv, active_network, network);
6984 static int ipw_handle_beacon(struct net_device *dev,
6985 struct ieee80211_beacon *resp,
6986 struct ieee80211_network *network)
6988 struct ipw_priv *priv = ieee80211_priv(dev);
6989 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6990 (network == priv->assoc_network));
6992 ipw_qos_handle_probe_response(priv, active_network, network);
6997 static int ipw_handle_assoc_response(struct net_device *dev,
6998 struct ieee80211_assoc_response *resp,
6999 struct ieee80211_network *network)
7001 struct ipw_priv *priv = ieee80211_priv(dev);
7002 ipw_qos_association_resp(priv, network);
7006 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7009 return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7010 sizeof(*qos_param) * 3, qos_param);
7013 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7016 return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7020 #endif /* CONFIG_IPW_QOS */
7022 static int ipw_associate_network(struct ipw_priv *priv,
7023 struct ieee80211_network *network,
7024 struct ipw_supported_rates *rates, int roaming)
7028 if (priv->config & CFG_FIXED_RATE)
7029 ipw_set_fixed_rate(priv, network->mode);
7031 if (!(priv->config & CFG_STATIC_ESSID)) {
7032 priv->essid_len = min(network->ssid_len,
7033 (u8) IW_ESSID_MAX_SIZE);
7034 memcpy(priv->essid, network->ssid, priv->essid_len);
7037 network->last_associate = jiffies;
7039 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7040 priv->assoc_request.channel = network->channel;
7041 priv->assoc_request.auth_key = 0;
7043 if ((priv->capability & CAP_PRIVACY_ON) &&
7044 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
7045 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7046 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7048 if (priv->ieee->sec.level == SEC_LEVEL_1)
7049 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7051 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7052 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7053 priv->assoc_request.auth_type = AUTH_LEAP;
7055 priv->assoc_request.auth_type = AUTH_OPEN;
7057 if (priv->ieee->wpa_ie_len) {
7058 priv->assoc_request.policy_support = 0x02; /* RSN active */
7059 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7060 priv->ieee->wpa_ie_len);
7064 * It is valid for our ieee device to support multiple modes, but
7065 * when it comes to associating to a given network we have to choose
7068 if (network->mode & priv->ieee->mode & IEEE_A)
7069 priv->assoc_request.ieee_mode = IPW_A_MODE;
7070 else if (network->mode & priv->ieee->mode & IEEE_G)
7071 priv->assoc_request.ieee_mode = IPW_G_MODE;
7072 else if (network->mode & priv->ieee->mode & IEEE_B)
7073 priv->assoc_request.ieee_mode = IPW_B_MODE;
7075 priv->assoc_request.capability = network->capability;
7076 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7077 && !(priv->config & CFG_PREAMBLE_LONG)) {
7078 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7080 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7082 /* Clear the short preamble if we won't be supporting it */
7083 priv->assoc_request.capability &=
7084 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7087 /* Clear capability bits that aren't used in Ad Hoc */
7088 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7089 priv->assoc_request.capability &=
7090 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7092 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7093 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7094 roaming ? "Rea" : "A",
7095 escape_essid(priv->essid, priv->essid_len),
7097 ipw_modes[priv->assoc_request.ieee_mode],
7099 (priv->assoc_request.preamble_length ==
7100 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7101 network->capability &
7102 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7103 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7104 priv->capability & CAP_PRIVACY_ON ?
7105 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7107 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7108 priv->capability & CAP_PRIVACY_ON ?
7109 '1' + priv->ieee->sec.active_key : '.',
7110 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7112 priv->assoc_request.beacon_interval = network->beacon_interval;
7113 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7114 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7115 priv->assoc_request.assoc_type = HC_IBSS_START;
7116 priv->assoc_request.assoc_tsf_msw = 0;
7117 priv->assoc_request.assoc_tsf_lsw = 0;
7119 if (unlikely(roaming))
7120 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7122 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7123 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7124 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7127 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7129 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7130 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7131 priv->assoc_request.atim_window = network->atim_window;
7133 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7134 priv->assoc_request.atim_window = 0;
7137 priv->assoc_request.listen_interval = network->listen_interval;
7139 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7141 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7145 rates->ieee_mode = priv->assoc_request.ieee_mode;
7146 rates->purpose = IPW_RATE_CONNECT;
7147 ipw_send_supported_rates(priv, rates);
7149 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7150 priv->sys_config.dot11g_auto_detection = 1;
7152 priv->sys_config.dot11g_auto_detection = 0;
7154 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7155 priv->sys_config.answer_broadcast_ssid_probe = 1;
7157 priv->sys_config.answer_broadcast_ssid_probe = 0;
7159 err = ipw_send_system_config(priv, &priv->sys_config);
7161 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7165 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7166 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7168 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7173 * If preemption is enabled, it is possible for the association
7174 * to complete before we return from ipw_send_associate. Therefore
7175 * we have to be sure and update our priviate data first.
7177 priv->channel = network->channel;
7178 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7179 priv->status |= STATUS_ASSOCIATING;
7180 priv->status &= ~STATUS_SECURITY_UPDATED;
7182 priv->assoc_network = network;
7184 #ifdef CONFIG_IPW_QOS
7185 ipw_qos_association(priv, network);
7188 err = ipw_send_associate(priv, &priv->assoc_request);
7190 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7194 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7195 escape_essid(priv->essid, priv->essid_len),
7196 MAC_ARG(priv->bssid));
7201 static void ipw_roam(void *data)
7203 struct ipw_priv *priv = data;
7204 struct ieee80211_network *network = NULL;
7205 struct ipw_network_match match = {
7206 .network = priv->assoc_network
7209 /* The roaming process is as follows:
7211 * 1. Missed beacon threshold triggers the roaming process by
7212 * setting the status ROAM bit and requesting a scan.
7213 * 2. When the scan completes, it schedules the ROAM work
7214 * 3. The ROAM work looks at all of the known networks for one that
7215 * is a better network than the currently associated. If none
7216 * found, the ROAM process is over (ROAM bit cleared)
7217 * 4. If a better network is found, a disassociation request is
7219 * 5. When the disassociation completes, the roam work is again
7220 * scheduled. The second time through, the driver is no longer
7221 * associated, and the newly selected network is sent an
7222 * association request.
7223 * 6. At this point ,the roaming process is complete and the ROAM
7224 * status bit is cleared.
7227 /* If we are no longer associated, and the roaming bit is no longer
7228 * set, then we are not actively roaming, so just return */
7229 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7232 if (priv->status & STATUS_ASSOCIATED) {
7233 /* First pass through ROAM process -- look for a better
7235 unsigned long flags;
7236 u8 rssi = priv->assoc_network->stats.rssi;
7237 priv->assoc_network->stats.rssi = -128;
7238 spin_lock_irqsave(&priv->ieee->lock, flags);
7239 list_for_each_entry(network, &priv->ieee->network_list, list) {
7240 if (network != priv->assoc_network)
7241 ipw_best_network(priv, &match, network, 1);
7243 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7244 priv->assoc_network->stats.rssi = rssi;
7246 if (match.network == priv->assoc_network) {
7247 IPW_DEBUG_ASSOC("No better APs in this network to "
7249 priv->status &= ~STATUS_ROAMING;
7250 ipw_debug_config(priv);
7254 ipw_send_disassociate(priv, 1);
7255 priv->assoc_network = match.network;
7260 /* Second pass through ROAM process -- request association */
7261 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7262 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7263 priv->status &= ~STATUS_ROAMING;
7266 static void ipw_bg_roam(void *data)
7268 struct ipw_priv *priv = data;
7269 mutex_lock(&priv->mutex);
7271 mutex_unlock(&priv->mutex);
7274 static int ipw_associate(void *data)
7276 struct ipw_priv *priv = data;
7278 struct ieee80211_network *network = NULL;
7279 struct ipw_network_match match = {
7282 struct ipw_supported_rates *rates;
7283 struct list_head *element;
7284 unsigned long flags;
7286 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7287 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7291 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7292 IPW_DEBUG_ASSOC("Not attempting association (already in "
7297 if (priv->status & STATUS_DISASSOCIATING) {
7298 IPW_DEBUG_ASSOC("Not attempting association (in "
7299 "disassociating)\n ");
7300 queue_work(priv->workqueue, &priv->associate);
7304 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7305 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7310 if (!(priv->config & CFG_ASSOCIATE) &&
7311 !(priv->config & (CFG_STATIC_ESSID |
7312 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7313 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7317 /* Protect our use of the network_list */
7318 spin_lock_irqsave(&priv->ieee->lock, flags);
7319 list_for_each_entry(network, &priv->ieee->network_list, list)
7320 ipw_best_network(priv, &match, network, 0);
7322 network = match.network;
7323 rates = &match.rates;
7325 if (network == NULL &&
7326 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7327 priv->config & CFG_ADHOC_CREATE &&
7328 priv->config & CFG_STATIC_ESSID &&
7329 priv->config & CFG_STATIC_CHANNEL &&
7330 !list_empty(&priv->ieee->network_free_list)) {
7331 element = priv->ieee->network_free_list.next;
7332 network = list_entry(element, struct ieee80211_network, list);
7333 ipw_adhoc_create(priv, network);
7334 rates = &priv->rates;
7336 list_add_tail(&network->list, &priv->ieee->network_list);
7338 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7340 /* If we reached the end of the list, then we don't have any valid
7343 ipw_debug_config(priv);
7345 if (!(priv->status & STATUS_SCANNING)) {
7346 if (!(priv->config & CFG_SPEED_SCAN))
7347 queue_delayed_work(priv->workqueue,
7348 &priv->request_scan,
7351 queue_work(priv->workqueue,
7352 &priv->request_scan);
7358 ipw_associate_network(priv, network, rates, 0);
7363 static void ipw_bg_associate(void *data)
7365 struct ipw_priv *priv = data;
7366 mutex_lock(&priv->mutex);
7367 ipw_associate(data);
7368 mutex_unlock(&priv->mutex);
7371 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7372 struct sk_buff *skb)
7374 struct ieee80211_hdr *hdr;
7377 hdr = (struct ieee80211_hdr *)skb->data;
7378 fc = le16_to_cpu(hdr->frame_ctl);
7379 if (!(fc & IEEE80211_FCTL_PROTECTED))
7382 fc &= ~IEEE80211_FCTL_PROTECTED;
7383 hdr->frame_ctl = cpu_to_le16(fc);
7384 switch (priv->ieee->sec.level) {
7386 /* Remove CCMP HDR */
7387 memmove(skb->data + IEEE80211_3ADDR_LEN,
7388 skb->data + IEEE80211_3ADDR_LEN + 8,
7389 skb->len - IEEE80211_3ADDR_LEN - 8);
7390 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7396 memmove(skb->data + IEEE80211_3ADDR_LEN,
7397 skb->data + IEEE80211_3ADDR_LEN + 4,
7398 skb->len - IEEE80211_3ADDR_LEN - 4);
7399 skb_trim(skb, skb->len - 8); /* IV + ICV */
7404 printk(KERN_ERR "Unknow security level %d\n",
7405 priv->ieee->sec.level);
7410 static void ipw_handle_data_packet(struct ipw_priv *priv,
7411 struct ipw_rx_mem_buffer *rxb,
7412 struct ieee80211_rx_stats *stats)
7414 struct ieee80211_hdr_4addr *hdr;
7415 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7417 /* We received data from the HW, so stop the watchdog */
7418 priv->net_dev->trans_start = jiffies;
7420 /* We only process data packets if the
7421 * interface is open */
7422 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7423 skb_tailroom(rxb->skb))) {
7424 priv->ieee->stats.rx_errors++;
7425 priv->wstats.discard.misc++;
7426 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7428 } else if (unlikely(!netif_running(priv->net_dev))) {
7429 priv->ieee->stats.rx_dropped++;
7430 priv->wstats.discard.misc++;
7431 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7435 /* Advance skb->data to the start of the actual payload */
7436 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7438 /* Set the size of the skb to the size of the frame */
7439 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7441 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7443 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7444 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7445 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7446 (is_multicast_ether_addr(hdr->addr1) ?
7447 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7448 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7450 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7451 priv->ieee->stats.rx_errors++;
7452 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7454 __ipw_led_activity_on(priv);
7458 #ifdef CONFIG_IEEE80211_RADIOTAP
7459 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7460 struct ipw_rx_mem_buffer *rxb,
7461 struct ieee80211_rx_stats *stats)
7463 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7464 struct ipw_rx_frame *frame = &pkt->u.frame;
7466 /* initial pull of some data */
7467 u16 received_channel = frame->received_channel;
7468 u8 antennaAndPhy = frame->antennaAndPhy;
7469 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7470 u16 pktrate = frame->rate;
7472 /* Magic struct that slots into the radiotap header -- no reason
7473 * to build this manually element by element, we can write it much
7474 * more efficiently than we can parse it. ORDER MATTERS HERE */
7476 struct ieee80211_radiotap_header rt_hdr;
7477 u8 rt_flags; /* radiotap packet flags */
7478 u8 rt_rate; /* rate in 500kb/s */
7479 u16 rt_channel; /* channel in mhz */
7480 u16 rt_chbitmask; /* channel bitfield */
7481 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7482 u8 rt_antenna; /* antenna number */
7485 short len = le16_to_cpu(pkt->u.frame.length);
7487 /* We received data from the HW, so stop the watchdog */
7488 priv->net_dev->trans_start = jiffies;
7490 /* We only process data packets if the
7491 * interface is open */
7492 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7493 skb_tailroom(rxb->skb))) {
7494 priv->ieee->stats.rx_errors++;
7495 priv->wstats.discard.misc++;
7496 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7498 } else if (unlikely(!netif_running(priv->net_dev))) {
7499 priv->ieee->stats.rx_dropped++;
7500 priv->wstats.discard.misc++;
7501 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7505 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7507 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7508 /* FIXME: Should alloc bigger skb instead */
7509 priv->ieee->stats.rx_dropped++;
7510 priv->wstats.discard.misc++;
7511 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7515 /* copy the frame itself */
7516 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7517 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7519 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7520 * part of our real header, saves a little time.
7522 * No longer necessary since we fill in all our data. Purge before merging
7524 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7525 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7528 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7530 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7531 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7532 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7534 /* Big bitfield of all the fields we provide in radiotap */
7535 ipw_rt->rt_hdr.it_present =
7536 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7537 (1 << IEEE80211_RADIOTAP_RATE) |
7538 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7539 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7540 (1 << IEEE80211_RADIOTAP_ANTENNA));
7542 /* Zero the flags, we'll add to them as we go */
7543 ipw_rt->rt_flags = 0;
7545 /* Convert signal to DBM */
7546 ipw_rt->rt_dbmsignal = antsignal;
7548 /* Convert the channel data and set the flags */
7549 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7550 if (received_channel > 14) { /* 802.11a */
7551 ipw_rt->rt_chbitmask =
7552 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7553 } else if (antennaAndPhy & 32) { /* 802.11b */
7554 ipw_rt->rt_chbitmask =
7555 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7556 } else { /* 802.11g */
7557 ipw_rt->rt_chbitmask =
7558 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7561 /* set the rate in multiples of 500k/s */
7563 case IPW_TX_RATE_1MB:
7564 ipw_rt->rt_rate = 2;
7566 case IPW_TX_RATE_2MB:
7567 ipw_rt->rt_rate = 4;
7569 case IPW_TX_RATE_5MB:
7570 ipw_rt->rt_rate = 10;
7572 case IPW_TX_RATE_6MB:
7573 ipw_rt->rt_rate = 12;
7575 case IPW_TX_RATE_9MB:
7576 ipw_rt->rt_rate = 18;
7578 case IPW_TX_RATE_11MB:
7579 ipw_rt->rt_rate = 22;
7581 case IPW_TX_RATE_12MB:
7582 ipw_rt->rt_rate = 24;
7584 case IPW_TX_RATE_18MB:
7585 ipw_rt->rt_rate = 36;
7587 case IPW_TX_RATE_24MB:
7588 ipw_rt->rt_rate = 48;
7590 case IPW_TX_RATE_36MB:
7591 ipw_rt->rt_rate = 72;
7593 case IPW_TX_RATE_48MB:
7594 ipw_rt->rt_rate = 96;
7596 case IPW_TX_RATE_54MB:
7597 ipw_rt->rt_rate = 108;
7600 ipw_rt->rt_rate = 0;
7604 /* antenna number */
7605 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7607 /* set the preamble flag if we have it */
7608 if ((antennaAndPhy & 64))
7609 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7611 /* Set the size of the skb to the size of the frame */
7612 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7614 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7616 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7617 priv->ieee->stats.rx_errors++;
7618 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7620 /* no LED during capture */
7625 static int is_network_packet(struct ipw_priv *priv,
7626 struct ieee80211_hdr_4addr *header)
7628 /* Filter incoming packets to determine if they are targetted toward
7629 * this network, discarding packets coming from ourselves */
7630 switch (priv->ieee->iw_mode) {
7631 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
7632 /* packets from our adapter are dropped (echo) */
7633 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7636 /* {broad,multi}cast packets to our BSSID go through */
7637 if (is_multicast_ether_addr(header->addr1))
7638 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
7640 /* packets to our adapter go through */
7641 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7644 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
7645 /* packets from our adapter are dropped (echo) */
7646 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7649 /* {broad,multi}cast packets to our BSS go through */
7650 if (is_multicast_ether_addr(header->addr1))
7651 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7653 /* packets to our adapter go through */
7654 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7661 #define IPW_PACKET_RETRY_TIME HZ
7663 static int is_duplicate_packet(struct ipw_priv *priv,
7664 struct ieee80211_hdr_4addr *header)
7666 u16 sc = le16_to_cpu(header->seq_ctl);
7667 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7668 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7669 u16 *last_seq, *last_frag;
7670 unsigned long *last_time;
7672 switch (priv->ieee->iw_mode) {
7675 struct list_head *p;
7676 struct ipw_ibss_seq *entry = NULL;
7677 u8 *mac = header->addr2;
7678 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7680 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7682 list_entry(p, struct ipw_ibss_seq, list);
7683 if (!memcmp(entry->mac, mac, ETH_ALEN))
7686 if (p == &priv->ibss_mac_hash[index]) {
7687 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7690 ("Cannot malloc new mac entry\n");
7693 memcpy(entry->mac, mac, ETH_ALEN);
7694 entry->seq_num = seq;
7695 entry->frag_num = frag;
7696 entry->packet_time = jiffies;
7697 list_add(&entry->list,
7698 &priv->ibss_mac_hash[index]);
7701 last_seq = &entry->seq_num;
7702 last_frag = &entry->frag_num;
7703 last_time = &entry->packet_time;
7707 last_seq = &priv->last_seq_num;
7708 last_frag = &priv->last_frag_num;
7709 last_time = &priv->last_packet_time;
7714 if ((*last_seq == seq) &&
7715 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7716 if (*last_frag == frag)
7718 if (*last_frag + 1 != frag)
7719 /* out-of-order fragment */
7725 *last_time = jiffies;
7729 /* Comment this line now since we observed the card receives
7730 * duplicate packets but the FCTL_RETRY bit is not set in the
7731 * IBSS mode with fragmentation enabled.
7732 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
7736 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7737 struct ipw_rx_mem_buffer *rxb,
7738 struct ieee80211_rx_stats *stats)
7740 struct sk_buff *skb = rxb->skb;
7741 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7742 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7743 (skb->data + IPW_RX_FRAME_SIZE);
7745 ieee80211_rx_mgt(priv->ieee, header, stats);
7747 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7748 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7749 IEEE80211_STYPE_PROBE_RESP) ||
7750 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7751 IEEE80211_STYPE_BEACON))) {
7752 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7753 ipw_add_station(priv, header->addr2);
7756 if (priv->config & CFG_NET_STATS) {
7757 IPW_DEBUG_HC("sending stat packet\n");
7759 /* Set the size of the skb to the size of the full
7760 * ipw header and 802.11 frame */
7761 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7764 /* Advance past the ipw packet header to the 802.11 frame */
7765 skb_pull(skb, IPW_RX_FRAME_SIZE);
7767 /* Push the ieee80211_rx_stats before the 802.11 frame */
7768 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7770 skb->dev = priv->ieee->dev;
7772 /* Point raw at the ieee80211_stats */
7773 skb->mac.raw = skb->data;
7775 skb->pkt_type = PACKET_OTHERHOST;
7776 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7777 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7784 * Main entry function for recieving a packet with 80211 headers. This
7785 * should be called when ever the FW has notified us that there is a new
7786 * skb in the recieve queue.
7788 static void ipw_rx(struct ipw_priv *priv)
7790 struct ipw_rx_mem_buffer *rxb;
7791 struct ipw_rx_packet *pkt;
7792 struct ieee80211_hdr_4addr *header;
7796 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7797 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
7798 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7801 rxb = priv->rxq->queue[i];
7802 if (unlikely(rxb == NULL)) {
7803 printk(KERN_CRIT "Queue not allocated!\n");
7806 priv->rxq->queue[i] = NULL;
7808 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
7810 PCI_DMA_FROMDEVICE);
7812 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7813 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7814 pkt->header.message_type,
7815 pkt->header.rx_seq_num, pkt->header.control_bits);
7817 switch (pkt->header.message_type) {
7818 case RX_FRAME_TYPE: /* 802.11 frame */ {
7819 struct ieee80211_rx_stats stats = {
7821 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7824 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7825 IPW_RSSI_TO_DBM + 0x100,
7827 le16_to_cpu(pkt->u.frame.noise),
7828 .rate = pkt->u.frame.rate,
7829 .mac_time = jiffies,
7831 pkt->u.frame.received_channel,
7834 control & (1 << 0)) ?
7835 IEEE80211_24GHZ_BAND :
7836 IEEE80211_52GHZ_BAND,
7837 .len = le16_to_cpu(pkt->u.frame.length),
7840 if (stats.rssi != 0)
7841 stats.mask |= IEEE80211_STATMASK_RSSI;
7842 if (stats.signal != 0)
7843 stats.mask |= IEEE80211_STATMASK_SIGNAL;
7844 if (stats.noise != 0)
7845 stats.mask |= IEEE80211_STATMASK_NOISE;
7846 if (stats.rate != 0)
7847 stats.mask |= IEEE80211_STATMASK_RATE;
7851 #ifdef CONFIG_IPW2200_MONITOR
7852 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7853 #ifdef CONFIG_IEEE80211_RADIOTAP
7854 ipw_handle_data_packet_monitor(priv,
7858 ipw_handle_data_packet(priv, rxb,
7866 (struct ieee80211_hdr_4addr *)(rxb->skb->
7869 /* TODO: Check Ad-Hoc dest/source and make sure
7870 * that we are actually parsing these packets
7871 * correctly -- we should probably use the
7872 * frame control of the packet and disregard
7873 * the current iw_mode */
7876 is_network_packet(priv, header);
7877 if (network_packet && priv->assoc_network) {
7878 priv->assoc_network->stats.rssi =
7880 average_add(&priv->average_rssi,
7882 priv->last_rx_rssi = stats.rssi;
7885 IPW_DEBUG_RX("Frame: len=%u\n",
7886 le16_to_cpu(pkt->u.frame.length));
7888 if (le16_to_cpu(pkt->u.frame.length) <
7889 ieee80211_get_hdrlen(le16_to_cpu(
7890 header->frame_ctl))) {
7892 ("Received packet is too small. "
7894 priv->ieee->stats.rx_errors++;
7895 priv->wstats.discard.misc++;
7899 switch (WLAN_FC_GET_TYPE
7900 (le16_to_cpu(header->frame_ctl))) {
7902 case IEEE80211_FTYPE_MGMT:
7903 ipw_handle_mgmt_packet(priv, rxb,
7907 case IEEE80211_FTYPE_CTL:
7910 case IEEE80211_FTYPE_DATA:
7911 if (unlikely(!network_packet ||
7912 is_duplicate_packet(priv,
7915 IPW_DEBUG_DROP("Dropping: "
7928 ipw_handle_data_packet(priv, rxb,
7936 case RX_HOST_NOTIFICATION_TYPE:{
7938 ("Notification: subtype=%02X flags=%02X size=%d\n",
7939 pkt->u.notification.subtype,
7940 pkt->u.notification.flags,
7941 pkt->u.notification.size);
7942 ipw_rx_notification(priv, &pkt->u.notification);
7947 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7948 pkt->header.message_type);
7952 /* For now we just don't re-use anything. We can tweak this
7953 * later to try and re-use notification packets and SKBs that
7954 * fail to Rx correctly */
7955 if (rxb->skb != NULL) {
7956 dev_kfree_skb_any(rxb->skb);
7960 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
7961 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
7962 list_add_tail(&rxb->list, &priv->rxq->rx_used);
7964 i = (i + 1) % RX_QUEUE_SIZE;
7967 /* Backtrack one entry */
7968 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7970 ipw_rx_queue_restock(priv);
7973 #define DEFAULT_RTS_THRESHOLD 2304U
7974 #define MIN_RTS_THRESHOLD 1U
7975 #define MAX_RTS_THRESHOLD 2304U
7976 #define DEFAULT_BEACON_INTERVAL 100U
7977 #define DEFAULT_SHORT_RETRY_LIMIT 7U
7978 #define DEFAULT_LONG_RETRY_LIMIT 4U
7982 * @option: options to control different reset behaviour
7983 * 0 = reset everything except the 'disable' module_param
7984 * 1 = reset everything and print out driver info (for probe only)
7985 * 2 = reset everything
7987 static int ipw_sw_reset(struct ipw_priv *priv, int option)
7989 int band, modulation;
7990 int old_mode = priv->ieee->iw_mode;
7992 /* Initialize module parameter values here */
7995 /* We default to disabling the LED code as right now it causes
7996 * too many systems to lock up... */
7998 priv->config |= CFG_NO_LED;
8001 priv->config |= CFG_ASSOCIATE;
8003 IPW_DEBUG_INFO("Auto associate disabled.\n");
8006 priv->config |= CFG_ADHOC_CREATE;
8008 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8010 priv->config &= ~CFG_STATIC_ESSID;
8011 priv->essid_len = 0;
8012 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8014 if (disable && option) {
8015 priv->status |= STATUS_RF_KILL_SW;
8016 IPW_DEBUG_INFO("Radio disabled.\n");
8020 priv->config |= CFG_STATIC_CHANNEL;
8021 priv->channel = channel;
8022 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8023 /* TODO: Validate that provided channel is in range */
8025 #ifdef CONFIG_IPW_QOS
8026 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8027 burst_duration_CCK, burst_duration_OFDM);
8028 #endif /* CONFIG_IPW_QOS */
8032 priv->ieee->iw_mode = IW_MODE_ADHOC;
8033 priv->net_dev->type = ARPHRD_ETHER;
8036 #ifdef CONFIG_IPW2200_MONITOR
8038 priv->ieee->iw_mode = IW_MODE_MONITOR;
8039 #ifdef CONFIG_IEEE80211_RADIOTAP
8040 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8042 priv->net_dev->type = ARPHRD_IEEE80211;
8048 priv->net_dev->type = ARPHRD_ETHER;
8049 priv->ieee->iw_mode = IW_MODE_INFRA;
8054 priv->ieee->host_encrypt = 0;
8055 priv->ieee->host_encrypt_msdu = 0;
8056 priv->ieee->host_decrypt = 0;
8057 priv->ieee->host_mc_decrypt = 0;
8059 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8061 /* IPW2200/2915 is abled to do hardware fragmentation. */
8062 priv->ieee->host_open_frag = 0;
8064 if ((priv->pci_dev->device == 0x4223) ||
8065 (priv->pci_dev->device == 0x4224)) {
8067 printk(KERN_INFO DRV_NAME
8068 ": Detected Intel PRO/Wireless 2915ABG Network "
8070 priv->ieee->abg_true = 1;
8071 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8072 modulation = IEEE80211_OFDM_MODULATION |
8073 IEEE80211_CCK_MODULATION;
8074 priv->adapter = IPW_2915ABG;
8075 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8078 printk(KERN_INFO DRV_NAME
8079 ": Detected Intel PRO/Wireless 2200BG Network "
8082 priv->ieee->abg_true = 0;
8083 band = IEEE80211_24GHZ_BAND;
8084 modulation = IEEE80211_OFDM_MODULATION |
8085 IEEE80211_CCK_MODULATION;
8086 priv->adapter = IPW_2200BG;
8087 priv->ieee->mode = IEEE_G | IEEE_B;
8090 priv->ieee->freq_band = band;
8091 priv->ieee->modulation = modulation;
8093 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8095 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8096 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8098 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8099 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8100 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8102 /* If power management is turned on, default to AC mode */
8103 priv->power_mode = IPW_POWER_AC;
8104 priv->tx_power = IPW_TX_POWER_DEFAULT;
8106 return old_mode == priv->ieee->iw_mode;
8110 * This file defines the Wireless Extension handlers. It does not
8111 * define any methods of hardware manipulation and relies on the
8112 * functions defined in ipw_main to provide the HW interaction.
8114 * The exception to this is the use of the ipw_get_ordinal()
8115 * function used to poll the hardware vs. making unecessary calls.
8119 static int ipw_wx_get_name(struct net_device *dev,
8120 struct iw_request_info *info,
8121 union iwreq_data *wrqu, char *extra)
8123 struct ipw_priv *priv = ieee80211_priv(dev);
8124 mutex_lock(&priv->mutex);
8125 if (priv->status & STATUS_RF_KILL_MASK)
8126 strcpy(wrqu->name, "radio off");
8127 else if (!(priv->status & STATUS_ASSOCIATED))
8128 strcpy(wrqu->name, "unassociated");
8130 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8131 ipw_modes[priv->assoc_request.ieee_mode]);
8132 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8133 mutex_unlock(&priv->mutex);
8137 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8140 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8141 priv->config &= ~CFG_STATIC_CHANNEL;
8142 IPW_DEBUG_ASSOC("Attempting to associate with new "
8144 ipw_associate(priv);
8148 priv->config |= CFG_STATIC_CHANNEL;
8150 if (priv->channel == channel) {
8151 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8156 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8157 priv->channel = channel;
8159 #ifdef CONFIG_IPW2200_MONITOR
8160 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8162 if (priv->status & STATUS_SCANNING) {
8163 IPW_DEBUG_SCAN("Scan abort triggered due to "
8164 "channel change.\n");
8165 ipw_abort_scan(priv);
8168 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8171 if (priv->status & STATUS_SCANNING)
8172 IPW_DEBUG_SCAN("Still scanning...\n");
8174 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8179 #endif /* CONFIG_IPW2200_MONITOR */
8181 /* Network configuration changed -- force [re]association */
8182 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8183 if (!ipw_disassociate(priv))
8184 ipw_associate(priv);
8189 static int ipw_wx_set_freq(struct net_device *dev,
8190 struct iw_request_info *info,
8191 union iwreq_data *wrqu, char *extra)
8193 struct ipw_priv *priv = ieee80211_priv(dev);
8194 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
8195 struct iw_freq *fwrq = &wrqu->freq;
8201 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8202 mutex_lock(&priv->mutex);
8203 ret = ipw_set_channel(priv, 0);
8204 mutex_unlock(&priv->mutex);
8207 /* if setting by freq convert to channel */
8209 channel = ieee80211_freq_to_channel(priv->ieee, fwrq->m);
8215 if (!(band = ieee80211_is_valid_channel(priv->ieee, channel)))
8218 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8219 i = ieee80211_channel_to_index(priv->ieee, channel);
8223 flags = (band == IEEE80211_24GHZ_BAND) ?
8224 geo->bg[i].flags : geo->a[i].flags;
8225 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8226 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8231 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8232 mutex_lock(&priv->mutex);
8233 ret = ipw_set_channel(priv, channel);
8234 mutex_unlock(&priv->mutex);
8238 static int ipw_wx_get_freq(struct net_device *dev,
8239 struct iw_request_info *info,
8240 union iwreq_data *wrqu, char *extra)
8242 struct ipw_priv *priv = ieee80211_priv(dev);
8246 /* If we are associated, trying to associate, or have a statically
8247 * configured CHANNEL then return that; otherwise return ANY */
8248 mutex_lock(&priv->mutex);
8249 if (priv->config & CFG_STATIC_CHANNEL ||
8250 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8251 wrqu->freq.m = priv->channel;
8255 mutex_unlock(&priv->mutex);
8256 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8260 static int ipw_wx_set_mode(struct net_device *dev,
8261 struct iw_request_info *info,
8262 union iwreq_data *wrqu, char *extra)
8264 struct ipw_priv *priv = ieee80211_priv(dev);
8267 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8269 switch (wrqu->mode) {
8270 #ifdef CONFIG_IPW2200_MONITOR
8271 case IW_MODE_MONITOR:
8277 wrqu->mode = IW_MODE_INFRA;
8282 if (wrqu->mode == priv->ieee->iw_mode)
8285 mutex_lock(&priv->mutex);
8287 ipw_sw_reset(priv, 0);
8289 #ifdef CONFIG_IPW2200_MONITOR
8290 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8291 priv->net_dev->type = ARPHRD_ETHER;
8293 if (wrqu->mode == IW_MODE_MONITOR)
8294 #ifdef CONFIG_IEEE80211_RADIOTAP
8295 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8297 priv->net_dev->type = ARPHRD_IEEE80211;
8299 #endif /* CONFIG_IPW2200_MONITOR */
8301 /* Free the existing firmware and reset the fw_loaded
8302 * flag so ipw_load() will bring in the new firmawre */
8305 priv->ieee->iw_mode = wrqu->mode;
8307 queue_work(priv->workqueue, &priv->adapter_restart);
8308 mutex_unlock(&priv->mutex);
8312 static int ipw_wx_get_mode(struct net_device *dev,
8313 struct iw_request_info *info,
8314 union iwreq_data *wrqu, char *extra)
8316 struct ipw_priv *priv = ieee80211_priv(dev);
8317 mutex_lock(&priv->mutex);
8318 wrqu->mode = priv->ieee->iw_mode;
8319 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8320 mutex_unlock(&priv->mutex);
8324 /* Values are in microsecond */
8325 static const s32 timeout_duration[] = {
8333 static const s32 period_duration[] = {
8341 static int ipw_wx_get_range(struct net_device *dev,
8342 struct iw_request_info *info,
8343 union iwreq_data *wrqu, char *extra)
8345 struct ipw_priv *priv = ieee80211_priv(dev);
8346 struct iw_range *range = (struct iw_range *)extra;
8347 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
8350 wrqu->data.length = sizeof(*range);
8351 memset(range, 0, sizeof(*range));
8353 /* 54Mbs == ~27 Mb/s real (802.11g) */
8354 range->throughput = 27 * 1000 * 1000;
8356 range->max_qual.qual = 100;
8357 /* TODO: Find real max RSSI and stick here */
8358 range->max_qual.level = 0;
8359 range->max_qual.noise = 0;
8360 range->max_qual.updated = 7; /* Updated all three */
8362 range->avg_qual.qual = 70;
8363 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8364 range->avg_qual.level = 0; /* FIXME to real average level */
8365 range->avg_qual.noise = 0;
8366 range->avg_qual.updated = 7; /* Updated all three */
8367 mutex_lock(&priv->mutex);
8368 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8370 for (i = 0; i < range->num_bitrates; i++)
8371 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8374 range->max_rts = DEFAULT_RTS_THRESHOLD;
8375 range->min_frag = MIN_FRAG_THRESHOLD;
8376 range->max_frag = MAX_FRAG_THRESHOLD;
8378 range->encoding_size[0] = 5;
8379 range->encoding_size[1] = 13;
8380 range->num_encoding_sizes = 2;
8381 range->max_encoding_tokens = WEP_KEYS;
8383 /* Set the Wireless Extension versions */
8384 range->we_version_compiled = WIRELESS_EXT;
8385 range->we_version_source = 18;
8388 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8389 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8390 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8391 (geo->bg[j].flags & IEEE80211_CH_PASSIVE_ONLY))
8394 range->freq[i].i = geo->bg[j].channel;
8395 range->freq[i].m = geo->bg[j].freq * 100000;
8396 range->freq[i].e = 1;
8401 if (priv->ieee->mode & IEEE_A) {
8402 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8403 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8404 (geo->a[j].flags & IEEE80211_CH_PASSIVE_ONLY))
8407 range->freq[i].i = geo->a[j].channel;
8408 range->freq[i].m = geo->a[j].freq * 100000;
8409 range->freq[i].e = 1;
8414 range->num_channels = i;
8415 range->num_frequency = i;
8417 mutex_unlock(&priv->mutex);
8419 /* Event capability (kernel + driver) */
8420 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8421 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8422 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8423 range->event_capa[1] = IW_EVENT_CAPA_K_1;
8425 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8426 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8428 IPW_DEBUG_WX("GET Range\n");
8432 static int ipw_wx_set_wap(struct net_device *dev,
8433 struct iw_request_info *info,
8434 union iwreq_data *wrqu, char *extra)
8436 struct ipw_priv *priv = ieee80211_priv(dev);
8438 static const unsigned char any[] = {
8439 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8441 static const unsigned char off[] = {
8442 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8445 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8447 mutex_lock(&priv->mutex);
8448 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8449 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8450 /* we disable mandatory BSSID association */
8451 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8452 priv->config &= ~CFG_STATIC_BSSID;
8453 IPW_DEBUG_ASSOC("Attempting to associate with new "
8455 ipw_associate(priv);
8456 mutex_unlock(&priv->mutex);
8460 priv->config |= CFG_STATIC_BSSID;
8461 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8462 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8463 mutex_unlock(&priv->mutex);
8467 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8468 MAC_ARG(wrqu->ap_addr.sa_data));
8470 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8472 /* Network configuration changed -- force [re]association */
8473 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8474 if (!ipw_disassociate(priv))
8475 ipw_associate(priv);
8477 mutex_unlock(&priv->mutex);
8481 static int ipw_wx_get_wap(struct net_device *dev,
8482 struct iw_request_info *info,
8483 union iwreq_data *wrqu, char *extra)
8485 struct ipw_priv *priv = ieee80211_priv(dev);
8486 /* If we are associated, trying to associate, or have a statically
8487 * configured BSSID then return that; otherwise return ANY */
8488 mutex_lock(&priv->mutex);
8489 if (priv->config & CFG_STATIC_BSSID ||
8490 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8491 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8492 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8494 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8496 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8497 MAC_ARG(wrqu->ap_addr.sa_data));
8498 mutex_unlock(&priv->mutex);
8502 static int ipw_wx_set_essid(struct net_device *dev,
8503 struct iw_request_info *info,
8504 union iwreq_data *wrqu, char *extra)
8506 struct ipw_priv *priv = ieee80211_priv(dev);
8507 char *essid = ""; /* ANY */
8509 mutex_lock(&priv->mutex);
8510 if (wrqu->essid.flags && wrqu->essid.length) {
8511 length = wrqu->essid.length - 1;
8515 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8516 if ((priv->config & CFG_STATIC_ESSID) &&
8517 !(priv->status & (STATUS_ASSOCIATED |
8518 STATUS_ASSOCIATING))) {
8519 IPW_DEBUG_ASSOC("Attempting to associate with new "
8521 priv->config &= ~CFG_STATIC_ESSID;
8522 ipw_associate(priv);
8524 mutex_unlock(&priv->mutex);
8528 length = min(length, IW_ESSID_MAX_SIZE);
8530 priv->config |= CFG_STATIC_ESSID;
8532 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8533 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8534 mutex_unlock(&priv->mutex);
8538 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8541 priv->essid_len = length;
8542 memcpy(priv->essid, essid, priv->essid_len);
8544 /* Network configuration changed -- force [re]association */
8545 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8546 if (!ipw_disassociate(priv))
8547 ipw_associate(priv);
8549 mutex_unlock(&priv->mutex);
8553 static int ipw_wx_get_essid(struct net_device *dev,
8554 struct iw_request_info *info,
8555 union iwreq_data *wrqu, char *extra)
8557 struct ipw_priv *priv = ieee80211_priv(dev);
8559 /* If we are associated, trying to associate, or have a statically
8560 * configured ESSID then return that; otherwise return ANY */
8561 mutex_lock(&priv->mutex);
8562 if (priv->config & CFG_STATIC_ESSID ||
8563 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8564 IPW_DEBUG_WX("Getting essid: '%s'\n",
8565 escape_essid(priv->essid, priv->essid_len));
8566 memcpy(extra, priv->essid, priv->essid_len);
8567 wrqu->essid.length = priv->essid_len;
8568 wrqu->essid.flags = 1; /* active */
8570 IPW_DEBUG_WX("Getting essid: ANY\n");
8571 wrqu->essid.length = 0;
8572 wrqu->essid.flags = 0; /* active */
8574 mutex_unlock(&priv->mutex);
8578 static int ipw_wx_set_nick(struct net_device *dev,
8579 struct iw_request_info *info,
8580 union iwreq_data *wrqu, char *extra)
8582 struct ipw_priv *priv = ieee80211_priv(dev);
8584 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8585 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8587 mutex_lock(&priv->mutex);
8588 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
8589 memset(priv->nick, 0, sizeof(priv->nick));
8590 memcpy(priv->nick, extra, wrqu->data.length);
8591 IPW_DEBUG_TRACE("<<\n");
8592 mutex_unlock(&priv->mutex);
8597 static int ipw_wx_get_nick(struct net_device *dev,
8598 struct iw_request_info *info,
8599 union iwreq_data *wrqu, char *extra)
8601 struct ipw_priv *priv = ieee80211_priv(dev);
8602 IPW_DEBUG_WX("Getting nick\n");
8603 mutex_lock(&priv->mutex);
8604 wrqu->data.length = strlen(priv->nick) + 1;
8605 memcpy(extra, priv->nick, wrqu->data.length);
8606 wrqu->data.flags = 1; /* active */
8607 mutex_unlock(&priv->mutex);
8611 static int ipw_wx_set_rate(struct net_device *dev,
8612 struct iw_request_info *info,
8613 union iwreq_data *wrqu, char *extra)
8615 /* TODO: We should use semaphores or locks for access to priv */
8616 struct ipw_priv *priv = ieee80211_priv(dev);
8617 u32 target_rate = wrqu->bitrate.value;
8620 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8621 /* value = X, fixed = 1 means only rate X */
8622 /* value = X, fixed = 0 means all rates lower equal X */
8624 if (target_rate == -1) {
8626 mask = IEEE80211_DEFAULT_RATES_MASK;
8627 /* Now we should reassociate */
8632 fixed = wrqu->bitrate.fixed;
8634 if (target_rate == 1000000 || !fixed)
8635 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8636 if (target_rate == 1000000)
8639 if (target_rate == 2000000 || !fixed)
8640 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8641 if (target_rate == 2000000)
8644 if (target_rate == 5500000 || !fixed)
8645 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8646 if (target_rate == 5500000)
8649 if (target_rate == 6000000 || !fixed)
8650 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8651 if (target_rate == 6000000)
8654 if (target_rate == 9000000 || !fixed)
8655 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8656 if (target_rate == 9000000)
8659 if (target_rate == 11000000 || !fixed)
8660 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8661 if (target_rate == 11000000)
8664 if (target_rate == 12000000 || !fixed)
8665 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8666 if (target_rate == 12000000)
8669 if (target_rate == 18000000 || !fixed)
8670 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8671 if (target_rate == 18000000)
8674 if (target_rate == 24000000 || !fixed)
8675 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8676 if (target_rate == 24000000)
8679 if (target_rate == 36000000 || !fixed)
8680 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8681 if (target_rate == 36000000)
8684 if (target_rate == 48000000 || !fixed)
8685 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8686 if (target_rate == 48000000)
8689 if (target_rate == 54000000 || !fixed)
8690 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8691 if (target_rate == 54000000)
8694 IPW_DEBUG_WX("invalid rate specified, returning error\n");
8698 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8699 mask, fixed ? "fixed" : "sub-rates");
8700 mutex_lock(&priv->mutex);
8701 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
8702 priv->config &= ~CFG_FIXED_RATE;
8703 ipw_set_fixed_rate(priv, priv->ieee->mode);
8705 priv->config |= CFG_FIXED_RATE;
8707 if (priv->rates_mask == mask) {
8708 IPW_DEBUG_WX("Mask set to current mask.\n");
8709 mutex_unlock(&priv->mutex);
8713 priv->rates_mask = mask;
8715 /* Network configuration changed -- force [re]association */
8716 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8717 if (!ipw_disassociate(priv))
8718 ipw_associate(priv);
8720 mutex_unlock(&priv->mutex);
8724 static int ipw_wx_get_rate(struct net_device *dev,
8725 struct iw_request_info *info,
8726 union iwreq_data *wrqu, char *extra)
8728 struct ipw_priv *priv = ieee80211_priv(dev);
8729 mutex_lock(&priv->mutex);
8730 wrqu->bitrate.value = priv->last_rate;
8731 mutex_unlock(&priv->mutex);
8732 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8736 static int ipw_wx_set_rts(struct net_device *dev,
8737 struct iw_request_info *info,
8738 union iwreq_data *wrqu, char *extra)
8740 struct ipw_priv *priv = ieee80211_priv(dev);
8741 mutex_lock(&priv->mutex);
8742 if (wrqu->rts.disabled)
8743 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8745 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
8746 wrqu->rts.value > MAX_RTS_THRESHOLD) {
8747 mutex_unlock(&priv->mutex);
8750 priv->rts_threshold = wrqu->rts.value;
8753 ipw_send_rts_threshold(priv, priv->rts_threshold);
8754 mutex_unlock(&priv->mutex);
8755 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8759 static int ipw_wx_get_rts(struct net_device *dev,
8760 struct iw_request_info *info,
8761 union iwreq_data *wrqu, char *extra)
8763 struct ipw_priv *priv = ieee80211_priv(dev);
8764 mutex_lock(&priv->mutex);
8765 wrqu->rts.value = priv->rts_threshold;
8766 wrqu->rts.fixed = 0; /* no auto select */
8767 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
8768 mutex_unlock(&priv->mutex);
8769 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8773 static int ipw_wx_set_txpow(struct net_device *dev,
8774 struct iw_request_info *info,
8775 union iwreq_data *wrqu, char *extra)
8777 struct ipw_priv *priv = ieee80211_priv(dev);
8780 mutex_lock(&priv->mutex);
8781 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
8786 if (!wrqu->power.fixed)
8787 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8789 if (wrqu->power.flags != IW_TXPOW_DBM) {
8794 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
8795 (wrqu->power.value < IPW_TX_POWER_MIN)) {
8800 priv->tx_power = wrqu->power.value;
8801 err = ipw_set_tx_power(priv);
8803 mutex_unlock(&priv->mutex);
8807 static int ipw_wx_get_txpow(struct net_device *dev,
8808 struct iw_request_info *info,
8809 union iwreq_data *wrqu, char *extra)
8811 struct ipw_priv *priv = ieee80211_priv(dev);
8812 mutex_lock(&priv->mutex);
8813 wrqu->power.value = priv->tx_power;
8814 wrqu->power.fixed = 1;
8815 wrqu->power.flags = IW_TXPOW_DBM;
8816 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
8817 mutex_unlock(&priv->mutex);
8819 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
8820 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
8825 static int ipw_wx_set_frag(struct net_device *dev,
8826 struct iw_request_info *info,
8827 union iwreq_data *wrqu, char *extra)
8829 struct ipw_priv *priv = ieee80211_priv(dev);
8830 mutex_lock(&priv->mutex);
8831 if (wrqu->frag.disabled)
8832 priv->ieee->fts = DEFAULT_FTS;
8834 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
8835 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8836 mutex_unlock(&priv->mutex);
8840 priv->ieee->fts = wrqu->frag.value & ~0x1;
8843 ipw_send_frag_threshold(priv, wrqu->frag.value);
8844 mutex_unlock(&priv->mutex);
8845 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8849 static int ipw_wx_get_frag(struct net_device *dev,
8850 struct iw_request_info *info,
8851 union iwreq_data *wrqu, char *extra)
8853 struct ipw_priv *priv = ieee80211_priv(dev);
8854 mutex_lock(&priv->mutex);
8855 wrqu->frag.value = priv->ieee->fts;
8856 wrqu->frag.fixed = 0; /* no auto select */
8857 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
8858 mutex_unlock(&priv->mutex);
8859 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8864 static int ipw_wx_set_retry(struct net_device *dev,
8865 struct iw_request_info *info,
8866 union iwreq_data *wrqu, char *extra)
8868 struct ipw_priv *priv = ieee80211_priv(dev);
8870 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8873 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8876 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8879 mutex_lock(&priv->mutex);
8880 if (wrqu->retry.flags & IW_RETRY_MIN)
8881 priv->short_retry_limit = (u8) wrqu->retry.value;
8882 else if (wrqu->retry.flags & IW_RETRY_MAX)
8883 priv->long_retry_limit = (u8) wrqu->retry.value;
8885 priv->short_retry_limit = (u8) wrqu->retry.value;
8886 priv->long_retry_limit = (u8) wrqu->retry.value;
8889 ipw_send_retry_limit(priv, priv->short_retry_limit,
8890 priv->long_retry_limit);
8891 mutex_unlock(&priv->mutex);
8892 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8893 priv->short_retry_limit, priv->long_retry_limit);
8897 static int ipw_wx_get_retry(struct net_device *dev,
8898 struct iw_request_info *info,
8899 union iwreq_data *wrqu, char *extra)
8901 struct ipw_priv *priv = ieee80211_priv(dev);
8903 mutex_lock(&priv->mutex);
8904 wrqu->retry.disabled = 0;
8906 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
8907 mutex_unlock(&priv->mutex);
8911 if (wrqu->retry.flags & IW_RETRY_MAX) {
8912 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8913 wrqu->retry.value = priv->long_retry_limit;
8914 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8915 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8916 wrqu->retry.value = priv->short_retry_limit;
8918 wrqu->retry.flags = IW_RETRY_LIMIT;
8919 wrqu->retry.value = priv->short_retry_limit;
8921 mutex_unlock(&priv->mutex);
8923 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8928 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8931 struct ipw_scan_request_ext scan;
8932 int err = 0, scan_type;
8934 if (!(priv->status & STATUS_INIT) ||
8935 (priv->status & STATUS_EXIT_PENDING))
8938 mutex_lock(&priv->mutex);
8940 if (priv->status & STATUS_RF_KILL_MASK) {
8941 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8942 priv->status |= STATUS_SCAN_PENDING;
8946 IPW_DEBUG_HC("starting request direct scan!\n");
8948 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
8949 /* We should not sleep here; otherwise we will block most
8950 * of the system (for instance, we hold rtnl_lock when we
8956 memset(&scan, 0, sizeof(scan));
8958 if (priv->config & CFG_SPEED_SCAN)
8959 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8962 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8965 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8967 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8968 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8970 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8972 err = ipw_send_ssid(priv, essid, essid_len);
8974 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8977 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8979 ipw_add_scan_channels(priv, &scan, scan_type);
8981 err = ipw_send_scan_request_ext(priv, &scan);
8983 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8987 priv->status |= STATUS_SCANNING;
8990 mutex_unlock(&priv->mutex);
8994 static int ipw_wx_set_scan(struct net_device *dev,
8995 struct iw_request_info *info,
8996 union iwreq_data *wrqu, char *extra)
8998 struct ipw_priv *priv = ieee80211_priv(dev);
8999 struct iw_scan_req *req = NULL;
9000 if (wrqu->data.length
9001 && wrqu->data.length == sizeof(struct iw_scan_req)) {
9002 req = (struct iw_scan_req *)extra;
9003 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9004 ipw_request_direct_scan(priv, req->essid,
9010 IPW_DEBUG_WX("Start scan\n");
9012 queue_work(priv->workqueue, &priv->request_scan);
9017 static int ipw_wx_get_scan(struct net_device *dev,
9018 struct iw_request_info *info,
9019 union iwreq_data *wrqu, char *extra)
9021 struct ipw_priv *priv = ieee80211_priv(dev);
9022 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9025 static int ipw_wx_set_encode(struct net_device *dev,
9026 struct iw_request_info *info,
9027 union iwreq_data *wrqu, char *key)
9029 struct ipw_priv *priv = ieee80211_priv(dev);
9031 u32 cap = priv->capability;
9033 mutex_lock(&priv->mutex);
9034 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9036 /* In IBSS mode, we need to notify the firmware to update
9037 * the beacon info after we changed the capability. */
9038 if (cap != priv->capability &&
9039 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9040 priv->status & STATUS_ASSOCIATED)
9041 ipw_disassociate(priv);
9043 mutex_unlock(&priv->mutex);
9047 static int ipw_wx_get_encode(struct net_device *dev,
9048 struct iw_request_info *info,
9049 union iwreq_data *wrqu, char *key)
9051 struct ipw_priv *priv = ieee80211_priv(dev);
9052 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9055 static int ipw_wx_set_power(struct net_device *dev,
9056 struct iw_request_info *info,
9057 union iwreq_data *wrqu, char *extra)
9059 struct ipw_priv *priv = ieee80211_priv(dev);
9061 mutex_lock(&priv->mutex);
9062 if (wrqu->power.disabled) {
9063 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9064 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9066 IPW_DEBUG_WX("failed setting power mode.\n");
9067 mutex_unlock(&priv->mutex);
9070 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9071 mutex_unlock(&priv->mutex);
9075 switch (wrqu->power.flags & IW_POWER_MODE) {
9076 case IW_POWER_ON: /* If not specified */
9077 case IW_POWER_MODE: /* If set all mask */
9078 case IW_POWER_ALL_R: /* If explicitely state all */
9080 default: /* Otherwise we don't support it */
9081 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9083 mutex_unlock(&priv->mutex);
9087 /* If the user hasn't specified a power management mode yet, default
9089 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9090 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9092 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9093 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9095 IPW_DEBUG_WX("failed setting power mode.\n");
9096 mutex_unlock(&priv->mutex);
9100 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9101 mutex_unlock(&priv->mutex);
9105 static int ipw_wx_get_power(struct net_device *dev,
9106 struct iw_request_info *info,
9107 union iwreq_data *wrqu, char *extra)
9109 struct ipw_priv *priv = ieee80211_priv(dev);
9110 mutex_lock(&priv->mutex);
9111 if (!(priv->power_mode & IPW_POWER_ENABLED))
9112 wrqu->power.disabled = 1;
9114 wrqu->power.disabled = 0;
9116 mutex_unlock(&priv->mutex);
9117 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9122 static int ipw_wx_set_powermode(struct net_device *dev,
9123 struct iw_request_info *info,
9124 union iwreq_data *wrqu, char *extra)
9126 struct ipw_priv *priv = ieee80211_priv(dev);
9127 int mode = *(int *)extra;
9129 mutex_lock(&priv->mutex);
9130 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9131 mode = IPW_POWER_AC;
9132 priv->power_mode = mode;
9134 priv->power_mode = IPW_POWER_ENABLED | mode;
9137 if (priv->power_mode != mode) {
9138 err = ipw_send_power_mode(priv, mode);
9141 IPW_DEBUG_WX("failed setting power mode.\n");
9142 mutex_unlock(&priv->mutex);
9146 mutex_unlock(&priv->mutex);
9150 #define MAX_WX_STRING 80
9151 static int ipw_wx_get_powermode(struct net_device *dev,
9152 struct iw_request_info *info,
9153 union iwreq_data *wrqu, char *extra)
9155 struct ipw_priv *priv = ieee80211_priv(dev);
9156 int level = IPW_POWER_LEVEL(priv->power_mode);
9159 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9163 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9165 case IPW_POWER_BATTERY:
9166 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9169 p += snprintf(p, MAX_WX_STRING - (p - extra),
9170 "(Timeout %dms, Period %dms)",
9171 timeout_duration[level - 1] / 1000,
9172 period_duration[level - 1] / 1000);
9175 if (!(priv->power_mode & IPW_POWER_ENABLED))
9176 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9178 wrqu->data.length = p - extra + 1;
9183 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9184 struct iw_request_info *info,
9185 union iwreq_data *wrqu, char *extra)
9187 struct ipw_priv *priv = ieee80211_priv(dev);
9188 int mode = *(int *)extra;
9189 u8 band = 0, modulation = 0;
9191 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9192 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9195 mutex_lock(&priv->mutex);
9196 if (priv->adapter == IPW_2915ABG) {
9197 priv->ieee->abg_true = 1;
9198 if (mode & IEEE_A) {
9199 band |= IEEE80211_52GHZ_BAND;
9200 modulation |= IEEE80211_OFDM_MODULATION;
9202 priv->ieee->abg_true = 0;
9204 if (mode & IEEE_A) {
9205 IPW_WARNING("Attempt to set 2200BG into "
9207 mutex_unlock(&priv->mutex);
9211 priv->ieee->abg_true = 0;
9214 if (mode & IEEE_B) {
9215 band |= IEEE80211_24GHZ_BAND;
9216 modulation |= IEEE80211_CCK_MODULATION;
9218 priv->ieee->abg_true = 0;
9220 if (mode & IEEE_G) {
9221 band |= IEEE80211_24GHZ_BAND;
9222 modulation |= IEEE80211_OFDM_MODULATION;
9224 priv->ieee->abg_true = 0;
9226 priv->ieee->mode = mode;
9227 priv->ieee->freq_band = band;
9228 priv->ieee->modulation = modulation;
9229 init_supported_rates(priv, &priv->rates);
9231 /* Network configuration changed -- force [re]association */
9232 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9233 if (!ipw_disassociate(priv)) {
9234 ipw_send_supported_rates(priv, &priv->rates);
9235 ipw_associate(priv);
9238 /* Update the band LEDs */
9239 ipw_led_band_on(priv);
9241 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9242 mode & IEEE_A ? 'a' : '.',
9243 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9244 mutex_unlock(&priv->mutex);
9248 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9249 struct iw_request_info *info,
9250 union iwreq_data *wrqu, char *extra)
9252 struct ipw_priv *priv = ieee80211_priv(dev);
9253 mutex_lock(&priv->mutex);
9254 switch (priv->ieee->mode) {
9256 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9259 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9261 case IEEE_A | IEEE_B:
9262 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9265 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9267 case IEEE_A | IEEE_G:
9268 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9270 case IEEE_B | IEEE_G:
9271 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9273 case IEEE_A | IEEE_B | IEEE_G:
9274 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9277 strncpy(extra, "unknown", MAX_WX_STRING);
9281 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9283 wrqu->data.length = strlen(extra) + 1;
9284 mutex_unlock(&priv->mutex);
9289 static int ipw_wx_set_preamble(struct net_device *dev,
9290 struct iw_request_info *info,
9291 union iwreq_data *wrqu, char *extra)
9293 struct ipw_priv *priv = ieee80211_priv(dev);
9294 int mode = *(int *)extra;
9295 mutex_lock(&priv->mutex);
9296 /* Switching from SHORT -> LONG requires a disassociation */
9298 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9299 priv->config |= CFG_PREAMBLE_LONG;
9301 /* Network configuration changed -- force [re]association */
9303 ("[re]association triggered due to preamble change.\n");
9304 if (!ipw_disassociate(priv))
9305 ipw_associate(priv);
9311 priv->config &= ~CFG_PREAMBLE_LONG;
9314 mutex_unlock(&priv->mutex);
9318 mutex_unlock(&priv->mutex);
9322 static int ipw_wx_get_preamble(struct net_device *dev,
9323 struct iw_request_info *info,
9324 union iwreq_data *wrqu, char *extra)
9326 struct ipw_priv *priv = ieee80211_priv(dev);
9327 mutex_lock(&priv->mutex);
9328 if (priv->config & CFG_PREAMBLE_LONG)
9329 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9331 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9332 mutex_unlock(&priv->mutex);
9336 #ifdef CONFIG_IPW2200_MONITOR
9337 static int ipw_wx_set_monitor(struct net_device *dev,
9338 struct iw_request_info *info,
9339 union iwreq_data *wrqu, char *extra)
9341 struct ipw_priv *priv = ieee80211_priv(dev);
9342 int *parms = (int *)extra;
9343 int enable = (parms[0] > 0);
9344 mutex_lock(&priv->mutex);
9345 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9347 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9348 #ifdef CONFIG_IEEE80211_RADIOTAP
9349 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9351 priv->net_dev->type = ARPHRD_IEEE80211;
9353 queue_work(priv->workqueue, &priv->adapter_restart);
9356 ipw_set_channel(priv, parms[1]);
9358 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9359 mutex_unlock(&priv->mutex);
9362 priv->net_dev->type = ARPHRD_ETHER;
9363 queue_work(priv->workqueue, &priv->adapter_restart);
9365 mutex_unlock(&priv->mutex);
9369 #endif // CONFIG_IPW2200_MONITOR
9371 static int ipw_wx_reset(struct net_device *dev,
9372 struct iw_request_info *info,
9373 union iwreq_data *wrqu, char *extra)
9375 struct ipw_priv *priv = ieee80211_priv(dev);
9376 IPW_DEBUG_WX("RESET\n");
9377 queue_work(priv->workqueue, &priv->adapter_restart);
9381 static int ipw_wx_sw_reset(struct net_device *dev,
9382 struct iw_request_info *info,
9383 union iwreq_data *wrqu, char *extra)
9385 struct ipw_priv *priv = ieee80211_priv(dev);
9386 union iwreq_data wrqu_sec = {
9388 .flags = IW_ENCODE_DISABLED,
9393 IPW_DEBUG_WX("SW_RESET\n");
9395 mutex_lock(&priv->mutex);
9397 ret = ipw_sw_reset(priv, 2);
9400 ipw_adapter_restart(priv);
9403 /* The SW reset bit might have been toggled on by the 'disable'
9404 * module parameter, so take appropriate action */
9405 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9407 mutex_unlock(&priv->mutex);
9408 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9409 mutex_lock(&priv->mutex);
9411 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9412 /* Configuration likely changed -- force [re]association */
9413 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9415 if (!ipw_disassociate(priv))
9416 ipw_associate(priv);
9419 mutex_unlock(&priv->mutex);
9424 /* Rebase the WE IOCTLs to zero for the handler array */
9425 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9426 static iw_handler ipw_wx_handlers[] = {
9427 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9428 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9429 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9430 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9431 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9432 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9433 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9434 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9435 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9436 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9437 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9438 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9439 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9440 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9441 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9442 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9443 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9444 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9445 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9446 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9447 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9448 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9449 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9450 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9451 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9452 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9453 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9454 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9455 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9456 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9457 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9458 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9459 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9460 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9461 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9462 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9463 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9464 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9465 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9469 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9473 IPW_PRIV_SET_PREAMBLE,
9474 IPW_PRIV_GET_PREAMBLE,
9477 #ifdef CONFIG_IPW2200_MONITOR
9478 IPW_PRIV_SET_MONITOR,
9482 static struct iw_priv_args ipw_priv_args[] = {
9484 .cmd = IPW_PRIV_SET_POWER,
9485 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9486 .name = "set_power"},
9488 .cmd = IPW_PRIV_GET_POWER,
9489 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9490 .name = "get_power"},
9492 .cmd = IPW_PRIV_SET_MODE,
9493 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9494 .name = "set_mode"},
9496 .cmd = IPW_PRIV_GET_MODE,
9497 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9498 .name = "get_mode"},
9500 .cmd = IPW_PRIV_SET_PREAMBLE,
9501 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9502 .name = "set_preamble"},
9504 .cmd = IPW_PRIV_GET_PREAMBLE,
9505 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9506 .name = "get_preamble"},
9509 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9512 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9513 #ifdef CONFIG_IPW2200_MONITOR
9515 IPW_PRIV_SET_MONITOR,
9516 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9517 #endif /* CONFIG_IPW2200_MONITOR */
9520 static iw_handler ipw_priv_handler[] = {
9521 ipw_wx_set_powermode,
9522 ipw_wx_get_powermode,
9523 ipw_wx_set_wireless_mode,
9524 ipw_wx_get_wireless_mode,
9525 ipw_wx_set_preamble,
9526 ipw_wx_get_preamble,
9529 #ifdef CONFIG_IPW2200_MONITOR
9534 static struct iw_handler_def ipw_wx_handler_def = {
9535 .standard = ipw_wx_handlers,
9536 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9537 .num_private = ARRAY_SIZE(ipw_priv_handler),
9538 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9539 .private = ipw_priv_handler,
9540 .private_args = ipw_priv_args,
9541 .get_wireless_stats = ipw_get_wireless_stats,
9545 * Get wireless statistics.
9546 * Called by /proc/net/wireless
9547 * Also called by SIOCGIWSTATS
9549 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9551 struct ipw_priv *priv = ieee80211_priv(dev);
9552 struct iw_statistics *wstats;
9554 wstats = &priv->wstats;
9556 /* if hw is disabled, then ipw_get_ordinal() can't be called.
9557 * netdev->get_wireless_stats seems to be called before fw is
9558 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9559 * and associated; if not associcated, the values are all meaningless
9560 * anyway, so set them all to NULL and INVALID */
9561 if (!(priv->status & STATUS_ASSOCIATED)) {
9562 wstats->miss.beacon = 0;
9563 wstats->discard.retries = 0;
9564 wstats->qual.qual = 0;
9565 wstats->qual.level = 0;
9566 wstats->qual.noise = 0;
9567 wstats->qual.updated = 7;
9568 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9569 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9573 wstats->qual.qual = priv->quality;
9574 wstats->qual.level = average_value(&priv->average_rssi);
9575 wstats->qual.noise = average_value(&priv->average_noise);
9576 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9577 IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
9579 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9580 wstats->discard.retries = priv->last_tx_failures;
9581 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9583 /* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9584 goto fail_get_ordinal;
9585 wstats->discard.retries += tx_retry; */
9590 /* net device stuff */
9592 static void init_sys_config(struct ipw_sys_config *sys_config)
9594 memset(sys_config, 0, sizeof(struct ipw_sys_config));
9595 sys_config->bt_coexistence = 0;
9596 sys_config->answer_broadcast_ssid_probe = 0;
9597 sys_config->accept_all_data_frames = 0;
9598 sys_config->accept_non_directed_frames = 1;
9599 sys_config->exclude_unicast_unencrypted = 0;
9600 sys_config->disable_unicast_decryption = 1;
9601 sys_config->exclude_multicast_unencrypted = 0;
9602 sys_config->disable_multicast_decryption = 1;
9603 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
9604 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
9605 sys_config->dot11g_auto_detection = 0;
9606 sys_config->enable_cts_to_self = 0;
9607 sys_config->bt_coexist_collision_thr = 0;
9608 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
9609 sys_config->silence_threshold = 0x1e;
9612 static int ipw_net_open(struct net_device *dev)
9614 struct ipw_priv *priv = ieee80211_priv(dev);
9615 IPW_DEBUG_INFO("dev->open\n");
9616 /* we should be verifying the device is ready to be opened */
9617 mutex_lock(&priv->mutex);
9618 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9619 (priv->status & STATUS_ASSOCIATED))
9620 netif_start_queue(dev);
9621 mutex_unlock(&priv->mutex);
9625 static int ipw_net_stop(struct net_device *dev)
9627 IPW_DEBUG_INFO("dev->close\n");
9628 netif_stop_queue(dev);
9635 modify to send one tfd per fragment instead of using chunking. otherwise
9636 we need to heavily modify the ieee80211_skb_to_txb.
9639 static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9642 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9643 txb->fragments[0]->data;
9645 struct tfd_frame *tfd;
9646 #ifdef CONFIG_IPW_QOS
9647 int tx_id = ipw_get_tx_queue_number(priv, pri);
9648 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9650 struct clx2_tx_queue *txq = &priv->txq[0];
9652 struct clx2_queue *q = &txq->q;
9653 u8 id, hdr_len, unicast;
9654 u16 remaining_bytes;
9657 switch (priv->ieee->iw_mode) {
9659 hdr_len = IEEE80211_3ADDR_LEN;
9660 unicast = !is_multicast_ether_addr(hdr->addr1);
9661 id = ipw_find_station(priv, hdr->addr1);
9662 if (id == IPW_INVALID_STATION) {
9663 id = ipw_add_station(priv, hdr->addr1);
9664 if (id == IPW_INVALID_STATION) {
9665 IPW_WARNING("Attempt to send data to "
9666 "invalid cell: " MAC_FMT "\n",
9667 MAC_ARG(hdr->addr1));
9675 unicast = !is_multicast_ether_addr(hdr->addr3);
9676 hdr_len = IEEE80211_3ADDR_LEN;
9681 tfd = &txq->bd[q->first_empty];
9682 txq->txb[q->first_empty] = txb;
9683 memset(tfd, 0, sizeof(*tfd));
9684 tfd->u.data.station_number = id;
9686 tfd->control_flags.message_type = TX_FRAME_TYPE;
9687 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9689 tfd->u.data.cmd_id = DINO_CMD_TX;
9690 tfd->u.data.len = cpu_to_le16(txb->payload_size);
9691 remaining_bytes = txb->payload_size;
9693 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9694 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9696 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9698 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9699 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9701 fc = le16_to_cpu(hdr->frame_ctl);
9702 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9704 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9706 if (likely(unicast))
9707 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9709 if (txb->encrypted && !priv->ieee->host_encrypt) {
9710 switch (priv->ieee->sec.level) {
9712 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9713 IEEE80211_FCTL_PROTECTED;
9714 /* XXX: ACK flag must be set for CCMP even if it
9715 * is a multicast/broadcast packet, because CCMP
9716 * group communication encrypted by GTK is
9717 * actually done by the AP. */
9719 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9721 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9722 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9723 tfd->u.data.key_index = 0;
9724 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9727 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9728 IEEE80211_FCTL_PROTECTED;
9729 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9730 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9731 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9734 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9735 IEEE80211_FCTL_PROTECTED;
9736 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9737 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9739 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9741 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9746 printk(KERN_ERR "Unknow security level %d\n",
9747 priv->ieee->sec.level);
9751 /* No hardware encryption */
9752 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9754 #ifdef CONFIG_IPW_QOS
9755 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9756 #endif /* CONFIG_IPW_QOS */
9759 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9761 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9762 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9763 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9764 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9765 i, le32_to_cpu(tfd->u.data.num_chunks),
9766 txb->fragments[i]->len - hdr_len);
9767 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9768 i, tfd->u.data.num_chunks,
9769 txb->fragments[i]->len - hdr_len);
9770 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9771 txb->fragments[i]->len - hdr_len);
9773 tfd->u.data.chunk_ptr[i] =
9774 cpu_to_le32(pci_map_single
9776 txb->fragments[i]->data + hdr_len,
9777 txb->fragments[i]->len - hdr_len,
9779 tfd->u.data.chunk_len[i] =
9780 cpu_to_le16(txb->fragments[i]->len - hdr_len);
9783 if (i != txb->nr_frags) {
9784 struct sk_buff *skb;
9785 u16 remaining_bytes = 0;
9788 for (j = i; j < txb->nr_frags; j++)
9789 remaining_bytes += txb->fragments[j]->len - hdr_len;
9791 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9793 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9795 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9796 for (j = i; j < txb->nr_frags; j++) {
9797 int size = txb->fragments[j]->len - hdr_len;
9799 printk(KERN_INFO "Adding frag %d %d...\n",
9801 memcpy(skb_put(skb, size),
9802 txb->fragments[j]->data + hdr_len, size);
9804 dev_kfree_skb_any(txb->fragments[i]);
9805 txb->fragments[i] = skb;
9806 tfd->u.data.chunk_ptr[i] =
9807 cpu_to_le32(pci_map_single
9808 (priv->pci_dev, skb->data,
9809 tfd->u.data.chunk_len[i],
9812 tfd->u.data.num_chunks =
9813 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9819 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9820 ipw_write32(priv, q->reg_w, q->first_empty);
9822 if (ipw_queue_space(q) < q->high_mark)
9823 netif_stop_queue(priv->net_dev);
9825 return NETDEV_TX_OK;
9828 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9829 ieee80211_txb_free(txb);
9830 return NETDEV_TX_OK;
9833 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9835 struct ipw_priv *priv = ieee80211_priv(dev);
9836 #ifdef CONFIG_IPW_QOS
9837 int tx_id = ipw_get_tx_queue_number(priv, pri);
9838 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9840 struct clx2_tx_queue *txq = &priv->txq[0];
9841 #endif /* CONFIG_IPW_QOS */
9843 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9849 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9850 struct net_device *dev, int pri)
9852 struct ipw_priv *priv = ieee80211_priv(dev);
9853 unsigned long flags;
9856 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9857 spin_lock_irqsave(&priv->lock, flags);
9859 if (!(priv->status & STATUS_ASSOCIATED)) {
9860 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9861 priv->ieee->stats.tx_carrier_errors++;
9862 netif_stop_queue(dev);
9866 ret = ipw_tx_skb(priv, txb, pri);
9867 if (ret == NETDEV_TX_OK)
9868 __ipw_led_activity_on(priv);
9869 spin_unlock_irqrestore(&priv->lock, flags);
9874 spin_unlock_irqrestore(&priv->lock, flags);
9878 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9880 struct ipw_priv *priv = ieee80211_priv(dev);
9882 priv->ieee->stats.tx_packets = priv->tx_packets;
9883 priv->ieee->stats.rx_packets = priv->rx_packets;
9884 return &priv->ieee->stats;
9887 static void ipw_net_set_multicast_list(struct net_device *dev)
9892 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9894 struct ipw_priv *priv = ieee80211_priv(dev);
9895 struct sockaddr *addr = p;
9896 if (!is_valid_ether_addr(addr->sa_data))
9897 return -EADDRNOTAVAIL;
9898 mutex_lock(&priv->mutex);
9899 priv->config |= CFG_CUSTOM_MAC;
9900 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9901 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9902 priv->net_dev->name, MAC_ARG(priv->mac_addr));
9903 queue_work(priv->workqueue, &priv->adapter_restart);
9904 mutex_unlock(&priv->mutex);
9908 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9909 struct ethtool_drvinfo *info)
9911 struct ipw_priv *p = ieee80211_priv(dev);
9916 strcpy(info->driver, DRV_NAME);
9917 strcpy(info->version, DRV_VERSION);
9920 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9922 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9924 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9926 strcpy(info->bus_info, pci_name(p->pci_dev));
9927 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9930 static u32 ipw_ethtool_get_link(struct net_device *dev)
9932 struct ipw_priv *priv = ieee80211_priv(dev);
9933 return (priv->status & STATUS_ASSOCIATED) != 0;
9936 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9938 return IPW_EEPROM_IMAGE_SIZE;
9941 static int ipw_ethtool_get_eeprom(struct net_device *dev,
9942 struct ethtool_eeprom *eeprom, u8 * bytes)
9944 struct ipw_priv *p = ieee80211_priv(dev);
9946 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9948 mutex_lock(&p->mutex);
9949 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9950 mutex_unlock(&p->mutex);
9954 static int ipw_ethtool_set_eeprom(struct net_device *dev,
9955 struct ethtool_eeprom *eeprom, u8 * bytes)
9957 struct ipw_priv *p = ieee80211_priv(dev);
9960 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9962 mutex_lock(&p->mutex);
9963 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
9964 for (i = IPW_EEPROM_DATA;
9965 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
9966 ipw_write8(p, i, p->eeprom[i]);
9967 mutex_unlock(&p->mutex);
9971 static struct ethtool_ops ipw_ethtool_ops = {
9972 .get_link = ipw_ethtool_get_link,
9973 .get_drvinfo = ipw_ethtool_get_drvinfo,
9974 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9975 .get_eeprom = ipw_ethtool_get_eeprom,
9976 .set_eeprom = ipw_ethtool_set_eeprom,
9979 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9981 struct ipw_priv *priv = data;
9982 u32 inta, inta_mask;
9987 spin_lock(&priv->lock);
9989 if (!(priv->status & STATUS_INT_ENABLED)) {
9994 inta = ipw_read32(priv, IPW_INTA_RW);
9995 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
9997 if (inta == 0xFFFFFFFF) {
9998 /* Hardware disappeared */
9999 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10003 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10004 /* Shared interrupt */
10008 /* tell the device to stop sending interrupts */
10009 ipw_disable_interrupts(priv);
10011 /* ack current interrupts */
10012 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10013 ipw_write32(priv, IPW_INTA_RW, inta);
10015 /* Cache INTA value for our tasklet */
10016 priv->isr_inta = inta;
10018 tasklet_schedule(&priv->irq_tasklet);
10020 spin_unlock(&priv->lock);
10022 return IRQ_HANDLED;
10024 spin_unlock(&priv->lock);
10028 static void ipw_rf_kill(void *adapter)
10030 struct ipw_priv *priv = adapter;
10031 unsigned long flags;
10033 spin_lock_irqsave(&priv->lock, flags);
10035 if (rf_kill_active(priv)) {
10036 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10037 if (priv->workqueue)
10038 queue_delayed_work(priv->workqueue,
10039 &priv->rf_kill, 2 * HZ);
10043 /* RF Kill is now disabled, so bring the device back up */
10045 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10046 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10049 /* we can not do an adapter restart while inside an irq lock */
10050 queue_work(priv->workqueue, &priv->adapter_restart);
10052 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10056 spin_unlock_irqrestore(&priv->lock, flags);
10059 static void ipw_bg_rf_kill(void *data)
10061 struct ipw_priv *priv = data;
10062 mutex_lock(&priv->mutex);
10064 mutex_unlock(&priv->mutex);
10067 static void ipw_link_up(struct ipw_priv *priv)
10069 priv->last_seq_num = -1;
10070 priv->last_frag_num = -1;
10071 priv->last_packet_time = 0;
10073 netif_carrier_on(priv->net_dev);
10074 if (netif_queue_stopped(priv->net_dev)) {
10075 IPW_DEBUG_NOTIF("waking queue\n");
10076 netif_wake_queue(priv->net_dev);
10078 IPW_DEBUG_NOTIF("starting queue\n");
10079 netif_start_queue(priv->net_dev);
10082 cancel_delayed_work(&priv->request_scan);
10083 ipw_reset_stats(priv);
10084 /* Ensure the rate is updated immediately */
10085 priv->last_rate = ipw_get_current_rate(priv);
10086 ipw_gather_stats(priv);
10087 ipw_led_link_up(priv);
10088 notify_wx_assoc_event(priv);
10090 if (priv->config & CFG_BACKGROUND_SCAN)
10091 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10094 static void ipw_bg_link_up(void *data)
10096 struct ipw_priv *priv = data;
10097 mutex_lock(&priv->mutex);
10099 mutex_unlock(&priv->mutex);
10102 static void ipw_link_down(struct ipw_priv *priv)
10104 ipw_led_link_down(priv);
10105 netif_carrier_off(priv->net_dev);
10106 netif_stop_queue(priv->net_dev);
10107 notify_wx_assoc_event(priv);
10109 /* Cancel any queued work ... */
10110 cancel_delayed_work(&priv->request_scan);
10111 cancel_delayed_work(&priv->adhoc_check);
10112 cancel_delayed_work(&priv->gather_stats);
10114 ipw_reset_stats(priv);
10116 if (!(priv->status & STATUS_EXIT_PENDING)) {
10117 /* Queue up another scan... */
10118 queue_work(priv->workqueue, &priv->request_scan);
10122 static void ipw_bg_link_down(void *data)
10124 struct ipw_priv *priv = data;
10125 mutex_lock(&priv->mutex);
10126 ipw_link_down(data);
10127 mutex_unlock(&priv->mutex);
10130 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10134 priv->workqueue = create_workqueue(DRV_NAME);
10135 init_waitqueue_head(&priv->wait_command_queue);
10136 init_waitqueue_head(&priv->wait_state);
10138 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10139 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10140 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10141 INIT_WORK(&priv->system_config, ipw_system_config, priv);
10142 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10143 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10144 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10145 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10146 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10147 INIT_WORK(&priv->request_scan,
10148 (void (*)(void *))ipw_request_scan, priv);
10149 INIT_WORK(&priv->gather_stats,
10150 (void (*)(void *))ipw_bg_gather_stats, priv);
10151 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10152 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10153 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10154 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10155 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10156 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10158 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10160 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10162 INIT_WORK(&priv->merge_networks,
10163 (void (*)(void *))ipw_merge_adhoc_network, priv);
10165 #ifdef CONFIG_IPW_QOS
10166 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10168 #endif /* CONFIG_IPW_QOS */
10170 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10171 ipw_irq_tasklet, (unsigned long)priv);
10176 static void shim__set_security(struct net_device *dev,
10177 struct ieee80211_security *sec)
10179 struct ipw_priv *priv = ieee80211_priv(dev);
10181 for (i = 0; i < 4; i++) {
10182 if (sec->flags & (1 << i)) {
10183 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10184 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10185 if (sec->key_sizes[i] == 0)
10186 priv->ieee->sec.flags &= ~(1 << i);
10188 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10189 sec->key_sizes[i]);
10190 priv->ieee->sec.flags |= (1 << i);
10192 priv->status |= STATUS_SECURITY_UPDATED;
10193 } else if (sec->level != SEC_LEVEL_1)
10194 priv->ieee->sec.flags &= ~(1 << i);
10197 if (sec->flags & SEC_ACTIVE_KEY) {
10198 if (sec->active_key <= 3) {
10199 priv->ieee->sec.active_key = sec->active_key;
10200 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10202 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10203 priv->status |= STATUS_SECURITY_UPDATED;
10205 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10207 if ((sec->flags & SEC_AUTH_MODE) &&
10208 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10209 priv->ieee->sec.auth_mode = sec->auth_mode;
10210 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10211 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10212 priv->capability |= CAP_SHARED_KEY;
10214 priv->capability &= ~CAP_SHARED_KEY;
10215 priv->status |= STATUS_SECURITY_UPDATED;
10218 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10219 priv->ieee->sec.flags |= SEC_ENABLED;
10220 priv->ieee->sec.enabled = sec->enabled;
10221 priv->status |= STATUS_SECURITY_UPDATED;
10223 priv->capability |= CAP_PRIVACY_ON;
10225 priv->capability &= ~CAP_PRIVACY_ON;
10228 if (sec->flags & SEC_ENCRYPT)
10229 priv->ieee->sec.encrypt = sec->encrypt;
10231 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10232 priv->ieee->sec.level = sec->level;
10233 priv->ieee->sec.flags |= SEC_LEVEL;
10234 priv->status |= STATUS_SECURITY_UPDATED;
10237 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10238 ipw_set_hwcrypto_keys(priv);
10240 /* To match current functionality of ipw2100 (which works well w/
10241 * various supplicants, we don't force a disassociate if the
10242 * privacy capability changes ... */
10244 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10245 (((priv->assoc_request.capability &
10246 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10247 (!(priv->assoc_request.capability &
10248 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10249 IPW_DEBUG_ASSOC("Disassociating due to capability "
10251 ipw_disassociate(priv);
10256 static int init_supported_rates(struct ipw_priv *priv,
10257 struct ipw_supported_rates *rates)
10259 /* TODO: Mask out rates based on priv->rates_mask */
10261 memset(rates, 0, sizeof(*rates));
10262 /* configure supported rates */
10263 switch (priv->ieee->freq_band) {
10264 case IEEE80211_52GHZ_BAND:
10265 rates->ieee_mode = IPW_A_MODE;
10266 rates->purpose = IPW_RATE_CAPABILITIES;
10267 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10268 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10271 default: /* Mixed or 2.4Ghz */
10272 rates->ieee_mode = IPW_G_MODE;
10273 rates->purpose = IPW_RATE_CAPABILITIES;
10274 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10275 IEEE80211_CCK_DEFAULT_RATES_MASK);
10276 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10277 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10278 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10286 static int ipw_config(struct ipw_priv *priv)
10288 /* This is only called from ipw_up, which resets/reloads the firmware
10289 so, we don't need to first disable the card before we configure
10291 if (ipw_set_tx_power(priv))
10294 /* initialize adapter address */
10295 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10298 /* set basic system config settings */
10299 init_sys_config(&priv->sys_config);
10301 /* Support Bluetooth if we have BT h/w on board, and user wants to.
10302 * Does not support BT priority yet (don't abort or defer our Tx) */
10304 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10306 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10307 priv->sys_config.bt_coexistence
10308 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
10309 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10310 priv->sys_config.bt_coexistence
10311 |= CFG_BT_COEXISTENCE_OOB;
10314 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10315 priv->sys_config.answer_broadcast_ssid_probe = 1;
10317 priv->sys_config.answer_broadcast_ssid_probe = 0;
10319 if (ipw_send_system_config(priv, &priv->sys_config))
10322 init_supported_rates(priv, &priv->rates);
10323 if (ipw_send_supported_rates(priv, &priv->rates))
10326 /* Set request-to-send threshold */
10327 if (priv->rts_threshold) {
10328 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10331 #ifdef CONFIG_IPW_QOS
10332 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10333 ipw_qos_activate(priv, NULL);
10334 #endif /* CONFIG_IPW_QOS */
10336 if (ipw_set_random_seed(priv))
10339 /* final state transition to the RUN state */
10340 if (ipw_send_host_complete(priv))
10343 priv->status |= STATUS_INIT;
10345 ipw_led_init(priv);
10346 ipw_led_radio_on(priv);
10347 priv->notif_missed_beacons = 0;
10349 /* Set hardware WEP key if it is configured. */
10350 if ((priv->capability & CAP_PRIVACY_ON) &&
10351 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10352 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10353 ipw_set_hwcrypto_keys(priv);
10364 * These tables have been tested in conjunction with the
10365 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10367 * Altering this values, using it on other hardware, or in geographies
10368 * not intended for resale of the above mentioned Intel adapters has
10371 * Remember to update the table in README.ipw2200 when changing this
10375 static const struct ieee80211_geo ipw_geos[] = {
10379 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10380 {2427, 4}, {2432, 5}, {2437, 6},
10381 {2442, 7}, {2447, 8}, {2452, 9},
10382 {2457, 10}, {2462, 11}},
10385 { /* Custom US/Canada */
10388 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10389 {2427, 4}, {2432, 5}, {2437, 6},
10390 {2442, 7}, {2447, 8}, {2452, 9},
10391 {2457, 10}, {2462, 11}},
10397 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10398 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10399 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10400 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10403 { /* Rest of World */
10406 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10407 {2427, 4}, {2432, 5}, {2437, 6},
10408 {2442, 7}, {2447, 8}, {2452, 9},
10409 {2457, 10}, {2462, 11}, {2467, 12},
10413 { /* Custom USA & Europe & High */
10416 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10417 {2427, 4}, {2432, 5}, {2437, 6},
10418 {2442, 7}, {2447, 8}, {2452, 9},
10419 {2457, 10}, {2462, 11}},
10425 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10426 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10427 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10428 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10436 { /* Custom NA & Europe */
10439 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10440 {2427, 4}, {2432, 5}, {2437, 6},
10441 {2442, 7}, {2447, 8}, {2452, 9},
10442 {2457, 10}, {2462, 11}},
10448 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10449 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10450 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10451 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10452 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10453 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10454 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10455 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10456 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10459 { /* Custom Japan */
10462 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10463 {2427, 4}, {2432, 5}, {2437, 6},
10464 {2442, 7}, {2447, 8}, {2452, 9},
10465 {2457, 10}, {2462, 11}},
10467 .a = {{5170, 34}, {5190, 38},
10468 {5210, 42}, {5230, 46}},
10474 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10475 {2427, 4}, {2432, 5}, {2437, 6},
10476 {2442, 7}, {2447, 8}, {2452, 9},
10477 {2457, 10}, {2462, 11}},
10483 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10484 {2427, 4}, {2432, 5}, {2437, 6},
10485 {2442, 7}, {2447, 8}, {2452, 9},
10486 {2457, 10}, {2462, 11}, {2467, 12},
10493 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10494 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10495 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10496 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10497 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10498 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10499 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10500 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10501 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10502 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10503 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10504 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10505 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10506 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10507 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10510 { /* Custom Japan */
10513 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10514 {2427, 4}, {2432, 5}, {2437, 6},
10515 {2442, 7}, {2447, 8}, {2452, 9},
10516 {2457, 10}, {2462, 11}, {2467, 12},
10517 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10519 .a = {{5170, 34}, {5190, 38},
10520 {5210, 42}, {5230, 46}},
10523 { /* Rest of World */
10526 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10527 {2427, 4}, {2432, 5}, {2437, 6},
10528 {2442, 7}, {2447, 8}, {2452, 9},
10529 {2457, 10}, {2462, 11}, {2467, 12},
10530 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10531 IEEE80211_CH_PASSIVE_ONLY}},
10537 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10538 {2427, 4}, {2432, 5}, {2437, 6},
10539 {2442, 7}, {2447, 8}, {2452, 9},
10540 {2457, 10}, {2462, 11},
10541 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10542 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10544 .a = {{5745, 149}, {5765, 153},
10545 {5785, 157}, {5805, 161}},
10548 { /* Custom Europe */
10551 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10552 {2427, 4}, {2432, 5}, {2437, 6},
10553 {2442, 7}, {2447, 8}, {2452, 9},
10554 {2457, 10}, {2462, 11},
10555 {2467, 12}, {2472, 13}},
10557 .a = {{5180, 36}, {5200, 40},
10558 {5220, 44}, {5240, 48}},
10564 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10565 {2427, 4}, {2432, 5}, {2437, 6},
10566 {2442, 7}, {2447, 8}, {2452, 9},
10567 {2457, 10}, {2462, 11},
10568 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10569 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10571 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10572 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10573 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10574 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10575 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10576 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10577 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10578 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10579 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10580 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10581 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10582 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10583 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10584 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10585 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10586 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10587 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10588 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10589 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10590 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10591 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10592 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10593 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10594 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10600 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10601 {2427, 4}, {2432, 5}, {2437, 6},
10602 {2442, 7}, {2447, 8}, {2452, 9},
10603 {2457, 10}, {2462, 11}},
10605 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10606 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10607 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10608 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10609 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10610 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10611 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10612 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10613 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10614 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10615 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10616 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10617 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10621 #define MAX_HW_RESTARTS 5
10622 static int ipw_up(struct ipw_priv *priv)
10626 if (priv->status & STATUS_EXIT_PENDING)
10629 if (cmdlog && !priv->cmdlog) {
10630 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10632 if (priv->cmdlog == NULL) {
10633 IPW_ERROR("Error allocating %d command log entries.\n",
10636 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10637 priv->cmdlog_len = cmdlog;
10641 for (i = 0; i < MAX_HW_RESTARTS; i++) {
10642 /* Load the microcode, firmware, and eeprom.
10643 * Also start the clocks. */
10644 rc = ipw_load(priv);
10646 IPW_ERROR("Unable to load firmware: %d\n", rc);
10650 ipw_init_ordinals(priv);
10651 if (!(priv->config & CFG_CUSTOM_MAC))
10652 eeprom_parse_mac(priv, priv->mac_addr);
10653 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10655 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10656 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10657 ipw_geos[j].name, 3))
10660 if (j == ARRAY_SIZE(ipw_geos)) {
10661 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10662 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10663 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10664 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10667 if (ieee80211_set_geo(priv->ieee, &ipw_geos[j])) {
10668 IPW_WARNING("Could not set geography.");
10672 if (priv->status & STATUS_RF_KILL_SW) {
10673 IPW_WARNING("Radio disabled by module parameter.\n");
10675 } else if (rf_kill_active(priv)) {
10676 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10677 "Kill switch must be turned off for "
10678 "wireless networking to work.\n");
10679 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10684 rc = ipw_config(priv);
10686 IPW_DEBUG_INFO("Configured device on count %i\n", i);
10688 /* If configure to try and auto-associate, kick
10690 queue_work(priv->workqueue, &priv->request_scan);
10695 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10696 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10697 i, MAX_HW_RESTARTS);
10699 /* We had an error bringing up the hardware, so take it
10700 * all the way back down so we can try again */
10704 /* tried to restart and config the device for as long as our
10705 * patience could withstand */
10706 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10711 static void ipw_bg_up(void *data)
10713 struct ipw_priv *priv = data;
10714 mutex_lock(&priv->mutex);
10716 mutex_unlock(&priv->mutex);
10719 static void ipw_deinit(struct ipw_priv *priv)
10723 if (priv->status & STATUS_SCANNING) {
10724 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10725 ipw_abort_scan(priv);
10728 if (priv->status & STATUS_ASSOCIATED) {
10729 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10730 ipw_disassociate(priv);
10733 ipw_led_shutdown(priv);
10735 /* Wait up to 1s for status to change to not scanning and not
10736 * associated (disassociation can take a while for a ful 802.11
10738 for (i = 1000; i && (priv->status &
10739 (STATUS_DISASSOCIATING |
10740 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10743 if (priv->status & (STATUS_DISASSOCIATING |
10744 STATUS_ASSOCIATED | STATUS_SCANNING))
10745 IPW_DEBUG_INFO("Still associated or scanning...\n");
10747 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10749 /* Attempt to disable the card */
10750 ipw_send_card_disable(priv, 0);
10752 priv->status &= ~STATUS_INIT;
10755 static void ipw_down(struct ipw_priv *priv)
10757 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10759 priv->status |= STATUS_EXIT_PENDING;
10761 if (ipw_is_init(priv))
10764 /* Wipe out the EXIT_PENDING status bit if we are not actually
10765 * exiting the module */
10767 priv->status &= ~STATUS_EXIT_PENDING;
10769 /* tell the device to stop sending interrupts */
10770 ipw_disable_interrupts(priv);
10772 /* Clear all bits but the RF Kill */
10773 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10774 netif_carrier_off(priv->net_dev);
10775 netif_stop_queue(priv->net_dev);
10777 ipw_stop_nic(priv);
10779 ipw_led_radio_off(priv);
10782 static void ipw_bg_down(void *data)
10784 struct ipw_priv *priv = data;
10785 mutex_lock(&priv->mutex);
10787 mutex_unlock(&priv->mutex);
10790 /* Called by register_netdev() */
10791 static int ipw_net_init(struct net_device *dev)
10793 struct ipw_priv *priv = ieee80211_priv(dev);
10794 mutex_lock(&priv->mutex);
10796 if (ipw_up(priv)) {
10797 mutex_unlock(&priv->mutex);
10801 mutex_unlock(&priv->mutex);
10805 /* PCI driver stuff */
10806 static struct pci_device_id card_ids[] = {
10807 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10808 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10809 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10810 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10811 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10812 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10813 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10814 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10815 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10816 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10817 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10818 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10819 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10820 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10821 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10822 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10823 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10824 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10825 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10826 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10827 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10828 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10830 /* required last entry */
10834 MODULE_DEVICE_TABLE(pci, card_ids);
10836 static struct attribute *ipw_sysfs_entries[] = {
10837 &dev_attr_rf_kill.attr,
10838 &dev_attr_direct_dword.attr,
10839 &dev_attr_indirect_byte.attr,
10840 &dev_attr_indirect_dword.attr,
10841 &dev_attr_mem_gpio_reg.attr,
10842 &dev_attr_command_event_reg.attr,
10843 &dev_attr_nic_type.attr,
10844 &dev_attr_status.attr,
10845 &dev_attr_cfg.attr,
10846 &dev_attr_error.attr,
10847 &dev_attr_event_log.attr,
10848 &dev_attr_cmd_log.attr,
10849 &dev_attr_eeprom_delay.attr,
10850 &dev_attr_ucode_version.attr,
10851 &dev_attr_rtc.attr,
10852 &dev_attr_scan_age.attr,
10853 &dev_attr_led.attr,
10854 &dev_attr_speed_scan.attr,
10855 &dev_attr_net_stats.attr,
10859 static struct attribute_group ipw_attribute_group = {
10860 .name = NULL, /* put in device directory */
10861 .attrs = ipw_sysfs_entries,
10864 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
10867 struct net_device *net_dev;
10868 void __iomem *base;
10870 struct ipw_priv *priv;
10873 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10874 if (net_dev == NULL) {
10879 priv = ieee80211_priv(net_dev);
10880 priv->ieee = netdev_priv(net_dev);
10882 priv->net_dev = net_dev;
10883 priv->pci_dev = pdev;
10884 #ifdef CONFIG_IPW2200_DEBUG
10885 ipw_debug_level = debug;
10887 spin_lock_init(&priv->lock);
10888 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10889 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
10891 mutex_init(&priv->mutex);
10892 if (pci_enable_device(pdev)) {
10894 goto out_free_ieee80211;
10897 pci_set_master(pdev);
10899 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
10901 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
10903 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10904 goto out_pci_disable_device;
10907 pci_set_drvdata(pdev, priv);
10909 err = pci_request_regions(pdev, DRV_NAME);
10911 goto out_pci_disable_device;
10913 /* We disable the RETRY_TIMEOUT register (0x41) to keep
10914 * PCI Tx retries from interfering with C3 CPU state */
10915 pci_read_config_dword(pdev, 0x40, &val);
10916 if ((val & 0x0000ff00) != 0)
10917 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
10919 length = pci_resource_len(pdev, 0);
10920 priv->hw_len = length;
10922 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10925 goto out_pci_release_regions;
10928 priv->hw_base = base;
10929 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
10930 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
10932 err = ipw_setup_deferred_work(priv);
10934 IPW_ERROR("Unable to setup deferred work\n");
10938 ipw_sw_reset(priv, 1);
10940 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
10942 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
10943 goto out_destroy_workqueue;
10946 SET_MODULE_OWNER(net_dev);
10947 SET_NETDEV_DEV(net_dev, &pdev->dev);
10949 mutex_lock(&priv->mutex);
10951 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
10952 priv->ieee->set_security = shim__set_security;
10953 priv->ieee->is_queue_full = ipw_net_is_queue_full;
10955 #ifdef CONFIG_IPW_QOS
10956 priv->ieee->handle_probe_response = ipw_handle_beacon;
10957 priv->ieee->handle_beacon = ipw_handle_probe_response;
10958 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
10959 #endif /* CONFIG_IPW_QOS */
10961 priv->ieee->perfect_rssi = -20;
10962 priv->ieee->worst_rssi = -85;
10964 net_dev->open = ipw_net_open;
10965 net_dev->stop = ipw_net_stop;
10966 net_dev->init = ipw_net_init;
10967 net_dev->get_stats = ipw_net_get_stats;
10968 net_dev->set_multicast_list = ipw_net_set_multicast_list;
10969 net_dev->set_mac_address = ipw_net_set_mac_address;
10970 priv->wireless_data.spy_data = &priv->ieee->spy_data;
10971 net_dev->wireless_data = &priv->wireless_data;
10972 net_dev->wireless_handlers = &ipw_wx_handler_def;
10973 net_dev->ethtool_ops = &ipw_ethtool_ops;
10974 net_dev->irq = pdev->irq;
10975 net_dev->base_addr = (unsigned long)priv->hw_base;
10976 net_dev->mem_start = pci_resource_start(pdev, 0);
10977 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
10979 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
10981 IPW_ERROR("failed to create sysfs device attributes\n");
10982 mutex_unlock(&priv->mutex);
10983 goto out_release_irq;
10986 mutex_unlock(&priv->mutex);
10987 err = register_netdev(net_dev);
10989 IPW_ERROR("failed to register network device\n");
10990 goto out_remove_sysfs;
10993 printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
10994 "channels, %d 802.11a channels)\n",
10995 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
10996 priv->ieee->geo.a_channels);
11001 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11003 free_irq(pdev->irq, priv);
11004 out_destroy_workqueue:
11005 destroy_workqueue(priv->workqueue);
11006 priv->workqueue = NULL;
11008 iounmap(priv->hw_base);
11009 out_pci_release_regions:
11010 pci_release_regions(pdev);
11011 out_pci_disable_device:
11012 pci_disable_device(pdev);
11013 pci_set_drvdata(pdev, NULL);
11014 out_free_ieee80211:
11015 free_ieee80211(priv->net_dev);
11020 static void ipw_pci_remove(struct pci_dev *pdev)
11022 struct ipw_priv *priv = pci_get_drvdata(pdev);
11023 struct list_head *p, *q;
11029 mutex_lock(&priv->mutex);
11031 priv->status |= STATUS_EXIT_PENDING;
11033 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11035 mutex_unlock(&priv->mutex);
11037 unregister_netdev(priv->net_dev);
11040 ipw_rx_queue_free(priv, priv->rxq);
11043 ipw_tx_queue_free(priv);
11045 if (priv->cmdlog) {
11046 kfree(priv->cmdlog);
11047 priv->cmdlog = NULL;
11049 /* ipw_down will ensure that there is no more pending work
11050 * in the workqueue's, so we can safely remove them now. */
11051 cancel_delayed_work(&priv->adhoc_check);
11052 cancel_delayed_work(&priv->gather_stats);
11053 cancel_delayed_work(&priv->request_scan);
11054 cancel_delayed_work(&priv->rf_kill);
11055 cancel_delayed_work(&priv->scan_check);
11056 destroy_workqueue(priv->workqueue);
11057 priv->workqueue = NULL;
11059 /* Free MAC hash list for ADHOC */
11060 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11061 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11063 kfree(list_entry(p, struct ipw_ibss_seq, list));
11068 ipw_free_error_log(priv->error);
11069 priv->error = NULL;
11072 free_irq(pdev->irq, priv);
11073 iounmap(priv->hw_base);
11074 pci_release_regions(pdev);
11075 pci_disable_device(pdev);
11076 pci_set_drvdata(pdev, NULL);
11077 free_ieee80211(priv->net_dev);
11082 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11084 struct ipw_priv *priv = pci_get_drvdata(pdev);
11085 struct net_device *dev = priv->net_dev;
11087 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11089 /* Take down the device; powers it off, etc. */
11092 /* Remove the PRESENT state of the device */
11093 netif_device_detach(dev);
11095 pci_save_state(pdev);
11096 pci_disable_device(pdev);
11097 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11102 static int ipw_pci_resume(struct pci_dev *pdev)
11104 struct ipw_priv *priv = pci_get_drvdata(pdev);
11105 struct net_device *dev = priv->net_dev;
11108 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11110 pci_set_power_state(pdev, PCI_D0);
11111 pci_enable_device(pdev);
11112 pci_restore_state(pdev);
11115 * Suspend/Resume resets the PCI configuration space, so we have to
11116 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11117 * from interfering with C3 CPU state. pci_restore_state won't help
11118 * here since it only restores the first 64 bytes pci config header.
11120 pci_read_config_dword(pdev, 0x40, &val);
11121 if ((val & 0x0000ff00) != 0)
11122 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11124 /* Set the device back into the PRESENT state; this will also wake
11125 * the queue of needed */
11126 netif_device_attach(dev);
11128 /* Bring the device back up */
11129 queue_work(priv->workqueue, &priv->up);
11135 /* driver initialization stuff */
11136 static struct pci_driver ipw_driver = {
11138 .id_table = card_ids,
11139 .probe = ipw_pci_probe,
11140 .remove = __devexit_p(ipw_pci_remove),
11142 .suspend = ipw_pci_suspend,
11143 .resume = ipw_pci_resume,
11147 static int __init ipw_init(void)
11151 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11152 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11154 ret = pci_module_init(&ipw_driver);
11156 IPW_ERROR("Unable to initialize PCI module\n");
11160 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11162 IPW_ERROR("Unable to create driver sysfs file\n");
11163 pci_unregister_driver(&ipw_driver);
11170 static void __exit ipw_exit(void)
11172 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11173 pci_unregister_driver(&ipw_driver);
11176 module_param(disable, int, 0444);
11177 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11179 module_param(associate, int, 0444);
11180 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11182 module_param(auto_create, int, 0444);
11183 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11185 module_param(led, int, 0444);
11186 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11188 #ifdef CONFIG_IPW2200_DEBUG
11189 module_param(debug, int, 0444);
11190 MODULE_PARM_DESC(debug, "debug output mask");
11193 module_param(channel, int, 0444);
11194 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11196 #ifdef CONFIG_IPW_QOS
11197 module_param(qos_enable, int, 0444);
11198 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11200 module_param(qos_burst_enable, int, 0444);
11201 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11203 module_param(qos_no_ack_mask, int, 0444);
11204 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11206 module_param(burst_duration_CCK, int, 0444);
11207 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11209 module_param(burst_duration_OFDM, int, 0444);
11210 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11211 #endif /* CONFIG_IPW_QOS */
11213 #ifdef CONFIG_IPW2200_MONITOR
11214 module_param(mode, int, 0444);
11215 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11217 module_param(mode, int, 0444);
11218 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11221 module_param(bt_coexist, int, 0444);
11222 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
11224 module_param(hwcrypto, int, 0444);
11225 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
11227 module_param(cmdlog, int, 0444);
11228 MODULE_PARM_DESC(cmdlog,
11229 "allocate a ring buffer for logging firmware commands");
11231 module_param(roaming, int, 0444);
11232 MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
11234 module_exit(ipw_exit);
11235 module_init(ipw_init);