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.8"
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 hwcrypto = 1;
59 static const char ipw_modes[] = {
64 static int qos_enable = 0;
65 static int qos_burst_enable = 0;
66 static int qos_no_ack_mask = 0;
67 static int burst_duration_CCK = 0;
68 static int burst_duration_OFDM = 0;
70 static struct ieee80211_qos_parameters def_qos_parameters_OFDM = {
71 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
73 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
75 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
76 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
77 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
78 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
81 static struct ieee80211_qos_parameters def_qos_parameters_CCK = {
82 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
84 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
86 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
87 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
88 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
89 QOS_TX3_TXOP_LIMIT_CCK}
92 static struct ieee80211_qos_parameters def_parameters_OFDM = {
93 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
95 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
97 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
98 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
99 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
100 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
103 static struct ieee80211_qos_parameters def_parameters_CCK = {
104 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
106 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
108 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
109 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
110 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
111 DEF_TX3_TXOP_LIMIT_CCK}
114 static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
116 static int from_priority_to_tx_queue[] = {
117 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
118 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
121 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
123 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
125 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
127 #endif /* CONFIG_IPW_QOS */
129 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
130 static void ipw_remove_current_network(struct ipw_priv *priv);
131 static void ipw_rx(struct ipw_priv *priv);
132 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
133 struct clx2_tx_queue *txq, int qindex);
134 static int ipw_queue_reset(struct ipw_priv *priv);
136 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
139 static void ipw_tx_queue_free(struct ipw_priv *);
141 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
142 static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
143 static void ipw_rx_queue_replenish(void *);
144 static int ipw_up(struct ipw_priv *);
145 static void ipw_bg_up(void *);
146 static void ipw_down(struct ipw_priv *);
147 static void ipw_bg_down(void *);
148 static int ipw_config(struct ipw_priv *);
149 static int init_supported_rates(struct ipw_priv *priv,
150 struct ipw_supported_rates *prates);
151 static void ipw_set_hwcrypto_keys(struct ipw_priv *);
152 static void ipw_send_wep_keys(struct ipw_priv *, int);
154 static int ipw_is_valid_channel(struct ieee80211_device *, u8);
155 static int ipw_channel_to_index(struct ieee80211_device *, u8);
156 static u8 ipw_freq_to_channel(struct ieee80211_device *, u32);
157 static int ipw_set_geo(struct ieee80211_device *, const struct ieee80211_geo *);
158 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *);
160 static int snprint_line(char *buf, size_t count,
161 const u8 * data, u32 len, u32 ofs)
166 out = snprintf(buf, count, "%08X", ofs);
168 for (l = 0, i = 0; i < 2; i++) {
169 out += snprintf(buf + out, count - out, " ");
170 for (j = 0; j < 8 && l < len; j++, l++)
171 out += snprintf(buf + out, count - out, "%02X ",
174 out += snprintf(buf + out, count - out, " ");
177 out += snprintf(buf + out, count - out, " ");
178 for (l = 0, i = 0; i < 2; i++) {
179 out += snprintf(buf + out, count - out, " ");
180 for (j = 0; j < 8 && l < len; j++, l++) {
181 c = data[(i * 8 + j)];
182 if (!isascii(c) || !isprint(c))
185 out += snprintf(buf + out, count - out, "%c", c);
189 out += snprintf(buf + out, count - out, " ");
195 static void printk_buf(int level, const u8 * data, u32 len)
199 if (!(ipw_debug_level & level))
203 snprint_line(line, sizeof(line), &data[ofs],
205 printk(KERN_DEBUG "%s\n", line);
207 len -= min(len, 16U);
211 static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
217 while (size && len) {
218 out = snprint_line(output, size, &data[ofs],
219 min_t(size_t, len, 16U), ofs);
224 len -= min_t(size_t, len, 16U);
230 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
231 #define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
233 static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
234 #define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
236 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
237 static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
239 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
240 __LINE__, (u32) (b), (u32) (c));
241 _ipw_write_reg8(a, b, c);
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 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
253 static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
255 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
256 __LINE__, (u32) (b), (u32) (c));
257 _ipw_write_reg32(a, b, c);
260 #define _ipw_write8(ipw, ofs, val) writeb((val), (ipw)->hw_base + (ofs))
261 #define ipw_write8(ipw, ofs, val) \
262 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
263 _ipw_write8(ipw, ofs, val)
265 #define _ipw_write16(ipw, ofs, val) writew((val), (ipw)->hw_base + (ofs))
266 #define ipw_write16(ipw, ofs, val) \
267 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
268 _ipw_write16(ipw, ofs, val)
270 #define _ipw_write32(ipw, ofs, val) writel((val), (ipw)->hw_base + (ofs))
271 #define ipw_write32(ipw, ofs, val) \
272 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
273 _ipw_write32(ipw, ofs, val)
275 #define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
276 static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
278 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
279 return _ipw_read8(ipw, ofs);
282 #define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)
284 #define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
285 static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
287 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
288 return _ipw_read16(ipw, ofs);
291 #define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)
293 #define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
294 static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
296 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
297 return _ipw_read32(ipw, ofs);
300 #define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
302 static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
303 static inline void __ipw_read_indirect(const char *f, int l,
304 struct ipw_priv *a, u32 b, u8 * c, int d)
306 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
308 _ipw_read_indirect(a, b, c, d);
311 #define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
313 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
315 #define ipw_write_indirect(a, b, c, d) \
316 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
317 _ipw_write_indirect(a, b, c, d)
319 /* indirect write s */
320 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
322 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
323 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
324 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
327 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
329 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
330 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
331 _ipw_write8(priv, IPW_INDIRECT_DATA, value);
334 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
336 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
337 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
338 _ipw_write16(priv, IPW_INDIRECT_DATA, value);
341 /* indirect read s */
343 static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
346 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
347 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
348 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
349 return (word >> ((reg & 0x3) * 8)) & 0xff;
352 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
356 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
358 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
359 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
360 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
364 /* iterative/auto-increment 32 bit reads and writes */
365 static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
368 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
369 u32 dif_len = addr - aligned_addr;
372 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
378 /* Read the first nibble byte by byte */
379 if (unlikely(dif_len)) {
380 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
381 /* Start reading at aligned_addr + dif_len */
382 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
383 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
387 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
388 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
389 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
391 /* Copy the last nibble */
393 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
394 for (i = 0; num > 0; i++, num--)
395 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
399 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
402 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
403 u32 dif_len = addr - aligned_addr;
406 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
412 /* Write the first nibble 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--, buf++)
417 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
421 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
422 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
423 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
425 /* Copy the last nibble */
427 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
428 for (i = 0; num > 0; i++, num--, buf++)
429 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
433 static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
436 memcpy_toio((priv->hw_base + addr), buf, num);
439 static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
441 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
444 static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
446 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
449 static inline void ipw_enable_interrupts(struct ipw_priv *priv)
451 if (priv->status & STATUS_INT_ENABLED)
453 priv->status |= STATUS_INT_ENABLED;
454 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
457 static inline void ipw_disable_interrupts(struct ipw_priv *priv)
459 if (!(priv->status & STATUS_INT_ENABLED))
461 priv->status &= ~STATUS_INT_ENABLED;
462 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
465 #ifdef CONFIG_IPW2200_DEBUG
466 static char *ipw_error_desc(u32 val)
469 case IPW_FW_ERROR_OK:
471 case IPW_FW_ERROR_FAIL:
473 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
474 return "MEMORY_UNDERFLOW";
475 case IPW_FW_ERROR_MEMORY_OVERFLOW:
476 return "MEMORY_OVERFLOW";
477 case IPW_FW_ERROR_BAD_PARAM:
479 case IPW_FW_ERROR_BAD_CHECKSUM:
480 return "BAD_CHECKSUM";
481 case IPW_FW_ERROR_NMI_INTERRUPT:
482 return "NMI_INTERRUPT";
483 case IPW_FW_ERROR_BAD_DATABASE:
484 return "BAD_DATABASE";
485 case IPW_FW_ERROR_ALLOC_FAIL:
487 case IPW_FW_ERROR_DMA_UNDERRUN:
488 return "DMA_UNDERRUN";
489 case IPW_FW_ERROR_DMA_STATUS:
491 case IPW_FW_ERROR_DINO_ERROR:
493 case IPW_FW_ERROR_EEPROM_ERROR:
494 return "EEPROM_ERROR";
495 case IPW_FW_ERROR_SYSASSERT:
497 case IPW_FW_ERROR_FATAL_ERROR:
498 return "FATAL_ERROR";
500 return "UNKNOWN_ERROR";
504 static void ipw_dump_error_log(struct ipw_priv *priv,
505 struct ipw_fw_error *error)
510 IPW_ERROR("Error allocating and capturing error log. "
511 "Nothing to dump.\n");
515 IPW_ERROR("Start IPW Error Log Dump:\n");
516 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
517 error->status, error->config);
519 for (i = 0; i < error->elem_len; i++)
520 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
521 ipw_error_desc(error->elem[i].desc),
523 error->elem[i].blink1,
524 error->elem[i].blink2,
525 error->elem[i].link1,
526 error->elem[i].link2, error->elem[i].data);
527 for (i = 0; i < error->log_len; i++)
528 IPW_ERROR("%i\t0x%08x\t%i\n",
530 error->log[i].data, error->log[i].event);
534 static inline int ipw_is_init(struct ipw_priv *priv)
536 return (priv->status & STATUS_INIT) ? 1 : 0;
539 static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
541 u32 addr, field_info, field_len, field_count, total_len;
543 IPW_DEBUG_ORD("ordinal = %i\n", ord);
545 if (!priv || !val || !len) {
546 IPW_DEBUG_ORD("Invalid argument\n");
550 /* verify device ordinal tables have been initialized */
551 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
552 IPW_DEBUG_ORD("Access ordinals before initialization\n");
556 switch (IPW_ORD_TABLE_ID_MASK & ord) {
557 case IPW_ORD_TABLE_0_MASK:
559 * TABLE 0: Direct access to a table of 32 bit values
561 * This is a very simple table with the data directly
562 * read from the table
565 /* remove the table id from the ordinal */
566 ord &= IPW_ORD_TABLE_VALUE_MASK;
569 if (ord > priv->table0_len) {
570 IPW_DEBUG_ORD("ordinal value (%i) longer then "
571 "max (%i)\n", ord, priv->table0_len);
575 /* verify we have enough room to store the value */
576 if (*len < sizeof(u32)) {
577 IPW_DEBUG_ORD("ordinal buffer length too small, "
578 "need %zd\n", sizeof(u32));
582 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
583 ord, priv->table0_addr + (ord << 2));
587 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
590 case IPW_ORD_TABLE_1_MASK:
592 * TABLE 1: Indirect access to a table of 32 bit values
594 * This is a fairly large table of u32 values each
595 * representing starting addr for the data (which is
599 /* remove the table id from the ordinal */
600 ord &= IPW_ORD_TABLE_VALUE_MASK;
603 if (ord > priv->table1_len) {
604 IPW_DEBUG_ORD("ordinal value too long\n");
608 /* verify we have enough room to store the value */
609 if (*len < sizeof(u32)) {
610 IPW_DEBUG_ORD("ordinal buffer length too small, "
611 "need %zd\n", sizeof(u32));
616 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
620 case IPW_ORD_TABLE_2_MASK:
622 * TABLE 2: Indirect access to a table of variable sized values
624 * This table consist of six values, each containing
625 * - dword containing the starting offset of the data
626 * - dword containing the lengh in the first 16bits
627 * and the count in the second 16bits
630 /* remove the table id from the ordinal */
631 ord &= IPW_ORD_TABLE_VALUE_MASK;
634 if (ord > priv->table2_len) {
635 IPW_DEBUG_ORD("ordinal value too long\n");
639 /* get the address of statistic */
640 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
642 /* get the second DW of statistics ;
643 * two 16-bit words - first is length, second is count */
646 priv->table2_addr + (ord << 3) +
649 /* get each entry length */
650 field_len = *((u16 *) & field_info);
652 /* get number of entries */
653 field_count = *(((u16 *) & field_info) + 1);
655 /* abort if not enought memory */
656 total_len = field_len * field_count;
657 if (total_len > *len) {
666 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
667 "field_info = 0x%08x\n",
668 addr, total_len, field_info);
669 ipw_read_indirect(priv, addr, val, total_len);
673 IPW_DEBUG_ORD("Invalid ordinal!\n");
681 static void ipw_init_ordinals(struct ipw_priv *priv)
683 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
684 priv->table0_len = ipw_read32(priv, priv->table0_addr);
686 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
687 priv->table0_addr, priv->table0_len);
689 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
690 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
692 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
693 priv->table1_addr, priv->table1_len);
695 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
696 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
697 priv->table2_len &= 0x0000ffff; /* use first two bytes */
699 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
700 priv->table2_addr, priv->table2_len);
704 u32 ipw_register_toggle(u32 reg)
706 reg &= ~IPW_START_STANDBY;
707 if (reg & IPW_GATE_ODMA)
708 reg &= ~IPW_GATE_ODMA;
709 if (reg & IPW_GATE_IDMA)
710 reg &= ~IPW_GATE_IDMA;
711 if (reg & IPW_GATE_ADMA)
712 reg &= ~IPW_GATE_ADMA;
718 * - On radio ON, turn on any LEDs that require to be on during start
719 * - On initialization, start unassociated blink
720 * - On association, disable unassociated blink
721 * - On disassociation, start unassociated blink
722 * - On radio OFF, turn off any LEDs started during radio on
725 #define LD_TIME_LINK_ON 300
726 #define LD_TIME_LINK_OFF 2700
727 #define LD_TIME_ACT_ON 250
729 void ipw_led_link_on(struct ipw_priv *priv)
734 /* If configured to not use LEDs, or nic_type is 1,
735 * then we don't toggle a LINK led */
736 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
739 spin_lock_irqsave(&priv->lock, flags);
741 if (!(priv->status & STATUS_RF_KILL_MASK) &&
742 !(priv->status & STATUS_LED_LINK_ON)) {
743 IPW_DEBUG_LED("Link LED On\n");
744 led = ipw_read_reg32(priv, IPW_EVENT_REG);
745 led |= priv->led_association_on;
747 led = ipw_register_toggle(led);
749 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
750 ipw_write_reg32(priv, IPW_EVENT_REG, led);
752 priv->status |= STATUS_LED_LINK_ON;
754 /* If we aren't associated, schedule turning the LED off */
755 if (!(priv->status & STATUS_ASSOCIATED))
756 queue_delayed_work(priv->workqueue,
761 spin_unlock_irqrestore(&priv->lock, flags);
764 static void ipw_bg_led_link_on(void *data)
766 struct ipw_priv *priv = data;
768 ipw_led_link_on(data);
772 void ipw_led_link_off(struct ipw_priv *priv)
777 /* If configured not to use LEDs, or nic type is 1,
778 * then we don't goggle the LINK led. */
779 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
782 spin_lock_irqsave(&priv->lock, flags);
784 if (priv->status & STATUS_LED_LINK_ON) {
785 led = ipw_read_reg32(priv, IPW_EVENT_REG);
786 led &= priv->led_association_off;
787 led = ipw_register_toggle(led);
789 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
790 ipw_write_reg32(priv, IPW_EVENT_REG, led);
792 IPW_DEBUG_LED("Link LED Off\n");
794 priv->status &= ~STATUS_LED_LINK_ON;
796 /* If we aren't associated and the radio is on, schedule
797 * turning the LED on (blink while unassociated) */
798 if (!(priv->status & STATUS_RF_KILL_MASK) &&
799 !(priv->status & STATUS_ASSOCIATED))
800 queue_delayed_work(priv->workqueue, &priv->led_link_on,
805 spin_unlock_irqrestore(&priv->lock, flags);
808 static void ipw_bg_led_link_off(void *data)
810 struct ipw_priv *priv = data;
812 ipw_led_link_off(data);
816 static inline void __ipw_led_activity_on(struct ipw_priv *priv)
820 if (priv->config & CFG_NO_LED)
823 if (priv->status & STATUS_RF_KILL_MASK)
826 if (!(priv->status & STATUS_LED_ACT_ON)) {
827 led = ipw_read_reg32(priv, IPW_EVENT_REG);
828 led |= priv->led_activity_on;
830 led = ipw_register_toggle(led);
832 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
833 ipw_write_reg32(priv, IPW_EVENT_REG, led);
835 IPW_DEBUG_LED("Activity LED On\n");
837 priv->status |= STATUS_LED_ACT_ON;
839 cancel_delayed_work(&priv->led_act_off);
840 queue_delayed_work(priv->workqueue, &priv->led_act_off,
843 /* Reschedule LED off for full time period */
844 cancel_delayed_work(&priv->led_act_off);
845 queue_delayed_work(priv->workqueue, &priv->led_act_off,
850 void ipw_led_activity_on(struct ipw_priv *priv)
853 spin_lock_irqsave(&priv->lock, flags);
854 __ipw_led_activity_on(priv);
855 spin_unlock_irqrestore(&priv->lock, flags);
858 void ipw_led_activity_off(struct ipw_priv *priv)
863 if (priv->config & CFG_NO_LED)
866 spin_lock_irqsave(&priv->lock, flags);
868 if (priv->status & STATUS_LED_ACT_ON) {
869 led = ipw_read_reg32(priv, IPW_EVENT_REG);
870 led &= priv->led_activity_off;
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 Off\n");
879 priv->status &= ~STATUS_LED_ACT_ON;
882 spin_unlock_irqrestore(&priv->lock, flags);
885 static void ipw_bg_led_activity_off(void *data)
887 struct ipw_priv *priv = data;
889 ipw_led_activity_off(data);
893 void ipw_led_band_on(struct ipw_priv *priv)
898 /* Only nic type 1 supports mode LEDs */
899 if (priv->config & CFG_NO_LED ||
900 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
903 spin_lock_irqsave(&priv->lock, flags);
905 led = ipw_read_reg32(priv, IPW_EVENT_REG);
906 if (priv->assoc_network->mode == IEEE_A) {
907 led |= priv->led_ofdm_on;
908 led &= priv->led_association_off;
909 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
910 } else if (priv->assoc_network->mode == IEEE_G) {
911 led |= priv->led_ofdm_on;
912 led |= priv->led_association_on;
913 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
915 led &= priv->led_ofdm_off;
916 led |= priv->led_association_on;
917 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
920 led = ipw_register_toggle(led);
922 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
923 ipw_write_reg32(priv, IPW_EVENT_REG, led);
925 spin_unlock_irqrestore(&priv->lock, flags);
928 void ipw_led_band_off(struct ipw_priv *priv)
933 /* Only nic type 1 supports mode LEDs */
934 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
937 spin_lock_irqsave(&priv->lock, flags);
939 led = ipw_read_reg32(priv, IPW_EVENT_REG);
940 led &= priv->led_ofdm_off;
941 led &= priv->led_association_off;
943 led = ipw_register_toggle(led);
945 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
946 ipw_write_reg32(priv, IPW_EVENT_REG, led);
948 spin_unlock_irqrestore(&priv->lock, flags);
951 void ipw_led_radio_on(struct ipw_priv *priv)
953 ipw_led_link_on(priv);
956 void ipw_led_radio_off(struct ipw_priv *priv)
958 ipw_led_activity_off(priv);
959 ipw_led_link_off(priv);
962 void ipw_led_link_up(struct ipw_priv *priv)
964 /* Set the Link Led on for all nic types */
965 ipw_led_link_on(priv);
968 void ipw_led_link_down(struct ipw_priv *priv)
970 ipw_led_activity_off(priv);
971 ipw_led_link_off(priv);
973 if (priv->status & STATUS_RF_KILL_MASK)
974 ipw_led_radio_off(priv);
977 void ipw_led_init(struct ipw_priv *priv)
979 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
981 /* Set the default PINs for the link and activity leds */
982 priv->led_activity_on = IPW_ACTIVITY_LED;
983 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
985 priv->led_association_on = IPW_ASSOCIATED_LED;
986 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
988 /* Set the default PINs for the OFDM leds */
989 priv->led_ofdm_on = IPW_OFDM_LED;
990 priv->led_ofdm_off = ~(IPW_OFDM_LED);
992 switch (priv->nic_type) {
993 case EEPROM_NIC_TYPE_1:
994 /* In this NIC type, the LEDs are reversed.... */
995 priv->led_activity_on = IPW_ASSOCIATED_LED;
996 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
997 priv->led_association_on = IPW_ACTIVITY_LED;
998 priv->led_association_off = ~(IPW_ACTIVITY_LED);
1000 if (!(priv->config & CFG_NO_LED))
1001 ipw_led_band_on(priv);
1003 /* And we don't blink link LEDs for this nic, so
1004 * just return here */
1007 case EEPROM_NIC_TYPE_3:
1008 case EEPROM_NIC_TYPE_2:
1009 case EEPROM_NIC_TYPE_4:
1010 case EEPROM_NIC_TYPE_0:
1014 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1016 priv->nic_type = EEPROM_NIC_TYPE_0;
1020 if (!(priv->config & CFG_NO_LED)) {
1021 if (priv->status & STATUS_ASSOCIATED)
1022 ipw_led_link_on(priv);
1024 ipw_led_link_off(priv);
1028 void ipw_led_shutdown(struct ipw_priv *priv)
1030 ipw_led_activity_off(priv);
1031 ipw_led_link_off(priv);
1032 ipw_led_band_off(priv);
1033 cancel_delayed_work(&priv->led_link_on);
1034 cancel_delayed_work(&priv->led_link_off);
1035 cancel_delayed_work(&priv->led_act_off);
1039 * The following adds a new attribute to the sysfs representation
1040 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1041 * used for controling the debug level.
1043 * See the level definitions in ipw for details.
1045 static ssize_t show_debug_level(struct device_driver *d, char *buf)
1047 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1050 static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1053 char *p = (char *)buf;
1056 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1058 if (p[0] == 'x' || p[0] == 'X')
1060 val = simple_strtoul(p, &p, 16);
1062 val = simple_strtoul(p, &p, 10);
1064 printk(KERN_INFO DRV_NAME
1065 ": %s is not in hex or decimal form.\n", buf);
1067 ipw_debug_level = val;
1069 return strnlen(buf, count);
1072 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
1073 show_debug_level, store_debug_level);
1075 static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
1077 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
1080 static void ipw_capture_event_log(struct ipw_priv *priv,
1081 u32 log_len, struct ipw_event *log)
1086 base = ipw_read32(priv, IPW_EVENT_LOG);
1087 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1088 (u8 *) log, sizeof(*log) * log_len);
1092 static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
1094 struct ipw_fw_error *error;
1095 u32 log_len = ipw_get_event_log_len(priv);
1096 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1097 u32 elem_len = ipw_read_reg32(priv, base);
1099 error = kmalloc(sizeof(*error) +
1100 sizeof(*error->elem) * elem_len +
1101 sizeof(*error->log) * log_len, GFP_ATOMIC);
1103 IPW_ERROR("Memory allocation for firmware error log "
1107 error->jiffies = jiffies;
1108 error->status = priv->status;
1109 error->config = priv->config;
1110 error->elem_len = elem_len;
1111 error->log_len = log_len;
1112 error->elem = (struct ipw_error_elem *)error->payload;
1113 error->log = (struct ipw_event *)(error->elem + elem_len);
1115 ipw_capture_event_log(priv, log_len, error->log);
1118 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1119 sizeof(*error->elem) * elem_len);
1124 static void ipw_free_error_log(struct ipw_fw_error *error)
1130 static ssize_t show_event_log(struct device *d,
1131 struct device_attribute *attr, char *buf)
1133 struct ipw_priv *priv = dev_get_drvdata(d);
1134 u32 log_len = ipw_get_event_log_len(priv);
1135 struct ipw_event log[log_len];
1138 ipw_capture_event_log(priv, log_len, log);
1140 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1141 for (i = 0; i < log_len; i++)
1142 len += snprintf(buf + len, PAGE_SIZE - len,
1144 log[i].time, log[i].event, log[i].data);
1145 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1149 static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
1151 static ssize_t show_error(struct device *d,
1152 struct device_attribute *attr, char *buf)
1154 struct ipw_priv *priv = dev_get_drvdata(d);
1158 len += snprintf(buf + len, PAGE_SIZE - len,
1159 "%08lX%08X%08X%08X",
1160 priv->error->jiffies,
1161 priv->error->status,
1162 priv->error->config, priv->error->elem_len);
1163 for (i = 0; i < priv->error->elem_len; i++)
1164 len += snprintf(buf + len, PAGE_SIZE - len,
1165 "\n%08X%08X%08X%08X%08X%08X%08X",
1166 priv->error->elem[i].time,
1167 priv->error->elem[i].desc,
1168 priv->error->elem[i].blink1,
1169 priv->error->elem[i].blink2,
1170 priv->error->elem[i].link1,
1171 priv->error->elem[i].link2,
1172 priv->error->elem[i].data);
1174 len += snprintf(buf + len, PAGE_SIZE - len,
1175 "\n%08X", priv->error->log_len);
1176 for (i = 0; i < priv->error->log_len; i++)
1177 len += snprintf(buf + len, PAGE_SIZE - len,
1179 priv->error->log[i].time,
1180 priv->error->log[i].event,
1181 priv->error->log[i].data);
1182 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1186 static ssize_t clear_error(struct device *d,
1187 struct device_attribute *attr,
1188 const char *buf, size_t count)
1190 struct ipw_priv *priv = dev_get_drvdata(d);
1192 ipw_free_error_log(priv->error);
1198 static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
1200 static ssize_t show_cmd_log(struct device *d,
1201 struct device_attribute *attr, char *buf)
1203 struct ipw_priv *priv = dev_get_drvdata(d);
1207 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1208 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1209 i = (i + 1) % priv->cmdlog_len) {
1211 snprintf(buf + len, PAGE_SIZE - len,
1212 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1213 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1214 priv->cmdlog[i].cmd.len);
1216 snprintk_buf(buf + len, PAGE_SIZE - len,
1217 (u8 *) priv->cmdlog[i].cmd.param,
1218 priv->cmdlog[i].cmd.len);
1219 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1221 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1225 static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
1227 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1230 struct ipw_priv *priv = dev_get_drvdata(d);
1231 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1234 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1235 const char *buf, size_t count)
1237 struct ipw_priv *priv = dev_get_drvdata(d);
1238 #ifdef CONFIG_IPW2200_DEBUG
1239 struct net_device *dev = priv->net_dev;
1241 char buffer[] = "00000000";
1243 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1247 IPW_DEBUG_INFO("enter\n");
1249 strncpy(buffer, buf, len);
1252 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1254 if (p[0] == 'x' || p[0] == 'X')
1256 val = simple_strtoul(p, &p, 16);
1258 val = simple_strtoul(p, &p, 10);
1260 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1262 priv->ieee->scan_age = val;
1263 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1266 IPW_DEBUG_INFO("exit\n");
1270 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1272 static ssize_t show_led(struct device *d, struct device_attribute *attr,
1275 struct ipw_priv *priv = dev_get_drvdata(d);
1276 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1279 static ssize_t store_led(struct device *d, struct device_attribute *attr,
1280 const char *buf, size_t count)
1282 struct ipw_priv *priv = dev_get_drvdata(d);
1284 IPW_DEBUG_INFO("enter\n");
1290 IPW_DEBUG_LED("Disabling LED control.\n");
1291 priv->config |= CFG_NO_LED;
1292 ipw_led_shutdown(priv);
1294 IPW_DEBUG_LED("Enabling LED control.\n");
1295 priv->config &= ~CFG_NO_LED;
1299 IPW_DEBUG_INFO("exit\n");
1303 static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1305 static ssize_t show_status(struct device *d,
1306 struct device_attribute *attr, char *buf)
1308 struct ipw_priv *p = d->driver_data;
1309 return sprintf(buf, "0x%08x\n", (int)p->status);
1312 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1314 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1317 struct ipw_priv *p = d->driver_data;
1318 return sprintf(buf, "0x%08x\n", (int)p->config);
1321 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1323 static ssize_t show_nic_type(struct device *d,
1324 struct device_attribute *attr, char *buf)
1326 struct ipw_priv *priv = d->driver_data;
1327 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1330 static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1332 static ssize_t show_ucode_version(struct device *d,
1333 struct device_attribute *attr, char *buf)
1335 u32 len = sizeof(u32), tmp = 0;
1336 struct ipw_priv *p = d->driver_data;
1338 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
1341 return sprintf(buf, "0x%08x\n", tmp);
1344 static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
1346 static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1349 u32 len = sizeof(u32), tmp = 0;
1350 struct ipw_priv *p = d->driver_data;
1352 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
1355 return sprintf(buf, "0x%08x\n", tmp);
1358 static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
1361 * Add a device attribute to view/control the delay between eeprom
1364 static ssize_t show_eeprom_delay(struct device *d,
1365 struct device_attribute *attr, char *buf)
1367 int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
1368 return sprintf(buf, "%i\n", n);
1370 static ssize_t store_eeprom_delay(struct device *d,
1371 struct device_attribute *attr,
1372 const char *buf, size_t count)
1374 struct ipw_priv *p = d->driver_data;
1375 sscanf(buf, "%i", &p->eeprom_delay);
1376 return strnlen(buf, count);
1379 static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1380 show_eeprom_delay, store_eeprom_delay);
1382 static ssize_t show_command_event_reg(struct device *d,
1383 struct device_attribute *attr, char *buf)
1386 struct ipw_priv *p = d->driver_data;
1388 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
1389 return sprintf(buf, "0x%08x\n", reg);
1391 static ssize_t store_command_event_reg(struct device *d,
1392 struct device_attribute *attr,
1393 const char *buf, size_t count)
1396 struct ipw_priv *p = d->driver_data;
1398 sscanf(buf, "%x", ®);
1399 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
1400 return strnlen(buf, count);
1403 static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1404 show_command_event_reg, store_command_event_reg);
1406 static ssize_t show_mem_gpio_reg(struct device *d,
1407 struct device_attribute *attr, char *buf)
1410 struct ipw_priv *p = d->driver_data;
1412 reg = ipw_read_reg32(p, 0x301100);
1413 return sprintf(buf, "0x%08x\n", reg);
1415 static ssize_t store_mem_gpio_reg(struct device *d,
1416 struct device_attribute *attr,
1417 const char *buf, size_t count)
1420 struct ipw_priv *p = d->driver_data;
1422 sscanf(buf, "%x", ®);
1423 ipw_write_reg32(p, 0x301100, reg);
1424 return strnlen(buf, count);
1427 static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1428 show_mem_gpio_reg, store_mem_gpio_reg);
1430 static ssize_t show_indirect_dword(struct device *d,
1431 struct device_attribute *attr, char *buf)
1434 struct ipw_priv *priv = d->driver_data;
1436 if (priv->status & STATUS_INDIRECT_DWORD)
1437 reg = ipw_read_reg32(priv, priv->indirect_dword);
1441 return sprintf(buf, "0x%08x\n", reg);
1443 static ssize_t store_indirect_dword(struct device *d,
1444 struct device_attribute *attr,
1445 const char *buf, size_t count)
1447 struct ipw_priv *priv = d->driver_data;
1449 sscanf(buf, "%x", &priv->indirect_dword);
1450 priv->status |= STATUS_INDIRECT_DWORD;
1451 return strnlen(buf, count);
1454 static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1455 show_indirect_dword, store_indirect_dword);
1457 static ssize_t show_indirect_byte(struct device *d,
1458 struct device_attribute *attr, char *buf)
1461 struct ipw_priv *priv = d->driver_data;
1463 if (priv->status & STATUS_INDIRECT_BYTE)
1464 reg = ipw_read_reg8(priv, priv->indirect_byte);
1468 return sprintf(buf, "0x%02x\n", reg);
1470 static ssize_t store_indirect_byte(struct device *d,
1471 struct device_attribute *attr,
1472 const char *buf, size_t count)
1474 struct ipw_priv *priv = d->driver_data;
1476 sscanf(buf, "%x", &priv->indirect_byte);
1477 priv->status |= STATUS_INDIRECT_BYTE;
1478 return strnlen(buf, count);
1481 static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
1482 show_indirect_byte, store_indirect_byte);
1484 static ssize_t show_direct_dword(struct device *d,
1485 struct device_attribute *attr, char *buf)
1488 struct ipw_priv *priv = d->driver_data;
1490 if (priv->status & STATUS_DIRECT_DWORD)
1491 reg = ipw_read32(priv, priv->direct_dword);
1495 return sprintf(buf, "0x%08x\n", reg);
1497 static ssize_t store_direct_dword(struct device *d,
1498 struct device_attribute *attr,
1499 const char *buf, size_t count)
1501 struct ipw_priv *priv = d->driver_data;
1503 sscanf(buf, "%x", &priv->direct_dword);
1504 priv->status |= STATUS_DIRECT_DWORD;
1505 return strnlen(buf, count);
1508 static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1509 show_direct_dword, store_direct_dword);
1511 static inline int rf_kill_active(struct ipw_priv *priv)
1513 if (0 == (ipw_read32(priv, 0x30) & 0x10000))
1514 priv->status |= STATUS_RF_KILL_HW;
1516 priv->status &= ~STATUS_RF_KILL_HW;
1518 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1521 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
1524 /* 0 - RF kill not enabled
1525 1 - SW based RF kill active (sysfs)
1526 2 - HW based RF kill active
1527 3 - Both HW and SW baed RF kill active */
1528 struct ipw_priv *priv = d->driver_data;
1529 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1530 (rf_kill_active(priv) ? 0x2 : 0x0);
1531 return sprintf(buf, "%i\n", val);
1534 static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1536 if ((disable_radio ? 1 : 0) ==
1537 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1540 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1541 disable_radio ? "OFF" : "ON");
1543 if (disable_radio) {
1544 priv->status |= STATUS_RF_KILL_SW;
1546 if (priv->workqueue)
1547 cancel_delayed_work(&priv->request_scan);
1548 queue_work(priv->workqueue, &priv->down);
1550 priv->status &= ~STATUS_RF_KILL_SW;
1551 if (rf_kill_active(priv)) {
1552 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1553 "disabled by HW switch\n");
1554 /* Make sure the RF_KILL check timer is running */
1555 cancel_delayed_work(&priv->rf_kill);
1556 queue_delayed_work(priv->workqueue, &priv->rf_kill,
1559 queue_work(priv->workqueue, &priv->up);
1565 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1566 const char *buf, size_t count)
1568 struct ipw_priv *priv = d->driver_data;
1570 ipw_radio_kill_sw(priv, buf[0] == '1');
1575 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
1577 static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1580 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1581 int pos = 0, len = 0;
1582 if (priv->config & CFG_SPEED_SCAN) {
1583 while (priv->speed_scan[pos] != 0)
1584 len += sprintf(&buf[len], "%d ",
1585 priv->speed_scan[pos++]);
1586 return len + sprintf(&buf[len], "\n");
1589 return sprintf(buf, "0\n");
1592 static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1593 const char *buf, size_t count)
1595 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1596 int channel, pos = 0;
1597 const char *p = buf;
1599 /* list of space separated channels to scan, optionally ending with 0 */
1600 while ((channel = simple_strtol(p, NULL, 0))) {
1601 if (pos == MAX_SPEED_SCAN - 1) {
1602 priv->speed_scan[pos] = 0;
1606 if (ipw_is_valid_channel(priv->ieee, channel))
1607 priv->speed_scan[pos++] = channel;
1609 IPW_WARNING("Skipping invalid channel request: %d\n",
1614 while (*p == ' ' || *p == '\t')
1619 priv->config &= ~CFG_SPEED_SCAN;
1621 priv->speed_scan_pos = 0;
1622 priv->config |= CFG_SPEED_SCAN;
1628 static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1631 static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1634 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1635 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1638 static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1639 const char *buf, size_t count)
1641 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1643 priv->config |= CFG_NET_STATS;
1645 priv->config &= ~CFG_NET_STATS;
1650 static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1651 show_net_stats, store_net_stats);
1653 static void notify_wx_assoc_event(struct ipw_priv *priv)
1655 union iwreq_data wrqu;
1656 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1657 if (priv->status & STATUS_ASSOCIATED)
1658 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1660 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1661 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1664 static void ipw_irq_tasklet(struct ipw_priv *priv)
1666 u32 inta, inta_mask, handled = 0;
1667 unsigned long flags;
1670 spin_lock_irqsave(&priv->lock, flags);
1672 inta = ipw_read32(priv, IPW_INTA_RW);
1673 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1674 inta &= (IPW_INTA_MASK_ALL & inta_mask);
1676 /* Add any cached INTA values that need to be handled */
1677 inta |= priv->isr_inta;
1679 /* handle all the justifications for the interrupt */
1680 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1682 handled |= IPW_INTA_BIT_RX_TRANSFER;
1685 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1686 IPW_DEBUG_HC("Command completed.\n");
1687 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1688 priv->status &= ~STATUS_HCMD_ACTIVE;
1689 wake_up_interruptible(&priv->wait_command_queue);
1690 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1693 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
1694 IPW_DEBUG_TX("TX_QUEUE_1\n");
1695 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1696 handled |= IPW_INTA_BIT_TX_QUEUE_1;
1699 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
1700 IPW_DEBUG_TX("TX_QUEUE_2\n");
1701 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1702 handled |= IPW_INTA_BIT_TX_QUEUE_2;
1705 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
1706 IPW_DEBUG_TX("TX_QUEUE_3\n");
1707 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1708 handled |= IPW_INTA_BIT_TX_QUEUE_3;
1711 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
1712 IPW_DEBUG_TX("TX_QUEUE_4\n");
1713 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
1714 handled |= IPW_INTA_BIT_TX_QUEUE_4;
1717 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
1718 IPW_WARNING("STATUS_CHANGE\n");
1719 handled |= IPW_INTA_BIT_STATUS_CHANGE;
1722 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
1723 IPW_WARNING("TX_PERIOD_EXPIRED\n");
1724 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
1727 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
1728 IPW_WARNING("HOST_CMD_DONE\n");
1729 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
1732 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
1733 IPW_WARNING("FW_INITIALIZATION_DONE\n");
1734 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
1737 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
1738 IPW_WARNING("PHY_OFF_DONE\n");
1739 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
1742 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
1743 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1744 priv->status |= STATUS_RF_KILL_HW;
1745 wake_up_interruptible(&priv->wait_command_queue);
1746 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1747 cancel_delayed_work(&priv->request_scan);
1748 schedule_work(&priv->link_down);
1749 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
1750 handled |= IPW_INTA_BIT_RF_KILL_DONE;
1753 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1754 IPW_ERROR("Firmware error detected. Restarting.\n");
1756 IPW_ERROR("Sysfs 'error' log already exists.\n");
1757 #ifdef CONFIG_IPW2200_DEBUG
1758 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1759 struct ipw_fw_error *error =
1760 ipw_alloc_error_log(priv);
1761 ipw_dump_error_log(priv, error);
1763 ipw_free_error_log(error);
1767 priv->error = ipw_alloc_error_log(priv);
1769 IPW_ERROR("Sysfs 'error' log captured.\n");
1771 IPW_ERROR("Error allocating sysfs 'error' "
1773 #ifdef CONFIG_IPW2200_DEBUG
1774 if (ipw_debug_level & IPW_DL_FW_ERRORS)
1775 ipw_dump_error_log(priv, priv->error);
1779 /* XXX: If hardware encryption is for WPA/WPA2,
1780 * we have to notify the supplicant. */
1781 if (priv->ieee->sec.encrypt) {
1782 priv->status &= ~STATUS_ASSOCIATED;
1783 notify_wx_assoc_event(priv);
1786 /* Keep the restart process from trying to send host
1787 * commands by clearing the INIT status bit */
1788 priv->status &= ~STATUS_INIT;
1790 /* Cancel currently queued command. */
1791 priv->status &= ~STATUS_HCMD_ACTIVE;
1792 wake_up_interruptible(&priv->wait_command_queue);
1794 queue_work(priv->workqueue, &priv->adapter_restart);
1795 handled |= IPW_INTA_BIT_FATAL_ERROR;
1798 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
1799 IPW_ERROR("Parity error\n");
1800 handled |= IPW_INTA_BIT_PARITY_ERROR;
1803 if (handled != inta) {
1804 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
1807 /* enable all interrupts */
1808 ipw_enable_interrupts(priv);
1810 spin_unlock_irqrestore(&priv->lock, flags);
1813 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1814 static char *get_cmd_string(u8 cmd)
1817 IPW_CMD(HOST_COMPLETE);
1818 IPW_CMD(POWER_DOWN);
1819 IPW_CMD(SYSTEM_CONFIG);
1820 IPW_CMD(MULTICAST_ADDRESS);
1822 IPW_CMD(ADAPTER_ADDRESS);
1824 IPW_CMD(RTS_THRESHOLD);
1825 IPW_CMD(FRAG_THRESHOLD);
1826 IPW_CMD(POWER_MODE);
1828 IPW_CMD(TGI_TX_KEY);
1829 IPW_CMD(SCAN_REQUEST);
1830 IPW_CMD(SCAN_REQUEST_EXT);
1832 IPW_CMD(SUPPORTED_RATES);
1833 IPW_CMD(SCAN_ABORT);
1835 IPW_CMD(QOS_PARAMETERS);
1836 IPW_CMD(DINO_CONFIG);
1837 IPW_CMD(RSN_CAPABILITIES);
1839 IPW_CMD(CARD_DISABLE);
1840 IPW_CMD(SEED_NUMBER);
1842 IPW_CMD(COUNTRY_INFO);
1843 IPW_CMD(AIRONET_INFO);
1844 IPW_CMD(AP_TX_POWER);
1846 IPW_CMD(CCX_VER_INFO);
1847 IPW_CMD(SET_CALIBRATION);
1848 IPW_CMD(SENSITIVITY_CALIB);
1849 IPW_CMD(RETRY_LIMIT);
1850 IPW_CMD(IPW_PRE_POWER_DOWN);
1851 IPW_CMD(VAP_BEACON_TEMPLATE);
1852 IPW_CMD(VAP_DTIM_PERIOD);
1853 IPW_CMD(EXT_SUPPORTED_RATES);
1854 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1855 IPW_CMD(VAP_QUIET_INTERVALS);
1856 IPW_CMD(VAP_CHANNEL_SWITCH);
1857 IPW_CMD(VAP_MANDATORY_CHANNELS);
1858 IPW_CMD(VAP_CELL_PWR_LIMIT);
1859 IPW_CMD(VAP_CF_PARAM_SET);
1860 IPW_CMD(VAP_SET_BEACONING_STATE);
1861 IPW_CMD(MEASUREMENT);
1862 IPW_CMD(POWER_CAPABILITY);
1863 IPW_CMD(SUPPORTED_CHANNELS);
1864 IPW_CMD(TPC_REPORT);
1866 IPW_CMD(PRODUCTION_COMMAND);
1872 #define HOST_COMPLETE_TIMEOUT HZ
1873 static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
1876 unsigned long flags;
1878 spin_lock_irqsave(&priv->lock, flags);
1879 if (priv->status & STATUS_HCMD_ACTIVE) {
1880 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1881 get_cmd_string(cmd->cmd));
1882 spin_unlock_irqrestore(&priv->lock, flags);
1886 priv->status |= STATUS_HCMD_ACTIVE;
1889 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1890 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1891 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1892 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1894 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1897 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1898 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1900 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1902 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
1904 priv->status &= ~STATUS_HCMD_ACTIVE;
1905 IPW_ERROR("Failed to send %s: Reason %d\n",
1906 get_cmd_string(cmd->cmd), rc);
1907 spin_unlock_irqrestore(&priv->lock, flags);
1910 spin_unlock_irqrestore(&priv->lock, flags);
1912 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1914 status & STATUS_HCMD_ACTIVE),
1915 HOST_COMPLETE_TIMEOUT);
1917 spin_lock_irqsave(&priv->lock, flags);
1918 if (priv->status & STATUS_HCMD_ACTIVE) {
1919 IPW_ERROR("Failed to send %s: Command timed out.\n",
1920 get_cmd_string(cmd->cmd));
1921 priv->status &= ~STATUS_HCMD_ACTIVE;
1922 spin_unlock_irqrestore(&priv->lock, flags);
1926 spin_unlock_irqrestore(&priv->lock, flags);
1930 if (priv->status & STATUS_RF_KILL_HW) {
1931 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1932 get_cmd_string(cmd->cmd));
1939 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1940 priv->cmdlog_pos %= priv->cmdlog_len;
1945 static int ipw_send_host_complete(struct ipw_priv *priv)
1947 struct host_cmd cmd = {
1948 .cmd = IPW_CMD_HOST_COMPLETE,
1953 IPW_ERROR("Invalid args\n");
1957 return ipw_send_cmd(priv, &cmd);
1960 static int ipw_send_system_config(struct ipw_priv *priv,
1961 struct ipw_sys_config *config)
1963 struct host_cmd cmd = {
1964 .cmd = IPW_CMD_SYSTEM_CONFIG,
1965 .len = sizeof(*config)
1968 if (!priv || !config) {
1969 IPW_ERROR("Invalid args\n");
1973 memcpy(cmd.param, config, sizeof(*config));
1974 return ipw_send_cmd(priv, &cmd);
1977 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
1979 struct host_cmd cmd = {
1980 .cmd = IPW_CMD_SSID,
1981 .len = min(len, IW_ESSID_MAX_SIZE)
1984 if (!priv || !ssid) {
1985 IPW_ERROR("Invalid args\n");
1989 memcpy(cmd.param, ssid, cmd.len);
1990 return ipw_send_cmd(priv, &cmd);
1993 static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
1995 struct host_cmd cmd = {
1996 .cmd = IPW_CMD_ADAPTER_ADDRESS,
2000 if (!priv || !mac) {
2001 IPW_ERROR("Invalid args\n");
2005 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2006 priv->net_dev->name, MAC_ARG(mac));
2008 memcpy(cmd.param, mac, ETH_ALEN);
2009 return ipw_send_cmd(priv, &cmd);
2013 * NOTE: This must be executed from our workqueue as it results in udelay
2014 * being called which may corrupt the keyboard if executed on default
2017 static void ipw_adapter_restart(void *adapter)
2019 struct ipw_priv *priv = adapter;
2021 if (priv->status & STATUS_RF_KILL_MASK)
2026 if (priv->assoc_network &&
2027 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2028 ipw_remove_current_network(priv);
2031 IPW_ERROR("Failed to up device\n");
2036 static void ipw_bg_adapter_restart(void *data)
2038 struct ipw_priv *priv = data;
2040 ipw_adapter_restart(data);
2044 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2046 static void ipw_scan_check(void *data)
2048 struct ipw_priv *priv = data;
2049 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2050 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2051 "adapter (%dms).\n",
2052 IPW_SCAN_CHECK_WATCHDOG / 100);
2053 queue_work(priv->workqueue, &priv->adapter_restart);
2057 static void ipw_bg_scan_check(void *data)
2059 struct ipw_priv *priv = data;
2061 ipw_scan_check(data);
2065 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2066 struct ipw_scan_request_ext *request)
2068 struct host_cmd cmd = {
2069 .cmd = IPW_CMD_SCAN_REQUEST_EXT,
2070 .len = sizeof(*request)
2073 memcpy(cmd.param, request, sizeof(*request));
2074 return ipw_send_cmd(priv, &cmd);
2077 static int ipw_send_scan_abort(struct ipw_priv *priv)
2079 struct host_cmd cmd = {
2080 .cmd = IPW_CMD_SCAN_ABORT,
2085 IPW_ERROR("Invalid args\n");
2089 return ipw_send_cmd(priv, &cmd);
2092 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2094 struct host_cmd cmd = {
2095 .cmd = IPW_CMD_SENSITIVITY_CALIB,
2096 .len = sizeof(struct ipw_sensitivity_calib)
2098 struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
2100 calib->beacon_rssi_raw = sens;
2101 return ipw_send_cmd(priv, &cmd);
2104 static int ipw_send_associate(struct ipw_priv *priv,
2105 struct ipw_associate *associate)
2107 struct host_cmd cmd = {
2108 .cmd = IPW_CMD_ASSOCIATE,
2109 .len = sizeof(*associate)
2112 struct ipw_associate tmp_associate;
2113 memcpy(&tmp_associate, associate, sizeof(*associate));
2114 tmp_associate.policy_support =
2115 cpu_to_le16(tmp_associate.policy_support);
2116 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2117 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2118 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2119 tmp_associate.listen_interval =
2120 cpu_to_le16(tmp_associate.listen_interval);
2121 tmp_associate.beacon_interval =
2122 cpu_to_le16(tmp_associate.beacon_interval);
2123 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2125 if (!priv || !associate) {
2126 IPW_ERROR("Invalid args\n");
2130 memcpy(cmd.param, &tmp_associate, sizeof(*associate));
2131 return ipw_send_cmd(priv, &cmd);
2134 static int ipw_send_supported_rates(struct ipw_priv *priv,
2135 struct ipw_supported_rates *rates)
2137 struct host_cmd cmd = {
2138 .cmd = IPW_CMD_SUPPORTED_RATES,
2139 .len = sizeof(*rates)
2142 if (!priv || !rates) {
2143 IPW_ERROR("Invalid args\n");
2147 memcpy(cmd.param, rates, sizeof(*rates));
2148 return ipw_send_cmd(priv, &cmd);
2151 static int ipw_set_random_seed(struct ipw_priv *priv)
2153 struct host_cmd cmd = {
2154 .cmd = IPW_CMD_SEED_NUMBER,
2159 IPW_ERROR("Invalid args\n");
2163 get_random_bytes(&cmd.param, sizeof(u32));
2165 return ipw_send_cmd(priv, &cmd);
2168 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2170 struct host_cmd cmd = {
2171 .cmd = IPW_CMD_CARD_DISABLE,
2176 IPW_ERROR("Invalid args\n");
2180 *((u32 *) & cmd.param) = phy_off;
2182 return ipw_send_cmd(priv, &cmd);
2185 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2187 struct host_cmd cmd = {
2188 .cmd = IPW_CMD_TX_POWER,
2189 .len = sizeof(*power)
2192 if (!priv || !power) {
2193 IPW_ERROR("Invalid args\n");
2197 memcpy(cmd.param, power, sizeof(*power));
2198 return ipw_send_cmd(priv, &cmd);
2201 static int ipw_set_tx_power(struct ipw_priv *priv)
2203 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
2204 struct ipw_tx_power tx_power;
2208 memset(&tx_power, 0, sizeof(tx_power));
2210 /* configure device for 'G' band */
2211 tx_power.ieee_mode = IPW_G_MODE;
2212 tx_power.num_channels = geo->bg_channels;
2213 for (i = 0; i < geo->bg_channels; i++) {
2214 max_power = geo->bg[i].max_power;
2215 tx_power.channels_tx_power[i].channel_number =
2217 tx_power.channels_tx_power[i].tx_power = max_power ?
2218 min(max_power, priv->tx_power) : priv->tx_power;
2220 if (ipw_send_tx_power(priv, &tx_power))
2223 /* configure device to also handle 'B' band */
2224 tx_power.ieee_mode = IPW_B_MODE;
2225 if (ipw_send_tx_power(priv, &tx_power))
2228 /* configure device to also handle 'A' band */
2229 if (priv->ieee->abg_true) {
2230 tx_power.ieee_mode = IPW_A_MODE;
2231 tx_power.num_channels = geo->a_channels;
2232 for (i = 0; i < tx_power.num_channels; i++) {
2233 max_power = geo->a[i].max_power;
2234 tx_power.channels_tx_power[i].channel_number =
2236 tx_power.channels_tx_power[i].tx_power = max_power ?
2237 min(max_power, priv->tx_power) : priv->tx_power;
2239 if (ipw_send_tx_power(priv, &tx_power))
2245 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2247 struct ipw_rts_threshold rts_threshold = {
2248 .rts_threshold = rts,
2250 struct host_cmd cmd = {
2251 .cmd = IPW_CMD_RTS_THRESHOLD,
2252 .len = sizeof(rts_threshold)
2256 IPW_ERROR("Invalid args\n");
2260 memcpy(cmd.param, &rts_threshold, sizeof(rts_threshold));
2261 return ipw_send_cmd(priv, &cmd);
2264 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2266 struct ipw_frag_threshold frag_threshold = {
2267 .frag_threshold = frag,
2269 struct host_cmd cmd = {
2270 .cmd = IPW_CMD_FRAG_THRESHOLD,
2271 .len = sizeof(frag_threshold)
2275 IPW_ERROR("Invalid args\n");
2279 memcpy(cmd.param, &frag_threshold, sizeof(frag_threshold));
2280 return ipw_send_cmd(priv, &cmd);
2283 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2285 struct host_cmd cmd = {
2286 .cmd = IPW_CMD_POWER_MODE,
2289 u32 *param = (u32 *) (&cmd.param);
2292 IPW_ERROR("Invalid args\n");
2296 /* If on battery, set to 3, if AC set to CAM, else user
2299 case IPW_POWER_BATTERY:
2300 *param = IPW_POWER_INDEX_3;
2303 *param = IPW_POWER_MODE_CAM;
2310 return ipw_send_cmd(priv, &cmd);
2313 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2315 struct ipw_retry_limit retry_limit = {
2316 .short_retry_limit = slimit,
2317 .long_retry_limit = llimit
2319 struct host_cmd cmd = {
2320 .cmd = IPW_CMD_RETRY_LIMIT,
2321 .len = sizeof(retry_limit)
2325 IPW_ERROR("Invalid args\n");
2329 memcpy(cmd.param, &retry_limit, sizeof(retry_limit));
2330 return ipw_send_cmd(priv, &cmd);
2334 * The IPW device contains a Microwire compatible EEPROM that stores
2335 * various data like the MAC address. Usually the firmware has exclusive
2336 * access to the eeprom, but during device initialization (before the
2337 * device driver has sent the HostComplete command to the firmware) the
2338 * device driver has read access to the EEPROM by way of indirect addressing
2339 * through a couple of memory mapped registers.
2341 * The following is a simplified implementation for pulling data out of the
2342 * the eeprom, along with some helper functions to find information in
2343 * the per device private data's copy of the eeprom.
2345 * NOTE: To better understand how these functions work (i.e what is a chip
2346 * select and why do have to keep driving the eeprom clock?), read
2347 * just about any data sheet for a Microwire compatible EEPROM.
2350 /* write a 32 bit value into the indirect accessor register */
2351 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2353 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2355 /* the eeprom requires some time to complete the operation */
2356 udelay(p->eeprom_delay);
2361 /* perform a chip select operation */
2362 static inline void eeprom_cs(struct ipw_priv *priv)
2364 eeprom_write_reg(priv, 0);
2365 eeprom_write_reg(priv, EEPROM_BIT_CS);
2366 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2367 eeprom_write_reg(priv, EEPROM_BIT_CS);
2370 /* perform a chip select operation */
2371 static inline void eeprom_disable_cs(struct ipw_priv *priv)
2373 eeprom_write_reg(priv, EEPROM_BIT_CS);
2374 eeprom_write_reg(priv, 0);
2375 eeprom_write_reg(priv, EEPROM_BIT_SK);
2378 /* push a single bit down to the eeprom */
2379 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2381 int d = (bit ? EEPROM_BIT_DI : 0);
2382 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2383 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2386 /* push an opcode followed by an address down to the eeprom */
2387 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2392 eeprom_write_bit(priv, 1);
2393 eeprom_write_bit(priv, op & 2);
2394 eeprom_write_bit(priv, op & 1);
2395 for (i = 7; i >= 0; i--) {
2396 eeprom_write_bit(priv, addr & (1 << i));
2400 /* pull 16 bits off the eeprom, one bit at a time */
2401 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2406 /* Send READ Opcode */
2407 eeprom_op(priv, EEPROM_CMD_READ, addr);
2409 /* Send dummy bit */
2410 eeprom_write_reg(priv, EEPROM_BIT_CS);
2412 /* Read the byte off the eeprom one bit at a time */
2413 for (i = 0; i < 16; i++) {
2415 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2416 eeprom_write_reg(priv, EEPROM_BIT_CS);
2417 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2418 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2421 /* Send another dummy bit */
2422 eeprom_write_reg(priv, 0);
2423 eeprom_disable_cs(priv);
2428 /* helper function for pulling the mac address out of the private */
2429 /* data's copy of the eeprom data */
2430 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2432 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
2436 * Either the device driver (i.e. the host) or the firmware can
2437 * load eeprom data into the designated region in SRAM. If neither
2438 * happens then the FW will shutdown with a fatal error.
2440 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2441 * bit needs region of shared SRAM needs to be non-zero.
2443 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2446 u16 *eeprom = (u16 *) priv->eeprom;
2448 IPW_DEBUG_TRACE(">>\n");
2450 /* read entire contents of eeprom into private buffer */
2451 for (i = 0; i < 128; i++)
2452 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
2455 If the data looks correct, then copy it to our private
2456 copy. Otherwise let the firmware know to perform the operation
2459 if ((priv->eeprom + EEPROM_VERSION) != 0) {
2460 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2462 /* write the eeprom data to sram */
2463 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2464 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2466 /* Do not load eeprom data on fatal error or suspend */
2467 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2469 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2471 /* Load eeprom data on fatal error or suspend */
2472 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2475 IPW_DEBUG_TRACE("<<\n");
2478 static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2483 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2485 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2488 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2490 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2491 CB_NUMBER_OF_ELEMENTS_SMALL *
2492 sizeof(struct command_block));
2495 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2496 { /* start dma engine but no transfers yet */
2498 IPW_DEBUG_FW(">> : \n");
2501 ipw_fw_dma_reset_command_blocks(priv);
2503 /* Write CB base address */
2504 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2506 IPW_DEBUG_FW("<< : \n");
2510 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2514 IPW_DEBUG_FW(">> :\n");
2516 //set the Stop and Abort bit
2517 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2518 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2519 priv->sram_desc.last_cb_index = 0;
2521 IPW_DEBUG_FW("<< \n");
2524 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2525 struct command_block *cb)
2528 IPW_SHARED_SRAM_DMA_CONTROL +
2529 (sizeof(struct command_block) * index);
2530 IPW_DEBUG_FW(">> :\n");
2532 ipw_write_indirect(priv, address, (u8 *) cb,
2533 (int)sizeof(struct command_block));
2535 IPW_DEBUG_FW("<< :\n");
2540 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2545 IPW_DEBUG_FW(">> :\n");
2547 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2548 ipw_fw_dma_write_command_block(priv, index,
2549 &priv->sram_desc.cb_list[index]);
2551 /* Enable the DMA in the CSR register */
2552 ipw_clear_bit(priv, IPW_RESET_REG,
2553 IPW_RESET_REG_MASTER_DISABLED |
2554 IPW_RESET_REG_STOP_MASTER);
2556 /* Set the Start bit. */
2557 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2558 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2560 IPW_DEBUG_FW("<< :\n");
2564 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2567 u32 register_value = 0;
2568 u32 cb_fields_address = 0;
2570 IPW_DEBUG_FW(">> :\n");
2571 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2572 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
2574 /* Read the DMA Controlor register */
2575 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2576 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
2578 /* Print the CB values */
2579 cb_fields_address = address;
2580 register_value = ipw_read_reg32(priv, cb_fields_address);
2581 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
2583 cb_fields_address += sizeof(u32);
2584 register_value = ipw_read_reg32(priv, cb_fields_address);
2585 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
2587 cb_fields_address += sizeof(u32);
2588 register_value = ipw_read_reg32(priv, cb_fields_address);
2589 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2592 cb_fields_address += sizeof(u32);
2593 register_value = ipw_read_reg32(priv, cb_fields_address);
2594 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
2596 IPW_DEBUG_FW(">> :\n");
2599 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2601 u32 current_cb_address = 0;
2602 u32 current_cb_index = 0;
2604 IPW_DEBUG_FW("<< :\n");
2605 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2607 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2608 sizeof(struct command_block);
2610 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
2611 current_cb_index, current_cb_address);
2613 IPW_DEBUG_FW(">> :\n");
2614 return current_cb_index;
2618 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2622 int interrupt_enabled, int is_last)
2625 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2626 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2628 struct command_block *cb;
2629 u32 last_cb_element = 0;
2631 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2632 src_address, dest_address, length);
2634 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2637 last_cb_element = priv->sram_desc.last_cb_index;
2638 cb = &priv->sram_desc.cb_list[last_cb_element];
2639 priv->sram_desc.last_cb_index++;
2641 /* Calculate the new CB control word */
2642 if (interrupt_enabled)
2643 control |= CB_INT_ENABLED;
2646 control |= CB_LAST_VALID;
2650 /* Calculate the CB Element's checksum value */
2651 cb->status = control ^ src_address ^ dest_address;
2653 /* Copy the Source and Destination addresses */
2654 cb->dest_addr = dest_address;
2655 cb->source_addr = src_address;
2657 /* Copy the Control Word last */
2658 cb->control = control;
2663 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
2664 u32 src_phys, u32 dest_address, u32 length)
2666 u32 bytes_left = length;
2668 u32 dest_offset = 0;
2670 IPW_DEBUG_FW(">> \n");
2671 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2672 src_phys, dest_address, length);
2673 while (bytes_left > CB_MAX_LENGTH) {
2674 status = ipw_fw_dma_add_command_block(priv,
2675 src_phys + src_offset,
2678 CB_MAX_LENGTH, 0, 0);
2680 IPW_DEBUG_FW_INFO(": Failed\n");
2683 IPW_DEBUG_FW_INFO(": Added new cb\n");
2685 src_offset += CB_MAX_LENGTH;
2686 dest_offset += CB_MAX_LENGTH;
2687 bytes_left -= CB_MAX_LENGTH;
2690 /* add the buffer tail */
2691 if (bytes_left > 0) {
2693 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2694 dest_address + dest_offset,
2697 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2701 (": Adding new cb - the buffer tail\n");
2704 IPW_DEBUG_FW("<< \n");
2708 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2710 u32 current_index = 0;
2713 IPW_DEBUG_FW(">> : \n");
2715 current_index = ipw_fw_dma_command_block_index(priv);
2716 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%8X\n",
2717 (int)priv->sram_desc.last_cb_index);
2719 while (current_index < priv->sram_desc.last_cb_index) {
2721 current_index = ipw_fw_dma_command_block_index(priv);
2725 if (watchdog > 400) {
2726 IPW_DEBUG_FW_INFO("Timeout\n");
2727 ipw_fw_dma_dump_command_block(priv);
2728 ipw_fw_dma_abort(priv);
2733 ipw_fw_dma_abort(priv);
2735 /*Disable the DMA in the CSR register */
2736 ipw_set_bit(priv, IPW_RESET_REG,
2737 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2739 IPW_DEBUG_FW("<< dmaWaitSync \n");
2743 static void ipw_remove_current_network(struct ipw_priv *priv)
2745 struct list_head *element, *safe;
2746 struct ieee80211_network *network = NULL;
2747 unsigned long flags;
2749 spin_lock_irqsave(&priv->ieee->lock, flags);
2750 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2751 network = list_entry(element, struct ieee80211_network, list);
2752 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2754 list_add_tail(&network->list,
2755 &priv->ieee->network_free_list);
2758 spin_unlock_irqrestore(&priv->ieee->lock, flags);
2762 * Check that card is still alive.
2763 * Reads debug register from domain0.
2764 * If card is present, pre-defined value should
2768 * @return 1 if card is present, 0 otherwise
2770 static inline int ipw_alive(struct ipw_priv *priv)
2772 return ipw_read32(priv, 0x90) == 0xd55555d5;
2775 static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2781 if ((ipw_read32(priv, addr) & mask) == mask)
2785 } while (i < timeout);
2790 /* These functions load the firmware and micro code for the operation of
2791 * the ipw hardware. It assumes the buffer has all the bits for the
2792 * image and the caller is handling the memory allocation and clean up.
2795 static int ipw_stop_master(struct ipw_priv *priv)
2799 IPW_DEBUG_TRACE(">> \n");
2800 /* stop master. typical delay - 0 */
2801 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2803 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2804 IPW_RESET_REG_MASTER_DISABLED, 100);
2806 IPW_ERROR("stop master failed in 10ms\n");
2810 IPW_DEBUG_INFO("stop master %dms\n", rc);
2815 static void ipw_arc_release(struct ipw_priv *priv)
2817 IPW_DEBUG_TRACE(">> \n");
2820 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2822 /* no one knows timing, for safety add some delay */
2836 #define IPW_FW_MAJOR_VERSION 2
2837 #define IPW_FW_MINOR_VERSION 4
2839 #define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2840 #define IPW_FW_MAJOR(x) (x & 0xff)
2842 #define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2844 #define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2845 "." __stringify(IPW_FW_MINOR_VERSION) "-"
2847 #if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2848 #define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2850 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2853 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2855 int rc = 0, i, addr;
2859 image = (u16 *) data;
2861 IPW_DEBUG_TRACE(">> \n");
2863 rc = ipw_stop_master(priv);
2868 // spin_lock_irqsave(&priv->lock, flags);
2870 for (addr = IPW_SHARED_LOWER_BOUND;
2871 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2872 ipw_write32(priv, addr, 0);
2875 /* no ucode (yet) */
2876 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2877 /* destroy DMA queues */
2878 /* reset sequence */
2880 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2881 ipw_arc_release(priv);
2882 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2886 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2889 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2892 /* enable ucode store */
2893 ipw_write_reg8(priv, DINO_CONTROL_REG, 0x0);
2894 ipw_write_reg8(priv, DINO_CONTROL_REG, DINO_ENABLE_CS);
2900 * Do NOT set indirect address register once and then
2901 * store data to indirect data register in the loop.
2902 * It seems very reasonable, but in this case DINO do not
2903 * accept ucode. It is essential to set address each time.
2905 /* load new ipw uCode */
2906 for (i = 0; i < len / 2; i++)
2907 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2908 cpu_to_le16(image[i]));
2911 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2912 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2914 /* this is where the igx / win driver deveates from the VAP driver. */
2916 /* wait for alive response */
2917 for (i = 0; i < 100; i++) {
2918 /* poll for incoming data */
2919 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2920 if (cr & DINO_RXFIFO_DATA)
2925 if (cr & DINO_RXFIFO_DATA) {
2926 /* alive_command_responce size is NOT multiple of 4 */
2927 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2929 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2930 response_buffer[i] =
2931 le32_to_cpu(ipw_read_reg32(priv,
2932 IPW_BASEBAND_RX_FIFO_READ));
2933 memcpy(&priv->dino_alive, response_buffer,
2934 sizeof(priv->dino_alive));
2935 if (priv->dino_alive.alive_command == 1
2936 && priv->dino_alive.ucode_valid == 1) {
2939 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2940 "of %02d/%02d/%02d %02d:%02d\n",
2941 priv->dino_alive.software_revision,
2942 priv->dino_alive.software_revision,
2943 priv->dino_alive.device_identifier,
2944 priv->dino_alive.device_identifier,
2945 priv->dino_alive.time_stamp[0],
2946 priv->dino_alive.time_stamp[1],
2947 priv->dino_alive.time_stamp[2],
2948 priv->dino_alive.time_stamp[3],
2949 priv->dino_alive.time_stamp[4]);
2951 IPW_DEBUG_INFO("Microcode is not alive\n");
2955 IPW_DEBUG_INFO("No alive response from DINO\n");
2959 /* disable DINO, otherwise for some reason
2960 firmware have problem getting alive resp. */
2961 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2963 // spin_unlock_irqrestore(&priv->lock, flags);
2968 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
2972 struct fw_chunk *chunk;
2973 dma_addr_t shared_phys;
2976 IPW_DEBUG_TRACE("<< : \n");
2977 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2982 memmove(shared_virt, data, len);
2985 rc = ipw_fw_dma_enable(priv);
2987 if (priv->sram_desc.last_cb_index > 0) {
2988 /* the DMA is already ready this would be a bug. */
2994 chunk = (struct fw_chunk *)(data + offset);
2995 offset += sizeof(struct fw_chunk);
2996 /* build DMA packet and queue up for sending */
2997 /* dma to chunk->address, the chunk->length bytes from data +
3000 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3001 le32_to_cpu(chunk->address),
3002 le32_to_cpu(chunk->length));
3004 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3008 offset += le32_to_cpu(chunk->length);
3009 } while (offset < len);
3011 /* Run the DMA and wait for the answer */
3012 rc = ipw_fw_dma_kick(priv);
3014 IPW_ERROR("dmaKick Failed\n");
3018 rc = ipw_fw_dma_wait(priv);
3020 IPW_ERROR("dmaWaitSync Failed\n");
3024 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
3029 static int ipw_stop_nic(struct ipw_priv *priv)
3034 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3036 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3037 IPW_RESET_REG_MASTER_DISABLED, 500);
3039 IPW_ERROR("wait for reg master disabled failed\n");
3043 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3048 static void ipw_start_nic(struct ipw_priv *priv)
3050 IPW_DEBUG_TRACE(">>\n");
3052 /* prvHwStartNic release ARC */
3053 ipw_clear_bit(priv, IPW_RESET_REG,
3054 IPW_RESET_REG_MASTER_DISABLED |
3055 IPW_RESET_REG_STOP_MASTER |
3056 CBD_RESET_REG_PRINCETON_RESET);
3058 /* enable power management */
3059 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3060 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3062 IPW_DEBUG_TRACE("<<\n");
3065 static int ipw_init_nic(struct ipw_priv *priv)
3069 IPW_DEBUG_TRACE(">>\n");
3072 /* set "initialization complete" bit to move adapter to D0 state */
3073 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3075 /* low-level PLL activation */
3076 ipw_write32(priv, IPW_READ_INT_REGISTER,
3077 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3079 /* wait for clock stabilization */
3080 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3081 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3083 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3085 /* assert SW reset */
3086 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3090 /* set "initialization complete" bit to move adapter to D0 state */
3091 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3093 IPW_DEBUG_TRACE(">>\n");
3097 /* Call this function from process context, it will sleep in request_firmware.
3098 * Probe is an ok place to call this from.
3100 static int ipw_reset_nic(struct ipw_priv *priv)
3103 unsigned long flags;
3105 IPW_DEBUG_TRACE(">>\n");
3107 rc = ipw_init_nic(priv);
3109 spin_lock_irqsave(&priv->lock, flags);
3110 /* Clear the 'host command active' bit... */
3111 priv->status &= ~STATUS_HCMD_ACTIVE;
3112 wake_up_interruptible(&priv->wait_command_queue);
3113 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3114 wake_up_interruptible(&priv->wait_state);
3115 spin_unlock_irqrestore(&priv->lock, flags);
3117 IPW_DEBUG_TRACE("<<\n");
3121 static int ipw_get_fw(struct ipw_priv *priv,
3122 const struct firmware **fw, const char *name)
3124 struct fw_header *header;
3127 /* ask firmware_class module to get the boot firmware off disk */
3128 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3130 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3134 header = (struct fw_header *)(*fw)->data;
3135 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
3136 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3138 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3139 IPW_FW_MAJOR_VERSION);
3143 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
3145 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3146 IPW_FW_MINOR(le32_to_cpu(header->version)),
3147 (*fw)->size - sizeof(struct fw_header));
3151 #define IPW_RX_BUF_SIZE (3000)
3153 static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
3154 struct ipw_rx_queue *rxq)
3156 unsigned long flags;
3159 spin_lock_irqsave(&rxq->lock, flags);
3161 INIT_LIST_HEAD(&rxq->rx_free);
3162 INIT_LIST_HEAD(&rxq->rx_used);
3164 /* Fill the rx_used queue with _all_ of the Rx buffers */
3165 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3166 /* In the reset function, these buffers may have been allocated
3167 * to an SKB, so we need to unmap and free potential storage */
3168 if (rxq->pool[i].skb != NULL) {
3169 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3170 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3171 dev_kfree_skb(rxq->pool[i].skb);
3172 rxq->pool[i].skb = NULL;
3174 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3177 /* Set us so that we have processed and used all buffers, but have
3178 * not restocked the Rx queue with fresh buffers */
3179 rxq->read = rxq->write = 0;
3180 rxq->processed = RX_QUEUE_SIZE - 1;
3181 rxq->free_count = 0;
3182 spin_unlock_irqrestore(&rxq->lock, flags);
3186 static int fw_loaded = 0;
3187 static const struct firmware *bootfw = NULL;
3188 static const struct firmware *firmware = NULL;
3189 static const struct firmware *ucode = NULL;
3191 static void free_firmware(void)
3194 release_firmware(bootfw);
3195 release_firmware(ucode);
3196 release_firmware(firmware);
3197 bootfw = ucode = firmware = NULL;
3202 #define free_firmware() do {} while (0)
3205 static int ipw_load(struct ipw_priv *priv)
3208 const struct firmware *bootfw = NULL;
3209 const struct firmware *firmware = NULL;
3210 const struct firmware *ucode = NULL;
3212 int rc = 0, retries = 3;
3217 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3221 switch (priv->ieee->iw_mode) {
3223 rc = ipw_get_fw(priv, &ucode,
3224 IPW_FW_NAME("ibss_ucode"));
3228 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
3231 #ifdef CONFIG_IPW2200_MONITOR
3232 case IW_MODE_MONITOR:
3233 rc = ipw_get_fw(priv, &ucode,
3234 IPW_FW_NAME("sniffer_ucode"));
3238 rc = ipw_get_fw(priv, &firmware,
3239 IPW_FW_NAME("sniffer"));
3243 rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
3247 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("bss"));
3263 priv->rxq = ipw_rx_queue_alloc(priv);
3265 ipw_rx_queue_reset(priv, priv->rxq);
3267 IPW_ERROR("Unable to initialize Rx queue\n");
3272 /* Ensure interrupts are disabled */
3273 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3274 priv->status &= ~STATUS_INT_ENABLED;
3276 /* ack pending interrupts */
3277 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3281 rc = ipw_reset_nic(priv);
3283 IPW_ERROR("Unable to reset NIC\n");
3287 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3288 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3290 /* DMA the initial boot firmware into the device */
3291 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
3292 bootfw->size - sizeof(struct fw_header));
3294 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3298 /* kick start the device */
3299 ipw_start_nic(priv);
3301 /* wait for the device to finish it's initial startup sequence */
3302 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3303 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3305 IPW_ERROR("device failed to boot initial fw image\n");
3308 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3310 /* ack fw init done interrupt */
3311 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3313 /* DMA the ucode into the device */
3314 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
3315 ucode->size - sizeof(struct fw_header));
3317 IPW_ERROR("Unable to load ucode: %d\n", rc);
3324 /* DMA bss firmware into the device */
3325 rc = ipw_load_firmware(priv, firmware->data +
3326 sizeof(struct fw_header),
3327 firmware->size - sizeof(struct fw_header));
3329 IPW_ERROR("Unable to load firmware: %d\n", rc);
3333 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3335 rc = ipw_queue_reset(priv);
3337 IPW_ERROR("Unable to initialize queues\n");
3341 /* Ensure interrupts are disabled */
3342 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3343 /* ack pending interrupts */
3344 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3346 /* kick start the device */
3347 ipw_start_nic(priv);
3349 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3351 IPW_WARNING("Parity error. Retrying init.\n");
3356 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3361 /* wait for the device */
3362 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3363 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3365 IPW_ERROR("device failed to start after 500ms\n");
3368 IPW_DEBUG_INFO("device response after %dms\n", rc);
3370 /* ack fw init done interrupt */
3371 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3373 /* read eeprom data and initialize the eeprom region of sram */
3374 priv->eeprom_delay = 1;
3375 ipw_eeprom_init_sram(priv);
3377 /* enable interrupts */
3378 ipw_enable_interrupts(priv);
3380 /* Ensure our queue has valid packets */
3381 ipw_rx_queue_replenish(priv);
3383 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3385 /* ack pending interrupts */
3386 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3389 release_firmware(bootfw);
3390 release_firmware(ucode);
3391 release_firmware(firmware);
3397 ipw_rx_queue_free(priv, priv->rxq);
3400 ipw_tx_queue_free(priv);
3402 release_firmware(bootfw);
3404 release_firmware(ucode);
3406 release_firmware(firmware);
3409 bootfw = ucode = firmware = NULL;
3418 * Theory of operation
3420 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3421 * 2 empty entries always kept in the buffer to protect from overflow.
3423 * For Tx queue, there are low mark and high mark limits. If, after queuing
3424 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3425 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3428 * The IPW operates with six queues, one receive queue in the device's
3429 * sram, one transmit queue for sending commands to the device firmware,
3430 * and four transmit queues for data.
3432 * The four transmit queues allow for performing quality of service (qos)
3433 * transmissions as per the 802.11 protocol. Currently Linux does not
3434 * provide a mechanism to the user for utilizing prioritized queues, so
3435 * we only utilize the first data transmit queue (queue1).
3439 * Driver allocates buffers of this size for Rx
3442 static inline int ipw_queue_space(const struct clx2_queue *q)
3444 int s = q->last_used - q->first_empty;
3447 s -= 2; /* keep some reserve to not confuse empty and full situations */
3453 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3455 return (++index == n_bd) ? 0 : index;
3459 * Initialize common DMA queue structure
3461 * @param q queue to init
3462 * @param count Number of BD's to allocate. Should be power of 2
3463 * @param read_register Address for 'read' register
3464 * (not offset within BAR, full address)
3465 * @param write_register Address for 'write' register
3466 * (not offset within BAR, full address)
3467 * @param base_register Address for 'base' register
3468 * (not offset within BAR, full address)
3469 * @param size Address for 'size' register
3470 * (not offset within BAR, full address)
3472 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3473 int count, u32 read, u32 write, u32 base, u32 size)
3477 q->low_mark = q->n_bd / 4;
3478 if (q->low_mark < 4)
3481 q->high_mark = q->n_bd / 8;
3482 if (q->high_mark < 2)
3485 q->first_empty = q->last_used = 0;
3489 ipw_write32(priv, base, q->dma_addr);
3490 ipw_write32(priv, size, count);
3491 ipw_write32(priv, read, 0);
3492 ipw_write32(priv, write, 0);
3494 _ipw_read32(priv, 0x90);
3497 static int ipw_queue_tx_init(struct ipw_priv *priv,
3498 struct clx2_tx_queue *q,
3499 int count, u32 read, u32 write, u32 base, u32 size)
3501 struct pci_dev *dev = priv->pci_dev;
3503 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3505 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3510 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3512 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3513 sizeof(q->bd[0]) * count);
3519 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3524 * Free one TFD, those at index [txq->q.last_used].
3525 * Do NOT advance any indexes
3530 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3531 struct clx2_tx_queue *txq)
3533 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3534 struct pci_dev *dev = priv->pci_dev;
3538 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3539 /* nothing to cleanup after for host commands */
3543 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3544 IPW_ERROR("Too many chunks: %i\n",
3545 le32_to_cpu(bd->u.data.num_chunks));
3546 /** @todo issue fatal error, it is quite serious situation */
3550 /* unmap chunks if any */
3551 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3552 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3553 le16_to_cpu(bd->u.data.chunk_len[i]),
3555 if (txq->txb[txq->q.last_used]) {
3556 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3557 txq->txb[txq->q.last_used] = NULL;
3563 * Deallocate DMA queue.
3565 * Empty queue by removing and destroying all BD's.
3571 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3573 struct clx2_queue *q = &txq->q;
3574 struct pci_dev *dev = priv->pci_dev;
3579 /* first, empty all BD's */
3580 for (; q->first_empty != q->last_used;
3581 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3582 ipw_queue_tx_free_tfd(priv, txq);
3585 /* free buffers belonging to queue itself */
3586 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3590 /* 0 fill whole structure */
3591 memset(txq, 0, sizeof(*txq));
3595 * Destroy all DMA queues and structures
3599 static void ipw_tx_queue_free(struct ipw_priv *priv)
3602 ipw_queue_tx_free(priv, &priv->txq_cmd);
3605 ipw_queue_tx_free(priv, &priv->txq[0]);
3606 ipw_queue_tx_free(priv, &priv->txq[1]);
3607 ipw_queue_tx_free(priv, &priv->txq[2]);
3608 ipw_queue_tx_free(priv, &priv->txq[3]);
3611 static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3613 /* First 3 bytes are manufacturer */
3614 bssid[0] = priv->mac_addr[0];
3615 bssid[1] = priv->mac_addr[1];
3616 bssid[2] = priv->mac_addr[2];
3618 /* Last bytes are random */
3619 get_random_bytes(&bssid[3], ETH_ALEN - 3);
3621 bssid[0] &= 0xfe; /* clear multicast bit */
3622 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
3625 static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3627 struct ipw_station_entry entry;
3630 for (i = 0; i < priv->num_stations; i++) {
3631 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3632 /* Another node is active in network */
3633 priv->missed_adhoc_beacons = 0;
3634 if (!(priv->config & CFG_STATIC_CHANNEL))
3635 /* when other nodes drop out, we drop out */
3636 priv->config &= ~CFG_ADHOC_PERSIST;
3642 if (i == MAX_STATIONS)
3643 return IPW_INVALID_STATION;
3645 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3648 entry.support_mode = 0;
3649 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3650 memcpy(priv->stations[i], bssid, ETH_ALEN);
3651 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3652 &entry, sizeof(entry));
3653 priv->num_stations++;
3658 static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3662 for (i = 0; i < priv->num_stations; i++)
3663 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3666 return IPW_INVALID_STATION;
3669 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3673 if (priv->status & STATUS_ASSOCIATING) {
3674 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3675 queue_work(priv->workqueue, &priv->disassociate);
3679 if (!(priv->status & STATUS_ASSOCIATED)) {
3680 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3684 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3686 MAC_ARG(priv->assoc_request.bssid),
3687 priv->assoc_request.channel);
3689 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3690 priv->status |= STATUS_DISASSOCIATING;
3693 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3695 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3697 err = ipw_send_associate(priv, &priv->assoc_request);
3699 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3706 static int ipw_disassociate(void *data)
3708 struct ipw_priv *priv = data;
3709 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3711 ipw_send_disassociate(data, 0);
3715 static void ipw_bg_disassociate(void *data)
3717 struct ipw_priv *priv = data;
3719 ipw_disassociate(data);
3723 static void ipw_system_config(void *data)
3725 struct ipw_priv *priv = data;
3726 ipw_send_system_config(priv, &priv->sys_config);
3729 struct ipw_status_code {
3734 static const struct ipw_status_code ipw_status_codes[] = {
3735 {0x00, "Successful"},
3736 {0x01, "Unspecified failure"},
3737 {0x0A, "Cannot support all requested capabilities in the "
3738 "Capability information field"},
3739 {0x0B, "Reassociation denied due to inability to confirm that "
3740 "association exists"},
3741 {0x0C, "Association denied due to reason outside the scope of this "
3744 "Responding station does not support the specified authentication "
3747 "Received an Authentication frame with authentication sequence "
3748 "transaction sequence number out of expected sequence"},
3749 {0x0F, "Authentication rejected because of challenge failure"},
3750 {0x10, "Authentication rejected due to timeout waiting for next "
3751 "frame in sequence"},
3752 {0x11, "Association denied because AP is unable to handle additional "
3753 "associated stations"},
3755 "Association denied due to requesting station not supporting all "
3756 "of the datarates in the BSSBasicServiceSet Parameter"},
3758 "Association denied due to requesting station not supporting "
3759 "short preamble operation"},
3761 "Association denied due to requesting station not supporting "
3764 "Association denied due to requesting station not supporting "
3767 "Association denied due to requesting station not supporting "
3768 "short slot operation"},
3770 "Association denied due to requesting station not supporting "
3771 "DSSS-OFDM operation"},
3772 {0x28, "Invalid Information Element"},
3773 {0x29, "Group Cipher is not valid"},
3774 {0x2A, "Pairwise Cipher is not valid"},
3775 {0x2B, "AKMP is not valid"},
3776 {0x2C, "Unsupported RSN IE version"},
3777 {0x2D, "Invalid RSN IE Capabilities"},
3778 {0x2E, "Cipher suite is rejected per security policy"},
3781 #ifdef CONFIG_IPW2200_DEBUG
3782 static const char *ipw_get_status_code(u16 status)
3785 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3786 if (ipw_status_codes[i].status == (status & 0xff))
3787 return ipw_status_codes[i].reason;
3788 return "Unknown status value.";
3792 static void inline average_init(struct average *avg)
3794 memset(avg, 0, sizeof(*avg));
3797 static void inline average_add(struct average *avg, s16 val)
3799 avg->sum -= avg->entries[avg->pos];
3801 avg->entries[avg->pos++] = val;
3802 if (unlikely(avg->pos == AVG_ENTRIES)) {
3808 static s16 inline average_value(struct average *avg)
3810 if (!unlikely(avg->init)) {
3812 return avg->sum / avg->pos;
3816 return avg->sum / AVG_ENTRIES;
3819 static void ipw_reset_stats(struct ipw_priv *priv)
3821 u32 len = sizeof(u32);
3825 average_init(&priv->average_missed_beacons);
3826 average_init(&priv->average_rssi);
3827 average_init(&priv->average_noise);
3829 priv->last_rate = 0;
3830 priv->last_missed_beacons = 0;
3831 priv->last_rx_packets = 0;
3832 priv->last_tx_packets = 0;
3833 priv->last_tx_failures = 0;
3835 /* Firmware managed, reset only when NIC is restarted, so we have to
3836 * normalize on the current value */
3837 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
3838 &priv->last_rx_err, &len);
3839 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
3840 &priv->last_tx_failures, &len);
3842 /* Driver managed, reset with each association */
3843 priv->missed_adhoc_beacons = 0;
3844 priv->missed_beacons = 0;
3845 priv->tx_packets = 0;
3846 priv->rx_packets = 0;
3850 static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
3853 u32 mask = priv->rates_mask;
3854 /* If currently associated in B mode, restrict the maximum
3855 * rate match to B rates */
3856 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3857 mask &= IEEE80211_CCK_RATES_MASK;
3859 /* TODO: Verify that the rate is supported by the current rates
3862 while (i && !(mask & i))
3865 case IEEE80211_CCK_RATE_1MB_MASK:
3867 case IEEE80211_CCK_RATE_2MB_MASK:
3869 case IEEE80211_CCK_RATE_5MB_MASK:
3871 case IEEE80211_OFDM_RATE_6MB_MASK:
3873 case IEEE80211_OFDM_RATE_9MB_MASK:
3875 case IEEE80211_CCK_RATE_11MB_MASK:
3877 case IEEE80211_OFDM_RATE_12MB_MASK:
3879 case IEEE80211_OFDM_RATE_18MB_MASK:
3881 case IEEE80211_OFDM_RATE_24MB_MASK:
3883 case IEEE80211_OFDM_RATE_36MB_MASK:
3885 case IEEE80211_OFDM_RATE_48MB_MASK:
3887 case IEEE80211_OFDM_RATE_54MB_MASK:
3891 if (priv->ieee->mode == IEEE_B)
3897 static u32 ipw_get_current_rate(struct ipw_priv *priv)
3899 u32 rate, len = sizeof(rate);
3902 if (!(priv->status & STATUS_ASSOCIATED))
3905 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3906 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
3909 IPW_DEBUG_INFO("failed querying ordinals.\n");
3913 return ipw_get_max_rate(priv);
3916 case IPW_TX_RATE_1MB:
3918 case IPW_TX_RATE_2MB:
3920 case IPW_TX_RATE_5MB:
3922 case IPW_TX_RATE_6MB:
3924 case IPW_TX_RATE_9MB:
3926 case IPW_TX_RATE_11MB:
3928 case IPW_TX_RATE_12MB:
3930 case IPW_TX_RATE_18MB:
3932 case IPW_TX_RATE_24MB:
3934 case IPW_TX_RATE_36MB:
3936 case IPW_TX_RATE_48MB:
3938 case IPW_TX_RATE_54MB:
3945 #define IPW_STATS_INTERVAL (2 * HZ)
3946 static void ipw_gather_stats(struct ipw_priv *priv)
3948 u32 rx_err, rx_err_delta, rx_packets_delta;
3949 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3950 u32 missed_beacons_percent, missed_beacons_delta;
3952 u32 len = sizeof(u32);
3954 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3958 if (!(priv->status & STATUS_ASSOCIATED)) {
3963 /* Update the statistics */
3964 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
3965 &priv->missed_beacons, &len);
3966 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
3967 priv->last_missed_beacons = priv->missed_beacons;
3968 if (priv->assoc_request.beacon_interval) {
3969 missed_beacons_percent = missed_beacons_delta *
3970 (HZ * priv->assoc_request.beacon_interval) /
3971 (IPW_STATS_INTERVAL * 10);
3973 missed_beacons_percent = 0;
3975 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3977 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3978 rx_err_delta = rx_err - priv->last_rx_err;
3979 priv->last_rx_err = rx_err;
3981 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3982 tx_failures_delta = tx_failures - priv->last_tx_failures;
3983 priv->last_tx_failures = tx_failures;
3985 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
3986 priv->last_rx_packets = priv->rx_packets;
3988 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
3989 priv->last_tx_packets = priv->tx_packets;
3991 /* Calculate quality based on the following:
3993 * Missed beacon: 100% = 0, 0% = 70% missed
3994 * Rate: 60% = 1Mbs, 100% = Max
3995 * Rx and Tx errors represent a straight % of total Rx/Tx
3996 * RSSI: 100% = > -50, 0% = < -80
3997 * Rx errors: 100% = 0, 0% = 50% missed
3999 * The lowest computed quality is used.
4002 #define BEACON_THRESHOLD 5
4003 beacon_quality = 100 - missed_beacons_percent;
4004 if (beacon_quality < BEACON_THRESHOLD)
4007 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4008 (100 - BEACON_THRESHOLD);
4009 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4010 beacon_quality, missed_beacons_percent);
4012 priv->last_rate = ipw_get_current_rate(priv);
4013 max_rate = ipw_get_max_rate(priv);
4014 rate_quality = priv->last_rate * 40 / max_rate + 60;
4015 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4016 rate_quality, priv->last_rate / 1000000);
4018 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4019 rx_quality = 100 - (rx_err_delta * 100) /
4020 (rx_packets_delta + rx_err_delta);
4023 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4024 rx_quality, rx_err_delta, rx_packets_delta);
4026 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4027 tx_quality = 100 - (tx_failures_delta * 100) /
4028 (tx_packets_delta + tx_failures_delta);
4031 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4032 tx_quality, tx_failures_delta, tx_packets_delta);
4034 rssi = average_value(&priv->average_rssi);
4037 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4038 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4039 (priv->ieee->perfect_rssi - rssi) *
4040 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4041 62 * (priv->ieee->perfect_rssi - rssi))) /
4042 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4043 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4044 if (signal_quality > 100)
4045 signal_quality = 100;
4046 else if (signal_quality < 1)
4049 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4050 signal_quality, rssi);
4052 quality = min(beacon_quality,
4054 min(tx_quality, min(rx_quality, signal_quality))));
4055 if (quality == beacon_quality)
4056 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4058 if (quality == rate_quality)
4059 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4061 if (quality == tx_quality)
4062 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4064 if (quality == rx_quality)
4065 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4067 if (quality == signal_quality)
4068 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4071 priv->quality = quality;
4073 queue_delayed_work(priv->workqueue, &priv->gather_stats,
4074 IPW_STATS_INTERVAL);
4077 static void ipw_bg_gather_stats(void *data)
4079 struct ipw_priv *priv = data;
4081 ipw_gather_stats(data);
4085 /* Missed beacon behavior:
4086 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4087 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4088 * Above disassociate threshold, give up and stop scanning.
4089 * Roaming is disabled if disassociate_threshold <= roaming_threshold */
4090 static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
4093 priv->notif_missed_beacons = missed_count;
4095 if (missed_count > priv->disassociate_threshold &&
4096 priv->status & STATUS_ASSOCIATED) {
4097 /* If associated and we've hit the missed
4098 * beacon threshold, disassociate, turn
4099 * off roaming, and abort any active scans */
4100 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4101 IPW_DL_STATE | IPW_DL_ASSOC,
4102 "Missed beacon: %d - disassociate\n", missed_count);
4103 priv->status &= ~STATUS_ROAMING;
4104 if (priv->status & STATUS_SCANNING) {
4105 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4107 "Aborting scan with missed beacon.\n");
4108 queue_work(priv->workqueue, &priv->abort_scan);
4111 queue_work(priv->workqueue, &priv->disassociate);
4115 if (priv->status & STATUS_ROAMING) {
4116 /* If we are currently roaming, then just
4117 * print a debug statement... */
4118 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4119 "Missed beacon: %d - roam in progress\n",
4124 if (missed_count > priv->roaming_threshold &&
4125 missed_count <= priv->disassociate_threshold) {
4126 /* If we are not already roaming, set the ROAM
4127 * bit in the status and kick off a scan.
4128 * This can happen several times before we reach
4129 * disassociate_threshold. */
4130 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4131 "Missed beacon: %d - initiate "
4132 "roaming\n", missed_count);
4133 if (!(priv->status & STATUS_ROAMING)) {
4134 priv->status |= STATUS_ROAMING;
4135 if (!(priv->status & STATUS_SCANNING))
4136 queue_work(priv->workqueue,
4137 &priv->request_scan);
4142 if (priv->status & STATUS_SCANNING) {
4143 /* Stop scan to keep fw from getting
4144 * stuck (only if we aren't roaming --
4145 * otherwise we'll never scan more than 2 or 3
4147 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4148 "Aborting scan with missed beacon.\n");
4149 queue_work(priv->workqueue, &priv->abort_scan);
4152 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4157 * Handle host notification packet.
4158 * Called from interrupt routine
4160 static inline void ipw_rx_notification(struct ipw_priv *priv,
4161 struct ipw_rx_notification *notif)
4163 notif->size = le16_to_cpu(notif->size);
4165 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4167 switch (notif->subtype) {
4168 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4169 struct notif_association *assoc = ¬if->u.assoc;
4171 switch (assoc->state) {
4172 case CMAS_ASSOCIATED:{
4173 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4175 "associated: '%s' " MAC_FMT
4177 escape_essid(priv->essid,
4179 MAC_ARG(priv->bssid));
4181 switch (priv->ieee->iw_mode) {
4183 memcpy(priv->ieee->bssid,
4184 priv->bssid, ETH_ALEN);
4188 memcpy(priv->ieee->bssid,
4189 priv->bssid, ETH_ALEN);
4191 /* clear out the station table */
4192 priv->num_stations = 0;
4195 ("queueing adhoc check\n");
4196 queue_delayed_work(priv->
4206 priv->status &= ~STATUS_ASSOCIATING;
4207 priv->status |= STATUS_ASSOCIATED;
4208 queue_work(priv->workqueue,
4209 &priv->system_config);
4211 #ifdef CONFIG_IPW_QOS
4212 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4213 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4214 if ((priv->status & STATUS_AUTH) &&
4215 (IPW_GET_PACKET_STYPE(¬if->u.raw)
4216 == IEEE80211_STYPE_ASSOC_RESP)) {
4219 ieee80211_assoc_response)
4221 && (notif->size <= 2314)) {
4234 ieee80211_rx_mgt(priv->
4239 ¬if->u.raw, &stats);
4244 schedule_work(&priv->link_up);
4249 case CMAS_AUTHENTICATED:{
4251 status & (STATUS_ASSOCIATED |
4253 #ifdef CONFIG_IPW2200_DEBUG
4254 struct notif_authenticate *auth
4256 IPW_DEBUG(IPW_DL_NOTIF |
4259 "deauthenticated: '%s' "
4261 ": (0x%04X) - %s \n",
4266 MAC_ARG(priv->bssid),
4267 ntohs(auth->status),
4274 ~(STATUS_ASSOCIATING |
4278 schedule_work(&priv->link_down);
4282 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4284 "authenticated: '%s' " MAC_FMT
4286 escape_essid(priv->essid,
4288 MAC_ARG(priv->bssid));
4293 if (priv->status & STATUS_AUTH) {
4295 ieee80211_assoc_response
4299 ieee80211_assoc_response
4301 IPW_DEBUG(IPW_DL_NOTIF |
4304 "association failed (0x%04X): %s\n",
4305 ntohs(resp->status),
4311 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4313 "disassociated: '%s' " MAC_FMT
4315 escape_essid(priv->essid,
4317 MAC_ARG(priv->bssid));
4320 ~(STATUS_DISASSOCIATING |
4321 STATUS_ASSOCIATING |
4322 STATUS_ASSOCIATED | STATUS_AUTH);
4323 if (priv->assoc_network
4324 && (priv->assoc_network->
4326 WLAN_CAPABILITY_IBSS))
4327 ipw_remove_current_network
4330 schedule_work(&priv->link_down);
4335 case CMAS_RX_ASSOC_RESP:
4339 IPW_ERROR("assoc: unknown (%d)\n",
4347 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4348 struct notif_authenticate *auth = ¬if->u.auth;
4349 switch (auth->state) {
4350 case CMAS_AUTHENTICATED:
4351 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4352 "authenticated: '%s' " MAC_FMT " \n",
4353 escape_essid(priv->essid,
4355 MAC_ARG(priv->bssid));
4356 priv->status |= STATUS_AUTH;
4360 if (priv->status & STATUS_AUTH) {
4361 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4363 "authentication failed (0x%04X): %s\n",
4364 ntohs(auth->status),
4365 ipw_get_status_code(ntohs
4369 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4371 "deauthenticated: '%s' " MAC_FMT "\n",
4372 escape_essid(priv->essid,
4374 MAC_ARG(priv->bssid));
4376 priv->status &= ~(STATUS_ASSOCIATING |
4380 schedule_work(&priv->link_down);
4383 case CMAS_TX_AUTH_SEQ_1:
4384 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4385 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4387 case CMAS_RX_AUTH_SEQ_2:
4388 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4389 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4391 case CMAS_AUTH_SEQ_1_PASS:
4392 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4393 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4395 case CMAS_AUTH_SEQ_1_FAIL:
4396 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4397 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4399 case CMAS_TX_AUTH_SEQ_3:
4400 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4401 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4403 case CMAS_RX_AUTH_SEQ_4:
4404 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4405 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4407 case CMAS_AUTH_SEQ_2_PASS:
4408 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4409 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4411 case CMAS_AUTH_SEQ_2_FAIL:
4412 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4413 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4416 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4417 IPW_DL_ASSOC, "TX_ASSOC\n");
4419 case CMAS_RX_ASSOC_RESP:
4420 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4421 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4424 case CMAS_ASSOCIATED:
4425 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4426 IPW_DL_ASSOC, "ASSOCIATED\n");
4429 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4436 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4437 struct notif_channel_result *x =
4438 ¬if->u.channel_result;
4440 if (notif->size == sizeof(*x)) {
4441 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4444 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4445 "(should be %zd)\n",
4446 notif->size, sizeof(*x));
4451 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4452 struct notif_scan_complete *x = ¬if->u.scan_complete;
4453 if (notif->size == sizeof(*x)) {
4455 ("Scan completed: type %d, %d channels, "
4456 "%d status\n", x->scan_type,
4457 x->num_channels, x->status);
4459 IPW_ERROR("Scan completed of wrong size %d "
4460 "(should be %zd)\n",
4461 notif->size, sizeof(*x));
4465 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4467 wake_up_interruptible(&priv->wait_state);
4468 cancel_delayed_work(&priv->scan_check);
4470 if (priv->status & STATUS_EXIT_PENDING)
4473 priv->ieee->scans++;
4475 #ifdef CONFIG_IPW2200_MONITOR
4476 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4477 priv->status |= STATUS_SCAN_FORCED;
4478 queue_work(priv->workqueue,
4479 &priv->request_scan);
4482 priv->status &= ~STATUS_SCAN_FORCED;
4483 #endif /* CONFIG_IPW2200_MONITOR */
4485 if (!(priv->status & (STATUS_ASSOCIATED |
4486 STATUS_ASSOCIATING |
4488 STATUS_DISASSOCIATING)))
4489 queue_work(priv->workqueue, &priv->associate);
4490 else if (priv->status & STATUS_ROAMING) {
4491 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4492 /* If a scan completed and we are in roam mode, then
4493 * the scan that completed was the one requested as a
4494 * result of entering roam... so, schedule the
4496 queue_work(priv->workqueue,
4499 /* Don't schedule if we aborted the scan */
4500 priv->status &= ~STATUS_ROAMING;
4501 } else if (priv->status & STATUS_SCAN_PENDING)
4502 queue_work(priv->workqueue,
4503 &priv->request_scan);
4504 else if (priv->config & CFG_BACKGROUND_SCAN
4505 && priv->status & STATUS_ASSOCIATED)
4506 queue_delayed_work(priv->workqueue,
4507 &priv->request_scan, HZ);
4511 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4512 struct notif_frag_length *x = ¬if->u.frag_len;
4514 if (notif->size == sizeof(*x))
4515 IPW_ERROR("Frag length: %d\n",
4516 le16_to_cpu(x->frag_length));
4518 IPW_ERROR("Frag length of wrong size %d "
4519 "(should be %zd)\n",
4520 notif->size, sizeof(*x));
4524 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4525 struct notif_link_deterioration *x =
4526 ¬if->u.link_deterioration;
4528 if (notif->size == sizeof(*x)) {
4529 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4530 "link deterioration: '%s' " MAC_FMT
4531 " \n", escape_essid(priv->essid,
4533 MAC_ARG(priv->bssid));
4534 memcpy(&priv->last_link_deterioration, x,
4537 IPW_ERROR("Link Deterioration of wrong size %d "
4538 "(should be %zd)\n",
4539 notif->size, sizeof(*x));
4544 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4545 IPW_ERROR("Dino config\n");
4547 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4548 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4553 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4554 struct notif_beacon_state *x = ¬if->u.beacon_state;
4555 if (notif->size != sizeof(*x)) {
4557 ("Beacon state of wrong size %d (should "
4558 "be %zd)\n", notif->size, sizeof(*x));
4562 if (le32_to_cpu(x->state) ==
4563 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4564 ipw_handle_missed_beacon(priv,
4571 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4572 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4573 if (notif->size == sizeof(*x)) {
4574 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4575 "0x%02x station %d\n",
4576 x->key_state, x->security_type,
4582 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4583 notif->size, sizeof(*x));
4587 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4588 struct notif_calibration *x = ¬if->u.calibration;
4590 if (notif->size == sizeof(*x)) {
4591 memcpy(&priv->calib, x, sizeof(*x));
4592 IPW_DEBUG_INFO("TODO: Calibration\n");
4597 ("Calibration of wrong size %d (should be %zd)\n",
4598 notif->size, sizeof(*x));
4602 case HOST_NOTIFICATION_NOISE_STATS:{
4603 if (notif->size == sizeof(u32)) {
4605 (u8) (le32_to_cpu(notif->u.noise.value) &
4607 average_add(&priv->average_noise,
4613 ("Noise stat is wrong size %d (should be %zd)\n",
4614 notif->size, sizeof(u32));
4619 IPW_ERROR("Unknown notification: "
4620 "subtype=%d,flags=0x%2x,size=%d\n",
4621 notif->subtype, notif->flags, notif->size);
4626 * Destroys all DMA structures and initialise them again
4629 * @return error code
4631 static int ipw_queue_reset(struct ipw_priv *priv)
4634 /** @todo customize queue sizes */
4635 int nTx = 64, nTxCmd = 8;
4636 ipw_tx_queue_free(priv);
4638 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4639 IPW_TX_CMD_QUEUE_READ_INDEX,
4640 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4641 IPW_TX_CMD_QUEUE_BD_BASE,
4642 IPW_TX_CMD_QUEUE_BD_SIZE);
4644 IPW_ERROR("Tx Cmd queue init failed\n");
4648 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4649 IPW_TX_QUEUE_0_READ_INDEX,
4650 IPW_TX_QUEUE_0_WRITE_INDEX,
4651 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4653 IPW_ERROR("Tx 0 queue init failed\n");
4656 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4657 IPW_TX_QUEUE_1_READ_INDEX,
4658 IPW_TX_QUEUE_1_WRITE_INDEX,
4659 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4661 IPW_ERROR("Tx 1 queue init failed\n");
4664 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4665 IPW_TX_QUEUE_2_READ_INDEX,
4666 IPW_TX_QUEUE_2_WRITE_INDEX,
4667 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4669 IPW_ERROR("Tx 2 queue init failed\n");
4672 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4673 IPW_TX_QUEUE_3_READ_INDEX,
4674 IPW_TX_QUEUE_3_WRITE_INDEX,
4675 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4677 IPW_ERROR("Tx 3 queue init failed\n");
4681 priv->rx_bufs_min = 0;
4682 priv->rx_pend_max = 0;
4686 ipw_tx_queue_free(priv);
4691 * Reclaim Tx queue entries no more used by NIC.
4693 * When FW adwances 'R' index, all entries between old and
4694 * new 'R' index need to be reclaimed. As result, some free space
4695 * forms. If there is enough free space (> low mark), wake Tx queue.
4697 * @note Need to protect against garbage in 'R' index
4701 * @return Number of used entries remains in the queue
4703 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4704 struct clx2_tx_queue *txq, int qindex)
4708 struct clx2_queue *q = &txq->q;
4710 hw_tail = ipw_read32(priv, q->reg_r);
4711 if (hw_tail >= q->n_bd) {
4713 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4717 for (; q->last_used != hw_tail;
4718 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4719 ipw_queue_tx_free_tfd(priv, txq);
4723 if ((ipw_queue_space(q) > q->low_mark) &&
4725 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4726 netif_wake_queue(priv->net_dev);
4727 used = q->first_empty - q->last_used;
4734 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4737 struct clx2_tx_queue *txq = &priv->txq_cmd;
4738 struct clx2_queue *q = &txq->q;
4739 struct tfd_frame *tfd;
4741 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4742 IPW_ERROR("No space for Tx\n");
4746 tfd = &txq->bd[q->first_empty];
4747 txq->txb[q->first_empty] = NULL;
4749 memset(tfd, 0, sizeof(*tfd));
4750 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4751 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4753 tfd->u.cmd.index = hcmd;
4754 tfd->u.cmd.length = len;
4755 memcpy(tfd->u.cmd.payload, buf, len);
4756 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4757 ipw_write32(priv, q->reg_w, q->first_empty);
4758 _ipw_read32(priv, 0x90);
4764 * Rx theory of operation
4766 * The host allocates 32 DMA target addresses and passes the host address
4767 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4771 * The host/firmware share two index registers for managing the Rx buffers.
4773 * The READ index maps to the first position that the firmware may be writing
4774 * to -- the driver can read up to (but not including) this position and get
4776 * The READ index is managed by the firmware once the card is enabled.
4778 * The WRITE index maps to the last position the driver has read from -- the
4779 * position preceding WRITE is the last slot the firmware can place a packet.
4781 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4784 * During initialization the host sets up the READ queue position to the first
4785 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4787 * When the firmware places a packet in a buffer it will advance the READ index
4788 * and fire the RX interrupt. The driver can then query the READ index and
4789 * process as many packets as possible, moving the WRITE index forward as it
4790 * resets the Rx queue buffers with new memory.
4792 * The management in the driver is as follows:
4793 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
4794 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4795 * to replensish the ipw->rxq->rx_free.
4796 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4797 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4798 * 'processed' and 'read' driver indexes as well)
4799 * + A received packet is processed and handed to the kernel network stack,
4800 * detached from the ipw->rxq. The driver 'processed' index is updated.
4801 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4802 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4803 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
4804 * were enough free buffers and RX_STALLED is set it is cleared.
4809 * ipw_rx_queue_alloc() Allocates rx_free
4810 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4811 * ipw_rx_queue_restock
4812 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4813 * queue, updates firmware pointers, and updates
4814 * the WRITE index. If insufficient rx_free buffers
4815 * are available, schedules ipw_rx_queue_replenish
4817 * -- enable interrupts --
4818 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
4819 * READ INDEX, detaching the SKB from the pool.
4820 * Moves the packet buffer from queue to rx_used.
4821 * Calls ipw_rx_queue_restock to refill any empty
4828 * If there are slots in the RX queue that need to be restocked,
4829 * and we have free pre-allocated buffers, fill the ranks as much
4830 * as we can pulling from rx_free.
4832 * This moves the 'write' index forward to catch up with 'processed', and
4833 * also updates the memory address in the firmware to reference the new
4836 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4838 struct ipw_rx_queue *rxq = priv->rxq;
4839 struct list_head *element;
4840 struct ipw_rx_mem_buffer *rxb;
4841 unsigned long flags;
4844 spin_lock_irqsave(&rxq->lock, flags);
4846 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4847 element = rxq->rx_free.next;
4848 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4851 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4853 rxq->queue[rxq->write] = rxb;
4854 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4857 spin_unlock_irqrestore(&rxq->lock, flags);
4859 /* If the pre-allocated buffer pool is dropping low, schedule to
4861 if (rxq->free_count <= RX_LOW_WATERMARK)
4862 queue_work(priv->workqueue, &priv->rx_replenish);
4864 /* If we've added more space for the firmware to place data, tell it */
4865 if (write != rxq->write)
4866 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4870 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4871 * Also restock the Rx queue via ipw_rx_queue_restock.
4873 * This is called as a scheduled work item (except for during intialization)
4875 static void ipw_rx_queue_replenish(void *data)
4877 struct ipw_priv *priv = data;
4878 struct ipw_rx_queue *rxq = priv->rxq;
4879 struct list_head *element;
4880 struct ipw_rx_mem_buffer *rxb;
4881 unsigned long flags;
4883 spin_lock_irqsave(&rxq->lock, flags);
4884 while (!list_empty(&rxq->rx_used)) {
4885 element = rxq->rx_used.next;
4886 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4887 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4889 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4890 priv->net_dev->name);
4891 /* We don't reschedule replenish work here -- we will
4892 * call the restock method and if it still needs
4893 * more buffers it will schedule replenish */
4898 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4900 pci_map_single(priv->pci_dev, rxb->skb->data,
4901 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4903 list_add_tail(&rxb->list, &rxq->rx_free);
4906 spin_unlock_irqrestore(&rxq->lock, flags);
4908 ipw_rx_queue_restock(priv);
4911 static void ipw_bg_rx_queue_replenish(void *data)
4913 struct ipw_priv *priv = data;
4915 ipw_rx_queue_replenish(data);
4919 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4920 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL
4921 * This free routine walks the list of POOL entries and if SKB is set to
4922 * non NULL it is unmapped and freed
4924 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4931 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4932 if (rxq->pool[i].skb != NULL) {
4933 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4934 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4935 dev_kfree_skb(rxq->pool[i].skb);
4942 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4944 struct ipw_rx_queue *rxq;
4947 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
4948 if (unlikely(!rxq)) {
4949 IPW_ERROR("memory allocation failed\n");
4952 spin_lock_init(&rxq->lock);
4953 INIT_LIST_HEAD(&rxq->rx_free);
4954 INIT_LIST_HEAD(&rxq->rx_used);
4956 /* Fill the rx_used queue with _all_ of the Rx buffers */
4957 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
4958 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4960 /* Set us so that we have processed and used all buffers, but have
4961 * not restocked the Rx queue with fresh buffers */
4962 rxq->read = rxq->write = 0;
4963 rxq->processed = RX_QUEUE_SIZE - 1;
4964 rxq->free_count = 0;
4969 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4971 rate &= ~IEEE80211_BASIC_RATE_MASK;
4972 if (ieee_mode == IEEE_A) {
4974 case IEEE80211_OFDM_RATE_6MB:
4975 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4977 case IEEE80211_OFDM_RATE_9MB:
4978 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4980 case IEEE80211_OFDM_RATE_12MB:
4982 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4983 case IEEE80211_OFDM_RATE_18MB:
4985 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
4986 case IEEE80211_OFDM_RATE_24MB:
4988 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
4989 case IEEE80211_OFDM_RATE_36MB:
4991 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
4992 case IEEE80211_OFDM_RATE_48MB:
4994 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
4995 case IEEE80211_OFDM_RATE_54MB:
4997 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5005 case IEEE80211_CCK_RATE_1MB:
5006 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5007 case IEEE80211_CCK_RATE_2MB:
5008 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5009 case IEEE80211_CCK_RATE_5MB:
5010 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5011 case IEEE80211_CCK_RATE_11MB:
5012 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5015 /* If we are limited to B modulations, bail at this point */
5016 if (ieee_mode == IEEE_B)
5021 case IEEE80211_OFDM_RATE_6MB:
5022 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5023 case IEEE80211_OFDM_RATE_9MB:
5024 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5025 case IEEE80211_OFDM_RATE_12MB:
5026 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5027 case IEEE80211_OFDM_RATE_18MB:
5028 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5029 case IEEE80211_OFDM_RATE_24MB:
5030 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5031 case IEEE80211_OFDM_RATE_36MB:
5032 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5033 case IEEE80211_OFDM_RATE_48MB:
5034 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5035 case IEEE80211_OFDM_RATE_54MB:
5036 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5042 static int ipw_compatible_rates(struct ipw_priv *priv,
5043 const struct ieee80211_network *network,
5044 struct ipw_supported_rates *rates)
5048 memset(rates, 0, sizeof(*rates));
5049 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5050 rates->num_rates = 0;
5051 for (i = 0; i < num_rates; i++) {
5052 if (!ipw_is_rate_in_mask(priv, network->mode,
5053 network->rates[i])) {
5055 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5056 IPW_DEBUG_SCAN("Adding masked mandatory "
5059 rates->supported_rates[rates->num_rates++] =
5064 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5065 network->rates[i], priv->rates_mask);
5069 rates->supported_rates[rates->num_rates++] = network->rates[i];
5072 num_rates = min(network->rates_ex_len,
5073 (u8) (IPW_MAX_RATES - num_rates));
5074 for (i = 0; i < num_rates; i++) {
5075 if (!ipw_is_rate_in_mask(priv, network->mode,
5076 network->rates_ex[i])) {
5077 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5078 IPW_DEBUG_SCAN("Adding masked mandatory "
5080 network->rates_ex[i]);
5081 rates->supported_rates[rates->num_rates++] =
5086 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5087 network->rates_ex[i], priv->rates_mask);
5091 rates->supported_rates[rates->num_rates++] =
5092 network->rates_ex[i];
5098 static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
5099 const struct ipw_supported_rates *src)
5102 for (i = 0; i < src->num_rates; i++)
5103 dest->supported_rates[i] = src->supported_rates[i];
5104 dest->num_rates = src->num_rates;
5107 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5108 * mask should ever be used -- right now all callers to add the scan rates are
5109 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5110 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5111 u8 modulation, u32 rate_mask)
5113 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5114 IEEE80211_BASIC_RATE_MASK : 0;
5116 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5117 rates->supported_rates[rates->num_rates++] =
5118 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5120 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5121 rates->supported_rates[rates->num_rates++] =
5122 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5124 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5125 rates->supported_rates[rates->num_rates++] = basic_mask |
5126 IEEE80211_CCK_RATE_5MB;
5128 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5129 rates->supported_rates[rates->num_rates++] = basic_mask |
5130 IEEE80211_CCK_RATE_11MB;
5133 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5134 u8 modulation, u32 rate_mask)
5136 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5137 IEEE80211_BASIC_RATE_MASK : 0;
5139 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5140 rates->supported_rates[rates->num_rates++] = basic_mask |
5141 IEEE80211_OFDM_RATE_6MB;
5143 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5144 rates->supported_rates[rates->num_rates++] =
5145 IEEE80211_OFDM_RATE_9MB;
5147 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5148 rates->supported_rates[rates->num_rates++] = basic_mask |
5149 IEEE80211_OFDM_RATE_12MB;
5151 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5152 rates->supported_rates[rates->num_rates++] =
5153 IEEE80211_OFDM_RATE_18MB;
5155 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5156 rates->supported_rates[rates->num_rates++] = basic_mask |
5157 IEEE80211_OFDM_RATE_24MB;
5159 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5160 rates->supported_rates[rates->num_rates++] =
5161 IEEE80211_OFDM_RATE_36MB;
5163 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5164 rates->supported_rates[rates->num_rates++] =
5165 IEEE80211_OFDM_RATE_48MB;
5167 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5168 rates->supported_rates[rates->num_rates++] =
5169 IEEE80211_OFDM_RATE_54MB;
5172 struct ipw_network_match {
5173 struct ieee80211_network *network;
5174 struct ipw_supported_rates rates;
5177 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5178 struct ipw_network_match *match,
5179 struct ieee80211_network *network,
5182 struct ipw_supported_rates rates;
5184 /* Verify that this network's capability is compatible with the
5185 * current mode (AdHoc or Infrastructure) */
5186 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5187 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5188 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5189 "capability mismatch.\n",
5190 escape_essid(network->ssid, network->ssid_len),
5191 MAC_ARG(network->bssid));
5195 /* If we do not have an ESSID for this AP, we can not associate with
5197 if (network->flags & NETWORK_EMPTY_ESSID) {
5198 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5199 "because of hidden ESSID.\n",
5200 escape_essid(network->ssid, network->ssid_len),
5201 MAC_ARG(network->bssid));
5205 if (unlikely(roaming)) {
5206 /* If we are roaming, then ensure check if this is a valid
5207 * network to try and roam to */
5208 if ((network->ssid_len != match->network->ssid_len) ||
5209 memcmp(network->ssid, match->network->ssid,
5210 network->ssid_len)) {
5211 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5212 "because of non-network ESSID.\n",
5213 escape_essid(network->ssid,
5215 MAC_ARG(network->bssid));
5219 /* If an ESSID has been configured then compare the broadcast
5221 if ((priv->config & CFG_STATIC_ESSID) &&
5222 ((network->ssid_len != priv->essid_len) ||
5223 memcmp(network->ssid, priv->essid,
5224 min(network->ssid_len, priv->essid_len)))) {
5225 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5228 escape_essid(network->ssid, network->ssid_len),
5230 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5231 "because of ESSID mismatch: '%s'.\n",
5232 escaped, MAC_ARG(network->bssid),
5233 escape_essid(priv->essid,
5239 /* If the old network rate is better than this one, don't bother
5240 * testing everything else. */
5242 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5243 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5244 "current network.\n",
5245 escape_essid(match->network->ssid,
5246 match->network->ssid_len));
5248 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5249 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5250 "current network.\n",
5251 escape_essid(match->network->ssid,
5252 match->network->ssid_len));
5256 /* Now go through and see if the requested network is valid... */
5257 if (priv->ieee->scan_age != 0 &&
5258 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5259 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5260 "because of age: %lums.\n",
5261 escape_essid(network->ssid, network->ssid_len),
5262 MAC_ARG(network->bssid),
5263 1000 * (jiffies - network->last_scanned) / HZ);
5267 if ((priv->config & CFG_STATIC_CHANNEL) &&
5268 (network->channel != priv->channel)) {
5269 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5270 "because of channel mismatch: %d != %d.\n",
5271 escape_essid(network->ssid, network->ssid_len),
5272 MAC_ARG(network->bssid),
5273 network->channel, priv->channel);
5277 /* Verify privacy compatability */
5278 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5279 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5280 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5281 "because of privacy mismatch: %s != %s.\n",
5282 escape_essid(network->ssid, network->ssid_len),
5283 MAC_ARG(network->bssid),
5285 capability & CAP_PRIVACY_ON ? "on" : "off",
5287 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5292 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5293 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5294 "because of the same BSSID match: " MAC_FMT
5295 ".\n", escape_essid(network->ssid,
5297 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5301 /* Filter out any incompatible freq / mode combinations */
5302 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5303 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5304 "because of invalid frequency/mode "
5306 escape_essid(network->ssid, network->ssid_len),
5307 MAC_ARG(network->bssid));
5311 /* Ensure that the rates supported by the driver are compatible with
5312 * this AP, including verification of basic rates (mandatory) */
5313 if (!ipw_compatible_rates(priv, network, &rates)) {
5314 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5315 "because configured rate mask excludes "
5316 "AP mandatory rate.\n",
5317 escape_essid(network->ssid, network->ssid_len),
5318 MAC_ARG(network->bssid));
5322 if (rates.num_rates == 0) {
5323 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5324 "because of no compatible rates.\n",
5325 escape_essid(network->ssid, network->ssid_len),
5326 MAC_ARG(network->bssid));
5330 /* TODO: Perform any further minimal comparititive tests. We do not
5331 * want to put too much policy logic here; intelligent scan selection
5332 * should occur within a generic IEEE 802.11 user space tool. */
5334 /* Set up 'new' AP to this network */
5335 ipw_copy_rates(&match->rates, &rates);
5336 match->network = network;
5337 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5338 escape_essid(network->ssid, network->ssid_len),
5339 MAC_ARG(network->bssid));
5344 static void ipw_merge_adhoc_network(void *data)
5346 struct ipw_priv *priv = data;
5347 struct ieee80211_network *network = NULL;
5348 struct ipw_network_match match = {
5349 .network = priv->assoc_network
5352 if ((priv->status & STATUS_ASSOCIATED) &&
5353 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5354 /* First pass through ROAM process -- look for a better
5356 unsigned long flags;
5358 spin_lock_irqsave(&priv->ieee->lock, flags);
5359 list_for_each_entry(network, &priv->ieee->network_list, list) {
5360 if (network != priv->assoc_network)
5361 ipw_find_adhoc_network(priv, &match, network,
5364 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5366 if (match.network == priv->assoc_network) {
5367 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5373 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5374 IPW_DEBUG_MERGE("remove network %s\n",
5375 escape_essid(priv->essid,
5377 ipw_remove_current_network(priv);
5380 ipw_disassociate(priv);
5381 priv->assoc_network = match.network;
5387 static int ipw_best_network(struct ipw_priv *priv,
5388 struct ipw_network_match *match,
5389 struct ieee80211_network *network, int roaming)
5391 struct ipw_supported_rates rates;
5393 /* Verify that this network's capability is compatible with the
5394 * current mode (AdHoc or Infrastructure) */
5395 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5396 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5397 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5398 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5399 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5400 "capability mismatch.\n",
5401 escape_essid(network->ssid, network->ssid_len),
5402 MAC_ARG(network->bssid));
5406 /* If we do not have an ESSID for this AP, we can not associate with
5408 if (network->flags & NETWORK_EMPTY_ESSID) {
5409 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5410 "because of hidden ESSID.\n",
5411 escape_essid(network->ssid, network->ssid_len),
5412 MAC_ARG(network->bssid));
5416 if (unlikely(roaming)) {
5417 /* If we are roaming, then ensure check if this is a valid
5418 * network to try and roam to */
5419 if ((network->ssid_len != match->network->ssid_len) ||
5420 memcmp(network->ssid, match->network->ssid,
5421 network->ssid_len)) {
5422 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5423 "because of non-network ESSID.\n",
5424 escape_essid(network->ssid,
5426 MAC_ARG(network->bssid));
5430 /* If an ESSID has been configured then compare the broadcast
5432 if ((priv->config & CFG_STATIC_ESSID) &&
5433 ((network->ssid_len != priv->essid_len) ||
5434 memcmp(network->ssid, priv->essid,
5435 min(network->ssid_len, priv->essid_len)))) {
5436 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5438 escape_essid(network->ssid, network->ssid_len),
5440 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5441 "because of ESSID mismatch: '%s'.\n",
5442 escaped, MAC_ARG(network->bssid),
5443 escape_essid(priv->essid,
5449 /* If the old network rate is better than this one, don't bother
5450 * testing everything else. */
5451 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5452 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5454 escape_essid(network->ssid, network->ssid_len),
5456 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5457 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5458 escaped, MAC_ARG(network->bssid),
5459 escape_essid(match->network->ssid,
5460 match->network->ssid_len),
5461 MAC_ARG(match->network->bssid));
5465 /* If this network has already had an association attempt within the
5466 * last 3 seconds, do not try and associate again... */
5467 if (network->last_associate &&
5468 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5469 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5470 "because of storming (%lus since last "
5471 "assoc attempt).\n",
5472 escape_essid(network->ssid, network->ssid_len),
5473 MAC_ARG(network->bssid),
5474 (jiffies - network->last_associate) / HZ);
5478 /* Now go through and see if the requested network is valid... */
5479 if (priv->ieee->scan_age != 0 &&
5480 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5481 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5482 "because of age: %lums.\n",
5483 escape_essid(network->ssid, network->ssid_len),
5484 MAC_ARG(network->bssid),
5485 1000 * (jiffies - network->last_scanned) / HZ);
5489 if ((priv->config & CFG_STATIC_CHANNEL) &&
5490 (network->channel != priv->channel)) {
5491 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5492 "because of channel mismatch: %d != %d.\n",
5493 escape_essid(network->ssid, network->ssid_len),
5494 MAC_ARG(network->bssid),
5495 network->channel, priv->channel);
5499 /* Verify privacy compatability */
5500 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5501 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5502 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5503 "because of privacy mismatch: %s != %s.\n",
5504 escape_essid(network->ssid, network->ssid_len),
5505 MAC_ARG(network->bssid),
5506 priv->capability & CAP_PRIVACY_ON ? "on" :
5508 network->capability &
5509 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5513 if (!priv->ieee->wpa_enabled && (network->wpa_ie_len > 0 ||
5514 network->rsn_ie_len > 0)) {
5515 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5516 "because of WPA capability mismatch.\n",
5517 escape_essid(network->ssid, network->ssid_len),
5518 MAC_ARG(network->bssid));
5522 if ((priv->config & CFG_STATIC_BSSID) &&
5523 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5524 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5525 "because of BSSID mismatch: " MAC_FMT ".\n",
5526 escape_essid(network->ssid, network->ssid_len),
5527 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5531 /* Filter out any incompatible freq / mode combinations */
5532 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5533 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5534 "because of invalid frequency/mode "
5536 escape_essid(network->ssid, network->ssid_len),
5537 MAC_ARG(network->bssid));
5541 /* Filter out invalid channel in current GEO */
5542 if (!ipw_is_valid_channel(priv->ieee, network->channel)) {
5543 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5544 "because of invalid channel in current GEO\n",
5545 escape_essid(network->ssid, network->ssid_len),
5546 MAC_ARG(network->bssid));
5550 /* Ensure that the rates supported by the driver are compatible with
5551 * this AP, including verification of basic rates (mandatory) */
5552 if (!ipw_compatible_rates(priv, network, &rates)) {
5553 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5554 "because configured rate mask excludes "
5555 "AP mandatory rate.\n",
5556 escape_essid(network->ssid, network->ssid_len),
5557 MAC_ARG(network->bssid));
5561 if (rates.num_rates == 0) {
5562 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5563 "because of no compatible rates.\n",
5564 escape_essid(network->ssid, network->ssid_len),
5565 MAC_ARG(network->bssid));
5569 /* TODO: Perform any further minimal comparititive tests. We do not
5570 * want to put too much policy logic here; intelligent scan selection
5571 * should occur within a generic IEEE 802.11 user space tool. */
5573 /* Set up 'new' AP to this network */
5574 ipw_copy_rates(&match->rates, &rates);
5575 match->network = network;
5577 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5578 escape_essid(network->ssid, network->ssid_len),
5579 MAC_ARG(network->bssid));
5584 static void ipw_adhoc_create(struct ipw_priv *priv,
5585 struct ieee80211_network *network)
5587 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5591 * For the purposes of scanning, we can set our wireless mode
5592 * to trigger scans across combinations of bands, but when it
5593 * comes to creating a new ad-hoc network, we have tell the FW
5594 * exactly which band to use.
5596 * We also have the possibility of an invalid channel for the
5597 * chossen band. Attempting to create a new ad-hoc network
5598 * with an invalid channel for wireless mode will trigger a
5602 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
5603 case IEEE80211_52GHZ_BAND:
5604 network->mode = IEEE_A;
5605 i = ipw_channel_to_index(priv->ieee, priv->channel);
5608 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5609 IPW_WARNING("Overriding invalid channel\n");
5610 priv->channel = geo->a[0].channel;
5614 case IEEE80211_24GHZ_BAND:
5615 if (priv->ieee->mode & IEEE_G)
5616 network->mode = IEEE_G;
5618 network->mode = IEEE_B;
5619 i = ipw_channel_to_index(priv->ieee, priv->channel);
5622 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5623 IPW_WARNING("Overriding invalid channel\n");
5624 priv->channel = geo->bg[0].channel;
5629 IPW_WARNING("Overriding invalid channel\n");
5630 if (priv->ieee->mode & IEEE_A) {
5631 network->mode = IEEE_A;
5632 priv->channel = geo->a[0].channel;
5633 } else if (priv->ieee->mode & IEEE_G) {
5634 network->mode = IEEE_G;
5635 priv->channel = geo->bg[0].channel;
5637 network->mode = IEEE_B;
5638 priv->channel = geo->bg[0].channel;
5643 network->channel = priv->channel;
5644 priv->config |= CFG_ADHOC_PERSIST;
5645 ipw_create_bssid(priv, network->bssid);
5646 network->ssid_len = priv->essid_len;
5647 memcpy(network->ssid, priv->essid, priv->essid_len);
5648 memset(&network->stats, 0, sizeof(network->stats));
5649 network->capability = WLAN_CAPABILITY_IBSS;
5650 if (!(priv->config & CFG_PREAMBLE_LONG))
5651 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5652 if (priv->capability & CAP_PRIVACY_ON)
5653 network->capability |= WLAN_CAPABILITY_PRIVACY;
5654 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5655 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5656 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5657 memcpy(network->rates_ex,
5658 &priv->rates.supported_rates[network->rates_len],
5659 network->rates_ex_len);
5660 network->last_scanned = 0;
5662 network->last_associate = 0;
5663 network->time_stamp[0] = 0;
5664 network->time_stamp[1] = 0;
5665 network->beacon_interval = 100; /* Default */
5666 network->listen_interval = 10; /* Default */
5667 network->atim_window = 0; /* Default */
5668 network->wpa_ie_len = 0;
5669 network->rsn_ie_len = 0;
5672 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5674 struct ipw_tgi_tx_key *key;
5675 struct host_cmd cmd = {
5676 .cmd = IPW_CMD_TGI_TX_KEY,
5680 if (!(priv->ieee->sec.flags & (1 << index)))
5683 key = (struct ipw_tgi_tx_key *)&cmd.param;
5684 key->key_id = index;
5685 memcpy(key->key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5686 key->security_type = type;
5687 key->station_index = 0; /* always 0 for BSS */
5689 /* 0 for new key; previous value of counter (after fatal error) */
5690 key->tx_counter[0] = 0;
5691 key->tx_counter[1] = 0;
5693 ipw_send_cmd(priv, &cmd);
5696 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5698 struct ipw_wep_key *key;
5700 struct host_cmd cmd = {
5701 .cmd = IPW_CMD_WEP_KEY,
5705 key = (struct ipw_wep_key *)&cmd.param;
5706 key->cmd_id = DINO_CMD_WEP_KEY;
5709 /* Note: AES keys cannot be set for multiple times.
5710 * Only set it at the first time. */
5711 for (i = 0; i < 4; i++) {
5712 key->key_index = i | type;
5713 if (!(priv->ieee->sec.flags & (1 << i))) {
5718 key->key_size = priv->ieee->sec.key_sizes[i];
5719 memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);
5721 ipw_send_cmd(priv, &cmd);
5725 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5727 if (priv->ieee->host_encrypt)
5732 priv->sys_config.disable_unicast_decryption = 0;
5733 priv->ieee->host_decrypt = 0;
5736 priv->sys_config.disable_unicast_decryption = 1;
5737 priv->ieee->host_decrypt = 1;
5740 priv->sys_config.disable_unicast_decryption = 0;
5741 priv->ieee->host_decrypt = 0;
5744 priv->sys_config.disable_unicast_decryption = 1;
5751 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5753 if (priv->ieee->host_encrypt)
5758 priv->sys_config.disable_multicast_decryption = 0;
5761 priv->sys_config.disable_multicast_decryption = 1;
5764 priv->sys_config.disable_multicast_decryption = 0;
5767 priv->sys_config.disable_multicast_decryption = 1;
5774 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5776 switch (priv->ieee->sec.level) {
5778 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5779 ipw_send_tgi_tx_key(priv,
5780 DCT_FLAG_EXT_SECURITY_CCM,
5781 priv->ieee->sec.active_key);
5783 if (!priv->ieee->host_mc_decrypt)
5784 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5787 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5788 ipw_send_tgi_tx_key(priv,
5789 DCT_FLAG_EXT_SECURITY_TKIP,
5790 priv->ieee->sec.active_key);
5793 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5794 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5795 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5803 static void ipw_adhoc_check(void *data)
5805 struct ipw_priv *priv = data;
5807 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5808 !(priv->config & CFG_ADHOC_PERSIST)) {
5809 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5810 IPW_DL_STATE | IPW_DL_ASSOC,
5811 "Missed beacon: %d - disassociate\n",
5812 priv->missed_adhoc_beacons);
5813 ipw_remove_current_network(priv);
5814 ipw_disassociate(priv);
5818 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5819 priv->assoc_request.beacon_interval);
5822 static void ipw_bg_adhoc_check(void *data)
5824 struct ipw_priv *priv = data;
5826 ipw_adhoc_check(data);
5830 #ifdef CONFIG_IPW2200_DEBUG
5831 static void ipw_debug_config(struct ipw_priv *priv)
5833 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5834 "[CFG 0x%08X]\n", priv->config);
5835 if (priv->config & CFG_STATIC_CHANNEL)
5836 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5838 IPW_DEBUG_INFO("Channel unlocked.\n");
5839 if (priv->config & CFG_STATIC_ESSID)
5840 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5841 escape_essid(priv->essid, priv->essid_len));
5843 IPW_DEBUG_INFO("ESSID unlocked.\n");
5844 if (priv->config & CFG_STATIC_BSSID)
5845 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5846 MAC_ARG(priv->bssid));
5848 IPW_DEBUG_INFO("BSSID unlocked.\n");
5849 if (priv->capability & CAP_PRIVACY_ON)
5850 IPW_DEBUG_INFO("PRIVACY on\n");
5852 IPW_DEBUG_INFO("PRIVACY off\n");
5853 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5856 #define ipw_debug_config(x) do {} while (0)
5859 static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5861 /* TODO: Verify that this works... */
5862 struct ipw_fixed_rate fr = {
5863 .tx_rates = priv->rates_mask
5868 /* Identify 'current FW band' and match it with the fixed
5871 switch (priv->ieee->freq_band) {
5872 case IEEE80211_52GHZ_BAND: /* A only */
5874 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5875 /* Invalid fixed rate mask */
5877 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5882 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5885 default: /* 2.4Ghz or Mixed */
5887 if (mode == IEEE_B) {
5888 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5889 /* Invalid fixed rate mask */
5891 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5898 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5899 IEEE80211_OFDM_RATES_MASK)) {
5900 /* Invalid fixed rate mask */
5902 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5907 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5908 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5909 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5912 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5913 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5914 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5917 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5918 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5919 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5922 fr.tx_rates |= mask;
5926 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5927 ipw_write_reg32(priv, reg, *(u32 *) & fr);
5930 static void ipw_abort_scan(struct ipw_priv *priv)
5934 if (priv->status & STATUS_SCAN_ABORTING) {
5935 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5938 priv->status |= STATUS_SCAN_ABORTING;
5940 err = ipw_send_scan_abort(priv);
5942 IPW_DEBUG_HC("Request to abort scan failed.\n");
5945 static void ipw_add_scan_channels(struct ipw_priv *priv,
5946 struct ipw_scan_request_ext *scan,
5949 int channel_index = 0;
5950 const struct ieee80211_geo *geo;
5953 geo = ipw_get_geo(priv->ieee);
5955 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5956 int start = channel_index;
5957 for (i = 0; i < geo->a_channels; i++) {
5958 if ((priv->status & STATUS_ASSOCIATED) &&
5959 geo->a[i].channel == priv->channel)
5962 scan->channels_list[channel_index] = geo->a[i].channel;
5963 ipw_set_scan_type(scan, channel_index,
5965 flags & IEEE80211_CH_PASSIVE_ONLY ?
5966 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5970 if (start != channel_index) {
5971 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5972 (channel_index - start);
5977 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5978 int start = channel_index;
5979 if (priv->config & CFG_SPEED_SCAN) {
5981 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5982 /* nop out the list */
5987 while (channel_index < IPW_SCAN_CHANNELS) {
5989 priv->speed_scan[priv->speed_scan_pos];
5991 priv->speed_scan_pos = 0;
5992 channel = priv->speed_scan[0];
5994 if ((priv->status & STATUS_ASSOCIATED) &&
5995 channel == priv->channel) {
5996 priv->speed_scan_pos++;
6000 /* If this channel has already been
6001 * added in scan, break from loop
6002 * and this will be the first channel
6005 if (channels[channel - 1] != 0)
6008 channels[channel - 1] = 1;
6009 priv->speed_scan_pos++;
6011 scan->channels_list[channel_index] = channel;
6013 ipw_channel_to_index(priv->ieee, channel);
6014 ipw_set_scan_type(scan, channel_index,
6017 IEEE80211_CH_PASSIVE_ONLY ?
6018 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6022 for (i = 0; i < geo->bg_channels; i++) {
6023 if ((priv->status & STATUS_ASSOCIATED) &&
6024 geo->bg[i].channel == priv->channel)
6027 scan->channels_list[channel_index] =
6029 ipw_set_scan_type(scan, channel_index,
6032 IEEE80211_CH_PASSIVE_ONLY ?
6033 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6038 if (start != channel_index) {
6039 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6040 (channel_index - start);
6045 static int ipw_request_scan(struct ipw_priv *priv)
6047 struct ipw_scan_request_ext scan;
6048 int err = 0, scan_type;
6050 if (!(priv->status & STATUS_INIT) ||
6051 (priv->status & STATUS_EXIT_PENDING))
6056 if (priv->status & STATUS_SCANNING) {
6057 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
6058 priv->status |= STATUS_SCAN_PENDING;
6062 if (!(priv->status & STATUS_SCAN_FORCED) &&
6063 priv->status & STATUS_SCAN_ABORTING) {
6064 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6065 priv->status |= STATUS_SCAN_PENDING;
6069 if (priv->status & STATUS_RF_KILL_MASK) {
6070 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6071 priv->status |= STATUS_SCAN_PENDING;
6075 memset(&scan, 0, sizeof(scan));
6077 if (priv->config & CFG_SPEED_SCAN)
6078 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6081 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6084 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6086 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6088 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6090 #ifdef CONFIG_IPW2200_MONITOR
6091 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6095 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
6096 case IEEE80211_52GHZ_BAND:
6097 band = (u8) (IPW_A_MODE << 6) | 1;
6098 channel = priv->channel;
6101 case IEEE80211_24GHZ_BAND:
6102 band = (u8) (IPW_B_MODE << 6) | 1;
6103 channel = priv->channel;
6107 band = (u8) (IPW_B_MODE << 6) | 1;
6112 scan.channels_list[0] = band;
6113 scan.channels_list[1] = channel;
6114 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6116 /* NOTE: The card will sit on this channel for this time
6117 * period. Scan aborts are timing sensitive and frequently
6118 * result in firmware restarts. As such, it is best to
6119 * set a small dwell_time here and just keep re-issuing
6120 * scans. Otherwise fast channel hopping will not actually
6123 * TODO: Move SPEED SCAN support to all modes and bands */
6124 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6127 #endif /* CONFIG_IPW2200_MONITOR */
6128 /* If we are roaming, then make this a directed scan for the
6129 * current network. Otherwise, ensure that every other scan
6130 * is a fast channel hop scan */
6131 if ((priv->status & STATUS_ROAMING)
6132 || (!(priv->status & STATUS_ASSOCIATED)
6133 && (priv->config & CFG_STATIC_ESSID)
6134 && (le32_to_cpu(scan.full_scan_index) % 2))) {
6135 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6137 IPW_DEBUG_HC("Attempt to send SSID command "
6142 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6144 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6146 ipw_add_scan_channels(priv, &scan, scan_type);
6147 #ifdef CONFIG_IPW2200_MONITOR
6151 err = ipw_send_scan_request_ext(priv, &scan);
6153 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6157 priv->status |= STATUS_SCANNING;
6158 priv->status &= ~STATUS_SCAN_PENDING;
6159 queue_delayed_work(priv->workqueue, &priv->scan_check,
6160 IPW_SCAN_CHECK_WATCHDOG);
6166 static void ipw_bg_abort_scan(void *data)
6168 struct ipw_priv *priv = data;
6170 ipw_abort_scan(data);
6174 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6176 /* This is called when wpa_supplicant loads and closes the driver
6178 priv->ieee->wpa_enabled = value;
6182 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6184 struct ieee80211_device *ieee = priv->ieee;
6185 struct ieee80211_security sec = {
6186 .flags = SEC_AUTH_MODE,
6190 if (value & IW_AUTH_ALG_SHARED_KEY) {
6191 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6193 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6194 sec.auth_mode = WLAN_AUTH_OPEN;
6199 if (ieee->set_security)
6200 ieee->set_security(ieee->dev, &sec);
6207 void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie, int wpa_ie_len)
6209 /* make sure WPA is enabled */
6210 ipw_wpa_enable(priv, 1);
6212 ipw_disassociate(priv);
6215 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6216 char *capabilities, int length)
6218 struct host_cmd cmd = {
6219 .cmd = IPW_CMD_RSN_CAPABILITIES,
6223 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6225 memcpy(cmd.param, capabilities, length);
6226 return ipw_send_cmd(priv, &cmd);
6234 static int ipw_wx_set_genie(struct net_device *dev,
6235 struct iw_request_info *info,
6236 union iwreq_data *wrqu, char *extra)
6238 struct ipw_priv *priv = ieee80211_priv(dev);
6239 struct ieee80211_device *ieee = priv->ieee;
6243 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6244 (wrqu->data.length && extra == NULL))
6249 //if (!ieee->wpa_enabled) {
6250 // err = -EOPNOTSUPP;
6254 if (wrqu->data.length) {
6255 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6261 memcpy(buf, extra, wrqu->data.length);
6262 kfree(ieee->wpa_ie);
6264 ieee->wpa_ie_len = wrqu->data.length;
6266 kfree(ieee->wpa_ie);
6267 ieee->wpa_ie = NULL;
6268 ieee->wpa_ie_len = 0;
6271 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6278 static int ipw_wx_get_genie(struct net_device *dev,
6279 struct iw_request_info *info,
6280 union iwreq_data *wrqu, char *extra)
6282 struct ipw_priv *priv = ieee80211_priv(dev);
6283 struct ieee80211_device *ieee = priv->ieee;
6288 //if (!ieee->wpa_enabled) {
6289 // err = -EOPNOTSUPP;
6293 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6294 wrqu->data.length = 0;
6298 if (wrqu->data.length < ieee->wpa_ie_len) {
6303 wrqu->data.length = ieee->wpa_ie_len;
6304 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6311 static int wext_cipher2level(int cipher)
6314 case IW_AUTH_CIPHER_NONE:
6316 case IW_AUTH_CIPHER_WEP40:
6317 case IW_AUTH_CIPHER_WEP104:
6319 case IW_AUTH_CIPHER_TKIP:
6321 case IW_AUTH_CIPHER_CCMP:
6329 static int ipw_wx_set_auth(struct net_device *dev,
6330 struct iw_request_info *info,
6331 union iwreq_data *wrqu, char *extra)
6333 struct ipw_priv *priv = ieee80211_priv(dev);
6334 struct ieee80211_device *ieee = priv->ieee;
6335 struct iw_param *param = &wrqu->param;
6336 struct ieee80211_crypt_data *crypt;
6337 unsigned long flags;
6340 switch (param->flags & IW_AUTH_INDEX) {
6341 case IW_AUTH_WPA_VERSION:
6343 case IW_AUTH_CIPHER_PAIRWISE:
6344 ipw_set_hw_decrypt_unicast(priv,
6345 wext_cipher2level(param->value));
6347 case IW_AUTH_CIPHER_GROUP:
6348 ipw_set_hw_decrypt_multicast(priv,
6349 wext_cipher2level(param->value));
6351 case IW_AUTH_KEY_MGMT:
6353 * ipw2200 does not use these parameters
6357 case IW_AUTH_TKIP_COUNTERMEASURES:
6358 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6359 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6362 flags = crypt->ops->get_flags(crypt->priv);
6365 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6367 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6369 crypt->ops->set_flags(flags, crypt->priv);
6373 case IW_AUTH_DROP_UNENCRYPTED:{
6376 * wpa_supplicant calls set_wpa_enabled when the driver
6377 * is loaded and unloaded, regardless of if WPA is being
6378 * used. No other calls are made which can be used to
6379 * determine if encryption will be used or not prior to
6380 * association being expected. If encryption is not being
6381 * used, drop_unencrypted is set to false, else true -- we
6382 * can use this to determine if the CAP_PRIVACY_ON bit should
6385 struct ieee80211_security sec = {
6386 .flags = SEC_ENABLED,
6387 .enabled = param->value,
6389 priv->ieee->drop_unencrypted = param->value;
6390 /* We only change SEC_LEVEL for open mode. Others
6391 * are set by ipw_wpa_set_encryption.
6393 if (!param->value) {
6394 sec.flags |= SEC_LEVEL;
6395 sec.level = SEC_LEVEL_0;
6397 sec.flags |= SEC_LEVEL;
6398 sec.level = SEC_LEVEL_1;
6400 if (priv->ieee->set_security)
6401 priv->ieee->set_security(priv->ieee->dev, &sec);
6405 case IW_AUTH_80211_AUTH_ALG:
6406 ret = ipw_wpa_set_auth_algs(priv, param->value);
6409 case IW_AUTH_WPA_ENABLED:
6410 ret = ipw_wpa_enable(priv, param->value);
6413 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6414 ieee->ieee802_1x = param->value;
6417 //case IW_AUTH_ROAMING_CONTROL:
6418 case IW_AUTH_PRIVACY_INVOKED:
6419 ieee->privacy_invoked = param->value;
6429 static int ipw_wx_get_auth(struct net_device *dev,
6430 struct iw_request_info *info,
6431 union iwreq_data *wrqu, char *extra)
6433 struct ipw_priv *priv = ieee80211_priv(dev);
6434 struct ieee80211_device *ieee = priv->ieee;
6435 struct ieee80211_crypt_data *crypt;
6436 struct iw_param *param = &wrqu->param;
6439 switch (param->flags & IW_AUTH_INDEX) {
6440 case IW_AUTH_WPA_VERSION:
6441 case IW_AUTH_CIPHER_PAIRWISE:
6442 case IW_AUTH_CIPHER_GROUP:
6443 case IW_AUTH_KEY_MGMT:
6445 * wpa_supplicant will control these internally
6450 case IW_AUTH_TKIP_COUNTERMEASURES:
6451 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6452 if (!crypt || !crypt->ops->get_flags)
6455 param->value = (crypt->ops->get_flags(crypt->priv) &
6456 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6460 case IW_AUTH_DROP_UNENCRYPTED:
6461 param->value = ieee->drop_unencrypted;
6464 case IW_AUTH_80211_AUTH_ALG:
6465 param->value = ieee->sec.auth_mode;
6468 case IW_AUTH_WPA_ENABLED:
6469 param->value = ieee->wpa_enabled;
6472 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6473 param->value = ieee->ieee802_1x;
6476 case IW_AUTH_ROAMING_CONTROL:
6477 case IW_AUTH_PRIVACY_INVOKED:
6478 param->value = ieee->privacy_invoked;
6487 /* SIOCSIWENCODEEXT */
6488 static int ipw_wx_set_encodeext(struct net_device *dev,
6489 struct iw_request_info *info,
6490 union iwreq_data *wrqu, char *extra)
6492 struct ipw_priv *priv = ieee80211_priv(dev);
6493 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6496 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6497 /* IPW HW can't build TKIP MIC,
6498 host decryption still needed */
6499 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6500 priv->ieee->host_mc_decrypt = 1;
6502 priv->ieee->host_encrypt = 0;
6503 priv->ieee->host_encrypt_msdu = 1;
6504 priv->ieee->host_decrypt = 1;
6507 priv->ieee->host_encrypt = 0;
6508 priv->ieee->host_encrypt_msdu = 0;
6509 priv->ieee->host_decrypt = 0;
6510 priv->ieee->host_mc_decrypt = 0;
6514 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6517 /* SIOCGIWENCODEEXT */
6518 static int ipw_wx_get_encodeext(struct net_device *dev,
6519 struct iw_request_info *info,
6520 union iwreq_data *wrqu, char *extra)
6522 struct ipw_priv *priv = ieee80211_priv(dev);
6523 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6527 static int ipw_wx_set_mlme(struct net_device *dev,
6528 struct iw_request_info *info,
6529 union iwreq_data *wrqu, char *extra)
6531 struct ipw_priv *priv = ieee80211_priv(dev);
6532 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6535 reason = cpu_to_le16(mlme->reason_code);
6537 switch (mlme->cmd) {
6538 case IW_MLME_DEAUTH:
6542 case IW_MLME_DISASSOC:
6543 ipw_disassociate(priv);
6552 #ifdef CONFIG_IPW_QOS
6556 * get the modulation type of the current network or
6557 * the card current mode
6559 u8 ipw_qos_current_mode(struct ipw_priv * priv)
6563 if (priv->status & STATUS_ASSOCIATED) {
6564 unsigned long flags;
6566 spin_lock_irqsave(&priv->ieee->lock, flags);
6567 mode = priv->assoc_network->mode;
6568 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6570 mode = priv->ieee->mode;
6572 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6577 * Handle management frame beacon and probe response
6579 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6581 struct ieee80211_network *network)
6583 u32 size = sizeof(struct ieee80211_qos_parameters);
6585 if (network->capability & WLAN_CAPABILITY_IBSS)
6586 network->qos_data.active = network->qos_data.supported;
6588 if (network->flags & NETWORK_HAS_QOS_MASK) {
6589 if (active_network &&
6590 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6591 network->qos_data.active = network->qos_data.supported;
6593 if ((network->qos_data.active == 1) && (active_network == 1) &&
6594 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6595 (network->qos_data.old_param_count !=
6596 network->qos_data.param_count)) {
6597 network->qos_data.old_param_count =
6598 network->qos_data.param_count;
6599 schedule_work(&priv->qos_activate);
6600 IPW_DEBUG_QOS("QoS parameters change call "
6604 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6605 memcpy(&network->qos_data.parameters,
6606 &def_parameters_CCK, size);
6608 memcpy(&network->qos_data.parameters,
6609 &def_parameters_OFDM, size);
6611 if ((network->qos_data.active == 1) && (active_network == 1)) {
6612 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6613 schedule_work(&priv->qos_activate);
6616 network->qos_data.active = 0;
6617 network->qos_data.supported = 0;
6619 if ((priv->status & STATUS_ASSOCIATED) &&
6620 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6621 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6622 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6623 !(network->flags & NETWORK_EMPTY_ESSID))
6624 if ((network->ssid_len ==
6625 priv->assoc_network->ssid_len) &&
6626 !memcmp(network->ssid,
6627 priv->assoc_network->ssid,
6628 network->ssid_len)) {
6629 queue_work(priv->workqueue,
6630 &priv->merge_networks);
6638 * This function set up the firmware to support QoS. It sends
6639 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6641 static int ipw_qos_activate(struct ipw_priv *priv,
6642 struct ieee80211_qos_data *qos_network_data)
6645 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6646 struct ieee80211_qos_parameters *active_one = NULL;
6647 u32 size = sizeof(struct ieee80211_qos_parameters);
6652 type = ipw_qos_current_mode(priv);
6654 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6655 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6656 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6657 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6659 if (qos_network_data == NULL) {
6660 if (type == IEEE_B) {
6661 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6662 active_one = &def_parameters_CCK;
6664 active_one = &def_parameters_OFDM;
6666 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6667 burst_duration = ipw_qos_get_burst_duration(priv);
6668 for (i = 0; i < QOS_QUEUE_NUM; i++)
6669 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6670 (u16) burst_duration;
6671 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6672 if (type == IEEE_B) {
6673 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6675 if (priv->qos_data.qos_enable == 0)
6676 active_one = &def_parameters_CCK;
6678 active_one = priv->qos_data.def_qos_parm_CCK;
6680 if (priv->qos_data.qos_enable == 0)
6681 active_one = &def_parameters_OFDM;
6683 active_one = priv->qos_data.def_qos_parm_OFDM;
6685 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6687 unsigned long flags;
6690 spin_lock_irqsave(&priv->ieee->lock, flags);
6691 active_one = &(qos_network_data->parameters);
6692 qos_network_data->old_param_count =
6693 qos_network_data->param_count;
6694 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6695 active = qos_network_data->supported;
6696 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6699 burst_duration = ipw_qos_get_burst_duration(priv);
6700 for (i = 0; i < QOS_QUEUE_NUM; i++)
6701 qos_parameters[QOS_PARAM_SET_ACTIVE].
6702 tx_op_limit[i] = (u16) burst_duration;
6706 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6707 err = ipw_send_qos_params_command(priv,
6708 (struct ieee80211_qos_parameters *)
6709 &(qos_parameters[0]));
6711 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6717 * send IPW_CMD_WME_INFO to the firmware
6719 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6722 struct ieee80211_qos_information_element qos_info;
6727 qos_info.elementID = QOS_ELEMENT_ID;
6728 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6730 qos_info.version = QOS_VERSION_1;
6731 qos_info.ac_info = 0;
6733 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6734 qos_info.qui_type = QOS_OUI_TYPE;
6735 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6737 ret = ipw_send_qos_info_command(priv, &qos_info);
6739 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6745 * Set the QoS parameter with the association request structure
6747 static int ipw_qos_association(struct ipw_priv *priv,
6748 struct ieee80211_network *network)
6751 struct ieee80211_qos_data *qos_data = NULL;
6752 struct ieee80211_qos_data ibss_data = {
6757 switch (priv->ieee->iw_mode) {
6759 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6762 qos_data = &ibss_data;
6766 qos_data = &network->qos_data;
6774 err = ipw_qos_activate(priv, qos_data);
6776 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6780 if (priv->qos_data.qos_enable && qos_data->supported) {
6781 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6782 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6783 return ipw_qos_set_info_element(priv);
6790 * handling the beaconing responces. if we get different QoS setting
6791 * of the network from the the associated setting adjust the QoS
6794 static int ipw_qos_association_resp(struct ipw_priv *priv,
6795 struct ieee80211_network *network)
6798 unsigned long flags;
6799 u32 size = sizeof(struct ieee80211_qos_parameters);
6800 int set_qos_param = 0;
6802 if ((priv == NULL) || (network == NULL) ||
6803 (priv->assoc_network == NULL))
6806 if (!(priv->status & STATUS_ASSOCIATED))
6809 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
6812 spin_lock_irqsave(&priv->ieee->lock, flags);
6813 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
6814 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
6815 sizeof(struct ieee80211_qos_data));
6816 priv->assoc_network->qos_data.active = 1;
6817 if ((network->qos_data.old_param_count !=
6818 network->qos_data.param_count)) {
6820 network->qos_data.old_param_count =
6821 network->qos_data.param_count;
6825 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6826 memcpy(&priv->assoc_network->qos_data.parameters,
6827 &def_parameters_CCK, size);
6829 memcpy(&priv->assoc_network->qos_data.parameters,
6830 &def_parameters_OFDM, size);
6831 priv->assoc_network->qos_data.active = 0;
6832 priv->assoc_network->qos_data.supported = 0;
6836 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6838 if (set_qos_param == 1)
6839 schedule_work(&priv->qos_activate);
6844 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6851 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
6852 ret = priv->qos_data.burst_duration_CCK;
6854 ret = priv->qos_data.burst_duration_OFDM;
6860 * Initialize the setting of QoS global
6862 static void ipw_qos_init(struct ipw_priv *priv, int enable,
6863 int burst_enable, u32 burst_duration_CCK,
6864 u32 burst_duration_OFDM)
6866 priv->qos_data.qos_enable = enable;
6868 if (priv->qos_data.qos_enable) {
6869 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6870 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6871 IPW_DEBUG_QOS("QoS is enabled\n");
6873 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6874 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6875 IPW_DEBUG_QOS("QoS is not enabled\n");
6878 priv->qos_data.burst_enable = burst_enable;
6881 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6882 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6884 priv->qos_data.burst_duration_CCK = 0;
6885 priv->qos_data.burst_duration_OFDM = 0;
6890 * map the packet priority to the right TX Queue
6892 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6894 if (priority > 7 || !priv->qos_data.qos_enable)
6897 return from_priority_to_tx_queue[priority] - 1;
6901 * add QoS parameter to the TX command
6903 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6905 struct tfd_data *tfd, u8 unicast)
6908 int tx_queue_id = 0;
6909 struct ieee80211_qos_data *qos_data = NULL;
6910 int active, supported;
6911 unsigned long flags;
6913 if (!(priv->status & STATUS_ASSOCIATED))
6916 qos_data = &priv->assoc_network->qos_data;
6918 spin_lock_irqsave(&priv->ieee->lock, flags);
6920 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6922 qos_data->active = 0;
6924 qos_data->active = qos_data->supported;
6927 active = qos_data->active;
6928 supported = qos_data->supported;
6930 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6932 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
6934 priv->qos_data.qos_enable, active, supported, unicast);
6935 if (active && priv->qos_data.qos_enable) {
6936 ret = from_priority_to_tx_queue[priority];
6937 tx_queue_id = ret - 1;
6938 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6939 if (priority <= 7) {
6940 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6941 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6942 tfd->tfd.tfd_26.mchdr.frame_ctl |=
6943 IEEE80211_STYPE_QOS_DATA;
6945 if (priv->qos_data.qos_no_ack_mask &
6946 (1UL << tx_queue_id)) {
6947 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6948 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6958 * background support to run QoS activate functionality
6960 static void ipw_bg_qos_activate(void *data)
6962 struct ipw_priv *priv = data;
6969 if (priv->status & STATUS_ASSOCIATED)
6970 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6975 static int ipw_handle_probe_response(struct net_device *dev,
6976 struct ieee80211_probe_response *resp,
6977 struct ieee80211_network *network)
6979 struct ipw_priv *priv = ieee80211_priv(dev);
6980 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6981 (network == priv->assoc_network));
6983 ipw_qos_handle_probe_response(priv, active_network, network);
6988 static int ipw_handle_beacon(struct net_device *dev,
6989 struct ieee80211_beacon *resp,
6990 struct ieee80211_network *network)
6992 struct ipw_priv *priv = ieee80211_priv(dev);
6993 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6994 (network == priv->assoc_network));
6996 ipw_qos_handle_probe_response(priv, active_network, network);
7001 static int ipw_handle_assoc_response(struct net_device *dev,
7002 struct ieee80211_assoc_response *resp,
7003 struct ieee80211_network *network)
7005 struct ipw_priv *priv = ieee80211_priv(dev);
7006 ipw_qos_association_resp(priv, network);
7010 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7013 struct host_cmd cmd = {
7014 .cmd = IPW_CMD_QOS_PARAMETERS,
7015 .len = (sizeof(struct ieee80211_qos_parameters) * 3)
7018 memcpy(cmd.param, qos_param, sizeof(*qos_param) * 3);
7019 return ipw_send_cmd(priv, &cmd);
7022 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7025 struct host_cmd cmd = {
7026 .cmd = IPW_CMD_WME_INFO,
7027 .len = sizeof(*qos_param)
7030 memcpy(cmd.param, qos_param, sizeof(*qos_param));
7031 return ipw_send_cmd(priv, &cmd);
7034 #endif /* CONFIG_IPW_QOS */
7036 static int ipw_associate_network(struct ipw_priv *priv,
7037 struct ieee80211_network *network,
7038 struct ipw_supported_rates *rates, int roaming)
7042 if (priv->config & CFG_FIXED_RATE)
7043 ipw_set_fixed_rate(priv, network->mode);
7045 if (!(priv->config & CFG_STATIC_ESSID)) {
7046 priv->essid_len = min(network->ssid_len,
7047 (u8) IW_ESSID_MAX_SIZE);
7048 memcpy(priv->essid, network->ssid, priv->essid_len);
7051 network->last_associate = jiffies;
7053 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7054 priv->assoc_request.channel = network->channel;
7055 if ((priv->capability & CAP_PRIVACY_ON) &&
7056 (priv->capability & CAP_SHARED_KEY)) {
7057 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7058 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7060 if ((priv->capability & CAP_PRIVACY_ON) &&
7061 (priv->ieee->sec.level == SEC_LEVEL_1) &&
7062 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
7063 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7065 priv->assoc_request.auth_type = AUTH_OPEN;
7066 priv->assoc_request.auth_key = 0;
7069 if (priv->ieee->wpa_ie_len) {
7070 priv->assoc_request.policy_support = 0x02; /* RSN active */
7071 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7072 priv->ieee->wpa_ie_len);
7076 * It is valid for our ieee device to support multiple modes, but
7077 * when it comes to associating to a given network we have to choose
7080 if (network->mode & priv->ieee->mode & IEEE_A)
7081 priv->assoc_request.ieee_mode = IPW_A_MODE;
7082 else if (network->mode & priv->ieee->mode & IEEE_G)
7083 priv->assoc_request.ieee_mode = IPW_G_MODE;
7084 else if (network->mode & priv->ieee->mode & IEEE_B)
7085 priv->assoc_request.ieee_mode = IPW_B_MODE;
7087 priv->assoc_request.capability = network->capability;
7088 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7089 && !(priv->config & CFG_PREAMBLE_LONG)) {
7090 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7092 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7094 /* Clear the short preamble if we won't be supporting it */
7095 priv->assoc_request.capability &=
7096 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7099 /* Clear capability bits that aren't used in Ad Hoc */
7100 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7101 priv->assoc_request.capability &=
7102 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7104 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7105 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7106 roaming ? "Rea" : "A",
7107 escape_essid(priv->essid, priv->essid_len),
7109 ipw_modes[priv->assoc_request.ieee_mode],
7111 (priv->assoc_request.preamble_length ==
7112 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7113 network->capability &
7114 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7115 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7116 priv->capability & CAP_PRIVACY_ON ?
7117 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7119 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7120 priv->capability & CAP_PRIVACY_ON ?
7121 '1' + priv->ieee->sec.active_key : '.',
7122 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7124 priv->assoc_request.beacon_interval = network->beacon_interval;
7125 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7126 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7127 priv->assoc_request.assoc_type = HC_IBSS_START;
7128 priv->assoc_request.assoc_tsf_msw = 0;
7129 priv->assoc_request.assoc_tsf_lsw = 0;
7131 if (unlikely(roaming))
7132 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7134 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7135 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7136 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7139 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7141 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7142 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7143 priv->assoc_request.atim_window = network->atim_window;
7145 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7146 priv->assoc_request.atim_window = 0;
7149 priv->assoc_request.listen_interval = network->listen_interval;
7151 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7153 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7157 rates->ieee_mode = priv->assoc_request.ieee_mode;
7158 rates->purpose = IPW_RATE_CONNECT;
7159 ipw_send_supported_rates(priv, rates);
7161 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7162 priv->sys_config.dot11g_auto_detection = 1;
7164 priv->sys_config.dot11g_auto_detection = 0;
7166 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7167 priv->sys_config.answer_broadcast_ssid_probe = 1;
7169 priv->sys_config.answer_broadcast_ssid_probe = 0;
7171 err = ipw_send_system_config(priv, &priv->sys_config);
7173 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7177 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7178 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7180 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7185 * If preemption is enabled, it is possible for the association
7186 * to complete before we return from ipw_send_associate. Therefore
7187 * we have to be sure and update our priviate data first.
7189 priv->channel = network->channel;
7190 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7191 priv->status |= STATUS_ASSOCIATING;
7192 priv->status &= ~STATUS_SECURITY_UPDATED;
7194 priv->assoc_network = network;
7196 #ifdef CONFIG_IPW_QOS
7197 ipw_qos_association(priv, network);
7200 err = ipw_send_associate(priv, &priv->assoc_request);
7202 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7206 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7207 escape_essid(priv->essid, priv->essid_len),
7208 MAC_ARG(priv->bssid));
7213 static void ipw_roam(void *data)
7215 struct ipw_priv *priv = data;
7216 struct ieee80211_network *network = NULL;
7217 struct ipw_network_match match = {
7218 .network = priv->assoc_network
7221 /* The roaming process is as follows:
7223 * 1. Missed beacon threshold triggers the roaming process by
7224 * setting the status ROAM bit and requesting a scan.
7225 * 2. When the scan completes, it schedules the ROAM work
7226 * 3. The ROAM work looks at all of the known networks for one that
7227 * is a better network than the currently associated. If none
7228 * found, the ROAM process is over (ROAM bit cleared)
7229 * 4. If a better network is found, a disassociation request is
7231 * 5. When the disassociation completes, the roam work is again
7232 * scheduled. The second time through, the driver is no longer
7233 * associated, and the newly selected network is sent an
7234 * association request.
7235 * 6. At this point ,the roaming process is complete and the ROAM
7236 * status bit is cleared.
7239 /* If we are no longer associated, and the roaming bit is no longer
7240 * set, then we are not actively roaming, so just return */
7241 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7244 if (priv->status & STATUS_ASSOCIATED) {
7245 /* First pass through ROAM process -- look for a better
7247 unsigned long flags;
7248 u8 rssi = priv->assoc_network->stats.rssi;
7249 priv->assoc_network->stats.rssi = -128;
7250 spin_lock_irqsave(&priv->ieee->lock, flags);
7251 list_for_each_entry(network, &priv->ieee->network_list, list) {
7252 if (network != priv->assoc_network)
7253 ipw_best_network(priv, &match, network, 1);
7255 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7256 priv->assoc_network->stats.rssi = rssi;
7258 if (match.network == priv->assoc_network) {
7259 IPW_DEBUG_ASSOC("No better APs in this network to "
7261 priv->status &= ~STATUS_ROAMING;
7262 ipw_debug_config(priv);
7266 ipw_send_disassociate(priv, 1);
7267 priv->assoc_network = match.network;
7272 /* Second pass through ROAM process -- request association */
7273 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7274 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7275 priv->status &= ~STATUS_ROAMING;
7278 static void ipw_bg_roam(void *data)
7280 struct ipw_priv *priv = data;
7286 static int ipw_associate(void *data)
7288 struct ipw_priv *priv = data;
7290 struct ieee80211_network *network = NULL;
7291 struct ipw_network_match match = {
7294 struct ipw_supported_rates *rates;
7295 struct list_head *element;
7296 unsigned long flags;
7298 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7299 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7303 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7304 IPW_DEBUG_ASSOC("Not attempting association (already in "
7309 if (priv->status & STATUS_DISASSOCIATING) {
7310 IPW_DEBUG_ASSOC("Not attempting association (in "
7311 "disassociating)\n ");
7312 queue_work(priv->workqueue, &priv->associate);
7316 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7317 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7322 if (!(priv->config & CFG_ASSOCIATE) &&
7323 !(priv->config & (CFG_STATIC_ESSID |
7324 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7325 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7329 /* Protect our use of the network_list */
7330 spin_lock_irqsave(&priv->ieee->lock, flags);
7331 list_for_each_entry(network, &priv->ieee->network_list, list)
7332 ipw_best_network(priv, &match, network, 0);
7334 network = match.network;
7335 rates = &match.rates;
7337 if (network == NULL &&
7338 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7339 priv->config & CFG_ADHOC_CREATE &&
7340 priv->config & CFG_STATIC_ESSID &&
7341 priv->config & CFG_STATIC_CHANNEL &&
7342 !list_empty(&priv->ieee->network_free_list)) {
7343 element = priv->ieee->network_free_list.next;
7344 network = list_entry(element, struct ieee80211_network, list);
7345 ipw_adhoc_create(priv, network);
7346 rates = &priv->rates;
7348 list_add_tail(&network->list, &priv->ieee->network_list);
7350 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7352 /* If we reached the end of the list, then we don't have any valid
7355 ipw_debug_config(priv);
7357 if (!(priv->status & STATUS_SCANNING)) {
7358 if (!(priv->config & CFG_SPEED_SCAN))
7359 queue_delayed_work(priv->workqueue,
7360 &priv->request_scan,
7363 queue_work(priv->workqueue,
7364 &priv->request_scan);
7370 ipw_associate_network(priv, network, rates, 0);
7375 static void ipw_bg_associate(void *data)
7377 struct ipw_priv *priv = data;
7379 ipw_associate(data);
7383 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7384 struct sk_buff *skb)
7386 struct ieee80211_hdr *hdr;
7389 hdr = (struct ieee80211_hdr *)skb->data;
7390 fc = le16_to_cpu(hdr->frame_ctl);
7391 if (!(fc & IEEE80211_FCTL_PROTECTED))
7394 fc &= ~IEEE80211_FCTL_PROTECTED;
7395 hdr->frame_ctl = cpu_to_le16(fc);
7396 switch (priv->ieee->sec.level) {
7398 /* Remove CCMP HDR */
7399 memmove(skb->data + IEEE80211_3ADDR_LEN,
7400 skb->data + IEEE80211_3ADDR_LEN + 8,
7401 skb->len - IEEE80211_3ADDR_LEN - 8);
7402 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7408 memmove(skb->data + IEEE80211_3ADDR_LEN,
7409 skb->data + IEEE80211_3ADDR_LEN + 4,
7410 skb->len - IEEE80211_3ADDR_LEN - 4);
7411 skb_trim(skb, skb->len - 8); /* IV + ICV */
7416 printk(KERN_ERR "Unknow security level %d\n",
7417 priv->ieee->sec.level);
7422 static void ipw_handle_data_packet(struct ipw_priv *priv,
7423 struct ipw_rx_mem_buffer *rxb,
7424 struct ieee80211_rx_stats *stats)
7426 struct ieee80211_hdr_4addr *hdr;
7427 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7429 /* We received data from the HW, so stop the watchdog */
7430 priv->net_dev->trans_start = jiffies;
7432 /* We only process data packets if the
7433 * interface is open */
7434 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7435 skb_tailroom(rxb->skb))) {
7436 priv->ieee->stats.rx_errors++;
7437 priv->wstats.discard.misc++;
7438 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7440 } else if (unlikely(!netif_running(priv->net_dev))) {
7441 priv->ieee->stats.rx_dropped++;
7442 priv->wstats.discard.misc++;
7443 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7447 /* Advance skb->data to the start of the actual payload */
7448 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7450 /* Set the size of the skb to the size of the frame */
7451 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7453 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7455 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7456 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7457 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7458 ((is_multicast_ether_addr(hdr->addr1) ||
7459 is_broadcast_ether_addr(hdr->addr1)) ?
7460 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7461 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7463 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7464 priv->ieee->stats.rx_errors++;
7465 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7467 __ipw_led_activity_on(priv);
7471 #ifdef CONFIG_IEEE80211_RADIOTAP
7472 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7473 struct ipw_rx_mem_buffer *rxb,
7474 struct ieee80211_rx_stats *stats)
7476 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7477 struct ipw_rx_frame *frame = &pkt->u.frame;
7479 /* initial pull of some data */
7480 u16 received_channel = frame->received_channel;
7481 u8 antennaAndPhy = frame->antennaAndPhy;
7482 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7483 u16 pktrate = frame->rate;
7485 /* Magic struct that slots into the radiotap header -- no reason
7486 * to build this manually element by element, we can write it much
7487 * more efficiently than we can parse it. ORDER MATTERS HERE */
7489 struct ieee80211_radiotap_header rt_hdr;
7490 u8 rt_flags; /* radiotap packet flags */
7491 u8 rt_rate; /* rate in 500kb/s */
7492 u16 rt_channel; /* channel in mhz */
7493 u16 rt_chbitmask; /* channel bitfield */
7494 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7495 u8 rt_antenna; /* antenna number */
7498 short len = le16_to_cpu(pkt->u.frame.length);
7500 /* We received data from the HW, so stop the watchdog */
7501 priv->net_dev->trans_start = jiffies;
7503 /* We only process data packets if the
7504 * interface is open */
7505 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7506 skb_tailroom(rxb->skb))) {
7507 priv->ieee->stats.rx_errors++;
7508 priv->wstats.discard.misc++;
7509 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7511 } else if (unlikely(!netif_running(priv->net_dev))) {
7512 priv->ieee->stats.rx_dropped++;
7513 priv->wstats.discard.misc++;
7514 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7518 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7520 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7521 /* FIXME: Should alloc bigger skb instead */
7522 priv->ieee->stats.rx_dropped++;
7523 priv->wstats.discard.misc++;
7524 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7528 /* copy the frame itself */
7529 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7530 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7532 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7533 * part of our real header, saves a little time.
7535 * No longer necessary since we fill in all our data. Purge before merging
7537 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7538 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7541 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7543 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7544 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7545 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7547 /* Big bitfield of all the fields we provide in radiotap */
7548 ipw_rt->rt_hdr.it_present =
7549 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7550 (1 << IEEE80211_RADIOTAP_RATE) |
7551 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7552 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7553 (1 << IEEE80211_RADIOTAP_ANTENNA));
7555 /* Zero the flags, we'll add to them as we go */
7556 ipw_rt->rt_flags = 0;
7558 /* Convert signal to DBM */
7559 ipw_rt->rt_dbmsignal = antsignal;
7561 /* Convert the channel data and set the flags */
7562 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7563 if (received_channel > 14) { /* 802.11a */
7564 ipw_rt->rt_chbitmask =
7565 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7566 } else if (antennaAndPhy & 32) { /* 802.11b */
7567 ipw_rt->rt_chbitmask =
7568 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7569 } else { /* 802.11g */
7570 ipw_rt->rt_chbitmask =
7571 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7574 /* set the rate in multiples of 500k/s */
7576 case IPW_TX_RATE_1MB:
7577 ipw_rt->rt_rate = 2;
7579 case IPW_TX_RATE_2MB:
7580 ipw_rt->rt_rate = 4;
7582 case IPW_TX_RATE_5MB:
7583 ipw_rt->rt_rate = 10;
7585 case IPW_TX_RATE_6MB:
7586 ipw_rt->rt_rate = 12;
7588 case IPW_TX_RATE_9MB:
7589 ipw_rt->rt_rate = 18;
7591 case IPW_TX_RATE_11MB:
7592 ipw_rt->rt_rate = 22;
7594 case IPW_TX_RATE_12MB:
7595 ipw_rt->rt_rate = 24;
7597 case IPW_TX_RATE_18MB:
7598 ipw_rt->rt_rate = 36;
7600 case IPW_TX_RATE_24MB:
7601 ipw_rt->rt_rate = 48;
7603 case IPW_TX_RATE_36MB:
7604 ipw_rt->rt_rate = 72;
7606 case IPW_TX_RATE_48MB:
7607 ipw_rt->rt_rate = 96;
7609 case IPW_TX_RATE_54MB:
7610 ipw_rt->rt_rate = 108;
7613 ipw_rt->rt_rate = 0;
7617 /* antenna number */
7618 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7620 /* set the preamble flag if we have it */
7621 if ((antennaAndPhy & 64))
7622 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7624 /* Set the size of the skb to the size of the frame */
7625 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7627 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7629 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7630 priv->ieee->stats.rx_errors++;
7631 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7633 /* no LED during capture */
7638 static inline int is_network_packet(struct ipw_priv *priv,
7639 struct ieee80211_hdr_4addr *header)
7641 /* Filter incoming packets to determine if they are targetted toward
7642 * this network, discarding packets coming from ourselves */
7643 switch (priv->ieee->iw_mode) {
7644 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
7645 /* packets from our adapter are dropped (echo) */
7646 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7649 /* {broad,multi}cast packets to our BSSID go through */
7650 if (is_multicast_ether_addr(header->addr1) ||
7651 is_broadcast_ether_addr(header->addr1))
7652 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
7654 /* packets to our adapter go through */
7655 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7658 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
7659 /* packets from our adapter are dropped (echo) */
7660 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7663 /* {broad,multi}cast packets to our BSS go through */
7664 if (is_multicast_ether_addr(header->addr1) ||
7665 is_broadcast_ether_addr(header->addr1))
7666 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7668 /* packets to our adapter go through */
7669 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7676 #define IPW_PACKET_RETRY_TIME HZ
7678 static inline int is_duplicate_packet(struct ipw_priv *priv,
7679 struct ieee80211_hdr_4addr *header)
7681 u16 sc = le16_to_cpu(header->seq_ctl);
7682 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7683 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7684 u16 *last_seq, *last_frag;
7685 unsigned long *last_time;
7687 switch (priv->ieee->iw_mode) {
7690 struct list_head *p;
7691 struct ipw_ibss_seq *entry = NULL;
7692 u8 *mac = header->addr2;
7693 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7695 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7697 list_entry(p, struct ipw_ibss_seq, list);
7698 if (!memcmp(entry->mac, mac, ETH_ALEN))
7701 if (p == &priv->ibss_mac_hash[index]) {
7702 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7705 ("Cannot malloc new mac entry\n");
7708 memcpy(entry->mac, mac, ETH_ALEN);
7709 entry->seq_num = seq;
7710 entry->frag_num = frag;
7711 entry->packet_time = jiffies;
7712 list_add(&entry->list,
7713 &priv->ibss_mac_hash[index]);
7716 last_seq = &entry->seq_num;
7717 last_frag = &entry->frag_num;
7718 last_time = &entry->packet_time;
7722 last_seq = &priv->last_seq_num;
7723 last_frag = &priv->last_frag_num;
7724 last_time = &priv->last_packet_time;
7729 if ((*last_seq == seq) &&
7730 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7731 if (*last_frag == frag)
7733 if (*last_frag + 1 != frag)
7734 /* out-of-order fragment */
7740 *last_time = jiffies;
7744 /* Comment this line now since we observed the card receives
7745 * duplicate packets but the FCTL_RETRY bit is not set in the
7746 * IBSS mode with fragmentation enabled.
7747 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
7751 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7752 struct ipw_rx_mem_buffer *rxb,
7753 struct ieee80211_rx_stats *stats)
7755 struct sk_buff *skb = rxb->skb;
7756 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7757 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7758 (skb->data + IPW_RX_FRAME_SIZE);
7760 ieee80211_rx_mgt(priv->ieee, header, stats);
7762 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7763 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7764 IEEE80211_STYPE_PROBE_RESP) ||
7765 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7766 IEEE80211_STYPE_BEACON))) {
7767 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7768 ipw_add_station(priv, header->addr2);
7771 if (priv->config & CFG_NET_STATS) {
7772 IPW_DEBUG_HC("sending stat packet\n");
7774 /* Set the size of the skb to the size of the full
7775 * ipw header and 802.11 frame */
7776 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7779 /* Advance past the ipw packet header to the 802.11 frame */
7780 skb_pull(skb, IPW_RX_FRAME_SIZE);
7782 /* Push the ieee80211_rx_stats before the 802.11 frame */
7783 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7785 skb->dev = priv->ieee->dev;
7787 /* Point raw at the ieee80211_stats */
7788 skb->mac.raw = skb->data;
7790 skb->pkt_type = PACKET_OTHERHOST;
7791 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7792 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7799 * Main entry function for recieving a packet with 80211 headers. This
7800 * should be called when ever the FW has notified us that there is a new
7801 * skb in the recieve queue.
7803 static void ipw_rx(struct ipw_priv *priv)
7805 struct ipw_rx_mem_buffer *rxb;
7806 struct ipw_rx_packet *pkt;
7807 struct ieee80211_hdr_4addr *header;
7811 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7812 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
7813 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7816 rxb = priv->rxq->queue[i];
7817 #ifdef CONFIG_IPW2200_DEBUG
7818 if (unlikely(rxb == NULL)) {
7819 printk(KERN_CRIT "Queue not allocated!\n");
7823 priv->rxq->queue[i] = NULL;
7825 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
7827 PCI_DMA_FROMDEVICE);
7829 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7830 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7831 pkt->header.message_type,
7832 pkt->header.rx_seq_num, pkt->header.control_bits);
7834 switch (pkt->header.message_type) {
7835 case RX_FRAME_TYPE: /* 802.11 frame */ {
7836 struct ieee80211_rx_stats stats = {
7838 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7841 le16_to_cpu(pkt->u.frame.signal),
7843 le16_to_cpu(pkt->u.frame.noise),
7844 .rate = pkt->u.frame.rate,
7845 .mac_time = jiffies,
7847 pkt->u.frame.received_channel,
7850 control & (1 << 0)) ?
7851 IEEE80211_24GHZ_BAND :
7852 IEEE80211_52GHZ_BAND,
7853 .len = le16_to_cpu(pkt->u.frame.length),
7856 if (stats.rssi != 0)
7857 stats.mask |= IEEE80211_STATMASK_RSSI;
7858 if (stats.signal != 0)
7859 stats.mask |= IEEE80211_STATMASK_SIGNAL;
7860 if (stats.noise != 0)
7861 stats.mask |= IEEE80211_STATMASK_NOISE;
7862 if (stats.rate != 0)
7863 stats.mask |= IEEE80211_STATMASK_RATE;
7867 #ifdef CONFIG_IPW2200_MONITOR
7868 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7869 #ifdef CONFIG_IEEE80211_RADIOTAP
7870 ipw_handle_data_packet_monitor(priv,
7874 ipw_handle_data_packet(priv, rxb,
7882 (struct ieee80211_hdr_4addr *)(rxb->skb->
7885 /* TODO: Check Ad-Hoc dest/source and make sure
7886 * that we are actually parsing these packets
7887 * correctly -- we should probably use the
7888 * frame control of the packet and disregard
7889 * the current iw_mode */
7892 is_network_packet(priv, header);
7893 if (network_packet && priv->assoc_network) {
7894 priv->assoc_network->stats.rssi =
7896 average_add(&priv->average_rssi,
7898 priv->last_rx_rssi = stats.rssi;
7901 IPW_DEBUG_RX("Frame: len=%u\n",
7902 le16_to_cpu(pkt->u.frame.length));
7904 if (le16_to_cpu(pkt->u.frame.length) <
7905 frame_hdr_len(header)) {
7907 ("Received packet is too small. "
7909 priv->ieee->stats.rx_errors++;
7910 priv->wstats.discard.misc++;
7914 switch (WLAN_FC_GET_TYPE
7915 (le16_to_cpu(header->frame_ctl))) {
7917 case IEEE80211_FTYPE_MGMT:
7918 ipw_handle_mgmt_packet(priv, rxb,
7922 case IEEE80211_FTYPE_CTL:
7925 case IEEE80211_FTYPE_DATA:
7926 if (unlikely(!network_packet ||
7927 is_duplicate_packet(priv,
7930 IPW_DEBUG_DROP("Dropping: "
7943 ipw_handle_data_packet(priv, rxb,
7951 case RX_HOST_NOTIFICATION_TYPE:{
7953 ("Notification: subtype=%02X flags=%02X size=%d\n",
7954 pkt->u.notification.subtype,
7955 pkt->u.notification.flags,
7956 pkt->u.notification.size);
7957 ipw_rx_notification(priv, &pkt->u.notification);
7962 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7963 pkt->header.message_type);
7967 /* For now we just don't re-use anything. We can tweak this
7968 * later to try and re-use notification packets and SKBs that
7969 * fail to Rx correctly */
7970 if (rxb->skb != NULL) {
7971 dev_kfree_skb_any(rxb->skb);
7975 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
7976 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
7977 list_add_tail(&rxb->list, &priv->rxq->rx_used);
7979 i = (i + 1) % RX_QUEUE_SIZE;
7982 /* Backtrack one entry */
7983 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7985 ipw_rx_queue_restock(priv);
7988 #define DEFAULT_RTS_THRESHOLD 2304U
7989 #define MIN_RTS_THRESHOLD 1U
7990 #define MAX_RTS_THRESHOLD 2304U
7991 #define DEFAULT_BEACON_INTERVAL 100U
7992 #define DEFAULT_SHORT_RETRY_LIMIT 7U
7993 #define DEFAULT_LONG_RETRY_LIMIT 4U
7995 static int ipw_sw_reset(struct ipw_priv *priv, int init)
7997 int band, modulation;
7998 int old_mode = priv->ieee->iw_mode;
8000 /* Initialize module parameter values here */
8003 /* We default to disabling the LED code as right now it causes
8004 * too many systems to lock up... */
8006 priv->config |= CFG_NO_LED;
8009 priv->config |= CFG_ASSOCIATE;
8011 IPW_DEBUG_INFO("Auto associate disabled.\n");
8014 priv->config |= CFG_ADHOC_CREATE;
8016 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8019 priv->status |= STATUS_RF_KILL_SW;
8020 IPW_DEBUG_INFO("Radio disabled.\n");
8024 priv->config |= CFG_STATIC_CHANNEL;
8025 priv->channel = channel;
8026 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8027 /* TODO: Validate that provided channel is in range */
8029 #ifdef CONFIG_IPW_QOS
8030 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8031 burst_duration_CCK, burst_duration_OFDM);
8032 #endif /* CONFIG_IPW_QOS */
8036 priv->ieee->iw_mode = IW_MODE_ADHOC;
8037 priv->net_dev->type = ARPHRD_ETHER;
8040 #ifdef CONFIG_IPW2200_MONITOR
8042 priv->ieee->iw_mode = IW_MODE_MONITOR;
8043 #ifdef CONFIG_IEEE80211_RADIOTAP
8044 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8046 priv->net_dev->type = ARPHRD_IEEE80211;
8052 priv->net_dev->type = ARPHRD_ETHER;
8053 priv->ieee->iw_mode = IW_MODE_INFRA;
8058 priv->ieee->host_encrypt = 0;
8059 priv->ieee->host_encrypt_msdu = 0;
8060 priv->ieee->host_decrypt = 0;
8061 priv->ieee->host_mc_decrypt = 0;
8063 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8065 /* IPW2200/2915 is abled to do hardware fragmentation. */
8066 priv->ieee->host_open_frag = 0;
8068 if ((priv->pci_dev->device == 0x4223) ||
8069 (priv->pci_dev->device == 0x4224)) {
8071 printk(KERN_INFO DRV_NAME
8072 ": Detected Intel PRO/Wireless 2915ABG Network "
8074 priv->ieee->abg_true = 1;
8075 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8076 modulation = IEEE80211_OFDM_MODULATION |
8077 IEEE80211_CCK_MODULATION;
8078 priv->adapter = IPW_2915ABG;
8079 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8082 printk(KERN_INFO DRV_NAME
8083 ": Detected Intel PRO/Wireless 2200BG Network "
8086 priv->ieee->abg_true = 0;
8087 band = IEEE80211_24GHZ_BAND;
8088 modulation = IEEE80211_OFDM_MODULATION |
8089 IEEE80211_CCK_MODULATION;
8090 priv->adapter = IPW_2200BG;
8091 priv->ieee->mode = IEEE_G | IEEE_B;
8094 priv->ieee->freq_band = band;
8095 priv->ieee->modulation = modulation;
8097 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8099 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8100 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8102 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8103 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8104 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8106 /* If power management is turned on, default to AC mode */
8107 priv->power_mode = IPW_POWER_AC;
8108 priv->tx_power = IPW_TX_POWER_DEFAULT;
8110 return old_mode == priv->ieee->iw_mode;
8114 * This file defines the Wireless Extension handlers. It does not
8115 * define any methods of hardware manipulation and relies on the
8116 * functions defined in ipw_main to provide the HW interaction.
8118 * The exception to this is the use of the ipw_get_ordinal()
8119 * function used to poll the hardware vs. making unecessary calls.
8123 static int ipw_wx_get_name(struct net_device *dev,
8124 struct iw_request_info *info,
8125 union iwreq_data *wrqu, char *extra)
8127 struct ipw_priv *priv = ieee80211_priv(dev);
8129 if (priv->status & STATUS_RF_KILL_MASK)
8130 strcpy(wrqu->name, "radio off");
8131 else if (!(priv->status & STATUS_ASSOCIATED))
8132 strcpy(wrqu->name, "unassociated");
8134 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8135 ipw_modes[priv->assoc_request.ieee_mode]);
8136 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8141 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8144 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8145 priv->config &= ~CFG_STATIC_CHANNEL;
8146 IPW_DEBUG_ASSOC("Attempting to associate with new "
8148 ipw_associate(priv);
8152 priv->config |= CFG_STATIC_CHANNEL;
8154 if (priv->channel == channel) {
8155 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8160 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8161 priv->channel = channel;
8163 #ifdef CONFIG_IPW2200_MONITOR
8164 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8166 if (priv->status & STATUS_SCANNING) {
8167 IPW_DEBUG_SCAN("Scan abort triggered due to "
8168 "channel change.\n");
8169 ipw_abort_scan(priv);
8172 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8175 if (priv->status & STATUS_SCANNING)
8176 IPW_DEBUG_SCAN("Still scanning...\n");
8178 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8183 #endif /* CONFIG_IPW2200_MONITOR */
8185 /* Network configuration changed -- force [re]association */
8186 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8187 if (!ipw_disassociate(priv))
8188 ipw_associate(priv);
8193 static int ipw_wx_set_freq(struct net_device *dev,
8194 struct iw_request_info *info,
8195 union iwreq_data *wrqu, char *extra)
8197 struct ipw_priv *priv = ieee80211_priv(dev);
8198 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8199 struct iw_freq *fwrq = &wrqu->freq;
8205 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8207 ret = ipw_set_channel(priv, 0);
8211 /* if setting by freq convert to channel */
8213 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
8219 if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8222 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8223 i = ipw_channel_to_index(priv->ieee, channel);
8227 flags = (band == IEEE80211_24GHZ_BAND) ?
8228 geo->bg[i].flags : geo->a[i].flags;
8229 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8230 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8235 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8237 ret = ipw_set_channel(priv, channel);
8242 static int ipw_wx_get_freq(struct net_device *dev,
8243 struct iw_request_info *info,
8244 union iwreq_data *wrqu, char *extra)
8246 struct ipw_priv *priv = ieee80211_priv(dev);
8250 /* If we are associated, trying to associate, or have a statically
8251 * configured CHANNEL then return that; otherwise return ANY */
8253 if (priv->config & CFG_STATIC_CHANNEL ||
8254 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8255 wrqu->freq.m = priv->channel;
8260 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8264 static int ipw_wx_set_mode(struct net_device *dev,
8265 struct iw_request_info *info,
8266 union iwreq_data *wrqu, char *extra)
8268 struct ipw_priv *priv = ieee80211_priv(dev);
8271 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8273 switch (wrqu->mode) {
8274 #ifdef CONFIG_IPW2200_MONITOR
8275 case IW_MODE_MONITOR:
8281 wrqu->mode = IW_MODE_INFRA;
8286 if (wrqu->mode == priv->ieee->iw_mode)
8291 ipw_sw_reset(priv, 0);
8293 #ifdef CONFIG_IPW2200_MONITOR
8294 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8295 priv->net_dev->type = ARPHRD_ETHER;
8297 if (wrqu->mode == IW_MODE_MONITOR)
8298 #ifdef CONFIG_IEEE80211_RADIOTAP
8299 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8301 priv->net_dev->type = ARPHRD_IEEE80211;
8303 #endif /* CONFIG_IPW2200_MONITOR */
8305 /* Free the existing firmware and reset the fw_loaded
8306 * flag so ipw_load() will bring in the new firmawre */
8309 priv->ieee->iw_mode = wrqu->mode;
8311 queue_work(priv->workqueue, &priv->adapter_restart);
8316 static int ipw_wx_get_mode(struct net_device *dev,
8317 struct iw_request_info *info,
8318 union iwreq_data *wrqu, char *extra)
8320 struct ipw_priv *priv = ieee80211_priv(dev);
8322 wrqu->mode = priv->ieee->iw_mode;
8323 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8328 /* Values are in microsecond */
8329 static const s32 timeout_duration[] = {
8337 static const s32 period_duration[] = {
8345 static int ipw_wx_get_range(struct net_device *dev,
8346 struct iw_request_info *info,
8347 union iwreq_data *wrqu, char *extra)
8349 struct ipw_priv *priv = ieee80211_priv(dev);
8350 struct iw_range *range = (struct iw_range *)extra;
8351 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8354 wrqu->data.length = sizeof(*range);
8355 memset(range, 0, sizeof(*range));
8357 /* 54Mbs == ~27 Mb/s real (802.11g) */
8358 range->throughput = 27 * 1000 * 1000;
8360 range->max_qual.qual = 100;
8361 /* TODO: Find real max RSSI and stick here */
8362 range->max_qual.level = 0;
8363 range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
8364 range->max_qual.updated = 7; /* Updated all three */
8366 range->avg_qual.qual = 70;
8367 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8368 range->avg_qual.level = 0; /* FIXME to real average level */
8369 range->avg_qual.noise = 0;
8370 range->avg_qual.updated = 7; /* Updated all three */
8372 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8374 for (i = 0; i < range->num_bitrates; i++)
8375 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8378 range->max_rts = DEFAULT_RTS_THRESHOLD;
8379 range->min_frag = MIN_FRAG_THRESHOLD;
8380 range->max_frag = MAX_FRAG_THRESHOLD;
8382 range->encoding_size[0] = 5;
8383 range->encoding_size[1] = 13;
8384 range->num_encoding_sizes = 2;
8385 range->max_encoding_tokens = WEP_KEYS;
8387 /* Set the Wireless Extension versions */
8388 range->we_version_compiled = WIRELESS_EXT;
8389 range->we_version_source = 16;
8392 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8393 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8395 range->freq[i].i = geo->bg[j].channel;
8396 range->freq[i].m = geo->bg[j].freq * 100000;
8397 range->freq[i].e = 1;
8401 if (priv->ieee->mode & IEEE_A) {
8402 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8404 range->freq[i].i = geo->a[j].channel;
8405 range->freq[i].m = geo->a[j].freq * 100000;
8406 range->freq[i].e = 1;
8410 range->num_channels = i;
8411 range->num_frequency = i;
8415 /* Event capability (kernel + driver) */
8416 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8417 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8418 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8419 range->event_capa[1] = IW_EVENT_CAPA_K_1;
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)
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);
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");
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);
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 */
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));
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 */
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);
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");
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);
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 */
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 */
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)
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");
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");
8597 wrqu->data.length = strlen(priv->nick) + 1;
8598 memcpy(extra, priv->nick, wrqu->data.length);
8599 wrqu->data.flags = 1; /* active */
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");
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");
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);
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);
8723 wrqu->bitrate.value = priv->last_rate;
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);
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) {
8743 priv->rts_threshold = wrqu->rts.value;
8746 ipw_send_rts_threshold(priv, priv->rts_threshold);
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);
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);
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);
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);
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);
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;
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);
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) {
8833 priv->ieee->fts = wrqu->frag.value & ~0x1;
8836 ipw_send_frag_threshold(priv, wrqu->frag.value);
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);
8848 wrqu->frag.value = priv->ieee->fts;
8849 wrqu->frag.fixed = 0; /* no auto select */
8850 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
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)
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);
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);
8897 wrqu->retry.disabled = 0;
8899 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
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;
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))
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 err = wait_event_interruptible(priv->wait_state,
8944 status & (STATUS_SCANNING |
8945 STATUS_SCAN_ABORTING)));
8947 IPW_DEBUG_HC("aborting direct scan");
8951 memset(&scan, 0, sizeof(scan));
8953 if (priv->config & CFG_SPEED_SCAN)
8954 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8957 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8960 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8962 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8963 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8965 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8967 err = ipw_send_ssid(priv, essid, essid_len);
8969 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8972 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8974 ipw_add_scan_channels(priv, &scan, scan_type);
8976 err = ipw_send_scan_request_ext(priv, &scan);
8978 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8982 priv->status |= STATUS_SCANNING;
8989 static int ipw_wx_set_scan(struct net_device *dev,
8990 struct iw_request_info *info,
8991 union iwreq_data *wrqu, char *extra)
8993 struct ipw_priv *priv = ieee80211_priv(dev);
8994 struct iw_scan_req *req = NULL;
8995 if (wrqu->data.length
8996 && wrqu->data.length == sizeof(struct iw_scan_req)) {
8997 req = (struct iw_scan_req *)extra;
8998 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
8999 ipw_request_direct_scan(priv, req->essid,
9005 IPW_DEBUG_WX("Start scan\n");
9007 queue_work(priv->workqueue, &priv->request_scan);
9012 static int ipw_wx_get_scan(struct net_device *dev,
9013 struct iw_request_info *info,
9014 union iwreq_data *wrqu, char *extra)
9016 struct ipw_priv *priv = ieee80211_priv(dev);
9017 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9020 static int ipw_wx_set_encode(struct net_device *dev,
9021 struct iw_request_info *info,
9022 union iwreq_data *wrqu, char *key)
9024 struct ipw_priv *priv = ieee80211_priv(dev);
9026 u32 cap = priv->capability;
9029 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9031 /* In IBSS mode, we need to notify the firmware to update
9032 * the beacon info after we changed the capability. */
9033 if (cap != priv->capability &&
9034 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9035 priv->status & STATUS_ASSOCIATED)
9036 ipw_disassociate(priv);
9042 static int ipw_wx_get_encode(struct net_device *dev,
9043 struct iw_request_info *info,
9044 union iwreq_data *wrqu, char *key)
9046 struct ipw_priv *priv = ieee80211_priv(dev);
9047 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9050 static int ipw_wx_set_power(struct net_device *dev,
9051 struct iw_request_info *info,
9052 union iwreq_data *wrqu, char *extra)
9054 struct ipw_priv *priv = ieee80211_priv(dev);
9057 if (wrqu->power.disabled) {
9058 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9059 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9061 IPW_DEBUG_WX("failed setting power mode.\n");
9065 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9070 switch (wrqu->power.flags & IW_POWER_MODE) {
9071 case IW_POWER_ON: /* If not specified */
9072 case IW_POWER_MODE: /* If set all mask */
9073 case IW_POWER_ALL_R: /* If explicitely state all */
9075 default: /* Otherwise we don't support it */
9076 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9082 /* If the user hasn't specified a power management mode yet, default
9084 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9085 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9087 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9088 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9090 IPW_DEBUG_WX("failed setting power mode.\n");
9095 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9100 static int ipw_wx_get_power(struct net_device *dev,
9101 struct iw_request_info *info,
9102 union iwreq_data *wrqu, char *extra)
9104 struct ipw_priv *priv = ieee80211_priv(dev);
9106 if (!(priv->power_mode & IPW_POWER_ENABLED))
9107 wrqu->power.disabled = 1;
9109 wrqu->power.disabled = 0;
9112 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9117 static int ipw_wx_set_powermode(struct net_device *dev,
9118 struct iw_request_info *info,
9119 union iwreq_data *wrqu, char *extra)
9121 struct ipw_priv *priv = ieee80211_priv(dev);
9122 int mode = *(int *)extra;
9125 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9126 mode = IPW_POWER_AC;
9127 priv->power_mode = mode;
9129 priv->power_mode = IPW_POWER_ENABLED | mode;
9132 if (priv->power_mode != mode) {
9133 err = ipw_send_power_mode(priv, mode);
9136 IPW_DEBUG_WX("failed setting power mode.\n");
9145 #define MAX_WX_STRING 80
9146 static int ipw_wx_get_powermode(struct net_device *dev,
9147 struct iw_request_info *info,
9148 union iwreq_data *wrqu, char *extra)
9150 struct ipw_priv *priv = ieee80211_priv(dev);
9151 int level = IPW_POWER_LEVEL(priv->power_mode);
9154 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9158 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9160 case IPW_POWER_BATTERY:
9161 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9164 p += snprintf(p, MAX_WX_STRING - (p - extra),
9165 "(Timeout %dms, Period %dms)",
9166 timeout_duration[level - 1] / 1000,
9167 period_duration[level - 1] / 1000);
9170 if (!(priv->power_mode & IPW_POWER_ENABLED))
9171 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9173 wrqu->data.length = p - extra + 1;
9178 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9179 struct iw_request_info *info,
9180 union iwreq_data *wrqu, char *extra)
9182 struct ipw_priv *priv = ieee80211_priv(dev);
9183 int mode = *(int *)extra;
9184 u8 band = 0, modulation = 0;
9186 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9187 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9191 if (priv->adapter == IPW_2915ABG) {
9192 priv->ieee->abg_true = 1;
9193 if (mode & IEEE_A) {
9194 band |= IEEE80211_52GHZ_BAND;
9195 modulation |= IEEE80211_OFDM_MODULATION;
9197 priv->ieee->abg_true = 0;
9199 if (mode & IEEE_A) {
9200 IPW_WARNING("Attempt to set 2200BG into "
9206 priv->ieee->abg_true = 0;
9209 if (mode & IEEE_B) {
9210 band |= IEEE80211_24GHZ_BAND;
9211 modulation |= IEEE80211_CCK_MODULATION;
9213 priv->ieee->abg_true = 0;
9215 if (mode & IEEE_G) {
9216 band |= IEEE80211_24GHZ_BAND;
9217 modulation |= IEEE80211_OFDM_MODULATION;
9219 priv->ieee->abg_true = 0;
9221 priv->ieee->mode = mode;
9222 priv->ieee->freq_band = band;
9223 priv->ieee->modulation = modulation;
9224 init_supported_rates(priv, &priv->rates);
9226 /* Network configuration changed -- force [re]association */
9227 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9228 if (!ipw_disassociate(priv)) {
9229 ipw_send_supported_rates(priv, &priv->rates);
9230 ipw_associate(priv);
9233 /* Update the band LEDs */
9234 ipw_led_band_on(priv);
9236 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9237 mode & IEEE_A ? 'a' : '.',
9238 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9243 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9244 struct iw_request_info *info,
9245 union iwreq_data *wrqu, char *extra)
9247 struct ipw_priv *priv = ieee80211_priv(dev);
9249 switch (priv->ieee->mode) {
9251 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9254 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9256 case IEEE_A | IEEE_B:
9257 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9260 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9262 case IEEE_A | IEEE_G:
9263 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9265 case IEEE_B | IEEE_G:
9266 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9268 case IEEE_A | IEEE_B | IEEE_G:
9269 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9272 strncpy(extra, "unknown", MAX_WX_STRING);
9276 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9278 wrqu->data.length = strlen(extra) + 1;
9284 static int ipw_wx_set_preamble(struct net_device *dev,
9285 struct iw_request_info *info,
9286 union iwreq_data *wrqu, char *extra)
9288 struct ipw_priv *priv = ieee80211_priv(dev);
9289 int mode = *(int *)extra;
9291 /* Switching from SHORT -> LONG requires a disassociation */
9293 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9294 priv->config |= CFG_PREAMBLE_LONG;
9296 /* Network configuration changed -- force [re]association */
9298 ("[re]association triggered due to preamble change.\n");
9299 if (!ipw_disassociate(priv))
9300 ipw_associate(priv);
9306 priv->config &= ~CFG_PREAMBLE_LONG;
9317 static int ipw_wx_get_preamble(struct net_device *dev,
9318 struct iw_request_info *info,
9319 union iwreq_data *wrqu, char *extra)
9321 struct ipw_priv *priv = ieee80211_priv(dev);
9323 if (priv->config & CFG_PREAMBLE_LONG)
9324 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9326 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9331 #ifdef CONFIG_IPW2200_MONITOR
9332 static int ipw_wx_set_monitor(struct net_device *dev,
9333 struct iw_request_info *info,
9334 union iwreq_data *wrqu, char *extra)
9336 struct ipw_priv *priv = ieee80211_priv(dev);
9337 int *parms = (int *)extra;
9338 int enable = (parms[0] > 0);
9340 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9342 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9343 #ifdef CONFIG_IEEE80211_RADIOTAP
9344 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9346 priv->net_dev->type = ARPHRD_IEEE80211;
9348 queue_work(priv->workqueue, &priv->adapter_restart);
9351 ipw_set_channel(priv, parms[1]);
9353 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9357 priv->net_dev->type = ARPHRD_ETHER;
9358 queue_work(priv->workqueue, &priv->adapter_restart);
9364 #endif // CONFIG_IPW2200_MONITOR
9366 static int ipw_wx_reset(struct net_device *dev,
9367 struct iw_request_info *info,
9368 union iwreq_data *wrqu, char *extra)
9370 struct ipw_priv *priv = ieee80211_priv(dev);
9371 IPW_DEBUG_WX("RESET\n");
9372 queue_work(priv->workqueue, &priv->adapter_restart);
9376 static int ipw_wx_sw_reset(struct net_device *dev,
9377 struct iw_request_info *info,
9378 union iwreq_data *wrqu, char *extra)
9380 struct ipw_priv *priv = ieee80211_priv(dev);
9381 union iwreq_data wrqu_sec = {
9383 .flags = IW_ENCODE_DISABLED,
9388 IPW_DEBUG_WX("SW_RESET\n");
9392 ret = ipw_sw_reset(priv, 0);
9395 ipw_adapter_restart(priv);
9398 /* The SW reset bit might have been toggled on by the 'disable'
9399 * module parameter, so take appropriate action */
9400 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9403 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9406 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9407 /* Configuration likely changed -- force [re]association */
9408 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9410 if (!ipw_disassociate(priv))
9411 ipw_associate(priv);
9419 /* Rebase the WE IOCTLs to zero for the handler array */
9420 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9421 static iw_handler ipw_wx_handlers[] = {
9422 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9423 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9424 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9425 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9426 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9427 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9428 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9429 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9430 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9431 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9432 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9433 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9434 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9435 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9436 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9437 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9438 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9439 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9440 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9441 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9442 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9443 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9444 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9445 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9446 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9447 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9448 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9449 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9450 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9451 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9452 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9453 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9454 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9455 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9456 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9457 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9458 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9459 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9460 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9464 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9468 IPW_PRIV_SET_PREAMBLE,
9469 IPW_PRIV_GET_PREAMBLE,
9472 #ifdef CONFIG_IPW2200_MONITOR
9473 IPW_PRIV_SET_MONITOR,
9477 static struct iw_priv_args ipw_priv_args[] = {
9479 .cmd = IPW_PRIV_SET_POWER,
9480 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9481 .name = "set_power"},
9483 .cmd = IPW_PRIV_GET_POWER,
9484 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9485 .name = "get_power"},
9487 .cmd = IPW_PRIV_SET_MODE,
9488 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9489 .name = "set_mode"},
9491 .cmd = IPW_PRIV_GET_MODE,
9492 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9493 .name = "get_mode"},
9495 .cmd = IPW_PRIV_SET_PREAMBLE,
9496 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9497 .name = "set_preamble"},
9499 .cmd = IPW_PRIV_GET_PREAMBLE,
9500 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9501 .name = "get_preamble"},
9504 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9507 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9508 #ifdef CONFIG_IPW2200_MONITOR
9510 IPW_PRIV_SET_MONITOR,
9511 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9512 #endif /* CONFIG_IPW2200_MONITOR */
9515 static iw_handler ipw_priv_handler[] = {
9516 ipw_wx_set_powermode,
9517 ipw_wx_get_powermode,
9518 ipw_wx_set_wireless_mode,
9519 ipw_wx_get_wireless_mode,
9520 ipw_wx_set_preamble,
9521 ipw_wx_get_preamble,
9524 #ifdef CONFIG_IPW2200_MONITOR
9529 static struct iw_handler_def ipw_wx_handler_def = {
9530 .standard = ipw_wx_handlers,
9531 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9532 .num_private = ARRAY_SIZE(ipw_priv_handler),
9533 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9534 .private = ipw_priv_handler,
9535 .private_args = ipw_priv_args,
9536 .get_wireless_stats = ipw_get_wireless_stats,
9540 * Get wireless statistics.
9541 * Called by /proc/net/wireless
9542 * Also called by SIOCGIWSTATS
9544 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9546 struct ipw_priv *priv = ieee80211_priv(dev);
9547 struct iw_statistics *wstats;
9549 wstats = &priv->wstats;
9551 /* if hw is disabled, then ipw_get_ordinal() can't be called.
9552 * netdev->get_wireless_stats seems to be called before fw is
9553 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9554 * and associated; if not associcated, the values are all meaningless
9555 * anyway, so set them all to NULL and INVALID */
9556 if (!(priv->status & STATUS_ASSOCIATED)) {
9557 wstats->miss.beacon = 0;
9558 wstats->discard.retries = 0;
9559 wstats->qual.qual = 0;
9560 wstats->qual.level = 0;
9561 wstats->qual.noise = 0;
9562 wstats->qual.updated = 7;
9563 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9564 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9568 wstats->qual.qual = priv->quality;
9569 wstats->qual.level = average_value(&priv->average_rssi);
9570 wstats->qual.noise = average_value(&priv->average_noise);
9571 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9572 IW_QUAL_NOISE_UPDATED;
9574 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9575 wstats->discard.retries = priv->last_tx_failures;
9576 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9578 /* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9579 goto fail_get_ordinal;
9580 wstats->discard.retries += tx_retry; */
9585 /* net device stuff */
9587 static inline void init_sys_config(struct ipw_sys_config *sys_config)
9589 memset(sys_config, 0, sizeof(struct ipw_sys_config));
9590 sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
9591 sys_config->answer_broadcast_ssid_probe = 0;
9592 sys_config->accept_all_data_frames = 0;
9593 sys_config->accept_non_directed_frames = 1;
9594 sys_config->exclude_unicast_unencrypted = 0;
9595 sys_config->disable_unicast_decryption = 1;
9596 sys_config->exclude_multicast_unencrypted = 0;
9597 sys_config->disable_multicast_decryption = 1;
9598 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
9599 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
9600 sys_config->dot11g_auto_detection = 0;
9601 sys_config->enable_cts_to_self = 0;
9602 sys_config->bt_coexist_collision_thr = 0;
9603 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
9606 static int ipw_net_open(struct net_device *dev)
9608 struct ipw_priv *priv = ieee80211_priv(dev);
9609 IPW_DEBUG_INFO("dev->open\n");
9610 /* we should be verifying the device is ready to be opened */
9612 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9613 (priv->status & STATUS_ASSOCIATED))
9614 netif_start_queue(dev);
9619 static int ipw_net_stop(struct net_device *dev)
9621 IPW_DEBUG_INFO("dev->close\n");
9622 netif_stop_queue(dev);
9629 modify to send one tfd per fragment instead of using chunking. otherwise
9630 we need to heavily modify the ieee80211_skb_to_txb.
9633 static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9636 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9637 txb->fragments[0]->data;
9639 struct tfd_frame *tfd;
9640 #ifdef CONFIG_IPW_QOS
9641 int tx_id = ipw_get_tx_queue_number(priv, pri);
9642 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9644 struct clx2_tx_queue *txq = &priv->txq[0];
9646 struct clx2_queue *q = &txq->q;
9647 u8 id, hdr_len, unicast;
9648 u16 remaining_bytes;
9651 /* If there isn't room in the queue, we return busy and let the
9652 * network stack requeue the packet for us */
9653 if (ipw_queue_space(q) < q->high_mark)
9654 return NETDEV_TX_BUSY;
9656 switch (priv->ieee->iw_mode) {
9658 hdr_len = IEEE80211_3ADDR_LEN;
9659 unicast = !(is_multicast_ether_addr(hdr->addr1) ||
9660 is_broadcast_ether_addr(hdr->addr1));
9661 id = ipw_find_station(priv, hdr->addr1);
9662 if (id == IPW_INVALID_STATION) {
9663 id = ipw_add_station(priv, hdr->addr1);
9664 if (id == IPW_INVALID_STATION) {
9665 IPW_WARNING("Attempt to send data to "
9666 "invalid cell: " MAC_FMT "\n",
9667 MAC_ARG(hdr->addr1));
9675 unicast = !(is_multicast_ether_addr(hdr->addr3) ||
9676 is_broadcast_ether_addr(hdr->addr3));
9677 hdr_len = IEEE80211_3ADDR_LEN;
9682 tfd = &txq->bd[q->first_empty];
9683 txq->txb[q->first_empty] = txb;
9684 memset(tfd, 0, sizeof(*tfd));
9685 tfd->u.data.station_number = id;
9687 tfd->control_flags.message_type = TX_FRAME_TYPE;
9688 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9690 tfd->u.data.cmd_id = DINO_CMD_TX;
9691 tfd->u.data.len = cpu_to_le16(txb->payload_size);
9692 remaining_bytes = txb->payload_size;
9694 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9695 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9697 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9699 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9700 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9702 fc = le16_to_cpu(hdr->frame_ctl);
9703 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9705 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9707 if (likely(unicast))
9708 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9710 if (txb->encrypted && !priv->ieee->host_encrypt) {
9711 switch (priv->ieee->sec.level) {
9713 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9714 IEEE80211_FCTL_PROTECTED;
9715 /* XXX: ACK flag must be set for CCMP even if it
9716 * is a multicast/broadcast packet, because CCMP
9717 * group communication encrypted by GTK is
9718 * actually done by the AP. */
9720 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9722 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9723 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9724 tfd->u.data.key_index = 0;
9725 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9728 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9729 IEEE80211_FCTL_PROTECTED;
9730 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9731 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9732 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9735 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9736 IEEE80211_FCTL_PROTECTED;
9737 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9738 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9740 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9742 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9747 printk(KERN_ERR "Unknow security level %d\n",
9748 priv->ieee->sec.level);
9752 /* No hardware encryption */
9753 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9755 #ifdef CONFIG_IPW_QOS
9756 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9757 #endif /* CONFIG_IPW_QOS */
9760 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9762 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9763 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9764 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9765 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9766 i, le32_to_cpu(tfd->u.data.num_chunks),
9767 txb->fragments[i]->len - hdr_len);
9768 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9769 i, tfd->u.data.num_chunks,
9770 txb->fragments[i]->len - hdr_len);
9771 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9772 txb->fragments[i]->len - hdr_len);
9774 tfd->u.data.chunk_ptr[i] =
9775 cpu_to_le32(pci_map_single
9777 txb->fragments[i]->data + hdr_len,
9778 txb->fragments[i]->len - hdr_len,
9780 tfd->u.data.chunk_len[i] =
9781 cpu_to_le16(txb->fragments[i]->len - hdr_len);
9784 if (i != txb->nr_frags) {
9785 struct sk_buff *skb;
9786 u16 remaining_bytes = 0;
9789 for (j = i; j < txb->nr_frags; j++)
9790 remaining_bytes += txb->fragments[j]->len - hdr_len;
9792 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9794 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9796 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9797 for (j = i; j < txb->nr_frags; j++) {
9798 int size = txb->fragments[j]->len - hdr_len;
9800 printk(KERN_INFO "Adding frag %d %d...\n",
9802 memcpy(skb_put(skb, size),
9803 txb->fragments[j]->data + hdr_len, size);
9805 dev_kfree_skb_any(txb->fragments[i]);
9806 txb->fragments[i] = skb;
9807 tfd->u.data.chunk_ptr[i] =
9808 cpu_to_le32(pci_map_single
9809 (priv->pci_dev, skb->data,
9810 tfd->u.data.chunk_len[i],
9813 tfd->u.data.num_chunks =
9814 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9820 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9821 ipw_write32(priv, q->reg_w, q->first_empty);
9823 return NETDEV_TX_OK;
9826 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9827 ieee80211_txb_free(txb);
9828 return NETDEV_TX_OK;
9831 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9833 struct ipw_priv *priv = ieee80211_priv(dev);
9834 #ifdef CONFIG_IPW_QOS
9835 int tx_id = ipw_get_tx_queue_number(priv, pri);
9836 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9838 struct clx2_tx_queue *txq = &priv->txq[0];
9839 #endif /* CONFIG_IPW_QOS */
9841 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9847 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9848 struct net_device *dev, int pri)
9850 struct ipw_priv *priv = ieee80211_priv(dev);
9851 unsigned long flags;
9854 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9855 spin_lock_irqsave(&priv->lock, flags);
9857 if (!(priv->status & STATUS_ASSOCIATED)) {
9858 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9859 priv->ieee->stats.tx_carrier_errors++;
9860 netif_stop_queue(dev);
9864 ret = ipw_tx_skb(priv, txb, pri);
9865 if (ret == NETDEV_TX_OK)
9866 __ipw_led_activity_on(priv);
9867 spin_unlock_irqrestore(&priv->lock, flags);
9872 spin_unlock_irqrestore(&priv->lock, flags);
9876 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9878 struct ipw_priv *priv = ieee80211_priv(dev);
9880 priv->ieee->stats.tx_packets = priv->tx_packets;
9881 priv->ieee->stats.rx_packets = priv->rx_packets;
9882 return &priv->ieee->stats;
9885 static void ipw_net_set_multicast_list(struct net_device *dev)
9890 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9892 struct ipw_priv *priv = ieee80211_priv(dev);
9893 struct sockaddr *addr = p;
9894 if (!is_valid_ether_addr(addr->sa_data))
9895 return -EADDRNOTAVAIL;
9897 priv->config |= CFG_CUSTOM_MAC;
9898 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9899 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9900 priv->net_dev->name, MAC_ARG(priv->mac_addr));
9901 queue_work(priv->workqueue, &priv->adapter_restart);
9906 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9907 struct ethtool_drvinfo *info)
9909 struct ipw_priv *p = ieee80211_priv(dev);
9914 strcpy(info->driver, DRV_NAME);
9915 strcpy(info->version, DRV_VERSION);
9918 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9920 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9922 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9924 strcpy(info->bus_info, pci_name(p->pci_dev));
9925 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9928 static u32 ipw_ethtool_get_link(struct net_device *dev)
9930 struct ipw_priv *priv = ieee80211_priv(dev);
9931 return (priv->status & STATUS_ASSOCIATED) != 0;
9934 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9936 return IPW_EEPROM_IMAGE_SIZE;
9939 static int ipw_ethtool_get_eeprom(struct net_device *dev,
9940 struct ethtool_eeprom *eeprom, u8 * bytes)
9942 struct ipw_priv *p = ieee80211_priv(dev);
9944 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9947 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9952 static int ipw_ethtool_set_eeprom(struct net_device *dev,
9953 struct ethtool_eeprom *eeprom, u8 * bytes)
9955 struct ipw_priv *p = ieee80211_priv(dev);
9958 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9961 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
9962 for (i = IPW_EEPROM_DATA;
9963 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
9964 ipw_write8(p, i, p->eeprom[i]);
9969 static struct ethtool_ops ipw_ethtool_ops = {
9970 .get_link = ipw_ethtool_get_link,
9971 .get_drvinfo = ipw_ethtool_get_drvinfo,
9972 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9973 .get_eeprom = ipw_ethtool_get_eeprom,
9974 .set_eeprom = ipw_ethtool_set_eeprom,
9977 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9979 struct ipw_priv *priv = data;
9980 u32 inta, inta_mask;
9985 spin_lock(&priv->lock);
9987 if (!(priv->status & STATUS_INT_ENABLED)) {
9992 inta = ipw_read32(priv, IPW_INTA_RW);
9993 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
9995 if (inta == 0xFFFFFFFF) {
9996 /* Hardware disappeared */
9997 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10001 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10002 /* Shared interrupt */
10006 /* tell the device to stop sending interrupts */
10007 ipw_disable_interrupts(priv);
10009 /* ack current interrupts */
10010 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10011 ipw_write32(priv, IPW_INTA_RW, inta);
10013 /* Cache INTA value for our tasklet */
10014 priv->isr_inta = inta;
10016 tasklet_schedule(&priv->irq_tasklet);
10018 spin_unlock(&priv->lock);
10020 return IRQ_HANDLED;
10022 spin_unlock(&priv->lock);
10026 static void ipw_rf_kill(void *adapter)
10028 struct ipw_priv *priv = adapter;
10029 unsigned long flags;
10031 spin_lock_irqsave(&priv->lock, flags);
10033 if (rf_kill_active(priv)) {
10034 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10035 if (priv->workqueue)
10036 queue_delayed_work(priv->workqueue,
10037 &priv->rf_kill, 2 * HZ);
10041 /* RF Kill is now disabled, so bring the device back up */
10043 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10044 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10047 /* we can not do an adapter restart while inside an irq lock */
10048 queue_work(priv->workqueue, &priv->adapter_restart);
10050 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10054 spin_unlock_irqrestore(&priv->lock, flags);
10057 static void ipw_bg_rf_kill(void *data)
10059 struct ipw_priv *priv = data;
10065 void ipw_link_up(struct ipw_priv *priv)
10067 priv->last_seq_num = -1;
10068 priv->last_frag_num = -1;
10069 priv->last_packet_time = 0;
10071 netif_carrier_on(priv->net_dev);
10072 if (netif_queue_stopped(priv->net_dev)) {
10073 IPW_DEBUG_NOTIF("waking queue\n");
10074 netif_wake_queue(priv->net_dev);
10076 IPW_DEBUG_NOTIF("starting queue\n");
10077 netif_start_queue(priv->net_dev);
10080 cancel_delayed_work(&priv->request_scan);
10081 ipw_reset_stats(priv);
10082 /* Ensure the rate is updated immediately */
10083 priv->last_rate = ipw_get_current_rate(priv);
10084 ipw_gather_stats(priv);
10085 ipw_led_link_up(priv);
10086 notify_wx_assoc_event(priv);
10088 if (priv->config & CFG_BACKGROUND_SCAN)
10089 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10092 static void ipw_bg_link_up(void *data)
10094 struct ipw_priv *priv = data;
10100 void ipw_link_down(struct ipw_priv *priv)
10102 ipw_led_link_down(priv);
10103 netif_carrier_off(priv->net_dev);
10104 netif_stop_queue(priv->net_dev);
10105 notify_wx_assoc_event(priv);
10107 /* Cancel any queued work ... */
10108 cancel_delayed_work(&priv->request_scan);
10109 cancel_delayed_work(&priv->adhoc_check);
10110 cancel_delayed_work(&priv->gather_stats);
10112 ipw_reset_stats(priv);
10114 if (!(priv->status & STATUS_EXIT_PENDING)) {
10115 /* Queue up another scan... */
10116 queue_work(priv->workqueue, &priv->request_scan);
10120 static void ipw_bg_link_down(void *data)
10122 struct ipw_priv *priv = data;
10124 ipw_link_down(data);
10128 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10132 priv->workqueue = create_workqueue(DRV_NAME);
10133 init_waitqueue_head(&priv->wait_command_queue);
10134 init_waitqueue_head(&priv->wait_state);
10136 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10137 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10138 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10139 INIT_WORK(&priv->system_config, ipw_system_config, priv);
10140 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10141 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10142 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10143 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10144 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10145 INIT_WORK(&priv->request_scan,
10146 (void (*)(void *))ipw_request_scan, priv);
10147 INIT_WORK(&priv->gather_stats,
10148 (void (*)(void *))ipw_bg_gather_stats, priv);
10149 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10150 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10151 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10152 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10153 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10154 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10156 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10158 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10160 INIT_WORK(&priv->merge_networks,
10161 (void (*)(void *))ipw_merge_adhoc_network, priv);
10163 #ifdef CONFIG_IPW_QOS
10164 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10166 #endif /* CONFIG_IPW_QOS */
10168 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10169 ipw_irq_tasklet, (unsigned long)priv);
10174 static void shim__set_security(struct net_device *dev,
10175 struct ieee80211_security *sec)
10177 struct ipw_priv *priv = ieee80211_priv(dev);
10179 for (i = 0; i < 4; i++) {
10180 if (sec->flags & (1 << i)) {
10181 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10182 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10183 if (sec->key_sizes[i] == 0)
10184 priv->ieee->sec.flags &= ~(1 << i);
10186 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10187 sec->key_sizes[i]);
10188 priv->ieee->sec.flags |= (1 << i);
10190 priv->status |= STATUS_SECURITY_UPDATED;
10191 } else if (sec->level != SEC_LEVEL_1)
10192 priv->ieee->sec.flags &= ~(1 << i);
10195 if (sec->flags & SEC_ACTIVE_KEY) {
10196 if (sec->active_key <= 3) {
10197 priv->ieee->sec.active_key = sec->active_key;
10198 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10200 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10201 priv->status |= STATUS_SECURITY_UPDATED;
10203 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10205 if ((sec->flags & SEC_AUTH_MODE) &&
10206 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10207 priv->ieee->sec.auth_mode = sec->auth_mode;
10208 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10209 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10210 priv->capability |= CAP_SHARED_KEY;
10212 priv->capability &= ~CAP_SHARED_KEY;
10213 priv->status |= STATUS_SECURITY_UPDATED;
10216 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10217 priv->ieee->sec.flags |= SEC_ENABLED;
10218 priv->ieee->sec.enabled = sec->enabled;
10219 priv->status |= STATUS_SECURITY_UPDATED;
10221 priv->capability |= CAP_PRIVACY_ON;
10223 priv->capability &= ~CAP_PRIVACY_ON;
10226 if (sec->flags & SEC_ENCRYPT)
10227 priv->ieee->sec.encrypt = sec->encrypt;
10229 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10230 priv->ieee->sec.level = sec->level;
10231 priv->ieee->sec.flags |= SEC_LEVEL;
10232 priv->status |= STATUS_SECURITY_UPDATED;
10235 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10236 ipw_set_hwcrypto_keys(priv);
10238 /* To match current functionality of ipw2100 (which works well w/
10239 * various supplicants, we don't force a disassociate if the
10240 * privacy capability changes ... */
10242 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10243 (((priv->assoc_request.capability &
10244 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10245 (!(priv->assoc_request.capability &
10246 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10247 IPW_DEBUG_ASSOC("Disassociating due to capability "
10249 ipw_disassociate(priv);
10254 static int init_supported_rates(struct ipw_priv *priv,
10255 struct ipw_supported_rates *rates)
10257 /* TODO: Mask out rates based on priv->rates_mask */
10259 memset(rates, 0, sizeof(*rates));
10260 /* configure supported rates */
10261 switch (priv->ieee->freq_band) {
10262 case IEEE80211_52GHZ_BAND:
10263 rates->ieee_mode = IPW_A_MODE;
10264 rates->purpose = IPW_RATE_CAPABILITIES;
10265 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10266 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10269 default: /* Mixed or 2.4Ghz */
10270 rates->ieee_mode = IPW_G_MODE;
10271 rates->purpose = IPW_RATE_CAPABILITIES;
10272 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10273 IEEE80211_CCK_DEFAULT_RATES_MASK);
10274 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10275 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10276 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10284 static int ipw_config(struct ipw_priv *priv)
10286 /* This is only called from ipw_up, which resets/reloads the firmware
10287 so, we don't need to first disable the card before we configure
10289 if (ipw_set_tx_power(priv))
10292 /* initialize adapter address */
10293 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10296 /* set basic system config settings */
10297 init_sys_config(&priv->sys_config);
10298 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10299 priv->sys_config.answer_broadcast_ssid_probe = 1;
10301 priv->sys_config.answer_broadcast_ssid_probe = 0;
10303 if (ipw_send_system_config(priv, &priv->sys_config))
10306 init_supported_rates(priv, &priv->rates);
10307 if (ipw_send_supported_rates(priv, &priv->rates))
10310 /* Set request-to-send threshold */
10311 if (priv->rts_threshold) {
10312 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10315 #ifdef CONFIG_IPW_QOS
10316 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10317 ipw_qos_activate(priv, NULL);
10318 #endif /* CONFIG_IPW_QOS */
10320 if (ipw_set_random_seed(priv))
10323 /* final state transition to the RUN state */
10324 if (ipw_send_host_complete(priv))
10327 priv->status |= STATUS_INIT;
10329 ipw_led_init(priv);
10330 ipw_led_radio_on(priv);
10331 priv->notif_missed_beacons = 0;
10333 /* Set hardware WEP key if it is configured. */
10334 if ((priv->capability & CAP_PRIVACY_ON) &&
10335 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10336 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10337 ipw_set_hwcrypto_keys(priv);
10348 * These tables have been tested in conjunction with the
10349 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10351 * Altering this values, using it on other hardware, or in geographies
10352 * not intended for resale of the above mentioned Intel adapters has
10356 static const struct ieee80211_geo ipw_geos[] = {
10360 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10361 {2427, 4}, {2432, 5}, {2437, 6},
10362 {2442, 7}, {2447, 8}, {2452, 9},
10363 {2457, 10}, {2462, 11}},
10366 { /* Custom US/Canada */
10369 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10370 {2427, 4}, {2432, 5}, {2437, 6},
10371 {2442, 7}, {2447, 8}, {2452, 9},
10372 {2457, 10}, {2462, 11}},
10378 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10379 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10380 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10381 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10384 { /* Rest of World */
10387 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10388 {2427, 4}, {2432, 5}, {2437, 6},
10389 {2442, 7}, {2447, 8}, {2452, 9},
10390 {2457, 10}, {2462, 11}, {2467, 12},
10394 { /* Custom USA & Europe & High */
10397 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10398 {2427, 4}, {2432, 5}, {2437, 6},
10399 {2442, 7}, {2447, 8}, {2452, 9},
10400 {2457, 10}, {2462, 11}},
10406 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10407 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10408 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10409 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10417 { /* Custom NA & Europe */
10420 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10421 {2427, 4}, {2432, 5}, {2437, 6},
10422 {2442, 7}, {2447, 8}, {2452, 9},
10423 {2457, 10}, {2462, 11}},
10429 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10430 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10431 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10432 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10433 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10434 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10435 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10436 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10437 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10440 { /* Custom Japan */
10443 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10444 {2427, 4}, {2432, 5}, {2437, 6},
10445 {2442, 7}, {2447, 8}, {2452, 9},
10446 {2457, 10}, {2462, 11}},
10448 .a = {{5170, 34}, {5190, 38},
10449 {5210, 42}, {5230, 46}},
10455 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10456 {2427, 4}, {2432, 5}, {2437, 6},
10457 {2442, 7}, {2447, 8}, {2452, 9},
10458 {2457, 10}, {2462, 11}},
10464 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10465 {2427, 4}, {2432, 5}, {2437, 6},
10466 {2442, 7}, {2447, 8}, {2452, 9},
10467 {2457, 10}, {2462, 11}, {2467, 12},
10474 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10475 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10476 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10477 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10478 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10479 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10480 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10481 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10482 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10483 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10484 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10485 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10486 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10487 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10488 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10491 { /* Custom Japan */
10494 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10495 {2427, 4}, {2432, 5}, {2437, 6},
10496 {2442, 7}, {2447, 8}, {2452, 9},
10497 {2457, 10}, {2462, 11}, {2467, 12},
10498 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10500 .a = {{5170, 34}, {5190, 38},
10501 {5210, 42}, {5230, 46}},
10504 { /* Rest of World */
10507 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10508 {2427, 4}, {2432, 5}, {2437, 6},
10509 {2442, 7}, {2447, 8}, {2452, 9},
10510 {2457, 10}, {2462, 11}, {2467, 12},
10511 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10512 IEEE80211_CH_PASSIVE_ONLY}},
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},
10522 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10523 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10525 .a = {{5745, 149}, {5765, 153},
10526 {5785, 157}, {5805, 161}},
10529 { /* Custom Europe */
10532 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10533 {2427, 4}, {2432, 5}, {2437, 6},
10534 {2442, 7}, {2447, 8}, {2452, 9},
10535 {2457, 10}, {2462, 11},
10536 {2467, 12}, {2472, 13}},
10538 .a = {{5180, 36}, {5200, 40},
10539 {5220, 44}, {5240, 48}},
10545 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10546 {2427, 4}, {2432, 5}, {2437, 6},
10547 {2442, 7}, {2447, 8}, {2452, 9},
10548 {2457, 10}, {2462, 11},
10549 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10550 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10552 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10553 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10554 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10555 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10556 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10557 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10558 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10559 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10560 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10561 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10562 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10563 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10564 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10565 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10566 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10567 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10568 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10569 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10570 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10571 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10572 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10573 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10574 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10575 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10581 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10582 {2427, 4}, {2432, 5}, {2437, 6},
10583 {2442, 7}, {2447, 8}, {2452, 9},
10584 {2457, 10}, {2462, 11}},
10586 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10587 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10588 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10589 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10590 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10591 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10592 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10593 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10594 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10595 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10596 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10597 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10598 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10602 /* GEO code borrowed from ieee80211_geo.c */
10603 static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
10607 /* Driver needs to initialize the geography map before using
10608 * these helper functions */
10609 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10611 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10612 for (i = 0; i < ieee->geo.bg_channels; i++)
10613 /* NOTE: If G mode is currently supported but
10614 * this is a B only channel, we don't see it
10616 if ((ieee->geo.bg[i].channel == channel) &&
10617 (!(ieee->mode & IEEE_G) ||
10618 !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
10619 return IEEE80211_24GHZ_BAND;
10621 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10622 for (i = 0; i < ieee->geo.a_channels; i++)
10623 if (ieee->geo.a[i].channel == channel)
10624 return IEEE80211_52GHZ_BAND;
10629 static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
10633 /* Driver needs to initialize the geography map before using
10634 * these helper functions */
10635 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10637 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10638 for (i = 0; i < ieee->geo.bg_channels; i++)
10639 if (ieee->geo.bg[i].channel == channel)
10642 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10643 for (i = 0; i < ieee->geo.a_channels; i++)
10644 if (ieee->geo.a[i].channel == channel)
10650 static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
10654 /* Driver needs to initialize the geography map before using
10655 * these helper functions */
10656 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10660 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10661 for (i = 0; i < ieee->geo.bg_channels; i++)
10662 if (ieee->geo.bg[i].freq == freq)
10663 return ieee->geo.bg[i].channel;
10665 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10666 for (i = 0; i < ieee->geo.a_channels; i++)
10667 if (ieee->geo.a[i].freq == freq)
10668 return ieee->geo.a[i].channel;
10673 static int ipw_set_geo(struct ieee80211_device *ieee,
10674 const struct ieee80211_geo *geo)
10676 memcpy(ieee->geo.name, geo->name, 3);
10677 ieee->geo.name[3] = '\0';
10678 ieee->geo.bg_channels = geo->bg_channels;
10679 ieee->geo.a_channels = geo->a_channels;
10680 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
10681 sizeof(struct ieee80211_channel));
10682 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
10683 sizeof(struct ieee80211_channel));
10687 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
10692 #define MAX_HW_RESTARTS 5
10693 static int ipw_up(struct ipw_priv *priv)
10697 if (priv->status & STATUS_EXIT_PENDING)
10700 if (cmdlog && !priv->cmdlog) {
10701 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10703 if (priv->cmdlog == NULL) {
10704 IPW_ERROR("Error allocating %d command log entries.\n",
10707 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10708 priv->cmdlog_len = cmdlog;
10712 for (i = 0; i < MAX_HW_RESTARTS; i++) {
10713 /* Load the microcode, firmware, and eeprom.
10714 * Also start the clocks. */
10715 rc = ipw_load(priv);
10717 IPW_ERROR("Unable to load firmware: %d\n", rc);
10721 ipw_init_ordinals(priv);
10722 if (!(priv->config & CFG_CUSTOM_MAC))
10723 eeprom_parse_mac(priv, priv->mac_addr);
10724 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10726 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10727 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10728 ipw_geos[j].name, 3))
10731 if (j == ARRAY_SIZE(ipw_geos)) {
10732 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10733 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10734 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10735 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10738 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
10739 IPW_WARNING("Could not set geography.");
10743 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
10744 j, priv->ieee->geo.name);
10746 if (priv->status & STATUS_RF_KILL_SW) {
10747 IPW_WARNING("Radio disabled by module parameter.\n");
10749 } else if (rf_kill_active(priv)) {
10750 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10751 "Kill switch must be turned off for "
10752 "wireless networking to work.\n");
10753 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10758 rc = ipw_config(priv);
10760 IPW_DEBUG_INFO("Configured device on count %i\n", i);
10762 /* If configure to try and auto-associate, kick
10764 queue_work(priv->workqueue, &priv->request_scan);
10769 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10770 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10771 i, MAX_HW_RESTARTS);
10773 /* We had an error bringing up the hardware, so take it
10774 * all the way back down so we can try again */
10778 /* tried to restart and config the device for as long as our
10779 * patience could withstand */
10780 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10785 static void ipw_bg_up(void *data)
10787 struct ipw_priv *priv = data;
10793 static void ipw_deinit(struct ipw_priv *priv)
10797 if (priv->status & STATUS_SCANNING) {
10798 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10799 ipw_abort_scan(priv);
10802 if (priv->status & STATUS_ASSOCIATED) {
10803 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10804 ipw_disassociate(priv);
10807 ipw_led_shutdown(priv);
10809 /* Wait up to 1s for status to change to not scanning and not
10810 * associated (disassociation can take a while for a ful 802.11
10812 for (i = 1000; i && (priv->status &
10813 (STATUS_DISASSOCIATING |
10814 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10817 if (priv->status & (STATUS_DISASSOCIATING |
10818 STATUS_ASSOCIATED | STATUS_SCANNING))
10819 IPW_DEBUG_INFO("Still associated or scanning...\n");
10821 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10823 /* Attempt to disable the card */
10824 ipw_send_card_disable(priv, 0);
10826 priv->status &= ~STATUS_INIT;
10829 static void ipw_down(struct ipw_priv *priv)
10831 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10833 priv->status |= STATUS_EXIT_PENDING;
10835 if (ipw_is_init(priv))
10838 /* Wipe out the EXIT_PENDING status bit if we are not actually
10839 * exiting the module */
10841 priv->status &= ~STATUS_EXIT_PENDING;
10843 /* tell the device to stop sending interrupts */
10844 ipw_disable_interrupts(priv);
10846 /* Clear all bits but the RF Kill */
10847 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10848 netif_carrier_off(priv->net_dev);
10849 netif_stop_queue(priv->net_dev);
10851 ipw_stop_nic(priv);
10853 ipw_led_radio_off(priv);
10856 static void ipw_bg_down(void *data)
10858 struct ipw_priv *priv = data;
10864 /* Called by register_netdev() */
10865 static int ipw_net_init(struct net_device *dev)
10867 struct ipw_priv *priv = ieee80211_priv(dev);
10870 if (ipw_up(priv)) {
10879 /* PCI driver stuff */
10880 static struct pci_device_id card_ids[] = {
10881 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10882 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10883 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10884 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10885 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10886 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10887 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10888 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10889 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10890 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10891 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10892 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10893 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10894 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10895 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10896 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10897 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10898 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10899 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10900 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10901 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10902 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10904 /* required last entry */
10908 MODULE_DEVICE_TABLE(pci, card_ids);
10910 static struct attribute *ipw_sysfs_entries[] = {
10911 &dev_attr_rf_kill.attr,
10912 &dev_attr_direct_dword.attr,
10913 &dev_attr_indirect_byte.attr,
10914 &dev_attr_indirect_dword.attr,
10915 &dev_attr_mem_gpio_reg.attr,
10916 &dev_attr_command_event_reg.attr,
10917 &dev_attr_nic_type.attr,
10918 &dev_attr_status.attr,
10919 &dev_attr_cfg.attr,
10920 &dev_attr_error.attr,
10921 &dev_attr_event_log.attr,
10922 &dev_attr_cmd_log.attr,
10923 &dev_attr_eeprom_delay.attr,
10924 &dev_attr_ucode_version.attr,
10925 &dev_attr_rtc.attr,
10926 &dev_attr_scan_age.attr,
10927 &dev_attr_led.attr,
10928 &dev_attr_speed_scan.attr,
10929 &dev_attr_net_stats.attr,
10933 static struct attribute_group ipw_attribute_group = {
10934 .name = NULL, /* put in device directory */
10935 .attrs = ipw_sysfs_entries,
10938 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
10941 struct net_device *net_dev;
10942 void __iomem *base;
10944 struct ipw_priv *priv;
10947 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10948 if (net_dev == NULL) {
10953 priv = ieee80211_priv(net_dev);
10954 priv->ieee = netdev_priv(net_dev);
10956 priv->net_dev = net_dev;
10957 priv->pci_dev = pdev;
10958 #ifdef CONFIG_IPW2200_DEBUG
10959 ipw_debug_level = debug;
10961 spin_lock_init(&priv->lock);
10962 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10963 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
10965 init_MUTEX(&priv->sem);
10966 if (pci_enable_device(pdev)) {
10968 goto out_free_ieee80211;
10971 pci_set_master(pdev);
10973 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
10975 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
10977 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10978 goto out_pci_disable_device;
10981 pci_set_drvdata(pdev, priv);
10983 err = pci_request_regions(pdev, DRV_NAME);
10985 goto out_pci_disable_device;
10987 /* We disable the RETRY_TIMEOUT register (0x41) to keep
10988 * PCI Tx retries from interfering with C3 CPU state */
10989 pci_read_config_dword(pdev, 0x40, &val);
10990 if ((val & 0x0000ff00) != 0)
10991 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
10993 length = pci_resource_len(pdev, 0);
10994 priv->hw_len = length;
10996 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10999 goto out_pci_release_regions;
11002 priv->hw_base = base;
11003 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11004 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11006 err = ipw_setup_deferred_work(priv);
11008 IPW_ERROR("Unable to setup deferred work\n");
11012 ipw_sw_reset(priv, 1);
11014 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
11016 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11017 goto out_destroy_workqueue;
11020 SET_MODULE_OWNER(net_dev);
11021 SET_NETDEV_DEV(net_dev, &pdev->dev);
11025 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11026 priv->ieee->set_security = shim__set_security;
11027 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11029 #ifdef CONFIG_IPW_QOS
11030 priv->ieee->handle_probe_response = ipw_handle_beacon;
11031 priv->ieee->handle_beacon = ipw_handle_probe_response;
11032 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11033 #endif /* CONFIG_IPW_QOS */
11035 priv->ieee->perfect_rssi = -20;
11036 priv->ieee->worst_rssi = -85;
11038 net_dev->open = ipw_net_open;
11039 net_dev->stop = ipw_net_stop;
11040 net_dev->init = ipw_net_init;
11041 net_dev->get_stats = ipw_net_get_stats;
11042 net_dev->set_multicast_list = ipw_net_set_multicast_list;
11043 net_dev->set_mac_address = ipw_net_set_mac_address;
11044 priv->wireless_data.spy_data = &priv->ieee->spy_data;
11045 priv->wireless_data.ieee80211 = priv->ieee;
11046 net_dev->wireless_data = &priv->wireless_data;
11047 net_dev->wireless_handlers = &ipw_wx_handler_def;
11048 net_dev->ethtool_ops = &ipw_ethtool_ops;
11049 net_dev->irq = pdev->irq;
11050 net_dev->base_addr = (unsigned long)priv->hw_base;
11051 net_dev->mem_start = pci_resource_start(pdev, 0);
11052 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11054 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11056 IPW_ERROR("failed to create sysfs device attributes\n");
11058 goto out_release_irq;
11062 err = register_netdev(net_dev);
11064 IPW_ERROR("failed to register network device\n");
11065 goto out_remove_sysfs;
11070 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11072 free_irq(pdev->irq, priv);
11073 out_destroy_workqueue:
11074 destroy_workqueue(priv->workqueue);
11075 priv->workqueue = NULL;
11077 iounmap(priv->hw_base);
11078 out_pci_release_regions:
11079 pci_release_regions(pdev);
11080 out_pci_disable_device:
11081 pci_disable_device(pdev);
11082 pci_set_drvdata(pdev, NULL);
11083 out_free_ieee80211:
11084 free_ieee80211(priv->net_dev);
11089 static void ipw_pci_remove(struct pci_dev *pdev)
11091 struct ipw_priv *priv = pci_get_drvdata(pdev);
11092 struct list_head *p, *q;
11100 priv->status |= STATUS_EXIT_PENDING;
11102 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11106 unregister_netdev(priv->net_dev);
11109 ipw_rx_queue_free(priv, priv->rxq);
11112 ipw_tx_queue_free(priv);
11114 if (priv->cmdlog) {
11115 kfree(priv->cmdlog);
11116 priv->cmdlog = NULL;
11118 /* ipw_down will ensure that there is no more pending work
11119 * in the workqueue's, so we can safely remove them now. */
11120 cancel_delayed_work(&priv->adhoc_check);
11121 cancel_delayed_work(&priv->gather_stats);
11122 cancel_delayed_work(&priv->request_scan);
11123 cancel_delayed_work(&priv->rf_kill);
11124 cancel_delayed_work(&priv->scan_check);
11125 destroy_workqueue(priv->workqueue);
11126 priv->workqueue = NULL;
11128 /* Free MAC hash list for ADHOC */
11129 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11130 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11131 kfree(list_entry(p, struct ipw_ibss_seq, list));
11137 ipw_free_error_log(priv->error);
11138 priv->error = NULL;
11141 free_irq(pdev->irq, priv);
11142 iounmap(priv->hw_base);
11143 pci_release_regions(pdev);
11144 pci_disable_device(pdev);
11145 pci_set_drvdata(pdev, NULL);
11146 free_ieee80211(priv->net_dev);
11151 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11153 struct ipw_priv *priv = pci_get_drvdata(pdev);
11154 struct net_device *dev = priv->net_dev;
11156 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11158 /* Take down the device; powers it off, etc. */
11161 /* Remove the PRESENT state of the device */
11162 netif_device_detach(dev);
11164 pci_save_state(pdev);
11165 pci_disable_device(pdev);
11166 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11171 static int ipw_pci_resume(struct pci_dev *pdev)
11173 struct ipw_priv *priv = pci_get_drvdata(pdev);
11174 struct net_device *dev = priv->net_dev;
11177 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11179 pci_set_power_state(pdev, PCI_D0);
11180 pci_enable_device(pdev);
11181 pci_restore_state(pdev);
11184 * Suspend/Resume resets the PCI configuration space, so we have to
11185 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11186 * from interfering with C3 CPU state. pci_restore_state won't help
11187 * here since it only restores the first 64 bytes pci config header.
11189 pci_read_config_dword(pdev, 0x40, &val);
11190 if ((val & 0x0000ff00) != 0)
11191 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11193 /* Set the device back into the PRESENT state; this will also wake
11194 * the queue of needed */
11195 netif_device_attach(dev);
11197 /* Bring the device back up */
11198 queue_work(priv->workqueue, &priv->up);
11204 /* driver initialization stuff */
11205 static struct pci_driver ipw_driver = {
11207 .id_table = card_ids,
11208 .probe = ipw_pci_probe,
11209 .remove = __devexit_p(ipw_pci_remove),
11211 .suspend = ipw_pci_suspend,
11212 .resume = ipw_pci_resume,
11216 static int __init ipw_init(void)
11220 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11221 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11223 ret = pci_module_init(&ipw_driver);
11225 IPW_ERROR("Unable to initialize PCI module\n");
11229 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11231 IPW_ERROR("Unable to create driver sysfs file\n");
11232 pci_unregister_driver(&ipw_driver);
11239 static void __exit ipw_exit(void)
11241 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11242 pci_unregister_driver(&ipw_driver);
11245 module_param(disable, int, 0444);
11246 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11248 module_param(associate, int, 0444);
11249 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11251 module_param(auto_create, int, 0444);
11252 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11254 module_param(led, int, 0444);
11255 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11257 module_param(debug, int, 0444);
11258 MODULE_PARM_DESC(debug, "debug output mask");
11260 module_param(channel, int, 0444);
11261 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11263 #ifdef CONFIG_IPW_QOS
11264 module_param(qos_enable, int, 0444);
11265 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11267 module_param(qos_burst_enable, int, 0444);
11268 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11270 module_param(qos_no_ack_mask, int, 0444);
11271 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11273 module_param(burst_duration_CCK, int, 0444);
11274 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11276 module_param(burst_duration_OFDM, int, 0444);
11277 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11278 #endif /* CONFIG_IPW_QOS */
11280 #ifdef CONFIG_IPW2200_MONITOR
11281 module_param(mode, int, 0444);
11282 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11284 module_param(mode, int, 0444);
11285 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11288 module_param(hwcrypto, int, 0444);
11289 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11291 module_param(cmdlog, int, 0444);
11292 MODULE_PARM_DESC(cmdlog,
11293 "allocate a ring buffer for logging firmware commands");
11295 module_exit(ipw_exit);
11296 module_init(ipw_init);