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_ERROR("Firmware error detected. Restarting.\n");
1801 IPW_ERROR("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_ERROR("Sysfs 'error' log captured.\n");
1816 IPW_ERROR("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: '%s' " MAC_FMT
4545 " \n", escape_essid(priv->essid,
4547 MAC_ARG(priv->bssid));
4548 memcpy(&priv->last_link_deterioration, x,
4551 IPW_ERROR("Link Deterioration of wrong size %d "
4552 "(should be %zd)\n",
4553 notif->size, sizeof(*x));
4558 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4559 IPW_ERROR("Dino config\n");
4561 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4562 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4567 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4568 struct notif_beacon_state *x = ¬if->u.beacon_state;
4569 if (notif->size != sizeof(*x)) {
4571 ("Beacon state of wrong size %d (should "
4572 "be %zd)\n", notif->size, sizeof(*x));
4576 if (le32_to_cpu(x->state) ==
4577 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4578 ipw_handle_missed_beacon(priv,
4585 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4586 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4587 if (notif->size == sizeof(*x)) {
4588 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4589 "0x%02x station %d\n",
4590 x->key_state, x->security_type,
4596 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4597 notif->size, sizeof(*x));
4601 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4602 struct notif_calibration *x = ¬if->u.calibration;
4604 if (notif->size == sizeof(*x)) {
4605 memcpy(&priv->calib, x, sizeof(*x));
4606 IPW_DEBUG_INFO("TODO: Calibration\n");
4611 ("Calibration of wrong size %d (should be %zd)\n",
4612 notif->size, sizeof(*x));
4616 case HOST_NOTIFICATION_NOISE_STATS:{
4617 if (notif->size == sizeof(u32)) {
4619 (u8) (le32_to_cpu(notif->u.noise.value) &
4621 average_add(&priv->average_noise,
4627 ("Noise stat is wrong size %d (should be %zd)\n",
4628 notif->size, sizeof(u32));
4633 IPW_DEBUG_NOTIF("Unknown notification: "
4634 "subtype=%d,flags=0x%2x,size=%d\n",
4635 notif->subtype, notif->flags, notif->size);
4640 * Destroys all DMA structures and initialise them again
4643 * @return error code
4645 static int ipw_queue_reset(struct ipw_priv *priv)
4648 /** @todo customize queue sizes */
4649 int nTx = 64, nTxCmd = 8;
4650 ipw_tx_queue_free(priv);
4652 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4653 IPW_TX_CMD_QUEUE_READ_INDEX,
4654 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4655 IPW_TX_CMD_QUEUE_BD_BASE,
4656 IPW_TX_CMD_QUEUE_BD_SIZE);
4658 IPW_ERROR("Tx Cmd queue init failed\n");
4662 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4663 IPW_TX_QUEUE_0_READ_INDEX,
4664 IPW_TX_QUEUE_0_WRITE_INDEX,
4665 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4667 IPW_ERROR("Tx 0 queue init failed\n");
4670 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4671 IPW_TX_QUEUE_1_READ_INDEX,
4672 IPW_TX_QUEUE_1_WRITE_INDEX,
4673 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4675 IPW_ERROR("Tx 1 queue init failed\n");
4678 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4679 IPW_TX_QUEUE_2_READ_INDEX,
4680 IPW_TX_QUEUE_2_WRITE_INDEX,
4681 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4683 IPW_ERROR("Tx 2 queue init failed\n");
4686 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4687 IPW_TX_QUEUE_3_READ_INDEX,
4688 IPW_TX_QUEUE_3_WRITE_INDEX,
4689 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4691 IPW_ERROR("Tx 3 queue init failed\n");
4695 priv->rx_bufs_min = 0;
4696 priv->rx_pend_max = 0;
4700 ipw_tx_queue_free(priv);
4705 * Reclaim Tx queue entries no more used by NIC.
4707 * When FW adwances 'R' index, all entries between old and
4708 * new 'R' index need to be reclaimed. As result, some free space
4709 * forms. If there is enough free space (> low mark), wake Tx queue.
4711 * @note Need to protect against garbage in 'R' index
4715 * @return Number of used entries remains in the queue
4717 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4718 struct clx2_tx_queue *txq, int qindex)
4722 struct clx2_queue *q = &txq->q;
4724 hw_tail = ipw_read32(priv, q->reg_r);
4725 if (hw_tail >= q->n_bd) {
4727 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4731 for (; q->last_used != hw_tail;
4732 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4733 ipw_queue_tx_free_tfd(priv, txq);
4737 if ((ipw_queue_space(q) > q->low_mark) &&
4739 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4740 netif_wake_queue(priv->net_dev);
4741 used = q->first_empty - q->last_used;
4748 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4751 struct clx2_tx_queue *txq = &priv->txq_cmd;
4752 struct clx2_queue *q = &txq->q;
4753 struct tfd_frame *tfd;
4755 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4756 IPW_ERROR("No space for Tx\n");
4760 tfd = &txq->bd[q->first_empty];
4761 txq->txb[q->first_empty] = NULL;
4763 memset(tfd, 0, sizeof(*tfd));
4764 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4765 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4767 tfd->u.cmd.index = hcmd;
4768 tfd->u.cmd.length = len;
4769 memcpy(tfd->u.cmd.payload, buf, len);
4770 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4771 ipw_write32(priv, q->reg_w, q->first_empty);
4772 _ipw_read32(priv, 0x90);
4778 * Rx theory of operation
4780 * The host allocates 32 DMA target addresses and passes the host address
4781 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4785 * The host/firmware share two index registers for managing the Rx buffers.
4787 * The READ index maps to the first position that the firmware may be writing
4788 * to -- the driver can read up to (but not including) this position and get
4790 * The READ index is managed by the firmware once the card is enabled.
4792 * The WRITE index maps to the last position the driver has read from -- the
4793 * position preceding WRITE is the last slot the firmware can place a packet.
4795 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4798 * During initialization the host sets up the READ queue position to the first
4799 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4801 * When the firmware places a packet in a buffer it will advance the READ index
4802 * and fire the RX interrupt. The driver can then query the READ index and
4803 * process as many packets as possible, moving the WRITE index forward as it
4804 * resets the Rx queue buffers with new memory.
4806 * The management in the driver is as follows:
4807 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
4808 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4809 * to replensish the ipw->rxq->rx_free.
4810 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4811 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4812 * 'processed' and 'read' driver indexes as well)
4813 * + A received packet is processed and handed to the kernel network stack,
4814 * detached from the ipw->rxq. The driver 'processed' index is updated.
4815 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4816 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4817 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
4818 * were enough free buffers and RX_STALLED is set it is cleared.
4823 * ipw_rx_queue_alloc() Allocates rx_free
4824 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4825 * ipw_rx_queue_restock
4826 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4827 * queue, updates firmware pointers, and updates
4828 * the WRITE index. If insufficient rx_free buffers
4829 * are available, schedules ipw_rx_queue_replenish
4831 * -- enable interrupts --
4832 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
4833 * READ INDEX, detaching the SKB from the pool.
4834 * Moves the packet buffer from queue to rx_used.
4835 * Calls ipw_rx_queue_restock to refill any empty
4842 * If there are slots in the RX queue that need to be restocked,
4843 * and we have free pre-allocated buffers, fill the ranks as much
4844 * as we can pulling from rx_free.
4846 * This moves the 'write' index forward to catch up with 'processed', and
4847 * also updates the memory address in the firmware to reference the new
4850 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4852 struct ipw_rx_queue *rxq = priv->rxq;
4853 struct list_head *element;
4854 struct ipw_rx_mem_buffer *rxb;
4855 unsigned long flags;
4858 spin_lock_irqsave(&rxq->lock, flags);
4860 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4861 element = rxq->rx_free.next;
4862 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4865 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4867 rxq->queue[rxq->write] = rxb;
4868 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4871 spin_unlock_irqrestore(&rxq->lock, flags);
4873 /* If the pre-allocated buffer pool is dropping low, schedule to
4875 if (rxq->free_count <= RX_LOW_WATERMARK)
4876 queue_work(priv->workqueue, &priv->rx_replenish);
4878 /* If we've added more space for the firmware to place data, tell it */
4879 if (write != rxq->write)
4880 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4884 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4885 * Also restock the Rx queue via ipw_rx_queue_restock.
4887 * This is called as a scheduled work item (except for during intialization)
4889 static void ipw_rx_queue_replenish(void *data)
4891 struct ipw_priv *priv = data;
4892 struct ipw_rx_queue *rxq = priv->rxq;
4893 struct list_head *element;
4894 struct ipw_rx_mem_buffer *rxb;
4895 unsigned long flags;
4897 spin_lock_irqsave(&rxq->lock, flags);
4898 while (!list_empty(&rxq->rx_used)) {
4899 element = rxq->rx_used.next;
4900 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4901 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4903 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4904 priv->net_dev->name);
4905 /* We don't reschedule replenish work here -- we will
4906 * call the restock method and if it still needs
4907 * more buffers it will schedule replenish */
4912 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4914 pci_map_single(priv->pci_dev, rxb->skb->data,
4915 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4917 list_add_tail(&rxb->list, &rxq->rx_free);
4920 spin_unlock_irqrestore(&rxq->lock, flags);
4922 ipw_rx_queue_restock(priv);
4925 static void ipw_bg_rx_queue_replenish(void *data)
4927 struct ipw_priv *priv = data;
4928 mutex_lock(&priv->mutex);
4929 ipw_rx_queue_replenish(data);
4930 mutex_unlock(&priv->mutex);
4933 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4934 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
4935 * This free routine walks the list of POOL entries and if SKB is set to
4936 * non NULL it is unmapped and freed
4938 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4945 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4946 if (rxq->pool[i].skb != NULL) {
4947 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4948 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4949 dev_kfree_skb(rxq->pool[i].skb);
4956 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4958 struct ipw_rx_queue *rxq;
4961 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
4962 if (unlikely(!rxq)) {
4963 IPW_ERROR("memory allocation failed\n");
4966 spin_lock_init(&rxq->lock);
4967 INIT_LIST_HEAD(&rxq->rx_free);
4968 INIT_LIST_HEAD(&rxq->rx_used);
4970 /* Fill the rx_used queue with _all_ of the Rx buffers */
4971 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
4972 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4974 /* Set us so that we have processed and used all buffers, but have
4975 * not restocked the Rx queue with fresh buffers */
4976 rxq->read = rxq->write = 0;
4977 rxq->processed = RX_QUEUE_SIZE - 1;
4978 rxq->free_count = 0;
4983 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4985 rate &= ~IEEE80211_BASIC_RATE_MASK;
4986 if (ieee_mode == IEEE_A) {
4988 case IEEE80211_OFDM_RATE_6MB:
4989 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4991 case IEEE80211_OFDM_RATE_9MB:
4992 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4994 case IEEE80211_OFDM_RATE_12MB:
4996 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4997 case IEEE80211_OFDM_RATE_18MB:
4999 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5000 case IEEE80211_OFDM_RATE_24MB:
5002 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5003 case IEEE80211_OFDM_RATE_36MB:
5005 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5006 case IEEE80211_OFDM_RATE_48MB:
5008 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5009 case IEEE80211_OFDM_RATE_54MB:
5011 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5019 case IEEE80211_CCK_RATE_1MB:
5020 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5021 case IEEE80211_CCK_RATE_2MB:
5022 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5023 case IEEE80211_CCK_RATE_5MB:
5024 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5025 case IEEE80211_CCK_RATE_11MB:
5026 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5029 /* If we are limited to B modulations, bail at this point */
5030 if (ieee_mode == IEEE_B)
5035 case IEEE80211_OFDM_RATE_6MB:
5036 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5037 case IEEE80211_OFDM_RATE_9MB:
5038 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5039 case IEEE80211_OFDM_RATE_12MB:
5040 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5041 case IEEE80211_OFDM_RATE_18MB:
5042 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5043 case IEEE80211_OFDM_RATE_24MB:
5044 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5045 case IEEE80211_OFDM_RATE_36MB:
5046 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5047 case IEEE80211_OFDM_RATE_48MB:
5048 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5049 case IEEE80211_OFDM_RATE_54MB:
5050 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5056 static int ipw_compatible_rates(struct ipw_priv *priv,
5057 const struct ieee80211_network *network,
5058 struct ipw_supported_rates *rates)
5062 memset(rates, 0, sizeof(*rates));
5063 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5064 rates->num_rates = 0;
5065 for (i = 0; i < num_rates; i++) {
5066 if (!ipw_is_rate_in_mask(priv, network->mode,
5067 network->rates[i])) {
5069 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5070 IPW_DEBUG_SCAN("Adding masked mandatory "
5073 rates->supported_rates[rates->num_rates++] =
5078 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5079 network->rates[i], priv->rates_mask);
5083 rates->supported_rates[rates->num_rates++] = network->rates[i];
5086 num_rates = min(network->rates_ex_len,
5087 (u8) (IPW_MAX_RATES - num_rates));
5088 for (i = 0; i < num_rates; i++) {
5089 if (!ipw_is_rate_in_mask(priv, network->mode,
5090 network->rates_ex[i])) {
5091 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5092 IPW_DEBUG_SCAN("Adding masked mandatory "
5094 network->rates_ex[i]);
5095 rates->supported_rates[rates->num_rates++] =
5100 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5101 network->rates_ex[i], priv->rates_mask);
5105 rates->supported_rates[rates->num_rates++] =
5106 network->rates_ex[i];
5112 static void ipw_copy_rates(struct ipw_supported_rates *dest,
5113 const struct ipw_supported_rates *src)
5116 for (i = 0; i < src->num_rates; i++)
5117 dest->supported_rates[i] = src->supported_rates[i];
5118 dest->num_rates = src->num_rates;
5121 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5122 * mask should ever be used -- right now all callers to add the scan rates are
5123 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5124 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5125 u8 modulation, u32 rate_mask)
5127 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5128 IEEE80211_BASIC_RATE_MASK : 0;
5130 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5131 rates->supported_rates[rates->num_rates++] =
5132 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5134 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5135 rates->supported_rates[rates->num_rates++] =
5136 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5138 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5139 rates->supported_rates[rates->num_rates++] = basic_mask |
5140 IEEE80211_CCK_RATE_5MB;
5142 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5143 rates->supported_rates[rates->num_rates++] = basic_mask |
5144 IEEE80211_CCK_RATE_11MB;
5147 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5148 u8 modulation, u32 rate_mask)
5150 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5151 IEEE80211_BASIC_RATE_MASK : 0;
5153 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5154 rates->supported_rates[rates->num_rates++] = basic_mask |
5155 IEEE80211_OFDM_RATE_6MB;
5157 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5158 rates->supported_rates[rates->num_rates++] =
5159 IEEE80211_OFDM_RATE_9MB;
5161 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5162 rates->supported_rates[rates->num_rates++] = basic_mask |
5163 IEEE80211_OFDM_RATE_12MB;
5165 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5166 rates->supported_rates[rates->num_rates++] =
5167 IEEE80211_OFDM_RATE_18MB;
5169 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5170 rates->supported_rates[rates->num_rates++] = basic_mask |
5171 IEEE80211_OFDM_RATE_24MB;
5173 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5174 rates->supported_rates[rates->num_rates++] =
5175 IEEE80211_OFDM_RATE_36MB;
5177 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5178 rates->supported_rates[rates->num_rates++] =
5179 IEEE80211_OFDM_RATE_48MB;
5181 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5182 rates->supported_rates[rates->num_rates++] =
5183 IEEE80211_OFDM_RATE_54MB;
5186 struct ipw_network_match {
5187 struct ieee80211_network *network;
5188 struct ipw_supported_rates rates;
5191 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5192 struct ipw_network_match *match,
5193 struct ieee80211_network *network,
5196 struct ipw_supported_rates rates;
5198 /* Verify that this network's capability is compatible with the
5199 * current mode (AdHoc or Infrastructure) */
5200 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5201 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5202 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5203 "capability mismatch.\n",
5204 escape_essid(network->ssid, network->ssid_len),
5205 MAC_ARG(network->bssid));
5209 /* If we do not have an ESSID for this AP, we can not associate with
5211 if (network->flags & NETWORK_EMPTY_ESSID) {
5212 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5213 "because of hidden ESSID.\n",
5214 escape_essid(network->ssid, network->ssid_len),
5215 MAC_ARG(network->bssid));
5219 if (unlikely(roaming)) {
5220 /* If we are roaming, then ensure check if this is a valid
5221 * network to try and roam to */
5222 if ((network->ssid_len != match->network->ssid_len) ||
5223 memcmp(network->ssid, match->network->ssid,
5224 network->ssid_len)) {
5225 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5226 "because of non-network ESSID.\n",
5227 escape_essid(network->ssid,
5229 MAC_ARG(network->bssid));
5233 /* If an ESSID has been configured then compare the broadcast
5235 if ((priv->config & CFG_STATIC_ESSID) &&
5236 ((network->ssid_len != priv->essid_len) ||
5237 memcmp(network->ssid, priv->essid,
5238 min(network->ssid_len, priv->essid_len)))) {
5239 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5242 escape_essid(network->ssid, network->ssid_len),
5244 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5245 "because of ESSID mismatch: '%s'.\n",
5246 escaped, MAC_ARG(network->bssid),
5247 escape_essid(priv->essid,
5253 /* If the old network rate is better than this one, don't bother
5254 * testing everything else. */
5256 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5257 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5258 "current network.\n",
5259 escape_essid(match->network->ssid,
5260 match->network->ssid_len));
5262 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5263 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5264 "current network.\n",
5265 escape_essid(match->network->ssid,
5266 match->network->ssid_len));
5270 /* Now go through and see if the requested network is valid... */
5271 if (priv->ieee->scan_age != 0 &&
5272 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5273 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5274 "because of age: %ums.\n",
5275 escape_essid(network->ssid, network->ssid_len),
5276 MAC_ARG(network->bssid),
5277 jiffies_to_msecs(jiffies -
5278 network->last_scanned));
5282 if ((priv->config & CFG_STATIC_CHANNEL) &&
5283 (network->channel != priv->channel)) {
5284 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5285 "because of channel mismatch: %d != %d.\n",
5286 escape_essid(network->ssid, network->ssid_len),
5287 MAC_ARG(network->bssid),
5288 network->channel, priv->channel);
5292 /* Verify privacy compatability */
5293 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5294 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5295 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5296 "because of privacy mismatch: %s != %s.\n",
5297 escape_essid(network->ssid, network->ssid_len),
5298 MAC_ARG(network->bssid),
5300 capability & CAP_PRIVACY_ON ? "on" : "off",
5302 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5307 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5308 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5309 "because of the same BSSID match: " MAC_FMT
5310 ".\n", escape_essid(network->ssid,
5312 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5316 /* Filter out any incompatible freq / mode combinations */
5317 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5318 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5319 "because of invalid frequency/mode "
5321 escape_essid(network->ssid, network->ssid_len),
5322 MAC_ARG(network->bssid));
5326 /* Ensure that the rates supported by the driver are compatible with
5327 * this AP, including verification of basic rates (mandatory) */
5328 if (!ipw_compatible_rates(priv, network, &rates)) {
5329 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5330 "because configured rate mask excludes "
5331 "AP mandatory rate.\n",
5332 escape_essid(network->ssid, network->ssid_len),
5333 MAC_ARG(network->bssid));
5337 if (rates.num_rates == 0) {
5338 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5339 "because of no compatible rates.\n",
5340 escape_essid(network->ssid, network->ssid_len),
5341 MAC_ARG(network->bssid));
5345 /* TODO: Perform any further minimal comparititive tests. We do not
5346 * want to put too much policy logic here; intelligent scan selection
5347 * should occur within a generic IEEE 802.11 user space tool. */
5349 /* Set up 'new' AP to this network */
5350 ipw_copy_rates(&match->rates, &rates);
5351 match->network = network;
5352 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5353 escape_essid(network->ssid, network->ssid_len),
5354 MAC_ARG(network->bssid));
5359 static void ipw_merge_adhoc_network(void *data)
5361 struct ipw_priv *priv = data;
5362 struct ieee80211_network *network = NULL;
5363 struct ipw_network_match match = {
5364 .network = priv->assoc_network
5367 if ((priv->status & STATUS_ASSOCIATED) &&
5368 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5369 /* First pass through ROAM process -- look for a better
5371 unsigned long flags;
5373 spin_lock_irqsave(&priv->ieee->lock, flags);
5374 list_for_each_entry(network, &priv->ieee->network_list, list) {
5375 if (network != priv->assoc_network)
5376 ipw_find_adhoc_network(priv, &match, network,
5379 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5381 if (match.network == priv->assoc_network) {
5382 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5387 mutex_lock(&priv->mutex);
5388 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5389 IPW_DEBUG_MERGE("remove network %s\n",
5390 escape_essid(priv->essid,
5392 ipw_remove_current_network(priv);
5395 ipw_disassociate(priv);
5396 priv->assoc_network = match.network;
5397 mutex_unlock(&priv->mutex);
5402 static int ipw_best_network(struct ipw_priv *priv,
5403 struct ipw_network_match *match,
5404 struct ieee80211_network *network, int roaming)
5406 struct ipw_supported_rates rates;
5408 /* Verify that this network's capability is compatible with the
5409 * current mode (AdHoc or Infrastructure) */
5410 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5411 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5412 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5413 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5414 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5415 "capability mismatch.\n",
5416 escape_essid(network->ssid, network->ssid_len),
5417 MAC_ARG(network->bssid));
5421 /* If we do not have an ESSID for this AP, we can not associate with
5423 if (network->flags & NETWORK_EMPTY_ESSID) {
5424 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5425 "because of hidden ESSID.\n",
5426 escape_essid(network->ssid, network->ssid_len),
5427 MAC_ARG(network->bssid));
5431 if (unlikely(roaming)) {
5432 /* If we are roaming, then ensure check if this is a valid
5433 * network to try and roam to */
5434 if ((network->ssid_len != match->network->ssid_len) ||
5435 memcmp(network->ssid, match->network->ssid,
5436 network->ssid_len)) {
5437 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5438 "because of non-network ESSID.\n",
5439 escape_essid(network->ssid,
5441 MAC_ARG(network->bssid));
5445 /* If an ESSID has been configured then compare the broadcast
5447 if ((priv->config & CFG_STATIC_ESSID) &&
5448 ((network->ssid_len != priv->essid_len) ||
5449 memcmp(network->ssid, priv->essid,
5450 min(network->ssid_len, priv->essid_len)))) {
5451 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5453 escape_essid(network->ssid, network->ssid_len),
5455 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5456 "because of ESSID mismatch: '%s'.\n",
5457 escaped, MAC_ARG(network->bssid),
5458 escape_essid(priv->essid,
5464 /* If the old network rate is better than this one, don't bother
5465 * testing everything else. */
5466 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5467 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5469 escape_essid(network->ssid, network->ssid_len),
5471 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5472 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5473 escaped, MAC_ARG(network->bssid),
5474 escape_essid(match->network->ssid,
5475 match->network->ssid_len),
5476 MAC_ARG(match->network->bssid));
5480 /* If this network has already had an association attempt within the
5481 * last 3 seconds, do not try and associate again... */
5482 if (network->last_associate &&
5483 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5484 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5485 "because of storming (%ums since last "
5486 "assoc attempt).\n",
5487 escape_essid(network->ssid, network->ssid_len),
5488 MAC_ARG(network->bssid),
5489 jiffies_to_msecs(jiffies -
5490 network->last_associate));
5494 /* Now go through and see if the requested network is valid... */
5495 if (priv->ieee->scan_age != 0 &&
5496 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5497 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5498 "because of age: %ums.\n",
5499 escape_essid(network->ssid, network->ssid_len),
5500 MAC_ARG(network->bssid),
5501 jiffies_to_msecs(jiffies -
5502 network->last_scanned));
5506 if ((priv->config & CFG_STATIC_CHANNEL) &&
5507 (network->channel != priv->channel)) {
5508 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5509 "because of channel mismatch: %d != %d.\n",
5510 escape_essid(network->ssid, network->ssid_len),
5511 MAC_ARG(network->bssid),
5512 network->channel, priv->channel);
5516 /* Verify privacy compatability */
5517 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5518 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5519 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5520 "because of privacy mismatch: %s != %s.\n",
5521 escape_essid(network->ssid, network->ssid_len),
5522 MAC_ARG(network->bssid),
5523 priv->capability & CAP_PRIVACY_ON ? "on" :
5525 network->capability &
5526 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5530 if ((priv->config & CFG_STATIC_BSSID) &&
5531 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5532 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5533 "because of BSSID mismatch: " MAC_FMT ".\n",
5534 escape_essid(network->ssid, network->ssid_len),
5535 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5539 /* Filter out any incompatible freq / mode combinations */
5540 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5541 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5542 "because of invalid frequency/mode "
5544 escape_essid(network->ssid, network->ssid_len),
5545 MAC_ARG(network->bssid));
5549 /* Filter out invalid channel in current GEO */
5550 if (!ieee80211_is_valid_channel(priv->ieee, network->channel)) {
5551 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5552 "because of invalid channel in current GEO\n",
5553 escape_essid(network->ssid, network->ssid_len),
5554 MAC_ARG(network->bssid));
5558 /* Ensure that the rates supported by the driver are compatible with
5559 * this AP, including verification of basic rates (mandatory) */
5560 if (!ipw_compatible_rates(priv, network, &rates)) {
5561 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5562 "because configured rate mask excludes "
5563 "AP mandatory rate.\n",
5564 escape_essid(network->ssid, network->ssid_len),
5565 MAC_ARG(network->bssid));
5569 if (rates.num_rates == 0) {
5570 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5571 "because of no compatible rates.\n",
5572 escape_essid(network->ssid, network->ssid_len),
5573 MAC_ARG(network->bssid));
5577 /* TODO: Perform any further minimal comparititive tests. We do not
5578 * want to put too much policy logic here; intelligent scan selection
5579 * should occur within a generic IEEE 802.11 user space tool. */
5581 /* Set up 'new' AP to this network */
5582 ipw_copy_rates(&match->rates, &rates);
5583 match->network = network;
5585 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5586 escape_essid(network->ssid, network->ssid_len),
5587 MAC_ARG(network->bssid));
5592 static void ipw_adhoc_create(struct ipw_priv *priv,
5593 struct ieee80211_network *network)
5595 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
5599 * For the purposes of scanning, we can set our wireless mode
5600 * to trigger scans across combinations of bands, but when it
5601 * comes to creating a new ad-hoc network, we have tell the FW
5602 * exactly which band to use.
5604 * We also have the possibility of an invalid channel for the
5605 * chossen band. Attempting to create a new ad-hoc network
5606 * with an invalid channel for wireless mode will trigger a
5610 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
5611 case IEEE80211_52GHZ_BAND:
5612 network->mode = IEEE_A;
5613 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
5616 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5617 IPW_WARNING("Overriding invalid channel\n");
5618 priv->channel = geo->a[0].channel;
5622 case IEEE80211_24GHZ_BAND:
5623 if (priv->ieee->mode & IEEE_G)
5624 network->mode = IEEE_G;
5626 network->mode = IEEE_B;
5627 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
5630 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5631 IPW_WARNING("Overriding invalid channel\n");
5632 priv->channel = geo->bg[0].channel;
5637 IPW_WARNING("Overriding invalid channel\n");
5638 if (priv->ieee->mode & IEEE_A) {
5639 network->mode = IEEE_A;
5640 priv->channel = geo->a[0].channel;
5641 } else if (priv->ieee->mode & IEEE_G) {
5642 network->mode = IEEE_G;
5643 priv->channel = geo->bg[0].channel;
5645 network->mode = IEEE_B;
5646 priv->channel = geo->bg[0].channel;
5651 network->channel = priv->channel;
5652 priv->config |= CFG_ADHOC_PERSIST;
5653 ipw_create_bssid(priv, network->bssid);
5654 network->ssid_len = priv->essid_len;
5655 memcpy(network->ssid, priv->essid, priv->essid_len);
5656 memset(&network->stats, 0, sizeof(network->stats));
5657 network->capability = WLAN_CAPABILITY_IBSS;
5658 if (!(priv->config & CFG_PREAMBLE_LONG))
5659 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5660 if (priv->capability & CAP_PRIVACY_ON)
5661 network->capability |= WLAN_CAPABILITY_PRIVACY;
5662 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5663 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5664 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5665 memcpy(network->rates_ex,
5666 &priv->rates.supported_rates[network->rates_len],
5667 network->rates_ex_len);
5668 network->last_scanned = 0;
5670 network->last_associate = 0;
5671 network->time_stamp[0] = 0;
5672 network->time_stamp[1] = 0;
5673 network->beacon_interval = 100; /* Default */
5674 network->listen_interval = 10; /* Default */
5675 network->atim_window = 0; /* Default */
5676 network->wpa_ie_len = 0;
5677 network->rsn_ie_len = 0;
5680 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5682 struct ipw_tgi_tx_key key;
5684 if (!(priv->ieee->sec.flags & (1 << index)))
5688 memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5689 key.security_type = type;
5690 key.station_index = 0; /* always 0 for BSS */
5692 /* 0 for new key; previous value of counter (after fatal error) */
5693 key.tx_counter[0] = 0;
5694 key.tx_counter[1] = 0;
5696 ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
5699 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5701 struct ipw_wep_key key;
5704 key.cmd_id = DINO_CMD_WEP_KEY;
5707 /* Note: AES keys cannot be set for multiple times.
5708 * Only set it at the first time. */
5709 for (i = 0; i < 4; i++) {
5710 key.key_index = i | type;
5711 if (!(priv->ieee->sec.flags & (1 << i))) {
5716 key.key_size = priv->ieee->sec.key_sizes[i];
5717 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
5719 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
5723 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5725 if (priv->ieee->host_encrypt)
5730 priv->sys_config.disable_unicast_decryption = 0;
5731 priv->ieee->host_decrypt = 0;
5734 priv->sys_config.disable_unicast_decryption = 1;
5735 priv->ieee->host_decrypt = 1;
5738 priv->sys_config.disable_unicast_decryption = 0;
5739 priv->ieee->host_decrypt = 0;
5742 priv->sys_config.disable_unicast_decryption = 1;
5749 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5751 if (priv->ieee->host_encrypt)
5756 priv->sys_config.disable_multicast_decryption = 0;
5759 priv->sys_config.disable_multicast_decryption = 1;
5762 priv->sys_config.disable_multicast_decryption = 0;
5765 priv->sys_config.disable_multicast_decryption = 1;
5772 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5774 switch (priv->ieee->sec.level) {
5776 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5777 ipw_send_tgi_tx_key(priv,
5778 DCT_FLAG_EXT_SECURITY_CCM,
5779 priv->ieee->sec.active_key);
5781 if (!priv->ieee->host_mc_decrypt)
5782 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5785 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5786 ipw_send_tgi_tx_key(priv,
5787 DCT_FLAG_EXT_SECURITY_TKIP,
5788 priv->ieee->sec.active_key);
5791 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5792 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5793 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5801 static void ipw_adhoc_check(void *data)
5803 struct ipw_priv *priv = data;
5805 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5806 !(priv->config & CFG_ADHOC_PERSIST)) {
5807 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5808 IPW_DL_STATE | IPW_DL_ASSOC,
5809 "Missed beacon: %d - disassociate\n",
5810 priv->missed_adhoc_beacons);
5811 ipw_remove_current_network(priv);
5812 ipw_disassociate(priv);
5816 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5817 priv->assoc_request.beacon_interval);
5820 static void ipw_bg_adhoc_check(void *data)
5822 struct ipw_priv *priv = data;
5823 mutex_lock(&priv->mutex);
5824 ipw_adhoc_check(data);
5825 mutex_unlock(&priv->mutex);
5828 #ifdef CONFIG_IPW2200_DEBUG
5829 static void ipw_debug_config(struct ipw_priv *priv)
5831 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5832 "[CFG 0x%08X]\n", priv->config);
5833 if (priv->config & CFG_STATIC_CHANNEL)
5834 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5836 IPW_DEBUG_INFO("Channel unlocked.\n");
5837 if (priv->config & CFG_STATIC_ESSID)
5838 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5839 escape_essid(priv->essid, priv->essid_len));
5841 IPW_DEBUG_INFO("ESSID unlocked.\n");
5842 if (priv->config & CFG_STATIC_BSSID)
5843 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5844 MAC_ARG(priv->bssid));
5846 IPW_DEBUG_INFO("BSSID unlocked.\n");
5847 if (priv->capability & CAP_PRIVACY_ON)
5848 IPW_DEBUG_INFO("PRIVACY on\n");
5850 IPW_DEBUG_INFO("PRIVACY off\n");
5851 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5854 #define ipw_debug_config(x) do {} while (0)
5857 static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5859 /* TODO: Verify that this works... */
5860 struct ipw_fixed_rate fr = {
5861 .tx_rates = priv->rates_mask
5866 /* Identify 'current FW band' and match it with the fixed
5869 switch (priv->ieee->freq_band) {
5870 case IEEE80211_52GHZ_BAND: /* A only */
5872 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5873 /* Invalid fixed rate mask */
5875 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5880 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5883 default: /* 2.4Ghz or Mixed */
5885 if (mode == IEEE_B) {
5886 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5887 /* Invalid fixed rate mask */
5889 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5896 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5897 IEEE80211_OFDM_RATES_MASK)) {
5898 /* Invalid fixed rate mask */
5900 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5905 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5906 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5907 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5910 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5911 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5912 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5915 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5916 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5917 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5920 fr.tx_rates |= mask;
5924 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5925 ipw_write_reg32(priv, reg, *(u32 *) & fr);
5928 static void ipw_abort_scan(struct ipw_priv *priv)
5932 if (priv->status & STATUS_SCAN_ABORTING) {
5933 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5936 priv->status |= STATUS_SCAN_ABORTING;
5938 err = ipw_send_scan_abort(priv);
5940 IPW_DEBUG_HC("Request to abort scan failed.\n");
5943 static void ipw_add_scan_channels(struct ipw_priv *priv,
5944 struct ipw_scan_request_ext *scan,
5947 int channel_index = 0;
5948 const struct ieee80211_geo *geo;
5951 geo = ieee80211_get_geo(priv->ieee);
5953 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5954 int start = channel_index;
5955 for (i = 0; i < geo->a_channels; i++) {
5956 if ((priv->status & STATUS_ASSOCIATED) &&
5957 geo->a[i].channel == priv->channel)
5960 scan->channels_list[channel_index] = geo->a[i].channel;
5961 ipw_set_scan_type(scan, channel_index,
5963 flags & IEEE80211_CH_PASSIVE_ONLY ?
5964 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5968 if (start != channel_index) {
5969 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5970 (channel_index - start);
5975 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5976 int start = channel_index;
5977 if (priv->config & CFG_SPEED_SCAN) {
5979 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5980 /* nop out the list */
5985 while (channel_index < IPW_SCAN_CHANNELS) {
5987 priv->speed_scan[priv->speed_scan_pos];
5989 priv->speed_scan_pos = 0;
5990 channel = priv->speed_scan[0];
5992 if ((priv->status & STATUS_ASSOCIATED) &&
5993 channel == priv->channel) {
5994 priv->speed_scan_pos++;
5998 /* If this channel has already been
5999 * added in scan, break from loop
6000 * and this will be the first channel
6003 if (channels[channel - 1] != 0)
6006 channels[channel - 1] = 1;
6007 priv->speed_scan_pos++;
6009 scan->channels_list[channel_index] = channel;
6011 ieee80211_channel_to_index(priv->ieee, channel);
6012 ipw_set_scan_type(scan, channel_index,
6015 IEEE80211_CH_PASSIVE_ONLY ?
6016 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6020 for (i = 0; i < geo->bg_channels; i++) {
6021 if ((priv->status & STATUS_ASSOCIATED) &&
6022 geo->bg[i].channel == priv->channel)
6025 scan->channels_list[channel_index] =
6027 ipw_set_scan_type(scan, channel_index,
6030 IEEE80211_CH_PASSIVE_ONLY ?
6031 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6036 if (start != channel_index) {
6037 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6038 (channel_index - start);
6043 static int ipw_request_scan(struct ipw_priv *priv)
6045 struct ipw_scan_request_ext scan;
6046 int err = 0, scan_type;
6048 if (!(priv->status & STATUS_INIT) ||
6049 (priv->status & STATUS_EXIT_PENDING))
6052 mutex_lock(&priv->mutex);
6054 if (priv->status & STATUS_SCANNING) {
6055 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
6056 priv->status |= STATUS_SCAN_PENDING;
6060 if (!(priv->status & STATUS_SCAN_FORCED) &&
6061 priv->status & STATUS_SCAN_ABORTING) {
6062 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6063 priv->status |= STATUS_SCAN_PENDING;
6067 if (priv->status & STATUS_RF_KILL_MASK) {
6068 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6069 priv->status |= STATUS_SCAN_PENDING;
6073 memset(&scan, 0, sizeof(scan));
6075 if (priv->config & CFG_SPEED_SCAN)
6076 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6079 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6082 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6084 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6086 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6088 #ifdef CONFIG_IPW2200_MONITOR
6089 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6093 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
6094 case IEEE80211_52GHZ_BAND:
6095 band = (u8) (IPW_A_MODE << 6) | 1;
6096 channel = priv->channel;
6099 case IEEE80211_24GHZ_BAND:
6100 band = (u8) (IPW_B_MODE << 6) | 1;
6101 channel = priv->channel;
6105 band = (u8) (IPW_B_MODE << 6) | 1;
6110 scan.channels_list[0] = band;
6111 scan.channels_list[1] = channel;
6112 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6114 /* NOTE: The card will sit on this channel for this time
6115 * period. Scan aborts are timing sensitive and frequently
6116 * result in firmware restarts. As such, it is best to
6117 * set a small dwell_time here and just keep re-issuing
6118 * scans. Otherwise fast channel hopping will not actually
6121 * TODO: Move SPEED SCAN support to all modes and bands */
6122 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6125 #endif /* CONFIG_IPW2200_MONITOR */
6126 /* If we are roaming, then make this a directed scan for the
6127 * current network. Otherwise, ensure that every other scan
6128 * is a fast channel hop scan */
6129 if ((priv->status & STATUS_ROAMING)
6130 || (!(priv->status & STATUS_ASSOCIATED)
6131 && (priv->config & CFG_STATIC_ESSID)
6132 && (le32_to_cpu(scan.full_scan_index) % 2))) {
6133 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6135 IPW_DEBUG_HC("Attempt to send SSID command "
6140 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6142 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6144 ipw_add_scan_channels(priv, &scan, scan_type);
6145 #ifdef CONFIG_IPW2200_MONITOR
6149 err = ipw_send_scan_request_ext(priv, &scan);
6151 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6155 priv->status |= STATUS_SCANNING;
6156 priv->status &= ~STATUS_SCAN_PENDING;
6157 queue_delayed_work(priv->workqueue, &priv->scan_check,
6158 IPW_SCAN_CHECK_WATCHDOG);
6160 mutex_unlock(&priv->mutex);
6164 static void ipw_bg_abort_scan(void *data)
6166 struct ipw_priv *priv = data;
6167 mutex_lock(&priv->mutex);
6168 ipw_abort_scan(data);
6169 mutex_unlock(&priv->mutex);
6172 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6174 /* This is called when wpa_supplicant loads and closes the driver
6176 priv->ieee->wpa_enabled = value;
6180 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6182 struct ieee80211_device *ieee = priv->ieee;
6183 struct ieee80211_security sec = {
6184 .flags = SEC_AUTH_MODE,
6188 if (value & IW_AUTH_ALG_SHARED_KEY) {
6189 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6191 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6192 sec.auth_mode = WLAN_AUTH_OPEN;
6194 } else if (value & IW_AUTH_ALG_LEAP) {
6195 sec.auth_mode = WLAN_AUTH_LEAP;
6200 if (ieee->set_security)
6201 ieee->set_security(ieee->dev, &sec);
6208 static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6211 /* make sure WPA is enabled */
6212 ipw_wpa_enable(priv, 1);
6214 ipw_disassociate(priv);
6217 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6218 char *capabilities, int length)
6220 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6222 return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
6231 static int ipw_wx_set_genie(struct net_device *dev,
6232 struct iw_request_info *info,
6233 union iwreq_data *wrqu, char *extra)
6235 struct ipw_priv *priv = ieee80211_priv(dev);
6236 struct ieee80211_device *ieee = priv->ieee;
6240 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6241 (wrqu->data.length && extra == NULL))
6244 //mutex_lock(&priv->mutex);
6246 //if (!ieee->wpa_enabled) {
6247 // err = -EOPNOTSUPP;
6251 if (wrqu->data.length) {
6252 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6258 memcpy(buf, extra, wrqu->data.length);
6259 kfree(ieee->wpa_ie);
6261 ieee->wpa_ie_len = wrqu->data.length;
6263 kfree(ieee->wpa_ie);
6264 ieee->wpa_ie = NULL;
6265 ieee->wpa_ie_len = 0;
6268 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6270 //mutex_unlock(&priv->mutex);
6275 static int ipw_wx_get_genie(struct net_device *dev,
6276 struct iw_request_info *info,
6277 union iwreq_data *wrqu, char *extra)
6279 struct ipw_priv *priv = ieee80211_priv(dev);
6280 struct ieee80211_device *ieee = priv->ieee;
6283 //mutex_lock(&priv->mutex);
6285 //if (!ieee->wpa_enabled) {
6286 // err = -EOPNOTSUPP;
6290 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6291 wrqu->data.length = 0;
6295 if (wrqu->data.length < ieee->wpa_ie_len) {
6300 wrqu->data.length = ieee->wpa_ie_len;
6301 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6304 //mutex_unlock(&priv->mutex);
6308 static int wext_cipher2level(int cipher)
6311 case IW_AUTH_CIPHER_NONE:
6313 case IW_AUTH_CIPHER_WEP40:
6314 case IW_AUTH_CIPHER_WEP104:
6316 case IW_AUTH_CIPHER_TKIP:
6318 case IW_AUTH_CIPHER_CCMP:
6326 static int ipw_wx_set_auth(struct net_device *dev,
6327 struct iw_request_info *info,
6328 union iwreq_data *wrqu, char *extra)
6330 struct ipw_priv *priv = ieee80211_priv(dev);
6331 struct ieee80211_device *ieee = priv->ieee;
6332 struct iw_param *param = &wrqu->param;
6333 struct ieee80211_crypt_data *crypt;
6334 unsigned long flags;
6337 switch (param->flags & IW_AUTH_INDEX) {
6338 case IW_AUTH_WPA_VERSION:
6340 case IW_AUTH_CIPHER_PAIRWISE:
6341 ipw_set_hw_decrypt_unicast(priv,
6342 wext_cipher2level(param->value));
6344 case IW_AUTH_CIPHER_GROUP:
6345 ipw_set_hw_decrypt_multicast(priv,
6346 wext_cipher2level(param->value));
6348 case IW_AUTH_KEY_MGMT:
6350 * ipw2200 does not use these parameters
6354 case IW_AUTH_TKIP_COUNTERMEASURES:
6355 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6356 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6359 flags = crypt->ops->get_flags(crypt->priv);
6362 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6364 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6366 crypt->ops->set_flags(flags, crypt->priv);
6370 case IW_AUTH_DROP_UNENCRYPTED:{
6373 * wpa_supplicant calls set_wpa_enabled when the driver
6374 * is loaded and unloaded, regardless of if WPA is being
6375 * used. No other calls are made which can be used to
6376 * determine if encryption will be used or not prior to
6377 * association being expected. If encryption is not being
6378 * used, drop_unencrypted is set to false, else true -- we
6379 * can use this to determine if the CAP_PRIVACY_ON bit should
6382 struct ieee80211_security sec = {
6383 .flags = SEC_ENABLED,
6384 .enabled = param->value,
6386 priv->ieee->drop_unencrypted = param->value;
6387 /* We only change SEC_LEVEL for open mode. Others
6388 * are set by ipw_wpa_set_encryption.
6390 if (!param->value) {
6391 sec.flags |= SEC_LEVEL;
6392 sec.level = SEC_LEVEL_0;
6394 sec.flags |= SEC_LEVEL;
6395 sec.level = SEC_LEVEL_1;
6397 if (priv->ieee->set_security)
6398 priv->ieee->set_security(priv->ieee->dev, &sec);
6402 case IW_AUTH_80211_AUTH_ALG:
6403 ret = ipw_wpa_set_auth_algs(priv, param->value);
6406 case IW_AUTH_WPA_ENABLED:
6407 ret = ipw_wpa_enable(priv, param->value);
6410 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6411 ieee->ieee802_1x = param->value;
6414 //case IW_AUTH_ROAMING_CONTROL:
6415 case IW_AUTH_PRIVACY_INVOKED:
6416 ieee->privacy_invoked = param->value;
6426 static int ipw_wx_get_auth(struct net_device *dev,
6427 struct iw_request_info *info,
6428 union iwreq_data *wrqu, char *extra)
6430 struct ipw_priv *priv = ieee80211_priv(dev);
6431 struct ieee80211_device *ieee = priv->ieee;
6432 struct ieee80211_crypt_data *crypt;
6433 struct iw_param *param = &wrqu->param;
6436 switch (param->flags & IW_AUTH_INDEX) {
6437 case IW_AUTH_WPA_VERSION:
6438 case IW_AUTH_CIPHER_PAIRWISE:
6439 case IW_AUTH_CIPHER_GROUP:
6440 case IW_AUTH_KEY_MGMT:
6442 * wpa_supplicant will control these internally
6447 case IW_AUTH_TKIP_COUNTERMEASURES:
6448 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6449 if (!crypt || !crypt->ops->get_flags)
6452 param->value = (crypt->ops->get_flags(crypt->priv) &
6453 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6457 case IW_AUTH_DROP_UNENCRYPTED:
6458 param->value = ieee->drop_unencrypted;
6461 case IW_AUTH_80211_AUTH_ALG:
6462 param->value = ieee->sec.auth_mode;
6465 case IW_AUTH_WPA_ENABLED:
6466 param->value = ieee->wpa_enabled;
6469 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6470 param->value = ieee->ieee802_1x;
6473 case IW_AUTH_ROAMING_CONTROL:
6474 case IW_AUTH_PRIVACY_INVOKED:
6475 param->value = ieee->privacy_invoked;
6484 /* SIOCSIWENCODEEXT */
6485 static int ipw_wx_set_encodeext(struct net_device *dev,
6486 struct iw_request_info *info,
6487 union iwreq_data *wrqu, char *extra)
6489 struct ipw_priv *priv = ieee80211_priv(dev);
6490 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6493 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6494 /* IPW HW can't build TKIP MIC,
6495 host decryption still needed */
6496 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6497 priv->ieee->host_mc_decrypt = 1;
6499 priv->ieee->host_encrypt = 0;
6500 priv->ieee->host_encrypt_msdu = 1;
6501 priv->ieee->host_decrypt = 1;
6504 priv->ieee->host_encrypt = 0;
6505 priv->ieee->host_encrypt_msdu = 0;
6506 priv->ieee->host_decrypt = 0;
6507 priv->ieee->host_mc_decrypt = 0;
6511 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6514 /* SIOCGIWENCODEEXT */
6515 static int ipw_wx_get_encodeext(struct net_device *dev,
6516 struct iw_request_info *info,
6517 union iwreq_data *wrqu, char *extra)
6519 struct ipw_priv *priv = ieee80211_priv(dev);
6520 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6524 static int ipw_wx_set_mlme(struct net_device *dev,
6525 struct iw_request_info *info,
6526 union iwreq_data *wrqu, char *extra)
6528 struct ipw_priv *priv = ieee80211_priv(dev);
6529 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6532 reason = cpu_to_le16(mlme->reason_code);
6534 switch (mlme->cmd) {
6535 case IW_MLME_DEAUTH:
6539 case IW_MLME_DISASSOC:
6540 ipw_disassociate(priv);
6549 #ifdef CONFIG_IPW_QOS
6553 * get the modulation type of the current network or
6554 * the card current mode
6556 static u8 ipw_qos_current_mode(struct ipw_priv * priv)
6560 if (priv->status & STATUS_ASSOCIATED) {
6561 unsigned long flags;
6563 spin_lock_irqsave(&priv->ieee->lock, flags);
6564 mode = priv->assoc_network->mode;
6565 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6567 mode = priv->ieee->mode;
6569 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6574 * Handle management frame beacon and probe response
6576 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6578 struct ieee80211_network *network)
6580 u32 size = sizeof(struct ieee80211_qos_parameters);
6582 if (network->capability & WLAN_CAPABILITY_IBSS)
6583 network->qos_data.active = network->qos_data.supported;
6585 if (network->flags & NETWORK_HAS_QOS_MASK) {
6586 if (active_network &&
6587 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6588 network->qos_data.active = network->qos_data.supported;
6590 if ((network->qos_data.active == 1) && (active_network == 1) &&
6591 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6592 (network->qos_data.old_param_count !=
6593 network->qos_data.param_count)) {
6594 network->qos_data.old_param_count =
6595 network->qos_data.param_count;
6596 schedule_work(&priv->qos_activate);
6597 IPW_DEBUG_QOS("QoS parameters change call "
6601 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6602 memcpy(&network->qos_data.parameters,
6603 &def_parameters_CCK, size);
6605 memcpy(&network->qos_data.parameters,
6606 &def_parameters_OFDM, size);
6608 if ((network->qos_data.active == 1) && (active_network == 1)) {
6609 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6610 schedule_work(&priv->qos_activate);
6613 network->qos_data.active = 0;
6614 network->qos_data.supported = 0;
6616 if ((priv->status & STATUS_ASSOCIATED) &&
6617 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6618 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6619 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6620 !(network->flags & NETWORK_EMPTY_ESSID))
6621 if ((network->ssid_len ==
6622 priv->assoc_network->ssid_len) &&
6623 !memcmp(network->ssid,
6624 priv->assoc_network->ssid,
6625 network->ssid_len)) {
6626 queue_work(priv->workqueue,
6627 &priv->merge_networks);
6635 * This function set up the firmware to support QoS. It sends
6636 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6638 static int ipw_qos_activate(struct ipw_priv *priv,
6639 struct ieee80211_qos_data *qos_network_data)
6642 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6643 struct ieee80211_qos_parameters *active_one = NULL;
6644 u32 size = sizeof(struct ieee80211_qos_parameters);
6649 type = ipw_qos_current_mode(priv);
6651 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6652 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6653 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6654 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6656 if (qos_network_data == NULL) {
6657 if (type == IEEE_B) {
6658 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6659 active_one = &def_parameters_CCK;
6661 active_one = &def_parameters_OFDM;
6663 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6664 burst_duration = ipw_qos_get_burst_duration(priv);
6665 for (i = 0; i < QOS_QUEUE_NUM; i++)
6666 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6667 (u16) burst_duration;
6668 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6669 if (type == IEEE_B) {
6670 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6672 if (priv->qos_data.qos_enable == 0)
6673 active_one = &def_parameters_CCK;
6675 active_one = priv->qos_data.def_qos_parm_CCK;
6677 if (priv->qos_data.qos_enable == 0)
6678 active_one = &def_parameters_OFDM;
6680 active_one = priv->qos_data.def_qos_parm_OFDM;
6682 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6684 unsigned long flags;
6687 spin_lock_irqsave(&priv->ieee->lock, flags);
6688 active_one = &(qos_network_data->parameters);
6689 qos_network_data->old_param_count =
6690 qos_network_data->param_count;
6691 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6692 active = qos_network_data->supported;
6693 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6696 burst_duration = ipw_qos_get_burst_duration(priv);
6697 for (i = 0; i < QOS_QUEUE_NUM; i++)
6698 qos_parameters[QOS_PARAM_SET_ACTIVE].
6699 tx_op_limit[i] = (u16) burst_duration;
6703 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6704 err = ipw_send_qos_params_command(priv,
6705 (struct ieee80211_qos_parameters *)
6706 &(qos_parameters[0]));
6708 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6714 * send IPW_CMD_WME_INFO to the firmware
6716 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6719 struct ieee80211_qos_information_element qos_info;
6724 qos_info.elementID = QOS_ELEMENT_ID;
6725 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6727 qos_info.version = QOS_VERSION_1;
6728 qos_info.ac_info = 0;
6730 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6731 qos_info.qui_type = QOS_OUI_TYPE;
6732 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6734 ret = ipw_send_qos_info_command(priv, &qos_info);
6736 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6742 * Set the QoS parameter with the association request structure
6744 static int ipw_qos_association(struct ipw_priv *priv,
6745 struct ieee80211_network *network)
6748 struct ieee80211_qos_data *qos_data = NULL;
6749 struct ieee80211_qos_data ibss_data = {
6754 switch (priv->ieee->iw_mode) {
6756 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6759 qos_data = &ibss_data;
6763 qos_data = &network->qos_data;
6771 err = ipw_qos_activate(priv, qos_data);
6773 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6777 if (priv->qos_data.qos_enable && qos_data->supported) {
6778 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6779 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6780 return ipw_qos_set_info_element(priv);
6787 * handling the beaconing responces. if we get different QoS setting
6788 * of the network from the the associated setting adjust the QoS
6791 static int ipw_qos_association_resp(struct ipw_priv *priv,
6792 struct ieee80211_network *network)
6795 unsigned long flags;
6796 u32 size = sizeof(struct ieee80211_qos_parameters);
6797 int set_qos_param = 0;
6799 if ((priv == NULL) || (network == NULL) ||
6800 (priv->assoc_network == NULL))
6803 if (!(priv->status & STATUS_ASSOCIATED))
6806 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
6809 spin_lock_irqsave(&priv->ieee->lock, flags);
6810 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
6811 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
6812 sizeof(struct ieee80211_qos_data));
6813 priv->assoc_network->qos_data.active = 1;
6814 if ((network->qos_data.old_param_count !=
6815 network->qos_data.param_count)) {
6817 network->qos_data.old_param_count =
6818 network->qos_data.param_count;
6822 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6823 memcpy(&priv->assoc_network->qos_data.parameters,
6824 &def_parameters_CCK, size);
6826 memcpy(&priv->assoc_network->qos_data.parameters,
6827 &def_parameters_OFDM, size);
6828 priv->assoc_network->qos_data.active = 0;
6829 priv->assoc_network->qos_data.supported = 0;
6833 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6835 if (set_qos_param == 1)
6836 schedule_work(&priv->qos_activate);
6841 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6848 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
6849 ret = priv->qos_data.burst_duration_CCK;
6851 ret = priv->qos_data.burst_duration_OFDM;
6857 * Initialize the setting of QoS global
6859 static void ipw_qos_init(struct ipw_priv *priv, int enable,
6860 int burst_enable, u32 burst_duration_CCK,
6861 u32 burst_duration_OFDM)
6863 priv->qos_data.qos_enable = enable;
6865 if (priv->qos_data.qos_enable) {
6866 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6867 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6868 IPW_DEBUG_QOS("QoS is enabled\n");
6870 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6871 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6872 IPW_DEBUG_QOS("QoS is not enabled\n");
6875 priv->qos_data.burst_enable = burst_enable;
6878 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6879 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6881 priv->qos_data.burst_duration_CCK = 0;
6882 priv->qos_data.burst_duration_OFDM = 0;
6887 * map the packet priority to the right TX Queue
6889 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6891 if (priority > 7 || !priv->qos_data.qos_enable)
6894 return from_priority_to_tx_queue[priority] - 1;
6898 * add QoS parameter to the TX command
6900 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6902 struct tfd_data *tfd, u8 unicast)
6905 int tx_queue_id = 0;
6906 struct ieee80211_qos_data *qos_data = NULL;
6907 int active, supported;
6908 unsigned long flags;
6910 if (!(priv->status & STATUS_ASSOCIATED))
6913 qos_data = &priv->assoc_network->qos_data;
6915 spin_lock_irqsave(&priv->ieee->lock, flags);
6917 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6919 qos_data->active = 0;
6921 qos_data->active = qos_data->supported;
6924 active = qos_data->active;
6925 supported = qos_data->supported;
6927 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6929 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
6931 priv->qos_data.qos_enable, active, supported, unicast);
6932 if (active && priv->qos_data.qos_enable) {
6933 ret = from_priority_to_tx_queue[priority];
6934 tx_queue_id = ret - 1;
6935 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6936 if (priority <= 7) {
6937 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6938 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6939 tfd->tfd.tfd_26.mchdr.frame_ctl |=
6940 IEEE80211_STYPE_QOS_DATA;
6942 if (priv->qos_data.qos_no_ack_mask &
6943 (1UL << tx_queue_id)) {
6944 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6945 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6955 * background support to run QoS activate functionality
6957 static void ipw_bg_qos_activate(void *data)
6959 struct ipw_priv *priv = data;
6964 mutex_lock(&priv->mutex);
6966 if (priv->status & STATUS_ASSOCIATED)
6967 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6969 mutex_unlock(&priv->mutex);
6972 static int ipw_handle_probe_response(struct net_device *dev,
6973 struct ieee80211_probe_response *resp,
6974 struct ieee80211_network *network)
6976 struct ipw_priv *priv = ieee80211_priv(dev);
6977 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6978 (network == priv->assoc_network));
6980 ipw_qos_handle_probe_response(priv, active_network, network);
6985 static int ipw_handle_beacon(struct net_device *dev,
6986 struct ieee80211_beacon *resp,
6987 struct ieee80211_network *network)
6989 struct ipw_priv *priv = ieee80211_priv(dev);
6990 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6991 (network == priv->assoc_network));
6993 ipw_qos_handle_probe_response(priv, active_network, network);
6998 static int ipw_handle_assoc_response(struct net_device *dev,
6999 struct ieee80211_assoc_response *resp,
7000 struct ieee80211_network *network)
7002 struct ipw_priv *priv = ieee80211_priv(dev);
7003 ipw_qos_association_resp(priv, network);
7007 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7010 return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7011 sizeof(*qos_param) * 3, qos_param);
7014 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7017 return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7021 #endif /* CONFIG_IPW_QOS */
7023 static int ipw_associate_network(struct ipw_priv *priv,
7024 struct ieee80211_network *network,
7025 struct ipw_supported_rates *rates, int roaming)
7029 if (priv->config & CFG_FIXED_RATE)
7030 ipw_set_fixed_rate(priv, network->mode);
7032 if (!(priv->config & CFG_STATIC_ESSID)) {
7033 priv->essid_len = min(network->ssid_len,
7034 (u8) IW_ESSID_MAX_SIZE);
7035 memcpy(priv->essid, network->ssid, priv->essid_len);
7038 network->last_associate = jiffies;
7040 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7041 priv->assoc_request.channel = network->channel;
7042 priv->assoc_request.auth_key = 0;
7044 if ((priv->capability & CAP_PRIVACY_ON) &&
7045 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
7046 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7047 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7049 if (priv->ieee->sec.level == SEC_LEVEL_1)
7050 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7052 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7053 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7054 priv->assoc_request.auth_type = AUTH_LEAP;
7056 priv->assoc_request.auth_type = AUTH_OPEN;
7058 if (priv->ieee->wpa_ie_len) {
7059 priv->assoc_request.policy_support = 0x02; /* RSN active */
7060 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7061 priv->ieee->wpa_ie_len);
7065 * It is valid for our ieee device to support multiple modes, but
7066 * when it comes to associating to a given network we have to choose
7069 if (network->mode & priv->ieee->mode & IEEE_A)
7070 priv->assoc_request.ieee_mode = IPW_A_MODE;
7071 else if (network->mode & priv->ieee->mode & IEEE_G)
7072 priv->assoc_request.ieee_mode = IPW_G_MODE;
7073 else if (network->mode & priv->ieee->mode & IEEE_B)
7074 priv->assoc_request.ieee_mode = IPW_B_MODE;
7076 priv->assoc_request.capability = network->capability;
7077 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7078 && !(priv->config & CFG_PREAMBLE_LONG)) {
7079 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7081 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7083 /* Clear the short preamble if we won't be supporting it */
7084 priv->assoc_request.capability &=
7085 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7088 /* Clear capability bits that aren't used in Ad Hoc */
7089 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7090 priv->assoc_request.capability &=
7091 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7093 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7094 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7095 roaming ? "Rea" : "A",
7096 escape_essid(priv->essid, priv->essid_len),
7098 ipw_modes[priv->assoc_request.ieee_mode],
7100 (priv->assoc_request.preamble_length ==
7101 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7102 network->capability &
7103 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7104 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7105 priv->capability & CAP_PRIVACY_ON ?
7106 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7108 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7109 priv->capability & CAP_PRIVACY_ON ?
7110 '1' + priv->ieee->sec.active_key : '.',
7111 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7113 priv->assoc_request.beacon_interval = network->beacon_interval;
7114 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7115 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7116 priv->assoc_request.assoc_type = HC_IBSS_START;
7117 priv->assoc_request.assoc_tsf_msw = 0;
7118 priv->assoc_request.assoc_tsf_lsw = 0;
7120 if (unlikely(roaming))
7121 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7123 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7124 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7125 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7128 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7130 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7131 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7132 priv->assoc_request.atim_window = network->atim_window;
7134 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7135 priv->assoc_request.atim_window = 0;
7138 priv->assoc_request.listen_interval = network->listen_interval;
7140 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7142 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7146 rates->ieee_mode = priv->assoc_request.ieee_mode;
7147 rates->purpose = IPW_RATE_CONNECT;
7148 ipw_send_supported_rates(priv, rates);
7150 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7151 priv->sys_config.dot11g_auto_detection = 1;
7153 priv->sys_config.dot11g_auto_detection = 0;
7155 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7156 priv->sys_config.answer_broadcast_ssid_probe = 1;
7158 priv->sys_config.answer_broadcast_ssid_probe = 0;
7160 err = ipw_send_system_config(priv, &priv->sys_config);
7162 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7166 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7167 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7169 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7174 * If preemption is enabled, it is possible for the association
7175 * to complete before we return from ipw_send_associate. Therefore
7176 * we have to be sure and update our priviate data first.
7178 priv->channel = network->channel;
7179 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7180 priv->status |= STATUS_ASSOCIATING;
7181 priv->status &= ~STATUS_SECURITY_UPDATED;
7183 priv->assoc_network = network;
7185 #ifdef CONFIG_IPW_QOS
7186 ipw_qos_association(priv, network);
7189 err = ipw_send_associate(priv, &priv->assoc_request);
7191 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7195 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7196 escape_essid(priv->essid, priv->essid_len),
7197 MAC_ARG(priv->bssid));
7202 static void ipw_roam(void *data)
7204 struct ipw_priv *priv = data;
7205 struct ieee80211_network *network = NULL;
7206 struct ipw_network_match match = {
7207 .network = priv->assoc_network
7210 /* The roaming process is as follows:
7212 * 1. Missed beacon threshold triggers the roaming process by
7213 * setting the status ROAM bit and requesting a scan.
7214 * 2. When the scan completes, it schedules the ROAM work
7215 * 3. The ROAM work looks at all of the known networks for one that
7216 * is a better network than the currently associated. If none
7217 * found, the ROAM process is over (ROAM bit cleared)
7218 * 4. If a better network is found, a disassociation request is
7220 * 5. When the disassociation completes, the roam work is again
7221 * scheduled. The second time through, the driver is no longer
7222 * associated, and the newly selected network is sent an
7223 * association request.
7224 * 6. At this point ,the roaming process is complete and the ROAM
7225 * status bit is cleared.
7228 /* If we are no longer associated, and the roaming bit is no longer
7229 * set, then we are not actively roaming, so just return */
7230 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7233 if (priv->status & STATUS_ASSOCIATED) {
7234 /* First pass through ROAM process -- look for a better
7236 unsigned long flags;
7237 u8 rssi = priv->assoc_network->stats.rssi;
7238 priv->assoc_network->stats.rssi = -128;
7239 spin_lock_irqsave(&priv->ieee->lock, flags);
7240 list_for_each_entry(network, &priv->ieee->network_list, list) {
7241 if (network != priv->assoc_network)
7242 ipw_best_network(priv, &match, network, 1);
7244 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7245 priv->assoc_network->stats.rssi = rssi;
7247 if (match.network == priv->assoc_network) {
7248 IPW_DEBUG_ASSOC("No better APs in this network to "
7250 priv->status &= ~STATUS_ROAMING;
7251 ipw_debug_config(priv);
7255 ipw_send_disassociate(priv, 1);
7256 priv->assoc_network = match.network;
7261 /* Second pass through ROAM process -- request association */
7262 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7263 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7264 priv->status &= ~STATUS_ROAMING;
7267 static void ipw_bg_roam(void *data)
7269 struct ipw_priv *priv = data;
7270 mutex_lock(&priv->mutex);
7272 mutex_unlock(&priv->mutex);
7275 static int ipw_associate(void *data)
7277 struct ipw_priv *priv = data;
7279 struct ieee80211_network *network = NULL;
7280 struct ipw_network_match match = {
7283 struct ipw_supported_rates *rates;
7284 struct list_head *element;
7285 unsigned long flags;
7287 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7288 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7292 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7293 IPW_DEBUG_ASSOC("Not attempting association (already in "
7298 if (priv->status & STATUS_DISASSOCIATING) {
7299 IPW_DEBUG_ASSOC("Not attempting association (in "
7300 "disassociating)\n ");
7301 queue_work(priv->workqueue, &priv->associate);
7305 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7306 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7311 if (!(priv->config & CFG_ASSOCIATE) &&
7312 !(priv->config & (CFG_STATIC_ESSID |
7313 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7314 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7318 /* Protect our use of the network_list */
7319 spin_lock_irqsave(&priv->ieee->lock, flags);
7320 list_for_each_entry(network, &priv->ieee->network_list, list)
7321 ipw_best_network(priv, &match, network, 0);
7323 network = match.network;
7324 rates = &match.rates;
7326 if (network == NULL &&
7327 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7328 priv->config & CFG_ADHOC_CREATE &&
7329 priv->config & CFG_STATIC_ESSID &&
7330 priv->config & CFG_STATIC_CHANNEL &&
7331 !list_empty(&priv->ieee->network_free_list)) {
7332 element = priv->ieee->network_free_list.next;
7333 network = list_entry(element, struct ieee80211_network, list);
7334 ipw_adhoc_create(priv, network);
7335 rates = &priv->rates;
7337 list_add_tail(&network->list, &priv->ieee->network_list);
7339 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7341 /* If we reached the end of the list, then we don't have any valid
7344 ipw_debug_config(priv);
7346 if (!(priv->status & STATUS_SCANNING)) {
7347 if (!(priv->config & CFG_SPEED_SCAN))
7348 queue_delayed_work(priv->workqueue,
7349 &priv->request_scan,
7352 queue_work(priv->workqueue,
7353 &priv->request_scan);
7359 ipw_associate_network(priv, network, rates, 0);
7364 static void ipw_bg_associate(void *data)
7366 struct ipw_priv *priv = data;
7367 mutex_lock(&priv->mutex);
7368 ipw_associate(data);
7369 mutex_unlock(&priv->mutex);
7372 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7373 struct sk_buff *skb)
7375 struct ieee80211_hdr *hdr;
7378 hdr = (struct ieee80211_hdr *)skb->data;
7379 fc = le16_to_cpu(hdr->frame_ctl);
7380 if (!(fc & IEEE80211_FCTL_PROTECTED))
7383 fc &= ~IEEE80211_FCTL_PROTECTED;
7384 hdr->frame_ctl = cpu_to_le16(fc);
7385 switch (priv->ieee->sec.level) {
7387 /* Remove CCMP HDR */
7388 memmove(skb->data + IEEE80211_3ADDR_LEN,
7389 skb->data + IEEE80211_3ADDR_LEN + 8,
7390 skb->len - IEEE80211_3ADDR_LEN - 8);
7391 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7397 memmove(skb->data + IEEE80211_3ADDR_LEN,
7398 skb->data + IEEE80211_3ADDR_LEN + 4,
7399 skb->len - IEEE80211_3ADDR_LEN - 4);
7400 skb_trim(skb, skb->len - 8); /* IV + ICV */
7405 printk(KERN_ERR "Unknow security level %d\n",
7406 priv->ieee->sec.level);
7411 static void ipw_handle_data_packet(struct ipw_priv *priv,
7412 struct ipw_rx_mem_buffer *rxb,
7413 struct ieee80211_rx_stats *stats)
7415 struct ieee80211_hdr_4addr *hdr;
7416 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7418 /* We received data from the HW, so stop the watchdog */
7419 priv->net_dev->trans_start = jiffies;
7421 /* We only process data packets if the
7422 * interface is open */
7423 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7424 skb_tailroom(rxb->skb))) {
7425 priv->ieee->stats.rx_errors++;
7426 priv->wstats.discard.misc++;
7427 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7429 } else if (unlikely(!netif_running(priv->net_dev))) {
7430 priv->ieee->stats.rx_dropped++;
7431 priv->wstats.discard.misc++;
7432 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7436 /* Advance skb->data to the start of the actual payload */
7437 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7439 /* Set the size of the skb to the size of the frame */
7440 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7442 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7444 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7445 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7446 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7447 (is_multicast_ether_addr(hdr->addr1) ?
7448 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7449 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7451 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7452 priv->ieee->stats.rx_errors++;
7453 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7455 __ipw_led_activity_on(priv);
7459 #ifdef CONFIG_IEEE80211_RADIOTAP
7460 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7461 struct ipw_rx_mem_buffer *rxb,
7462 struct ieee80211_rx_stats *stats)
7464 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7465 struct ipw_rx_frame *frame = &pkt->u.frame;
7467 /* initial pull of some data */
7468 u16 received_channel = frame->received_channel;
7469 u8 antennaAndPhy = frame->antennaAndPhy;
7470 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7471 u16 pktrate = frame->rate;
7473 /* Magic struct that slots into the radiotap header -- no reason
7474 * to build this manually element by element, we can write it much
7475 * more efficiently than we can parse it. ORDER MATTERS HERE */
7477 struct ieee80211_radiotap_header rt_hdr;
7478 u8 rt_flags; /* radiotap packet flags */
7479 u8 rt_rate; /* rate in 500kb/s */
7480 u16 rt_channel; /* channel in mhz */
7481 u16 rt_chbitmask; /* channel bitfield */
7482 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7483 u8 rt_antenna; /* antenna number */
7486 short len = le16_to_cpu(pkt->u.frame.length);
7488 /* We received data from the HW, so stop the watchdog */
7489 priv->net_dev->trans_start = jiffies;
7491 /* We only process data packets if the
7492 * interface is open */
7493 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7494 skb_tailroom(rxb->skb))) {
7495 priv->ieee->stats.rx_errors++;
7496 priv->wstats.discard.misc++;
7497 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7499 } else if (unlikely(!netif_running(priv->net_dev))) {
7500 priv->ieee->stats.rx_dropped++;
7501 priv->wstats.discard.misc++;
7502 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7506 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7508 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7509 /* FIXME: Should alloc bigger skb instead */
7510 priv->ieee->stats.rx_dropped++;
7511 priv->wstats.discard.misc++;
7512 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7516 /* copy the frame itself */
7517 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7518 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7520 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7521 * part of our real header, saves a little time.
7523 * No longer necessary since we fill in all our data. Purge before merging
7525 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7526 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7529 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7531 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7532 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7533 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7535 /* Big bitfield of all the fields we provide in radiotap */
7536 ipw_rt->rt_hdr.it_present =
7537 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7538 (1 << IEEE80211_RADIOTAP_RATE) |
7539 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7540 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7541 (1 << IEEE80211_RADIOTAP_ANTENNA));
7543 /* Zero the flags, we'll add to them as we go */
7544 ipw_rt->rt_flags = 0;
7546 /* Convert signal to DBM */
7547 ipw_rt->rt_dbmsignal = antsignal;
7549 /* Convert the channel data and set the flags */
7550 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7551 if (received_channel > 14) { /* 802.11a */
7552 ipw_rt->rt_chbitmask =
7553 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7554 } else if (antennaAndPhy & 32) { /* 802.11b */
7555 ipw_rt->rt_chbitmask =
7556 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7557 } else { /* 802.11g */
7558 ipw_rt->rt_chbitmask =
7559 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7562 /* set the rate in multiples of 500k/s */
7564 case IPW_TX_RATE_1MB:
7565 ipw_rt->rt_rate = 2;
7567 case IPW_TX_RATE_2MB:
7568 ipw_rt->rt_rate = 4;
7570 case IPW_TX_RATE_5MB:
7571 ipw_rt->rt_rate = 10;
7573 case IPW_TX_RATE_6MB:
7574 ipw_rt->rt_rate = 12;
7576 case IPW_TX_RATE_9MB:
7577 ipw_rt->rt_rate = 18;
7579 case IPW_TX_RATE_11MB:
7580 ipw_rt->rt_rate = 22;
7582 case IPW_TX_RATE_12MB:
7583 ipw_rt->rt_rate = 24;
7585 case IPW_TX_RATE_18MB:
7586 ipw_rt->rt_rate = 36;
7588 case IPW_TX_RATE_24MB:
7589 ipw_rt->rt_rate = 48;
7591 case IPW_TX_RATE_36MB:
7592 ipw_rt->rt_rate = 72;
7594 case IPW_TX_RATE_48MB:
7595 ipw_rt->rt_rate = 96;
7597 case IPW_TX_RATE_54MB:
7598 ipw_rt->rt_rate = 108;
7601 ipw_rt->rt_rate = 0;
7605 /* antenna number */
7606 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7608 /* set the preamble flag if we have it */
7609 if ((antennaAndPhy & 64))
7610 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7612 /* Set the size of the skb to the size of the frame */
7613 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7615 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7617 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7618 priv->ieee->stats.rx_errors++;
7619 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7621 /* no LED during capture */
7626 static int is_network_packet(struct ipw_priv *priv,
7627 struct ieee80211_hdr_4addr *header)
7629 /* Filter incoming packets to determine if they are targetted toward
7630 * this network, discarding packets coming from ourselves */
7631 switch (priv->ieee->iw_mode) {
7632 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
7633 /* packets from our adapter are dropped (echo) */
7634 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7637 /* {broad,multi}cast packets to our BSSID go through */
7638 if (is_multicast_ether_addr(header->addr1))
7639 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
7641 /* packets to our adapter go through */
7642 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7645 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
7646 /* packets from our adapter are dropped (echo) */
7647 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7650 /* {broad,multi}cast packets to our BSS go through */
7651 if (is_multicast_ether_addr(header->addr1))
7652 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7654 /* packets to our adapter go through */
7655 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7662 #define IPW_PACKET_RETRY_TIME HZ
7664 static int is_duplicate_packet(struct ipw_priv *priv,
7665 struct ieee80211_hdr_4addr *header)
7667 u16 sc = le16_to_cpu(header->seq_ctl);
7668 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7669 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7670 u16 *last_seq, *last_frag;
7671 unsigned long *last_time;
7673 switch (priv->ieee->iw_mode) {
7676 struct list_head *p;
7677 struct ipw_ibss_seq *entry = NULL;
7678 u8 *mac = header->addr2;
7679 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7681 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7683 list_entry(p, struct ipw_ibss_seq, list);
7684 if (!memcmp(entry->mac, mac, ETH_ALEN))
7687 if (p == &priv->ibss_mac_hash[index]) {
7688 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7691 ("Cannot malloc new mac entry\n");
7694 memcpy(entry->mac, mac, ETH_ALEN);
7695 entry->seq_num = seq;
7696 entry->frag_num = frag;
7697 entry->packet_time = jiffies;
7698 list_add(&entry->list,
7699 &priv->ibss_mac_hash[index]);
7702 last_seq = &entry->seq_num;
7703 last_frag = &entry->frag_num;
7704 last_time = &entry->packet_time;
7708 last_seq = &priv->last_seq_num;
7709 last_frag = &priv->last_frag_num;
7710 last_time = &priv->last_packet_time;
7715 if ((*last_seq == seq) &&
7716 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7717 if (*last_frag == frag)
7719 if (*last_frag + 1 != frag)
7720 /* out-of-order fragment */
7726 *last_time = jiffies;
7730 /* Comment this line now since we observed the card receives
7731 * duplicate packets but the FCTL_RETRY bit is not set in the
7732 * IBSS mode with fragmentation enabled.
7733 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
7737 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7738 struct ipw_rx_mem_buffer *rxb,
7739 struct ieee80211_rx_stats *stats)
7741 struct sk_buff *skb = rxb->skb;
7742 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7743 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7744 (skb->data + IPW_RX_FRAME_SIZE);
7746 ieee80211_rx_mgt(priv->ieee, header, stats);
7748 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7749 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7750 IEEE80211_STYPE_PROBE_RESP) ||
7751 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7752 IEEE80211_STYPE_BEACON))) {
7753 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7754 ipw_add_station(priv, header->addr2);
7757 if (priv->config & CFG_NET_STATS) {
7758 IPW_DEBUG_HC("sending stat packet\n");
7760 /* Set the size of the skb to the size of the full
7761 * ipw header and 802.11 frame */
7762 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7765 /* Advance past the ipw packet header to the 802.11 frame */
7766 skb_pull(skb, IPW_RX_FRAME_SIZE);
7768 /* Push the ieee80211_rx_stats before the 802.11 frame */
7769 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7771 skb->dev = priv->ieee->dev;
7773 /* Point raw at the ieee80211_stats */
7774 skb->mac.raw = skb->data;
7776 skb->pkt_type = PACKET_OTHERHOST;
7777 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7778 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7785 * Main entry function for recieving a packet with 80211 headers. This
7786 * should be called when ever the FW has notified us that there is a new
7787 * skb in the recieve queue.
7789 static void ipw_rx(struct ipw_priv *priv)
7791 struct ipw_rx_mem_buffer *rxb;
7792 struct ipw_rx_packet *pkt;
7793 struct ieee80211_hdr_4addr *header;
7797 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7798 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
7799 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7802 rxb = priv->rxq->queue[i];
7803 if (unlikely(rxb == NULL)) {
7804 printk(KERN_CRIT "Queue not allocated!\n");
7807 priv->rxq->queue[i] = NULL;
7809 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
7811 PCI_DMA_FROMDEVICE);
7813 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7814 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7815 pkt->header.message_type,
7816 pkt->header.rx_seq_num, pkt->header.control_bits);
7818 switch (pkt->header.message_type) {
7819 case RX_FRAME_TYPE: /* 802.11 frame */ {
7820 struct ieee80211_rx_stats stats = {
7822 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7825 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7826 IPW_RSSI_TO_DBM + 0x100,
7828 le16_to_cpu(pkt->u.frame.noise),
7829 .rate = pkt->u.frame.rate,
7830 .mac_time = jiffies,
7832 pkt->u.frame.received_channel,
7835 control & (1 << 0)) ?
7836 IEEE80211_24GHZ_BAND :
7837 IEEE80211_52GHZ_BAND,
7838 .len = le16_to_cpu(pkt->u.frame.length),
7841 if (stats.rssi != 0)
7842 stats.mask |= IEEE80211_STATMASK_RSSI;
7843 if (stats.signal != 0)
7844 stats.mask |= IEEE80211_STATMASK_SIGNAL;
7845 if (stats.noise != 0)
7846 stats.mask |= IEEE80211_STATMASK_NOISE;
7847 if (stats.rate != 0)
7848 stats.mask |= IEEE80211_STATMASK_RATE;
7852 #ifdef CONFIG_IPW2200_MONITOR
7853 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7854 #ifdef CONFIG_IEEE80211_RADIOTAP
7855 ipw_handle_data_packet_monitor(priv,
7859 ipw_handle_data_packet(priv, rxb,
7867 (struct ieee80211_hdr_4addr *)(rxb->skb->
7870 /* TODO: Check Ad-Hoc dest/source and make sure
7871 * that we are actually parsing these packets
7872 * correctly -- we should probably use the
7873 * frame control of the packet and disregard
7874 * the current iw_mode */
7877 is_network_packet(priv, header);
7878 if (network_packet && priv->assoc_network) {
7879 priv->assoc_network->stats.rssi =
7881 average_add(&priv->average_rssi,
7883 priv->last_rx_rssi = stats.rssi;
7886 IPW_DEBUG_RX("Frame: len=%u\n",
7887 le16_to_cpu(pkt->u.frame.length));
7889 if (le16_to_cpu(pkt->u.frame.length) <
7890 ieee80211_get_hdrlen(le16_to_cpu(
7891 header->frame_ctl))) {
7893 ("Received packet is too small. "
7895 priv->ieee->stats.rx_errors++;
7896 priv->wstats.discard.misc++;
7900 switch (WLAN_FC_GET_TYPE
7901 (le16_to_cpu(header->frame_ctl))) {
7903 case IEEE80211_FTYPE_MGMT:
7904 ipw_handle_mgmt_packet(priv, rxb,
7908 case IEEE80211_FTYPE_CTL:
7911 case IEEE80211_FTYPE_DATA:
7912 if (unlikely(!network_packet ||
7913 is_duplicate_packet(priv,
7916 IPW_DEBUG_DROP("Dropping: "
7929 ipw_handle_data_packet(priv, rxb,
7937 case RX_HOST_NOTIFICATION_TYPE:{
7939 ("Notification: subtype=%02X flags=%02X size=%d\n",
7940 pkt->u.notification.subtype,
7941 pkt->u.notification.flags,
7942 pkt->u.notification.size);
7943 ipw_rx_notification(priv, &pkt->u.notification);
7948 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7949 pkt->header.message_type);
7953 /* For now we just don't re-use anything. We can tweak this
7954 * later to try and re-use notification packets and SKBs that
7955 * fail to Rx correctly */
7956 if (rxb->skb != NULL) {
7957 dev_kfree_skb_any(rxb->skb);
7961 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
7962 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
7963 list_add_tail(&rxb->list, &priv->rxq->rx_used);
7965 i = (i + 1) % RX_QUEUE_SIZE;
7968 /* Backtrack one entry */
7969 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7971 ipw_rx_queue_restock(priv);
7974 #define DEFAULT_RTS_THRESHOLD 2304U
7975 #define MIN_RTS_THRESHOLD 1U
7976 #define MAX_RTS_THRESHOLD 2304U
7977 #define DEFAULT_BEACON_INTERVAL 100U
7978 #define DEFAULT_SHORT_RETRY_LIMIT 7U
7979 #define DEFAULT_LONG_RETRY_LIMIT 4U
7983 * @option: options to control different reset behaviour
7984 * 0 = reset everything except the 'disable' module_param
7985 * 1 = reset everything and print out driver info (for probe only)
7986 * 2 = reset everything
7988 static int ipw_sw_reset(struct ipw_priv *priv, int option)
7990 int band, modulation;
7991 int old_mode = priv->ieee->iw_mode;
7993 /* Initialize module parameter values here */
7996 /* We default to disabling the LED code as right now it causes
7997 * too many systems to lock up... */
7999 priv->config |= CFG_NO_LED;
8002 priv->config |= CFG_ASSOCIATE;
8004 IPW_DEBUG_INFO("Auto associate disabled.\n");
8007 priv->config |= CFG_ADHOC_CREATE;
8009 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8011 priv->config &= ~CFG_STATIC_ESSID;
8012 priv->essid_len = 0;
8013 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8015 if (disable && option) {
8016 priv->status |= STATUS_RF_KILL_SW;
8017 IPW_DEBUG_INFO("Radio disabled.\n");
8021 priv->config |= CFG_STATIC_CHANNEL;
8022 priv->channel = channel;
8023 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8024 /* TODO: Validate that provided channel is in range */
8026 #ifdef CONFIG_IPW_QOS
8027 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8028 burst_duration_CCK, burst_duration_OFDM);
8029 #endif /* CONFIG_IPW_QOS */
8033 priv->ieee->iw_mode = IW_MODE_ADHOC;
8034 priv->net_dev->type = ARPHRD_ETHER;
8037 #ifdef CONFIG_IPW2200_MONITOR
8039 priv->ieee->iw_mode = IW_MODE_MONITOR;
8040 #ifdef CONFIG_IEEE80211_RADIOTAP
8041 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8043 priv->net_dev->type = ARPHRD_IEEE80211;
8049 priv->net_dev->type = ARPHRD_ETHER;
8050 priv->ieee->iw_mode = IW_MODE_INFRA;
8055 priv->ieee->host_encrypt = 0;
8056 priv->ieee->host_encrypt_msdu = 0;
8057 priv->ieee->host_decrypt = 0;
8058 priv->ieee->host_mc_decrypt = 0;
8060 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8062 /* IPW2200/2915 is abled to do hardware fragmentation. */
8063 priv->ieee->host_open_frag = 0;
8065 if ((priv->pci_dev->device == 0x4223) ||
8066 (priv->pci_dev->device == 0x4224)) {
8068 printk(KERN_INFO DRV_NAME
8069 ": Detected Intel PRO/Wireless 2915ABG Network "
8071 priv->ieee->abg_true = 1;
8072 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8073 modulation = IEEE80211_OFDM_MODULATION |
8074 IEEE80211_CCK_MODULATION;
8075 priv->adapter = IPW_2915ABG;
8076 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8079 printk(KERN_INFO DRV_NAME
8080 ": Detected Intel PRO/Wireless 2200BG Network "
8083 priv->ieee->abg_true = 0;
8084 band = IEEE80211_24GHZ_BAND;
8085 modulation = IEEE80211_OFDM_MODULATION |
8086 IEEE80211_CCK_MODULATION;
8087 priv->adapter = IPW_2200BG;
8088 priv->ieee->mode = IEEE_G | IEEE_B;
8091 priv->ieee->freq_band = band;
8092 priv->ieee->modulation = modulation;
8094 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8096 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8097 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8099 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8100 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8101 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8103 /* If power management is turned on, default to AC mode */
8104 priv->power_mode = IPW_POWER_AC;
8105 priv->tx_power = IPW_TX_POWER_DEFAULT;
8107 return old_mode == priv->ieee->iw_mode;
8111 * This file defines the Wireless Extension handlers. It does not
8112 * define any methods of hardware manipulation and relies on the
8113 * functions defined in ipw_main to provide the HW interaction.
8115 * The exception to this is the use of the ipw_get_ordinal()
8116 * function used to poll the hardware vs. making unecessary calls.
8120 static int ipw_wx_get_name(struct net_device *dev,
8121 struct iw_request_info *info,
8122 union iwreq_data *wrqu, char *extra)
8124 struct ipw_priv *priv = ieee80211_priv(dev);
8125 mutex_lock(&priv->mutex);
8126 if (priv->status & STATUS_RF_KILL_MASK)
8127 strcpy(wrqu->name, "radio off");
8128 else if (!(priv->status & STATUS_ASSOCIATED))
8129 strcpy(wrqu->name, "unassociated");
8131 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8132 ipw_modes[priv->assoc_request.ieee_mode]);
8133 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8134 mutex_unlock(&priv->mutex);
8138 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8141 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8142 priv->config &= ~CFG_STATIC_CHANNEL;
8143 IPW_DEBUG_ASSOC("Attempting to associate with new "
8145 ipw_associate(priv);
8149 priv->config |= CFG_STATIC_CHANNEL;
8151 if (priv->channel == channel) {
8152 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8157 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8158 priv->channel = channel;
8160 #ifdef CONFIG_IPW2200_MONITOR
8161 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8163 if (priv->status & STATUS_SCANNING) {
8164 IPW_DEBUG_SCAN("Scan abort triggered due to "
8165 "channel change.\n");
8166 ipw_abort_scan(priv);
8169 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8172 if (priv->status & STATUS_SCANNING)
8173 IPW_DEBUG_SCAN("Still scanning...\n");
8175 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8180 #endif /* CONFIG_IPW2200_MONITOR */
8182 /* Network configuration changed -- force [re]association */
8183 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8184 if (!ipw_disassociate(priv))
8185 ipw_associate(priv);
8190 static int ipw_wx_set_freq(struct net_device *dev,
8191 struct iw_request_info *info,
8192 union iwreq_data *wrqu, char *extra)
8194 struct ipw_priv *priv = ieee80211_priv(dev);
8195 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
8196 struct iw_freq *fwrq = &wrqu->freq;
8202 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8203 mutex_lock(&priv->mutex);
8204 ret = ipw_set_channel(priv, 0);
8205 mutex_unlock(&priv->mutex);
8208 /* if setting by freq convert to channel */
8210 channel = ieee80211_freq_to_channel(priv->ieee, fwrq->m);
8216 if (!(band = ieee80211_is_valid_channel(priv->ieee, channel)))
8219 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8220 i = ieee80211_channel_to_index(priv->ieee, channel);
8224 flags = (band == IEEE80211_24GHZ_BAND) ?
8225 geo->bg[i].flags : geo->a[i].flags;
8226 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8227 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8232 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8233 mutex_lock(&priv->mutex);
8234 ret = ipw_set_channel(priv, channel);
8235 mutex_unlock(&priv->mutex);
8239 static int ipw_wx_get_freq(struct net_device *dev,
8240 struct iw_request_info *info,
8241 union iwreq_data *wrqu, char *extra)
8243 struct ipw_priv *priv = ieee80211_priv(dev);
8247 /* If we are associated, trying to associate, or have a statically
8248 * configured CHANNEL then return that; otherwise return ANY */
8249 mutex_lock(&priv->mutex);
8250 if (priv->config & CFG_STATIC_CHANNEL ||
8251 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8252 wrqu->freq.m = priv->channel;
8256 mutex_unlock(&priv->mutex);
8257 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8261 static int ipw_wx_set_mode(struct net_device *dev,
8262 struct iw_request_info *info,
8263 union iwreq_data *wrqu, char *extra)
8265 struct ipw_priv *priv = ieee80211_priv(dev);
8268 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8270 switch (wrqu->mode) {
8271 #ifdef CONFIG_IPW2200_MONITOR
8272 case IW_MODE_MONITOR:
8278 wrqu->mode = IW_MODE_INFRA;
8283 if (wrqu->mode == priv->ieee->iw_mode)
8286 mutex_lock(&priv->mutex);
8288 ipw_sw_reset(priv, 0);
8290 #ifdef CONFIG_IPW2200_MONITOR
8291 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8292 priv->net_dev->type = ARPHRD_ETHER;
8294 if (wrqu->mode == IW_MODE_MONITOR)
8295 #ifdef CONFIG_IEEE80211_RADIOTAP
8296 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8298 priv->net_dev->type = ARPHRD_IEEE80211;
8300 #endif /* CONFIG_IPW2200_MONITOR */
8302 /* Free the existing firmware and reset the fw_loaded
8303 * flag so ipw_load() will bring in the new firmawre */
8306 priv->ieee->iw_mode = wrqu->mode;
8308 queue_work(priv->workqueue, &priv->adapter_restart);
8309 mutex_unlock(&priv->mutex);
8313 static int ipw_wx_get_mode(struct net_device *dev,
8314 struct iw_request_info *info,
8315 union iwreq_data *wrqu, char *extra)
8317 struct ipw_priv *priv = ieee80211_priv(dev);
8318 mutex_lock(&priv->mutex);
8319 wrqu->mode = priv->ieee->iw_mode;
8320 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8321 mutex_unlock(&priv->mutex);
8325 /* Values are in microsecond */
8326 static const s32 timeout_duration[] = {
8334 static const s32 period_duration[] = {
8342 static int ipw_wx_get_range(struct net_device *dev,
8343 struct iw_request_info *info,
8344 union iwreq_data *wrqu, char *extra)
8346 struct ipw_priv *priv = ieee80211_priv(dev);
8347 struct iw_range *range = (struct iw_range *)extra;
8348 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
8351 wrqu->data.length = sizeof(*range);
8352 memset(range, 0, sizeof(*range));
8354 /* 54Mbs == ~27 Mb/s real (802.11g) */
8355 range->throughput = 27 * 1000 * 1000;
8357 range->max_qual.qual = 100;
8358 /* TODO: Find real max RSSI and stick here */
8359 range->max_qual.level = 0;
8360 range->max_qual.noise = 0;
8361 range->max_qual.updated = 7; /* Updated all three */
8363 range->avg_qual.qual = 70;
8364 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8365 range->avg_qual.level = 0; /* FIXME to real average level */
8366 range->avg_qual.noise = 0;
8367 range->avg_qual.updated = 7; /* Updated all three */
8368 mutex_lock(&priv->mutex);
8369 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8371 for (i = 0; i < range->num_bitrates; i++)
8372 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8375 range->max_rts = DEFAULT_RTS_THRESHOLD;
8376 range->min_frag = MIN_FRAG_THRESHOLD;
8377 range->max_frag = MAX_FRAG_THRESHOLD;
8379 range->encoding_size[0] = 5;
8380 range->encoding_size[1] = 13;
8381 range->num_encoding_sizes = 2;
8382 range->max_encoding_tokens = WEP_KEYS;
8384 /* Set the Wireless Extension versions */
8385 range->we_version_compiled = WIRELESS_EXT;
8386 range->we_version_source = 18;
8389 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8390 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8392 range->freq[i].i = geo->bg[j].channel;
8393 range->freq[i].m = geo->bg[j].freq * 100000;
8394 range->freq[i].e = 1;
8398 if (priv->ieee->mode & IEEE_A) {
8399 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8401 range->freq[i].i = geo->a[j].channel;
8402 range->freq[i].m = geo->a[j].freq * 100000;
8403 range->freq[i].e = 1;
8407 range->num_channels = i;
8408 range->num_frequency = i;
8410 mutex_unlock(&priv->mutex);
8412 /* Event capability (kernel + driver) */
8413 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8414 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8415 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8416 range->event_capa[1] = IW_EVENT_CAPA_K_1;
8418 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8419 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8421 IPW_DEBUG_WX("GET Range\n");
8425 static int ipw_wx_set_wap(struct net_device *dev,
8426 struct iw_request_info *info,
8427 union iwreq_data *wrqu, char *extra)
8429 struct ipw_priv *priv = ieee80211_priv(dev);
8431 static const unsigned char any[] = {
8432 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8434 static const unsigned char off[] = {
8435 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8438 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8440 mutex_lock(&priv->mutex);
8441 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8442 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8443 /* we disable mandatory BSSID association */
8444 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8445 priv->config &= ~CFG_STATIC_BSSID;
8446 IPW_DEBUG_ASSOC("Attempting to associate with new "
8448 ipw_associate(priv);
8449 mutex_unlock(&priv->mutex);
8453 priv->config |= CFG_STATIC_BSSID;
8454 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8455 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8456 mutex_unlock(&priv->mutex);
8460 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8461 MAC_ARG(wrqu->ap_addr.sa_data));
8463 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8465 /* Network configuration changed -- force [re]association */
8466 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8467 if (!ipw_disassociate(priv))
8468 ipw_associate(priv);
8470 mutex_unlock(&priv->mutex);
8474 static int ipw_wx_get_wap(struct net_device *dev,
8475 struct iw_request_info *info,
8476 union iwreq_data *wrqu, char *extra)
8478 struct ipw_priv *priv = ieee80211_priv(dev);
8479 /* If we are associated, trying to associate, or have a statically
8480 * configured BSSID then return that; otherwise return ANY */
8481 mutex_lock(&priv->mutex);
8482 if (priv->config & CFG_STATIC_BSSID ||
8483 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8484 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8485 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8487 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8489 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8490 MAC_ARG(wrqu->ap_addr.sa_data));
8491 mutex_unlock(&priv->mutex);
8495 static int ipw_wx_set_essid(struct net_device *dev,
8496 struct iw_request_info *info,
8497 union iwreq_data *wrqu, char *extra)
8499 struct ipw_priv *priv = ieee80211_priv(dev);
8500 char *essid = ""; /* ANY */
8502 mutex_lock(&priv->mutex);
8503 if (wrqu->essid.flags && wrqu->essid.length) {
8504 length = wrqu->essid.length - 1;
8508 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8509 if ((priv->config & CFG_STATIC_ESSID) &&
8510 !(priv->status & (STATUS_ASSOCIATED |
8511 STATUS_ASSOCIATING))) {
8512 IPW_DEBUG_ASSOC("Attempting to associate with new "
8514 priv->config &= ~CFG_STATIC_ESSID;
8515 ipw_associate(priv);
8517 mutex_unlock(&priv->mutex);
8521 length = min(length, IW_ESSID_MAX_SIZE);
8523 priv->config |= CFG_STATIC_ESSID;
8525 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8526 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8527 mutex_unlock(&priv->mutex);
8531 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8534 priv->essid_len = length;
8535 memcpy(priv->essid, essid, priv->essid_len);
8537 /* Network configuration changed -- force [re]association */
8538 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8539 if (!ipw_disassociate(priv))
8540 ipw_associate(priv);
8542 mutex_unlock(&priv->mutex);
8546 static int ipw_wx_get_essid(struct net_device *dev,
8547 struct iw_request_info *info,
8548 union iwreq_data *wrqu, char *extra)
8550 struct ipw_priv *priv = ieee80211_priv(dev);
8552 /* If we are associated, trying to associate, or have a statically
8553 * configured ESSID then return that; otherwise return ANY */
8554 mutex_lock(&priv->mutex);
8555 if (priv->config & CFG_STATIC_ESSID ||
8556 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8557 IPW_DEBUG_WX("Getting essid: '%s'\n",
8558 escape_essid(priv->essid, priv->essid_len));
8559 memcpy(extra, priv->essid, priv->essid_len);
8560 wrqu->essid.length = priv->essid_len;
8561 wrqu->essid.flags = 1; /* active */
8563 IPW_DEBUG_WX("Getting essid: ANY\n");
8564 wrqu->essid.length = 0;
8565 wrqu->essid.flags = 0; /* active */
8567 mutex_unlock(&priv->mutex);
8571 static int ipw_wx_set_nick(struct net_device *dev,
8572 struct iw_request_info *info,
8573 union iwreq_data *wrqu, char *extra)
8575 struct ipw_priv *priv = ieee80211_priv(dev);
8577 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8578 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8580 mutex_lock(&priv->mutex);
8581 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
8582 memset(priv->nick, 0, sizeof(priv->nick));
8583 memcpy(priv->nick, extra, wrqu->data.length);
8584 IPW_DEBUG_TRACE("<<\n");
8585 mutex_unlock(&priv->mutex);
8590 static int ipw_wx_get_nick(struct net_device *dev,
8591 struct iw_request_info *info,
8592 union iwreq_data *wrqu, char *extra)
8594 struct ipw_priv *priv = ieee80211_priv(dev);
8595 IPW_DEBUG_WX("Getting nick\n");
8596 mutex_lock(&priv->mutex);
8597 wrqu->data.length = strlen(priv->nick) + 1;
8598 memcpy(extra, priv->nick, wrqu->data.length);
8599 wrqu->data.flags = 1; /* active */
8600 mutex_unlock(&priv->mutex);
8604 static int ipw_wx_set_rate(struct net_device *dev,
8605 struct iw_request_info *info,
8606 union iwreq_data *wrqu, char *extra)
8608 /* TODO: We should use semaphores or locks for access to priv */
8609 struct ipw_priv *priv = ieee80211_priv(dev);
8610 u32 target_rate = wrqu->bitrate.value;
8613 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8614 /* value = X, fixed = 1 means only rate X */
8615 /* value = X, fixed = 0 means all rates lower equal X */
8617 if (target_rate == -1) {
8619 mask = IEEE80211_DEFAULT_RATES_MASK;
8620 /* Now we should reassociate */
8625 fixed = wrqu->bitrate.fixed;
8627 if (target_rate == 1000000 || !fixed)
8628 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8629 if (target_rate == 1000000)
8632 if (target_rate == 2000000 || !fixed)
8633 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8634 if (target_rate == 2000000)
8637 if (target_rate == 5500000 || !fixed)
8638 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8639 if (target_rate == 5500000)
8642 if (target_rate == 6000000 || !fixed)
8643 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8644 if (target_rate == 6000000)
8647 if (target_rate == 9000000 || !fixed)
8648 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8649 if (target_rate == 9000000)
8652 if (target_rate == 11000000 || !fixed)
8653 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8654 if (target_rate == 11000000)
8657 if (target_rate == 12000000 || !fixed)
8658 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8659 if (target_rate == 12000000)
8662 if (target_rate == 18000000 || !fixed)
8663 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8664 if (target_rate == 18000000)
8667 if (target_rate == 24000000 || !fixed)
8668 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8669 if (target_rate == 24000000)
8672 if (target_rate == 36000000 || !fixed)
8673 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8674 if (target_rate == 36000000)
8677 if (target_rate == 48000000 || !fixed)
8678 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8679 if (target_rate == 48000000)
8682 if (target_rate == 54000000 || !fixed)
8683 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8684 if (target_rate == 54000000)
8687 IPW_DEBUG_WX("invalid rate specified, returning error\n");
8691 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8692 mask, fixed ? "fixed" : "sub-rates");
8693 mutex_lock(&priv->mutex);
8694 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
8695 priv->config &= ~CFG_FIXED_RATE;
8696 ipw_set_fixed_rate(priv, priv->ieee->mode);
8698 priv->config |= CFG_FIXED_RATE;
8700 if (priv->rates_mask == mask) {
8701 IPW_DEBUG_WX("Mask set to current mask.\n");
8702 mutex_unlock(&priv->mutex);
8706 priv->rates_mask = mask;
8708 /* Network configuration changed -- force [re]association */
8709 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8710 if (!ipw_disassociate(priv))
8711 ipw_associate(priv);
8713 mutex_unlock(&priv->mutex);
8717 static int ipw_wx_get_rate(struct net_device *dev,
8718 struct iw_request_info *info,
8719 union iwreq_data *wrqu, char *extra)
8721 struct ipw_priv *priv = ieee80211_priv(dev);
8722 mutex_lock(&priv->mutex);
8723 wrqu->bitrate.value = priv->last_rate;
8724 mutex_unlock(&priv->mutex);
8725 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8729 static int ipw_wx_set_rts(struct net_device *dev,
8730 struct iw_request_info *info,
8731 union iwreq_data *wrqu, char *extra)
8733 struct ipw_priv *priv = ieee80211_priv(dev);
8734 mutex_lock(&priv->mutex);
8735 if (wrqu->rts.disabled)
8736 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8738 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
8739 wrqu->rts.value > MAX_RTS_THRESHOLD) {
8740 mutex_unlock(&priv->mutex);
8743 priv->rts_threshold = wrqu->rts.value;
8746 ipw_send_rts_threshold(priv, priv->rts_threshold);
8747 mutex_unlock(&priv->mutex);
8748 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8752 static int ipw_wx_get_rts(struct net_device *dev,
8753 struct iw_request_info *info,
8754 union iwreq_data *wrqu, char *extra)
8756 struct ipw_priv *priv = ieee80211_priv(dev);
8757 mutex_lock(&priv->mutex);
8758 wrqu->rts.value = priv->rts_threshold;
8759 wrqu->rts.fixed = 0; /* no auto select */
8760 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
8761 mutex_unlock(&priv->mutex);
8762 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8766 static int ipw_wx_set_txpow(struct net_device *dev,
8767 struct iw_request_info *info,
8768 union iwreq_data *wrqu, char *extra)
8770 struct ipw_priv *priv = ieee80211_priv(dev);
8773 mutex_lock(&priv->mutex);
8774 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
8779 if (!wrqu->power.fixed)
8780 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8782 if (wrqu->power.flags != IW_TXPOW_DBM) {
8787 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
8788 (wrqu->power.value < IPW_TX_POWER_MIN)) {
8793 priv->tx_power = wrqu->power.value;
8794 err = ipw_set_tx_power(priv);
8796 mutex_unlock(&priv->mutex);
8800 static int ipw_wx_get_txpow(struct net_device *dev,
8801 struct iw_request_info *info,
8802 union iwreq_data *wrqu, char *extra)
8804 struct ipw_priv *priv = ieee80211_priv(dev);
8805 mutex_lock(&priv->mutex);
8806 wrqu->power.value = priv->tx_power;
8807 wrqu->power.fixed = 1;
8808 wrqu->power.flags = IW_TXPOW_DBM;
8809 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
8810 mutex_unlock(&priv->mutex);
8812 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
8813 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
8818 static int ipw_wx_set_frag(struct net_device *dev,
8819 struct iw_request_info *info,
8820 union iwreq_data *wrqu, char *extra)
8822 struct ipw_priv *priv = ieee80211_priv(dev);
8823 mutex_lock(&priv->mutex);
8824 if (wrqu->frag.disabled)
8825 priv->ieee->fts = DEFAULT_FTS;
8827 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
8828 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8829 mutex_unlock(&priv->mutex);
8833 priv->ieee->fts = wrqu->frag.value & ~0x1;
8836 ipw_send_frag_threshold(priv, wrqu->frag.value);
8837 mutex_unlock(&priv->mutex);
8838 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8842 static int ipw_wx_get_frag(struct net_device *dev,
8843 struct iw_request_info *info,
8844 union iwreq_data *wrqu, char *extra)
8846 struct ipw_priv *priv = ieee80211_priv(dev);
8847 mutex_lock(&priv->mutex);
8848 wrqu->frag.value = priv->ieee->fts;
8849 wrqu->frag.fixed = 0; /* no auto select */
8850 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
8851 mutex_unlock(&priv->mutex);
8852 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8857 static int ipw_wx_set_retry(struct net_device *dev,
8858 struct iw_request_info *info,
8859 union iwreq_data *wrqu, char *extra)
8861 struct ipw_priv *priv = ieee80211_priv(dev);
8863 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8866 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8869 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8872 mutex_lock(&priv->mutex);
8873 if (wrqu->retry.flags & IW_RETRY_MIN)
8874 priv->short_retry_limit = (u8) wrqu->retry.value;
8875 else if (wrqu->retry.flags & IW_RETRY_MAX)
8876 priv->long_retry_limit = (u8) wrqu->retry.value;
8878 priv->short_retry_limit = (u8) wrqu->retry.value;
8879 priv->long_retry_limit = (u8) wrqu->retry.value;
8882 ipw_send_retry_limit(priv, priv->short_retry_limit,
8883 priv->long_retry_limit);
8884 mutex_unlock(&priv->mutex);
8885 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8886 priv->short_retry_limit, priv->long_retry_limit);
8890 static int ipw_wx_get_retry(struct net_device *dev,
8891 struct iw_request_info *info,
8892 union iwreq_data *wrqu, char *extra)
8894 struct ipw_priv *priv = ieee80211_priv(dev);
8896 mutex_lock(&priv->mutex);
8897 wrqu->retry.disabled = 0;
8899 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
8900 mutex_unlock(&priv->mutex);
8904 if (wrqu->retry.flags & IW_RETRY_MAX) {
8905 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8906 wrqu->retry.value = priv->long_retry_limit;
8907 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8908 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8909 wrqu->retry.value = priv->short_retry_limit;
8911 wrqu->retry.flags = IW_RETRY_LIMIT;
8912 wrqu->retry.value = priv->short_retry_limit;
8914 mutex_unlock(&priv->mutex);
8916 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8921 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8924 struct ipw_scan_request_ext scan;
8925 int err = 0, scan_type;
8927 if (!(priv->status & STATUS_INIT) ||
8928 (priv->status & STATUS_EXIT_PENDING))
8931 mutex_lock(&priv->mutex);
8933 if (priv->status & STATUS_RF_KILL_MASK) {
8934 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8935 priv->status |= STATUS_SCAN_PENDING;
8939 IPW_DEBUG_HC("starting request direct scan!\n");
8941 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
8942 /* We should not sleep here; otherwise we will block most
8943 * of the system (for instance, we hold rtnl_lock when we
8949 memset(&scan, 0, sizeof(scan));
8951 if (priv->config & CFG_SPEED_SCAN)
8952 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8955 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8958 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8960 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8961 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8963 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8965 err = ipw_send_ssid(priv, essid, essid_len);
8967 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8970 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8972 ipw_add_scan_channels(priv, &scan, scan_type);
8974 err = ipw_send_scan_request_ext(priv, &scan);
8976 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8980 priv->status |= STATUS_SCANNING;
8983 mutex_unlock(&priv->mutex);
8987 static int ipw_wx_set_scan(struct net_device *dev,
8988 struct iw_request_info *info,
8989 union iwreq_data *wrqu, char *extra)
8991 struct ipw_priv *priv = ieee80211_priv(dev);
8992 struct iw_scan_req *req = NULL;
8993 if (wrqu->data.length
8994 && wrqu->data.length == sizeof(struct iw_scan_req)) {
8995 req = (struct iw_scan_req *)extra;
8996 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
8997 ipw_request_direct_scan(priv, req->essid,
9003 IPW_DEBUG_WX("Start scan\n");
9005 queue_work(priv->workqueue, &priv->request_scan);
9010 static int ipw_wx_get_scan(struct net_device *dev,
9011 struct iw_request_info *info,
9012 union iwreq_data *wrqu, char *extra)
9014 struct ipw_priv *priv = ieee80211_priv(dev);
9015 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9018 static int ipw_wx_set_encode(struct net_device *dev,
9019 struct iw_request_info *info,
9020 union iwreq_data *wrqu, char *key)
9022 struct ipw_priv *priv = ieee80211_priv(dev);
9024 u32 cap = priv->capability;
9026 mutex_lock(&priv->mutex);
9027 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9029 /* In IBSS mode, we need to notify the firmware to update
9030 * the beacon info after we changed the capability. */
9031 if (cap != priv->capability &&
9032 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9033 priv->status & STATUS_ASSOCIATED)
9034 ipw_disassociate(priv);
9036 mutex_unlock(&priv->mutex);
9040 static int ipw_wx_get_encode(struct net_device *dev,
9041 struct iw_request_info *info,
9042 union iwreq_data *wrqu, char *key)
9044 struct ipw_priv *priv = ieee80211_priv(dev);
9045 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9048 static int ipw_wx_set_power(struct net_device *dev,
9049 struct iw_request_info *info,
9050 union iwreq_data *wrqu, char *extra)
9052 struct ipw_priv *priv = ieee80211_priv(dev);
9054 mutex_lock(&priv->mutex);
9055 if (wrqu->power.disabled) {
9056 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9057 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9059 IPW_DEBUG_WX("failed setting power mode.\n");
9060 mutex_unlock(&priv->mutex);
9063 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9064 mutex_unlock(&priv->mutex);
9068 switch (wrqu->power.flags & IW_POWER_MODE) {
9069 case IW_POWER_ON: /* If not specified */
9070 case IW_POWER_MODE: /* If set all mask */
9071 case IW_POWER_ALL_R: /* If explicitely state all */
9073 default: /* Otherwise we don't support it */
9074 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9076 mutex_unlock(&priv->mutex);
9080 /* If the user hasn't specified a power management mode yet, default
9082 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9083 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9085 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9086 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9088 IPW_DEBUG_WX("failed setting power mode.\n");
9089 mutex_unlock(&priv->mutex);
9093 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9094 mutex_unlock(&priv->mutex);
9098 static int ipw_wx_get_power(struct net_device *dev,
9099 struct iw_request_info *info,
9100 union iwreq_data *wrqu, char *extra)
9102 struct ipw_priv *priv = ieee80211_priv(dev);
9103 mutex_lock(&priv->mutex);
9104 if (!(priv->power_mode & IPW_POWER_ENABLED))
9105 wrqu->power.disabled = 1;
9107 wrqu->power.disabled = 0;
9109 mutex_unlock(&priv->mutex);
9110 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9115 static int ipw_wx_set_powermode(struct net_device *dev,
9116 struct iw_request_info *info,
9117 union iwreq_data *wrqu, char *extra)
9119 struct ipw_priv *priv = ieee80211_priv(dev);
9120 int mode = *(int *)extra;
9122 mutex_lock(&priv->mutex);
9123 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9124 mode = IPW_POWER_AC;
9125 priv->power_mode = mode;
9127 priv->power_mode = IPW_POWER_ENABLED | mode;
9130 if (priv->power_mode != mode) {
9131 err = ipw_send_power_mode(priv, mode);
9134 IPW_DEBUG_WX("failed setting power mode.\n");
9135 mutex_unlock(&priv->mutex);
9139 mutex_unlock(&priv->mutex);
9143 #define MAX_WX_STRING 80
9144 static int ipw_wx_get_powermode(struct net_device *dev,
9145 struct iw_request_info *info,
9146 union iwreq_data *wrqu, char *extra)
9148 struct ipw_priv *priv = ieee80211_priv(dev);
9149 int level = IPW_POWER_LEVEL(priv->power_mode);
9152 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9156 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9158 case IPW_POWER_BATTERY:
9159 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9162 p += snprintf(p, MAX_WX_STRING - (p - extra),
9163 "(Timeout %dms, Period %dms)",
9164 timeout_duration[level - 1] / 1000,
9165 period_duration[level - 1] / 1000);
9168 if (!(priv->power_mode & IPW_POWER_ENABLED))
9169 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9171 wrqu->data.length = p - extra + 1;
9176 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9177 struct iw_request_info *info,
9178 union iwreq_data *wrqu, char *extra)
9180 struct ipw_priv *priv = ieee80211_priv(dev);
9181 int mode = *(int *)extra;
9182 u8 band = 0, modulation = 0;
9184 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9185 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9188 mutex_lock(&priv->mutex);
9189 if (priv->adapter == IPW_2915ABG) {
9190 priv->ieee->abg_true = 1;
9191 if (mode & IEEE_A) {
9192 band |= IEEE80211_52GHZ_BAND;
9193 modulation |= IEEE80211_OFDM_MODULATION;
9195 priv->ieee->abg_true = 0;
9197 if (mode & IEEE_A) {
9198 IPW_WARNING("Attempt to set 2200BG into "
9200 mutex_unlock(&priv->mutex);
9204 priv->ieee->abg_true = 0;
9207 if (mode & IEEE_B) {
9208 band |= IEEE80211_24GHZ_BAND;
9209 modulation |= IEEE80211_CCK_MODULATION;
9211 priv->ieee->abg_true = 0;
9213 if (mode & IEEE_G) {
9214 band |= IEEE80211_24GHZ_BAND;
9215 modulation |= IEEE80211_OFDM_MODULATION;
9217 priv->ieee->abg_true = 0;
9219 priv->ieee->mode = mode;
9220 priv->ieee->freq_band = band;
9221 priv->ieee->modulation = modulation;
9222 init_supported_rates(priv, &priv->rates);
9224 /* Network configuration changed -- force [re]association */
9225 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9226 if (!ipw_disassociate(priv)) {
9227 ipw_send_supported_rates(priv, &priv->rates);
9228 ipw_associate(priv);
9231 /* Update the band LEDs */
9232 ipw_led_band_on(priv);
9234 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9235 mode & IEEE_A ? 'a' : '.',
9236 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9237 mutex_unlock(&priv->mutex);
9241 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9242 struct iw_request_info *info,
9243 union iwreq_data *wrqu, char *extra)
9245 struct ipw_priv *priv = ieee80211_priv(dev);
9246 mutex_lock(&priv->mutex);
9247 switch (priv->ieee->mode) {
9249 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9252 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9254 case IEEE_A | IEEE_B:
9255 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9258 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9260 case IEEE_A | IEEE_G:
9261 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9263 case IEEE_B | IEEE_G:
9264 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9266 case IEEE_A | IEEE_B | IEEE_G:
9267 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9270 strncpy(extra, "unknown", MAX_WX_STRING);
9274 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9276 wrqu->data.length = strlen(extra) + 1;
9277 mutex_unlock(&priv->mutex);
9282 static int ipw_wx_set_preamble(struct net_device *dev,
9283 struct iw_request_info *info,
9284 union iwreq_data *wrqu, char *extra)
9286 struct ipw_priv *priv = ieee80211_priv(dev);
9287 int mode = *(int *)extra;
9288 mutex_lock(&priv->mutex);
9289 /* Switching from SHORT -> LONG requires a disassociation */
9291 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9292 priv->config |= CFG_PREAMBLE_LONG;
9294 /* Network configuration changed -- force [re]association */
9296 ("[re]association triggered due to preamble change.\n");
9297 if (!ipw_disassociate(priv))
9298 ipw_associate(priv);
9304 priv->config &= ~CFG_PREAMBLE_LONG;
9307 mutex_unlock(&priv->mutex);
9311 mutex_unlock(&priv->mutex);
9315 static int ipw_wx_get_preamble(struct net_device *dev,
9316 struct iw_request_info *info,
9317 union iwreq_data *wrqu, char *extra)
9319 struct ipw_priv *priv = ieee80211_priv(dev);
9320 mutex_lock(&priv->mutex);
9321 if (priv->config & CFG_PREAMBLE_LONG)
9322 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9324 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9325 mutex_unlock(&priv->mutex);
9329 #ifdef CONFIG_IPW2200_MONITOR
9330 static int ipw_wx_set_monitor(struct net_device *dev,
9331 struct iw_request_info *info,
9332 union iwreq_data *wrqu, char *extra)
9334 struct ipw_priv *priv = ieee80211_priv(dev);
9335 int *parms = (int *)extra;
9336 int enable = (parms[0] > 0);
9337 mutex_lock(&priv->mutex);
9338 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9340 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9341 #ifdef CONFIG_IEEE80211_RADIOTAP
9342 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9344 priv->net_dev->type = ARPHRD_IEEE80211;
9346 queue_work(priv->workqueue, &priv->adapter_restart);
9349 ipw_set_channel(priv, parms[1]);
9351 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9352 mutex_unlock(&priv->mutex);
9355 priv->net_dev->type = ARPHRD_ETHER;
9356 queue_work(priv->workqueue, &priv->adapter_restart);
9358 mutex_unlock(&priv->mutex);
9362 #endif // CONFIG_IPW2200_MONITOR
9364 static int ipw_wx_reset(struct net_device *dev,
9365 struct iw_request_info *info,
9366 union iwreq_data *wrqu, char *extra)
9368 struct ipw_priv *priv = ieee80211_priv(dev);
9369 IPW_DEBUG_WX("RESET\n");
9370 queue_work(priv->workqueue, &priv->adapter_restart);
9374 static int ipw_wx_sw_reset(struct net_device *dev,
9375 struct iw_request_info *info,
9376 union iwreq_data *wrqu, char *extra)
9378 struct ipw_priv *priv = ieee80211_priv(dev);
9379 union iwreq_data wrqu_sec = {
9381 .flags = IW_ENCODE_DISABLED,
9386 IPW_DEBUG_WX("SW_RESET\n");
9388 mutex_lock(&priv->mutex);
9390 ret = ipw_sw_reset(priv, 2);
9393 ipw_adapter_restart(priv);
9396 /* The SW reset bit might have been toggled on by the 'disable'
9397 * module parameter, so take appropriate action */
9398 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9400 mutex_unlock(&priv->mutex);
9401 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9402 mutex_lock(&priv->mutex);
9404 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9405 /* Configuration likely changed -- force [re]association */
9406 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9408 if (!ipw_disassociate(priv))
9409 ipw_associate(priv);
9412 mutex_unlock(&priv->mutex);
9417 /* Rebase the WE IOCTLs to zero for the handler array */
9418 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9419 static iw_handler ipw_wx_handlers[] = {
9420 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9421 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9422 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9423 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9424 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9425 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9426 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9427 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9428 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9429 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9430 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9431 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9432 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9433 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9434 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9435 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9436 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9437 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9438 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9439 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9440 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9441 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9442 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9443 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9444 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9445 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9446 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9447 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9448 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9449 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9450 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9451 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9452 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9453 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9454 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9455 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9456 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9457 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9458 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9462 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9466 IPW_PRIV_SET_PREAMBLE,
9467 IPW_PRIV_GET_PREAMBLE,
9470 #ifdef CONFIG_IPW2200_MONITOR
9471 IPW_PRIV_SET_MONITOR,
9475 static struct iw_priv_args ipw_priv_args[] = {
9477 .cmd = IPW_PRIV_SET_POWER,
9478 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9479 .name = "set_power"},
9481 .cmd = IPW_PRIV_GET_POWER,
9482 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9483 .name = "get_power"},
9485 .cmd = IPW_PRIV_SET_MODE,
9486 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9487 .name = "set_mode"},
9489 .cmd = IPW_PRIV_GET_MODE,
9490 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9491 .name = "get_mode"},
9493 .cmd = IPW_PRIV_SET_PREAMBLE,
9494 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9495 .name = "set_preamble"},
9497 .cmd = IPW_PRIV_GET_PREAMBLE,
9498 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9499 .name = "get_preamble"},
9502 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9505 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9506 #ifdef CONFIG_IPW2200_MONITOR
9508 IPW_PRIV_SET_MONITOR,
9509 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9510 #endif /* CONFIG_IPW2200_MONITOR */
9513 static iw_handler ipw_priv_handler[] = {
9514 ipw_wx_set_powermode,
9515 ipw_wx_get_powermode,
9516 ipw_wx_set_wireless_mode,
9517 ipw_wx_get_wireless_mode,
9518 ipw_wx_set_preamble,
9519 ipw_wx_get_preamble,
9522 #ifdef CONFIG_IPW2200_MONITOR
9527 static struct iw_handler_def ipw_wx_handler_def = {
9528 .standard = ipw_wx_handlers,
9529 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9530 .num_private = ARRAY_SIZE(ipw_priv_handler),
9531 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9532 .private = ipw_priv_handler,
9533 .private_args = ipw_priv_args,
9534 .get_wireless_stats = ipw_get_wireless_stats,
9538 * Get wireless statistics.
9539 * Called by /proc/net/wireless
9540 * Also called by SIOCGIWSTATS
9542 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9544 struct ipw_priv *priv = ieee80211_priv(dev);
9545 struct iw_statistics *wstats;
9547 wstats = &priv->wstats;
9549 /* if hw is disabled, then ipw_get_ordinal() can't be called.
9550 * netdev->get_wireless_stats seems to be called before fw is
9551 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9552 * and associated; if not associcated, the values are all meaningless
9553 * anyway, so set them all to NULL and INVALID */
9554 if (!(priv->status & STATUS_ASSOCIATED)) {
9555 wstats->miss.beacon = 0;
9556 wstats->discard.retries = 0;
9557 wstats->qual.qual = 0;
9558 wstats->qual.level = 0;
9559 wstats->qual.noise = 0;
9560 wstats->qual.updated = 7;
9561 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9562 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9566 wstats->qual.qual = priv->quality;
9567 wstats->qual.level = average_value(&priv->average_rssi);
9568 wstats->qual.noise = average_value(&priv->average_noise);
9569 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9570 IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
9572 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9573 wstats->discard.retries = priv->last_tx_failures;
9574 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9576 /* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9577 goto fail_get_ordinal;
9578 wstats->discard.retries += tx_retry; */
9583 /* net device stuff */
9585 static void init_sys_config(struct ipw_sys_config *sys_config)
9587 memset(sys_config, 0, sizeof(struct ipw_sys_config));
9588 sys_config->bt_coexistence = 0;
9589 sys_config->answer_broadcast_ssid_probe = 0;
9590 sys_config->accept_all_data_frames = 0;
9591 sys_config->accept_non_directed_frames = 1;
9592 sys_config->exclude_unicast_unencrypted = 0;
9593 sys_config->disable_unicast_decryption = 1;
9594 sys_config->exclude_multicast_unencrypted = 0;
9595 sys_config->disable_multicast_decryption = 1;
9596 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
9597 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
9598 sys_config->dot11g_auto_detection = 0;
9599 sys_config->enable_cts_to_self = 0;
9600 sys_config->bt_coexist_collision_thr = 0;
9601 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
9604 static int ipw_net_open(struct net_device *dev)
9606 struct ipw_priv *priv = ieee80211_priv(dev);
9607 IPW_DEBUG_INFO("dev->open\n");
9608 /* we should be verifying the device is ready to be opened */
9609 mutex_lock(&priv->mutex);
9610 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9611 (priv->status & STATUS_ASSOCIATED))
9612 netif_start_queue(dev);
9613 mutex_unlock(&priv->mutex);
9617 static int ipw_net_stop(struct net_device *dev)
9619 IPW_DEBUG_INFO("dev->close\n");
9620 netif_stop_queue(dev);
9627 modify to send one tfd per fragment instead of using chunking. otherwise
9628 we need to heavily modify the ieee80211_skb_to_txb.
9631 static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9634 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9635 txb->fragments[0]->data;
9637 struct tfd_frame *tfd;
9638 #ifdef CONFIG_IPW_QOS
9639 int tx_id = ipw_get_tx_queue_number(priv, pri);
9640 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9642 struct clx2_tx_queue *txq = &priv->txq[0];
9644 struct clx2_queue *q = &txq->q;
9645 u8 id, hdr_len, unicast;
9646 u16 remaining_bytes;
9649 switch (priv->ieee->iw_mode) {
9651 hdr_len = IEEE80211_3ADDR_LEN;
9652 unicast = !is_multicast_ether_addr(hdr->addr1);
9653 id = ipw_find_station(priv, hdr->addr1);
9654 if (id == IPW_INVALID_STATION) {
9655 id = ipw_add_station(priv, hdr->addr1);
9656 if (id == IPW_INVALID_STATION) {
9657 IPW_WARNING("Attempt to send data to "
9658 "invalid cell: " MAC_FMT "\n",
9659 MAC_ARG(hdr->addr1));
9667 unicast = !is_multicast_ether_addr(hdr->addr3);
9668 hdr_len = IEEE80211_3ADDR_LEN;
9673 tfd = &txq->bd[q->first_empty];
9674 txq->txb[q->first_empty] = txb;
9675 memset(tfd, 0, sizeof(*tfd));
9676 tfd->u.data.station_number = id;
9678 tfd->control_flags.message_type = TX_FRAME_TYPE;
9679 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9681 tfd->u.data.cmd_id = DINO_CMD_TX;
9682 tfd->u.data.len = cpu_to_le16(txb->payload_size);
9683 remaining_bytes = txb->payload_size;
9685 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9686 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9688 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9690 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9691 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9693 fc = le16_to_cpu(hdr->frame_ctl);
9694 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9696 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9698 if (likely(unicast))
9699 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9701 if (txb->encrypted && !priv->ieee->host_encrypt) {
9702 switch (priv->ieee->sec.level) {
9704 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9705 IEEE80211_FCTL_PROTECTED;
9706 /* XXX: ACK flag must be set for CCMP even if it
9707 * is a multicast/broadcast packet, because CCMP
9708 * group communication encrypted by GTK is
9709 * actually done by the AP. */
9711 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9713 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9714 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9715 tfd->u.data.key_index = 0;
9716 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9719 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9720 IEEE80211_FCTL_PROTECTED;
9721 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9722 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9723 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9726 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9727 IEEE80211_FCTL_PROTECTED;
9728 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9729 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9731 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9733 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9738 printk(KERN_ERR "Unknow security level %d\n",
9739 priv->ieee->sec.level);
9743 /* No hardware encryption */
9744 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9746 #ifdef CONFIG_IPW_QOS
9747 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9748 #endif /* CONFIG_IPW_QOS */
9751 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9753 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9754 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9755 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9756 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9757 i, le32_to_cpu(tfd->u.data.num_chunks),
9758 txb->fragments[i]->len - hdr_len);
9759 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9760 i, tfd->u.data.num_chunks,
9761 txb->fragments[i]->len - hdr_len);
9762 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9763 txb->fragments[i]->len - hdr_len);
9765 tfd->u.data.chunk_ptr[i] =
9766 cpu_to_le32(pci_map_single
9768 txb->fragments[i]->data + hdr_len,
9769 txb->fragments[i]->len - hdr_len,
9771 tfd->u.data.chunk_len[i] =
9772 cpu_to_le16(txb->fragments[i]->len - hdr_len);
9775 if (i != txb->nr_frags) {
9776 struct sk_buff *skb;
9777 u16 remaining_bytes = 0;
9780 for (j = i; j < txb->nr_frags; j++)
9781 remaining_bytes += txb->fragments[j]->len - hdr_len;
9783 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9785 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9787 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9788 for (j = i; j < txb->nr_frags; j++) {
9789 int size = txb->fragments[j]->len - hdr_len;
9791 printk(KERN_INFO "Adding frag %d %d...\n",
9793 memcpy(skb_put(skb, size),
9794 txb->fragments[j]->data + hdr_len, size);
9796 dev_kfree_skb_any(txb->fragments[i]);
9797 txb->fragments[i] = skb;
9798 tfd->u.data.chunk_ptr[i] =
9799 cpu_to_le32(pci_map_single
9800 (priv->pci_dev, skb->data,
9801 tfd->u.data.chunk_len[i],
9804 tfd->u.data.num_chunks =
9805 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9811 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9812 ipw_write32(priv, q->reg_w, q->first_empty);
9814 if (ipw_queue_space(q) < q->high_mark)
9815 netif_stop_queue(priv->net_dev);
9817 return NETDEV_TX_OK;
9820 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9821 ieee80211_txb_free(txb);
9822 return NETDEV_TX_OK;
9825 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9827 struct ipw_priv *priv = ieee80211_priv(dev);
9828 #ifdef CONFIG_IPW_QOS
9829 int tx_id = ipw_get_tx_queue_number(priv, pri);
9830 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9832 struct clx2_tx_queue *txq = &priv->txq[0];
9833 #endif /* CONFIG_IPW_QOS */
9835 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9841 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9842 struct net_device *dev, int pri)
9844 struct ipw_priv *priv = ieee80211_priv(dev);
9845 unsigned long flags;
9848 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9849 spin_lock_irqsave(&priv->lock, flags);
9851 if (!(priv->status & STATUS_ASSOCIATED)) {
9852 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9853 priv->ieee->stats.tx_carrier_errors++;
9854 netif_stop_queue(dev);
9858 ret = ipw_tx_skb(priv, txb, pri);
9859 if (ret == NETDEV_TX_OK)
9860 __ipw_led_activity_on(priv);
9861 spin_unlock_irqrestore(&priv->lock, flags);
9866 spin_unlock_irqrestore(&priv->lock, flags);
9870 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9872 struct ipw_priv *priv = ieee80211_priv(dev);
9874 priv->ieee->stats.tx_packets = priv->tx_packets;
9875 priv->ieee->stats.rx_packets = priv->rx_packets;
9876 return &priv->ieee->stats;
9879 static void ipw_net_set_multicast_list(struct net_device *dev)
9884 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9886 struct ipw_priv *priv = ieee80211_priv(dev);
9887 struct sockaddr *addr = p;
9888 if (!is_valid_ether_addr(addr->sa_data))
9889 return -EADDRNOTAVAIL;
9890 mutex_lock(&priv->mutex);
9891 priv->config |= CFG_CUSTOM_MAC;
9892 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9893 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9894 priv->net_dev->name, MAC_ARG(priv->mac_addr));
9895 queue_work(priv->workqueue, &priv->adapter_restart);
9896 mutex_unlock(&priv->mutex);
9900 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9901 struct ethtool_drvinfo *info)
9903 struct ipw_priv *p = ieee80211_priv(dev);
9908 strcpy(info->driver, DRV_NAME);
9909 strcpy(info->version, DRV_VERSION);
9912 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9914 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9916 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9918 strcpy(info->bus_info, pci_name(p->pci_dev));
9919 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9922 static u32 ipw_ethtool_get_link(struct net_device *dev)
9924 struct ipw_priv *priv = ieee80211_priv(dev);
9925 return (priv->status & STATUS_ASSOCIATED) != 0;
9928 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9930 return IPW_EEPROM_IMAGE_SIZE;
9933 static int ipw_ethtool_get_eeprom(struct net_device *dev,
9934 struct ethtool_eeprom *eeprom, u8 * bytes)
9936 struct ipw_priv *p = ieee80211_priv(dev);
9938 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9940 mutex_lock(&p->mutex);
9941 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9942 mutex_unlock(&p->mutex);
9946 static int ipw_ethtool_set_eeprom(struct net_device *dev,
9947 struct ethtool_eeprom *eeprom, u8 * bytes)
9949 struct ipw_priv *p = ieee80211_priv(dev);
9952 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9954 mutex_lock(&p->mutex);
9955 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
9956 for (i = IPW_EEPROM_DATA;
9957 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
9958 ipw_write8(p, i, p->eeprom[i]);
9959 mutex_unlock(&p->mutex);
9963 static struct ethtool_ops ipw_ethtool_ops = {
9964 .get_link = ipw_ethtool_get_link,
9965 .get_drvinfo = ipw_ethtool_get_drvinfo,
9966 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9967 .get_eeprom = ipw_ethtool_get_eeprom,
9968 .set_eeprom = ipw_ethtool_set_eeprom,
9971 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9973 struct ipw_priv *priv = data;
9974 u32 inta, inta_mask;
9979 spin_lock(&priv->lock);
9981 if (!(priv->status & STATUS_INT_ENABLED)) {
9986 inta = ipw_read32(priv, IPW_INTA_RW);
9987 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
9989 if (inta == 0xFFFFFFFF) {
9990 /* Hardware disappeared */
9991 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
9995 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
9996 /* Shared interrupt */
10000 /* tell the device to stop sending interrupts */
10001 ipw_disable_interrupts(priv);
10003 /* ack current interrupts */
10004 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10005 ipw_write32(priv, IPW_INTA_RW, inta);
10007 /* Cache INTA value for our tasklet */
10008 priv->isr_inta = inta;
10010 tasklet_schedule(&priv->irq_tasklet);
10012 spin_unlock(&priv->lock);
10014 return IRQ_HANDLED;
10016 spin_unlock(&priv->lock);
10020 static void ipw_rf_kill(void *adapter)
10022 struct ipw_priv *priv = adapter;
10023 unsigned long flags;
10025 spin_lock_irqsave(&priv->lock, flags);
10027 if (rf_kill_active(priv)) {
10028 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10029 if (priv->workqueue)
10030 queue_delayed_work(priv->workqueue,
10031 &priv->rf_kill, 2 * HZ);
10035 /* RF Kill is now disabled, so bring the device back up */
10037 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10038 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10041 /* we can not do an adapter restart while inside an irq lock */
10042 queue_work(priv->workqueue, &priv->adapter_restart);
10044 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10048 spin_unlock_irqrestore(&priv->lock, flags);
10051 static void ipw_bg_rf_kill(void *data)
10053 struct ipw_priv *priv = data;
10054 mutex_lock(&priv->mutex);
10056 mutex_unlock(&priv->mutex);
10059 static void ipw_link_up(struct ipw_priv *priv)
10061 priv->last_seq_num = -1;
10062 priv->last_frag_num = -1;
10063 priv->last_packet_time = 0;
10065 netif_carrier_on(priv->net_dev);
10066 if (netif_queue_stopped(priv->net_dev)) {
10067 IPW_DEBUG_NOTIF("waking queue\n");
10068 netif_wake_queue(priv->net_dev);
10070 IPW_DEBUG_NOTIF("starting queue\n");
10071 netif_start_queue(priv->net_dev);
10074 cancel_delayed_work(&priv->request_scan);
10075 ipw_reset_stats(priv);
10076 /* Ensure the rate is updated immediately */
10077 priv->last_rate = ipw_get_current_rate(priv);
10078 ipw_gather_stats(priv);
10079 ipw_led_link_up(priv);
10080 notify_wx_assoc_event(priv);
10082 if (priv->config & CFG_BACKGROUND_SCAN)
10083 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10086 static void ipw_bg_link_up(void *data)
10088 struct ipw_priv *priv = data;
10089 mutex_lock(&priv->mutex);
10091 mutex_unlock(&priv->mutex);
10094 static void ipw_link_down(struct ipw_priv *priv)
10096 ipw_led_link_down(priv);
10097 netif_carrier_off(priv->net_dev);
10098 netif_stop_queue(priv->net_dev);
10099 notify_wx_assoc_event(priv);
10101 /* Cancel any queued work ... */
10102 cancel_delayed_work(&priv->request_scan);
10103 cancel_delayed_work(&priv->adhoc_check);
10104 cancel_delayed_work(&priv->gather_stats);
10106 ipw_reset_stats(priv);
10108 if (!(priv->status & STATUS_EXIT_PENDING)) {
10109 /* Queue up another scan... */
10110 queue_work(priv->workqueue, &priv->request_scan);
10114 static void ipw_bg_link_down(void *data)
10116 struct ipw_priv *priv = data;
10117 mutex_lock(&priv->mutex);
10118 ipw_link_down(data);
10119 mutex_unlock(&priv->mutex);
10122 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10126 priv->workqueue = create_workqueue(DRV_NAME);
10127 init_waitqueue_head(&priv->wait_command_queue);
10128 init_waitqueue_head(&priv->wait_state);
10130 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10131 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10132 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10133 INIT_WORK(&priv->system_config, ipw_system_config, priv);
10134 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10135 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10136 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10137 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10138 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10139 INIT_WORK(&priv->request_scan,
10140 (void (*)(void *))ipw_request_scan, priv);
10141 INIT_WORK(&priv->gather_stats,
10142 (void (*)(void *))ipw_bg_gather_stats, priv);
10143 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10144 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10145 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10146 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10147 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10148 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10150 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10152 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10154 INIT_WORK(&priv->merge_networks,
10155 (void (*)(void *))ipw_merge_adhoc_network, priv);
10157 #ifdef CONFIG_IPW_QOS
10158 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10160 #endif /* CONFIG_IPW_QOS */
10162 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10163 ipw_irq_tasklet, (unsigned long)priv);
10168 static void shim__set_security(struct net_device *dev,
10169 struct ieee80211_security *sec)
10171 struct ipw_priv *priv = ieee80211_priv(dev);
10173 for (i = 0; i < 4; i++) {
10174 if (sec->flags & (1 << i)) {
10175 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10176 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10177 if (sec->key_sizes[i] == 0)
10178 priv->ieee->sec.flags &= ~(1 << i);
10180 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10181 sec->key_sizes[i]);
10182 priv->ieee->sec.flags |= (1 << i);
10184 priv->status |= STATUS_SECURITY_UPDATED;
10185 } else if (sec->level != SEC_LEVEL_1)
10186 priv->ieee->sec.flags &= ~(1 << i);
10189 if (sec->flags & SEC_ACTIVE_KEY) {
10190 if (sec->active_key <= 3) {
10191 priv->ieee->sec.active_key = sec->active_key;
10192 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10194 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10195 priv->status |= STATUS_SECURITY_UPDATED;
10197 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10199 if ((sec->flags & SEC_AUTH_MODE) &&
10200 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10201 priv->ieee->sec.auth_mode = sec->auth_mode;
10202 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10203 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10204 priv->capability |= CAP_SHARED_KEY;
10206 priv->capability &= ~CAP_SHARED_KEY;
10207 priv->status |= STATUS_SECURITY_UPDATED;
10210 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10211 priv->ieee->sec.flags |= SEC_ENABLED;
10212 priv->ieee->sec.enabled = sec->enabled;
10213 priv->status |= STATUS_SECURITY_UPDATED;
10215 priv->capability |= CAP_PRIVACY_ON;
10217 priv->capability &= ~CAP_PRIVACY_ON;
10220 if (sec->flags & SEC_ENCRYPT)
10221 priv->ieee->sec.encrypt = sec->encrypt;
10223 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10224 priv->ieee->sec.level = sec->level;
10225 priv->ieee->sec.flags |= SEC_LEVEL;
10226 priv->status |= STATUS_SECURITY_UPDATED;
10229 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10230 ipw_set_hwcrypto_keys(priv);
10232 /* To match current functionality of ipw2100 (which works well w/
10233 * various supplicants, we don't force a disassociate if the
10234 * privacy capability changes ... */
10236 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10237 (((priv->assoc_request.capability &
10238 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10239 (!(priv->assoc_request.capability &
10240 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10241 IPW_DEBUG_ASSOC("Disassociating due to capability "
10243 ipw_disassociate(priv);
10248 static int init_supported_rates(struct ipw_priv *priv,
10249 struct ipw_supported_rates *rates)
10251 /* TODO: Mask out rates based on priv->rates_mask */
10253 memset(rates, 0, sizeof(*rates));
10254 /* configure supported rates */
10255 switch (priv->ieee->freq_band) {
10256 case IEEE80211_52GHZ_BAND:
10257 rates->ieee_mode = IPW_A_MODE;
10258 rates->purpose = IPW_RATE_CAPABILITIES;
10259 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10260 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10263 default: /* Mixed or 2.4Ghz */
10264 rates->ieee_mode = IPW_G_MODE;
10265 rates->purpose = IPW_RATE_CAPABILITIES;
10266 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10267 IEEE80211_CCK_DEFAULT_RATES_MASK);
10268 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10269 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10270 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10278 static int ipw_config(struct ipw_priv *priv)
10280 /* This is only called from ipw_up, which resets/reloads the firmware
10281 so, we don't need to first disable the card before we configure
10283 if (ipw_set_tx_power(priv))
10286 /* initialize adapter address */
10287 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10290 /* set basic system config settings */
10291 init_sys_config(&priv->sys_config);
10293 /* Support Bluetooth if we have BT h/w on board, and user wants to.
10294 * Does not support BT priority yet (don't abort or defer our Tx) */
10296 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10298 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10299 priv->sys_config.bt_coexistence
10300 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
10301 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10302 priv->sys_config.bt_coexistence
10303 |= CFG_BT_COEXISTENCE_OOB;
10306 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10307 priv->sys_config.answer_broadcast_ssid_probe = 1;
10309 priv->sys_config.answer_broadcast_ssid_probe = 0;
10311 if (ipw_send_system_config(priv, &priv->sys_config))
10314 init_supported_rates(priv, &priv->rates);
10315 if (ipw_send_supported_rates(priv, &priv->rates))
10318 /* Set request-to-send threshold */
10319 if (priv->rts_threshold) {
10320 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10323 #ifdef CONFIG_IPW_QOS
10324 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10325 ipw_qos_activate(priv, NULL);
10326 #endif /* CONFIG_IPW_QOS */
10328 if (ipw_set_random_seed(priv))
10331 /* final state transition to the RUN state */
10332 if (ipw_send_host_complete(priv))
10335 priv->status |= STATUS_INIT;
10337 ipw_led_init(priv);
10338 ipw_led_radio_on(priv);
10339 priv->notif_missed_beacons = 0;
10341 /* Set hardware WEP key if it is configured. */
10342 if ((priv->capability & CAP_PRIVACY_ON) &&
10343 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10344 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10345 ipw_set_hwcrypto_keys(priv);
10356 * These tables have been tested in conjunction with the
10357 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10359 * Altering this values, using it on other hardware, or in geographies
10360 * not intended for resale of the above mentioned Intel adapters has
10363 * Remember to update the table in README.ipw2200 when changing this
10367 static const struct ieee80211_geo ipw_geos[] = {
10371 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10372 {2427, 4}, {2432, 5}, {2437, 6},
10373 {2442, 7}, {2447, 8}, {2452, 9},
10374 {2457, 10}, {2462, 11}},
10377 { /* Custom US/Canada */
10380 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10381 {2427, 4}, {2432, 5}, {2437, 6},
10382 {2442, 7}, {2447, 8}, {2452, 9},
10383 {2457, 10}, {2462, 11}},
10389 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10390 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10391 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10392 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10395 { /* Rest of World */
10398 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10399 {2427, 4}, {2432, 5}, {2437, 6},
10400 {2442, 7}, {2447, 8}, {2452, 9},
10401 {2457, 10}, {2462, 11}, {2467, 12},
10405 { /* Custom USA & Europe & High */
10408 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10409 {2427, 4}, {2432, 5}, {2437, 6},
10410 {2442, 7}, {2447, 8}, {2452, 9},
10411 {2457, 10}, {2462, 11}},
10417 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10418 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10419 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10420 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10428 { /* Custom NA & Europe */
10431 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10432 {2427, 4}, {2432, 5}, {2437, 6},
10433 {2442, 7}, {2447, 8}, {2452, 9},
10434 {2457, 10}, {2462, 11}},
10440 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10441 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10442 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10443 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10444 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10445 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10446 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10447 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10448 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10451 { /* Custom Japan */
10454 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10455 {2427, 4}, {2432, 5}, {2437, 6},
10456 {2442, 7}, {2447, 8}, {2452, 9},
10457 {2457, 10}, {2462, 11}},
10459 .a = {{5170, 34}, {5190, 38},
10460 {5210, 42}, {5230, 46}},
10466 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10467 {2427, 4}, {2432, 5}, {2437, 6},
10468 {2442, 7}, {2447, 8}, {2452, 9},
10469 {2457, 10}, {2462, 11}},
10475 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10476 {2427, 4}, {2432, 5}, {2437, 6},
10477 {2442, 7}, {2447, 8}, {2452, 9},
10478 {2457, 10}, {2462, 11}, {2467, 12},
10485 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10486 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10487 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10488 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10489 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10490 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10491 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10492 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10493 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10494 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10495 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10496 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10497 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10498 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10499 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10502 { /* Custom Japan */
10505 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10506 {2427, 4}, {2432, 5}, {2437, 6},
10507 {2442, 7}, {2447, 8}, {2452, 9},
10508 {2457, 10}, {2462, 11}, {2467, 12},
10509 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10511 .a = {{5170, 34}, {5190, 38},
10512 {5210, 42}, {5230, 46}},
10515 { /* Rest of World */
10518 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10519 {2427, 4}, {2432, 5}, {2437, 6},
10520 {2442, 7}, {2447, 8}, {2452, 9},
10521 {2457, 10}, {2462, 11}, {2467, 12},
10522 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10523 IEEE80211_CH_PASSIVE_ONLY}},
10529 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10530 {2427, 4}, {2432, 5}, {2437, 6},
10531 {2442, 7}, {2447, 8}, {2452, 9},
10532 {2457, 10}, {2462, 11},
10533 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10534 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10536 .a = {{5745, 149}, {5765, 153},
10537 {5785, 157}, {5805, 161}},
10540 { /* Custom Europe */
10543 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10544 {2427, 4}, {2432, 5}, {2437, 6},
10545 {2442, 7}, {2447, 8}, {2452, 9},
10546 {2457, 10}, {2462, 11},
10547 {2467, 12}, {2472, 13}},
10549 .a = {{5180, 36}, {5200, 40},
10550 {5220, 44}, {5240, 48}},
10556 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10557 {2427, 4}, {2432, 5}, {2437, 6},
10558 {2442, 7}, {2447, 8}, {2452, 9},
10559 {2457, 10}, {2462, 11},
10560 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10561 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10563 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10564 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10565 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10566 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10567 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10568 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10569 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10570 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10571 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10572 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10573 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10574 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10575 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10576 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10577 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10578 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10579 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10580 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10581 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10582 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10583 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10584 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10585 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10586 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10592 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10593 {2427, 4}, {2432, 5}, {2437, 6},
10594 {2442, 7}, {2447, 8}, {2452, 9},
10595 {2457, 10}, {2462, 11}},
10597 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10598 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10599 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10600 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10601 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10602 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10603 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10604 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10605 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10606 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10607 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10608 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10609 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10613 #define MAX_HW_RESTARTS 5
10614 static int ipw_up(struct ipw_priv *priv)
10618 if (priv->status & STATUS_EXIT_PENDING)
10621 if (cmdlog && !priv->cmdlog) {
10622 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10624 if (priv->cmdlog == NULL) {
10625 IPW_ERROR("Error allocating %d command log entries.\n",
10628 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10629 priv->cmdlog_len = cmdlog;
10633 for (i = 0; i < MAX_HW_RESTARTS; i++) {
10634 /* Load the microcode, firmware, and eeprom.
10635 * Also start the clocks. */
10636 rc = ipw_load(priv);
10638 IPW_ERROR("Unable to load firmware: %d\n", rc);
10642 ipw_init_ordinals(priv);
10643 if (!(priv->config & CFG_CUSTOM_MAC))
10644 eeprom_parse_mac(priv, priv->mac_addr);
10645 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10647 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10648 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10649 ipw_geos[j].name, 3))
10652 if (j == ARRAY_SIZE(ipw_geos)) {
10653 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10654 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10655 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10656 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10659 if (ieee80211_set_geo(priv->ieee, &ipw_geos[j])) {
10660 IPW_WARNING("Could not set geography.");
10664 if (priv->status & STATUS_RF_KILL_SW) {
10665 IPW_WARNING("Radio disabled by module parameter.\n");
10667 } else if (rf_kill_active(priv)) {
10668 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10669 "Kill switch must be turned off for "
10670 "wireless networking to work.\n");
10671 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10676 rc = ipw_config(priv);
10678 IPW_DEBUG_INFO("Configured device on count %i\n", i);
10680 /* If configure to try and auto-associate, kick
10682 queue_work(priv->workqueue, &priv->request_scan);
10687 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10688 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10689 i, MAX_HW_RESTARTS);
10691 /* We had an error bringing up the hardware, so take it
10692 * all the way back down so we can try again */
10696 /* tried to restart and config the device for as long as our
10697 * patience could withstand */
10698 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10703 static void ipw_bg_up(void *data)
10705 struct ipw_priv *priv = data;
10706 mutex_lock(&priv->mutex);
10708 mutex_unlock(&priv->mutex);
10711 static void ipw_deinit(struct ipw_priv *priv)
10715 if (priv->status & STATUS_SCANNING) {
10716 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10717 ipw_abort_scan(priv);
10720 if (priv->status & STATUS_ASSOCIATED) {
10721 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10722 ipw_disassociate(priv);
10725 ipw_led_shutdown(priv);
10727 /* Wait up to 1s for status to change to not scanning and not
10728 * associated (disassociation can take a while for a ful 802.11
10730 for (i = 1000; i && (priv->status &
10731 (STATUS_DISASSOCIATING |
10732 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10735 if (priv->status & (STATUS_DISASSOCIATING |
10736 STATUS_ASSOCIATED | STATUS_SCANNING))
10737 IPW_DEBUG_INFO("Still associated or scanning...\n");
10739 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10741 /* Attempt to disable the card */
10742 ipw_send_card_disable(priv, 0);
10744 priv->status &= ~STATUS_INIT;
10747 static void ipw_down(struct ipw_priv *priv)
10749 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10751 priv->status |= STATUS_EXIT_PENDING;
10753 if (ipw_is_init(priv))
10756 /* Wipe out the EXIT_PENDING status bit if we are not actually
10757 * exiting the module */
10759 priv->status &= ~STATUS_EXIT_PENDING;
10761 /* tell the device to stop sending interrupts */
10762 ipw_disable_interrupts(priv);
10764 /* Clear all bits but the RF Kill */
10765 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10766 netif_carrier_off(priv->net_dev);
10767 netif_stop_queue(priv->net_dev);
10769 ipw_stop_nic(priv);
10771 ipw_led_radio_off(priv);
10774 static void ipw_bg_down(void *data)
10776 struct ipw_priv *priv = data;
10777 mutex_lock(&priv->mutex);
10779 mutex_unlock(&priv->mutex);
10782 /* Called by register_netdev() */
10783 static int ipw_net_init(struct net_device *dev)
10785 struct ipw_priv *priv = ieee80211_priv(dev);
10786 mutex_lock(&priv->mutex);
10788 if (ipw_up(priv)) {
10789 mutex_unlock(&priv->mutex);
10793 mutex_unlock(&priv->mutex);
10797 /* PCI driver stuff */
10798 static struct pci_device_id card_ids[] = {
10799 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10800 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10801 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10802 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10803 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10804 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10805 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10806 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10807 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10808 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10809 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10810 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10811 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10812 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10813 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10814 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10815 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10816 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10817 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10818 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10819 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10820 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10822 /* required last entry */
10826 MODULE_DEVICE_TABLE(pci, card_ids);
10828 static struct attribute *ipw_sysfs_entries[] = {
10829 &dev_attr_rf_kill.attr,
10830 &dev_attr_direct_dword.attr,
10831 &dev_attr_indirect_byte.attr,
10832 &dev_attr_indirect_dword.attr,
10833 &dev_attr_mem_gpio_reg.attr,
10834 &dev_attr_command_event_reg.attr,
10835 &dev_attr_nic_type.attr,
10836 &dev_attr_status.attr,
10837 &dev_attr_cfg.attr,
10838 &dev_attr_error.attr,
10839 &dev_attr_event_log.attr,
10840 &dev_attr_cmd_log.attr,
10841 &dev_attr_eeprom_delay.attr,
10842 &dev_attr_ucode_version.attr,
10843 &dev_attr_rtc.attr,
10844 &dev_attr_scan_age.attr,
10845 &dev_attr_led.attr,
10846 &dev_attr_speed_scan.attr,
10847 &dev_attr_net_stats.attr,
10851 static struct attribute_group ipw_attribute_group = {
10852 .name = NULL, /* put in device directory */
10853 .attrs = ipw_sysfs_entries,
10856 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
10859 struct net_device *net_dev;
10860 void __iomem *base;
10862 struct ipw_priv *priv;
10865 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10866 if (net_dev == NULL) {
10871 priv = ieee80211_priv(net_dev);
10872 priv->ieee = netdev_priv(net_dev);
10874 priv->net_dev = net_dev;
10875 priv->pci_dev = pdev;
10876 #ifdef CONFIG_IPW2200_DEBUG
10877 ipw_debug_level = debug;
10879 spin_lock_init(&priv->lock);
10880 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10881 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
10883 mutex_init(&priv->mutex);
10884 if (pci_enable_device(pdev)) {
10886 goto out_free_ieee80211;
10889 pci_set_master(pdev);
10891 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
10893 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
10895 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10896 goto out_pci_disable_device;
10899 pci_set_drvdata(pdev, priv);
10901 err = pci_request_regions(pdev, DRV_NAME);
10903 goto out_pci_disable_device;
10905 /* We disable the RETRY_TIMEOUT register (0x41) to keep
10906 * PCI Tx retries from interfering with C3 CPU state */
10907 pci_read_config_dword(pdev, 0x40, &val);
10908 if ((val & 0x0000ff00) != 0)
10909 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
10911 length = pci_resource_len(pdev, 0);
10912 priv->hw_len = length;
10914 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10917 goto out_pci_release_regions;
10920 priv->hw_base = base;
10921 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
10922 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
10924 err = ipw_setup_deferred_work(priv);
10926 IPW_ERROR("Unable to setup deferred work\n");
10930 ipw_sw_reset(priv, 1);
10932 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
10934 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
10935 goto out_destroy_workqueue;
10938 SET_MODULE_OWNER(net_dev);
10939 SET_NETDEV_DEV(net_dev, &pdev->dev);
10941 mutex_lock(&priv->mutex);
10943 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
10944 priv->ieee->set_security = shim__set_security;
10945 priv->ieee->is_queue_full = ipw_net_is_queue_full;
10947 #ifdef CONFIG_IPW_QOS
10948 priv->ieee->handle_probe_response = ipw_handle_beacon;
10949 priv->ieee->handle_beacon = ipw_handle_probe_response;
10950 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
10951 #endif /* CONFIG_IPW_QOS */
10953 priv->ieee->perfect_rssi = -20;
10954 priv->ieee->worst_rssi = -85;
10956 net_dev->open = ipw_net_open;
10957 net_dev->stop = ipw_net_stop;
10958 net_dev->init = ipw_net_init;
10959 net_dev->get_stats = ipw_net_get_stats;
10960 net_dev->set_multicast_list = ipw_net_set_multicast_list;
10961 net_dev->set_mac_address = ipw_net_set_mac_address;
10962 priv->wireless_data.spy_data = &priv->ieee->spy_data;
10963 net_dev->wireless_data = &priv->wireless_data;
10964 net_dev->wireless_handlers = &ipw_wx_handler_def;
10965 net_dev->ethtool_ops = &ipw_ethtool_ops;
10966 net_dev->irq = pdev->irq;
10967 net_dev->base_addr = (unsigned long)priv->hw_base;
10968 net_dev->mem_start = pci_resource_start(pdev, 0);
10969 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
10971 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
10973 IPW_ERROR("failed to create sysfs device attributes\n");
10974 mutex_unlock(&priv->mutex);
10975 goto out_release_irq;
10978 mutex_unlock(&priv->mutex);
10979 err = register_netdev(net_dev);
10981 IPW_ERROR("failed to register network device\n");
10982 goto out_remove_sysfs;
10985 printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
10986 "channels, %d 802.11a channels)\n",
10987 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
10988 priv->ieee->geo.a_channels);
10993 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
10995 free_irq(pdev->irq, priv);
10996 out_destroy_workqueue:
10997 destroy_workqueue(priv->workqueue);
10998 priv->workqueue = NULL;
11000 iounmap(priv->hw_base);
11001 out_pci_release_regions:
11002 pci_release_regions(pdev);
11003 out_pci_disable_device:
11004 pci_disable_device(pdev);
11005 pci_set_drvdata(pdev, NULL);
11006 out_free_ieee80211:
11007 free_ieee80211(priv->net_dev);
11012 static void ipw_pci_remove(struct pci_dev *pdev)
11014 struct ipw_priv *priv = pci_get_drvdata(pdev);
11015 struct list_head *p, *q;
11021 mutex_lock(&priv->mutex);
11023 priv->status |= STATUS_EXIT_PENDING;
11025 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11027 mutex_unlock(&priv->mutex);
11029 unregister_netdev(priv->net_dev);
11032 ipw_rx_queue_free(priv, priv->rxq);
11035 ipw_tx_queue_free(priv);
11037 if (priv->cmdlog) {
11038 kfree(priv->cmdlog);
11039 priv->cmdlog = NULL;
11041 /* ipw_down will ensure that there is no more pending work
11042 * in the workqueue's, so we can safely remove them now. */
11043 cancel_delayed_work(&priv->adhoc_check);
11044 cancel_delayed_work(&priv->gather_stats);
11045 cancel_delayed_work(&priv->request_scan);
11046 cancel_delayed_work(&priv->rf_kill);
11047 cancel_delayed_work(&priv->scan_check);
11048 destroy_workqueue(priv->workqueue);
11049 priv->workqueue = NULL;
11051 /* Free MAC hash list for ADHOC */
11052 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11053 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11055 kfree(list_entry(p, struct ipw_ibss_seq, list));
11060 ipw_free_error_log(priv->error);
11061 priv->error = NULL;
11064 free_irq(pdev->irq, priv);
11065 iounmap(priv->hw_base);
11066 pci_release_regions(pdev);
11067 pci_disable_device(pdev);
11068 pci_set_drvdata(pdev, NULL);
11069 free_ieee80211(priv->net_dev);
11074 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11076 struct ipw_priv *priv = pci_get_drvdata(pdev);
11077 struct net_device *dev = priv->net_dev;
11079 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11081 /* Take down the device; powers it off, etc. */
11084 /* Remove the PRESENT state of the device */
11085 netif_device_detach(dev);
11087 pci_save_state(pdev);
11088 pci_disable_device(pdev);
11089 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11094 static int ipw_pci_resume(struct pci_dev *pdev)
11096 struct ipw_priv *priv = pci_get_drvdata(pdev);
11097 struct net_device *dev = priv->net_dev;
11100 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11102 pci_set_power_state(pdev, PCI_D0);
11103 pci_enable_device(pdev);
11104 pci_restore_state(pdev);
11107 * Suspend/Resume resets the PCI configuration space, so we have to
11108 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11109 * from interfering with C3 CPU state. pci_restore_state won't help
11110 * here since it only restores the first 64 bytes pci config header.
11112 pci_read_config_dword(pdev, 0x40, &val);
11113 if ((val & 0x0000ff00) != 0)
11114 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11116 /* Set the device back into the PRESENT state; this will also wake
11117 * the queue of needed */
11118 netif_device_attach(dev);
11120 /* Bring the device back up */
11121 queue_work(priv->workqueue, &priv->up);
11127 /* driver initialization stuff */
11128 static struct pci_driver ipw_driver = {
11130 .id_table = card_ids,
11131 .probe = ipw_pci_probe,
11132 .remove = __devexit_p(ipw_pci_remove),
11134 .suspend = ipw_pci_suspend,
11135 .resume = ipw_pci_resume,
11139 static int __init ipw_init(void)
11143 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11144 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11146 ret = pci_module_init(&ipw_driver);
11148 IPW_ERROR("Unable to initialize PCI module\n");
11152 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11154 IPW_ERROR("Unable to create driver sysfs file\n");
11155 pci_unregister_driver(&ipw_driver);
11162 static void __exit ipw_exit(void)
11164 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11165 pci_unregister_driver(&ipw_driver);
11168 module_param(disable, int, 0444);
11169 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11171 module_param(associate, int, 0444);
11172 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11174 module_param(auto_create, int, 0444);
11175 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11177 module_param(led, int, 0444);
11178 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11180 module_param(debug, int, 0444);
11181 MODULE_PARM_DESC(debug, "debug output mask");
11183 module_param(channel, int, 0444);
11184 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11186 #ifdef CONFIG_IPW_QOS
11187 module_param(qos_enable, int, 0444);
11188 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11190 module_param(qos_burst_enable, int, 0444);
11191 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11193 module_param(qos_no_ack_mask, int, 0444);
11194 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11196 module_param(burst_duration_CCK, int, 0444);
11197 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11199 module_param(burst_duration_OFDM, int, 0444);
11200 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11201 #endif /* CONFIG_IPW_QOS */
11203 #ifdef CONFIG_IPW2200_MONITOR
11204 module_param(mode, int, 0444);
11205 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11207 module_param(mode, int, 0444);
11208 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11211 module_param(bt_coexist, int, 0444);
11212 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
11214 module_param(hwcrypto, int, 0444);
11215 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
11217 module_param(cmdlog, int, 0444);
11218 MODULE_PARM_DESC(cmdlog,
11219 "allocate a ring buffer for logging firmware commands");
11221 module_param(roaming, int, 0444);
11222 MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
11224 module_exit(ipw_exit);
11225 module_init(ipw_init);