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_IPW_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 +
1114 (sizeof(*error->elem) * elem_len));
1116 ipw_capture_event_log(priv, log_len, error->log);
1119 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1120 sizeof(*error->elem) * elem_len);
1125 static void ipw_free_error_log(struct ipw_fw_error *error)
1131 static ssize_t show_event_log(struct device *d,
1132 struct device_attribute *attr, char *buf)
1134 struct ipw_priv *priv = dev_get_drvdata(d);
1135 u32 log_len = ipw_get_event_log_len(priv);
1136 struct ipw_event log[log_len];
1139 ipw_capture_event_log(priv, log_len, log);
1141 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1142 for (i = 0; i < log_len; i++)
1143 len += snprintf(buf + len, PAGE_SIZE - len,
1145 log[i].time, log[i].event, log[i].data);
1146 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1150 static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
1152 static ssize_t show_error(struct device *d,
1153 struct device_attribute *attr, char *buf)
1155 struct ipw_priv *priv = dev_get_drvdata(d);
1159 len += snprintf(buf + len, PAGE_SIZE - len,
1160 "%08lX%08X%08X%08X",
1161 priv->error->jiffies,
1162 priv->error->status,
1163 priv->error->config, priv->error->elem_len);
1164 for (i = 0; i < priv->error->elem_len; i++)
1165 len += snprintf(buf + len, PAGE_SIZE - len,
1166 "\n%08X%08X%08X%08X%08X%08X%08X",
1167 priv->error->elem[i].time,
1168 priv->error->elem[i].desc,
1169 priv->error->elem[i].blink1,
1170 priv->error->elem[i].blink2,
1171 priv->error->elem[i].link1,
1172 priv->error->elem[i].link2,
1173 priv->error->elem[i].data);
1175 len += snprintf(buf + len, PAGE_SIZE - len,
1176 "\n%08X", priv->error->log_len);
1177 for (i = 0; i < priv->error->log_len; i++)
1178 len += snprintf(buf + len, PAGE_SIZE - len,
1180 priv->error->log[i].time,
1181 priv->error->log[i].event,
1182 priv->error->log[i].data);
1183 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1187 static ssize_t clear_error(struct device *d,
1188 struct device_attribute *attr,
1189 const char *buf, size_t count)
1191 struct ipw_priv *priv = dev_get_drvdata(d);
1193 ipw_free_error_log(priv->error);
1199 static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
1201 static ssize_t show_cmd_log(struct device *d,
1202 struct device_attribute *attr, char *buf)
1204 struct ipw_priv *priv = dev_get_drvdata(d);
1208 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1209 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1210 i = (i + 1) % priv->cmdlog_len) {
1212 snprintf(buf + len, PAGE_SIZE - len,
1213 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1214 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1215 priv->cmdlog[i].cmd.len);
1217 snprintk_buf(buf + len, PAGE_SIZE - len,
1218 (u8 *) priv->cmdlog[i].cmd.param,
1219 priv->cmdlog[i].cmd.len);
1220 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1222 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1226 static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
1228 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1231 struct ipw_priv *priv = dev_get_drvdata(d);
1232 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1235 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1236 const char *buf, size_t count)
1238 struct ipw_priv *priv = dev_get_drvdata(d);
1239 #ifdef CONFIG_IPW_DEBUG
1240 struct net_device *dev = priv->net_dev;
1242 char buffer[] = "00000000";
1244 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1248 IPW_DEBUG_INFO("enter\n");
1250 strncpy(buffer, buf, len);
1253 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1255 if (p[0] == 'x' || p[0] == 'X')
1257 val = simple_strtoul(p, &p, 16);
1259 val = simple_strtoul(p, &p, 10);
1261 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1263 priv->ieee->scan_age = val;
1264 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1267 IPW_DEBUG_INFO("exit\n");
1271 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1273 static ssize_t show_led(struct device *d, struct device_attribute *attr,
1276 struct ipw_priv *priv = dev_get_drvdata(d);
1277 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1280 static ssize_t store_led(struct device *d, struct device_attribute *attr,
1281 const char *buf, size_t count)
1283 struct ipw_priv *priv = dev_get_drvdata(d);
1285 IPW_DEBUG_INFO("enter\n");
1291 IPW_DEBUG_LED("Disabling LED control.\n");
1292 priv->config |= CFG_NO_LED;
1293 ipw_led_shutdown(priv);
1295 IPW_DEBUG_LED("Enabling LED control.\n");
1296 priv->config &= ~CFG_NO_LED;
1300 IPW_DEBUG_INFO("exit\n");
1304 static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1306 static ssize_t show_status(struct device *d,
1307 struct device_attribute *attr, char *buf)
1309 struct ipw_priv *p = d->driver_data;
1310 return sprintf(buf, "0x%08x\n", (int)p->status);
1313 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1315 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1318 struct ipw_priv *p = d->driver_data;
1319 return sprintf(buf, "0x%08x\n", (int)p->config);
1322 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1324 static ssize_t show_nic_type(struct device *d,
1325 struct device_attribute *attr, char *buf)
1327 struct ipw_priv *priv = d->driver_data;
1328 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1331 static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1333 static ssize_t show_ucode_version(struct device *d,
1334 struct device_attribute *attr, char *buf)
1336 u32 len = sizeof(u32), tmp = 0;
1337 struct ipw_priv *p = d->driver_data;
1339 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
1342 return sprintf(buf, "0x%08x\n", tmp);
1345 static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
1347 static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1350 u32 len = sizeof(u32), tmp = 0;
1351 struct ipw_priv *p = d->driver_data;
1353 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
1356 return sprintf(buf, "0x%08x\n", tmp);
1359 static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
1362 * Add a device attribute to view/control the delay between eeprom
1365 static ssize_t show_eeprom_delay(struct device *d,
1366 struct device_attribute *attr, char *buf)
1368 int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
1369 return sprintf(buf, "%i\n", n);
1371 static ssize_t store_eeprom_delay(struct device *d,
1372 struct device_attribute *attr,
1373 const char *buf, size_t count)
1375 struct ipw_priv *p = d->driver_data;
1376 sscanf(buf, "%i", &p->eeprom_delay);
1377 return strnlen(buf, count);
1380 static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1381 show_eeprom_delay, store_eeprom_delay);
1383 static ssize_t show_command_event_reg(struct device *d,
1384 struct device_attribute *attr, char *buf)
1387 struct ipw_priv *p = d->driver_data;
1389 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
1390 return sprintf(buf, "0x%08x\n", reg);
1392 static ssize_t store_command_event_reg(struct device *d,
1393 struct device_attribute *attr,
1394 const char *buf, size_t count)
1397 struct ipw_priv *p = d->driver_data;
1399 sscanf(buf, "%x", ®);
1400 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
1401 return strnlen(buf, count);
1404 static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1405 show_command_event_reg, store_command_event_reg);
1407 static ssize_t show_mem_gpio_reg(struct device *d,
1408 struct device_attribute *attr, char *buf)
1411 struct ipw_priv *p = d->driver_data;
1413 reg = ipw_read_reg32(p, 0x301100);
1414 return sprintf(buf, "0x%08x\n", reg);
1416 static ssize_t store_mem_gpio_reg(struct device *d,
1417 struct device_attribute *attr,
1418 const char *buf, size_t count)
1421 struct ipw_priv *p = d->driver_data;
1423 sscanf(buf, "%x", ®);
1424 ipw_write_reg32(p, 0x301100, reg);
1425 return strnlen(buf, count);
1428 static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1429 show_mem_gpio_reg, store_mem_gpio_reg);
1431 static ssize_t show_indirect_dword(struct device *d,
1432 struct device_attribute *attr, char *buf)
1435 struct ipw_priv *priv = d->driver_data;
1437 if (priv->status & STATUS_INDIRECT_DWORD)
1438 reg = ipw_read_reg32(priv, priv->indirect_dword);
1442 return sprintf(buf, "0x%08x\n", reg);
1444 static ssize_t store_indirect_dword(struct device *d,
1445 struct device_attribute *attr,
1446 const char *buf, size_t count)
1448 struct ipw_priv *priv = d->driver_data;
1450 sscanf(buf, "%x", &priv->indirect_dword);
1451 priv->status |= STATUS_INDIRECT_DWORD;
1452 return strnlen(buf, count);
1455 static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1456 show_indirect_dword, store_indirect_dword);
1458 static ssize_t show_indirect_byte(struct device *d,
1459 struct device_attribute *attr, char *buf)
1462 struct ipw_priv *priv = d->driver_data;
1464 if (priv->status & STATUS_INDIRECT_BYTE)
1465 reg = ipw_read_reg8(priv, priv->indirect_byte);
1469 return sprintf(buf, "0x%02x\n", reg);
1471 static ssize_t store_indirect_byte(struct device *d,
1472 struct device_attribute *attr,
1473 const char *buf, size_t count)
1475 struct ipw_priv *priv = d->driver_data;
1477 sscanf(buf, "%x", &priv->indirect_byte);
1478 priv->status |= STATUS_INDIRECT_BYTE;
1479 return strnlen(buf, count);
1482 static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
1483 show_indirect_byte, store_indirect_byte);
1485 static ssize_t show_direct_dword(struct device *d,
1486 struct device_attribute *attr, char *buf)
1489 struct ipw_priv *priv = d->driver_data;
1491 if (priv->status & STATUS_DIRECT_DWORD)
1492 reg = ipw_read32(priv, priv->direct_dword);
1496 return sprintf(buf, "0x%08x\n", reg);
1498 static ssize_t store_direct_dword(struct device *d,
1499 struct device_attribute *attr,
1500 const char *buf, size_t count)
1502 struct ipw_priv *priv = d->driver_data;
1504 sscanf(buf, "%x", &priv->direct_dword);
1505 priv->status |= STATUS_DIRECT_DWORD;
1506 return strnlen(buf, count);
1509 static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1510 show_direct_dword, store_direct_dword);
1512 static inline int rf_kill_active(struct ipw_priv *priv)
1514 if (0 == (ipw_read32(priv, 0x30) & 0x10000))
1515 priv->status |= STATUS_RF_KILL_HW;
1517 priv->status &= ~STATUS_RF_KILL_HW;
1519 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1522 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
1525 /* 0 - RF kill not enabled
1526 1 - SW based RF kill active (sysfs)
1527 2 - HW based RF kill active
1528 3 - Both HW and SW baed RF kill active */
1529 struct ipw_priv *priv = d->driver_data;
1530 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1531 (rf_kill_active(priv) ? 0x2 : 0x0);
1532 return sprintf(buf, "%i\n", val);
1535 static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1537 if ((disable_radio ? 1 : 0) ==
1538 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1541 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1542 disable_radio ? "OFF" : "ON");
1544 if (disable_radio) {
1545 priv->status |= STATUS_RF_KILL_SW;
1547 if (priv->workqueue)
1548 cancel_delayed_work(&priv->request_scan);
1549 queue_work(priv->workqueue, &priv->down);
1551 priv->status &= ~STATUS_RF_KILL_SW;
1552 if (rf_kill_active(priv)) {
1553 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1554 "disabled by HW switch\n");
1555 /* Make sure the RF_KILL check timer is running */
1556 cancel_delayed_work(&priv->rf_kill);
1557 queue_delayed_work(priv->workqueue, &priv->rf_kill,
1560 queue_work(priv->workqueue, &priv->up);
1566 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1567 const char *buf, size_t count)
1569 struct ipw_priv *priv = d->driver_data;
1571 ipw_radio_kill_sw(priv, buf[0] == '1');
1576 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
1578 static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1581 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1582 int pos = 0, len = 0;
1583 if (priv->config & CFG_SPEED_SCAN) {
1584 while (priv->speed_scan[pos] != 0)
1585 len += sprintf(&buf[len], "%d ",
1586 priv->speed_scan[pos++]);
1587 return len + sprintf(&buf[len], "\n");
1590 return sprintf(buf, "0\n");
1593 static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1594 const char *buf, size_t count)
1596 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1597 int channel, pos = 0;
1598 const char *p = buf;
1600 /* list of space separated channels to scan, optionally ending with 0 */
1601 while ((channel = simple_strtol(p, NULL, 0))) {
1602 if (pos == MAX_SPEED_SCAN - 1) {
1603 priv->speed_scan[pos] = 0;
1607 if (ipw_is_valid_channel(priv->ieee, channel))
1608 priv->speed_scan[pos++] = channel;
1610 IPW_WARNING("Skipping invalid channel request: %d\n",
1615 while (*p == ' ' || *p == '\t')
1620 priv->config &= ~CFG_SPEED_SCAN;
1622 priv->speed_scan_pos = 0;
1623 priv->config |= CFG_SPEED_SCAN;
1629 static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1632 static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1635 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1636 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1639 static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1640 const char *buf, size_t count)
1642 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1644 priv->config |= CFG_NET_STATS;
1646 priv->config &= ~CFG_NET_STATS;
1651 static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1652 show_net_stats, store_net_stats);
1654 static void notify_wx_assoc_event(struct ipw_priv *priv)
1656 union iwreq_data wrqu;
1657 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1658 if (priv->status & STATUS_ASSOCIATED)
1659 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1661 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1662 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1665 static void ipw_irq_tasklet(struct ipw_priv *priv)
1667 u32 inta, inta_mask, handled = 0;
1668 unsigned long flags;
1671 spin_lock_irqsave(&priv->lock, flags);
1673 inta = ipw_read32(priv, IPW_INTA_RW);
1674 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1675 inta &= (IPW_INTA_MASK_ALL & inta_mask);
1677 /* Add any cached INTA values that need to be handled */
1678 inta |= priv->isr_inta;
1680 /* handle all the justifications for the interrupt */
1681 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1683 handled |= IPW_INTA_BIT_RX_TRANSFER;
1686 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1687 IPW_DEBUG_HC("Command completed.\n");
1688 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1689 priv->status &= ~STATUS_HCMD_ACTIVE;
1690 wake_up_interruptible(&priv->wait_command_queue);
1691 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1694 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
1695 IPW_DEBUG_TX("TX_QUEUE_1\n");
1696 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1697 handled |= IPW_INTA_BIT_TX_QUEUE_1;
1700 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
1701 IPW_DEBUG_TX("TX_QUEUE_2\n");
1702 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1703 handled |= IPW_INTA_BIT_TX_QUEUE_2;
1706 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
1707 IPW_DEBUG_TX("TX_QUEUE_3\n");
1708 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1709 handled |= IPW_INTA_BIT_TX_QUEUE_3;
1712 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
1713 IPW_DEBUG_TX("TX_QUEUE_4\n");
1714 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
1715 handled |= IPW_INTA_BIT_TX_QUEUE_4;
1718 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
1719 IPW_WARNING("STATUS_CHANGE\n");
1720 handled |= IPW_INTA_BIT_STATUS_CHANGE;
1723 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
1724 IPW_WARNING("TX_PERIOD_EXPIRED\n");
1725 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
1728 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
1729 IPW_WARNING("HOST_CMD_DONE\n");
1730 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
1733 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
1734 IPW_WARNING("FW_INITIALIZATION_DONE\n");
1735 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
1738 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
1739 IPW_WARNING("PHY_OFF_DONE\n");
1740 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
1743 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
1744 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1745 priv->status |= STATUS_RF_KILL_HW;
1746 wake_up_interruptible(&priv->wait_command_queue);
1747 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1748 cancel_delayed_work(&priv->request_scan);
1749 schedule_work(&priv->link_down);
1750 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
1751 handled |= IPW_INTA_BIT_RF_KILL_DONE;
1754 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1755 IPW_ERROR("Firmware error detected. Restarting.\n");
1757 IPW_ERROR("Sysfs 'error' log already exists.\n");
1758 #ifdef CONFIG_IPW_DEBUG
1759 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1760 struct ipw_fw_error *error =
1761 ipw_alloc_error_log(priv);
1762 ipw_dump_error_log(priv, error);
1764 ipw_free_error_log(error);
1768 priv->error = ipw_alloc_error_log(priv);
1770 IPW_ERROR("Sysfs 'error' log captured.\n");
1772 IPW_ERROR("Error allocating sysfs 'error' "
1774 #ifdef CONFIG_IPW_DEBUG
1775 if (ipw_debug_level & IPW_DL_FW_ERRORS)
1776 ipw_dump_error_log(priv, priv->error);
1780 /* XXX: If hardware encryption is for WPA/WPA2,
1781 * we have to notify the supplicant. */
1782 if (priv->ieee->sec.encrypt) {
1783 priv->status &= ~STATUS_ASSOCIATED;
1784 notify_wx_assoc_event(priv);
1787 /* Keep the restart process from trying to send host
1788 * commands by clearing the INIT status bit */
1789 priv->status &= ~STATUS_INIT;
1791 /* Cancel currently queued command. */
1792 priv->status &= ~STATUS_HCMD_ACTIVE;
1793 wake_up_interruptible(&priv->wait_command_queue);
1795 queue_work(priv->workqueue, &priv->adapter_restart);
1796 handled |= IPW_INTA_BIT_FATAL_ERROR;
1799 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
1800 IPW_ERROR("Parity error\n");
1801 handled |= IPW_INTA_BIT_PARITY_ERROR;
1804 if (handled != inta) {
1805 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
1808 /* enable all interrupts */
1809 ipw_enable_interrupts(priv);
1811 spin_unlock_irqrestore(&priv->lock, flags);
1814 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1815 static char *get_cmd_string(u8 cmd)
1818 IPW_CMD(HOST_COMPLETE);
1819 IPW_CMD(POWER_DOWN);
1820 IPW_CMD(SYSTEM_CONFIG);
1821 IPW_CMD(MULTICAST_ADDRESS);
1823 IPW_CMD(ADAPTER_ADDRESS);
1825 IPW_CMD(RTS_THRESHOLD);
1826 IPW_CMD(FRAG_THRESHOLD);
1827 IPW_CMD(POWER_MODE);
1829 IPW_CMD(TGI_TX_KEY);
1830 IPW_CMD(SCAN_REQUEST);
1831 IPW_CMD(SCAN_REQUEST_EXT);
1833 IPW_CMD(SUPPORTED_RATES);
1834 IPW_CMD(SCAN_ABORT);
1836 IPW_CMD(QOS_PARAMETERS);
1837 IPW_CMD(DINO_CONFIG);
1838 IPW_CMD(RSN_CAPABILITIES);
1840 IPW_CMD(CARD_DISABLE);
1841 IPW_CMD(SEED_NUMBER);
1843 IPW_CMD(COUNTRY_INFO);
1844 IPW_CMD(AIRONET_INFO);
1845 IPW_CMD(AP_TX_POWER);
1847 IPW_CMD(CCX_VER_INFO);
1848 IPW_CMD(SET_CALIBRATION);
1849 IPW_CMD(SENSITIVITY_CALIB);
1850 IPW_CMD(RETRY_LIMIT);
1851 IPW_CMD(IPW_PRE_POWER_DOWN);
1852 IPW_CMD(VAP_BEACON_TEMPLATE);
1853 IPW_CMD(VAP_DTIM_PERIOD);
1854 IPW_CMD(EXT_SUPPORTED_RATES);
1855 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1856 IPW_CMD(VAP_QUIET_INTERVALS);
1857 IPW_CMD(VAP_CHANNEL_SWITCH);
1858 IPW_CMD(VAP_MANDATORY_CHANNELS);
1859 IPW_CMD(VAP_CELL_PWR_LIMIT);
1860 IPW_CMD(VAP_CF_PARAM_SET);
1861 IPW_CMD(VAP_SET_BEACONING_STATE);
1862 IPW_CMD(MEASUREMENT);
1863 IPW_CMD(POWER_CAPABILITY);
1864 IPW_CMD(SUPPORTED_CHANNELS);
1865 IPW_CMD(TPC_REPORT);
1867 IPW_CMD(PRODUCTION_COMMAND);
1873 #define HOST_COMPLETE_TIMEOUT HZ
1874 static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
1877 unsigned long flags;
1879 spin_lock_irqsave(&priv->lock, flags);
1880 if (priv->status & STATUS_HCMD_ACTIVE) {
1881 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1882 get_cmd_string(cmd->cmd));
1883 spin_unlock_irqrestore(&priv->lock, flags);
1887 priv->status |= STATUS_HCMD_ACTIVE;
1890 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1891 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1892 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1893 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1895 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1898 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1899 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1901 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1903 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
1905 priv->status &= ~STATUS_HCMD_ACTIVE;
1906 IPW_ERROR("Failed to send %s: Reason %d\n",
1907 get_cmd_string(cmd->cmd), rc);
1908 spin_unlock_irqrestore(&priv->lock, flags);
1911 spin_unlock_irqrestore(&priv->lock, flags);
1913 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1915 status & STATUS_HCMD_ACTIVE),
1916 HOST_COMPLETE_TIMEOUT);
1918 spin_lock_irqsave(&priv->lock, flags);
1919 if (priv->status & STATUS_HCMD_ACTIVE) {
1920 IPW_ERROR("Failed to send %s: Command timed out.\n",
1921 get_cmd_string(cmd->cmd));
1922 priv->status &= ~STATUS_HCMD_ACTIVE;
1923 spin_unlock_irqrestore(&priv->lock, flags);
1927 spin_unlock_irqrestore(&priv->lock, flags);
1931 if (priv->status & STATUS_RF_KILL_HW) {
1932 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1933 get_cmd_string(cmd->cmd));
1940 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1941 priv->cmdlog_pos %= priv->cmdlog_len;
1946 static int ipw_send_host_complete(struct ipw_priv *priv)
1948 struct host_cmd cmd = {
1949 .cmd = IPW_CMD_HOST_COMPLETE,
1954 IPW_ERROR("Invalid args\n");
1958 return ipw_send_cmd(priv, &cmd);
1961 static int ipw_send_system_config(struct ipw_priv *priv,
1962 struct ipw_sys_config *config)
1964 struct host_cmd cmd = {
1965 .cmd = IPW_CMD_SYSTEM_CONFIG,
1966 .len = sizeof(*config)
1969 if (!priv || !config) {
1970 IPW_ERROR("Invalid args\n");
1974 memcpy(cmd.param, config, sizeof(*config));
1975 return ipw_send_cmd(priv, &cmd);
1978 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
1980 struct host_cmd cmd = {
1981 .cmd = IPW_CMD_SSID,
1982 .len = min(len, IW_ESSID_MAX_SIZE)
1985 if (!priv || !ssid) {
1986 IPW_ERROR("Invalid args\n");
1990 memcpy(cmd.param, ssid, cmd.len);
1991 return ipw_send_cmd(priv, &cmd);
1994 static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
1996 struct host_cmd cmd = {
1997 .cmd = IPW_CMD_ADAPTER_ADDRESS,
2001 if (!priv || !mac) {
2002 IPW_ERROR("Invalid args\n");
2006 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2007 priv->net_dev->name, MAC_ARG(mac));
2009 memcpy(cmd.param, mac, ETH_ALEN);
2010 return ipw_send_cmd(priv, &cmd);
2014 * NOTE: This must be executed from our workqueue as it results in udelay
2015 * being called which may corrupt the keyboard if executed on default
2018 static void ipw_adapter_restart(void *adapter)
2020 struct ipw_priv *priv = adapter;
2022 if (priv->status & STATUS_RF_KILL_MASK)
2027 if (priv->assoc_network &&
2028 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2029 ipw_remove_current_network(priv);
2032 IPW_ERROR("Failed to up device\n");
2037 static void ipw_bg_adapter_restart(void *data)
2039 struct ipw_priv *priv = data;
2041 ipw_adapter_restart(data);
2045 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2047 static void ipw_scan_check(void *data)
2049 struct ipw_priv *priv = data;
2050 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2051 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2052 "adapter (%dms).\n",
2053 IPW_SCAN_CHECK_WATCHDOG / 100);
2054 queue_work(priv->workqueue, &priv->adapter_restart);
2058 static void ipw_bg_scan_check(void *data)
2060 struct ipw_priv *priv = data;
2062 ipw_scan_check(data);
2066 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2067 struct ipw_scan_request_ext *request)
2069 struct host_cmd cmd = {
2070 .cmd = IPW_CMD_SCAN_REQUEST_EXT,
2071 .len = sizeof(*request)
2074 memcpy(cmd.param, request, sizeof(*request));
2075 return ipw_send_cmd(priv, &cmd);
2078 static int ipw_send_scan_abort(struct ipw_priv *priv)
2080 struct host_cmd cmd = {
2081 .cmd = IPW_CMD_SCAN_ABORT,
2086 IPW_ERROR("Invalid args\n");
2090 return ipw_send_cmd(priv, &cmd);
2093 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2095 struct host_cmd cmd = {
2096 .cmd = IPW_CMD_SENSITIVITY_CALIB,
2097 .len = sizeof(struct ipw_sensitivity_calib)
2099 struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
2101 calib->beacon_rssi_raw = sens;
2102 return ipw_send_cmd(priv, &cmd);
2105 static int ipw_send_associate(struct ipw_priv *priv,
2106 struct ipw_associate *associate)
2108 struct host_cmd cmd = {
2109 .cmd = IPW_CMD_ASSOCIATE,
2110 .len = sizeof(*associate)
2113 struct ipw_associate tmp_associate;
2114 memcpy(&tmp_associate, associate, sizeof(*associate));
2115 tmp_associate.policy_support =
2116 cpu_to_le16(tmp_associate.policy_support);
2117 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2118 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2119 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2120 tmp_associate.listen_interval =
2121 cpu_to_le16(tmp_associate.listen_interval);
2122 tmp_associate.beacon_interval =
2123 cpu_to_le16(tmp_associate.beacon_interval);
2124 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2126 if (!priv || !associate) {
2127 IPW_ERROR("Invalid args\n");
2131 memcpy(cmd.param, &tmp_associate, sizeof(*associate));
2132 return ipw_send_cmd(priv, &cmd);
2135 static int ipw_send_supported_rates(struct ipw_priv *priv,
2136 struct ipw_supported_rates *rates)
2138 struct host_cmd cmd = {
2139 .cmd = IPW_CMD_SUPPORTED_RATES,
2140 .len = sizeof(*rates)
2143 if (!priv || !rates) {
2144 IPW_ERROR("Invalid args\n");
2148 memcpy(cmd.param, rates, sizeof(*rates));
2149 return ipw_send_cmd(priv, &cmd);
2152 static int ipw_set_random_seed(struct ipw_priv *priv)
2154 struct host_cmd cmd = {
2155 .cmd = IPW_CMD_SEED_NUMBER,
2160 IPW_ERROR("Invalid args\n");
2164 get_random_bytes(&cmd.param, sizeof(u32));
2166 return ipw_send_cmd(priv, &cmd);
2169 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2171 struct host_cmd cmd = {
2172 .cmd = IPW_CMD_CARD_DISABLE,
2177 IPW_ERROR("Invalid args\n");
2181 *((u32 *) & cmd.param) = phy_off;
2183 return ipw_send_cmd(priv, &cmd);
2186 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2188 struct host_cmd cmd = {
2189 .cmd = IPW_CMD_TX_POWER,
2190 .len = sizeof(*power)
2193 if (!priv || !power) {
2194 IPW_ERROR("Invalid args\n");
2198 memcpy(cmd.param, power, sizeof(*power));
2199 return ipw_send_cmd(priv, &cmd);
2202 static int ipw_set_tx_power(struct ipw_priv *priv)
2204 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
2205 struct ipw_tx_power tx_power;
2209 memset(&tx_power, 0, sizeof(tx_power));
2211 /* configure device for 'G' band */
2212 tx_power.ieee_mode = IPW_G_MODE;
2213 tx_power.num_channels = geo->bg_channels;
2214 for (i = 0; i < geo->bg_channels; i++) {
2215 max_power = geo->bg[i].max_power;
2216 tx_power.channels_tx_power[i].channel_number =
2218 tx_power.channels_tx_power[i].tx_power = max_power ?
2219 min(max_power, priv->tx_power) : priv->tx_power;
2221 if (ipw_send_tx_power(priv, &tx_power))
2224 /* configure device to also handle 'B' band */
2225 tx_power.ieee_mode = IPW_B_MODE;
2226 if (ipw_send_tx_power(priv, &tx_power))
2229 /* configure device to also handle 'A' band */
2230 if (priv->ieee->abg_true) {
2231 tx_power.ieee_mode = IPW_A_MODE;
2232 tx_power.num_channels = geo->a_channels;
2233 for (i = 0; i < tx_power.num_channels; i++) {
2234 max_power = geo->a[i].max_power;
2235 tx_power.channels_tx_power[i].channel_number =
2237 tx_power.channels_tx_power[i].tx_power = max_power ?
2238 min(max_power, priv->tx_power) : priv->tx_power;
2240 if (ipw_send_tx_power(priv, &tx_power))
2246 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2248 struct ipw_rts_threshold rts_threshold = {
2249 .rts_threshold = rts,
2251 struct host_cmd cmd = {
2252 .cmd = IPW_CMD_RTS_THRESHOLD,
2253 .len = sizeof(rts_threshold)
2257 IPW_ERROR("Invalid args\n");
2261 memcpy(cmd.param, &rts_threshold, sizeof(rts_threshold));
2262 return ipw_send_cmd(priv, &cmd);
2265 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2267 struct ipw_frag_threshold frag_threshold = {
2268 .frag_threshold = frag,
2270 struct host_cmd cmd = {
2271 .cmd = IPW_CMD_FRAG_THRESHOLD,
2272 .len = sizeof(frag_threshold)
2276 IPW_ERROR("Invalid args\n");
2280 memcpy(cmd.param, &frag_threshold, sizeof(frag_threshold));
2281 return ipw_send_cmd(priv, &cmd);
2284 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2286 struct host_cmd cmd = {
2287 .cmd = IPW_CMD_POWER_MODE,
2290 u32 *param = (u32 *) (&cmd.param);
2293 IPW_ERROR("Invalid args\n");
2297 /* If on battery, set to 3, if AC set to CAM, else user
2300 case IPW_POWER_BATTERY:
2301 *param = IPW_POWER_INDEX_3;
2304 *param = IPW_POWER_MODE_CAM;
2311 return ipw_send_cmd(priv, &cmd);
2314 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2316 struct ipw_retry_limit retry_limit = {
2317 .short_retry_limit = slimit,
2318 .long_retry_limit = llimit
2320 struct host_cmd cmd = {
2321 .cmd = IPW_CMD_RETRY_LIMIT,
2322 .len = sizeof(retry_limit)
2326 IPW_ERROR("Invalid args\n");
2330 memcpy(cmd.param, &retry_limit, sizeof(retry_limit));
2331 return ipw_send_cmd(priv, &cmd);
2335 * The IPW device contains a Microwire compatible EEPROM that stores
2336 * various data like the MAC address. Usually the firmware has exclusive
2337 * access to the eeprom, but during device initialization (before the
2338 * device driver has sent the HostComplete command to the firmware) the
2339 * device driver has read access to the EEPROM by way of indirect addressing
2340 * through a couple of memory mapped registers.
2342 * The following is a simplified implementation for pulling data out of the
2343 * the eeprom, along with some helper functions to find information in
2344 * the per device private data's copy of the eeprom.
2346 * NOTE: To better understand how these functions work (i.e what is a chip
2347 * select and why do have to keep driving the eeprom clock?), read
2348 * just about any data sheet for a Microwire compatible EEPROM.
2351 /* write a 32 bit value into the indirect accessor register */
2352 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2354 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2356 /* the eeprom requires some time to complete the operation */
2357 udelay(p->eeprom_delay);
2362 /* perform a chip select operation */
2363 static inline void eeprom_cs(struct ipw_priv *priv)
2365 eeprom_write_reg(priv, 0);
2366 eeprom_write_reg(priv, EEPROM_BIT_CS);
2367 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2368 eeprom_write_reg(priv, EEPROM_BIT_CS);
2371 /* perform a chip select operation */
2372 static inline void eeprom_disable_cs(struct ipw_priv *priv)
2374 eeprom_write_reg(priv, EEPROM_BIT_CS);
2375 eeprom_write_reg(priv, 0);
2376 eeprom_write_reg(priv, EEPROM_BIT_SK);
2379 /* push a single bit down to the eeprom */
2380 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2382 int d = (bit ? EEPROM_BIT_DI : 0);
2383 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2384 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2387 /* push an opcode followed by an address down to the eeprom */
2388 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2393 eeprom_write_bit(priv, 1);
2394 eeprom_write_bit(priv, op & 2);
2395 eeprom_write_bit(priv, op & 1);
2396 for (i = 7; i >= 0; i--) {
2397 eeprom_write_bit(priv, addr & (1 << i));
2401 /* pull 16 bits off the eeprom, one bit at a time */
2402 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2407 /* Send READ Opcode */
2408 eeprom_op(priv, EEPROM_CMD_READ, addr);
2410 /* Send dummy bit */
2411 eeprom_write_reg(priv, EEPROM_BIT_CS);
2413 /* Read the byte off the eeprom one bit at a time */
2414 for (i = 0; i < 16; i++) {
2416 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2417 eeprom_write_reg(priv, EEPROM_BIT_CS);
2418 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2419 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2422 /* Send another dummy bit */
2423 eeprom_write_reg(priv, 0);
2424 eeprom_disable_cs(priv);
2429 /* helper function for pulling the mac address out of the private */
2430 /* data's copy of the eeprom data */
2431 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2433 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
2437 * Either the device driver (i.e. the host) or the firmware can
2438 * load eeprom data into the designated region in SRAM. If neither
2439 * happens then the FW will shutdown with a fatal error.
2441 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2442 * bit needs region of shared SRAM needs to be non-zero.
2444 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2447 u16 *eeprom = (u16 *) priv->eeprom;
2449 IPW_DEBUG_TRACE(">>\n");
2451 /* read entire contents of eeprom into private buffer */
2452 for (i = 0; i < 128; i++)
2453 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
2456 If the data looks correct, then copy it to our private
2457 copy. Otherwise let the firmware know to perform the operation
2460 if ((priv->eeprom + EEPROM_VERSION) != 0) {
2461 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2463 /* write the eeprom data to sram */
2464 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2465 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2467 /* Do not load eeprom data on fatal error or suspend */
2468 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2470 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2472 /* Load eeprom data on fatal error or suspend */
2473 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2476 IPW_DEBUG_TRACE("<<\n");
2479 static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2484 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2486 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2489 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2491 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2492 CB_NUMBER_OF_ELEMENTS_SMALL *
2493 sizeof(struct command_block));
2496 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2497 { /* start dma engine but no transfers yet */
2499 IPW_DEBUG_FW(">> : \n");
2502 ipw_fw_dma_reset_command_blocks(priv);
2504 /* Write CB base address */
2505 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2507 IPW_DEBUG_FW("<< : \n");
2511 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2515 IPW_DEBUG_FW(">> :\n");
2517 //set the Stop and Abort bit
2518 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2519 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2520 priv->sram_desc.last_cb_index = 0;
2522 IPW_DEBUG_FW("<< \n");
2525 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2526 struct command_block *cb)
2529 IPW_SHARED_SRAM_DMA_CONTROL +
2530 (sizeof(struct command_block) * index);
2531 IPW_DEBUG_FW(">> :\n");
2533 ipw_write_indirect(priv, address, (u8 *) cb,
2534 (int)sizeof(struct command_block));
2536 IPW_DEBUG_FW("<< :\n");
2541 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2546 IPW_DEBUG_FW(">> :\n");
2548 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2549 ipw_fw_dma_write_command_block(priv, index,
2550 &priv->sram_desc.cb_list[index]);
2552 /* Enable the DMA in the CSR register */
2553 ipw_clear_bit(priv, IPW_RESET_REG,
2554 IPW_RESET_REG_MASTER_DISABLED |
2555 IPW_RESET_REG_STOP_MASTER);
2557 /* Set the Start bit. */
2558 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2559 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2561 IPW_DEBUG_FW("<< :\n");
2565 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2568 u32 register_value = 0;
2569 u32 cb_fields_address = 0;
2571 IPW_DEBUG_FW(">> :\n");
2572 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2573 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
2575 /* Read the DMA Controlor register */
2576 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2577 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
2579 /* Print the CB values */
2580 cb_fields_address = address;
2581 register_value = ipw_read_reg32(priv, cb_fields_address);
2582 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
2584 cb_fields_address += sizeof(u32);
2585 register_value = ipw_read_reg32(priv, cb_fields_address);
2586 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
2588 cb_fields_address += sizeof(u32);
2589 register_value = ipw_read_reg32(priv, cb_fields_address);
2590 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2593 cb_fields_address += sizeof(u32);
2594 register_value = ipw_read_reg32(priv, cb_fields_address);
2595 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
2597 IPW_DEBUG_FW(">> :\n");
2600 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2602 u32 current_cb_address = 0;
2603 u32 current_cb_index = 0;
2605 IPW_DEBUG_FW("<< :\n");
2606 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2608 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2609 sizeof(struct command_block);
2611 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
2612 current_cb_index, current_cb_address);
2614 IPW_DEBUG_FW(">> :\n");
2615 return current_cb_index;
2619 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2623 int interrupt_enabled, int is_last)
2626 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2627 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2629 struct command_block *cb;
2630 u32 last_cb_element = 0;
2632 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2633 src_address, dest_address, length);
2635 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2638 last_cb_element = priv->sram_desc.last_cb_index;
2639 cb = &priv->sram_desc.cb_list[last_cb_element];
2640 priv->sram_desc.last_cb_index++;
2642 /* Calculate the new CB control word */
2643 if (interrupt_enabled)
2644 control |= CB_INT_ENABLED;
2647 control |= CB_LAST_VALID;
2651 /* Calculate the CB Element's checksum value */
2652 cb->status = control ^ src_address ^ dest_address;
2654 /* Copy the Source and Destination addresses */
2655 cb->dest_addr = dest_address;
2656 cb->source_addr = src_address;
2658 /* Copy the Control Word last */
2659 cb->control = control;
2664 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
2665 u32 src_phys, u32 dest_address, u32 length)
2667 u32 bytes_left = length;
2669 u32 dest_offset = 0;
2671 IPW_DEBUG_FW(">> \n");
2672 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2673 src_phys, dest_address, length);
2674 while (bytes_left > CB_MAX_LENGTH) {
2675 status = ipw_fw_dma_add_command_block(priv,
2676 src_phys + src_offset,
2679 CB_MAX_LENGTH, 0, 0);
2681 IPW_DEBUG_FW_INFO(": Failed\n");
2684 IPW_DEBUG_FW_INFO(": Added new cb\n");
2686 src_offset += CB_MAX_LENGTH;
2687 dest_offset += CB_MAX_LENGTH;
2688 bytes_left -= CB_MAX_LENGTH;
2691 /* add the buffer tail */
2692 if (bytes_left > 0) {
2694 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2695 dest_address + dest_offset,
2698 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2702 (": Adding new cb - the buffer tail\n");
2705 IPW_DEBUG_FW("<< \n");
2709 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2711 u32 current_index = 0;
2714 IPW_DEBUG_FW(">> : \n");
2716 current_index = ipw_fw_dma_command_block_index(priv);
2717 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%8X\n",
2718 (int)priv->sram_desc.last_cb_index);
2720 while (current_index < priv->sram_desc.last_cb_index) {
2722 current_index = ipw_fw_dma_command_block_index(priv);
2726 if (watchdog > 400) {
2727 IPW_DEBUG_FW_INFO("Timeout\n");
2728 ipw_fw_dma_dump_command_block(priv);
2729 ipw_fw_dma_abort(priv);
2734 ipw_fw_dma_abort(priv);
2736 /*Disable the DMA in the CSR register */
2737 ipw_set_bit(priv, IPW_RESET_REG,
2738 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2740 IPW_DEBUG_FW("<< dmaWaitSync \n");
2744 static void ipw_remove_current_network(struct ipw_priv *priv)
2746 struct list_head *element, *safe;
2747 struct ieee80211_network *network = NULL;
2748 unsigned long flags;
2750 spin_lock_irqsave(&priv->ieee->lock, flags);
2751 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2752 network = list_entry(element, struct ieee80211_network, list);
2753 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2755 list_add_tail(&network->list,
2756 &priv->ieee->network_free_list);
2759 spin_unlock_irqrestore(&priv->ieee->lock, flags);
2763 * Check that card is still alive.
2764 * Reads debug register from domain0.
2765 * If card is present, pre-defined value should
2769 * @return 1 if card is present, 0 otherwise
2771 static inline int ipw_alive(struct ipw_priv *priv)
2773 return ipw_read32(priv, 0x90) == 0xd55555d5;
2776 static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2782 if ((ipw_read32(priv, addr) & mask) == mask)
2786 } while (i < timeout);
2791 /* These functions load the firmware and micro code for the operation of
2792 * the ipw hardware. It assumes the buffer has all the bits for the
2793 * image and the caller is handling the memory allocation and clean up.
2796 static int ipw_stop_master(struct ipw_priv *priv)
2800 IPW_DEBUG_TRACE(">> \n");
2801 /* stop master. typical delay - 0 */
2802 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2804 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2805 IPW_RESET_REG_MASTER_DISABLED, 100);
2807 IPW_ERROR("stop master failed in 10ms\n");
2811 IPW_DEBUG_INFO("stop master %dms\n", rc);
2816 static void ipw_arc_release(struct ipw_priv *priv)
2818 IPW_DEBUG_TRACE(">> \n");
2821 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2823 /* no one knows timing, for safety add some delay */
2837 #define IPW_FW_MAJOR_VERSION 2
2838 #define IPW_FW_MINOR_VERSION 4
2840 #define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2841 #define IPW_FW_MAJOR(x) (x & 0xff)
2843 #define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2845 #define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2846 "." __stringify(IPW_FW_MINOR_VERSION) "-"
2848 #if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2849 #define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2851 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2854 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2856 int rc = 0, i, addr;
2860 image = (u16 *) data;
2862 IPW_DEBUG_TRACE(">> \n");
2864 rc = ipw_stop_master(priv);
2869 // spin_lock_irqsave(&priv->lock, flags);
2871 for (addr = IPW_SHARED_LOWER_BOUND;
2872 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2873 ipw_write32(priv, addr, 0);
2876 /* no ucode (yet) */
2877 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2878 /* destroy DMA queues */
2879 /* reset sequence */
2881 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2882 ipw_arc_release(priv);
2883 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2887 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2890 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2893 /* enable ucode store */
2894 ipw_write_reg8(priv, DINO_CONTROL_REG, 0x0);
2895 ipw_write_reg8(priv, DINO_CONTROL_REG, DINO_ENABLE_CS);
2901 * Do NOT set indirect address register once and then
2902 * store data to indirect data register in the loop.
2903 * It seems very reasonable, but in this case DINO do not
2904 * accept ucode. It is essential to set address each time.
2906 /* load new ipw uCode */
2907 for (i = 0; i < len / 2; i++)
2908 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2909 cpu_to_le16(image[i]));
2912 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2913 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2915 /* this is where the igx / win driver deveates from the VAP driver. */
2917 /* wait for alive response */
2918 for (i = 0; i < 100; i++) {
2919 /* poll for incoming data */
2920 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2921 if (cr & DINO_RXFIFO_DATA)
2926 if (cr & DINO_RXFIFO_DATA) {
2927 /* alive_command_responce size is NOT multiple of 4 */
2928 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2930 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2931 response_buffer[i] =
2932 le32_to_cpu(ipw_read_reg32(priv,
2933 IPW_BASEBAND_RX_FIFO_READ));
2934 memcpy(&priv->dino_alive, response_buffer,
2935 sizeof(priv->dino_alive));
2936 if (priv->dino_alive.alive_command == 1
2937 && priv->dino_alive.ucode_valid == 1) {
2940 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2941 "of %02d/%02d/%02d %02d:%02d\n",
2942 priv->dino_alive.software_revision,
2943 priv->dino_alive.software_revision,
2944 priv->dino_alive.device_identifier,
2945 priv->dino_alive.device_identifier,
2946 priv->dino_alive.time_stamp[0],
2947 priv->dino_alive.time_stamp[1],
2948 priv->dino_alive.time_stamp[2],
2949 priv->dino_alive.time_stamp[3],
2950 priv->dino_alive.time_stamp[4]);
2952 IPW_DEBUG_INFO("Microcode is not alive\n");
2956 IPW_DEBUG_INFO("No alive response from DINO\n");
2960 /* disable DINO, otherwise for some reason
2961 firmware have problem getting alive resp. */
2962 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2964 // spin_unlock_irqrestore(&priv->lock, flags);
2969 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
2973 struct fw_chunk *chunk;
2974 dma_addr_t shared_phys;
2977 IPW_DEBUG_TRACE("<< : \n");
2978 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2983 memmove(shared_virt, data, len);
2986 rc = ipw_fw_dma_enable(priv);
2988 if (priv->sram_desc.last_cb_index > 0) {
2989 /* the DMA is already ready this would be a bug. */
2995 chunk = (struct fw_chunk *)(data + offset);
2996 offset += sizeof(struct fw_chunk);
2997 /* build DMA packet and queue up for sending */
2998 /* dma to chunk->address, the chunk->length bytes from data +
3001 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3002 le32_to_cpu(chunk->address),
3003 le32_to_cpu(chunk->length));
3005 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3009 offset += le32_to_cpu(chunk->length);
3010 } while (offset < len);
3012 /* Run the DMA and wait for the answer */
3013 rc = ipw_fw_dma_kick(priv);
3015 IPW_ERROR("dmaKick Failed\n");
3019 rc = ipw_fw_dma_wait(priv);
3021 IPW_ERROR("dmaWaitSync Failed\n");
3025 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
3030 static int ipw_stop_nic(struct ipw_priv *priv)
3035 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3037 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3038 IPW_RESET_REG_MASTER_DISABLED, 500);
3040 IPW_ERROR("wait for reg master disabled failed\n");
3044 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3049 static void ipw_start_nic(struct ipw_priv *priv)
3051 IPW_DEBUG_TRACE(">>\n");
3053 /* prvHwStartNic release ARC */
3054 ipw_clear_bit(priv, IPW_RESET_REG,
3055 IPW_RESET_REG_MASTER_DISABLED |
3056 IPW_RESET_REG_STOP_MASTER |
3057 CBD_RESET_REG_PRINCETON_RESET);
3059 /* enable power management */
3060 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3061 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3063 IPW_DEBUG_TRACE("<<\n");
3066 static int ipw_init_nic(struct ipw_priv *priv)
3070 IPW_DEBUG_TRACE(">>\n");
3073 /* set "initialization complete" bit to move adapter to D0 state */
3074 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3076 /* low-level PLL activation */
3077 ipw_write32(priv, IPW_READ_INT_REGISTER,
3078 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3080 /* wait for clock stabilization */
3081 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3082 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3084 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3086 /* assert SW reset */
3087 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3091 /* set "initialization complete" bit to move adapter to D0 state */
3092 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3094 IPW_DEBUG_TRACE(">>\n");
3098 /* Call this function from process context, it will sleep in request_firmware.
3099 * Probe is an ok place to call this from.
3101 static int ipw_reset_nic(struct ipw_priv *priv)
3104 unsigned long flags;
3106 IPW_DEBUG_TRACE(">>\n");
3108 rc = ipw_init_nic(priv);
3110 spin_lock_irqsave(&priv->lock, flags);
3111 /* Clear the 'host command active' bit... */
3112 priv->status &= ~STATUS_HCMD_ACTIVE;
3113 wake_up_interruptible(&priv->wait_command_queue);
3114 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3115 wake_up_interruptible(&priv->wait_state);
3116 spin_unlock_irqrestore(&priv->lock, flags);
3118 IPW_DEBUG_TRACE("<<\n");
3122 static int ipw_get_fw(struct ipw_priv *priv,
3123 const struct firmware **fw, const char *name)
3125 struct fw_header *header;
3128 /* ask firmware_class module to get the boot firmware off disk */
3129 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3131 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3135 header = (struct fw_header *)(*fw)->data;
3136 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
3137 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3139 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3140 IPW_FW_MAJOR_VERSION);
3144 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
3146 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3147 IPW_FW_MINOR(le32_to_cpu(header->version)),
3148 (*fw)->size - sizeof(struct fw_header));
3152 #define IPW_RX_BUF_SIZE (3000)
3154 static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
3155 struct ipw_rx_queue *rxq)
3157 unsigned long flags;
3160 spin_lock_irqsave(&rxq->lock, flags);
3162 INIT_LIST_HEAD(&rxq->rx_free);
3163 INIT_LIST_HEAD(&rxq->rx_used);
3165 /* Fill the rx_used queue with _all_ of the Rx buffers */
3166 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3167 /* In the reset function, these buffers may have been allocated
3168 * to an SKB, so we need to unmap and free potential storage */
3169 if (rxq->pool[i].skb != NULL) {
3170 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3171 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3172 dev_kfree_skb(rxq->pool[i].skb);
3173 rxq->pool[i].skb = NULL;
3175 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3178 /* Set us so that we have processed and used all buffers, but have
3179 * not restocked the Rx queue with fresh buffers */
3180 rxq->read = rxq->write = 0;
3181 rxq->processed = RX_QUEUE_SIZE - 1;
3182 rxq->free_count = 0;
3183 spin_unlock_irqrestore(&rxq->lock, flags);
3187 static int fw_loaded = 0;
3188 static const struct firmware *bootfw = NULL;
3189 static const struct firmware *firmware = NULL;
3190 static const struct firmware *ucode = NULL;
3192 static void free_firmware(void)
3195 release_firmware(bootfw);
3196 release_firmware(ucode);
3197 release_firmware(firmware);
3198 bootfw = ucode = firmware = NULL;
3203 #define free_firmware() do {} while (0)
3206 static int ipw_load(struct ipw_priv *priv)
3209 const struct firmware *bootfw = NULL;
3210 const struct firmware *firmware = NULL;
3211 const struct firmware *ucode = NULL;
3213 int rc = 0, retries = 3;
3218 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3222 switch (priv->ieee->iw_mode) {
3224 rc = ipw_get_fw(priv, &ucode,
3225 IPW_FW_NAME("ibss_ucode"));
3229 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
3232 #ifdef CONFIG_IPW2200_MONITOR
3233 case IW_MODE_MONITOR:
3234 rc = ipw_get_fw(priv, &ucode,
3235 IPW_FW_NAME("sniffer_ucode"));
3239 rc = ipw_get_fw(priv, &firmware,
3240 IPW_FW_NAME("sniffer"));
3244 rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
3248 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("bss"));
3264 priv->rxq = ipw_rx_queue_alloc(priv);
3266 ipw_rx_queue_reset(priv, priv->rxq);
3268 IPW_ERROR("Unable to initialize Rx queue\n");
3273 /* Ensure interrupts are disabled */
3274 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3275 priv->status &= ~STATUS_INT_ENABLED;
3277 /* ack pending interrupts */
3278 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3282 rc = ipw_reset_nic(priv);
3284 IPW_ERROR("Unable to reset NIC\n");
3288 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3289 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3291 /* DMA the initial boot firmware into the device */
3292 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
3293 bootfw->size - sizeof(struct fw_header));
3295 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3299 /* kick start the device */
3300 ipw_start_nic(priv);
3302 /* wait for the device to finish it's initial startup sequence */
3303 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3304 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3306 IPW_ERROR("device failed to boot initial fw image\n");
3309 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3311 /* ack fw init done interrupt */
3312 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3314 /* DMA the ucode into the device */
3315 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
3316 ucode->size - sizeof(struct fw_header));
3318 IPW_ERROR("Unable to load ucode: %d\n", rc);
3325 /* DMA bss firmware into the device */
3326 rc = ipw_load_firmware(priv, firmware->data +
3327 sizeof(struct fw_header),
3328 firmware->size - sizeof(struct fw_header));
3330 IPW_ERROR("Unable to load firmware: %d\n", rc);
3334 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3336 rc = ipw_queue_reset(priv);
3338 IPW_ERROR("Unable to initialize queues\n");
3342 /* Ensure interrupts are disabled */
3343 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3344 /* ack pending interrupts */
3345 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3347 /* kick start the device */
3348 ipw_start_nic(priv);
3350 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3352 IPW_WARNING("Parity error. Retrying init.\n");
3357 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3362 /* wait for the device */
3363 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3364 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3366 IPW_ERROR("device failed to start after 500ms\n");
3369 IPW_DEBUG_INFO("device response after %dms\n", rc);
3371 /* ack fw init done interrupt */
3372 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3374 /* read eeprom data and initialize the eeprom region of sram */
3375 priv->eeprom_delay = 1;
3376 ipw_eeprom_init_sram(priv);
3378 /* enable interrupts */
3379 ipw_enable_interrupts(priv);
3381 /* Ensure our queue has valid packets */
3382 ipw_rx_queue_replenish(priv);
3384 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3386 /* ack pending interrupts */
3387 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3390 release_firmware(bootfw);
3391 release_firmware(ucode);
3392 release_firmware(firmware);
3398 ipw_rx_queue_free(priv, priv->rxq);
3401 ipw_tx_queue_free(priv);
3403 release_firmware(bootfw);
3405 release_firmware(ucode);
3407 release_firmware(firmware);
3410 bootfw = ucode = firmware = NULL;
3419 * Theory of operation
3421 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3422 * 2 empty entries always kept in the buffer to protect from overflow.
3424 * For Tx queue, there are low mark and high mark limits. If, after queuing
3425 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3426 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3429 * The IPW operates with six queues, one receive queue in the device's
3430 * sram, one transmit queue for sending commands to the device firmware,
3431 * and four transmit queues for data.
3433 * The four transmit queues allow for performing quality of service (qos)
3434 * transmissions as per the 802.11 protocol. Currently Linux does not
3435 * provide a mechanism to the user for utilizing prioritized queues, so
3436 * we only utilize the first data transmit queue (queue1).
3440 * Driver allocates buffers of this size for Rx
3443 static inline int ipw_queue_space(const struct clx2_queue *q)
3445 int s = q->last_used - q->first_empty;
3448 s -= 2; /* keep some reserve to not confuse empty and full situations */
3454 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3456 return (++index == n_bd) ? 0 : index;
3460 * Initialize common DMA queue structure
3462 * @param q queue to init
3463 * @param count Number of BD's to allocate. Should be power of 2
3464 * @param read_register Address for 'read' register
3465 * (not offset within BAR, full address)
3466 * @param write_register Address for 'write' register
3467 * (not offset within BAR, full address)
3468 * @param base_register Address for 'base' register
3469 * (not offset within BAR, full address)
3470 * @param size Address for 'size' register
3471 * (not offset within BAR, full address)
3473 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3474 int count, u32 read, u32 write, u32 base, u32 size)
3478 q->low_mark = q->n_bd / 4;
3479 if (q->low_mark < 4)
3482 q->high_mark = q->n_bd / 8;
3483 if (q->high_mark < 2)
3486 q->first_empty = q->last_used = 0;
3490 ipw_write32(priv, base, q->dma_addr);
3491 ipw_write32(priv, size, count);
3492 ipw_write32(priv, read, 0);
3493 ipw_write32(priv, write, 0);
3495 _ipw_read32(priv, 0x90);
3498 static int ipw_queue_tx_init(struct ipw_priv *priv,
3499 struct clx2_tx_queue *q,
3500 int count, u32 read, u32 write, u32 base, u32 size)
3502 struct pci_dev *dev = priv->pci_dev;
3504 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3506 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3511 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3513 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3514 sizeof(q->bd[0]) * count);
3520 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3525 * Free one TFD, those at index [txq->q.last_used].
3526 * Do NOT advance any indexes
3531 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3532 struct clx2_tx_queue *txq)
3534 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3535 struct pci_dev *dev = priv->pci_dev;
3539 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3540 /* nothing to cleanup after for host commands */
3544 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3545 IPW_ERROR("Too many chunks: %i\n",
3546 le32_to_cpu(bd->u.data.num_chunks));
3547 /** @todo issue fatal error, it is quite serious situation */
3551 /* unmap chunks if any */
3552 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3553 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3554 le16_to_cpu(bd->u.data.chunk_len[i]),
3556 if (txq->txb[txq->q.last_used]) {
3557 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3558 txq->txb[txq->q.last_used] = NULL;
3564 * Deallocate DMA queue.
3566 * Empty queue by removing and destroying all BD's.
3572 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3574 struct clx2_queue *q = &txq->q;
3575 struct pci_dev *dev = priv->pci_dev;
3580 /* first, empty all BD's */
3581 for (; q->first_empty != q->last_used;
3582 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3583 ipw_queue_tx_free_tfd(priv, txq);
3586 /* free buffers belonging to queue itself */
3587 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3591 /* 0 fill whole structure */
3592 memset(txq, 0, sizeof(*txq));
3596 * Destroy all DMA queues and structures
3600 static void ipw_tx_queue_free(struct ipw_priv *priv)
3603 ipw_queue_tx_free(priv, &priv->txq_cmd);
3606 ipw_queue_tx_free(priv, &priv->txq[0]);
3607 ipw_queue_tx_free(priv, &priv->txq[1]);
3608 ipw_queue_tx_free(priv, &priv->txq[2]);
3609 ipw_queue_tx_free(priv, &priv->txq[3]);
3612 static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3614 /* First 3 bytes are manufacturer */
3615 bssid[0] = priv->mac_addr[0];
3616 bssid[1] = priv->mac_addr[1];
3617 bssid[2] = priv->mac_addr[2];
3619 /* Last bytes are random */
3620 get_random_bytes(&bssid[3], ETH_ALEN - 3);
3622 bssid[0] &= 0xfe; /* clear multicast bit */
3623 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
3626 static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3628 struct ipw_station_entry entry;
3631 for (i = 0; i < priv->num_stations; i++) {
3632 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3633 /* Another node is active in network */
3634 priv->missed_adhoc_beacons = 0;
3635 if (!(priv->config & CFG_STATIC_CHANNEL))
3636 /* when other nodes drop out, we drop out */
3637 priv->config &= ~CFG_ADHOC_PERSIST;
3643 if (i == MAX_STATIONS)
3644 return IPW_INVALID_STATION;
3646 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3649 entry.support_mode = 0;
3650 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3651 memcpy(priv->stations[i], bssid, ETH_ALEN);
3652 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3653 &entry, sizeof(entry));
3654 priv->num_stations++;
3659 static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3663 for (i = 0; i < priv->num_stations; i++)
3664 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3667 return IPW_INVALID_STATION;
3670 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3674 if (priv->status & STATUS_ASSOCIATING) {
3675 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3676 queue_work(priv->workqueue, &priv->disassociate);
3680 if (!(priv->status & STATUS_ASSOCIATED)) {
3681 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3685 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3687 MAC_ARG(priv->assoc_request.bssid),
3688 priv->assoc_request.channel);
3690 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3691 priv->status |= STATUS_DISASSOCIATING;
3694 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3696 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3698 err = ipw_send_associate(priv, &priv->assoc_request);
3700 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3707 static int ipw_disassociate(void *data)
3709 struct ipw_priv *priv = data;
3710 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3712 ipw_send_disassociate(data, 0);
3716 static void ipw_bg_disassociate(void *data)
3718 struct ipw_priv *priv = data;
3720 ipw_disassociate(data);
3724 static void ipw_system_config(void *data)
3726 struct ipw_priv *priv = data;
3727 ipw_send_system_config(priv, &priv->sys_config);
3730 struct ipw_status_code {
3735 static const struct ipw_status_code ipw_status_codes[] = {
3736 {0x00, "Successful"},
3737 {0x01, "Unspecified failure"},
3738 {0x0A, "Cannot support all requested capabilities in the "
3739 "Capability information field"},
3740 {0x0B, "Reassociation denied due to inability to confirm that "
3741 "association exists"},
3742 {0x0C, "Association denied due to reason outside the scope of this "
3745 "Responding station does not support the specified authentication "
3748 "Received an Authentication frame with authentication sequence "
3749 "transaction sequence number out of expected sequence"},
3750 {0x0F, "Authentication rejected because of challenge failure"},
3751 {0x10, "Authentication rejected due to timeout waiting for next "
3752 "frame in sequence"},
3753 {0x11, "Association denied because AP is unable to handle additional "
3754 "associated stations"},
3756 "Association denied due to requesting station not supporting all "
3757 "of the datarates in the BSSBasicServiceSet Parameter"},
3759 "Association denied due to requesting station not supporting "
3760 "short preamble operation"},
3762 "Association denied due to requesting station not supporting "
3765 "Association denied due to requesting station not supporting "
3768 "Association denied due to requesting station not supporting "
3769 "short slot operation"},
3771 "Association denied due to requesting station not supporting "
3772 "DSSS-OFDM operation"},
3773 {0x28, "Invalid Information Element"},
3774 {0x29, "Group Cipher is not valid"},
3775 {0x2A, "Pairwise Cipher is not valid"},
3776 {0x2B, "AKMP is not valid"},
3777 {0x2C, "Unsupported RSN IE version"},
3778 {0x2D, "Invalid RSN IE Capabilities"},
3779 {0x2E, "Cipher suite is rejected per security policy"},
3782 #ifdef CONFIG_IPW_DEBUG
3783 static const char *ipw_get_status_code(u16 status)
3786 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3787 if (ipw_status_codes[i].status == (status & 0xff))
3788 return ipw_status_codes[i].reason;
3789 return "Unknown status value.";
3793 static void inline average_init(struct average *avg)
3795 memset(avg, 0, sizeof(*avg));
3798 static void inline average_add(struct average *avg, s16 val)
3800 avg->sum -= avg->entries[avg->pos];
3802 avg->entries[avg->pos++] = val;
3803 if (unlikely(avg->pos == AVG_ENTRIES)) {
3809 static s16 inline average_value(struct average *avg)
3811 if (!unlikely(avg->init)) {
3813 return avg->sum / avg->pos;
3817 return avg->sum / AVG_ENTRIES;
3820 static void ipw_reset_stats(struct ipw_priv *priv)
3822 u32 len = sizeof(u32);
3826 average_init(&priv->average_missed_beacons);
3827 average_init(&priv->average_rssi);
3828 average_init(&priv->average_noise);
3830 priv->last_rate = 0;
3831 priv->last_missed_beacons = 0;
3832 priv->last_rx_packets = 0;
3833 priv->last_tx_packets = 0;
3834 priv->last_tx_failures = 0;
3836 /* Firmware managed, reset only when NIC is restarted, so we have to
3837 * normalize on the current value */
3838 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
3839 &priv->last_rx_err, &len);
3840 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
3841 &priv->last_tx_failures, &len);
3843 /* Driver managed, reset with each association */
3844 priv->missed_adhoc_beacons = 0;
3845 priv->missed_beacons = 0;
3846 priv->tx_packets = 0;
3847 priv->rx_packets = 0;
3851 static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
3854 u32 mask = priv->rates_mask;
3855 /* If currently associated in B mode, restrict the maximum
3856 * rate match to B rates */
3857 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3858 mask &= IEEE80211_CCK_RATES_MASK;
3860 /* TODO: Verify that the rate is supported by the current rates
3863 while (i && !(mask & i))
3866 case IEEE80211_CCK_RATE_1MB_MASK:
3868 case IEEE80211_CCK_RATE_2MB_MASK:
3870 case IEEE80211_CCK_RATE_5MB_MASK:
3872 case IEEE80211_OFDM_RATE_6MB_MASK:
3874 case IEEE80211_OFDM_RATE_9MB_MASK:
3876 case IEEE80211_CCK_RATE_11MB_MASK:
3878 case IEEE80211_OFDM_RATE_12MB_MASK:
3880 case IEEE80211_OFDM_RATE_18MB_MASK:
3882 case IEEE80211_OFDM_RATE_24MB_MASK:
3884 case IEEE80211_OFDM_RATE_36MB_MASK:
3886 case IEEE80211_OFDM_RATE_48MB_MASK:
3888 case IEEE80211_OFDM_RATE_54MB_MASK:
3892 if (priv->ieee->mode == IEEE_B)
3898 static u32 ipw_get_current_rate(struct ipw_priv *priv)
3900 u32 rate, len = sizeof(rate);
3903 if (!(priv->status & STATUS_ASSOCIATED))
3906 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3907 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
3910 IPW_DEBUG_INFO("failed querying ordinals.\n");
3914 return ipw_get_max_rate(priv);
3917 case IPW_TX_RATE_1MB:
3919 case IPW_TX_RATE_2MB:
3921 case IPW_TX_RATE_5MB:
3923 case IPW_TX_RATE_6MB:
3925 case IPW_TX_RATE_9MB:
3927 case IPW_TX_RATE_11MB:
3929 case IPW_TX_RATE_12MB:
3931 case IPW_TX_RATE_18MB:
3933 case IPW_TX_RATE_24MB:
3935 case IPW_TX_RATE_36MB:
3937 case IPW_TX_RATE_48MB:
3939 case IPW_TX_RATE_54MB:
3946 #define IPW_STATS_INTERVAL (2 * HZ)
3947 static void ipw_gather_stats(struct ipw_priv *priv)
3949 u32 rx_err, rx_err_delta, rx_packets_delta;
3950 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3951 u32 missed_beacons_percent, missed_beacons_delta;
3953 u32 len = sizeof(u32);
3955 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3959 if (!(priv->status & STATUS_ASSOCIATED)) {
3964 /* Update the statistics */
3965 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
3966 &priv->missed_beacons, &len);
3967 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
3968 priv->last_missed_beacons = priv->missed_beacons;
3969 if (priv->assoc_request.beacon_interval) {
3970 missed_beacons_percent = missed_beacons_delta *
3971 (HZ * priv->assoc_request.beacon_interval) /
3972 (IPW_STATS_INTERVAL * 10);
3974 missed_beacons_percent = 0;
3976 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3978 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3979 rx_err_delta = rx_err - priv->last_rx_err;
3980 priv->last_rx_err = rx_err;
3982 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3983 tx_failures_delta = tx_failures - priv->last_tx_failures;
3984 priv->last_tx_failures = tx_failures;
3986 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
3987 priv->last_rx_packets = priv->rx_packets;
3989 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
3990 priv->last_tx_packets = priv->tx_packets;
3992 /* Calculate quality based on the following:
3994 * Missed beacon: 100% = 0, 0% = 70% missed
3995 * Rate: 60% = 1Mbs, 100% = Max
3996 * Rx and Tx errors represent a straight % of total Rx/Tx
3997 * RSSI: 100% = > -50, 0% = < -80
3998 * Rx errors: 100% = 0, 0% = 50% missed
4000 * The lowest computed quality is used.
4003 #define BEACON_THRESHOLD 5
4004 beacon_quality = 100 - missed_beacons_percent;
4005 if (beacon_quality < BEACON_THRESHOLD)
4008 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4009 (100 - BEACON_THRESHOLD);
4010 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4011 beacon_quality, missed_beacons_percent);
4013 priv->last_rate = ipw_get_current_rate(priv);
4014 max_rate = ipw_get_max_rate(priv);
4015 rate_quality = priv->last_rate * 40 / max_rate + 60;
4016 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4017 rate_quality, priv->last_rate / 1000000);
4019 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4020 rx_quality = 100 - (rx_err_delta * 100) /
4021 (rx_packets_delta + rx_err_delta);
4024 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4025 rx_quality, rx_err_delta, rx_packets_delta);
4027 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4028 tx_quality = 100 - (tx_failures_delta * 100) /
4029 (tx_packets_delta + tx_failures_delta);
4032 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4033 tx_quality, tx_failures_delta, tx_packets_delta);
4035 rssi = average_value(&priv->average_rssi);
4038 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4039 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4040 (priv->ieee->perfect_rssi - rssi) *
4041 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4042 62 * (priv->ieee->perfect_rssi - rssi))) /
4043 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4044 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4045 if (signal_quality > 100)
4046 signal_quality = 100;
4047 else if (signal_quality < 1)
4050 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4051 signal_quality, rssi);
4053 quality = min(beacon_quality,
4055 min(tx_quality, min(rx_quality, signal_quality))));
4056 if (quality == beacon_quality)
4057 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4059 if (quality == rate_quality)
4060 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4062 if (quality == tx_quality)
4063 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4065 if (quality == rx_quality)
4066 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4068 if (quality == signal_quality)
4069 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4072 priv->quality = quality;
4074 queue_delayed_work(priv->workqueue, &priv->gather_stats,
4075 IPW_STATS_INTERVAL);
4078 static void ipw_bg_gather_stats(void *data)
4080 struct ipw_priv *priv = data;
4082 ipw_gather_stats(data);
4086 /* Missed beacon behavior:
4087 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4088 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4089 * Above disassociate threshold, give up and stop scanning.
4090 * Roaming is disabled if disassociate_threshold <= roaming_threshold */
4091 static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
4094 priv->notif_missed_beacons = missed_count;
4096 if (missed_count > priv->disassociate_threshold &&
4097 priv->status & STATUS_ASSOCIATED) {
4098 /* If associated and we've hit the missed
4099 * beacon threshold, disassociate, turn
4100 * off roaming, and abort any active scans */
4101 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4102 IPW_DL_STATE | IPW_DL_ASSOC,
4103 "Missed beacon: %d - disassociate\n", missed_count);
4104 priv->status &= ~STATUS_ROAMING;
4105 if (priv->status & STATUS_SCANNING) {
4106 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4108 "Aborting scan with missed beacon.\n");
4109 queue_work(priv->workqueue, &priv->abort_scan);
4112 queue_work(priv->workqueue, &priv->disassociate);
4116 if (priv->status & STATUS_ROAMING) {
4117 /* If we are currently roaming, then just
4118 * print a debug statement... */
4119 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4120 "Missed beacon: %d - roam in progress\n",
4125 if (missed_count > priv->roaming_threshold &&
4126 missed_count <= priv->disassociate_threshold) {
4127 /* If we are not already roaming, set the ROAM
4128 * bit in the status and kick off a scan.
4129 * This can happen several times before we reach
4130 * disassociate_threshold. */
4131 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4132 "Missed beacon: %d - initiate "
4133 "roaming\n", missed_count);
4134 if (!(priv->status & STATUS_ROAMING)) {
4135 priv->status |= STATUS_ROAMING;
4136 if (!(priv->status & STATUS_SCANNING))
4137 queue_work(priv->workqueue,
4138 &priv->request_scan);
4143 if (priv->status & STATUS_SCANNING) {
4144 /* Stop scan to keep fw from getting
4145 * stuck (only if we aren't roaming --
4146 * otherwise we'll never scan more than 2 or 3
4148 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4149 "Aborting scan with missed beacon.\n");
4150 queue_work(priv->workqueue, &priv->abort_scan);
4153 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4158 * Handle host notification packet.
4159 * Called from interrupt routine
4161 static inline void ipw_rx_notification(struct ipw_priv *priv,
4162 struct ipw_rx_notification *notif)
4164 notif->size = le16_to_cpu(notif->size);
4166 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4168 switch (notif->subtype) {
4169 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4170 struct notif_association *assoc = ¬if->u.assoc;
4172 switch (assoc->state) {
4173 case CMAS_ASSOCIATED:{
4174 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4176 "associated: '%s' " MAC_FMT
4178 escape_essid(priv->essid,
4180 MAC_ARG(priv->bssid));
4182 switch (priv->ieee->iw_mode) {
4184 memcpy(priv->ieee->bssid,
4185 priv->bssid, ETH_ALEN);
4189 memcpy(priv->ieee->bssid,
4190 priv->bssid, ETH_ALEN);
4192 /* clear out the station table */
4193 priv->num_stations = 0;
4196 ("queueing adhoc check\n");
4197 queue_delayed_work(priv->
4207 priv->status &= ~STATUS_ASSOCIATING;
4208 priv->status |= STATUS_ASSOCIATED;
4209 queue_work(priv->workqueue,
4210 &priv->system_config);
4212 #ifdef CONFIG_IPW_QOS
4213 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4214 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4215 if ((priv->status & STATUS_AUTH) &&
4216 (IPW_GET_PACKET_STYPE(¬if->u.raw)
4217 == IEEE80211_STYPE_ASSOC_RESP)) {
4220 ieee80211_assoc_response)
4222 && (notif->size <= 2314)) {
4235 ieee80211_rx_mgt(priv->
4240 ¬if->u.raw, &stats);
4245 schedule_work(&priv->link_up);
4250 case CMAS_AUTHENTICATED:{
4252 status & (STATUS_ASSOCIATED |
4254 #ifdef CONFIG_IPW_DEBUG
4255 struct notif_authenticate *auth
4257 IPW_DEBUG(IPW_DL_NOTIF |
4260 "deauthenticated: '%s' "
4262 ": (0x%04X) - %s \n",
4267 MAC_ARG(priv->bssid),
4268 ntohs(auth->status),
4275 ~(STATUS_ASSOCIATING |
4279 schedule_work(&priv->link_down);
4283 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4285 "authenticated: '%s' " MAC_FMT
4287 escape_essid(priv->essid,
4289 MAC_ARG(priv->bssid));
4294 if (priv->status & STATUS_AUTH) {
4296 ieee80211_assoc_response
4300 ieee80211_assoc_response
4302 IPW_DEBUG(IPW_DL_NOTIF |
4305 "association failed (0x%04X): %s\n",
4306 ntohs(resp->status),
4312 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4314 "disassociated: '%s' " MAC_FMT
4316 escape_essid(priv->essid,
4318 MAC_ARG(priv->bssid));
4321 ~(STATUS_DISASSOCIATING |
4322 STATUS_ASSOCIATING |
4323 STATUS_ASSOCIATED | STATUS_AUTH);
4324 if (priv->assoc_network
4325 && (priv->assoc_network->
4327 WLAN_CAPABILITY_IBSS))
4328 ipw_remove_current_network
4331 schedule_work(&priv->link_down);
4336 case CMAS_RX_ASSOC_RESP:
4340 IPW_ERROR("assoc: unknown (%d)\n",
4348 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4349 struct notif_authenticate *auth = ¬if->u.auth;
4350 switch (auth->state) {
4351 case CMAS_AUTHENTICATED:
4352 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4353 "authenticated: '%s' " MAC_FMT " \n",
4354 escape_essid(priv->essid,
4356 MAC_ARG(priv->bssid));
4357 priv->status |= STATUS_AUTH;
4361 if (priv->status & STATUS_AUTH) {
4362 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4364 "authentication failed (0x%04X): %s\n",
4365 ntohs(auth->status),
4366 ipw_get_status_code(ntohs
4370 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4372 "deauthenticated: '%s' " MAC_FMT "\n",
4373 escape_essid(priv->essid,
4375 MAC_ARG(priv->bssid));
4377 priv->status &= ~(STATUS_ASSOCIATING |
4381 schedule_work(&priv->link_down);
4384 case CMAS_TX_AUTH_SEQ_1:
4385 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4386 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4388 case CMAS_RX_AUTH_SEQ_2:
4389 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4390 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4392 case CMAS_AUTH_SEQ_1_PASS:
4393 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4394 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4396 case CMAS_AUTH_SEQ_1_FAIL:
4397 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4398 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4400 case CMAS_TX_AUTH_SEQ_3:
4401 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4402 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4404 case CMAS_RX_AUTH_SEQ_4:
4405 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4406 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4408 case CMAS_AUTH_SEQ_2_PASS:
4409 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4410 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4412 case CMAS_AUTH_SEQ_2_FAIL:
4413 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4414 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4417 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4418 IPW_DL_ASSOC, "TX_ASSOC\n");
4420 case CMAS_RX_ASSOC_RESP:
4421 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4422 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4425 case CMAS_ASSOCIATED:
4426 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4427 IPW_DL_ASSOC, "ASSOCIATED\n");
4430 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4437 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4438 struct notif_channel_result *x =
4439 ¬if->u.channel_result;
4441 if (notif->size == sizeof(*x)) {
4442 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4445 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4446 "(should be %zd)\n",
4447 notif->size, sizeof(*x));
4452 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4453 struct notif_scan_complete *x = ¬if->u.scan_complete;
4454 if (notif->size == sizeof(*x)) {
4456 ("Scan completed: type %d, %d channels, "
4457 "%d status\n", x->scan_type,
4458 x->num_channels, x->status);
4460 IPW_ERROR("Scan completed of wrong size %d "
4461 "(should be %zd)\n",
4462 notif->size, sizeof(*x));
4466 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4468 wake_up_interruptible(&priv->wait_state);
4469 cancel_delayed_work(&priv->scan_check);
4471 if (priv->status & STATUS_EXIT_PENDING)
4474 priv->ieee->scans++;
4476 #ifdef CONFIG_IPW2200_MONITOR
4477 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4478 priv->status |= STATUS_SCAN_FORCED;
4479 queue_work(priv->workqueue,
4480 &priv->request_scan);
4483 priv->status &= ~STATUS_SCAN_FORCED;
4484 #endif /* CONFIG_IPW2200_MONITOR */
4486 if (!(priv->status & (STATUS_ASSOCIATED |
4487 STATUS_ASSOCIATING |
4489 STATUS_DISASSOCIATING)))
4490 queue_work(priv->workqueue, &priv->associate);
4491 else if (priv->status & STATUS_ROAMING) {
4492 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4493 /* If a scan completed and we are in roam mode, then
4494 * the scan that completed was the one requested as a
4495 * result of entering roam... so, schedule the
4497 queue_work(priv->workqueue,
4500 /* Don't schedule if we aborted the scan */
4501 priv->status &= ~STATUS_ROAMING;
4502 } else if (priv->status & STATUS_SCAN_PENDING)
4503 queue_work(priv->workqueue,
4504 &priv->request_scan);
4505 else if (priv->config & CFG_BACKGROUND_SCAN
4506 && priv->status & STATUS_ASSOCIATED)
4507 queue_delayed_work(priv->workqueue,
4508 &priv->request_scan, HZ);
4512 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4513 struct notif_frag_length *x = ¬if->u.frag_len;
4515 if (notif->size == sizeof(*x))
4516 IPW_ERROR("Frag length: %d\n",
4517 le16_to_cpu(x->frag_length));
4519 IPW_ERROR("Frag length of wrong size %d "
4520 "(should be %zd)\n",
4521 notif->size, sizeof(*x));
4525 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4526 struct notif_link_deterioration *x =
4527 ¬if->u.link_deterioration;
4529 if (notif->size == sizeof(*x)) {
4530 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4531 "link deterioration: '%s' " MAC_FMT
4532 " \n", escape_essid(priv->essid,
4534 MAC_ARG(priv->bssid));
4535 memcpy(&priv->last_link_deterioration, x,
4538 IPW_ERROR("Link Deterioration of wrong size %d "
4539 "(should be %zd)\n",
4540 notif->size, sizeof(*x));
4545 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4546 IPW_ERROR("Dino config\n");
4548 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4549 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4554 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4555 struct notif_beacon_state *x = ¬if->u.beacon_state;
4556 if (notif->size != sizeof(*x)) {
4558 ("Beacon state of wrong size %d (should "
4559 "be %zd)\n", notif->size, sizeof(*x));
4563 if (le32_to_cpu(x->state) ==
4564 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4565 ipw_handle_missed_beacon(priv,
4572 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4573 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4574 if (notif->size == sizeof(*x)) {
4575 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4576 "0x%02x station %d\n",
4577 x->key_state, x->security_type,
4583 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4584 notif->size, sizeof(*x));
4588 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4589 struct notif_calibration *x = ¬if->u.calibration;
4591 if (notif->size == sizeof(*x)) {
4592 memcpy(&priv->calib, x, sizeof(*x));
4593 IPW_DEBUG_INFO("TODO: Calibration\n");
4598 ("Calibration of wrong size %d (should be %zd)\n",
4599 notif->size, sizeof(*x));
4603 case HOST_NOTIFICATION_NOISE_STATS:{
4604 if (notif->size == sizeof(u32)) {
4606 (u8) (le32_to_cpu(notif->u.noise.value) &
4608 average_add(&priv->average_noise,
4614 ("Noise stat is wrong size %d (should be %zd)\n",
4615 notif->size, sizeof(u32));
4620 IPW_ERROR("Unknown notification: "
4621 "subtype=%d,flags=0x%2x,size=%d\n",
4622 notif->subtype, notif->flags, notif->size);
4627 * Destroys all DMA structures and initialise them again
4630 * @return error code
4632 static int ipw_queue_reset(struct ipw_priv *priv)
4635 /** @todo customize queue sizes */
4636 int nTx = 64, nTxCmd = 8;
4637 ipw_tx_queue_free(priv);
4639 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4640 IPW_TX_CMD_QUEUE_READ_INDEX,
4641 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4642 IPW_TX_CMD_QUEUE_BD_BASE,
4643 IPW_TX_CMD_QUEUE_BD_SIZE);
4645 IPW_ERROR("Tx Cmd queue init failed\n");
4649 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4650 IPW_TX_QUEUE_0_READ_INDEX,
4651 IPW_TX_QUEUE_0_WRITE_INDEX,
4652 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4654 IPW_ERROR("Tx 0 queue init failed\n");
4657 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4658 IPW_TX_QUEUE_1_READ_INDEX,
4659 IPW_TX_QUEUE_1_WRITE_INDEX,
4660 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4662 IPW_ERROR("Tx 1 queue init failed\n");
4665 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4666 IPW_TX_QUEUE_2_READ_INDEX,
4667 IPW_TX_QUEUE_2_WRITE_INDEX,
4668 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4670 IPW_ERROR("Tx 2 queue init failed\n");
4673 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4674 IPW_TX_QUEUE_3_READ_INDEX,
4675 IPW_TX_QUEUE_3_WRITE_INDEX,
4676 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4678 IPW_ERROR("Tx 3 queue init failed\n");
4682 priv->rx_bufs_min = 0;
4683 priv->rx_pend_max = 0;
4687 ipw_tx_queue_free(priv);
4692 * Reclaim Tx queue entries no more used by NIC.
4694 * When FW adwances 'R' index, all entries between old and
4695 * new 'R' index need to be reclaimed. As result, some free space
4696 * forms. If there is enough free space (> low mark), wake Tx queue.
4698 * @note Need to protect against garbage in 'R' index
4702 * @return Number of used entries remains in the queue
4704 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4705 struct clx2_tx_queue *txq, int qindex)
4709 struct clx2_queue *q = &txq->q;
4711 hw_tail = ipw_read32(priv, q->reg_r);
4712 if (hw_tail >= q->n_bd) {
4714 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4718 for (; q->last_used != hw_tail;
4719 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4720 ipw_queue_tx_free_tfd(priv, txq);
4724 if ((ipw_queue_space(q) > q->low_mark) &&
4726 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4727 netif_wake_queue(priv->net_dev);
4728 used = q->first_empty - q->last_used;
4735 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4738 struct clx2_tx_queue *txq = &priv->txq_cmd;
4739 struct clx2_queue *q = &txq->q;
4740 struct tfd_frame *tfd;
4742 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4743 IPW_ERROR("No space for Tx\n");
4747 tfd = &txq->bd[q->first_empty];
4748 txq->txb[q->first_empty] = NULL;
4750 memset(tfd, 0, sizeof(*tfd));
4751 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4752 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4754 tfd->u.cmd.index = hcmd;
4755 tfd->u.cmd.length = len;
4756 memcpy(tfd->u.cmd.payload, buf, len);
4757 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4758 ipw_write32(priv, q->reg_w, q->first_empty);
4759 _ipw_read32(priv, 0x90);
4765 * Rx theory of operation
4767 * The host allocates 32 DMA target addresses and passes the host address
4768 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4772 * The host/firmware share two index registers for managing the Rx buffers.
4774 * The READ index maps to the first position that the firmware may be writing
4775 * to -- the driver can read up to (but not including) this position and get
4777 * The READ index is managed by the firmware once the card is enabled.
4779 * The WRITE index maps to the last position the driver has read from -- the
4780 * position preceding WRITE is the last slot the firmware can place a packet.
4782 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4785 * During initialization the host sets up the READ queue position to the first
4786 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4788 * When the firmware places a packet in a buffer it will advance the READ index
4789 * and fire the RX interrupt. The driver can then query the READ index and
4790 * process as many packets as possible, moving the WRITE index forward as it
4791 * resets the Rx queue buffers with new memory.
4793 * The management in the driver is as follows:
4794 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
4795 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4796 * to replensish the ipw->rxq->rx_free.
4797 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4798 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4799 * 'processed' and 'read' driver indexes as well)
4800 * + A received packet is processed and handed to the kernel network stack,
4801 * detached from the ipw->rxq. The driver 'processed' index is updated.
4802 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4803 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4804 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
4805 * were enough free buffers and RX_STALLED is set it is cleared.
4810 * ipw_rx_queue_alloc() Allocates rx_free
4811 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4812 * ipw_rx_queue_restock
4813 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4814 * queue, updates firmware pointers, and updates
4815 * the WRITE index. If insufficient rx_free buffers
4816 * are available, schedules ipw_rx_queue_replenish
4818 * -- enable interrupts --
4819 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
4820 * READ INDEX, detaching the SKB from the pool.
4821 * Moves the packet buffer from queue to rx_used.
4822 * Calls ipw_rx_queue_restock to refill any empty
4829 * If there are slots in the RX queue that need to be restocked,
4830 * and we have free pre-allocated buffers, fill the ranks as much
4831 * as we can pulling from rx_free.
4833 * This moves the 'write' index forward to catch up with 'processed', and
4834 * also updates the memory address in the firmware to reference the new
4837 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4839 struct ipw_rx_queue *rxq = priv->rxq;
4840 struct list_head *element;
4841 struct ipw_rx_mem_buffer *rxb;
4842 unsigned long flags;
4845 spin_lock_irqsave(&rxq->lock, flags);
4847 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4848 element = rxq->rx_free.next;
4849 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4852 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4854 rxq->queue[rxq->write] = rxb;
4855 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4858 spin_unlock_irqrestore(&rxq->lock, flags);
4860 /* If the pre-allocated buffer pool is dropping low, schedule to
4862 if (rxq->free_count <= RX_LOW_WATERMARK)
4863 queue_work(priv->workqueue, &priv->rx_replenish);
4865 /* If we've added more space for the firmware to place data, tell it */
4866 if (write != rxq->write)
4867 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4871 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4872 * Also restock the Rx queue via ipw_rx_queue_restock.
4874 * This is called as a scheduled work item (except for during intialization)
4876 static void ipw_rx_queue_replenish(void *data)
4878 struct ipw_priv *priv = data;
4879 struct ipw_rx_queue *rxq = priv->rxq;
4880 struct list_head *element;
4881 struct ipw_rx_mem_buffer *rxb;
4882 unsigned long flags;
4884 spin_lock_irqsave(&rxq->lock, flags);
4885 while (!list_empty(&rxq->rx_used)) {
4886 element = rxq->rx_used.next;
4887 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4888 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4890 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4891 priv->net_dev->name);
4892 /* We don't reschedule replenish work here -- we will
4893 * call the restock method and if it still needs
4894 * more buffers it will schedule replenish */
4899 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4901 pci_map_single(priv->pci_dev, rxb->skb->data,
4902 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4904 list_add_tail(&rxb->list, &rxq->rx_free);
4907 spin_unlock_irqrestore(&rxq->lock, flags);
4909 ipw_rx_queue_restock(priv);
4912 static void ipw_bg_rx_queue_replenish(void *data)
4914 struct ipw_priv *priv = data;
4916 ipw_rx_queue_replenish(data);
4920 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4921 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL
4922 * This free routine walks the list of POOL entries and if SKB is set to
4923 * non NULL it is unmapped and freed
4925 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4932 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4933 if (rxq->pool[i].skb != NULL) {
4934 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4935 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4936 dev_kfree_skb(rxq->pool[i].skb);
4943 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4945 struct ipw_rx_queue *rxq;
4948 rxq = (struct ipw_rx_queue *)kmalloc(sizeof(*rxq), GFP_KERNEL);
4949 if (unlikely(!rxq)) {
4950 IPW_ERROR("memory allocation failed\n");
4953 memset(rxq, 0, sizeof(*rxq));
4954 spin_lock_init(&rxq->lock);
4955 INIT_LIST_HEAD(&rxq->rx_free);
4956 INIT_LIST_HEAD(&rxq->rx_used);
4958 /* Fill the rx_used queue with _all_ of the Rx buffers */
4959 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
4960 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4962 /* Set us so that we have processed and used all buffers, but have
4963 * not restocked the Rx queue with fresh buffers */
4964 rxq->read = rxq->write = 0;
4965 rxq->processed = RX_QUEUE_SIZE - 1;
4966 rxq->free_count = 0;
4971 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4973 rate &= ~IEEE80211_BASIC_RATE_MASK;
4974 if (ieee_mode == IEEE_A) {
4976 case IEEE80211_OFDM_RATE_6MB:
4977 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4979 case IEEE80211_OFDM_RATE_9MB:
4980 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4982 case IEEE80211_OFDM_RATE_12MB:
4984 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4985 case IEEE80211_OFDM_RATE_18MB:
4987 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
4988 case IEEE80211_OFDM_RATE_24MB:
4990 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
4991 case IEEE80211_OFDM_RATE_36MB:
4993 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
4994 case IEEE80211_OFDM_RATE_48MB:
4996 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
4997 case IEEE80211_OFDM_RATE_54MB:
4999 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5007 case IEEE80211_CCK_RATE_1MB:
5008 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5009 case IEEE80211_CCK_RATE_2MB:
5010 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5011 case IEEE80211_CCK_RATE_5MB:
5012 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5013 case IEEE80211_CCK_RATE_11MB:
5014 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5017 /* If we are limited to B modulations, bail at this point */
5018 if (ieee_mode == IEEE_B)
5023 case IEEE80211_OFDM_RATE_6MB:
5024 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5025 case IEEE80211_OFDM_RATE_9MB:
5026 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5027 case IEEE80211_OFDM_RATE_12MB:
5028 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5029 case IEEE80211_OFDM_RATE_18MB:
5030 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5031 case IEEE80211_OFDM_RATE_24MB:
5032 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5033 case IEEE80211_OFDM_RATE_36MB:
5034 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5035 case IEEE80211_OFDM_RATE_48MB:
5036 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5037 case IEEE80211_OFDM_RATE_54MB:
5038 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5044 static int ipw_compatible_rates(struct ipw_priv *priv,
5045 const struct ieee80211_network *network,
5046 struct ipw_supported_rates *rates)
5050 memset(rates, 0, sizeof(*rates));
5051 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5052 rates->num_rates = 0;
5053 for (i = 0; i < num_rates; i++) {
5054 if (!ipw_is_rate_in_mask(priv, network->mode,
5055 network->rates[i])) {
5057 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5058 IPW_DEBUG_SCAN("Adding masked mandatory "
5061 rates->supported_rates[rates->num_rates++] =
5066 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5067 network->rates[i], priv->rates_mask);
5071 rates->supported_rates[rates->num_rates++] = network->rates[i];
5074 num_rates = min(network->rates_ex_len,
5075 (u8) (IPW_MAX_RATES - num_rates));
5076 for (i = 0; i < num_rates; i++) {
5077 if (!ipw_is_rate_in_mask(priv, network->mode,
5078 network->rates_ex[i])) {
5079 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5080 IPW_DEBUG_SCAN("Adding masked mandatory "
5082 network->rates_ex[i]);
5083 rates->supported_rates[rates->num_rates++] =
5088 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5089 network->rates_ex[i], priv->rates_mask);
5093 rates->supported_rates[rates->num_rates++] =
5094 network->rates_ex[i];
5100 static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
5101 const struct ipw_supported_rates *src)
5104 for (i = 0; i < src->num_rates; i++)
5105 dest->supported_rates[i] = src->supported_rates[i];
5106 dest->num_rates = src->num_rates;
5109 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5110 * mask should ever be used -- right now all callers to add the scan rates are
5111 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5112 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5113 u8 modulation, u32 rate_mask)
5115 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5116 IEEE80211_BASIC_RATE_MASK : 0;
5118 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5119 rates->supported_rates[rates->num_rates++] =
5120 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5122 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5123 rates->supported_rates[rates->num_rates++] =
5124 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5126 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5127 rates->supported_rates[rates->num_rates++] = basic_mask |
5128 IEEE80211_CCK_RATE_5MB;
5130 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5131 rates->supported_rates[rates->num_rates++] = basic_mask |
5132 IEEE80211_CCK_RATE_11MB;
5135 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5136 u8 modulation, u32 rate_mask)
5138 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5139 IEEE80211_BASIC_RATE_MASK : 0;
5141 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5142 rates->supported_rates[rates->num_rates++] = basic_mask |
5143 IEEE80211_OFDM_RATE_6MB;
5145 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5146 rates->supported_rates[rates->num_rates++] =
5147 IEEE80211_OFDM_RATE_9MB;
5149 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5150 rates->supported_rates[rates->num_rates++] = basic_mask |
5151 IEEE80211_OFDM_RATE_12MB;
5153 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5154 rates->supported_rates[rates->num_rates++] =
5155 IEEE80211_OFDM_RATE_18MB;
5157 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5158 rates->supported_rates[rates->num_rates++] = basic_mask |
5159 IEEE80211_OFDM_RATE_24MB;
5161 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5162 rates->supported_rates[rates->num_rates++] =
5163 IEEE80211_OFDM_RATE_36MB;
5165 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5166 rates->supported_rates[rates->num_rates++] =
5167 IEEE80211_OFDM_RATE_48MB;
5169 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5170 rates->supported_rates[rates->num_rates++] =
5171 IEEE80211_OFDM_RATE_54MB;
5174 struct ipw_network_match {
5175 struct ieee80211_network *network;
5176 struct ipw_supported_rates rates;
5179 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5180 struct ipw_network_match *match,
5181 struct ieee80211_network *network,
5184 struct ipw_supported_rates rates;
5186 /* Verify that this network's capability is compatible with the
5187 * current mode (AdHoc or Infrastructure) */
5188 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5189 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5190 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5191 "capability mismatch.\n",
5192 escape_essid(network->ssid, network->ssid_len),
5193 MAC_ARG(network->bssid));
5197 /* If we do not have an ESSID for this AP, we can not associate with
5199 if (network->flags & NETWORK_EMPTY_ESSID) {
5200 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5201 "because of hidden ESSID.\n",
5202 escape_essid(network->ssid, network->ssid_len),
5203 MAC_ARG(network->bssid));
5207 if (unlikely(roaming)) {
5208 /* If we are roaming, then ensure check if this is a valid
5209 * network to try and roam to */
5210 if ((network->ssid_len != match->network->ssid_len) ||
5211 memcmp(network->ssid, match->network->ssid,
5212 network->ssid_len)) {
5213 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5214 "because of non-network ESSID.\n",
5215 escape_essid(network->ssid,
5217 MAC_ARG(network->bssid));
5221 /* If an ESSID has been configured then compare the broadcast
5223 if ((priv->config & CFG_STATIC_ESSID) &&
5224 ((network->ssid_len != priv->essid_len) ||
5225 memcmp(network->ssid, priv->essid,
5226 min(network->ssid_len, priv->essid_len)))) {
5227 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5230 escape_essid(network->ssid, network->ssid_len),
5232 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5233 "because of ESSID mismatch: '%s'.\n",
5234 escaped, MAC_ARG(network->bssid),
5235 escape_essid(priv->essid,
5241 /* If the old network rate is better than this one, don't bother
5242 * testing everything else. */
5244 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5245 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5246 "current network.\n",
5247 escape_essid(match->network->ssid,
5248 match->network->ssid_len));
5250 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5251 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5252 "current network.\n",
5253 escape_essid(match->network->ssid,
5254 match->network->ssid_len));
5258 /* Now go through and see if the requested network is valid... */
5259 if (priv->ieee->scan_age != 0 &&
5260 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5261 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5262 "because of age: %lums.\n",
5263 escape_essid(network->ssid, network->ssid_len),
5264 MAC_ARG(network->bssid),
5265 1000 * (jiffies - network->last_scanned) / HZ);
5269 if ((priv->config & CFG_STATIC_CHANNEL) &&
5270 (network->channel != priv->channel)) {
5271 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5272 "because of channel mismatch: %d != %d.\n",
5273 escape_essid(network->ssid, network->ssid_len),
5274 MAC_ARG(network->bssid),
5275 network->channel, priv->channel);
5279 /* Verify privacy compatability */
5280 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5281 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5282 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5283 "because of privacy mismatch: %s != %s.\n",
5284 escape_essid(network->ssid, network->ssid_len),
5285 MAC_ARG(network->bssid),
5287 capability & CAP_PRIVACY_ON ? "on" : "off",
5289 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5294 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5295 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5296 "because of the same BSSID match: " MAC_FMT
5297 ".\n", escape_essid(network->ssid,
5299 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5303 /* Filter out any incompatible freq / mode combinations */
5304 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5305 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5306 "because of invalid frequency/mode "
5308 escape_essid(network->ssid, network->ssid_len),
5309 MAC_ARG(network->bssid));
5313 /* Ensure that the rates supported by the driver are compatible with
5314 * this AP, including verification of basic rates (mandatory) */
5315 if (!ipw_compatible_rates(priv, network, &rates)) {
5316 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5317 "because configured rate mask excludes "
5318 "AP mandatory rate.\n",
5319 escape_essid(network->ssid, network->ssid_len),
5320 MAC_ARG(network->bssid));
5324 if (rates.num_rates == 0) {
5325 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5326 "because of no compatible rates.\n",
5327 escape_essid(network->ssid, network->ssid_len),
5328 MAC_ARG(network->bssid));
5332 /* TODO: Perform any further minimal comparititive tests. We do not
5333 * want to put too much policy logic here; intelligent scan selection
5334 * should occur within a generic IEEE 802.11 user space tool. */
5336 /* Set up 'new' AP to this network */
5337 ipw_copy_rates(&match->rates, &rates);
5338 match->network = network;
5339 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5340 escape_essid(network->ssid, network->ssid_len),
5341 MAC_ARG(network->bssid));
5346 static void ipw_merge_adhoc_network(void *data)
5348 struct ipw_priv *priv = data;
5349 struct ieee80211_network *network = NULL;
5350 struct ipw_network_match match = {
5351 .network = priv->assoc_network
5354 if ((priv->status & STATUS_ASSOCIATED) &&
5355 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5356 /* First pass through ROAM process -- look for a better
5358 unsigned long flags;
5360 spin_lock_irqsave(&priv->ieee->lock, flags);
5361 list_for_each_entry(network, &priv->ieee->network_list, list) {
5362 if (network != priv->assoc_network)
5363 ipw_find_adhoc_network(priv, &match, network,
5366 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5368 if (match.network == priv->assoc_network) {
5369 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5375 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5376 IPW_DEBUG_MERGE("remove network %s\n",
5377 escape_essid(priv->essid,
5379 ipw_remove_current_network(priv);
5382 ipw_disassociate(priv);
5383 priv->assoc_network = match.network;
5389 static int ipw_best_network(struct ipw_priv *priv,
5390 struct ipw_network_match *match,
5391 struct ieee80211_network *network, int roaming)
5393 struct ipw_supported_rates rates;
5395 /* Verify that this network's capability is compatible with the
5396 * current mode (AdHoc or Infrastructure) */
5397 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5398 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5399 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5400 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5401 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5402 "capability mismatch.\n",
5403 escape_essid(network->ssid, network->ssid_len),
5404 MAC_ARG(network->bssid));
5408 /* If we do not have an ESSID for this AP, we can not associate with
5410 if (network->flags & NETWORK_EMPTY_ESSID) {
5411 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5412 "because of hidden ESSID.\n",
5413 escape_essid(network->ssid, network->ssid_len),
5414 MAC_ARG(network->bssid));
5418 if (unlikely(roaming)) {
5419 /* If we are roaming, then ensure check if this is a valid
5420 * network to try and roam to */
5421 if ((network->ssid_len != match->network->ssid_len) ||
5422 memcmp(network->ssid, match->network->ssid,
5423 network->ssid_len)) {
5424 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5425 "because of non-network ESSID.\n",
5426 escape_essid(network->ssid,
5428 MAC_ARG(network->bssid));
5432 /* If an ESSID has been configured then compare the broadcast
5434 if ((priv->config & CFG_STATIC_ESSID) &&
5435 ((network->ssid_len != priv->essid_len) ||
5436 memcmp(network->ssid, priv->essid,
5437 min(network->ssid_len, priv->essid_len)))) {
5438 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5440 escape_essid(network->ssid, network->ssid_len),
5442 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5443 "because of ESSID mismatch: '%s'.\n",
5444 escaped, MAC_ARG(network->bssid),
5445 escape_essid(priv->essid,
5451 /* If the old network rate is better than this one, don't bother
5452 * testing everything else. */
5453 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5454 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5456 escape_essid(network->ssid, network->ssid_len),
5458 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5459 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5460 escaped, MAC_ARG(network->bssid),
5461 escape_essid(match->network->ssid,
5462 match->network->ssid_len),
5463 MAC_ARG(match->network->bssid));
5467 /* If this network has already had an association attempt within the
5468 * last 3 seconds, do not try and associate again... */
5469 if (network->last_associate &&
5470 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5471 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5472 "because of storming (%lus since last "
5473 "assoc attempt).\n",
5474 escape_essid(network->ssid, network->ssid_len),
5475 MAC_ARG(network->bssid),
5476 (jiffies - network->last_associate) / HZ);
5480 /* Now go through and see if the requested network is valid... */
5481 if (priv->ieee->scan_age != 0 &&
5482 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5483 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5484 "because of age: %lums.\n",
5485 escape_essid(network->ssid, network->ssid_len),
5486 MAC_ARG(network->bssid),
5487 1000 * (jiffies - network->last_scanned) / HZ);
5491 if ((priv->config & CFG_STATIC_CHANNEL) &&
5492 (network->channel != priv->channel)) {
5493 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5494 "because of channel mismatch: %d != %d.\n",
5495 escape_essid(network->ssid, network->ssid_len),
5496 MAC_ARG(network->bssid),
5497 network->channel, priv->channel);
5501 /* Verify privacy compatability */
5502 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5503 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5504 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5505 "because of privacy mismatch: %s != %s.\n",
5506 escape_essid(network->ssid, network->ssid_len),
5507 MAC_ARG(network->bssid),
5508 priv->capability & CAP_PRIVACY_ON ? "on" :
5510 network->capability &
5511 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5515 if (!priv->ieee->wpa_enabled && (network->wpa_ie_len > 0 ||
5516 network->rsn_ie_len > 0)) {
5517 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5518 "because of WPA capability mismatch.\n",
5519 escape_essid(network->ssid, network->ssid_len),
5520 MAC_ARG(network->bssid));
5524 if ((priv->config & CFG_STATIC_BSSID) &&
5525 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5526 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5527 "because of BSSID mismatch: " MAC_FMT ".\n",
5528 escape_essid(network->ssid, network->ssid_len),
5529 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5533 /* Filter out any incompatible freq / mode combinations */
5534 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5535 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5536 "because of invalid frequency/mode "
5538 escape_essid(network->ssid, network->ssid_len),
5539 MAC_ARG(network->bssid));
5543 /* Filter out invalid channel in current GEO */
5544 if (!ipw_is_valid_channel(priv->ieee, network->channel)) {
5545 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5546 "because of invalid channel in current GEO\n",
5547 escape_essid(network->ssid, network->ssid_len),
5548 MAC_ARG(network->bssid));
5552 /* Ensure that the rates supported by the driver are compatible with
5553 * this AP, including verification of basic rates (mandatory) */
5554 if (!ipw_compatible_rates(priv, network, &rates)) {
5555 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5556 "because configured rate mask excludes "
5557 "AP mandatory rate.\n",
5558 escape_essid(network->ssid, network->ssid_len),
5559 MAC_ARG(network->bssid));
5563 if (rates.num_rates == 0) {
5564 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5565 "because of no compatible rates.\n",
5566 escape_essid(network->ssid, network->ssid_len),
5567 MAC_ARG(network->bssid));
5571 /* TODO: Perform any further minimal comparititive tests. We do not
5572 * want to put too much policy logic here; intelligent scan selection
5573 * should occur within a generic IEEE 802.11 user space tool. */
5575 /* Set up 'new' AP to this network */
5576 ipw_copy_rates(&match->rates, &rates);
5577 match->network = network;
5579 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5580 escape_essid(network->ssid, network->ssid_len),
5581 MAC_ARG(network->bssid));
5586 static void ipw_adhoc_create(struct ipw_priv *priv,
5587 struct ieee80211_network *network)
5589 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5593 * For the purposes of scanning, we can set our wireless mode
5594 * to trigger scans across combinations of bands, but when it
5595 * comes to creating a new ad-hoc network, we have tell the FW
5596 * exactly which band to use.
5598 * We also have the possibility of an invalid channel for the
5599 * chossen band. Attempting to create a new ad-hoc network
5600 * with an invalid channel for wireless mode will trigger a
5604 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
5605 case IEEE80211_52GHZ_BAND:
5606 network->mode = IEEE_A;
5607 i = ipw_channel_to_index(priv->ieee, priv->channel);
5610 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5611 IPW_WARNING("Overriding invalid channel\n");
5612 priv->channel = geo->a[0].channel;
5616 case IEEE80211_24GHZ_BAND:
5617 if (priv->ieee->mode & IEEE_G)
5618 network->mode = IEEE_G;
5620 network->mode = IEEE_B;
5621 i = ipw_channel_to_index(priv->ieee, priv->channel);
5624 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5625 IPW_WARNING("Overriding invalid channel\n");
5626 priv->channel = geo->bg[0].channel;
5631 IPW_WARNING("Overriding invalid channel\n");
5632 if (priv->ieee->mode & IEEE_A) {
5633 network->mode = IEEE_A;
5634 priv->channel = geo->a[0].channel;
5635 } else if (priv->ieee->mode & IEEE_G) {
5636 network->mode = IEEE_G;
5637 priv->channel = geo->bg[0].channel;
5639 network->mode = IEEE_B;
5640 priv->channel = geo->bg[0].channel;
5645 network->channel = priv->channel;
5646 priv->config |= CFG_ADHOC_PERSIST;
5647 ipw_create_bssid(priv, network->bssid);
5648 network->ssid_len = priv->essid_len;
5649 memcpy(network->ssid, priv->essid, priv->essid_len);
5650 memset(&network->stats, 0, sizeof(network->stats));
5651 network->capability = WLAN_CAPABILITY_IBSS;
5652 if (!(priv->config & CFG_PREAMBLE_LONG))
5653 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5654 if (priv->capability & CAP_PRIVACY_ON)
5655 network->capability |= WLAN_CAPABILITY_PRIVACY;
5656 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5657 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5658 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5659 memcpy(network->rates_ex,
5660 &priv->rates.supported_rates[network->rates_len],
5661 network->rates_ex_len);
5662 network->last_scanned = 0;
5664 network->last_associate = 0;
5665 network->time_stamp[0] = 0;
5666 network->time_stamp[1] = 0;
5667 network->beacon_interval = 100; /* Default */
5668 network->listen_interval = 10; /* Default */
5669 network->atim_window = 0; /* Default */
5670 network->wpa_ie_len = 0;
5671 network->rsn_ie_len = 0;
5674 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5676 struct ipw_tgi_tx_key *key;
5677 struct host_cmd cmd = {
5678 .cmd = IPW_CMD_TGI_TX_KEY,
5682 if (!(priv->ieee->sec.flags & (1 << index)))
5685 key = (struct ipw_tgi_tx_key *)&cmd.param;
5686 key->key_id = index;
5687 memcpy(key->key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5688 key->security_type = type;
5689 key->station_index = 0; /* always 0 for BSS */
5691 /* 0 for new key; previous value of counter (after fatal error) */
5692 key->tx_counter[0] = 0;
5693 key->tx_counter[1] = 0;
5695 ipw_send_cmd(priv, &cmd);
5698 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5700 struct ipw_wep_key *key;
5702 struct host_cmd cmd = {
5703 .cmd = IPW_CMD_WEP_KEY,
5707 key = (struct ipw_wep_key *)&cmd.param;
5708 key->cmd_id = DINO_CMD_WEP_KEY;
5711 /* Note: AES keys cannot be set for multiple times.
5712 * Only set it at the first time. */
5713 for (i = 0; i < 4; i++) {
5714 key->key_index = i | type;
5715 if (!(priv->ieee->sec.flags & (1 << i))) {
5720 key->key_size = priv->ieee->sec.key_sizes[i];
5721 memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);
5723 ipw_send_cmd(priv, &cmd);
5727 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5729 if (priv->ieee->host_encrypt)
5734 priv->sys_config.disable_unicast_decryption = 0;
5735 priv->ieee->host_decrypt = 0;
5738 priv->sys_config.disable_unicast_decryption = 1;
5739 priv->ieee->host_decrypt = 1;
5742 priv->sys_config.disable_unicast_decryption = 0;
5743 priv->ieee->host_decrypt = 0;
5746 priv->sys_config.disable_unicast_decryption = 1;
5753 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5755 if (priv->ieee->host_encrypt)
5760 priv->sys_config.disable_multicast_decryption = 0;
5763 priv->sys_config.disable_multicast_decryption = 1;
5766 priv->sys_config.disable_multicast_decryption = 0;
5769 priv->sys_config.disable_multicast_decryption = 1;
5776 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5778 switch (priv->ieee->sec.level) {
5780 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5781 ipw_send_tgi_tx_key(priv,
5782 DCT_FLAG_EXT_SECURITY_CCM,
5783 priv->ieee->sec.active_key);
5785 if (!priv->ieee->host_mc_decrypt)
5786 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5789 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5790 ipw_send_tgi_tx_key(priv,
5791 DCT_FLAG_EXT_SECURITY_TKIP,
5792 priv->ieee->sec.active_key);
5795 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5796 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5797 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5805 static void ipw_adhoc_check(void *data)
5807 struct ipw_priv *priv = data;
5809 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5810 !(priv->config & CFG_ADHOC_PERSIST)) {
5811 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5812 IPW_DL_STATE | IPW_DL_ASSOC,
5813 "Missed beacon: %d - disassociate\n",
5814 priv->missed_adhoc_beacons);
5815 ipw_remove_current_network(priv);
5816 ipw_disassociate(priv);
5820 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5821 priv->assoc_request.beacon_interval);
5824 static void ipw_bg_adhoc_check(void *data)
5826 struct ipw_priv *priv = data;
5828 ipw_adhoc_check(data);
5832 #ifdef CONFIG_IPW_DEBUG
5833 static void ipw_debug_config(struct ipw_priv *priv)
5835 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5836 "[CFG 0x%08X]\n", priv->config);
5837 if (priv->config & CFG_STATIC_CHANNEL)
5838 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5840 IPW_DEBUG_INFO("Channel unlocked.\n");
5841 if (priv->config & CFG_STATIC_ESSID)
5842 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5843 escape_essid(priv->essid, priv->essid_len));
5845 IPW_DEBUG_INFO("ESSID unlocked.\n");
5846 if (priv->config & CFG_STATIC_BSSID)
5847 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5848 MAC_ARG(priv->bssid));
5850 IPW_DEBUG_INFO("BSSID unlocked.\n");
5851 if (priv->capability & CAP_PRIVACY_ON)
5852 IPW_DEBUG_INFO("PRIVACY on\n");
5854 IPW_DEBUG_INFO("PRIVACY off\n");
5855 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5858 #define ipw_debug_config(x) do {} while (0)
5861 static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5863 /* TODO: Verify that this works... */
5864 struct ipw_fixed_rate fr = {
5865 .tx_rates = priv->rates_mask
5870 /* Identify 'current FW band' and match it with the fixed
5873 switch (priv->ieee->freq_band) {
5874 case IEEE80211_52GHZ_BAND: /* A only */
5876 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5877 /* Invalid fixed rate mask */
5879 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5884 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5887 default: /* 2.4Ghz or Mixed */
5889 if (mode == IEEE_B) {
5890 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5891 /* Invalid fixed rate mask */
5893 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5900 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5901 IEEE80211_OFDM_RATES_MASK)) {
5902 /* Invalid fixed rate mask */
5904 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5909 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5910 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5911 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5914 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5915 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5916 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5919 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5920 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5921 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5924 fr.tx_rates |= mask;
5928 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5929 ipw_write_reg32(priv, reg, *(u32 *) & fr);
5932 static void ipw_abort_scan(struct ipw_priv *priv)
5936 if (priv->status & STATUS_SCAN_ABORTING) {
5937 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5940 priv->status |= STATUS_SCAN_ABORTING;
5942 err = ipw_send_scan_abort(priv);
5944 IPW_DEBUG_HC("Request to abort scan failed.\n");
5947 static void ipw_add_scan_channels(struct ipw_priv *priv,
5948 struct ipw_scan_request_ext *scan,
5951 int channel_index = 0;
5952 const struct ieee80211_geo *geo;
5955 geo = ipw_get_geo(priv->ieee);
5957 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5958 int start = channel_index;
5959 for (i = 0; i < geo->a_channels; i++) {
5960 if ((priv->status & STATUS_ASSOCIATED) &&
5961 geo->a[i].channel == priv->channel)
5964 scan->channels_list[channel_index] = geo->a[i].channel;
5965 ipw_set_scan_type(scan, channel_index,
5967 flags & IEEE80211_CH_PASSIVE_ONLY ?
5968 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5972 if (start != channel_index) {
5973 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5974 (channel_index - start);
5979 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5980 int start = channel_index;
5981 if (priv->config & CFG_SPEED_SCAN) {
5983 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5984 /* nop out the list */
5989 while (channel_index < IPW_SCAN_CHANNELS) {
5991 priv->speed_scan[priv->speed_scan_pos];
5993 priv->speed_scan_pos = 0;
5994 channel = priv->speed_scan[0];
5996 if ((priv->status & STATUS_ASSOCIATED) &&
5997 channel == priv->channel) {
5998 priv->speed_scan_pos++;
6002 /* If this channel has already been
6003 * added in scan, break from loop
6004 * and this will be the first channel
6007 if (channels[channel - 1] != 0)
6010 channels[channel - 1] = 1;
6011 priv->speed_scan_pos++;
6013 scan->channels_list[channel_index] = channel;
6015 ipw_channel_to_index(priv->ieee, channel);
6016 ipw_set_scan_type(scan, channel_index,
6019 IEEE80211_CH_PASSIVE_ONLY ?
6020 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6024 for (i = 0; i < geo->bg_channels; i++) {
6025 if ((priv->status & STATUS_ASSOCIATED) &&
6026 geo->bg[i].channel == priv->channel)
6029 scan->channels_list[channel_index] =
6031 ipw_set_scan_type(scan, channel_index,
6034 IEEE80211_CH_PASSIVE_ONLY ?
6035 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6040 if (start != channel_index) {
6041 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6042 (channel_index - start);
6047 static int ipw_request_scan(struct ipw_priv *priv)
6049 struct ipw_scan_request_ext scan;
6050 int err = 0, scan_type;
6052 if (!(priv->status & STATUS_INIT) ||
6053 (priv->status & STATUS_EXIT_PENDING))
6058 if (priv->status & STATUS_SCANNING) {
6059 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
6060 priv->status |= STATUS_SCAN_PENDING;
6064 if (!(priv->status & STATUS_SCAN_FORCED) &&
6065 priv->status & STATUS_SCAN_ABORTING) {
6066 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6067 priv->status |= STATUS_SCAN_PENDING;
6071 if (priv->status & STATUS_RF_KILL_MASK) {
6072 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6073 priv->status |= STATUS_SCAN_PENDING;
6077 memset(&scan, 0, sizeof(scan));
6079 if (priv->config & CFG_SPEED_SCAN)
6080 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6083 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6086 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6088 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6090 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6092 #ifdef CONFIG_IPW2200_MONITOR
6093 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6097 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
6098 case IEEE80211_52GHZ_BAND:
6099 band = (u8) (IPW_A_MODE << 6) | 1;
6100 channel = priv->channel;
6103 case IEEE80211_24GHZ_BAND:
6104 band = (u8) (IPW_B_MODE << 6) | 1;
6105 channel = priv->channel;
6109 band = (u8) (IPW_B_MODE << 6) | 1;
6114 scan.channels_list[0] = band;
6115 scan.channels_list[1] = channel;
6116 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6118 /* NOTE: The card will sit on this channel for this time
6119 * period. Scan aborts are timing sensitive and frequently
6120 * result in firmware restarts. As such, it is best to
6121 * set a small dwell_time here and just keep re-issuing
6122 * scans. Otherwise fast channel hopping will not actually
6125 * TODO: Move SPEED SCAN support to all modes and bands */
6126 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6129 #endif /* CONFIG_IPW2200_MONITOR */
6130 /* If we are roaming, then make this a directed scan for the
6131 * current network. Otherwise, ensure that every other scan
6132 * is a fast channel hop scan */
6133 if ((priv->status & STATUS_ROAMING)
6134 || (!(priv->status & STATUS_ASSOCIATED)
6135 && (priv->config & CFG_STATIC_ESSID)
6136 && (le32_to_cpu(scan.full_scan_index) % 2))) {
6137 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6139 IPW_DEBUG_HC("Attempt to send SSID command "
6144 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6146 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6148 ipw_add_scan_channels(priv, &scan, scan_type);
6149 #ifdef CONFIG_IPW2200_MONITOR
6153 err = ipw_send_scan_request_ext(priv, &scan);
6155 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6159 priv->status |= STATUS_SCANNING;
6160 priv->status &= ~STATUS_SCAN_PENDING;
6161 queue_delayed_work(priv->workqueue, &priv->scan_check,
6162 IPW_SCAN_CHECK_WATCHDOG);
6168 static void ipw_bg_abort_scan(void *data)
6170 struct ipw_priv *priv = data;
6172 ipw_abort_scan(data);
6176 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6178 /* This is called when wpa_supplicant loads and closes the driver
6180 priv->ieee->wpa_enabled = value;
6184 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6186 struct ieee80211_device *ieee = priv->ieee;
6187 struct ieee80211_security sec = {
6188 .flags = SEC_AUTH_MODE,
6192 if (value & IW_AUTH_ALG_SHARED_KEY) {
6193 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6195 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6196 sec.auth_mode = WLAN_AUTH_OPEN;
6201 if (ieee->set_security)
6202 ieee->set_security(ieee->dev, &sec);
6209 void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie, int wpa_ie_len)
6211 /* make sure WPA is enabled */
6212 ipw_wpa_enable(priv, 1);
6214 ipw_disassociate(priv);
6217 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6218 char *capabilities, int length)
6220 struct host_cmd cmd = {
6221 .cmd = IPW_CMD_RSN_CAPABILITIES,
6225 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6227 memcpy(cmd.param, capabilities, length);
6228 return ipw_send_cmd(priv, &cmd);
6236 static int ipw_wx_set_genie(struct net_device *dev,
6237 struct iw_request_info *info,
6238 union iwreq_data *wrqu, char *extra)
6240 struct ipw_priv *priv = ieee80211_priv(dev);
6241 struct ieee80211_device *ieee = priv->ieee;
6245 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6246 (wrqu->data.length && extra == NULL))
6251 //if (!ieee->wpa_enabled) {
6252 // err = -EOPNOTSUPP;
6256 if (wrqu->data.length) {
6257 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6263 memcpy(buf, extra, wrqu->data.length);
6264 kfree(ieee->wpa_ie);
6266 ieee->wpa_ie_len = wrqu->data.length;
6268 kfree(ieee->wpa_ie);
6269 ieee->wpa_ie = NULL;
6270 ieee->wpa_ie_len = 0;
6273 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6280 static int ipw_wx_get_genie(struct net_device *dev,
6281 struct iw_request_info *info,
6282 union iwreq_data *wrqu, char *extra)
6284 struct ipw_priv *priv = ieee80211_priv(dev);
6285 struct ieee80211_device *ieee = priv->ieee;
6290 //if (!ieee->wpa_enabled) {
6291 // err = -EOPNOTSUPP;
6295 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6296 wrqu->data.length = 0;
6300 if (wrqu->data.length < ieee->wpa_ie_len) {
6305 wrqu->data.length = ieee->wpa_ie_len;
6306 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6313 static int wext_cipher2level(int cipher)
6316 case IW_AUTH_CIPHER_NONE:
6318 case IW_AUTH_CIPHER_WEP40:
6319 case IW_AUTH_CIPHER_WEP104:
6321 case IW_AUTH_CIPHER_TKIP:
6323 case IW_AUTH_CIPHER_CCMP:
6331 static int ipw_wx_set_auth(struct net_device *dev,
6332 struct iw_request_info *info,
6333 union iwreq_data *wrqu, char *extra)
6335 struct ipw_priv *priv = ieee80211_priv(dev);
6336 struct ieee80211_device *ieee = priv->ieee;
6337 struct iw_param *param = &wrqu->param;
6338 struct ieee80211_crypt_data *crypt;
6339 unsigned long flags;
6342 switch (param->flags & IW_AUTH_INDEX) {
6343 case IW_AUTH_WPA_VERSION:
6345 case IW_AUTH_CIPHER_PAIRWISE:
6346 ipw_set_hw_decrypt_unicast(priv,
6347 wext_cipher2level(param->value));
6349 case IW_AUTH_CIPHER_GROUP:
6350 ipw_set_hw_decrypt_multicast(priv,
6351 wext_cipher2level(param->value));
6353 case IW_AUTH_KEY_MGMT:
6355 * ipw2200 does not use these parameters
6359 case IW_AUTH_TKIP_COUNTERMEASURES:
6360 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6361 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6364 flags = crypt->ops->get_flags(crypt->priv);
6367 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6369 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6371 crypt->ops->set_flags(flags, crypt->priv);
6375 case IW_AUTH_DROP_UNENCRYPTED:{
6378 * wpa_supplicant calls set_wpa_enabled when the driver
6379 * is loaded and unloaded, regardless of if WPA is being
6380 * used. No other calls are made which can be used to
6381 * determine if encryption will be used or not prior to
6382 * association being expected. If encryption is not being
6383 * used, drop_unencrypted is set to false, else true -- we
6384 * can use this to determine if the CAP_PRIVACY_ON bit should
6387 struct ieee80211_security sec = {
6388 .flags = SEC_ENABLED,
6389 .enabled = param->value,
6391 priv->ieee->drop_unencrypted = param->value;
6392 /* We only change SEC_LEVEL for open mode. Others
6393 * are set by ipw_wpa_set_encryption.
6395 if (!param->value) {
6396 sec.flags |= SEC_LEVEL;
6397 sec.level = SEC_LEVEL_0;
6399 sec.flags |= SEC_LEVEL;
6400 sec.level = SEC_LEVEL_1;
6402 if (priv->ieee->set_security)
6403 priv->ieee->set_security(priv->ieee->dev, &sec);
6407 case IW_AUTH_80211_AUTH_ALG:
6408 ret = ipw_wpa_set_auth_algs(priv, param->value);
6411 case IW_AUTH_WPA_ENABLED:
6412 ret = ipw_wpa_enable(priv, param->value);
6415 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6416 ieee->ieee802_1x = param->value;
6419 //case IW_AUTH_ROAMING_CONTROL:
6420 case IW_AUTH_PRIVACY_INVOKED:
6421 ieee->privacy_invoked = param->value;
6431 static int ipw_wx_get_auth(struct net_device *dev,
6432 struct iw_request_info *info,
6433 union iwreq_data *wrqu, char *extra)
6435 struct ipw_priv *priv = ieee80211_priv(dev);
6436 struct ieee80211_device *ieee = priv->ieee;
6437 struct ieee80211_crypt_data *crypt;
6438 struct iw_param *param = &wrqu->param;
6441 switch (param->flags & IW_AUTH_INDEX) {
6442 case IW_AUTH_WPA_VERSION:
6443 case IW_AUTH_CIPHER_PAIRWISE:
6444 case IW_AUTH_CIPHER_GROUP:
6445 case IW_AUTH_KEY_MGMT:
6447 * wpa_supplicant will control these internally
6452 case IW_AUTH_TKIP_COUNTERMEASURES:
6453 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6454 if (!crypt || !crypt->ops->get_flags)
6457 param->value = (crypt->ops->get_flags(crypt->priv) &
6458 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6462 case IW_AUTH_DROP_UNENCRYPTED:
6463 param->value = ieee->drop_unencrypted;
6466 case IW_AUTH_80211_AUTH_ALG:
6467 param->value = ieee->sec.auth_mode;
6470 case IW_AUTH_WPA_ENABLED:
6471 param->value = ieee->wpa_enabled;
6474 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6475 param->value = ieee->ieee802_1x;
6478 case IW_AUTH_ROAMING_CONTROL:
6479 case IW_AUTH_PRIVACY_INVOKED:
6480 param->value = ieee->privacy_invoked;
6489 /* SIOCSIWENCODEEXT */
6490 static int ipw_wx_set_encodeext(struct net_device *dev,
6491 struct iw_request_info *info,
6492 union iwreq_data *wrqu, char *extra)
6494 struct ipw_priv *priv = ieee80211_priv(dev);
6495 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6498 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6499 /* IPW HW can't build TKIP MIC,
6500 host decryption still needed */
6501 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6502 priv->ieee->host_mc_decrypt = 1;
6504 priv->ieee->host_encrypt = 0;
6505 priv->ieee->host_encrypt_msdu = 1;
6506 priv->ieee->host_decrypt = 1;
6509 priv->ieee->host_encrypt = 0;
6510 priv->ieee->host_encrypt_msdu = 0;
6511 priv->ieee->host_decrypt = 0;
6512 priv->ieee->host_mc_decrypt = 0;
6516 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6519 /* SIOCGIWENCODEEXT */
6520 static int ipw_wx_get_encodeext(struct net_device *dev,
6521 struct iw_request_info *info,
6522 union iwreq_data *wrqu, char *extra)
6524 struct ipw_priv *priv = ieee80211_priv(dev);
6525 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6529 static int ipw_wx_set_mlme(struct net_device *dev,
6530 struct iw_request_info *info,
6531 union iwreq_data *wrqu, char *extra)
6533 struct ipw_priv *priv = ieee80211_priv(dev);
6534 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6537 reason = cpu_to_le16(mlme->reason_code);
6539 switch (mlme->cmd) {
6540 case IW_MLME_DEAUTH:
6544 case IW_MLME_DISASSOC:
6545 ipw_disassociate(priv);
6554 #ifdef CONFIG_IPW_QOS
6558 * get the modulation type of the current network or
6559 * the card current mode
6561 u8 ipw_qos_current_mode(struct ipw_priv * priv)
6565 if (priv->status & STATUS_ASSOCIATED) {
6566 unsigned long flags;
6568 spin_lock_irqsave(&priv->ieee->lock, flags);
6569 mode = priv->assoc_network->mode;
6570 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6572 mode = priv->ieee->mode;
6574 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6579 * Handle management frame beacon and probe response
6581 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6583 struct ieee80211_network *network)
6585 u32 size = sizeof(struct ieee80211_qos_parameters);
6587 if (network->capability & WLAN_CAPABILITY_IBSS)
6588 network->qos_data.active = network->qos_data.supported;
6590 if (network->flags & NETWORK_HAS_QOS_MASK) {
6591 if (active_network &&
6592 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6593 network->qos_data.active = network->qos_data.supported;
6595 if ((network->qos_data.active == 1) && (active_network == 1) &&
6596 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6597 (network->qos_data.old_param_count !=
6598 network->qos_data.param_count)) {
6599 network->qos_data.old_param_count =
6600 network->qos_data.param_count;
6601 schedule_work(&priv->qos_activate);
6602 IPW_DEBUG_QOS("QoS parameters change call "
6606 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6607 memcpy(&network->qos_data.parameters,
6608 &def_parameters_CCK, size);
6610 memcpy(&network->qos_data.parameters,
6611 &def_parameters_OFDM, size);
6613 if ((network->qos_data.active == 1) && (active_network == 1)) {
6614 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6615 schedule_work(&priv->qos_activate);
6618 network->qos_data.active = 0;
6619 network->qos_data.supported = 0;
6621 if ((priv->status & STATUS_ASSOCIATED) &&
6622 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6623 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6624 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6625 !(network->flags & NETWORK_EMPTY_ESSID))
6626 if ((network->ssid_len ==
6627 priv->assoc_network->ssid_len) &&
6628 !memcmp(network->ssid,
6629 priv->assoc_network->ssid,
6630 network->ssid_len)) {
6631 queue_work(priv->workqueue,
6632 &priv->merge_networks);
6640 * This function set up the firmware to support QoS. It sends
6641 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6643 static int ipw_qos_activate(struct ipw_priv *priv,
6644 struct ieee80211_qos_data *qos_network_data)
6647 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6648 struct ieee80211_qos_parameters *active_one = NULL;
6649 u32 size = sizeof(struct ieee80211_qos_parameters);
6654 type = ipw_qos_current_mode(priv);
6656 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6657 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6658 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6659 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6661 if (qos_network_data == NULL) {
6662 if (type == IEEE_B) {
6663 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6664 active_one = &def_parameters_CCK;
6666 active_one = &def_parameters_OFDM;
6668 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6669 burst_duration = ipw_qos_get_burst_duration(priv);
6670 for (i = 0; i < QOS_QUEUE_NUM; i++)
6671 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6672 (u16) burst_duration;
6673 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6674 if (type == IEEE_B) {
6675 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6677 if (priv->qos_data.qos_enable == 0)
6678 active_one = &def_parameters_CCK;
6680 active_one = priv->qos_data.def_qos_parm_CCK;
6682 if (priv->qos_data.qos_enable == 0)
6683 active_one = &def_parameters_OFDM;
6685 active_one = priv->qos_data.def_qos_parm_OFDM;
6687 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6689 unsigned long flags;
6692 spin_lock_irqsave(&priv->ieee->lock, flags);
6693 active_one = &(qos_network_data->parameters);
6694 qos_network_data->old_param_count =
6695 qos_network_data->param_count;
6696 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6697 active = qos_network_data->supported;
6698 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6701 burst_duration = ipw_qos_get_burst_duration(priv);
6702 for (i = 0; i < QOS_QUEUE_NUM; i++)
6703 qos_parameters[QOS_PARAM_SET_ACTIVE].
6704 tx_op_limit[i] = (u16) burst_duration;
6708 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6709 err = ipw_send_qos_params_command(priv,
6710 (struct ieee80211_qos_parameters *)
6711 &(qos_parameters[0]));
6713 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6719 * send IPW_CMD_WME_INFO to the firmware
6721 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6724 struct ieee80211_qos_information_element qos_info;
6729 qos_info.elementID = QOS_ELEMENT_ID;
6730 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6732 qos_info.version = QOS_VERSION_1;
6733 qos_info.ac_info = 0;
6735 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6736 qos_info.qui_type = QOS_OUI_TYPE;
6737 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6739 ret = ipw_send_qos_info_command(priv, &qos_info);
6741 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6747 * Set the QoS parameter with the association request structure
6749 static int ipw_qos_association(struct ipw_priv *priv,
6750 struct ieee80211_network *network)
6753 struct ieee80211_qos_data *qos_data = NULL;
6754 struct ieee80211_qos_data ibss_data = {
6759 switch (priv->ieee->iw_mode) {
6761 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6764 qos_data = &ibss_data;
6768 qos_data = &network->qos_data;
6776 err = ipw_qos_activate(priv, qos_data);
6778 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6782 if (priv->qos_data.qos_enable && qos_data->supported) {
6783 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6784 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6785 return ipw_qos_set_info_element(priv);
6792 * handling the beaconing responces. if we get different QoS setting
6793 * of the network from the the associated setting adjust the QoS
6796 static int ipw_qos_association_resp(struct ipw_priv *priv,
6797 struct ieee80211_network *network)
6800 unsigned long flags;
6801 u32 size = sizeof(struct ieee80211_qos_parameters);
6802 int set_qos_param = 0;
6804 if ((priv == NULL) || (network == NULL) ||
6805 (priv->assoc_network == NULL))
6808 if (!(priv->status & STATUS_ASSOCIATED))
6811 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
6814 spin_lock_irqsave(&priv->ieee->lock, flags);
6815 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
6816 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
6817 sizeof(struct ieee80211_qos_data));
6818 priv->assoc_network->qos_data.active = 1;
6819 if ((network->qos_data.old_param_count !=
6820 network->qos_data.param_count)) {
6822 network->qos_data.old_param_count =
6823 network->qos_data.param_count;
6827 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6828 memcpy(&priv->assoc_network->qos_data.parameters,
6829 &def_parameters_CCK, size);
6831 memcpy(&priv->assoc_network->qos_data.parameters,
6832 &def_parameters_OFDM, size);
6833 priv->assoc_network->qos_data.active = 0;
6834 priv->assoc_network->qos_data.supported = 0;
6838 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6840 if (set_qos_param == 1)
6841 schedule_work(&priv->qos_activate);
6846 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6853 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
6854 ret = priv->qos_data.burst_duration_CCK;
6856 ret = priv->qos_data.burst_duration_OFDM;
6862 * Initialize the setting of QoS global
6864 static void ipw_qos_init(struct ipw_priv *priv, int enable,
6865 int burst_enable, u32 burst_duration_CCK,
6866 u32 burst_duration_OFDM)
6868 priv->qos_data.qos_enable = enable;
6870 if (priv->qos_data.qos_enable) {
6871 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6872 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6873 IPW_DEBUG_QOS("QoS is enabled\n");
6875 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6876 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6877 IPW_DEBUG_QOS("QoS is not enabled\n");
6880 priv->qos_data.burst_enable = burst_enable;
6883 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6884 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6886 priv->qos_data.burst_duration_CCK = 0;
6887 priv->qos_data.burst_duration_OFDM = 0;
6892 * map the packet priority to the right TX Queue
6894 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6896 if (priority > 7 || !priv->qos_data.qos_enable)
6899 return from_priority_to_tx_queue[priority] - 1;
6903 * add QoS parameter to the TX command
6905 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6907 struct tfd_data *tfd, u8 unicast)
6910 int tx_queue_id = 0;
6911 struct ieee80211_qos_data *qos_data = NULL;
6912 int active, supported;
6913 unsigned long flags;
6915 if (!(priv->status & STATUS_ASSOCIATED))
6918 qos_data = &priv->assoc_network->qos_data;
6920 spin_lock_irqsave(&priv->ieee->lock, flags);
6922 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6924 qos_data->active = 0;
6926 qos_data->active = qos_data->supported;
6929 active = qos_data->active;
6930 supported = qos_data->supported;
6932 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6934 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
6936 priv->qos_data.qos_enable, active, supported, unicast);
6937 if (active && priv->qos_data.qos_enable) {
6938 ret = from_priority_to_tx_queue[priority];
6939 tx_queue_id = ret - 1;
6940 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6941 if (priority <= 7) {
6942 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6943 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6944 tfd->tfd.tfd_26.mchdr.frame_ctl |=
6945 IEEE80211_STYPE_QOS_DATA;
6947 if (priv->qos_data.qos_no_ack_mask &
6948 (1UL << tx_queue_id)) {
6949 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6950 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6960 * background support to run QoS activate functionality
6962 static void ipw_bg_qos_activate(void *data)
6964 struct ipw_priv *priv = data;
6971 if (priv->status & STATUS_ASSOCIATED)
6972 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6977 static int ipw_handle_probe_response(struct net_device *dev,
6978 struct ieee80211_probe_response *resp,
6979 struct ieee80211_network *network)
6981 struct ipw_priv *priv = ieee80211_priv(dev);
6982 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6983 (network == priv->assoc_network));
6985 ipw_qos_handle_probe_response(priv, active_network, network);
6990 static int ipw_handle_beacon(struct net_device *dev,
6991 struct ieee80211_beacon *resp,
6992 struct ieee80211_network *network)
6994 struct ipw_priv *priv = ieee80211_priv(dev);
6995 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6996 (network == priv->assoc_network));
6998 ipw_qos_handle_probe_response(priv, active_network, network);
7003 static int ipw_handle_assoc_response(struct net_device *dev,
7004 struct ieee80211_assoc_response *resp,
7005 struct ieee80211_network *network)
7007 struct ipw_priv *priv = ieee80211_priv(dev);
7008 ipw_qos_association_resp(priv, network);
7012 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7015 struct host_cmd cmd = {
7016 .cmd = IPW_CMD_QOS_PARAMETERS,
7017 .len = (sizeof(struct ieee80211_qos_parameters) * 3)
7020 memcpy(cmd.param, qos_param, sizeof(*qos_param) * 3);
7021 return ipw_send_cmd(priv, &cmd);
7024 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7027 struct host_cmd cmd = {
7028 .cmd = IPW_CMD_WME_INFO,
7029 .len = sizeof(*qos_param)
7032 memcpy(cmd.param, qos_param, sizeof(*qos_param));
7033 return ipw_send_cmd(priv, &cmd);
7036 #endif /* CONFIG_IPW_QOS */
7038 static int ipw_associate_network(struct ipw_priv *priv,
7039 struct ieee80211_network *network,
7040 struct ipw_supported_rates *rates, int roaming)
7044 if (priv->config & CFG_FIXED_RATE)
7045 ipw_set_fixed_rate(priv, network->mode);
7047 if (!(priv->config & CFG_STATIC_ESSID)) {
7048 priv->essid_len = min(network->ssid_len,
7049 (u8) IW_ESSID_MAX_SIZE);
7050 memcpy(priv->essid, network->ssid, priv->essid_len);
7053 network->last_associate = jiffies;
7055 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7056 priv->assoc_request.channel = network->channel;
7057 if ((priv->capability & CAP_PRIVACY_ON) &&
7058 (priv->capability & CAP_SHARED_KEY)) {
7059 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7060 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7062 if ((priv->capability & CAP_PRIVACY_ON) &&
7063 (priv->ieee->sec.level == SEC_LEVEL_1) &&
7064 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
7065 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7067 priv->assoc_request.auth_type = AUTH_OPEN;
7068 priv->assoc_request.auth_key = 0;
7071 if (priv->ieee->wpa_ie_len) {
7072 priv->assoc_request.policy_support = 0x02; /* RSN active */
7073 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7074 priv->ieee->wpa_ie_len);
7078 * It is valid for our ieee device to support multiple modes, but
7079 * when it comes to associating to a given network we have to choose
7082 if (network->mode & priv->ieee->mode & IEEE_A)
7083 priv->assoc_request.ieee_mode = IPW_A_MODE;
7084 else if (network->mode & priv->ieee->mode & IEEE_G)
7085 priv->assoc_request.ieee_mode = IPW_G_MODE;
7086 else if (network->mode & priv->ieee->mode & IEEE_B)
7087 priv->assoc_request.ieee_mode = IPW_B_MODE;
7089 priv->assoc_request.capability = network->capability;
7090 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7091 && !(priv->config & CFG_PREAMBLE_LONG)) {
7092 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7094 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7096 /* Clear the short preamble if we won't be supporting it */
7097 priv->assoc_request.capability &=
7098 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7101 /* Clear capability bits that aren't used in Ad Hoc */
7102 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7103 priv->assoc_request.capability &=
7104 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7106 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7107 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7108 roaming ? "Rea" : "A",
7109 escape_essid(priv->essid, priv->essid_len),
7111 ipw_modes[priv->assoc_request.ieee_mode],
7113 (priv->assoc_request.preamble_length ==
7114 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7115 network->capability &
7116 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7117 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7118 priv->capability & CAP_PRIVACY_ON ?
7119 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7121 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7122 priv->capability & CAP_PRIVACY_ON ?
7123 '1' + priv->ieee->sec.active_key : '.',
7124 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7126 priv->assoc_request.beacon_interval = network->beacon_interval;
7127 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7128 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7129 priv->assoc_request.assoc_type = HC_IBSS_START;
7130 priv->assoc_request.assoc_tsf_msw = 0;
7131 priv->assoc_request.assoc_tsf_lsw = 0;
7133 if (unlikely(roaming))
7134 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7136 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7137 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7138 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7141 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7143 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7144 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7145 priv->assoc_request.atim_window = network->atim_window;
7147 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7148 priv->assoc_request.atim_window = 0;
7151 priv->assoc_request.listen_interval = network->listen_interval;
7153 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7155 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7159 rates->ieee_mode = priv->assoc_request.ieee_mode;
7160 rates->purpose = IPW_RATE_CONNECT;
7161 ipw_send_supported_rates(priv, rates);
7163 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7164 priv->sys_config.dot11g_auto_detection = 1;
7166 priv->sys_config.dot11g_auto_detection = 0;
7168 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7169 priv->sys_config.answer_broadcast_ssid_probe = 1;
7171 priv->sys_config.answer_broadcast_ssid_probe = 0;
7173 err = ipw_send_system_config(priv, &priv->sys_config);
7175 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7179 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7180 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7182 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7187 * If preemption is enabled, it is possible for the association
7188 * to complete before we return from ipw_send_associate. Therefore
7189 * we have to be sure and update our priviate data first.
7191 priv->channel = network->channel;
7192 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7193 priv->status |= STATUS_ASSOCIATING;
7194 priv->status &= ~STATUS_SECURITY_UPDATED;
7196 priv->assoc_network = network;
7198 #ifdef CONFIG_IPW_QOS
7199 ipw_qos_association(priv, network);
7202 err = ipw_send_associate(priv, &priv->assoc_request);
7204 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7208 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7209 escape_essid(priv->essid, priv->essid_len),
7210 MAC_ARG(priv->bssid));
7215 static void ipw_roam(void *data)
7217 struct ipw_priv *priv = data;
7218 struct ieee80211_network *network = NULL;
7219 struct ipw_network_match match = {
7220 .network = priv->assoc_network
7223 /* The roaming process is as follows:
7225 * 1. Missed beacon threshold triggers the roaming process by
7226 * setting the status ROAM bit and requesting a scan.
7227 * 2. When the scan completes, it schedules the ROAM work
7228 * 3. The ROAM work looks at all of the known networks for one that
7229 * is a better network than the currently associated. If none
7230 * found, the ROAM process is over (ROAM bit cleared)
7231 * 4. If a better network is found, a disassociation request is
7233 * 5. When the disassociation completes, the roam work is again
7234 * scheduled. The second time through, the driver is no longer
7235 * associated, and the newly selected network is sent an
7236 * association request.
7237 * 6. At this point ,the roaming process is complete and the ROAM
7238 * status bit is cleared.
7241 /* If we are no longer associated, and the roaming bit is no longer
7242 * set, then we are not actively roaming, so just return */
7243 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7246 if (priv->status & STATUS_ASSOCIATED) {
7247 /* First pass through ROAM process -- look for a better
7249 unsigned long flags;
7250 u8 rssi = priv->assoc_network->stats.rssi;
7251 priv->assoc_network->stats.rssi = -128;
7252 spin_lock_irqsave(&priv->ieee->lock, flags);
7253 list_for_each_entry(network, &priv->ieee->network_list, list) {
7254 if (network != priv->assoc_network)
7255 ipw_best_network(priv, &match, network, 1);
7257 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7258 priv->assoc_network->stats.rssi = rssi;
7260 if (match.network == priv->assoc_network) {
7261 IPW_DEBUG_ASSOC("No better APs in this network to "
7263 priv->status &= ~STATUS_ROAMING;
7264 ipw_debug_config(priv);
7268 ipw_send_disassociate(priv, 1);
7269 priv->assoc_network = match.network;
7274 /* Second pass through ROAM process -- request association */
7275 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7276 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7277 priv->status &= ~STATUS_ROAMING;
7280 static void ipw_bg_roam(void *data)
7282 struct ipw_priv *priv = data;
7288 static int ipw_associate(void *data)
7290 struct ipw_priv *priv = data;
7292 struct ieee80211_network *network = NULL;
7293 struct ipw_network_match match = {
7296 struct ipw_supported_rates *rates;
7297 struct list_head *element;
7298 unsigned long flags;
7300 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7301 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7305 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7306 IPW_DEBUG_ASSOC("Not attempting association (already in "
7311 if (priv->status & STATUS_DISASSOCIATING) {
7312 IPW_DEBUG_ASSOC("Not attempting association (in "
7313 "disassociating)\n ");
7314 queue_work(priv->workqueue, &priv->associate);
7318 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7319 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7324 if (!(priv->config & CFG_ASSOCIATE) &&
7325 !(priv->config & (CFG_STATIC_ESSID |
7326 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7327 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7331 /* Protect our use of the network_list */
7332 spin_lock_irqsave(&priv->ieee->lock, flags);
7333 list_for_each_entry(network, &priv->ieee->network_list, list)
7334 ipw_best_network(priv, &match, network, 0);
7336 network = match.network;
7337 rates = &match.rates;
7339 if (network == NULL &&
7340 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7341 priv->config & CFG_ADHOC_CREATE &&
7342 priv->config & CFG_STATIC_ESSID &&
7343 priv->config & CFG_STATIC_CHANNEL &&
7344 !list_empty(&priv->ieee->network_free_list)) {
7345 element = priv->ieee->network_free_list.next;
7346 network = list_entry(element, struct ieee80211_network, list);
7347 ipw_adhoc_create(priv, network);
7348 rates = &priv->rates;
7350 list_add_tail(&network->list, &priv->ieee->network_list);
7352 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7354 /* If we reached the end of the list, then we don't have any valid
7357 ipw_debug_config(priv);
7359 if (!(priv->status & STATUS_SCANNING)) {
7360 if (!(priv->config & CFG_SPEED_SCAN))
7361 queue_delayed_work(priv->workqueue,
7362 &priv->request_scan,
7365 queue_work(priv->workqueue,
7366 &priv->request_scan);
7372 ipw_associate_network(priv, network, rates, 0);
7377 static void ipw_bg_associate(void *data)
7379 struct ipw_priv *priv = data;
7381 ipw_associate(data);
7385 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7386 struct sk_buff *skb)
7388 struct ieee80211_hdr *hdr;
7391 hdr = (struct ieee80211_hdr *)skb->data;
7392 fc = le16_to_cpu(hdr->frame_ctl);
7393 if (!(fc & IEEE80211_FCTL_PROTECTED))
7396 fc &= ~IEEE80211_FCTL_PROTECTED;
7397 hdr->frame_ctl = cpu_to_le16(fc);
7398 switch (priv->ieee->sec.level) {
7400 /* Remove CCMP HDR */
7401 memmove(skb->data + IEEE80211_3ADDR_LEN,
7402 skb->data + IEEE80211_3ADDR_LEN + 8,
7403 skb->len - IEEE80211_3ADDR_LEN - 8);
7404 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7410 memmove(skb->data + IEEE80211_3ADDR_LEN,
7411 skb->data + IEEE80211_3ADDR_LEN + 4,
7412 skb->len - IEEE80211_3ADDR_LEN - 4);
7413 skb_trim(skb, skb->len - 8); /* IV + ICV */
7418 printk(KERN_ERR "Unknow security level %d\n",
7419 priv->ieee->sec.level);
7424 static void ipw_handle_data_packet(struct ipw_priv *priv,
7425 struct ipw_rx_mem_buffer *rxb,
7426 struct ieee80211_rx_stats *stats)
7428 struct ieee80211_hdr_4addr *hdr;
7429 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7431 /* We received data from the HW, so stop the watchdog */
7432 priv->net_dev->trans_start = jiffies;
7434 /* We only process data packets if the
7435 * interface is open */
7436 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7437 skb_tailroom(rxb->skb))) {
7438 priv->ieee->stats.rx_errors++;
7439 priv->wstats.discard.misc++;
7440 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7442 } else if (unlikely(!netif_running(priv->net_dev))) {
7443 priv->ieee->stats.rx_dropped++;
7444 priv->wstats.discard.misc++;
7445 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7449 /* Advance skb->data to the start of the actual payload */
7450 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7452 /* Set the size of the skb to the size of the frame */
7453 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7455 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7457 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7458 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7459 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7460 ((is_multicast_ether_addr(hdr->addr1) ||
7461 is_broadcast_ether_addr(hdr->addr1)) ?
7462 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7463 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7465 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7466 priv->ieee->stats.rx_errors++;
7467 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7469 __ipw_led_activity_on(priv);
7473 #ifdef CONFIG_IEEE80211_RADIOTAP
7474 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7475 struct ipw_rx_mem_buffer *rxb,
7476 struct ieee80211_rx_stats *stats)
7478 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7479 struct ipw_rx_frame *frame = &pkt->u.frame;
7481 /* initial pull of some data */
7482 u16 received_channel = frame->received_channel;
7483 u8 antennaAndPhy = frame->antennaAndPhy;
7484 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7485 u16 pktrate = frame->rate;
7487 /* Magic struct that slots into the radiotap header -- no reason
7488 * to build this manually element by element, we can write it much
7489 * more efficiently than we can parse it. ORDER MATTERS HERE */
7491 struct ieee80211_radiotap_header rt_hdr;
7492 u8 rt_flags; /* radiotap packet flags */
7493 u8 rt_rate; /* rate in 500kb/s */
7494 u16 rt_channel; /* channel in mhz */
7495 u16 rt_chbitmask; /* channel bitfield */
7496 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7497 u8 rt_antenna; /* antenna number */
7500 short len = le16_to_cpu(pkt->u.frame.length);
7502 /* We received data from the HW, so stop the watchdog */
7503 priv->net_dev->trans_start = jiffies;
7505 /* We only process data packets if the
7506 * interface is open */
7507 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7508 skb_tailroom(rxb->skb))) {
7509 priv->ieee->stats.rx_errors++;
7510 priv->wstats.discard.misc++;
7511 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7513 } else if (unlikely(!netif_running(priv->net_dev))) {
7514 priv->ieee->stats.rx_dropped++;
7515 priv->wstats.discard.misc++;
7516 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7520 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7522 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7523 /* FIXME: Should alloc bigger skb instead */
7524 priv->ieee->stats.rx_dropped++;
7525 priv->wstats.discard.misc++;
7526 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7530 /* copy the frame itself */
7531 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7532 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7534 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7535 * part of our real header, saves a little time.
7537 * No longer necessary since we fill in all our data. Purge before merging
7539 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7540 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7543 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7545 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7546 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7547 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7549 /* Big bitfield of all the fields we provide in radiotap */
7550 ipw_rt->rt_hdr.it_present =
7551 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7552 (1 << IEEE80211_RADIOTAP_RATE) |
7553 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7554 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7555 (1 << IEEE80211_RADIOTAP_ANTENNA));
7557 /* Zero the flags, we'll add to them as we go */
7558 ipw_rt->rt_flags = 0;
7560 /* Convert signal to DBM */
7561 ipw_rt->rt_dbmsignal = antsignal;
7563 /* Convert the channel data and set the flags */
7564 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7565 if (received_channel > 14) { /* 802.11a */
7566 ipw_rt->rt_chbitmask =
7567 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7568 } else if (antennaAndPhy & 32) { /* 802.11b */
7569 ipw_rt->rt_chbitmask =
7570 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7571 } else { /* 802.11g */
7572 ipw_rt->rt_chbitmask =
7573 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7576 /* set the rate in multiples of 500k/s */
7578 case IPW_TX_RATE_1MB:
7579 ipw_rt->rt_rate = 2;
7581 case IPW_TX_RATE_2MB:
7582 ipw_rt->rt_rate = 4;
7584 case IPW_TX_RATE_5MB:
7585 ipw_rt->rt_rate = 10;
7587 case IPW_TX_RATE_6MB:
7588 ipw_rt->rt_rate = 12;
7590 case IPW_TX_RATE_9MB:
7591 ipw_rt->rt_rate = 18;
7593 case IPW_TX_RATE_11MB:
7594 ipw_rt->rt_rate = 22;
7596 case IPW_TX_RATE_12MB:
7597 ipw_rt->rt_rate = 24;
7599 case IPW_TX_RATE_18MB:
7600 ipw_rt->rt_rate = 36;
7602 case IPW_TX_RATE_24MB:
7603 ipw_rt->rt_rate = 48;
7605 case IPW_TX_RATE_36MB:
7606 ipw_rt->rt_rate = 72;
7608 case IPW_TX_RATE_48MB:
7609 ipw_rt->rt_rate = 96;
7611 case IPW_TX_RATE_54MB:
7612 ipw_rt->rt_rate = 108;
7615 ipw_rt->rt_rate = 0;
7619 /* antenna number */
7620 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7622 /* set the preamble flag if we have it */
7623 if ((antennaAndPhy & 64))
7624 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7626 /* Set the size of the skb to the size of the frame */
7627 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7629 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7631 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7632 priv->ieee->stats.rx_errors++;
7633 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7635 /* no LED during capture */
7640 static inline int is_network_packet(struct ipw_priv *priv,
7641 struct ieee80211_hdr_4addr *header)
7643 /* Filter incoming packets to determine if they are targetted toward
7644 * this network, discarding packets coming from ourselves */
7645 switch (priv->ieee->iw_mode) {
7646 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
7647 /* packets from our adapter are dropped (echo) */
7648 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7651 /* {broad,multi}cast packets to our BSSID go through */
7652 if (is_multicast_ether_addr(header->addr1) ||
7653 is_broadcast_ether_addr(header->addr1))
7654 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
7656 /* packets to our adapter go through */
7657 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7660 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
7661 /* packets from our adapter are dropped (echo) */
7662 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7665 /* {broad,multi}cast packets to our BSS go through */
7666 if (is_multicast_ether_addr(header->addr1) ||
7667 is_broadcast_ether_addr(header->addr1))
7668 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7670 /* packets to our adapter go through */
7671 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7678 #define IPW_PACKET_RETRY_TIME HZ
7680 static inline int is_duplicate_packet(struct ipw_priv *priv,
7681 struct ieee80211_hdr_4addr *header)
7683 u16 sc = le16_to_cpu(header->seq_ctl);
7684 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7685 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7686 u16 *last_seq, *last_frag;
7687 unsigned long *last_time;
7689 switch (priv->ieee->iw_mode) {
7692 struct list_head *p;
7693 struct ipw_ibss_seq *entry = NULL;
7694 u8 *mac = header->addr2;
7695 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7697 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7699 list_entry(p, struct ipw_ibss_seq, list);
7700 if (!memcmp(entry->mac, mac, ETH_ALEN))
7703 if (p == &priv->ibss_mac_hash[index]) {
7704 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7707 ("Cannot malloc new mac entry\n");
7710 memcpy(entry->mac, mac, ETH_ALEN);
7711 entry->seq_num = seq;
7712 entry->frag_num = frag;
7713 entry->packet_time = jiffies;
7714 list_add(&entry->list,
7715 &priv->ibss_mac_hash[index]);
7718 last_seq = &entry->seq_num;
7719 last_frag = &entry->frag_num;
7720 last_time = &entry->packet_time;
7724 last_seq = &priv->last_seq_num;
7725 last_frag = &priv->last_frag_num;
7726 last_time = &priv->last_packet_time;
7731 if ((*last_seq == seq) &&
7732 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7733 if (*last_frag == frag)
7735 if (*last_frag + 1 != frag)
7736 /* out-of-order fragment */
7742 *last_time = jiffies;
7746 /* Comment this line now since we observed the card receives
7747 * duplicate packets but the FCTL_RETRY bit is not set in the
7748 * IBSS mode with fragmentation enabled.
7749 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
7753 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7754 struct ipw_rx_mem_buffer *rxb,
7755 struct ieee80211_rx_stats *stats)
7757 struct sk_buff *skb = rxb->skb;
7758 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7759 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7760 (skb->data + IPW_RX_FRAME_SIZE);
7762 ieee80211_rx_mgt(priv->ieee, header, stats);
7764 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7765 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7766 IEEE80211_STYPE_PROBE_RESP) ||
7767 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7768 IEEE80211_STYPE_BEACON))) {
7769 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7770 ipw_add_station(priv, header->addr2);
7773 if (priv->config & CFG_NET_STATS) {
7774 IPW_DEBUG_HC("sending stat packet\n");
7776 /* Set the size of the skb to the size of the full
7777 * ipw header and 802.11 frame */
7778 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7781 /* Advance past the ipw packet header to the 802.11 frame */
7782 skb_pull(skb, IPW_RX_FRAME_SIZE);
7784 /* Push the ieee80211_rx_stats before the 802.11 frame */
7785 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7787 skb->dev = priv->ieee->dev;
7789 /* Point raw at the ieee80211_stats */
7790 skb->mac.raw = skb->data;
7792 skb->pkt_type = PACKET_OTHERHOST;
7793 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7794 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7801 * Main entry function for recieving a packet with 80211 headers. This
7802 * should be called when ever the FW has notified us that there is a new
7803 * skb in the recieve queue.
7805 static void ipw_rx(struct ipw_priv *priv)
7807 struct ipw_rx_mem_buffer *rxb;
7808 struct ipw_rx_packet *pkt;
7809 struct ieee80211_hdr_4addr *header;
7813 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7814 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
7815 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7818 rxb = priv->rxq->queue[i];
7819 #ifdef CONFIG_IPW_DEBUG
7820 if (unlikely(rxb == NULL)) {
7821 printk(KERN_CRIT "Queue not allocated!\n");
7825 priv->rxq->queue[i] = NULL;
7827 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
7829 PCI_DMA_FROMDEVICE);
7831 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7832 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7833 pkt->header.message_type,
7834 pkt->header.rx_seq_num, pkt->header.control_bits);
7836 switch (pkt->header.message_type) {
7837 case RX_FRAME_TYPE: /* 802.11 frame */ {
7838 struct ieee80211_rx_stats stats = {
7840 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7843 le16_to_cpu(pkt->u.frame.signal),
7845 le16_to_cpu(pkt->u.frame.noise),
7846 .rate = pkt->u.frame.rate,
7847 .mac_time = jiffies,
7849 pkt->u.frame.received_channel,
7852 control & (1 << 0)) ?
7853 IEEE80211_24GHZ_BAND :
7854 IEEE80211_52GHZ_BAND,
7855 .len = le16_to_cpu(pkt->u.frame.length),
7858 if (stats.rssi != 0)
7859 stats.mask |= IEEE80211_STATMASK_RSSI;
7860 if (stats.signal != 0)
7861 stats.mask |= IEEE80211_STATMASK_SIGNAL;
7862 if (stats.noise != 0)
7863 stats.mask |= IEEE80211_STATMASK_NOISE;
7864 if (stats.rate != 0)
7865 stats.mask |= IEEE80211_STATMASK_RATE;
7869 #ifdef CONFIG_IPW2200_MONITOR
7870 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7871 #ifdef CONFIG_IEEE80211_RADIOTAP
7872 ipw_handle_data_packet_monitor(priv,
7876 ipw_handle_data_packet(priv, rxb,
7884 (struct ieee80211_hdr_4addr *)(rxb->skb->
7887 /* TODO: Check Ad-Hoc dest/source and make sure
7888 * that we are actually parsing these packets
7889 * correctly -- we should probably use the
7890 * frame control of the packet and disregard
7891 * the current iw_mode */
7894 is_network_packet(priv, header);
7895 if (network_packet && priv->assoc_network) {
7896 priv->assoc_network->stats.rssi =
7898 average_add(&priv->average_rssi,
7900 priv->last_rx_rssi = stats.rssi;
7903 IPW_DEBUG_RX("Frame: len=%u\n",
7904 le16_to_cpu(pkt->u.frame.length));
7906 if (le16_to_cpu(pkt->u.frame.length) <
7907 frame_hdr_len(header)) {
7909 ("Received packet is too small. "
7911 priv->ieee->stats.rx_errors++;
7912 priv->wstats.discard.misc++;
7916 switch (WLAN_FC_GET_TYPE
7917 (le16_to_cpu(header->frame_ctl))) {
7919 case IEEE80211_FTYPE_MGMT:
7920 ipw_handle_mgmt_packet(priv, rxb,
7924 case IEEE80211_FTYPE_CTL:
7927 case IEEE80211_FTYPE_DATA:
7928 if (unlikely(!network_packet ||
7929 is_duplicate_packet(priv,
7932 IPW_DEBUG_DROP("Dropping: "
7945 ipw_handle_data_packet(priv, rxb,
7953 case RX_HOST_NOTIFICATION_TYPE:{
7955 ("Notification: subtype=%02X flags=%02X size=%d\n",
7956 pkt->u.notification.subtype,
7957 pkt->u.notification.flags,
7958 pkt->u.notification.size);
7959 ipw_rx_notification(priv, &pkt->u.notification);
7964 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7965 pkt->header.message_type);
7969 /* For now we just don't re-use anything. We can tweak this
7970 * later to try and re-use notification packets and SKBs that
7971 * fail to Rx correctly */
7972 if (rxb->skb != NULL) {
7973 dev_kfree_skb_any(rxb->skb);
7977 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
7978 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
7979 list_add_tail(&rxb->list, &priv->rxq->rx_used);
7981 i = (i + 1) % RX_QUEUE_SIZE;
7984 /* Backtrack one entry */
7985 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7987 ipw_rx_queue_restock(priv);
7990 #define DEFAULT_RTS_THRESHOLD 2304U
7991 #define MIN_RTS_THRESHOLD 1U
7992 #define MAX_RTS_THRESHOLD 2304U
7993 #define DEFAULT_BEACON_INTERVAL 100U
7994 #define DEFAULT_SHORT_RETRY_LIMIT 7U
7995 #define DEFAULT_LONG_RETRY_LIMIT 4U
7997 static int ipw_sw_reset(struct ipw_priv *priv, int init)
7999 int band, modulation;
8000 int old_mode = priv->ieee->iw_mode;
8002 /* Initialize module parameter values here */
8005 /* We default to disabling the LED code as right now it causes
8006 * too many systems to lock up... */
8008 priv->config |= CFG_NO_LED;
8011 priv->config |= CFG_ASSOCIATE;
8013 IPW_DEBUG_INFO("Auto associate disabled.\n");
8016 priv->config |= CFG_ADHOC_CREATE;
8018 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8021 priv->status |= STATUS_RF_KILL_SW;
8022 IPW_DEBUG_INFO("Radio disabled.\n");
8026 priv->config |= CFG_STATIC_CHANNEL;
8027 priv->channel = channel;
8028 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8029 /* TODO: Validate that provided channel is in range */
8031 #ifdef CONFIG_IPW_QOS
8032 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8033 burst_duration_CCK, burst_duration_OFDM);
8034 #endif /* CONFIG_IPW_QOS */
8038 priv->ieee->iw_mode = IW_MODE_ADHOC;
8039 priv->net_dev->type = ARPHRD_ETHER;
8042 #ifdef CONFIG_IPW2200_MONITOR
8044 priv->ieee->iw_mode = IW_MODE_MONITOR;
8045 #ifdef CONFIG_IEEE80211_RADIOTAP
8046 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8048 priv->net_dev->type = ARPHRD_IEEE80211;
8054 priv->net_dev->type = ARPHRD_ETHER;
8055 priv->ieee->iw_mode = IW_MODE_INFRA;
8060 priv->ieee->host_encrypt = 0;
8061 priv->ieee->host_encrypt_msdu = 0;
8062 priv->ieee->host_decrypt = 0;
8063 priv->ieee->host_mc_decrypt = 0;
8065 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8067 /* IPW2200/2915 is abled to do hardware fragmentation. */
8068 priv->ieee->host_open_frag = 0;
8070 if ((priv->pci_dev->device == 0x4223) ||
8071 (priv->pci_dev->device == 0x4224)) {
8073 printk(KERN_INFO DRV_NAME
8074 ": Detected Intel PRO/Wireless 2915ABG Network "
8076 priv->ieee->abg_true = 1;
8077 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8078 modulation = IEEE80211_OFDM_MODULATION |
8079 IEEE80211_CCK_MODULATION;
8080 priv->adapter = IPW_2915ABG;
8081 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8084 printk(KERN_INFO DRV_NAME
8085 ": Detected Intel PRO/Wireless 2200BG Network "
8088 priv->ieee->abg_true = 0;
8089 band = IEEE80211_24GHZ_BAND;
8090 modulation = IEEE80211_OFDM_MODULATION |
8091 IEEE80211_CCK_MODULATION;
8092 priv->adapter = IPW_2200BG;
8093 priv->ieee->mode = IEEE_G | IEEE_B;
8096 priv->ieee->freq_band = band;
8097 priv->ieee->modulation = modulation;
8099 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8101 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8102 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8104 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8105 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8106 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8108 /* If power management is turned on, default to AC mode */
8109 priv->power_mode = IPW_POWER_AC;
8110 priv->tx_power = IPW_TX_POWER_DEFAULT;
8112 return old_mode == priv->ieee->iw_mode;
8116 * This file defines the Wireless Extension handlers. It does not
8117 * define any methods of hardware manipulation and relies on the
8118 * functions defined in ipw_main to provide the HW interaction.
8120 * The exception to this is the use of the ipw_get_ordinal()
8121 * function used to poll the hardware vs. making unecessary calls.
8125 static int ipw_wx_get_name(struct net_device *dev,
8126 struct iw_request_info *info,
8127 union iwreq_data *wrqu, char *extra)
8129 struct ipw_priv *priv = ieee80211_priv(dev);
8131 if (priv->status & STATUS_RF_KILL_MASK)
8132 strcpy(wrqu->name, "radio off");
8133 else if (!(priv->status & STATUS_ASSOCIATED))
8134 strcpy(wrqu->name, "unassociated");
8136 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8137 ipw_modes[priv->assoc_request.ieee_mode]);
8138 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8143 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8146 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8147 priv->config &= ~CFG_STATIC_CHANNEL;
8148 IPW_DEBUG_ASSOC("Attempting to associate with new "
8150 ipw_associate(priv);
8154 priv->config |= CFG_STATIC_CHANNEL;
8156 if (priv->channel == channel) {
8157 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8162 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8163 priv->channel = channel;
8165 #ifdef CONFIG_IPW2200_MONITOR
8166 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8168 if (priv->status & STATUS_SCANNING) {
8169 IPW_DEBUG_SCAN("Scan abort triggered due to "
8170 "channel change.\n");
8171 ipw_abort_scan(priv);
8174 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8177 if (priv->status & STATUS_SCANNING)
8178 IPW_DEBUG_SCAN("Still scanning...\n");
8180 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8185 #endif /* CONFIG_IPW2200_MONITOR */
8187 /* Network configuration changed -- force [re]association */
8188 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8189 if (!ipw_disassociate(priv))
8190 ipw_associate(priv);
8195 static int ipw_wx_set_freq(struct net_device *dev,
8196 struct iw_request_info *info,
8197 union iwreq_data *wrqu, char *extra)
8199 struct ipw_priv *priv = ieee80211_priv(dev);
8200 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8201 struct iw_freq *fwrq = &wrqu->freq;
8207 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8209 ret = ipw_set_channel(priv, 0);
8213 /* if setting by freq convert to channel */
8215 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
8221 if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8224 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8225 i = ipw_channel_to_index(priv->ieee, channel);
8229 flags = (band == IEEE80211_24GHZ_BAND) ?
8230 geo->bg[i].flags : geo->a[i].flags;
8231 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8232 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8237 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8239 ret = ipw_set_channel(priv, channel);
8244 static int ipw_wx_get_freq(struct net_device *dev,
8245 struct iw_request_info *info,
8246 union iwreq_data *wrqu, char *extra)
8248 struct ipw_priv *priv = ieee80211_priv(dev);
8252 /* If we are associated, trying to associate, or have a statically
8253 * configured CHANNEL then return that; otherwise return ANY */
8255 if (priv->config & CFG_STATIC_CHANNEL ||
8256 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8257 wrqu->freq.m = priv->channel;
8262 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8266 static int ipw_wx_set_mode(struct net_device *dev,
8267 struct iw_request_info *info,
8268 union iwreq_data *wrqu, char *extra)
8270 struct ipw_priv *priv = ieee80211_priv(dev);
8273 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8275 switch (wrqu->mode) {
8276 #ifdef CONFIG_IPW2200_MONITOR
8277 case IW_MODE_MONITOR:
8283 wrqu->mode = IW_MODE_INFRA;
8288 if (wrqu->mode == priv->ieee->iw_mode)
8293 ipw_sw_reset(priv, 0);
8295 #ifdef CONFIG_IPW2200_MONITOR
8296 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8297 priv->net_dev->type = ARPHRD_ETHER;
8299 if (wrqu->mode == IW_MODE_MONITOR)
8300 #ifdef CONFIG_IEEE80211_RADIOTAP
8301 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8303 priv->net_dev->type = ARPHRD_IEEE80211;
8305 #endif /* CONFIG_IPW2200_MONITOR */
8307 /* Free the existing firmware and reset the fw_loaded
8308 * flag so ipw_load() will bring in the new firmawre */
8311 priv->ieee->iw_mode = wrqu->mode;
8313 queue_work(priv->workqueue, &priv->adapter_restart);
8318 static int ipw_wx_get_mode(struct net_device *dev,
8319 struct iw_request_info *info,
8320 union iwreq_data *wrqu, char *extra)
8322 struct ipw_priv *priv = ieee80211_priv(dev);
8324 wrqu->mode = priv->ieee->iw_mode;
8325 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8330 /* Values are in microsecond */
8331 static const s32 timeout_duration[] = {
8339 static const s32 period_duration[] = {
8347 static int ipw_wx_get_range(struct net_device *dev,
8348 struct iw_request_info *info,
8349 union iwreq_data *wrqu, char *extra)
8351 struct ipw_priv *priv = ieee80211_priv(dev);
8352 struct iw_range *range = (struct iw_range *)extra;
8353 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8356 wrqu->data.length = sizeof(*range);
8357 memset(range, 0, sizeof(*range));
8359 /* 54Mbs == ~27 Mb/s real (802.11g) */
8360 range->throughput = 27 * 1000 * 1000;
8362 range->max_qual.qual = 100;
8363 /* TODO: Find real max RSSI and stick here */
8364 range->max_qual.level = 0;
8365 range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
8366 range->max_qual.updated = 7; /* Updated all three */
8368 range->avg_qual.qual = 70;
8369 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8370 range->avg_qual.level = 0; /* FIXME to real average level */
8371 range->avg_qual.noise = 0;
8372 range->avg_qual.updated = 7; /* Updated all three */
8374 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8376 for (i = 0; i < range->num_bitrates; i++)
8377 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8380 range->max_rts = DEFAULT_RTS_THRESHOLD;
8381 range->min_frag = MIN_FRAG_THRESHOLD;
8382 range->max_frag = MAX_FRAG_THRESHOLD;
8384 range->encoding_size[0] = 5;
8385 range->encoding_size[1] = 13;
8386 range->num_encoding_sizes = 2;
8387 range->max_encoding_tokens = WEP_KEYS;
8389 /* Set the Wireless Extension versions */
8390 range->we_version_compiled = WIRELESS_EXT;
8391 range->we_version_source = 16;
8394 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8395 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8397 range->freq[i].i = geo->bg[j].channel;
8398 range->freq[i].m = geo->bg[j].freq * 100000;
8399 range->freq[i].e = 1;
8403 if (priv->ieee->mode & IEEE_A) {
8404 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8406 range->freq[i].i = geo->a[j].channel;
8407 range->freq[i].m = geo->a[j].freq * 100000;
8408 range->freq[i].e = 1;
8412 range->num_channels = i;
8413 range->num_frequency = i;
8417 /* Event capability (kernel + driver) */
8418 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8419 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8420 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8421 range->event_capa[1] = IW_EVENT_CAPA_K_1;
8423 IPW_DEBUG_WX("GET Range\n");
8427 static int ipw_wx_set_wap(struct net_device *dev,
8428 struct iw_request_info *info,
8429 union iwreq_data *wrqu, char *extra)
8431 struct ipw_priv *priv = ieee80211_priv(dev);
8433 static const unsigned char any[] = {
8434 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8436 static const unsigned char off[] = {
8437 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8440 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8443 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8444 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8445 /* we disable mandatory BSSID association */
8446 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8447 priv->config &= ~CFG_STATIC_BSSID;
8448 IPW_DEBUG_ASSOC("Attempting to associate with new "
8450 ipw_associate(priv);
8455 priv->config |= CFG_STATIC_BSSID;
8456 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8457 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8462 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8463 MAC_ARG(wrqu->ap_addr.sa_data));
8465 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8467 /* Network configuration changed -- force [re]association */
8468 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8469 if (!ipw_disassociate(priv))
8470 ipw_associate(priv);
8476 static int ipw_wx_get_wap(struct net_device *dev,
8477 struct iw_request_info *info,
8478 union iwreq_data *wrqu, char *extra)
8480 struct ipw_priv *priv = ieee80211_priv(dev);
8481 /* If we are associated, trying to associate, or have a statically
8482 * configured BSSID then return that; otherwise return ANY */
8484 if (priv->config & CFG_STATIC_BSSID ||
8485 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8486 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8487 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8489 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8491 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8492 MAC_ARG(wrqu->ap_addr.sa_data));
8497 static int ipw_wx_set_essid(struct net_device *dev,
8498 struct iw_request_info *info,
8499 union iwreq_data *wrqu, char *extra)
8501 struct ipw_priv *priv = ieee80211_priv(dev);
8502 char *essid = ""; /* ANY */
8505 if (wrqu->essid.flags && wrqu->essid.length) {
8506 length = wrqu->essid.length - 1;
8510 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8511 if ((priv->config & CFG_STATIC_ESSID) &&
8512 !(priv->status & (STATUS_ASSOCIATED |
8513 STATUS_ASSOCIATING))) {
8514 IPW_DEBUG_ASSOC("Attempting to associate with new "
8516 priv->config &= ~CFG_STATIC_ESSID;
8517 ipw_associate(priv);
8523 length = min(length, IW_ESSID_MAX_SIZE);
8525 priv->config |= CFG_STATIC_ESSID;
8527 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8528 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8533 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8536 priv->essid_len = length;
8537 memcpy(priv->essid, essid, priv->essid_len);
8539 /* Network configuration changed -- force [re]association */
8540 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8541 if (!ipw_disassociate(priv))
8542 ipw_associate(priv);
8548 static int ipw_wx_get_essid(struct net_device *dev,
8549 struct iw_request_info *info,
8550 union iwreq_data *wrqu, char *extra)
8552 struct ipw_priv *priv = ieee80211_priv(dev);
8554 /* If we are associated, trying to associate, or have a statically
8555 * configured ESSID then return that; otherwise return ANY */
8557 if (priv->config & CFG_STATIC_ESSID ||
8558 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8559 IPW_DEBUG_WX("Getting essid: '%s'\n",
8560 escape_essid(priv->essid, priv->essid_len));
8561 memcpy(extra, priv->essid, priv->essid_len);
8562 wrqu->essid.length = priv->essid_len;
8563 wrqu->essid.flags = 1; /* active */
8565 IPW_DEBUG_WX("Getting essid: ANY\n");
8566 wrqu->essid.length = 0;
8567 wrqu->essid.flags = 0; /* active */
8573 static int ipw_wx_set_nick(struct net_device *dev,
8574 struct iw_request_info *info,
8575 union iwreq_data *wrqu, char *extra)
8577 struct ipw_priv *priv = ieee80211_priv(dev);
8579 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8580 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8583 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
8584 memset(priv->nick, 0, sizeof(priv->nick));
8585 memcpy(priv->nick, extra, wrqu->data.length);
8586 IPW_DEBUG_TRACE("<<\n");
8592 static int ipw_wx_get_nick(struct net_device *dev,
8593 struct iw_request_info *info,
8594 union iwreq_data *wrqu, char *extra)
8596 struct ipw_priv *priv = ieee80211_priv(dev);
8597 IPW_DEBUG_WX("Getting nick\n");
8599 wrqu->data.length = strlen(priv->nick) + 1;
8600 memcpy(extra, priv->nick, wrqu->data.length);
8601 wrqu->data.flags = 1; /* active */
8606 static int ipw_wx_set_rate(struct net_device *dev,
8607 struct iw_request_info *info,
8608 union iwreq_data *wrqu, char *extra)
8610 /* TODO: We should use semaphores or locks for access to priv */
8611 struct ipw_priv *priv = ieee80211_priv(dev);
8612 u32 target_rate = wrqu->bitrate.value;
8615 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8616 /* value = X, fixed = 1 means only rate X */
8617 /* value = X, fixed = 0 means all rates lower equal X */
8619 if (target_rate == -1) {
8621 mask = IEEE80211_DEFAULT_RATES_MASK;
8622 /* Now we should reassociate */
8627 fixed = wrqu->bitrate.fixed;
8629 if (target_rate == 1000000 || !fixed)
8630 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8631 if (target_rate == 1000000)
8634 if (target_rate == 2000000 || !fixed)
8635 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8636 if (target_rate == 2000000)
8639 if (target_rate == 5500000 || !fixed)
8640 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8641 if (target_rate == 5500000)
8644 if (target_rate == 6000000 || !fixed)
8645 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8646 if (target_rate == 6000000)
8649 if (target_rate == 9000000 || !fixed)
8650 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8651 if (target_rate == 9000000)
8654 if (target_rate == 11000000 || !fixed)
8655 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8656 if (target_rate == 11000000)
8659 if (target_rate == 12000000 || !fixed)
8660 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8661 if (target_rate == 12000000)
8664 if (target_rate == 18000000 || !fixed)
8665 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8666 if (target_rate == 18000000)
8669 if (target_rate == 24000000 || !fixed)
8670 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8671 if (target_rate == 24000000)
8674 if (target_rate == 36000000 || !fixed)
8675 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8676 if (target_rate == 36000000)
8679 if (target_rate == 48000000 || !fixed)
8680 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8681 if (target_rate == 48000000)
8684 if (target_rate == 54000000 || !fixed)
8685 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8686 if (target_rate == 54000000)
8689 IPW_DEBUG_WX("invalid rate specified, returning error\n");
8693 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8694 mask, fixed ? "fixed" : "sub-rates");
8696 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
8697 priv->config &= ~CFG_FIXED_RATE;
8698 ipw_set_fixed_rate(priv, priv->ieee->mode);
8700 priv->config |= CFG_FIXED_RATE;
8702 if (priv->rates_mask == mask) {
8703 IPW_DEBUG_WX("Mask set to current mask.\n");
8708 priv->rates_mask = mask;
8710 /* Network configuration changed -- force [re]association */
8711 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8712 if (!ipw_disassociate(priv))
8713 ipw_associate(priv);
8719 static int ipw_wx_get_rate(struct net_device *dev,
8720 struct iw_request_info *info,
8721 union iwreq_data *wrqu, char *extra)
8723 struct ipw_priv *priv = ieee80211_priv(dev);
8725 wrqu->bitrate.value = priv->last_rate;
8727 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8731 static int ipw_wx_set_rts(struct net_device *dev,
8732 struct iw_request_info *info,
8733 union iwreq_data *wrqu, char *extra)
8735 struct ipw_priv *priv = ieee80211_priv(dev);
8737 if (wrqu->rts.disabled)
8738 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8740 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
8741 wrqu->rts.value > MAX_RTS_THRESHOLD) {
8745 priv->rts_threshold = wrqu->rts.value;
8748 ipw_send_rts_threshold(priv, priv->rts_threshold);
8750 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8754 static int ipw_wx_get_rts(struct net_device *dev,
8755 struct iw_request_info *info,
8756 union iwreq_data *wrqu, char *extra)
8758 struct ipw_priv *priv = ieee80211_priv(dev);
8760 wrqu->rts.value = priv->rts_threshold;
8761 wrqu->rts.fixed = 0; /* no auto select */
8762 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
8764 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8768 static int ipw_wx_set_txpow(struct net_device *dev,
8769 struct iw_request_info *info,
8770 union iwreq_data *wrqu, char *extra)
8772 struct ipw_priv *priv = ieee80211_priv(dev);
8776 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
8781 if (!wrqu->power.fixed)
8782 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8784 if (wrqu->power.flags != IW_TXPOW_DBM) {
8789 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
8790 (wrqu->power.value < IPW_TX_POWER_MIN)) {
8795 priv->tx_power = wrqu->power.value;
8796 err = ipw_set_tx_power(priv);
8802 static int ipw_wx_get_txpow(struct net_device *dev,
8803 struct iw_request_info *info,
8804 union iwreq_data *wrqu, char *extra)
8806 struct ipw_priv *priv = ieee80211_priv(dev);
8808 wrqu->power.value = priv->tx_power;
8809 wrqu->power.fixed = 1;
8810 wrqu->power.flags = IW_TXPOW_DBM;
8811 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
8814 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
8815 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
8820 static int ipw_wx_set_frag(struct net_device *dev,
8821 struct iw_request_info *info,
8822 union iwreq_data *wrqu, char *extra)
8824 struct ipw_priv *priv = ieee80211_priv(dev);
8826 if (wrqu->frag.disabled)
8827 priv->ieee->fts = DEFAULT_FTS;
8829 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
8830 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8835 priv->ieee->fts = wrqu->frag.value & ~0x1;
8838 ipw_send_frag_threshold(priv, wrqu->frag.value);
8840 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8844 static int ipw_wx_get_frag(struct net_device *dev,
8845 struct iw_request_info *info,
8846 union iwreq_data *wrqu, char *extra)
8848 struct ipw_priv *priv = ieee80211_priv(dev);
8850 wrqu->frag.value = priv->ieee->fts;
8851 wrqu->frag.fixed = 0; /* no auto select */
8852 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
8854 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8859 static int ipw_wx_set_retry(struct net_device *dev,
8860 struct iw_request_info *info,
8861 union iwreq_data *wrqu, char *extra)
8863 struct ipw_priv *priv = ieee80211_priv(dev);
8865 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8868 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8871 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8875 if (wrqu->retry.flags & IW_RETRY_MIN)
8876 priv->short_retry_limit = (u8) wrqu->retry.value;
8877 else if (wrqu->retry.flags & IW_RETRY_MAX)
8878 priv->long_retry_limit = (u8) wrqu->retry.value;
8880 priv->short_retry_limit = (u8) wrqu->retry.value;
8881 priv->long_retry_limit = (u8) wrqu->retry.value;
8884 ipw_send_retry_limit(priv, priv->short_retry_limit,
8885 priv->long_retry_limit);
8887 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8888 priv->short_retry_limit, priv->long_retry_limit);
8892 static int ipw_wx_get_retry(struct net_device *dev,
8893 struct iw_request_info *info,
8894 union iwreq_data *wrqu, char *extra)
8896 struct ipw_priv *priv = ieee80211_priv(dev);
8899 wrqu->retry.disabled = 0;
8901 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
8906 if (wrqu->retry.flags & IW_RETRY_MAX) {
8907 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8908 wrqu->retry.value = priv->long_retry_limit;
8909 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8910 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8911 wrqu->retry.value = priv->short_retry_limit;
8913 wrqu->retry.flags = IW_RETRY_LIMIT;
8914 wrqu->retry.value = priv->short_retry_limit;
8918 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8923 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8926 struct ipw_scan_request_ext scan;
8927 int err = 0, scan_type;
8929 if (!(priv->status & STATUS_INIT) ||
8930 (priv->status & STATUS_EXIT_PENDING))
8935 if (priv->status & STATUS_RF_KILL_MASK) {
8936 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8937 priv->status |= STATUS_SCAN_PENDING;
8941 IPW_DEBUG_HC("starting request direct scan!\n");
8943 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
8944 err = wait_event_interruptible(priv->wait_state,
8946 status & (STATUS_SCANNING |
8947 STATUS_SCAN_ABORTING)));
8949 IPW_DEBUG_HC("aborting direct scan");
8953 memset(&scan, 0, sizeof(scan));
8955 if (priv->config & CFG_SPEED_SCAN)
8956 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8959 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8962 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8964 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8965 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8967 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8969 err = ipw_send_ssid(priv, essid, essid_len);
8971 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8974 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8976 ipw_add_scan_channels(priv, &scan, scan_type);
8978 err = ipw_send_scan_request_ext(priv, &scan);
8980 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8984 priv->status |= STATUS_SCANNING;
8991 static int ipw_wx_set_scan(struct net_device *dev,
8992 struct iw_request_info *info,
8993 union iwreq_data *wrqu, char *extra)
8995 struct ipw_priv *priv = ieee80211_priv(dev);
8996 struct iw_scan_req *req = NULL;
8997 if (wrqu->data.length
8998 && wrqu->data.length == sizeof(struct iw_scan_req)) {
8999 req = (struct iw_scan_req *)extra;
9000 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9001 ipw_request_direct_scan(priv, req->essid,
9007 IPW_DEBUG_WX("Start scan\n");
9009 queue_work(priv->workqueue, &priv->request_scan);
9014 static int ipw_wx_get_scan(struct net_device *dev,
9015 struct iw_request_info *info,
9016 union iwreq_data *wrqu, char *extra)
9018 struct ipw_priv *priv = ieee80211_priv(dev);
9019 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9022 static int ipw_wx_set_encode(struct net_device *dev,
9023 struct iw_request_info *info,
9024 union iwreq_data *wrqu, char *key)
9026 struct ipw_priv *priv = ieee80211_priv(dev);
9028 u32 cap = priv->capability;
9031 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9033 /* In IBSS mode, we need to notify the firmware to update
9034 * the beacon info after we changed the capability. */
9035 if (cap != priv->capability &&
9036 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9037 priv->status & STATUS_ASSOCIATED)
9038 ipw_disassociate(priv);
9044 static int ipw_wx_get_encode(struct net_device *dev,
9045 struct iw_request_info *info,
9046 union iwreq_data *wrqu, char *key)
9048 struct ipw_priv *priv = ieee80211_priv(dev);
9049 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9052 static int ipw_wx_set_power(struct net_device *dev,
9053 struct iw_request_info *info,
9054 union iwreq_data *wrqu, char *extra)
9056 struct ipw_priv *priv = ieee80211_priv(dev);
9059 if (wrqu->power.disabled) {
9060 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9061 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9063 IPW_DEBUG_WX("failed setting power mode.\n");
9067 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9072 switch (wrqu->power.flags & IW_POWER_MODE) {
9073 case IW_POWER_ON: /* If not specified */
9074 case IW_POWER_MODE: /* If set all mask */
9075 case IW_POWER_ALL_R: /* If explicitely state all */
9077 default: /* Otherwise we don't support it */
9078 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9084 /* If the user hasn't specified a power management mode yet, default
9086 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9087 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9089 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9090 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9092 IPW_DEBUG_WX("failed setting power mode.\n");
9097 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9102 static int ipw_wx_get_power(struct net_device *dev,
9103 struct iw_request_info *info,
9104 union iwreq_data *wrqu, char *extra)
9106 struct ipw_priv *priv = ieee80211_priv(dev);
9108 if (!(priv->power_mode & IPW_POWER_ENABLED))
9109 wrqu->power.disabled = 1;
9111 wrqu->power.disabled = 0;
9114 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9119 static int ipw_wx_set_powermode(struct net_device *dev,
9120 struct iw_request_info *info,
9121 union iwreq_data *wrqu, char *extra)
9123 struct ipw_priv *priv = ieee80211_priv(dev);
9124 int mode = *(int *)extra;
9127 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9128 mode = IPW_POWER_AC;
9129 priv->power_mode = mode;
9131 priv->power_mode = IPW_POWER_ENABLED | mode;
9134 if (priv->power_mode != mode) {
9135 err = ipw_send_power_mode(priv, mode);
9138 IPW_DEBUG_WX("failed setting power mode.\n");
9147 #define MAX_WX_STRING 80
9148 static int ipw_wx_get_powermode(struct net_device *dev,
9149 struct iw_request_info *info,
9150 union iwreq_data *wrqu, char *extra)
9152 struct ipw_priv *priv = ieee80211_priv(dev);
9153 int level = IPW_POWER_LEVEL(priv->power_mode);
9156 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9160 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9162 case IPW_POWER_BATTERY:
9163 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9166 p += snprintf(p, MAX_WX_STRING - (p - extra),
9167 "(Timeout %dms, Period %dms)",
9168 timeout_duration[level - 1] / 1000,
9169 period_duration[level - 1] / 1000);
9172 if (!(priv->power_mode & IPW_POWER_ENABLED))
9173 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9175 wrqu->data.length = p - extra + 1;
9180 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9181 struct iw_request_info *info,
9182 union iwreq_data *wrqu, char *extra)
9184 struct ipw_priv *priv = ieee80211_priv(dev);
9185 int mode = *(int *)extra;
9186 u8 band = 0, modulation = 0;
9188 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9189 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9193 if (priv->adapter == IPW_2915ABG) {
9194 priv->ieee->abg_true = 1;
9195 if (mode & IEEE_A) {
9196 band |= IEEE80211_52GHZ_BAND;
9197 modulation |= IEEE80211_OFDM_MODULATION;
9199 priv->ieee->abg_true = 0;
9201 if (mode & IEEE_A) {
9202 IPW_WARNING("Attempt to set 2200BG into "
9208 priv->ieee->abg_true = 0;
9211 if (mode & IEEE_B) {
9212 band |= IEEE80211_24GHZ_BAND;
9213 modulation |= IEEE80211_CCK_MODULATION;
9215 priv->ieee->abg_true = 0;
9217 if (mode & IEEE_G) {
9218 band |= IEEE80211_24GHZ_BAND;
9219 modulation |= IEEE80211_OFDM_MODULATION;
9221 priv->ieee->abg_true = 0;
9223 priv->ieee->mode = mode;
9224 priv->ieee->freq_band = band;
9225 priv->ieee->modulation = modulation;
9226 init_supported_rates(priv, &priv->rates);
9228 /* Network configuration changed -- force [re]association */
9229 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9230 if (!ipw_disassociate(priv)) {
9231 ipw_send_supported_rates(priv, &priv->rates);
9232 ipw_associate(priv);
9235 /* Update the band LEDs */
9236 ipw_led_band_on(priv);
9238 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9239 mode & IEEE_A ? 'a' : '.',
9240 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9245 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9246 struct iw_request_info *info,
9247 union iwreq_data *wrqu, char *extra)
9249 struct ipw_priv *priv = ieee80211_priv(dev);
9251 switch (priv->ieee->mode) {
9253 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9256 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9258 case IEEE_A | IEEE_B:
9259 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9262 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9264 case IEEE_A | IEEE_G:
9265 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9267 case IEEE_B | IEEE_G:
9268 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9270 case IEEE_A | IEEE_B | IEEE_G:
9271 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9274 strncpy(extra, "unknown", MAX_WX_STRING);
9278 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9280 wrqu->data.length = strlen(extra) + 1;
9286 static int ipw_wx_set_preamble(struct net_device *dev,
9287 struct iw_request_info *info,
9288 union iwreq_data *wrqu, char *extra)
9290 struct ipw_priv *priv = ieee80211_priv(dev);
9291 int mode = *(int *)extra;
9293 /* Switching from SHORT -> LONG requires a disassociation */
9295 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9296 priv->config |= CFG_PREAMBLE_LONG;
9298 /* Network configuration changed -- force [re]association */
9300 ("[re]association triggered due to preamble change.\n");
9301 if (!ipw_disassociate(priv))
9302 ipw_associate(priv);
9308 priv->config &= ~CFG_PREAMBLE_LONG;
9319 static int ipw_wx_get_preamble(struct net_device *dev,
9320 struct iw_request_info *info,
9321 union iwreq_data *wrqu, char *extra)
9323 struct ipw_priv *priv = ieee80211_priv(dev);
9325 if (priv->config & CFG_PREAMBLE_LONG)
9326 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9328 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9333 #ifdef CONFIG_IPW2200_MONITOR
9334 static int ipw_wx_set_monitor(struct net_device *dev,
9335 struct iw_request_info *info,
9336 union iwreq_data *wrqu, char *extra)
9338 struct ipw_priv *priv = ieee80211_priv(dev);
9339 int *parms = (int *)extra;
9340 int enable = (parms[0] > 0);
9342 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9344 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9345 #ifdef CONFIG_IEEE80211_RADIOTAP
9346 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9348 priv->net_dev->type = ARPHRD_IEEE80211;
9350 queue_work(priv->workqueue, &priv->adapter_restart);
9353 ipw_set_channel(priv, parms[1]);
9355 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9359 priv->net_dev->type = ARPHRD_ETHER;
9360 queue_work(priv->workqueue, &priv->adapter_restart);
9366 #endif // CONFIG_IPW2200_MONITOR
9368 static int ipw_wx_reset(struct net_device *dev,
9369 struct iw_request_info *info,
9370 union iwreq_data *wrqu, char *extra)
9372 struct ipw_priv *priv = ieee80211_priv(dev);
9373 IPW_DEBUG_WX("RESET\n");
9374 queue_work(priv->workqueue, &priv->adapter_restart);
9378 static int ipw_wx_sw_reset(struct net_device *dev,
9379 struct iw_request_info *info,
9380 union iwreq_data *wrqu, char *extra)
9382 struct ipw_priv *priv = ieee80211_priv(dev);
9383 union iwreq_data wrqu_sec = {
9385 .flags = IW_ENCODE_DISABLED,
9390 IPW_DEBUG_WX("SW_RESET\n");
9394 ret = ipw_sw_reset(priv, 0);
9397 ipw_adapter_restart(priv);
9400 /* The SW reset bit might have been toggled on by the 'disable'
9401 * module parameter, so take appropriate action */
9402 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9405 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9408 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9409 /* Configuration likely changed -- force [re]association */
9410 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9412 if (!ipw_disassociate(priv))
9413 ipw_associate(priv);
9421 /* Rebase the WE IOCTLs to zero for the handler array */
9422 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9423 static iw_handler ipw_wx_handlers[] = {
9424 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9425 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9426 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9427 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9428 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9429 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9430 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9431 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9432 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9433 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9434 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9435 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9436 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9437 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9438 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9439 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9440 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9441 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9442 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9443 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9444 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9445 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9446 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9447 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9448 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9449 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9450 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9451 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9452 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9453 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9454 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9455 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9456 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9457 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9458 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9459 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9460 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9461 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9462 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9466 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9470 IPW_PRIV_SET_PREAMBLE,
9471 IPW_PRIV_GET_PREAMBLE,
9474 #ifdef CONFIG_IPW2200_MONITOR
9475 IPW_PRIV_SET_MONITOR,
9479 static struct iw_priv_args ipw_priv_args[] = {
9481 .cmd = IPW_PRIV_SET_POWER,
9482 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9483 .name = "set_power"},
9485 .cmd = IPW_PRIV_GET_POWER,
9486 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9487 .name = "get_power"},
9489 .cmd = IPW_PRIV_SET_MODE,
9490 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9491 .name = "set_mode"},
9493 .cmd = IPW_PRIV_GET_MODE,
9494 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9495 .name = "get_mode"},
9497 .cmd = IPW_PRIV_SET_PREAMBLE,
9498 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9499 .name = "set_preamble"},
9501 .cmd = IPW_PRIV_GET_PREAMBLE,
9502 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9503 .name = "get_preamble"},
9506 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9509 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9510 #ifdef CONFIG_IPW2200_MONITOR
9512 IPW_PRIV_SET_MONITOR,
9513 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9514 #endif /* CONFIG_IPW2200_MONITOR */
9517 static iw_handler ipw_priv_handler[] = {
9518 ipw_wx_set_powermode,
9519 ipw_wx_get_powermode,
9520 ipw_wx_set_wireless_mode,
9521 ipw_wx_get_wireless_mode,
9522 ipw_wx_set_preamble,
9523 ipw_wx_get_preamble,
9526 #ifdef CONFIG_IPW2200_MONITOR
9531 static struct iw_handler_def ipw_wx_handler_def = {
9532 .standard = ipw_wx_handlers,
9533 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9534 .num_private = ARRAY_SIZE(ipw_priv_handler),
9535 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9536 .private = ipw_priv_handler,
9537 .private_args = ipw_priv_args,
9538 .get_wireless_stats = ipw_get_wireless_stats,
9542 * Get wireless statistics.
9543 * Called by /proc/net/wireless
9544 * Also called by SIOCGIWSTATS
9546 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9548 struct ipw_priv *priv = ieee80211_priv(dev);
9549 struct iw_statistics *wstats;
9551 wstats = &priv->wstats;
9553 /* if hw is disabled, then ipw_get_ordinal() can't be called.
9554 * netdev->get_wireless_stats seems to be called before fw is
9555 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9556 * and associated; if not associcated, the values are all meaningless
9557 * anyway, so set them all to NULL and INVALID */
9558 if (!(priv->status & STATUS_ASSOCIATED)) {
9559 wstats->miss.beacon = 0;
9560 wstats->discard.retries = 0;
9561 wstats->qual.qual = 0;
9562 wstats->qual.level = 0;
9563 wstats->qual.noise = 0;
9564 wstats->qual.updated = 7;
9565 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9566 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9570 wstats->qual.qual = priv->quality;
9571 wstats->qual.level = average_value(&priv->average_rssi);
9572 wstats->qual.noise = average_value(&priv->average_noise);
9573 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9574 IW_QUAL_NOISE_UPDATED;
9576 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9577 wstats->discard.retries = priv->last_tx_failures;
9578 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9580 /* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9581 goto fail_get_ordinal;
9582 wstats->discard.retries += tx_retry; */
9587 /* net device stuff */
9589 static inline void init_sys_config(struct ipw_sys_config *sys_config)
9591 memset(sys_config, 0, sizeof(struct ipw_sys_config));
9592 sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
9593 sys_config->answer_broadcast_ssid_probe = 0;
9594 sys_config->accept_all_data_frames = 0;
9595 sys_config->accept_non_directed_frames = 1;
9596 sys_config->exclude_unicast_unencrypted = 0;
9597 sys_config->disable_unicast_decryption = 1;
9598 sys_config->exclude_multicast_unencrypted = 0;
9599 sys_config->disable_multicast_decryption = 1;
9600 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
9601 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
9602 sys_config->dot11g_auto_detection = 0;
9603 sys_config->enable_cts_to_self = 0;
9604 sys_config->bt_coexist_collision_thr = 0;
9605 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
9608 static int ipw_net_open(struct net_device *dev)
9610 struct ipw_priv *priv = ieee80211_priv(dev);
9611 IPW_DEBUG_INFO("dev->open\n");
9612 /* we should be verifying the device is ready to be opened */
9614 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9615 (priv->status & STATUS_ASSOCIATED))
9616 netif_start_queue(dev);
9621 static int ipw_net_stop(struct net_device *dev)
9623 IPW_DEBUG_INFO("dev->close\n");
9624 netif_stop_queue(dev);
9631 modify to send one tfd per fragment instead of using chunking. otherwise
9632 we need to heavily modify the ieee80211_skb_to_txb.
9635 static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9638 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9639 txb->fragments[0]->data;
9641 struct tfd_frame *tfd;
9642 #ifdef CONFIG_IPW_QOS
9643 int tx_id = ipw_get_tx_queue_number(priv, pri);
9644 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9646 struct clx2_tx_queue *txq = &priv->txq[0];
9648 struct clx2_queue *q = &txq->q;
9649 u8 id, hdr_len, unicast;
9650 u16 remaining_bytes;
9653 /* If there isn't room in the queue, we return busy and let the
9654 * network stack requeue the packet for us */
9655 if (ipw_queue_space(q) < q->high_mark)
9656 return NETDEV_TX_BUSY;
9658 switch (priv->ieee->iw_mode) {
9660 hdr_len = IEEE80211_3ADDR_LEN;
9661 unicast = !(is_multicast_ether_addr(hdr->addr1) ||
9662 is_broadcast_ether_addr(hdr->addr1));
9663 id = ipw_find_station(priv, hdr->addr1);
9664 if (id == IPW_INVALID_STATION) {
9665 id = ipw_add_station(priv, hdr->addr1);
9666 if (id == IPW_INVALID_STATION) {
9667 IPW_WARNING("Attempt to send data to "
9668 "invalid cell: " MAC_FMT "\n",
9669 MAC_ARG(hdr->addr1));
9677 unicast = !(is_multicast_ether_addr(hdr->addr3) ||
9678 is_broadcast_ether_addr(hdr->addr3));
9679 hdr_len = IEEE80211_3ADDR_LEN;
9684 tfd = &txq->bd[q->first_empty];
9685 txq->txb[q->first_empty] = txb;
9686 memset(tfd, 0, sizeof(*tfd));
9687 tfd->u.data.station_number = id;
9689 tfd->control_flags.message_type = TX_FRAME_TYPE;
9690 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9692 tfd->u.data.cmd_id = DINO_CMD_TX;
9693 tfd->u.data.len = cpu_to_le16(txb->payload_size);
9694 remaining_bytes = txb->payload_size;
9696 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9697 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9699 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9701 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9702 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9704 fc = le16_to_cpu(hdr->frame_ctl);
9705 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9707 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9709 if (likely(unicast))
9710 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9712 if (txb->encrypted && !priv->ieee->host_encrypt) {
9713 switch (priv->ieee->sec.level) {
9715 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9716 IEEE80211_FCTL_PROTECTED;
9717 /* XXX: ACK flag must be set for CCMP even if it
9718 * is a multicast/broadcast packet, because CCMP
9719 * group communication encrypted by GTK is
9720 * actually done by the AP. */
9722 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9724 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9725 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9726 tfd->u.data.key_index = 0;
9727 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9730 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9731 IEEE80211_FCTL_PROTECTED;
9732 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9733 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9734 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9737 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9738 IEEE80211_FCTL_PROTECTED;
9739 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9740 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9742 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9744 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9749 printk(KERN_ERR "Unknow security level %d\n",
9750 priv->ieee->sec.level);
9754 /* No hardware encryption */
9755 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9757 #ifdef CONFIG_IPW_QOS
9758 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9759 #endif /* CONFIG_IPW_QOS */
9762 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9764 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9765 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9766 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9767 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9768 i, le32_to_cpu(tfd->u.data.num_chunks),
9769 txb->fragments[i]->len - hdr_len);
9770 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9771 i, tfd->u.data.num_chunks,
9772 txb->fragments[i]->len - hdr_len);
9773 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9774 txb->fragments[i]->len - hdr_len);
9776 tfd->u.data.chunk_ptr[i] =
9777 cpu_to_le32(pci_map_single
9779 txb->fragments[i]->data + hdr_len,
9780 txb->fragments[i]->len - hdr_len,
9782 tfd->u.data.chunk_len[i] =
9783 cpu_to_le16(txb->fragments[i]->len - hdr_len);
9786 if (i != txb->nr_frags) {
9787 struct sk_buff *skb;
9788 u16 remaining_bytes = 0;
9791 for (j = i; j < txb->nr_frags; j++)
9792 remaining_bytes += txb->fragments[j]->len - hdr_len;
9794 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9796 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9798 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9799 for (j = i; j < txb->nr_frags; j++) {
9800 int size = txb->fragments[j]->len - hdr_len;
9802 printk(KERN_INFO "Adding frag %d %d...\n",
9804 memcpy(skb_put(skb, size),
9805 txb->fragments[j]->data + hdr_len, size);
9807 dev_kfree_skb_any(txb->fragments[i]);
9808 txb->fragments[i] = skb;
9809 tfd->u.data.chunk_ptr[i] =
9810 cpu_to_le32(pci_map_single
9811 (priv->pci_dev, skb->data,
9812 tfd->u.data.chunk_len[i],
9815 tfd->u.data.num_chunks =
9816 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9822 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9823 ipw_write32(priv, q->reg_w, q->first_empty);
9825 return NETDEV_TX_OK;
9828 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9829 ieee80211_txb_free(txb);
9830 return NETDEV_TX_OK;
9833 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9835 struct ipw_priv *priv = ieee80211_priv(dev);
9836 #ifdef CONFIG_IPW_QOS
9837 int tx_id = ipw_get_tx_queue_number(priv, pri);
9838 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9840 struct clx2_tx_queue *txq = &priv->txq[0];
9841 #endif /* CONFIG_IPW_QOS */
9843 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9849 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9850 struct net_device *dev, int pri)
9852 struct ipw_priv *priv = ieee80211_priv(dev);
9853 unsigned long flags;
9856 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9857 spin_lock_irqsave(&priv->lock, flags);
9859 if (!(priv->status & STATUS_ASSOCIATED)) {
9860 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9861 priv->ieee->stats.tx_carrier_errors++;
9862 netif_stop_queue(dev);
9866 ret = ipw_tx_skb(priv, txb, pri);
9867 if (ret == NETDEV_TX_OK)
9868 __ipw_led_activity_on(priv);
9869 spin_unlock_irqrestore(&priv->lock, flags);
9874 spin_unlock_irqrestore(&priv->lock, flags);
9878 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9880 struct ipw_priv *priv = ieee80211_priv(dev);
9882 priv->ieee->stats.tx_packets = priv->tx_packets;
9883 priv->ieee->stats.rx_packets = priv->rx_packets;
9884 return &priv->ieee->stats;
9887 static void ipw_net_set_multicast_list(struct net_device *dev)
9892 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9894 struct ipw_priv *priv = ieee80211_priv(dev);
9895 struct sockaddr *addr = p;
9896 if (!is_valid_ether_addr(addr->sa_data))
9897 return -EADDRNOTAVAIL;
9899 priv->config |= CFG_CUSTOM_MAC;
9900 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9901 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9902 priv->net_dev->name, MAC_ARG(priv->mac_addr));
9903 queue_work(priv->workqueue, &priv->adapter_restart);
9908 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9909 struct ethtool_drvinfo *info)
9911 struct ipw_priv *p = ieee80211_priv(dev);
9916 strcpy(info->driver, DRV_NAME);
9917 strcpy(info->version, DRV_VERSION);
9920 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9922 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9924 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9926 strcpy(info->bus_info, pci_name(p->pci_dev));
9927 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9930 static u32 ipw_ethtool_get_link(struct net_device *dev)
9932 struct ipw_priv *priv = ieee80211_priv(dev);
9933 return (priv->status & STATUS_ASSOCIATED) != 0;
9936 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9938 return IPW_EEPROM_IMAGE_SIZE;
9941 static int ipw_ethtool_get_eeprom(struct net_device *dev,
9942 struct ethtool_eeprom *eeprom, u8 * bytes)
9944 struct ipw_priv *p = ieee80211_priv(dev);
9946 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9949 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9954 static int ipw_ethtool_set_eeprom(struct net_device *dev,
9955 struct ethtool_eeprom *eeprom, u8 * bytes)
9957 struct ipw_priv *p = ieee80211_priv(dev);
9960 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9963 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
9964 for (i = IPW_EEPROM_DATA;
9965 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
9966 ipw_write8(p, i, p->eeprom[i]);
9971 static struct ethtool_ops ipw_ethtool_ops = {
9972 .get_link = ipw_ethtool_get_link,
9973 .get_drvinfo = ipw_ethtool_get_drvinfo,
9974 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9975 .get_eeprom = ipw_ethtool_get_eeprom,
9976 .set_eeprom = ipw_ethtool_set_eeprom,
9979 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9981 struct ipw_priv *priv = data;
9982 u32 inta, inta_mask;
9987 spin_lock(&priv->lock);
9989 if (!(priv->status & STATUS_INT_ENABLED)) {
9994 inta = ipw_read32(priv, IPW_INTA_RW);
9995 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
9997 if (inta == 0xFFFFFFFF) {
9998 /* Hardware disappeared */
9999 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10003 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10004 /* Shared interrupt */
10008 /* tell the device to stop sending interrupts */
10009 ipw_disable_interrupts(priv);
10011 /* ack current interrupts */
10012 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10013 ipw_write32(priv, IPW_INTA_RW, inta);
10015 /* Cache INTA value for our tasklet */
10016 priv->isr_inta = inta;
10018 tasklet_schedule(&priv->irq_tasklet);
10020 spin_unlock(&priv->lock);
10022 return IRQ_HANDLED;
10024 spin_unlock(&priv->lock);
10028 static void ipw_rf_kill(void *adapter)
10030 struct ipw_priv *priv = adapter;
10031 unsigned long flags;
10033 spin_lock_irqsave(&priv->lock, flags);
10035 if (rf_kill_active(priv)) {
10036 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10037 if (priv->workqueue)
10038 queue_delayed_work(priv->workqueue,
10039 &priv->rf_kill, 2 * HZ);
10043 /* RF Kill is now disabled, so bring the device back up */
10045 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10046 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10049 /* we can not do an adapter restart while inside an irq lock */
10050 queue_work(priv->workqueue, &priv->adapter_restart);
10052 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10056 spin_unlock_irqrestore(&priv->lock, flags);
10059 static void ipw_bg_rf_kill(void *data)
10061 struct ipw_priv *priv = data;
10067 void ipw_link_up(struct ipw_priv *priv)
10069 priv->last_seq_num = -1;
10070 priv->last_frag_num = -1;
10071 priv->last_packet_time = 0;
10073 netif_carrier_on(priv->net_dev);
10074 if (netif_queue_stopped(priv->net_dev)) {
10075 IPW_DEBUG_NOTIF("waking queue\n");
10076 netif_wake_queue(priv->net_dev);
10078 IPW_DEBUG_NOTIF("starting queue\n");
10079 netif_start_queue(priv->net_dev);
10082 cancel_delayed_work(&priv->request_scan);
10083 ipw_reset_stats(priv);
10084 /* Ensure the rate is updated immediately */
10085 priv->last_rate = ipw_get_current_rate(priv);
10086 ipw_gather_stats(priv);
10087 ipw_led_link_up(priv);
10088 notify_wx_assoc_event(priv);
10090 if (priv->config & CFG_BACKGROUND_SCAN)
10091 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10094 static void ipw_bg_link_up(void *data)
10096 struct ipw_priv *priv = data;
10102 void ipw_link_down(struct ipw_priv *priv)
10104 ipw_led_link_down(priv);
10105 netif_carrier_off(priv->net_dev);
10106 netif_stop_queue(priv->net_dev);
10107 notify_wx_assoc_event(priv);
10109 /* Cancel any queued work ... */
10110 cancel_delayed_work(&priv->request_scan);
10111 cancel_delayed_work(&priv->adhoc_check);
10112 cancel_delayed_work(&priv->gather_stats);
10114 ipw_reset_stats(priv);
10116 if (!(priv->status & STATUS_EXIT_PENDING)) {
10117 /* Queue up another scan... */
10118 queue_work(priv->workqueue, &priv->request_scan);
10122 static void ipw_bg_link_down(void *data)
10124 struct ipw_priv *priv = data;
10126 ipw_link_down(data);
10130 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10134 priv->workqueue = create_workqueue(DRV_NAME);
10135 init_waitqueue_head(&priv->wait_command_queue);
10136 init_waitqueue_head(&priv->wait_state);
10138 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10139 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10140 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10141 INIT_WORK(&priv->system_config, ipw_system_config, priv);
10142 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10143 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10144 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10145 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10146 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10147 INIT_WORK(&priv->request_scan,
10148 (void (*)(void *))ipw_request_scan, priv);
10149 INIT_WORK(&priv->gather_stats,
10150 (void (*)(void *))ipw_bg_gather_stats, priv);
10151 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10152 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10153 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10154 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10155 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10156 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10158 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10160 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10162 INIT_WORK(&priv->merge_networks,
10163 (void (*)(void *))ipw_merge_adhoc_network, priv);
10165 #ifdef CONFIG_IPW_QOS
10166 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10168 #endif /* CONFIG_IPW_QOS */
10170 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10171 ipw_irq_tasklet, (unsigned long)priv);
10176 static void shim__set_security(struct net_device *dev,
10177 struct ieee80211_security *sec)
10179 struct ipw_priv *priv = ieee80211_priv(dev);
10181 for (i = 0; i < 4; i++) {
10182 if (sec->flags & (1 << i)) {
10183 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10184 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10185 if (sec->key_sizes[i] == 0)
10186 priv->ieee->sec.flags &= ~(1 << i);
10188 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10189 sec->key_sizes[i]);
10190 priv->ieee->sec.flags |= (1 << i);
10192 priv->status |= STATUS_SECURITY_UPDATED;
10193 } else if (sec->level != SEC_LEVEL_1)
10194 priv->ieee->sec.flags &= ~(1 << i);
10197 if (sec->flags & SEC_ACTIVE_KEY) {
10198 if (sec->active_key <= 3) {
10199 priv->ieee->sec.active_key = sec->active_key;
10200 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10202 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10203 priv->status |= STATUS_SECURITY_UPDATED;
10205 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10207 if ((sec->flags & SEC_AUTH_MODE) &&
10208 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10209 priv->ieee->sec.auth_mode = sec->auth_mode;
10210 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10211 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10212 priv->capability |= CAP_SHARED_KEY;
10214 priv->capability &= ~CAP_SHARED_KEY;
10215 priv->status |= STATUS_SECURITY_UPDATED;
10218 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10219 priv->ieee->sec.flags |= SEC_ENABLED;
10220 priv->ieee->sec.enabled = sec->enabled;
10221 priv->status |= STATUS_SECURITY_UPDATED;
10223 priv->capability |= CAP_PRIVACY_ON;
10225 priv->capability &= ~CAP_PRIVACY_ON;
10228 if (sec->flags & SEC_ENCRYPT)
10229 priv->ieee->sec.encrypt = sec->encrypt;
10231 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10232 priv->ieee->sec.level = sec->level;
10233 priv->ieee->sec.flags |= SEC_LEVEL;
10234 priv->status |= STATUS_SECURITY_UPDATED;
10237 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10238 ipw_set_hwcrypto_keys(priv);
10240 /* To match current functionality of ipw2100 (which works well w/
10241 * various supplicants, we don't force a disassociate if the
10242 * privacy capability changes ... */
10244 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10245 (((priv->assoc_request.capability &
10246 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10247 (!(priv->assoc_request.capability &
10248 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10249 IPW_DEBUG_ASSOC("Disassociating due to capability "
10251 ipw_disassociate(priv);
10256 static int init_supported_rates(struct ipw_priv *priv,
10257 struct ipw_supported_rates *rates)
10259 /* TODO: Mask out rates based on priv->rates_mask */
10261 memset(rates, 0, sizeof(*rates));
10262 /* configure supported rates */
10263 switch (priv->ieee->freq_band) {
10264 case IEEE80211_52GHZ_BAND:
10265 rates->ieee_mode = IPW_A_MODE;
10266 rates->purpose = IPW_RATE_CAPABILITIES;
10267 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10268 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10271 default: /* Mixed or 2.4Ghz */
10272 rates->ieee_mode = IPW_G_MODE;
10273 rates->purpose = IPW_RATE_CAPABILITIES;
10274 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10275 IEEE80211_CCK_DEFAULT_RATES_MASK);
10276 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10277 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10278 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10286 static int ipw_config(struct ipw_priv *priv)
10288 /* This is only called from ipw_up, which resets/reloads the firmware
10289 so, we don't need to first disable the card before we configure
10291 if (ipw_set_tx_power(priv))
10294 /* initialize adapter address */
10295 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10298 /* set basic system config settings */
10299 init_sys_config(&priv->sys_config);
10300 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10301 priv->sys_config.answer_broadcast_ssid_probe = 1;
10303 priv->sys_config.answer_broadcast_ssid_probe = 0;
10305 if (ipw_send_system_config(priv, &priv->sys_config))
10308 init_supported_rates(priv, &priv->rates);
10309 if (ipw_send_supported_rates(priv, &priv->rates))
10312 /* Set request-to-send threshold */
10313 if (priv->rts_threshold) {
10314 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10317 #ifdef CONFIG_IPW_QOS
10318 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10319 ipw_qos_activate(priv, NULL);
10320 #endif /* CONFIG_IPW_QOS */
10322 if (ipw_set_random_seed(priv))
10325 /* final state transition to the RUN state */
10326 if (ipw_send_host_complete(priv))
10329 priv->status |= STATUS_INIT;
10331 ipw_led_init(priv);
10332 ipw_led_radio_on(priv);
10333 priv->notif_missed_beacons = 0;
10335 /* Set hardware WEP key if it is configured. */
10336 if ((priv->capability & CAP_PRIVACY_ON) &&
10337 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10338 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10339 ipw_set_hwcrypto_keys(priv);
10350 * These tables have been tested in conjunction with the
10351 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10353 * Altering this values, using it on other hardware, or in geographies
10354 * not intended for resale of the above mentioned Intel adapters has
10358 static const struct ieee80211_geo ipw_geos[] = {
10362 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10363 {2427, 4}, {2432, 5}, {2437, 6},
10364 {2442, 7}, {2447, 8}, {2452, 9},
10365 {2457, 10}, {2462, 11}},
10368 { /* Custom US/Canada */
10371 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10372 {2427, 4}, {2432, 5}, {2437, 6},
10373 {2442, 7}, {2447, 8}, {2452, 9},
10374 {2457, 10}, {2462, 11}},
10380 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10381 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10382 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10383 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10386 { /* Rest of World */
10389 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10390 {2427, 4}, {2432, 5}, {2437, 6},
10391 {2442, 7}, {2447, 8}, {2452, 9},
10392 {2457, 10}, {2462, 11}, {2467, 12},
10396 { /* Custom USA & Europe & High */
10399 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10400 {2427, 4}, {2432, 5}, {2437, 6},
10401 {2442, 7}, {2447, 8}, {2452, 9},
10402 {2457, 10}, {2462, 11}},
10408 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10409 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10410 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10411 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10419 { /* Custom NA & Europe */
10422 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10423 {2427, 4}, {2432, 5}, {2437, 6},
10424 {2442, 7}, {2447, 8}, {2452, 9},
10425 {2457, 10}, {2462, 11}},
10431 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10432 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10433 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10434 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10435 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10436 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10437 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10438 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10439 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10442 { /* Custom Japan */
10445 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10446 {2427, 4}, {2432, 5}, {2437, 6},
10447 {2442, 7}, {2447, 8}, {2452, 9},
10448 {2457, 10}, {2462, 11}},
10450 .a = {{5170, 34}, {5190, 38},
10451 {5210, 42}, {5230, 46}},
10457 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10458 {2427, 4}, {2432, 5}, {2437, 6},
10459 {2442, 7}, {2447, 8}, {2452, 9},
10460 {2457, 10}, {2462, 11}},
10466 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10467 {2427, 4}, {2432, 5}, {2437, 6},
10468 {2442, 7}, {2447, 8}, {2452, 9},
10469 {2457, 10}, {2462, 11}, {2467, 12},
10476 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10477 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10478 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10479 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10480 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10481 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10482 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10483 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10484 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10485 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10486 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10487 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10488 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10489 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10490 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10493 { /* Custom Japan */
10496 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10497 {2427, 4}, {2432, 5}, {2437, 6},
10498 {2442, 7}, {2447, 8}, {2452, 9},
10499 {2457, 10}, {2462, 11}, {2467, 12},
10500 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10502 .a = {{5170, 34}, {5190, 38},
10503 {5210, 42}, {5230, 46}},
10506 { /* Rest of World */
10509 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10510 {2427, 4}, {2432, 5}, {2437, 6},
10511 {2442, 7}, {2447, 8}, {2452, 9},
10512 {2457, 10}, {2462, 11}, {2467, 12},
10513 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10514 IEEE80211_CH_PASSIVE_ONLY}},
10520 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10521 {2427, 4}, {2432, 5}, {2437, 6},
10522 {2442, 7}, {2447, 8}, {2452, 9},
10523 {2457, 10}, {2462, 11},
10524 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10525 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10527 .a = {{5745, 149}, {5765, 153},
10528 {5785, 157}, {5805, 161}},
10531 { /* Custom Europe */
10534 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10535 {2427, 4}, {2432, 5}, {2437, 6},
10536 {2442, 7}, {2447, 8}, {2452, 9},
10537 {2457, 10}, {2462, 11},
10538 {2467, 12}, {2472, 13}},
10540 .a = {{5180, 36}, {5200, 40},
10541 {5220, 44}, {5240, 48}},
10547 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10548 {2427, 4}, {2432, 5}, {2437, 6},
10549 {2442, 7}, {2447, 8}, {2452, 9},
10550 {2457, 10}, {2462, 11},
10551 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10552 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10554 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10555 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10556 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10557 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10558 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10559 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10560 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10561 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10562 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10563 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10564 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10565 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10566 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10567 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10568 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10569 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10570 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10571 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10572 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10573 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10574 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10575 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10576 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10577 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10583 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10584 {2427, 4}, {2432, 5}, {2437, 6},
10585 {2442, 7}, {2447, 8}, {2452, 9},
10586 {2457, 10}, {2462, 11}},
10588 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10589 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10590 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10591 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10592 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10593 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10594 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10595 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10596 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10597 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10598 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10599 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10600 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10604 /* GEO code borrowed from ieee80211_geo.c */
10605 static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
10609 /* Driver needs to initialize the geography map before using
10610 * these helper functions */
10611 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10613 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10614 for (i = 0; i < ieee->geo.bg_channels; i++)
10615 /* NOTE: If G mode is currently supported but
10616 * this is a B only channel, we don't see it
10618 if ((ieee->geo.bg[i].channel == channel) &&
10619 (!(ieee->mode & IEEE_G) ||
10620 !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
10621 return IEEE80211_24GHZ_BAND;
10623 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10624 for (i = 0; i < ieee->geo.a_channels; i++)
10625 if (ieee->geo.a[i].channel == channel)
10626 return IEEE80211_52GHZ_BAND;
10631 static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
10635 /* Driver needs to initialize the geography map before using
10636 * these helper functions */
10637 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10639 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10640 for (i = 0; i < ieee->geo.bg_channels; i++)
10641 if (ieee->geo.bg[i].channel == channel)
10644 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10645 for (i = 0; i < ieee->geo.a_channels; i++)
10646 if (ieee->geo.a[i].channel == channel)
10652 static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
10656 /* Driver needs to initialize the geography map before using
10657 * these helper functions */
10658 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10662 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10663 for (i = 0; i < ieee->geo.bg_channels; i++)
10664 if (ieee->geo.bg[i].freq == freq)
10665 return ieee->geo.bg[i].channel;
10667 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10668 for (i = 0; i < ieee->geo.a_channels; i++)
10669 if (ieee->geo.a[i].freq == freq)
10670 return ieee->geo.a[i].channel;
10675 static int ipw_set_geo(struct ieee80211_device *ieee,
10676 const struct ieee80211_geo *geo)
10678 memcpy(ieee->geo.name, geo->name, 3);
10679 ieee->geo.name[3] = '\0';
10680 ieee->geo.bg_channels = geo->bg_channels;
10681 ieee->geo.a_channels = geo->a_channels;
10682 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
10683 sizeof(struct ieee80211_channel));
10684 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
10685 sizeof(struct ieee80211_channel));
10689 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
10694 #define MAX_HW_RESTARTS 5
10695 static int ipw_up(struct ipw_priv *priv)
10699 if (priv->status & STATUS_EXIT_PENDING)
10702 if (cmdlog && !priv->cmdlog) {
10703 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10705 if (priv->cmdlog == NULL) {
10706 IPW_ERROR("Error allocating %d command log entries.\n",
10709 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10710 priv->cmdlog_len = cmdlog;
10714 for (i = 0; i < MAX_HW_RESTARTS; i++) {
10715 /* Load the microcode, firmware, and eeprom.
10716 * Also start the clocks. */
10717 rc = ipw_load(priv);
10719 IPW_ERROR("Unable to load firmware: %d\n", rc);
10723 ipw_init_ordinals(priv);
10724 if (!(priv->config & CFG_CUSTOM_MAC))
10725 eeprom_parse_mac(priv, priv->mac_addr);
10726 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10728 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10729 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10730 ipw_geos[j].name, 3))
10733 if (j == ARRAY_SIZE(ipw_geos)) {
10734 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10735 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10736 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10737 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10740 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
10741 IPW_WARNING("Could not set geography.");
10745 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
10746 j, priv->ieee->geo.name);
10748 if (priv->status & STATUS_RF_KILL_SW) {
10749 IPW_WARNING("Radio disabled by module parameter.\n");
10751 } else if (rf_kill_active(priv)) {
10752 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10753 "Kill switch must be turned off for "
10754 "wireless networking to work.\n");
10755 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10760 rc = ipw_config(priv);
10762 IPW_DEBUG_INFO("Configured device on count %i\n", i);
10764 /* If configure to try and auto-associate, kick
10766 queue_work(priv->workqueue, &priv->request_scan);
10771 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10772 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10773 i, MAX_HW_RESTARTS);
10775 /* We had an error bringing up the hardware, so take it
10776 * all the way back down so we can try again */
10780 /* tried to restart and config the device for as long as our
10781 * patience could withstand */
10782 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10787 static void ipw_bg_up(void *data)
10789 struct ipw_priv *priv = data;
10795 static void ipw_deinit(struct ipw_priv *priv)
10799 if (priv->status & STATUS_SCANNING) {
10800 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10801 ipw_abort_scan(priv);
10804 if (priv->status & STATUS_ASSOCIATED) {
10805 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10806 ipw_disassociate(priv);
10809 ipw_led_shutdown(priv);
10811 /* Wait up to 1s for status to change to not scanning and not
10812 * associated (disassociation can take a while for a ful 802.11
10814 for (i = 1000; i && (priv->status &
10815 (STATUS_DISASSOCIATING |
10816 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10819 if (priv->status & (STATUS_DISASSOCIATING |
10820 STATUS_ASSOCIATED | STATUS_SCANNING))
10821 IPW_DEBUG_INFO("Still associated or scanning...\n");
10823 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10825 /* Attempt to disable the card */
10826 ipw_send_card_disable(priv, 0);
10828 priv->status &= ~STATUS_INIT;
10831 static void ipw_down(struct ipw_priv *priv)
10833 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10835 priv->status |= STATUS_EXIT_PENDING;
10837 if (ipw_is_init(priv))
10840 /* Wipe out the EXIT_PENDING status bit if we are not actually
10841 * exiting the module */
10843 priv->status &= ~STATUS_EXIT_PENDING;
10845 /* tell the device to stop sending interrupts */
10846 ipw_disable_interrupts(priv);
10848 /* Clear all bits but the RF Kill */
10849 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10850 netif_carrier_off(priv->net_dev);
10851 netif_stop_queue(priv->net_dev);
10853 ipw_stop_nic(priv);
10855 ipw_led_radio_off(priv);
10858 static void ipw_bg_down(void *data)
10860 struct ipw_priv *priv = data;
10866 /* Called by register_netdev() */
10867 static int ipw_net_init(struct net_device *dev)
10869 struct ipw_priv *priv = ieee80211_priv(dev);
10872 if (ipw_up(priv)) {
10881 /* PCI driver stuff */
10882 static struct pci_device_id card_ids[] = {
10883 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10884 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10885 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10886 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10887 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10888 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10889 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10890 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10891 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10892 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10893 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10894 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10895 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10896 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10897 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10898 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10899 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10900 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10901 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10902 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10903 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10904 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10906 /* required last entry */
10910 MODULE_DEVICE_TABLE(pci, card_ids);
10912 static struct attribute *ipw_sysfs_entries[] = {
10913 &dev_attr_rf_kill.attr,
10914 &dev_attr_direct_dword.attr,
10915 &dev_attr_indirect_byte.attr,
10916 &dev_attr_indirect_dword.attr,
10917 &dev_attr_mem_gpio_reg.attr,
10918 &dev_attr_command_event_reg.attr,
10919 &dev_attr_nic_type.attr,
10920 &dev_attr_status.attr,
10921 &dev_attr_cfg.attr,
10922 &dev_attr_error.attr,
10923 &dev_attr_event_log.attr,
10924 &dev_attr_cmd_log.attr,
10925 &dev_attr_eeprom_delay.attr,
10926 &dev_attr_ucode_version.attr,
10927 &dev_attr_rtc.attr,
10928 &dev_attr_scan_age.attr,
10929 &dev_attr_led.attr,
10930 &dev_attr_speed_scan.attr,
10931 &dev_attr_net_stats.attr,
10935 static struct attribute_group ipw_attribute_group = {
10936 .name = NULL, /* put in device directory */
10937 .attrs = ipw_sysfs_entries,
10940 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
10943 struct net_device *net_dev;
10944 void __iomem *base;
10946 struct ipw_priv *priv;
10949 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10950 if (net_dev == NULL) {
10955 priv = ieee80211_priv(net_dev);
10956 priv->ieee = netdev_priv(net_dev);
10958 priv->net_dev = net_dev;
10959 priv->pci_dev = pdev;
10960 #ifdef CONFIG_IPW_DEBUG
10961 ipw_debug_level = debug;
10963 spin_lock_init(&priv->lock);
10964 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10965 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
10967 init_MUTEX(&priv->sem);
10968 if (pci_enable_device(pdev)) {
10970 goto out_free_ieee80211;
10973 pci_set_master(pdev);
10975 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
10977 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
10979 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10980 goto out_pci_disable_device;
10983 pci_set_drvdata(pdev, priv);
10985 err = pci_request_regions(pdev, DRV_NAME);
10987 goto out_pci_disable_device;
10989 /* We disable the RETRY_TIMEOUT register (0x41) to keep
10990 * PCI Tx retries from interfering with C3 CPU state */
10991 pci_read_config_dword(pdev, 0x40, &val);
10992 if ((val & 0x0000ff00) != 0)
10993 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
10995 length = pci_resource_len(pdev, 0);
10996 priv->hw_len = length;
10998 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
11001 goto out_pci_release_regions;
11004 priv->hw_base = base;
11005 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11006 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11008 err = ipw_setup_deferred_work(priv);
11010 IPW_ERROR("Unable to setup deferred work\n");
11014 ipw_sw_reset(priv, 1);
11016 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
11018 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11019 goto out_destroy_workqueue;
11022 SET_MODULE_OWNER(net_dev);
11023 SET_NETDEV_DEV(net_dev, &pdev->dev);
11027 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11028 priv->ieee->set_security = shim__set_security;
11029 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11031 #ifdef CONFIG_IPW_QOS
11032 priv->ieee->handle_probe_response = ipw_handle_beacon;
11033 priv->ieee->handle_beacon = ipw_handle_probe_response;
11034 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11035 #endif /* CONFIG_IPW_QOS */
11037 priv->ieee->perfect_rssi = -20;
11038 priv->ieee->worst_rssi = -85;
11040 net_dev->open = ipw_net_open;
11041 net_dev->stop = ipw_net_stop;
11042 net_dev->init = ipw_net_init;
11043 net_dev->get_stats = ipw_net_get_stats;
11044 net_dev->set_multicast_list = ipw_net_set_multicast_list;
11045 net_dev->set_mac_address = ipw_net_set_mac_address;
11046 priv->wireless_data.spy_data = &priv->ieee->spy_data;
11047 priv->wireless_data.ieee80211 = priv->ieee;
11048 net_dev->wireless_data = &priv->wireless_data;
11049 net_dev->wireless_handlers = &ipw_wx_handler_def;
11050 net_dev->ethtool_ops = &ipw_ethtool_ops;
11051 net_dev->irq = pdev->irq;
11052 net_dev->base_addr = (unsigned long)priv->hw_base;
11053 net_dev->mem_start = pci_resource_start(pdev, 0);
11054 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11056 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11058 IPW_ERROR("failed to create sysfs device attributes\n");
11060 goto out_release_irq;
11064 err = register_netdev(net_dev);
11066 IPW_ERROR("failed to register network device\n");
11067 goto out_remove_sysfs;
11072 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11074 free_irq(pdev->irq, priv);
11075 out_destroy_workqueue:
11076 destroy_workqueue(priv->workqueue);
11077 priv->workqueue = NULL;
11079 iounmap(priv->hw_base);
11080 out_pci_release_regions:
11081 pci_release_regions(pdev);
11082 out_pci_disable_device:
11083 pci_disable_device(pdev);
11084 pci_set_drvdata(pdev, NULL);
11085 out_free_ieee80211:
11086 free_ieee80211(priv->net_dev);
11091 static void ipw_pci_remove(struct pci_dev *pdev)
11093 struct ipw_priv *priv = pci_get_drvdata(pdev);
11094 struct list_head *p, *q;
11102 priv->status |= STATUS_EXIT_PENDING;
11104 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11108 unregister_netdev(priv->net_dev);
11111 ipw_rx_queue_free(priv, priv->rxq);
11114 ipw_tx_queue_free(priv);
11116 if (priv->cmdlog) {
11117 kfree(priv->cmdlog);
11118 priv->cmdlog = NULL;
11120 /* ipw_down will ensure that there is no more pending work
11121 * in the workqueue's, so we can safely remove them now. */
11122 cancel_delayed_work(&priv->adhoc_check);
11123 cancel_delayed_work(&priv->gather_stats);
11124 cancel_delayed_work(&priv->request_scan);
11125 cancel_delayed_work(&priv->rf_kill);
11126 cancel_delayed_work(&priv->scan_check);
11127 destroy_workqueue(priv->workqueue);
11128 priv->workqueue = NULL;
11130 /* Free MAC hash list for ADHOC */
11131 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11132 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11133 kfree(list_entry(p, struct ipw_ibss_seq, list));
11139 ipw_free_error_log(priv->error);
11140 priv->error = NULL;
11143 free_irq(pdev->irq, priv);
11144 iounmap(priv->hw_base);
11145 pci_release_regions(pdev);
11146 pci_disable_device(pdev);
11147 pci_set_drvdata(pdev, NULL);
11148 free_ieee80211(priv->net_dev);
11153 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11155 struct ipw_priv *priv = pci_get_drvdata(pdev);
11156 struct net_device *dev = priv->net_dev;
11158 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11160 /* Take down the device; powers it off, etc. */
11163 /* Remove the PRESENT state of the device */
11164 netif_device_detach(dev);
11166 pci_save_state(pdev);
11167 pci_disable_device(pdev);
11168 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11173 static int ipw_pci_resume(struct pci_dev *pdev)
11175 struct ipw_priv *priv = pci_get_drvdata(pdev);
11176 struct net_device *dev = priv->net_dev;
11179 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11181 pci_set_power_state(pdev, PCI_D0);
11182 pci_enable_device(pdev);
11183 pci_restore_state(pdev);
11186 * Suspend/Resume resets the PCI configuration space, so we have to
11187 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11188 * from interfering with C3 CPU state. pci_restore_state won't help
11189 * here since it only restores the first 64 bytes pci config header.
11191 pci_read_config_dword(pdev, 0x40, &val);
11192 if ((val & 0x0000ff00) != 0)
11193 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11195 /* Set the device back into the PRESENT state; this will also wake
11196 * the queue of needed */
11197 netif_device_attach(dev);
11199 /* Bring the device back up */
11200 queue_work(priv->workqueue, &priv->up);
11206 /* driver initialization stuff */
11207 static struct pci_driver ipw_driver = {
11209 .id_table = card_ids,
11210 .probe = ipw_pci_probe,
11211 .remove = __devexit_p(ipw_pci_remove),
11213 .suspend = ipw_pci_suspend,
11214 .resume = ipw_pci_resume,
11218 static int __init ipw_init(void)
11222 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11223 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11225 ret = pci_module_init(&ipw_driver);
11227 IPW_ERROR("Unable to initialize PCI module\n");
11231 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11233 IPW_ERROR("Unable to create driver sysfs file\n");
11234 pci_unregister_driver(&ipw_driver);
11241 static void __exit ipw_exit(void)
11243 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11244 pci_unregister_driver(&ipw_driver);
11247 module_param(disable, int, 0444);
11248 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11250 module_param(associate, int, 0444);
11251 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11253 module_param(auto_create, int, 0444);
11254 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11256 module_param(led, int, 0444);
11257 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11259 module_param(debug, int, 0444);
11260 MODULE_PARM_DESC(debug, "debug output mask");
11262 module_param(channel, int, 0444);
11263 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11265 #ifdef CONFIG_IPW_QOS
11266 module_param(qos_enable, int, 0444);
11267 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11269 module_param(qos_burst_enable, int, 0444);
11270 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11272 module_param(qos_no_ack_mask, int, 0444);
11273 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11275 module_param(burst_duration_CCK, int, 0444);
11276 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11278 module_param(burst_duration_OFDM, int, 0444);
11279 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11280 #endif /* CONFIG_IPW_QOS */
11282 #ifdef CONFIG_IPW2200_MONITOR
11283 module_param(mode, int, 0444);
11284 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11286 module_param(mode, int, 0444);
11287 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11290 module_param(hwcrypto, int, 0444);
11291 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11293 module_param(cmdlog, int, 0444);
11294 MODULE_PARM_DESC(cmdlog,
11295 "allocate a ring buffer for logging firmware commands");
11297 module_exit(ipw_exit);
11298 module_init(ipw_init);