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 ******************************************************************************/
35 #define IPW2200_VERSION "1.0.7"
36 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
37 #define DRV_COPYRIGHT "Copyright(c) 2003-2005 Intel Corporation"
38 #define DRV_VERSION IPW2200_VERSION
40 #define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
42 MODULE_DESCRIPTION(DRV_DESCRIPTION);
43 MODULE_VERSION(DRV_VERSION);
44 MODULE_AUTHOR(DRV_COPYRIGHT);
45 MODULE_LICENSE("GPL");
47 static int cmdlog = 0;
49 static int channel = 0;
52 static u32 ipw_debug_level;
53 static int associate = 1;
54 static int auto_create = 1;
56 static int disable = 0;
57 static int hwcrypto = 1;
58 static const char ipw_modes[] = {
63 static int qos_enable = 0;
64 static int qos_burst_enable = 0;
65 static int qos_no_ack_mask = 0;
66 static int burst_duration_CCK = 0;
67 static int burst_duration_OFDM = 0;
69 static struct ieee80211_qos_parameters def_qos_parameters_OFDM = {
70 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
72 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
74 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
75 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
76 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
77 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
80 static struct ieee80211_qos_parameters def_qos_parameters_CCK = {
81 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
83 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
85 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
86 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
87 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
88 QOS_TX3_TXOP_LIMIT_CCK}
91 static struct ieee80211_qos_parameters def_parameters_OFDM = {
92 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
94 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
96 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
97 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
98 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
99 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
102 static struct ieee80211_qos_parameters def_parameters_CCK = {
103 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
105 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
107 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
108 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
109 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
110 DEF_TX3_TXOP_LIMIT_CCK}
113 static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
115 static int from_priority_to_tx_queue[] = {
116 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
117 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
120 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
122 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
124 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
126 #endif /* CONFIG_IPW_QOS */
128 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
129 static void ipw_remove_current_network(struct ipw_priv *priv);
130 static void ipw_rx(struct ipw_priv *priv);
131 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
132 struct clx2_tx_queue *txq, int qindex);
133 static int ipw_queue_reset(struct ipw_priv *priv);
135 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
138 static void ipw_tx_queue_free(struct ipw_priv *);
140 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
141 static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
142 static void ipw_rx_queue_replenish(void *);
143 static int ipw_up(struct ipw_priv *);
144 static void ipw_bg_up(void *);
145 static void ipw_down(struct ipw_priv *);
146 static void ipw_bg_down(void *);
147 static int ipw_config(struct ipw_priv *);
148 static int init_supported_rates(struct ipw_priv *priv,
149 struct ipw_supported_rates *prates);
150 static void ipw_set_hwcrypto_keys(struct ipw_priv *);
151 static void ipw_send_wep_keys(struct ipw_priv *, int);
153 static int ipw_is_valid_channel(struct ieee80211_device *, u8);
154 static int ipw_channel_to_index(struct ieee80211_device *, u8);
155 static u8 ipw_freq_to_channel(struct ieee80211_device *, u32);
156 static int ipw_set_geo(struct ieee80211_device *, const struct ieee80211_geo *);
157 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *);
159 static int snprint_line(char *buf, size_t count,
160 const u8 * data, u32 len, u32 ofs)
165 out = snprintf(buf, count, "%08X", ofs);
167 for (l = 0, i = 0; i < 2; i++) {
168 out += snprintf(buf + out, count - out, " ");
169 for (j = 0; j < 8 && l < len; j++, l++)
170 out += snprintf(buf + out, count - out, "%02X ",
173 out += snprintf(buf + out, count - out, " ");
176 out += snprintf(buf + out, count - out, " ");
177 for (l = 0, i = 0; i < 2; i++) {
178 out += snprintf(buf + out, count - out, " ");
179 for (j = 0; j < 8 && l < len; j++, l++) {
180 c = data[(i * 8 + j)];
181 if (!isascii(c) || !isprint(c))
184 out += snprintf(buf + out, count - out, "%c", c);
188 out += snprintf(buf + out, count - out, " ");
194 static void printk_buf(int level, const u8 * data, u32 len)
198 if (!(ipw_debug_level & level))
202 snprint_line(line, sizeof(line), &data[ofs],
204 printk(KERN_DEBUG "%s\n", line);
206 len -= min(len, 16U);
210 static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
216 while (size && len) {
217 out = snprint_line(output, size, &data[ofs],
218 min_t(size_t, len, 16U), ofs);
223 len -= min_t(size_t, len, 16U);
229 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
230 #define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
232 static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
233 #define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
235 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
236 static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
238 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
239 __LINE__, (u32) (b), (u32) (c));
240 _ipw_write_reg8(a, b, c);
243 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
244 static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
246 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
247 __LINE__, (u32) (b), (u32) (c));
248 _ipw_write_reg16(a, b, c);
251 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
252 static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
254 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
255 __LINE__, (u32) (b), (u32) (c));
256 _ipw_write_reg32(a, b, c);
259 #define _ipw_write8(ipw, ofs, val) writeb((val), (ipw)->hw_base + (ofs))
260 #define ipw_write8(ipw, ofs, val) \
261 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
262 _ipw_write8(ipw, ofs, val)
264 #define _ipw_write16(ipw, ofs, val) writew((val), (ipw)->hw_base + (ofs))
265 #define ipw_write16(ipw, ofs, val) \
266 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
267 _ipw_write16(ipw, ofs, val)
269 #define _ipw_write32(ipw, ofs, val) writel((val), (ipw)->hw_base + (ofs))
270 #define ipw_write32(ipw, ofs, val) \
271 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
272 _ipw_write32(ipw, ofs, val)
274 #define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
275 static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
277 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
278 return _ipw_read8(ipw, ofs);
281 #define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)
283 #define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
284 static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
286 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
287 return _ipw_read16(ipw, ofs);
290 #define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)
292 #define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
293 static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
295 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
296 return _ipw_read32(ipw, ofs);
299 #define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
301 static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
302 static inline void __ipw_read_indirect(const char *f, int l,
303 struct ipw_priv *a, u32 b, u8 * c, int d)
305 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
307 _ipw_read_indirect(a, b, c, d);
310 #define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
312 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
314 #define ipw_write_indirect(a, b, c, d) \
315 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
316 _ipw_write_indirect(a, b, c, d)
318 /* indirect write s */
319 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
321 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
322 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
323 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
326 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
328 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
329 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
330 _ipw_write8(priv, IPW_INDIRECT_DATA, value);
333 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
335 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
336 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
337 _ipw_write16(priv, IPW_INDIRECT_DATA, value);
340 /* indirect read s */
342 static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
345 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
346 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
347 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
348 return (word >> ((reg & 0x3) * 8)) & 0xff;
351 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
355 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
357 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
358 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
359 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
363 /* iterative/auto-increment 32 bit reads and writes */
364 static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
367 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
368 u32 dif_len = addr - aligned_addr;
371 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
377 /* Read the first nibble byte by byte */
378 if (unlikely(dif_len)) {
379 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
380 /* Start reading at aligned_addr + dif_len */
381 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
382 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
386 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
387 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
388 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
390 /* Copy the last nibble */
392 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
393 for (i = 0; num > 0; i++, num--)
394 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
398 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
401 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
402 u32 dif_len = addr - aligned_addr;
405 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
411 /* Write the first nibble byte by byte */
412 if (unlikely(dif_len)) {
413 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
414 /* Start reading at aligned_addr + dif_len */
415 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
416 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
420 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
421 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
422 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
424 /* Copy the last nibble */
426 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
427 for (i = 0; num > 0; i++, num--, buf++)
428 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
432 static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
435 memcpy_toio((priv->hw_base + addr), buf, num);
438 static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
440 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
443 static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
445 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
448 static inline void ipw_enable_interrupts(struct ipw_priv *priv)
450 if (priv->status & STATUS_INT_ENABLED)
452 priv->status |= STATUS_INT_ENABLED;
453 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
456 static inline void ipw_disable_interrupts(struct ipw_priv *priv)
458 if (!(priv->status & STATUS_INT_ENABLED))
460 priv->status &= ~STATUS_INT_ENABLED;
461 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
464 #ifdef CONFIG_IPW_DEBUG
465 static char *ipw_error_desc(u32 val)
468 case IPW_FW_ERROR_OK:
470 case IPW_FW_ERROR_FAIL:
472 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
473 return "MEMORY_UNDERFLOW";
474 case IPW_FW_ERROR_MEMORY_OVERFLOW:
475 return "MEMORY_OVERFLOW";
476 case IPW_FW_ERROR_BAD_PARAM:
478 case IPW_FW_ERROR_BAD_CHECKSUM:
479 return "BAD_CHECKSUM";
480 case IPW_FW_ERROR_NMI_INTERRUPT:
481 return "NMI_INTERRUPT";
482 case IPW_FW_ERROR_BAD_DATABASE:
483 return "BAD_DATABASE";
484 case IPW_FW_ERROR_ALLOC_FAIL:
486 case IPW_FW_ERROR_DMA_UNDERRUN:
487 return "DMA_UNDERRUN";
488 case IPW_FW_ERROR_DMA_STATUS:
490 case IPW_FW_ERROR_DINO_ERROR:
492 case IPW_FW_ERROR_EEPROM_ERROR:
493 return "EEPROM_ERROR";
494 case IPW_FW_ERROR_SYSASSERT:
496 case IPW_FW_ERROR_FATAL_ERROR:
497 return "FATAL_ERROR";
499 return "UNKNOWN_ERROR";
503 static void ipw_dump_error_log(struct ipw_priv *priv,
504 struct ipw_fw_error *error)
509 IPW_ERROR("Error allocating and capturing error log. "
510 "Nothing to dump.\n");
514 IPW_ERROR("Start IPW Error Log Dump:\n");
515 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
516 error->status, error->config);
518 for (i = 0; i < error->elem_len; i++)
519 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
520 ipw_error_desc(error->elem[i].desc),
522 error->elem[i].blink1,
523 error->elem[i].blink2,
524 error->elem[i].link1,
525 error->elem[i].link2, error->elem[i].data);
526 for (i = 0; i < error->log_len; i++)
527 IPW_ERROR("%i\t0x%08x\t%i\n",
529 error->log[i].event, error->log[i].data);
533 static inline int ipw_is_init(struct ipw_priv *priv)
535 return (priv->status & STATUS_INIT) ? 1 : 0;
538 static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
540 u32 addr, field_info, field_len, field_count, total_len;
542 IPW_DEBUG_ORD("ordinal = %i\n", ord);
544 if (!priv || !val || !len) {
545 IPW_DEBUG_ORD("Invalid argument\n");
549 /* verify device ordinal tables have been initialized */
550 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
551 IPW_DEBUG_ORD("Access ordinals before initialization\n");
555 switch (IPW_ORD_TABLE_ID_MASK & ord) {
556 case IPW_ORD_TABLE_0_MASK:
558 * TABLE 0: Direct access to a table of 32 bit values
560 * This is a very simple table with the data directly
561 * read from the table
564 /* remove the table id from the ordinal */
565 ord &= IPW_ORD_TABLE_VALUE_MASK;
568 if (ord > priv->table0_len) {
569 IPW_DEBUG_ORD("ordinal value (%i) longer then "
570 "max (%i)\n", ord, priv->table0_len);
574 /* verify we have enough room to store the value */
575 if (*len < sizeof(u32)) {
576 IPW_DEBUG_ORD("ordinal buffer length too small, "
577 "need %zd\n", sizeof(u32));
581 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
582 ord, priv->table0_addr + (ord << 2));
586 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
589 case IPW_ORD_TABLE_1_MASK:
591 * TABLE 1: Indirect access to a table of 32 bit values
593 * This is a fairly large table of u32 values each
594 * representing starting addr for the data (which is
598 /* remove the table id from the ordinal */
599 ord &= IPW_ORD_TABLE_VALUE_MASK;
602 if (ord > priv->table1_len) {
603 IPW_DEBUG_ORD("ordinal value too long\n");
607 /* verify we have enough room to store the value */
608 if (*len < sizeof(u32)) {
609 IPW_DEBUG_ORD("ordinal buffer length too small, "
610 "need %zd\n", sizeof(u32));
615 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
619 case IPW_ORD_TABLE_2_MASK:
621 * TABLE 2: Indirect access to a table of variable sized values
623 * This table consist of six values, each containing
624 * - dword containing the starting offset of the data
625 * - dword containing the lengh in the first 16bits
626 * and the count in the second 16bits
629 /* remove the table id from the ordinal */
630 ord &= IPW_ORD_TABLE_VALUE_MASK;
633 if (ord > priv->table2_len) {
634 IPW_DEBUG_ORD("ordinal value too long\n");
638 /* get the address of statistic */
639 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
641 /* get the second DW of statistics ;
642 * two 16-bit words - first is length, second is count */
645 priv->table2_addr + (ord << 3) +
648 /* get each entry length */
649 field_len = *((u16 *) & field_info);
651 /* get number of entries */
652 field_count = *(((u16 *) & field_info) + 1);
654 /* abort if not enought memory */
655 total_len = field_len * field_count;
656 if (total_len > *len) {
665 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
666 "field_info = 0x%08x\n",
667 addr, total_len, field_info);
668 ipw_read_indirect(priv, addr, val, total_len);
672 IPW_DEBUG_ORD("Invalid ordinal!\n");
680 static void ipw_init_ordinals(struct ipw_priv *priv)
682 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
683 priv->table0_len = ipw_read32(priv, priv->table0_addr);
685 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
686 priv->table0_addr, priv->table0_len);
688 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
689 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
691 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
692 priv->table1_addr, priv->table1_len);
694 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
695 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
696 priv->table2_len &= 0x0000ffff; /* use first two bytes */
698 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
699 priv->table2_addr, priv->table2_len);
703 u32 ipw_register_toggle(u32 reg)
705 reg &= ~IPW_START_STANDBY;
706 if (reg & IPW_GATE_ODMA)
707 reg &= ~IPW_GATE_ODMA;
708 if (reg & IPW_GATE_IDMA)
709 reg &= ~IPW_GATE_IDMA;
710 if (reg & IPW_GATE_ADMA)
711 reg &= ~IPW_GATE_ADMA;
717 * - On radio ON, turn on any LEDs that require to be on during start
718 * - On initialization, start unassociated blink
719 * - On association, disable unassociated blink
720 * - On disassociation, start unassociated blink
721 * - On radio OFF, turn off any LEDs started during radio on
724 #define LD_TIME_LINK_ON 300
725 #define LD_TIME_LINK_OFF 2700
726 #define LD_TIME_ACT_ON 250
728 void ipw_led_link_on(struct ipw_priv *priv)
733 /* If configured to not use LEDs, or nic_type is 1,
734 * then we don't toggle a LINK led */
735 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
738 spin_lock_irqsave(&priv->lock, flags);
740 if (!(priv->status & STATUS_RF_KILL_MASK) &&
741 !(priv->status & STATUS_LED_LINK_ON)) {
742 IPW_DEBUG_LED("Link LED On\n");
743 led = ipw_read_reg32(priv, IPW_EVENT_REG);
744 led |= priv->led_association_on;
746 led = ipw_register_toggle(led);
748 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
749 ipw_write_reg32(priv, IPW_EVENT_REG, led);
751 priv->status |= STATUS_LED_LINK_ON;
753 /* If we aren't associated, schedule turning the LED off */
754 if (!(priv->status & STATUS_ASSOCIATED))
755 queue_delayed_work(priv->workqueue,
760 spin_unlock_irqrestore(&priv->lock, flags);
763 static void ipw_bg_led_link_on(void *data)
765 struct ipw_priv *priv = data;
767 ipw_led_link_on(data);
771 void ipw_led_link_off(struct ipw_priv *priv)
776 /* If configured not to use LEDs, or nic type is 1,
777 * then we don't goggle the LINK led. */
778 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
781 spin_lock_irqsave(&priv->lock, flags);
783 if (priv->status & STATUS_LED_LINK_ON) {
784 led = ipw_read_reg32(priv, IPW_EVENT_REG);
785 led &= priv->led_association_off;
786 led = ipw_register_toggle(led);
788 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
789 ipw_write_reg32(priv, IPW_EVENT_REG, led);
791 IPW_DEBUG_LED("Link LED Off\n");
793 priv->status &= ~STATUS_LED_LINK_ON;
795 /* If we aren't associated and the radio is on, schedule
796 * turning the LED on (blink while unassociated) */
797 if (!(priv->status & STATUS_RF_KILL_MASK) &&
798 !(priv->status & STATUS_ASSOCIATED))
799 queue_delayed_work(priv->workqueue, &priv->led_link_on,
804 spin_unlock_irqrestore(&priv->lock, flags);
807 static void ipw_bg_led_link_off(void *data)
809 struct ipw_priv *priv = data;
811 ipw_led_link_off(data);
815 static inline void __ipw_led_activity_on(struct ipw_priv *priv)
819 if (priv->config & CFG_NO_LED)
822 if (priv->status & STATUS_RF_KILL_MASK)
825 if (!(priv->status & STATUS_LED_ACT_ON)) {
826 led = ipw_read_reg32(priv, IPW_EVENT_REG);
827 led |= priv->led_activity_on;
829 led = ipw_register_toggle(led);
831 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
832 ipw_write_reg32(priv, IPW_EVENT_REG, led);
834 IPW_DEBUG_LED("Activity LED On\n");
836 priv->status |= STATUS_LED_ACT_ON;
838 cancel_delayed_work(&priv->led_act_off);
839 queue_delayed_work(priv->workqueue, &priv->led_act_off,
842 /* Reschedule LED off for full time period */
843 cancel_delayed_work(&priv->led_act_off);
844 queue_delayed_work(priv->workqueue, &priv->led_act_off,
849 void ipw_led_activity_on(struct ipw_priv *priv)
852 spin_lock_irqsave(&priv->lock, flags);
853 __ipw_led_activity_on(priv);
854 spin_unlock_irqrestore(&priv->lock, flags);
857 void ipw_led_activity_off(struct ipw_priv *priv)
862 if (priv->config & CFG_NO_LED)
865 spin_lock_irqsave(&priv->lock, flags);
867 if (priv->status & STATUS_LED_ACT_ON) {
868 led = ipw_read_reg32(priv, IPW_EVENT_REG);
869 led &= priv->led_activity_off;
871 led = ipw_register_toggle(led);
873 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
874 ipw_write_reg32(priv, IPW_EVENT_REG, led);
876 IPW_DEBUG_LED("Activity LED Off\n");
878 priv->status &= ~STATUS_LED_ACT_ON;
881 spin_unlock_irqrestore(&priv->lock, flags);
884 static void ipw_bg_led_activity_off(void *data)
886 struct ipw_priv *priv = data;
888 ipw_led_activity_off(data);
892 void ipw_led_band_on(struct ipw_priv *priv)
897 /* Only nic type 1 supports mode LEDs */
898 if (priv->config & CFG_NO_LED ||
899 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
902 spin_lock_irqsave(&priv->lock, flags);
904 led = ipw_read_reg32(priv, IPW_EVENT_REG);
905 if (priv->assoc_network->mode == IEEE_A) {
906 led |= priv->led_ofdm_on;
907 led &= priv->led_association_off;
908 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
909 } else if (priv->assoc_network->mode == IEEE_G) {
910 led |= priv->led_ofdm_on;
911 led |= priv->led_association_on;
912 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
914 led &= priv->led_ofdm_off;
915 led |= priv->led_association_on;
916 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
919 led = ipw_register_toggle(led);
921 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
922 ipw_write_reg32(priv, IPW_EVENT_REG, led);
924 spin_unlock_irqrestore(&priv->lock, flags);
927 void ipw_led_band_off(struct ipw_priv *priv)
932 /* Only nic type 1 supports mode LEDs */
933 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
936 spin_lock_irqsave(&priv->lock, flags);
938 led = ipw_read_reg32(priv, IPW_EVENT_REG);
939 led &= priv->led_ofdm_off;
940 led &= priv->led_association_off;
942 led = ipw_register_toggle(led);
944 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
945 ipw_write_reg32(priv, IPW_EVENT_REG, led);
947 spin_unlock_irqrestore(&priv->lock, flags);
950 void ipw_led_radio_on(struct ipw_priv *priv)
952 ipw_led_link_on(priv);
955 void ipw_led_radio_off(struct ipw_priv *priv)
957 ipw_led_activity_off(priv);
958 ipw_led_link_off(priv);
961 void ipw_led_link_up(struct ipw_priv *priv)
963 /* Set the Link Led on for all nic types */
964 ipw_led_link_on(priv);
967 void ipw_led_link_down(struct ipw_priv *priv)
969 ipw_led_activity_off(priv);
970 ipw_led_link_off(priv);
972 if (priv->status & STATUS_RF_KILL_MASK)
973 ipw_led_radio_off(priv);
976 void ipw_led_init(struct ipw_priv *priv)
978 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
980 /* Set the default PINs for the link and activity leds */
981 priv->led_activity_on = IPW_ACTIVITY_LED;
982 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
984 priv->led_association_on = IPW_ASSOCIATED_LED;
985 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
987 /* Set the default PINs for the OFDM leds */
988 priv->led_ofdm_on = IPW_OFDM_LED;
989 priv->led_ofdm_off = ~(IPW_OFDM_LED);
991 switch (priv->nic_type) {
992 case EEPROM_NIC_TYPE_1:
993 /* In this NIC type, the LEDs are reversed.... */
994 priv->led_activity_on = IPW_ASSOCIATED_LED;
995 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
996 priv->led_association_on = IPW_ACTIVITY_LED;
997 priv->led_association_off = ~(IPW_ACTIVITY_LED);
999 if (!(priv->config & CFG_NO_LED))
1000 ipw_led_band_on(priv);
1002 /* And we don't blink link LEDs for this nic, so
1003 * just return here */
1006 case EEPROM_NIC_TYPE_3:
1007 case EEPROM_NIC_TYPE_2:
1008 case EEPROM_NIC_TYPE_4:
1009 case EEPROM_NIC_TYPE_0:
1013 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1015 priv->nic_type = EEPROM_NIC_TYPE_0;
1019 if (!(priv->config & CFG_NO_LED)) {
1020 if (priv->status & STATUS_ASSOCIATED)
1021 ipw_led_link_on(priv);
1023 ipw_led_link_off(priv);
1027 void ipw_led_shutdown(struct ipw_priv *priv)
1029 ipw_led_activity_off(priv);
1030 ipw_led_link_off(priv);
1031 ipw_led_band_off(priv);
1032 cancel_delayed_work(&priv->led_link_on);
1033 cancel_delayed_work(&priv->led_link_off);
1034 cancel_delayed_work(&priv->led_act_off);
1038 * The following adds a new attribute to the sysfs representation
1039 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1040 * used for controling the debug level.
1042 * See the level definitions in ipw for details.
1044 static ssize_t show_debug_level(struct device_driver *d, char *buf)
1046 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1049 static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1052 char *p = (char *)buf;
1055 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1057 if (p[0] == 'x' || p[0] == 'X')
1059 val = simple_strtoul(p, &p, 16);
1061 val = simple_strtoul(p, &p, 10);
1063 printk(KERN_INFO DRV_NAME
1064 ": %s is not in hex or decimal form.\n", buf);
1066 ipw_debug_level = val;
1068 return strnlen(buf, count);
1071 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
1072 show_debug_level, store_debug_level);
1074 static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
1076 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
1079 static void ipw_capture_event_log(struct ipw_priv *priv,
1080 u32 log_len, struct ipw_event *log)
1085 base = ipw_read32(priv, IPW_EVENT_LOG);
1086 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1087 (u8 *) log, sizeof(*log) * log_len);
1091 static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
1093 struct ipw_fw_error *error;
1094 u32 log_len = ipw_get_event_log_len(priv);
1095 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1096 u32 elem_len = ipw_read_reg32(priv, base);
1098 error = kmalloc(sizeof(*error) +
1099 sizeof(*error->elem) * elem_len +
1100 sizeof(*error->log) * log_len, GFP_ATOMIC);
1102 IPW_ERROR("Memory allocation for firmware error log "
1106 error->jiffies = jiffies;
1107 error->status = priv->status;
1108 error->config = priv->config;
1109 error->elem_len = elem_len;
1110 error->log_len = log_len;
1111 error->elem = (struct ipw_error_elem *)error->payload;
1112 error->log = (struct ipw_event *)(error->elem +
1113 (sizeof(*error->elem) * elem_len));
1115 ipw_capture_event_log(priv, log_len, error->log);
1118 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1119 sizeof(*error->elem) * elem_len);
1124 static void ipw_free_error_log(struct ipw_fw_error *error)
1130 static ssize_t show_event_log(struct device *d,
1131 struct device_attribute *attr, char *buf)
1133 struct ipw_priv *priv = dev_get_drvdata(d);
1134 u32 log_len = ipw_get_event_log_len(priv);
1135 struct ipw_event log[log_len];
1138 ipw_capture_event_log(priv, log_len, log);
1140 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1141 for (i = 0; i < log_len; i++)
1142 len += snprintf(buf + len, PAGE_SIZE - len,
1144 log[i].time, log[i].event, log[i].data);
1145 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1149 static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
1151 static ssize_t show_error(struct device *d,
1152 struct device_attribute *attr, char *buf)
1154 struct ipw_priv *priv = dev_get_drvdata(d);
1158 len += snprintf(buf + len, PAGE_SIZE - len,
1159 "%08lX%08X%08X%08X",
1160 priv->error->jiffies,
1161 priv->error->status,
1162 priv->error->config, priv->error->elem_len);
1163 for (i = 0; i < priv->error->elem_len; i++)
1164 len += snprintf(buf + len, PAGE_SIZE - len,
1165 "\n%08X%08X%08X%08X%08X%08X%08X",
1166 priv->error->elem[i].time,
1167 priv->error->elem[i].desc,
1168 priv->error->elem[i].blink1,
1169 priv->error->elem[i].blink2,
1170 priv->error->elem[i].link1,
1171 priv->error->elem[i].link2,
1172 priv->error->elem[i].data);
1174 len += snprintf(buf + len, PAGE_SIZE - len,
1175 "\n%08X", priv->error->log_len);
1176 for (i = 0; i < priv->error->log_len; i++)
1177 len += snprintf(buf + len, PAGE_SIZE - len,
1179 priv->error->log[i].time,
1180 priv->error->log[i].event,
1181 priv->error->log[i].data);
1182 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1186 static ssize_t clear_error(struct device *d,
1187 struct device_attribute *attr,
1188 const char *buf, size_t count)
1190 struct ipw_priv *priv = dev_get_drvdata(d);
1192 ipw_free_error_log(priv->error);
1198 static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
1200 static ssize_t show_cmd_log(struct device *d,
1201 struct device_attribute *attr, char *buf)
1203 struct ipw_priv *priv = dev_get_drvdata(d);
1207 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1208 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1209 i = (i + 1) % priv->cmdlog_len) {
1211 snprintf(buf + len, PAGE_SIZE - len,
1212 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1213 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1214 priv->cmdlog[i].cmd.len);
1216 snprintk_buf(buf + len, PAGE_SIZE - len,
1217 (u8 *) priv->cmdlog[i].cmd.param,
1218 priv->cmdlog[i].cmd.len);
1219 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1221 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1225 static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
1227 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1230 struct ipw_priv *priv = dev_get_drvdata(d);
1231 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1234 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1235 const char *buf, size_t count)
1237 struct ipw_priv *priv = dev_get_drvdata(d);
1238 #ifdef CONFIG_IPW_DEBUG
1239 struct net_device *dev = priv->net_dev;
1241 char buffer[] = "00000000";
1243 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1247 IPW_DEBUG_INFO("enter\n");
1249 strncpy(buffer, buf, len);
1252 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1254 if (p[0] == 'x' || p[0] == 'X')
1256 val = simple_strtoul(p, &p, 16);
1258 val = simple_strtoul(p, &p, 10);
1260 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1262 priv->ieee->scan_age = val;
1263 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1266 IPW_DEBUG_INFO("exit\n");
1270 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1272 static ssize_t show_led(struct device *d, struct device_attribute *attr,
1275 struct ipw_priv *priv = dev_get_drvdata(d);
1276 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1279 static ssize_t store_led(struct device *d, struct device_attribute *attr,
1280 const char *buf, size_t count)
1282 struct ipw_priv *priv = dev_get_drvdata(d);
1284 IPW_DEBUG_INFO("enter\n");
1290 IPW_DEBUG_LED("Disabling LED control.\n");
1291 priv->config |= CFG_NO_LED;
1292 ipw_led_shutdown(priv);
1294 IPW_DEBUG_LED("Enabling LED control.\n");
1295 priv->config &= ~CFG_NO_LED;
1299 IPW_DEBUG_INFO("exit\n");
1303 static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1305 static ssize_t show_status(struct device *d,
1306 struct device_attribute *attr, char *buf)
1308 struct ipw_priv *p = d->driver_data;
1309 return sprintf(buf, "0x%08x\n", (int)p->status);
1312 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1314 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1317 struct ipw_priv *p = d->driver_data;
1318 return sprintf(buf, "0x%08x\n", (int)p->config);
1321 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1323 static ssize_t show_nic_type(struct device *d,
1324 struct device_attribute *attr, char *buf)
1326 struct ipw_priv *priv = d->driver_data;
1327 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1330 static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1332 static ssize_t show_ucode_version(struct device *d,
1333 struct device_attribute *attr, char *buf)
1335 u32 len = sizeof(u32), tmp = 0;
1336 struct ipw_priv *p = d->driver_data;
1338 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
1341 return sprintf(buf, "0x%08x\n", tmp);
1344 static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
1346 static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1349 u32 len = sizeof(u32), tmp = 0;
1350 struct ipw_priv *p = d->driver_data;
1352 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
1355 return sprintf(buf, "0x%08x\n", tmp);
1358 static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
1361 * Add a device attribute to view/control the delay between eeprom
1364 static ssize_t show_eeprom_delay(struct device *d,
1365 struct device_attribute *attr, char *buf)
1367 int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
1368 return sprintf(buf, "%i\n", n);
1370 static ssize_t store_eeprom_delay(struct device *d,
1371 struct device_attribute *attr,
1372 const char *buf, size_t count)
1374 struct ipw_priv *p = d->driver_data;
1375 sscanf(buf, "%i", &p->eeprom_delay);
1376 return strnlen(buf, count);
1379 static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1380 show_eeprom_delay, store_eeprom_delay);
1382 static ssize_t show_command_event_reg(struct device *d,
1383 struct device_attribute *attr, char *buf)
1386 struct ipw_priv *p = d->driver_data;
1388 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
1389 return sprintf(buf, "0x%08x\n", reg);
1391 static ssize_t store_command_event_reg(struct device *d,
1392 struct device_attribute *attr,
1393 const char *buf, size_t count)
1396 struct ipw_priv *p = d->driver_data;
1398 sscanf(buf, "%x", ®);
1399 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
1400 return strnlen(buf, count);
1403 static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1404 show_command_event_reg, store_command_event_reg);
1406 static ssize_t show_mem_gpio_reg(struct device *d,
1407 struct device_attribute *attr, char *buf)
1410 struct ipw_priv *p = d->driver_data;
1412 reg = ipw_read_reg32(p, 0x301100);
1413 return sprintf(buf, "0x%08x\n", reg);
1415 static ssize_t store_mem_gpio_reg(struct device *d,
1416 struct device_attribute *attr,
1417 const char *buf, size_t count)
1420 struct ipw_priv *p = d->driver_data;
1422 sscanf(buf, "%x", ®);
1423 ipw_write_reg32(p, 0x301100, reg);
1424 return strnlen(buf, count);
1427 static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1428 show_mem_gpio_reg, store_mem_gpio_reg);
1430 static ssize_t show_indirect_dword(struct device *d,
1431 struct device_attribute *attr, char *buf)
1434 struct ipw_priv *priv = d->driver_data;
1436 if (priv->status & STATUS_INDIRECT_DWORD)
1437 reg = ipw_read_reg32(priv, priv->indirect_dword);
1441 return sprintf(buf, "0x%08x\n", reg);
1443 static ssize_t store_indirect_dword(struct device *d,
1444 struct device_attribute *attr,
1445 const char *buf, size_t count)
1447 struct ipw_priv *priv = d->driver_data;
1449 sscanf(buf, "%x", &priv->indirect_dword);
1450 priv->status |= STATUS_INDIRECT_DWORD;
1451 return strnlen(buf, count);
1454 static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1455 show_indirect_dword, store_indirect_dword);
1457 static ssize_t show_indirect_byte(struct device *d,
1458 struct device_attribute *attr, char *buf)
1461 struct ipw_priv *priv = d->driver_data;
1463 if (priv->status & STATUS_INDIRECT_BYTE)
1464 reg = ipw_read_reg8(priv, priv->indirect_byte);
1468 return sprintf(buf, "0x%02x\n", reg);
1470 static ssize_t store_indirect_byte(struct device *d,
1471 struct device_attribute *attr,
1472 const char *buf, size_t count)
1474 struct ipw_priv *priv = d->driver_data;
1476 sscanf(buf, "%x", &priv->indirect_byte);
1477 priv->status |= STATUS_INDIRECT_BYTE;
1478 return strnlen(buf, count);
1481 static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
1482 show_indirect_byte, store_indirect_byte);
1484 static ssize_t show_direct_dword(struct device *d,
1485 struct device_attribute *attr, char *buf)
1488 struct ipw_priv *priv = d->driver_data;
1490 if (priv->status & STATUS_DIRECT_DWORD)
1491 reg = ipw_read32(priv, priv->direct_dword);
1495 return sprintf(buf, "0x%08x\n", reg);
1497 static ssize_t store_direct_dword(struct device *d,
1498 struct device_attribute *attr,
1499 const char *buf, size_t count)
1501 struct ipw_priv *priv = d->driver_data;
1503 sscanf(buf, "%x", &priv->direct_dword);
1504 priv->status |= STATUS_DIRECT_DWORD;
1505 return strnlen(buf, count);
1508 static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1509 show_direct_dword, store_direct_dword);
1511 static inline int rf_kill_active(struct ipw_priv *priv)
1513 if (0 == (ipw_read32(priv, 0x30) & 0x10000))
1514 priv->status |= STATUS_RF_KILL_HW;
1516 priv->status &= ~STATUS_RF_KILL_HW;
1518 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1521 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
1524 /* 0 - RF kill not enabled
1525 1 - SW based RF kill active (sysfs)
1526 2 - HW based RF kill active
1527 3 - Both HW and SW baed RF kill active */
1528 struct ipw_priv *priv = d->driver_data;
1529 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1530 (rf_kill_active(priv) ? 0x2 : 0x0);
1531 return sprintf(buf, "%i\n", val);
1534 static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1536 if ((disable_radio ? 1 : 0) ==
1537 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1540 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1541 disable_radio ? "OFF" : "ON");
1543 if (disable_radio) {
1544 priv->status |= STATUS_RF_KILL_SW;
1546 if (priv->workqueue)
1547 cancel_delayed_work(&priv->request_scan);
1548 queue_work(priv->workqueue, &priv->down);
1550 priv->status &= ~STATUS_RF_KILL_SW;
1551 if (rf_kill_active(priv)) {
1552 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1553 "disabled by HW switch\n");
1554 /* Make sure the RF_KILL check timer is running */
1555 cancel_delayed_work(&priv->rf_kill);
1556 queue_delayed_work(priv->workqueue, &priv->rf_kill,
1559 queue_work(priv->workqueue, &priv->up);
1565 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1566 const char *buf, size_t count)
1568 struct ipw_priv *priv = d->driver_data;
1570 ipw_radio_kill_sw(priv, buf[0] == '1');
1575 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
1577 static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1580 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1581 int pos = 0, len = 0;
1582 if (priv->config & CFG_SPEED_SCAN) {
1583 while (priv->speed_scan[pos] != 0)
1584 len += sprintf(&buf[len], "%d ",
1585 priv->speed_scan[pos++]);
1586 return len + sprintf(&buf[len], "\n");
1589 return sprintf(buf, "0\n");
1592 static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1593 const char *buf, size_t count)
1595 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1596 int channel, pos = 0;
1597 const char *p = buf;
1599 /* list of space separated channels to scan, optionally ending with 0 */
1600 while ((channel = simple_strtol(p, NULL, 0))) {
1601 if (pos == MAX_SPEED_SCAN - 1) {
1602 priv->speed_scan[pos] = 0;
1606 if (ipw_is_valid_channel(priv->ieee, channel))
1607 priv->speed_scan[pos++] = channel;
1609 IPW_WARNING("Skipping invalid channel request: %d\n",
1614 while (*p == ' ' || *p == '\t')
1619 priv->config &= ~CFG_SPEED_SCAN;
1621 priv->speed_scan_pos = 0;
1622 priv->config |= CFG_SPEED_SCAN;
1628 static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1631 static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1634 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1635 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1638 static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1639 const char *buf, size_t count)
1641 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1643 priv->config |= CFG_NET_STATS;
1645 priv->config &= ~CFG_NET_STATS;
1650 static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1651 show_net_stats, store_net_stats);
1653 static void notify_wx_assoc_event(struct ipw_priv *priv)
1655 union iwreq_data wrqu;
1656 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1657 if (priv->status & STATUS_ASSOCIATED)
1658 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1660 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1661 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1664 static void ipw_irq_tasklet(struct ipw_priv *priv)
1666 u32 inta, inta_mask, handled = 0;
1667 unsigned long flags;
1670 spin_lock_irqsave(&priv->lock, flags);
1672 inta = ipw_read32(priv, IPW_INTA_RW);
1673 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1674 inta &= (IPW_INTA_MASK_ALL & inta_mask);
1676 /* Add any cached INTA values that need to be handled */
1677 inta |= priv->isr_inta;
1679 /* handle all the justifications for the interrupt */
1680 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1682 handled |= IPW_INTA_BIT_RX_TRANSFER;
1685 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1686 IPW_DEBUG_HC("Command completed.\n");
1687 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1688 priv->status &= ~STATUS_HCMD_ACTIVE;
1689 wake_up_interruptible(&priv->wait_command_queue);
1690 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1693 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
1694 IPW_DEBUG_TX("TX_QUEUE_1\n");
1695 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1696 handled |= IPW_INTA_BIT_TX_QUEUE_1;
1699 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
1700 IPW_DEBUG_TX("TX_QUEUE_2\n");
1701 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1702 handled |= IPW_INTA_BIT_TX_QUEUE_2;
1705 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
1706 IPW_DEBUG_TX("TX_QUEUE_3\n");
1707 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1708 handled |= IPW_INTA_BIT_TX_QUEUE_3;
1711 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
1712 IPW_DEBUG_TX("TX_QUEUE_4\n");
1713 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
1714 handled |= IPW_INTA_BIT_TX_QUEUE_4;
1717 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
1718 IPW_WARNING("STATUS_CHANGE\n");
1719 handled |= IPW_INTA_BIT_STATUS_CHANGE;
1722 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
1723 IPW_WARNING("TX_PERIOD_EXPIRED\n");
1724 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
1727 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
1728 IPW_WARNING("HOST_CMD_DONE\n");
1729 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
1732 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
1733 IPW_WARNING("FW_INITIALIZATION_DONE\n");
1734 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
1737 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
1738 IPW_WARNING("PHY_OFF_DONE\n");
1739 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
1742 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
1743 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1744 priv->status |= STATUS_RF_KILL_HW;
1745 wake_up_interruptible(&priv->wait_command_queue);
1746 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1747 cancel_delayed_work(&priv->request_scan);
1748 schedule_work(&priv->link_down);
1749 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
1750 handled |= IPW_INTA_BIT_RF_KILL_DONE;
1753 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1754 IPW_ERROR("Firmware error detected. Restarting.\n");
1756 IPW_ERROR("Sysfs 'error' log already exists.\n");
1757 #ifdef CONFIG_IPW_DEBUG
1758 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1759 struct ipw_fw_error *error =
1760 ipw_alloc_error_log(priv);
1761 ipw_dump_error_log(priv, error);
1763 ipw_free_error_log(error);
1767 priv->error = ipw_alloc_error_log(priv);
1769 IPW_ERROR("Sysfs 'error' log captured.\n");
1771 IPW_ERROR("Error allocating sysfs 'error' "
1773 #ifdef CONFIG_IPW_DEBUG
1774 if (ipw_debug_level & IPW_DL_FW_ERRORS)
1775 ipw_dump_error_log(priv, priv->error);
1779 /* XXX: If hardware encryption is for WPA/WPA2,
1780 * we have to notify the supplicant. */
1781 if (priv->ieee->sec.encrypt) {
1782 priv->status &= ~STATUS_ASSOCIATED;
1783 notify_wx_assoc_event(priv);
1786 /* Keep the restart process from trying to send host
1787 * commands by clearing the INIT status bit */
1788 priv->status &= ~STATUS_INIT;
1790 /* Cancel currently queued command. */
1791 priv->status &= ~STATUS_HCMD_ACTIVE;
1792 wake_up_interruptible(&priv->wait_command_queue);
1794 queue_work(priv->workqueue, &priv->adapter_restart);
1795 handled |= IPW_INTA_BIT_FATAL_ERROR;
1798 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
1799 IPW_ERROR("Parity error\n");
1800 handled |= IPW_INTA_BIT_PARITY_ERROR;
1803 if (handled != inta) {
1804 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
1807 /* enable all interrupts */
1808 ipw_enable_interrupts(priv);
1810 spin_unlock_irqrestore(&priv->lock, flags);
1813 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1814 static char *get_cmd_string(u8 cmd)
1817 IPW_CMD(HOST_COMPLETE);
1818 IPW_CMD(POWER_DOWN);
1819 IPW_CMD(SYSTEM_CONFIG);
1820 IPW_CMD(MULTICAST_ADDRESS);
1822 IPW_CMD(ADAPTER_ADDRESS);
1824 IPW_CMD(RTS_THRESHOLD);
1825 IPW_CMD(FRAG_THRESHOLD);
1826 IPW_CMD(POWER_MODE);
1828 IPW_CMD(TGI_TX_KEY);
1829 IPW_CMD(SCAN_REQUEST);
1830 IPW_CMD(SCAN_REQUEST_EXT);
1832 IPW_CMD(SUPPORTED_RATES);
1833 IPW_CMD(SCAN_ABORT);
1835 IPW_CMD(QOS_PARAMETERS);
1836 IPW_CMD(DINO_CONFIG);
1837 IPW_CMD(RSN_CAPABILITIES);
1839 IPW_CMD(CARD_DISABLE);
1840 IPW_CMD(SEED_NUMBER);
1842 IPW_CMD(COUNTRY_INFO);
1843 IPW_CMD(AIRONET_INFO);
1844 IPW_CMD(AP_TX_POWER);
1846 IPW_CMD(CCX_VER_INFO);
1847 IPW_CMD(SET_CALIBRATION);
1848 IPW_CMD(SENSITIVITY_CALIB);
1849 IPW_CMD(RETRY_LIMIT);
1850 IPW_CMD(IPW_PRE_POWER_DOWN);
1851 IPW_CMD(VAP_BEACON_TEMPLATE);
1852 IPW_CMD(VAP_DTIM_PERIOD);
1853 IPW_CMD(EXT_SUPPORTED_RATES);
1854 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1855 IPW_CMD(VAP_QUIET_INTERVALS);
1856 IPW_CMD(VAP_CHANNEL_SWITCH);
1857 IPW_CMD(VAP_MANDATORY_CHANNELS);
1858 IPW_CMD(VAP_CELL_PWR_LIMIT);
1859 IPW_CMD(VAP_CF_PARAM_SET);
1860 IPW_CMD(VAP_SET_BEACONING_STATE);
1861 IPW_CMD(MEASUREMENT);
1862 IPW_CMD(POWER_CAPABILITY);
1863 IPW_CMD(SUPPORTED_CHANNELS);
1864 IPW_CMD(TPC_REPORT);
1866 IPW_CMD(PRODUCTION_COMMAND);
1872 #define HOST_COMPLETE_TIMEOUT HZ
1873 static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
1876 unsigned long flags;
1878 spin_lock_irqsave(&priv->lock, flags);
1879 if (priv->status & STATUS_HCMD_ACTIVE) {
1880 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1881 get_cmd_string(cmd->cmd));
1882 spin_unlock_irqrestore(&priv->lock, flags);
1886 priv->status |= STATUS_HCMD_ACTIVE;
1889 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1890 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1891 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1892 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1894 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1897 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1898 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1900 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1902 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
1904 priv->status &= ~STATUS_HCMD_ACTIVE;
1905 IPW_ERROR("Failed to send %s: Reason %d\n",
1906 get_cmd_string(cmd->cmd), rc);
1907 spin_unlock_irqrestore(&priv->lock, flags);
1910 spin_unlock_irqrestore(&priv->lock, flags);
1912 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1914 status & STATUS_HCMD_ACTIVE),
1915 HOST_COMPLETE_TIMEOUT);
1917 spin_lock_irqsave(&priv->lock, flags);
1918 if (priv->status & STATUS_HCMD_ACTIVE) {
1919 IPW_ERROR("Failed to send %s: Command timed out.\n",
1920 get_cmd_string(cmd->cmd));
1921 priv->status &= ~STATUS_HCMD_ACTIVE;
1922 spin_unlock_irqrestore(&priv->lock, flags);
1926 spin_unlock_irqrestore(&priv->lock, flags);
1930 if (priv->status & STATUS_RF_KILL_HW) {
1931 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1932 get_cmd_string(cmd->cmd));
1939 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1940 priv->cmdlog_pos %= priv->cmdlog_len;
1945 static int ipw_send_host_complete(struct ipw_priv *priv)
1947 struct host_cmd cmd = {
1948 .cmd = IPW_CMD_HOST_COMPLETE,
1953 IPW_ERROR("Invalid args\n");
1957 return ipw_send_cmd(priv, &cmd);
1960 static int ipw_send_system_config(struct ipw_priv *priv,
1961 struct ipw_sys_config *config)
1963 struct host_cmd cmd = {
1964 .cmd = IPW_CMD_SYSTEM_CONFIG,
1965 .len = sizeof(*config)
1968 if (!priv || !config) {
1969 IPW_ERROR("Invalid args\n");
1973 memcpy(cmd.param, config, sizeof(*config));
1974 return ipw_send_cmd(priv, &cmd);
1977 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
1979 struct host_cmd cmd = {
1980 .cmd = IPW_CMD_SSID,
1981 .len = min(len, IW_ESSID_MAX_SIZE)
1984 if (!priv || !ssid) {
1985 IPW_ERROR("Invalid args\n");
1989 memcpy(cmd.param, ssid, cmd.len);
1990 return ipw_send_cmd(priv, &cmd);
1993 static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
1995 struct host_cmd cmd = {
1996 .cmd = IPW_CMD_ADAPTER_ADDRESS,
2000 if (!priv || !mac) {
2001 IPW_ERROR("Invalid args\n");
2005 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2006 priv->net_dev->name, MAC_ARG(mac));
2008 memcpy(cmd.param, mac, ETH_ALEN);
2009 return ipw_send_cmd(priv, &cmd);
2013 * NOTE: This must be executed from our workqueue as it results in udelay
2014 * being called which may corrupt the keyboard if executed on default
2017 static void ipw_adapter_restart(void *adapter)
2019 struct ipw_priv *priv = adapter;
2021 if (priv->status & STATUS_RF_KILL_MASK)
2026 if (priv->assoc_network &&
2027 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2028 ipw_remove_current_network(priv);
2031 IPW_ERROR("Failed to up device\n");
2036 static void ipw_bg_adapter_restart(void *data)
2038 struct ipw_priv *priv = data;
2040 ipw_adapter_restart(data);
2044 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2046 static void ipw_scan_check(void *data)
2048 struct ipw_priv *priv = data;
2049 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2050 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2051 "adapter (%dms).\n",
2052 IPW_SCAN_CHECK_WATCHDOG / 100);
2053 queue_work(priv->workqueue, &priv->adapter_restart);
2057 static void ipw_bg_scan_check(void *data)
2059 struct ipw_priv *priv = data;
2061 ipw_scan_check(data);
2065 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2066 struct ipw_scan_request_ext *request)
2068 struct host_cmd cmd = {
2069 .cmd = IPW_CMD_SCAN_REQUEST_EXT,
2070 .len = sizeof(*request)
2073 memcpy(cmd.param, request, sizeof(*request));
2074 return ipw_send_cmd(priv, &cmd);
2077 static int ipw_send_scan_abort(struct ipw_priv *priv)
2079 struct host_cmd cmd = {
2080 .cmd = IPW_CMD_SCAN_ABORT,
2085 IPW_ERROR("Invalid args\n");
2089 return ipw_send_cmd(priv, &cmd);
2092 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2094 struct host_cmd cmd = {
2095 .cmd = IPW_CMD_SENSITIVITY_CALIB,
2096 .len = sizeof(struct ipw_sensitivity_calib)
2098 struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
2100 calib->beacon_rssi_raw = sens;
2101 return ipw_send_cmd(priv, &cmd);
2104 static int ipw_send_associate(struct ipw_priv *priv,
2105 struct ipw_associate *associate)
2107 struct host_cmd cmd = {
2108 .cmd = IPW_CMD_ASSOCIATE,
2109 .len = sizeof(*associate)
2112 struct ipw_associate tmp_associate;
2113 memcpy(&tmp_associate, associate, sizeof(*associate));
2114 tmp_associate.policy_support =
2115 cpu_to_le16(tmp_associate.policy_support);
2116 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2117 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2118 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2119 tmp_associate.listen_interval =
2120 cpu_to_le16(tmp_associate.listen_interval);
2121 tmp_associate.beacon_interval =
2122 cpu_to_le16(tmp_associate.beacon_interval);
2123 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2125 if (!priv || !associate) {
2126 IPW_ERROR("Invalid args\n");
2130 memcpy(cmd.param, &tmp_associate, sizeof(*associate));
2131 return ipw_send_cmd(priv, &cmd);
2134 static int ipw_send_supported_rates(struct ipw_priv *priv,
2135 struct ipw_supported_rates *rates)
2137 struct host_cmd cmd = {
2138 .cmd = IPW_CMD_SUPPORTED_RATES,
2139 .len = sizeof(*rates)
2142 if (!priv || !rates) {
2143 IPW_ERROR("Invalid args\n");
2147 memcpy(cmd.param, rates, sizeof(*rates));
2148 return ipw_send_cmd(priv, &cmd);
2151 static int ipw_set_random_seed(struct ipw_priv *priv)
2153 struct host_cmd cmd = {
2154 .cmd = IPW_CMD_SEED_NUMBER,
2159 IPW_ERROR("Invalid args\n");
2163 get_random_bytes(&cmd.param, sizeof(u32));
2165 return ipw_send_cmd(priv, &cmd);
2168 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2170 struct host_cmd cmd = {
2171 .cmd = IPW_CMD_CARD_DISABLE,
2176 IPW_ERROR("Invalid args\n");
2180 *((u32 *) & cmd.param) = phy_off;
2182 return ipw_send_cmd(priv, &cmd);
2185 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2187 struct host_cmd cmd = {
2188 .cmd = IPW_CMD_TX_POWER,
2189 .len = sizeof(*power)
2192 if (!priv || !power) {
2193 IPW_ERROR("Invalid args\n");
2197 memcpy(cmd.param, power, sizeof(*power));
2198 return ipw_send_cmd(priv, &cmd);
2201 static int ipw_set_tx_power(struct ipw_priv *priv)
2203 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
2204 struct ipw_tx_power tx_power;
2208 memset(&tx_power, 0, sizeof(tx_power));
2210 /* configure device for 'G' band */
2211 tx_power.ieee_mode = IPW_G_MODE;
2212 tx_power.num_channels = geo->bg_channels;
2213 for (i = 0; i < geo->bg_channels; i++) {
2214 max_power = geo->bg[i].max_power;
2215 tx_power.channels_tx_power[i].channel_number =
2217 tx_power.channels_tx_power[i].tx_power = max_power ?
2218 min(max_power, priv->tx_power) : priv->tx_power;
2220 if (ipw_send_tx_power(priv, &tx_power))
2223 /* configure device to also handle 'B' band */
2224 tx_power.ieee_mode = IPW_B_MODE;
2225 if (ipw_send_tx_power(priv, &tx_power))
2228 /* configure device to also handle 'A' band */
2229 if (priv->ieee->abg_true) {
2230 tx_power.ieee_mode = IPW_A_MODE;
2231 tx_power.num_channels = geo->a_channels;
2232 for (i = 0; i < tx_power.num_channels; i++) {
2233 max_power = geo->a[i].max_power;
2234 tx_power.channels_tx_power[i].channel_number =
2236 tx_power.channels_tx_power[i].tx_power = max_power ?
2237 min(max_power, priv->tx_power) : priv->tx_power;
2239 if (ipw_send_tx_power(priv, &tx_power))
2245 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2247 struct ipw_rts_threshold rts_threshold = {
2248 .rts_threshold = rts,
2250 struct host_cmd cmd = {
2251 .cmd = IPW_CMD_RTS_THRESHOLD,
2252 .len = sizeof(rts_threshold)
2256 IPW_ERROR("Invalid args\n");
2260 memcpy(cmd.param, &rts_threshold, sizeof(rts_threshold));
2261 return ipw_send_cmd(priv, &cmd);
2264 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2266 struct ipw_frag_threshold frag_threshold = {
2267 .frag_threshold = frag,
2269 struct host_cmd cmd = {
2270 .cmd = IPW_CMD_FRAG_THRESHOLD,
2271 .len = sizeof(frag_threshold)
2275 IPW_ERROR("Invalid args\n");
2279 memcpy(cmd.param, &frag_threshold, sizeof(frag_threshold));
2280 return ipw_send_cmd(priv, &cmd);
2283 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2285 struct host_cmd cmd = {
2286 .cmd = IPW_CMD_POWER_MODE,
2289 u32 *param = (u32 *) (&cmd.param);
2292 IPW_ERROR("Invalid args\n");
2296 /* If on battery, set to 3, if AC set to CAM, else user
2299 case IPW_POWER_BATTERY:
2300 *param = IPW_POWER_INDEX_3;
2303 *param = IPW_POWER_MODE_CAM;
2310 return ipw_send_cmd(priv, &cmd);
2313 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2315 struct ipw_retry_limit retry_limit = {
2316 .short_retry_limit = slimit,
2317 .long_retry_limit = llimit
2319 struct host_cmd cmd = {
2320 .cmd = IPW_CMD_RETRY_LIMIT,
2321 .len = sizeof(retry_limit)
2325 IPW_ERROR("Invalid args\n");
2329 memcpy(cmd.param, &retry_limit, sizeof(retry_limit));
2330 return ipw_send_cmd(priv, &cmd);
2334 * The IPW device contains a Microwire compatible EEPROM that stores
2335 * various data like the MAC address. Usually the firmware has exclusive
2336 * access to the eeprom, but during device initialization (before the
2337 * device driver has sent the HostComplete command to the firmware) the
2338 * device driver has read access to the EEPROM by way of indirect addressing
2339 * through a couple of memory mapped registers.
2341 * The following is a simplified implementation for pulling data out of the
2342 * the eeprom, along with some helper functions to find information in
2343 * the per device private data's copy of the eeprom.
2345 * NOTE: To better understand how these functions work (i.e what is a chip
2346 * select and why do have to keep driving the eeprom clock?), read
2347 * just about any data sheet for a Microwire compatible EEPROM.
2350 /* write a 32 bit value into the indirect accessor register */
2351 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2353 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2355 /* the eeprom requires some time to complete the operation */
2356 udelay(p->eeprom_delay);
2361 /* perform a chip select operation */
2362 static inline void eeprom_cs(struct ipw_priv *priv)
2364 eeprom_write_reg(priv, 0);
2365 eeprom_write_reg(priv, EEPROM_BIT_CS);
2366 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2367 eeprom_write_reg(priv, EEPROM_BIT_CS);
2370 /* perform a chip select operation */
2371 static inline void eeprom_disable_cs(struct ipw_priv *priv)
2373 eeprom_write_reg(priv, EEPROM_BIT_CS);
2374 eeprom_write_reg(priv, 0);
2375 eeprom_write_reg(priv, EEPROM_BIT_SK);
2378 /* push a single bit down to the eeprom */
2379 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2381 int d = (bit ? EEPROM_BIT_DI : 0);
2382 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2383 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2386 /* push an opcode followed by an address down to the eeprom */
2387 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2392 eeprom_write_bit(priv, 1);
2393 eeprom_write_bit(priv, op & 2);
2394 eeprom_write_bit(priv, op & 1);
2395 for (i = 7; i >= 0; i--) {
2396 eeprom_write_bit(priv, addr & (1 << i));
2400 /* pull 16 bits off the eeprom, one bit at a time */
2401 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2406 /* Send READ Opcode */
2407 eeprom_op(priv, EEPROM_CMD_READ, addr);
2409 /* Send dummy bit */
2410 eeprom_write_reg(priv, EEPROM_BIT_CS);
2412 /* Read the byte off the eeprom one bit at a time */
2413 for (i = 0; i < 16; i++) {
2415 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2416 eeprom_write_reg(priv, EEPROM_BIT_CS);
2417 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2418 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2421 /* Send another dummy bit */
2422 eeprom_write_reg(priv, 0);
2423 eeprom_disable_cs(priv);
2428 /* helper function for pulling the mac address out of the private */
2429 /* data's copy of the eeprom data */
2430 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2432 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
2436 * Either the device driver (i.e. the host) or the firmware can
2437 * load eeprom data into the designated region in SRAM. If neither
2438 * happens then the FW will shutdown with a fatal error.
2440 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2441 * bit needs region of shared SRAM needs to be non-zero.
2443 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2446 u16 *eeprom = (u16 *) priv->eeprom;
2448 IPW_DEBUG_TRACE(">>\n");
2450 /* read entire contents of eeprom into private buffer */
2451 for (i = 0; i < 128; i++)
2452 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
2455 If the data looks correct, then copy it to our private
2456 copy. Otherwise let the firmware know to perform the operation
2459 if ((priv->eeprom + EEPROM_VERSION) != 0) {
2460 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2462 /* write the eeprom data to sram */
2463 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2464 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2466 /* Do not load eeprom data on fatal error or suspend */
2467 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2469 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2471 /* Load eeprom data on fatal error or suspend */
2472 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2475 IPW_DEBUG_TRACE("<<\n");
2478 static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2483 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2485 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2488 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2490 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2491 CB_NUMBER_OF_ELEMENTS_SMALL *
2492 sizeof(struct command_block));
2495 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2496 { /* start dma engine but no transfers yet */
2498 IPW_DEBUG_FW(">> : \n");
2501 ipw_fw_dma_reset_command_blocks(priv);
2503 /* Write CB base address */
2504 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2506 IPW_DEBUG_FW("<< : \n");
2510 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2514 IPW_DEBUG_FW(">> :\n");
2516 //set the Stop and Abort bit
2517 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2518 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2519 priv->sram_desc.last_cb_index = 0;
2521 IPW_DEBUG_FW("<< \n");
2524 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2525 struct command_block *cb)
2528 IPW_SHARED_SRAM_DMA_CONTROL +
2529 (sizeof(struct command_block) * index);
2530 IPW_DEBUG_FW(">> :\n");
2532 ipw_write_indirect(priv, address, (u8 *) cb,
2533 (int)sizeof(struct command_block));
2535 IPW_DEBUG_FW("<< :\n");
2540 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2545 IPW_DEBUG_FW(">> :\n");
2547 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2548 ipw_fw_dma_write_command_block(priv, index,
2549 &priv->sram_desc.cb_list[index]);
2551 /* Enable the DMA in the CSR register */
2552 ipw_clear_bit(priv, IPW_RESET_REG,
2553 IPW_RESET_REG_MASTER_DISABLED |
2554 IPW_RESET_REG_STOP_MASTER);
2556 /* Set the Start bit. */
2557 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2558 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2560 IPW_DEBUG_FW("<< :\n");
2564 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2567 u32 register_value = 0;
2568 u32 cb_fields_address = 0;
2570 IPW_DEBUG_FW(">> :\n");
2571 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2572 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
2574 /* Read the DMA Controlor register */
2575 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2576 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
2578 /* Print the CB values */
2579 cb_fields_address = address;
2580 register_value = ipw_read_reg32(priv, cb_fields_address);
2581 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
2583 cb_fields_address += sizeof(u32);
2584 register_value = ipw_read_reg32(priv, cb_fields_address);
2585 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
2587 cb_fields_address += sizeof(u32);
2588 register_value = ipw_read_reg32(priv, cb_fields_address);
2589 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2592 cb_fields_address += sizeof(u32);
2593 register_value = ipw_read_reg32(priv, cb_fields_address);
2594 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
2596 IPW_DEBUG_FW(">> :\n");
2599 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2601 u32 current_cb_address = 0;
2602 u32 current_cb_index = 0;
2604 IPW_DEBUG_FW("<< :\n");
2605 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2607 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2608 sizeof(struct command_block);
2610 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
2611 current_cb_index, current_cb_address);
2613 IPW_DEBUG_FW(">> :\n");
2614 return current_cb_index;
2618 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2622 int interrupt_enabled, int is_last)
2625 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2626 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2628 struct command_block *cb;
2629 u32 last_cb_element = 0;
2631 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2632 src_address, dest_address, length);
2634 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2637 last_cb_element = priv->sram_desc.last_cb_index;
2638 cb = &priv->sram_desc.cb_list[last_cb_element];
2639 priv->sram_desc.last_cb_index++;
2641 /* Calculate the new CB control word */
2642 if (interrupt_enabled)
2643 control |= CB_INT_ENABLED;
2646 control |= CB_LAST_VALID;
2650 /* Calculate the CB Element's checksum value */
2651 cb->status = control ^ src_address ^ dest_address;
2653 /* Copy the Source and Destination addresses */
2654 cb->dest_addr = dest_address;
2655 cb->source_addr = src_address;
2657 /* Copy the Control Word last */
2658 cb->control = control;
2663 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
2664 u32 src_phys, u32 dest_address, u32 length)
2666 u32 bytes_left = length;
2668 u32 dest_offset = 0;
2670 IPW_DEBUG_FW(">> \n");
2671 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2672 src_phys, dest_address, length);
2673 while (bytes_left > CB_MAX_LENGTH) {
2674 status = ipw_fw_dma_add_command_block(priv,
2675 src_phys + src_offset,
2678 CB_MAX_LENGTH, 0, 0);
2680 IPW_DEBUG_FW_INFO(": Failed\n");
2683 IPW_DEBUG_FW_INFO(": Added new cb\n");
2685 src_offset += CB_MAX_LENGTH;
2686 dest_offset += CB_MAX_LENGTH;
2687 bytes_left -= CB_MAX_LENGTH;
2690 /* add the buffer tail */
2691 if (bytes_left > 0) {
2693 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2694 dest_address + dest_offset,
2697 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2701 (": Adding new cb - the buffer tail\n");
2704 IPW_DEBUG_FW("<< \n");
2708 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2710 u32 current_index = 0;
2713 IPW_DEBUG_FW(">> : \n");
2715 current_index = ipw_fw_dma_command_block_index(priv);
2716 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%8X\n",
2717 (int)priv->sram_desc.last_cb_index);
2719 while (current_index < priv->sram_desc.last_cb_index) {
2721 current_index = ipw_fw_dma_command_block_index(priv);
2725 if (watchdog > 400) {
2726 IPW_DEBUG_FW_INFO("Timeout\n");
2727 ipw_fw_dma_dump_command_block(priv);
2728 ipw_fw_dma_abort(priv);
2733 ipw_fw_dma_abort(priv);
2735 /*Disable the DMA in the CSR register */
2736 ipw_set_bit(priv, IPW_RESET_REG,
2737 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2739 IPW_DEBUG_FW("<< dmaWaitSync \n");
2743 static void ipw_remove_current_network(struct ipw_priv *priv)
2745 struct list_head *element, *safe;
2746 struct ieee80211_network *network = NULL;
2747 unsigned long flags;
2749 spin_lock_irqsave(&priv->ieee->lock, flags);
2750 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2751 network = list_entry(element, struct ieee80211_network, list);
2752 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2754 list_add_tail(&network->list,
2755 &priv->ieee->network_free_list);
2758 spin_unlock_irqrestore(&priv->ieee->lock, flags);
2762 * Check that card is still alive.
2763 * Reads debug register from domain0.
2764 * If card is present, pre-defined value should
2768 * @return 1 if card is present, 0 otherwise
2770 static inline int ipw_alive(struct ipw_priv *priv)
2772 return ipw_read32(priv, 0x90) == 0xd55555d5;
2775 static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2781 if ((ipw_read32(priv, addr) & mask) == mask)
2785 } while (i < timeout);
2790 /* These functions load the firmware and micro code for the operation of
2791 * the ipw hardware. It assumes the buffer has all the bits for the
2792 * image and the caller is handling the memory allocation and clean up.
2795 static int ipw_stop_master(struct ipw_priv *priv)
2799 IPW_DEBUG_TRACE(">> \n");
2800 /* stop master. typical delay - 0 */
2801 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2803 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2804 IPW_RESET_REG_MASTER_DISABLED, 100);
2806 IPW_ERROR("stop master failed in 10ms\n");
2810 IPW_DEBUG_INFO("stop master %dms\n", rc);
2815 static void ipw_arc_release(struct ipw_priv *priv)
2817 IPW_DEBUG_TRACE(">> \n");
2820 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2822 /* no one knows timing, for safety add some delay */
2836 #define IPW_FW_MAJOR_VERSION 2
2837 #define IPW_FW_MINOR_VERSION 3
2839 #define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2840 #define IPW_FW_MAJOR(x) (x & 0xff)
2842 #define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2844 #define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2845 "." __stringify(IPW_FW_MINOR_VERSION) "-"
2847 #if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2848 #define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2850 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2853 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2855 int rc = 0, i, addr;
2859 image = (u16 *) data;
2861 IPW_DEBUG_TRACE(">> \n");
2863 rc = ipw_stop_master(priv);
2868 // spin_lock_irqsave(&priv->lock, flags);
2870 for (addr = IPW_SHARED_LOWER_BOUND;
2871 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2872 ipw_write32(priv, addr, 0);
2875 /* no ucode (yet) */
2876 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2877 /* destroy DMA queues */
2878 /* reset sequence */
2880 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2881 ipw_arc_release(priv);
2882 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2886 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2889 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2892 /* enable ucode store */
2893 ipw_write_reg8(priv, DINO_CONTROL_REG, 0x0);
2894 ipw_write_reg8(priv, DINO_CONTROL_REG, DINO_ENABLE_CS);
2900 * Do NOT set indirect address register once and then
2901 * store data to indirect data register in the loop.
2902 * It seems very reasonable, but in this case DINO do not
2903 * accept ucode. It is essential to set address each time.
2905 /* load new ipw uCode */
2906 for (i = 0; i < len / 2; i++)
2907 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2908 cpu_to_le16(image[i]));
2911 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2912 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2914 /* this is where the igx / win driver deveates from the VAP driver. */
2916 /* wait for alive response */
2917 for (i = 0; i < 100; i++) {
2918 /* poll for incoming data */
2919 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2920 if (cr & DINO_RXFIFO_DATA)
2925 if (cr & DINO_RXFIFO_DATA) {
2926 /* alive_command_responce size is NOT multiple of 4 */
2927 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2929 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2930 response_buffer[i] =
2931 le32_to_cpu(ipw_read_reg32(priv,
2932 IPW_BASEBAND_RX_FIFO_READ));
2933 memcpy(&priv->dino_alive, response_buffer,
2934 sizeof(priv->dino_alive));
2935 if (priv->dino_alive.alive_command == 1
2936 && priv->dino_alive.ucode_valid == 1) {
2939 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2940 "of %02d/%02d/%02d %02d:%02d\n",
2941 priv->dino_alive.software_revision,
2942 priv->dino_alive.software_revision,
2943 priv->dino_alive.device_identifier,
2944 priv->dino_alive.device_identifier,
2945 priv->dino_alive.time_stamp[0],
2946 priv->dino_alive.time_stamp[1],
2947 priv->dino_alive.time_stamp[2],
2948 priv->dino_alive.time_stamp[3],
2949 priv->dino_alive.time_stamp[4]);
2951 IPW_DEBUG_INFO("Microcode is not alive\n");
2955 IPW_DEBUG_INFO("No alive response from DINO\n");
2959 /* disable DINO, otherwise for some reason
2960 firmware have problem getting alive resp. */
2961 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2963 // spin_unlock_irqrestore(&priv->lock, flags);
2968 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
2972 struct fw_chunk *chunk;
2973 dma_addr_t shared_phys;
2976 IPW_DEBUG_TRACE("<< : \n");
2977 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2982 memmove(shared_virt, data, len);
2985 rc = ipw_fw_dma_enable(priv);
2987 if (priv->sram_desc.last_cb_index > 0) {
2988 /* the DMA is already ready this would be a bug. */
2994 chunk = (struct fw_chunk *)(data + offset);
2995 offset += sizeof(struct fw_chunk);
2996 /* build DMA packet and queue up for sending */
2997 /* dma to chunk->address, the chunk->length bytes from data +
3000 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3001 le32_to_cpu(chunk->address),
3002 le32_to_cpu(chunk->length));
3004 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3008 offset += le32_to_cpu(chunk->length);
3009 } while (offset < len);
3011 /* Run the DMA and wait for the answer */
3012 rc = ipw_fw_dma_kick(priv);
3014 IPW_ERROR("dmaKick Failed\n");
3018 rc = ipw_fw_dma_wait(priv);
3020 IPW_ERROR("dmaWaitSync Failed\n");
3024 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
3029 static int ipw_stop_nic(struct ipw_priv *priv)
3034 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3036 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3037 IPW_RESET_REG_MASTER_DISABLED, 500);
3039 IPW_ERROR("wait for reg master disabled failed\n");
3043 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3048 static void ipw_start_nic(struct ipw_priv *priv)
3050 IPW_DEBUG_TRACE(">>\n");
3052 /* prvHwStartNic release ARC */
3053 ipw_clear_bit(priv, IPW_RESET_REG,
3054 IPW_RESET_REG_MASTER_DISABLED |
3055 IPW_RESET_REG_STOP_MASTER |
3056 CBD_RESET_REG_PRINCETON_RESET);
3058 /* enable power management */
3059 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3060 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3062 IPW_DEBUG_TRACE("<<\n");
3065 static int ipw_init_nic(struct ipw_priv *priv)
3069 IPW_DEBUG_TRACE(">>\n");
3072 /* set "initialization complete" bit to move adapter to D0 state */
3073 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3075 /* low-level PLL activation */
3076 ipw_write32(priv, IPW_READ_INT_REGISTER,
3077 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3079 /* wait for clock stabilization */
3080 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3081 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3083 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3085 /* assert SW reset */
3086 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3090 /* set "initialization complete" bit to move adapter to D0 state */
3091 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3093 IPW_DEBUG_TRACE(">>\n");
3097 /* Call this function from process context, it will sleep in request_firmware.
3098 * Probe is an ok place to call this from.
3100 static int ipw_reset_nic(struct ipw_priv *priv)
3103 unsigned long flags;
3105 IPW_DEBUG_TRACE(">>\n");
3107 rc = ipw_init_nic(priv);
3109 spin_lock_irqsave(&priv->lock, flags);
3110 /* Clear the 'host command active' bit... */
3111 priv->status &= ~STATUS_HCMD_ACTIVE;
3112 wake_up_interruptible(&priv->wait_command_queue);
3113 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3114 wake_up_interruptible(&priv->wait_state);
3115 spin_unlock_irqrestore(&priv->lock, flags);
3117 IPW_DEBUG_TRACE("<<\n");
3121 static int ipw_get_fw(struct ipw_priv *priv,
3122 const struct firmware **fw, const char *name)
3124 struct fw_header *header;
3127 /* ask firmware_class module to get the boot firmware off disk */
3128 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3130 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3134 header = (struct fw_header *)(*fw)->data;
3135 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
3136 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3138 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3139 IPW_FW_MAJOR_VERSION);
3143 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
3145 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3146 IPW_FW_MINOR(le32_to_cpu(header->version)),
3147 (*fw)->size - sizeof(struct fw_header));
3151 #define IPW_RX_BUF_SIZE (3000)
3153 static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
3154 struct ipw_rx_queue *rxq)
3156 unsigned long flags;
3159 spin_lock_irqsave(&rxq->lock, flags);
3161 INIT_LIST_HEAD(&rxq->rx_free);
3162 INIT_LIST_HEAD(&rxq->rx_used);
3164 /* Fill the rx_used queue with _all_ of the Rx buffers */
3165 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3166 /* In the reset function, these buffers may have been allocated
3167 * to an SKB, so we need to unmap and free potential storage */
3168 if (rxq->pool[i].skb != NULL) {
3169 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3170 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3171 dev_kfree_skb(rxq->pool[i].skb);
3172 rxq->pool[i].skb = NULL;
3174 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3177 /* Set us so that we have processed and used all buffers, but have
3178 * not restocked the Rx queue with fresh buffers */
3179 rxq->read = rxq->write = 0;
3180 rxq->processed = RX_QUEUE_SIZE - 1;
3181 rxq->free_count = 0;
3182 spin_unlock_irqrestore(&rxq->lock, flags);
3186 static int fw_loaded = 0;
3187 static const struct firmware *bootfw = NULL;
3188 static const struct firmware *firmware = NULL;
3189 static const struct firmware *ucode = NULL;
3191 static void free_firmware(void)
3194 release_firmware(bootfw);
3195 release_firmware(ucode);
3196 release_firmware(firmware);
3197 bootfw = ucode = firmware = NULL;
3202 #define free_firmware() do {} while (0)
3205 static int ipw_load(struct ipw_priv *priv)
3208 const struct firmware *bootfw = NULL;
3209 const struct firmware *firmware = NULL;
3210 const struct firmware *ucode = NULL;
3212 int rc = 0, retries = 3;
3217 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3221 switch (priv->ieee->iw_mode) {
3223 rc = ipw_get_fw(priv, &ucode,
3224 IPW_FW_NAME("ibss_ucode"));
3228 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
3231 #ifdef CONFIG_IPW2200_MONITOR
3232 case IW_MODE_MONITOR:
3233 rc = ipw_get_fw(priv, &ucode,
3234 IPW_FW_NAME("sniffer_ucode"));
3238 rc = ipw_get_fw(priv, &firmware,
3239 IPW_FW_NAME("sniffer"));
3243 rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
3247 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("bss"));
3263 priv->rxq = ipw_rx_queue_alloc(priv);
3265 ipw_rx_queue_reset(priv, priv->rxq);
3267 IPW_ERROR("Unable to initialize Rx queue\n");
3272 /* Ensure interrupts are disabled */
3273 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3274 priv->status &= ~STATUS_INT_ENABLED;
3276 /* ack pending interrupts */
3277 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3281 rc = ipw_reset_nic(priv);
3283 IPW_ERROR("Unable to reset NIC\n");
3287 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3288 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3290 /* DMA the initial boot firmware into the device */
3291 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
3292 bootfw->size - sizeof(struct fw_header));
3294 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3298 /* kick start the device */
3299 ipw_start_nic(priv);
3301 /* wait for the device to finish it's initial startup sequence */
3302 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3303 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3305 IPW_ERROR("device failed to boot initial fw image\n");
3308 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3310 /* ack fw init done interrupt */
3311 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3313 /* DMA the ucode into the device */
3314 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
3315 ucode->size - sizeof(struct fw_header));
3317 IPW_ERROR("Unable to load ucode: %d\n", rc);
3324 /* DMA bss firmware into the device */
3325 rc = ipw_load_firmware(priv, firmware->data +
3326 sizeof(struct fw_header),
3327 firmware->size - sizeof(struct fw_header));
3329 IPW_ERROR("Unable to load firmware: %d\n", rc);
3333 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3335 rc = ipw_queue_reset(priv);
3337 IPW_ERROR("Unable to initialize queues\n");
3341 /* Ensure interrupts are disabled */
3342 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3343 /* ack pending interrupts */
3344 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3346 /* kick start the device */
3347 ipw_start_nic(priv);
3349 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3351 IPW_WARNING("Parity error. Retrying init.\n");
3356 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3361 /* wait for the device */
3362 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3363 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3365 IPW_ERROR("device failed to start after 500ms\n");
3368 IPW_DEBUG_INFO("device response after %dms\n", rc);
3370 /* ack fw init done interrupt */
3371 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3373 /* read eeprom data and initialize the eeprom region of sram */
3374 priv->eeprom_delay = 1;
3375 ipw_eeprom_init_sram(priv);
3377 /* enable interrupts */
3378 ipw_enable_interrupts(priv);
3380 /* Ensure our queue has valid packets */
3381 ipw_rx_queue_replenish(priv);
3383 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3385 /* ack pending interrupts */
3386 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3389 release_firmware(bootfw);
3390 release_firmware(ucode);
3391 release_firmware(firmware);
3397 ipw_rx_queue_free(priv, priv->rxq);
3400 ipw_tx_queue_free(priv);
3402 release_firmware(bootfw);
3404 release_firmware(ucode);
3406 release_firmware(firmware);
3409 bootfw = ucode = firmware = NULL;
3418 * Theory of operation
3420 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3421 * 2 empty entries always kept in the buffer to protect from overflow.
3423 * For Tx queue, there are low mark and high mark limits. If, after queuing
3424 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3425 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3428 * The IPW operates with six queues, one receive queue in the device's
3429 * sram, one transmit queue for sending commands to the device firmware,
3430 * and four transmit queues for data.
3432 * The four transmit queues allow for performing quality of service (qos)
3433 * transmissions as per the 802.11 protocol. Currently Linux does not
3434 * provide a mechanism to the user for utilizing prioritized queues, so
3435 * we only utilize the first data transmit queue (queue1).
3439 * Driver allocates buffers of this size for Rx
3442 static inline int ipw_queue_space(const struct clx2_queue *q)
3444 int s = q->last_used - q->first_empty;
3447 s -= 2; /* keep some reserve to not confuse empty and full situations */
3453 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3455 return (++index == n_bd) ? 0 : index;
3459 * Initialize common DMA queue structure
3461 * @param q queue to init
3462 * @param count Number of BD's to allocate. Should be power of 2
3463 * @param read_register Address for 'read' register
3464 * (not offset within BAR, full address)
3465 * @param write_register Address for 'write' register
3466 * (not offset within BAR, full address)
3467 * @param base_register Address for 'base' register
3468 * (not offset within BAR, full address)
3469 * @param size Address for 'size' register
3470 * (not offset within BAR, full address)
3472 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3473 int count, u32 read, u32 write, u32 base, u32 size)
3477 q->low_mark = q->n_bd / 4;
3478 if (q->low_mark < 4)
3481 q->high_mark = q->n_bd / 8;
3482 if (q->high_mark < 2)
3485 q->first_empty = q->last_used = 0;
3489 ipw_write32(priv, base, q->dma_addr);
3490 ipw_write32(priv, size, count);
3491 ipw_write32(priv, read, 0);
3492 ipw_write32(priv, write, 0);
3494 _ipw_read32(priv, 0x90);
3497 static int ipw_queue_tx_init(struct ipw_priv *priv,
3498 struct clx2_tx_queue *q,
3499 int count, u32 read, u32 write, u32 base, u32 size)
3501 struct pci_dev *dev = priv->pci_dev;
3503 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3505 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3510 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3512 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3513 sizeof(q->bd[0]) * count);
3519 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3524 * Free one TFD, those at index [txq->q.last_used].
3525 * Do NOT advance any indexes
3530 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3531 struct clx2_tx_queue *txq)
3533 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3534 struct pci_dev *dev = priv->pci_dev;
3538 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3539 /* nothing to cleanup after for host commands */
3543 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3544 IPW_ERROR("Too many chunks: %i\n",
3545 le32_to_cpu(bd->u.data.num_chunks));
3546 /** @todo issue fatal error, it is quite serious situation */
3550 /* unmap chunks if any */
3551 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3552 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3553 le16_to_cpu(bd->u.data.chunk_len[i]),
3555 if (txq->txb[txq->q.last_used]) {
3556 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3557 txq->txb[txq->q.last_used] = NULL;
3563 * Deallocate DMA queue.
3565 * Empty queue by removing and destroying all BD's.
3571 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3573 struct clx2_queue *q = &txq->q;
3574 struct pci_dev *dev = priv->pci_dev;
3579 /* first, empty all BD's */
3580 for (; q->first_empty != q->last_used;
3581 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3582 ipw_queue_tx_free_tfd(priv, txq);
3585 /* free buffers belonging to queue itself */
3586 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3590 /* 0 fill whole structure */
3591 memset(txq, 0, sizeof(*txq));
3595 * Destroy all DMA queues and structures
3599 static void ipw_tx_queue_free(struct ipw_priv *priv)
3602 ipw_queue_tx_free(priv, &priv->txq_cmd);
3605 ipw_queue_tx_free(priv, &priv->txq[0]);
3606 ipw_queue_tx_free(priv, &priv->txq[1]);
3607 ipw_queue_tx_free(priv, &priv->txq[2]);
3608 ipw_queue_tx_free(priv, &priv->txq[3]);
3611 static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3613 /* First 3 bytes are manufacturer */
3614 bssid[0] = priv->mac_addr[0];
3615 bssid[1] = priv->mac_addr[1];
3616 bssid[2] = priv->mac_addr[2];
3618 /* Last bytes are random */
3619 get_random_bytes(&bssid[3], ETH_ALEN - 3);
3621 bssid[0] &= 0xfe; /* clear multicast bit */
3622 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
3625 static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3627 struct ipw_station_entry entry;
3630 for (i = 0; i < priv->num_stations; i++) {
3631 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3632 /* Another node is active in network */
3633 priv->missed_adhoc_beacons = 0;
3634 if (!(priv->config & CFG_STATIC_CHANNEL))
3635 /* when other nodes drop out, we drop out */
3636 priv->config &= ~CFG_ADHOC_PERSIST;
3642 if (i == MAX_STATIONS)
3643 return IPW_INVALID_STATION;
3645 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3648 entry.support_mode = 0;
3649 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3650 memcpy(priv->stations[i], bssid, ETH_ALEN);
3651 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3652 &entry, sizeof(entry));
3653 priv->num_stations++;
3658 static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3662 for (i = 0; i < priv->num_stations; i++)
3663 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3666 return IPW_INVALID_STATION;
3669 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3673 if (priv->status & STATUS_ASSOCIATING) {
3674 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3675 queue_work(priv->workqueue, &priv->disassociate);
3679 if (!(priv->status & STATUS_ASSOCIATED)) {
3680 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3684 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3686 MAC_ARG(priv->assoc_request.bssid),
3687 priv->assoc_request.channel);
3689 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3690 priv->status |= STATUS_DISASSOCIATING;
3693 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3695 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3697 err = ipw_send_associate(priv, &priv->assoc_request);
3699 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3706 static int ipw_disassociate(void *data)
3708 struct ipw_priv *priv = data;
3709 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3711 ipw_send_disassociate(data, 0);
3715 static void ipw_bg_disassociate(void *data)
3717 struct ipw_priv *priv = data;
3719 ipw_disassociate(data);
3723 static void ipw_system_config(void *data)
3725 struct ipw_priv *priv = data;
3726 ipw_send_system_config(priv, &priv->sys_config);
3729 struct ipw_status_code {
3734 static const struct ipw_status_code ipw_status_codes[] = {
3735 {0x00, "Successful"},
3736 {0x01, "Unspecified failure"},
3737 {0x0A, "Cannot support all requested capabilities in the "
3738 "Capability information field"},
3739 {0x0B, "Reassociation denied due to inability to confirm that "
3740 "association exists"},
3741 {0x0C, "Association denied due to reason outside the scope of this "
3744 "Responding station does not support the specified authentication "
3747 "Received an Authentication frame with authentication sequence "
3748 "transaction sequence number out of expected sequence"},
3749 {0x0F, "Authentication rejected because of challenge failure"},
3750 {0x10, "Authentication rejected due to timeout waiting for next "
3751 "frame in sequence"},
3752 {0x11, "Association denied because AP is unable to handle additional "
3753 "associated stations"},
3755 "Association denied due to requesting station not supporting all "
3756 "of the datarates in the BSSBasicServiceSet Parameter"},
3758 "Association denied due to requesting station not supporting "
3759 "short preamble operation"},
3761 "Association denied due to requesting station not supporting "
3764 "Association denied due to requesting station not supporting "
3767 "Association denied due to requesting station not supporting "
3768 "short slot operation"},
3770 "Association denied due to requesting station not supporting "
3771 "DSSS-OFDM operation"},
3772 {0x28, "Invalid Information Element"},
3773 {0x29, "Group Cipher is not valid"},
3774 {0x2A, "Pairwise Cipher is not valid"},
3775 {0x2B, "AKMP is not valid"},
3776 {0x2C, "Unsupported RSN IE version"},
3777 {0x2D, "Invalid RSN IE Capabilities"},
3778 {0x2E, "Cipher suite is rejected per security policy"},
3781 #ifdef CONFIG_IPW_DEBUG
3782 static const char *ipw_get_status_code(u16 status)
3785 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3786 if (ipw_status_codes[i].status == (status & 0xff))
3787 return ipw_status_codes[i].reason;
3788 return "Unknown status value.";
3792 static void inline average_init(struct average *avg)
3794 memset(avg, 0, sizeof(*avg));
3797 static void inline average_add(struct average *avg, s16 val)
3799 avg->sum -= avg->entries[avg->pos];
3801 avg->entries[avg->pos++] = val;
3802 if (unlikely(avg->pos == AVG_ENTRIES)) {
3808 static s16 inline average_value(struct average *avg)
3810 if (!unlikely(avg->init)) {
3812 return avg->sum / avg->pos;
3816 return avg->sum / AVG_ENTRIES;
3819 static void ipw_reset_stats(struct ipw_priv *priv)
3821 u32 len = sizeof(u32);
3825 average_init(&priv->average_missed_beacons);
3826 average_init(&priv->average_rssi);
3827 average_init(&priv->average_noise);
3829 priv->last_rate = 0;
3830 priv->last_missed_beacons = 0;
3831 priv->last_rx_packets = 0;
3832 priv->last_tx_packets = 0;
3833 priv->last_tx_failures = 0;
3835 /* Firmware managed, reset only when NIC is restarted, so we have to
3836 * normalize on the current value */
3837 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
3838 &priv->last_rx_err, &len);
3839 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
3840 &priv->last_tx_failures, &len);
3842 /* Driver managed, reset with each association */
3843 priv->missed_adhoc_beacons = 0;
3844 priv->missed_beacons = 0;
3845 priv->tx_packets = 0;
3846 priv->rx_packets = 0;
3850 static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
3853 u32 mask = priv->rates_mask;
3854 /* If currently associated in B mode, restrict the maximum
3855 * rate match to B rates */
3856 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3857 mask &= IEEE80211_CCK_RATES_MASK;
3859 /* TODO: Verify that the rate is supported by the current rates
3862 while (i && !(mask & i))
3865 case IEEE80211_CCK_RATE_1MB_MASK:
3867 case IEEE80211_CCK_RATE_2MB_MASK:
3869 case IEEE80211_CCK_RATE_5MB_MASK:
3871 case IEEE80211_OFDM_RATE_6MB_MASK:
3873 case IEEE80211_OFDM_RATE_9MB_MASK:
3875 case IEEE80211_CCK_RATE_11MB_MASK:
3877 case IEEE80211_OFDM_RATE_12MB_MASK:
3879 case IEEE80211_OFDM_RATE_18MB_MASK:
3881 case IEEE80211_OFDM_RATE_24MB_MASK:
3883 case IEEE80211_OFDM_RATE_36MB_MASK:
3885 case IEEE80211_OFDM_RATE_48MB_MASK:
3887 case IEEE80211_OFDM_RATE_54MB_MASK:
3891 if (priv->ieee->mode == IEEE_B)
3897 static u32 ipw_get_current_rate(struct ipw_priv *priv)
3899 u32 rate, len = sizeof(rate);
3902 if (!(priv->status & STATUS_ASSOCIATED))
3905 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3906 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
3909 IPW_DEBUG_INFO("failed querying ordinals.\n");
3913 return ipw_get_max_rate(priv);
3916 case IPW_TX_RATE_1MB:
3918 case IPW_TX_RATE_2MB:
3920 case IPW_TX_RATE_5MB:
3922 case IPW_TX_RATE_6MB:
3924 case IPW_TX_RATE_9MB:
3926 case IPW_TX_RATE_11MB:
3928 case IPW_TX_RATE_12MB:
3930 case IPW_TX_RATE_18MB:
3932 case IPW_TX_RATE_24MB:
3934 case IPW_TX_RATE_36MB:
3936 case IPW_TX_RATE_48MB:
3938 case IPW_TX_RATE_54MB:
3945 #define IPW_STATS_INTERVAL (2 * HZ)
3946 static void ipw_gather_stats(struct ipw_priv *priv)
3948 u32 rx_err, rx_err_delta, rx_packets_delta;
3949 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3950 u32 missed_beacons_percent, missed_beacons_delta;
3952 u32 len = sizeof(u32);
3954 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3958 if (!(priv->status & STATUS_ASSOCIATED)) {
3963 /* Update the statistics */
3964 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
3965 &priv->missed_beacons, &len);
3966 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
3967 priv->last_missed_beacons = priv->missed_beacons;
3968 if (priv->assoc_request.beacon_interval) {
3969 missed_beacons_percent = missed_beacons_delta *
3970 (HZ * priv->assoc_request.beacon_interval) /
3971 (IPW_STATS_INTERVAL * 10);
3973 missed_beacons_percent = 0;
3975 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3977 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3978 rx_err_delta = rx_err - priv->last_rx_err;
3979 priv->last_rx_err = rx_err;
3981 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3982 tx_failures_delta = tx_failures - priv->last_tx_failures;
3983 priv->last_tx_failures = tx_failures;
3985 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
3986 priv->last_rx_packets = priv->rx_packets;
3988 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
3989 priv->last_tx_packets = priv->tx_packets;
3991 /* Calculate quality based on the following:
3993 * Missed beacon: 100% = 0, 0% = 70% missed
3994 * Rate: 60% = 1Mbs, 100% = Max
3995 * Rx and Tx errors represent a straight % of total Rx/Tx
3996 * RSSI: 100% = > -50, 0% = < -80
3997 * Rx errors: 100% = 0, 0% = 50% missed
3999 * The lowest computed quality is used.
4002 #define BEACON_THRESHOLD 5
4003 beacon_quality = 100 - missed_beacons_percent;
4004 if (beacon_quality < BEACON_THRESHOLD)
4007 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4008 (100 - BEACON_THRESHOLD);
4009 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4010 beacon_quality, missed_beacons_percent);
4012 priv->last_rate = ipw_get_current_rate(priv);
4013 max_rate = ipw_get_max_rate(priv);
4014 rate_quality = priv->last_rate * 40 / max_rate + 60;
4015 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4016 rate_quality, priv->last_rate / 1000000);
4018 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4019 rx_quality = 100 - (rx_err_delta * 100) /
4020 (rx_packets_delta + rx_err_delta);
4023 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4024 rx_quality, rx_err_delta, rx_packets_delta);
4026 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4027 tx_quality = 100 - (tx_failures_delta * 100) /
4028 (tx_packets_delta + tx_failures_delta);
4031 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4032 tx_quality, tx_failures_delta, tx_packets_delta);
4034 rssi = average_value(&priv->average_rssi);
4037 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4038 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4039 (priv->ieee->perfect_rssi - rssi) *
4040 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4041 62 * (priv->ieee->perfect_rssi - rssi))) /
4042 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4043 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4044 if (signal_quality > 100)
4045 signal_quality = 100;
4046 else if (signal_quality < 1)
4049 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4050 signal_quality, rssi);
4052 quality = min(beacon_quality,
4054 min(tx_quality, min(rx_quality, signal_quality))));
4055 if (quality == beacon_quality)
4056 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4058 if (quality == rate_quality)
4059 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4061 if (quality == tx_quality)
4062 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4064 if (quality == rx_quality)
4065 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4067 if (quality == signal_quality)
4068 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4071 priv->quality = quality;
4073 queue_delayed_work(priv->workqueue, &priv->gather_stats,
4074 IPW_STATS_INTERVAL);
4077 static void ipw_bg_gather_stats(void *data)
4079 struct ipw_priv *priv = data;
4081 ipw_gather_stats(data);
4085 static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
4088 priv->notif_missed_beacons = missed_count;
4090 if (missed_count > priv->disassociate_threshold &&
4091 priv->status & STATUS_ASSOCIATED) {
4092 /* If associated and we've hit the missed
4093 * beacon threshold, disassociate, turn
4094 * off roaming, and abort any active scans */
4095 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4096 IPW_DL_STATE | IPW_DL_ASSOC,
4097 "Missed beacon: %d - disassociate\n", missed_count);
4098 priv->status &= ~STATUS_ROAMING;
4099 if (priv->status & STATUS_SCANNING) {
4100 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4102 "Aborting scan with missed beacon.\n");
4103 queue_work(priv->workqueue, &priv->abort_scan);
4106 queue_work(priv->workqueue, &priv->disassociate);
4110 if (priv->status & STATUS_ROAMING) {
4111 /* If we are currently roaming, then just
4112 * print a debug statement... */
4113 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4114 "Missed beacon: %d - roam in progress\n",
4119 if (missed_count > priv->roaming_threshold) {
4120 /* If we are not already roaming, set the ROAM
4121 * bit in the status and kick off a scan */
4122 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4123 "Missed beacon: %d - initiate "
4124 "roaming\n", missed_count);
4125 if (!(priv->status & STATUS_ROAMING)) {
4126 priv->status |= STATUS_ROAMING;
4127 if (!(priv->status & STATUS_SCANNING))
4128 queue_work(priv->workqueue,
4129 &priv->request_scan);
4134 if (priv->status & STATUS_SCANNING) {
4135 /* Stop scan to keep fw from getting
4136 * stuck (only if we aren't roaming --
4137 * otherwise we'll never scan more than 2 or 3
4139 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4140 "Aborting scan with missed beacon.\n");
4141 queue_work(priv->workqueue, &priv->abort_scan);
4144 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4149 * Handle host notification packet.
4150 * Called from interrupt routine
4152 static inline void ipw_rx_notification(struct ipw_priv *priv,
4153 struct ipw_rx_notification *notif)
4155 notif->size = le16_to_cpu(notif->size);
4157 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4159 switch (notif->subtype) {
4160 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4161 struct notif_association *assoc = ¬if->u.assoc;
4163 switch (assoc->state) {
4164 case CMAS_ASSOCIATED:{
4165 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4167 "associated: '%s' " MAC_FMT
4169 escape_essid(priv->essid,
4171 MAC_ARG(priv->bssid));
4173 switch (priv->ieee->iw_mode) {
4175 memcpy(priv->ieee->bssid,
4176 priv->bssid, ETH_ALEN);
4180 memcpy(priv->ieee->bssid,
4181 priv->bssid, ETH_ALEN);
4183 /* clear out the station table */
4184 priv->num_stations = 0;
4187 ("queueing adhoc check\n");
4188 queue_delayed_work(priv->
4198 priv->status &= ~STATUS_ASSOCIATING;
4199 priv->status |= STATUS_ASSOCIATED;
4200 queue_work(priv->workqueue,
4201 &priv->system_config);
4203 #ifdef CONFIG_IPW_QOS
4204 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4205 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4206 if ((priv->status & STATUS_AUTH) &&
4207 (IPW_GET_PACKET_STYPE(¬if->u.raw)
4208 == IEEE80211_STYPE_ASSOC_RESP)) {
4211 ieee80211_assoc_response)
4213 && (notif->size <= 2314)) {
4226 ieee80211_rx_mgt(priv->
4231 ¬if->u.raw, &stats);
4236 schedule_work(&priv->link_up);
4241 case CMAS_AUTHENTICATED:{
4243 status & (STATUS_ASSOCIATED |
4245 #ifdef CONFIG_IPW_DEBUG
4246 struct notif_authenticate *auth
4248 IPW_DEBUG(IPW_DL_NOTIF |
4251 "deauthenticated: '%s' "
4253 ": (0x%04X) - %s \n",
4258 MAC_ARG(priv->bssid),
4259 ntohs(auth->status),
4266 ~(STATUS_ASSOCIATING |
4270 schedule_work(&priv->link_down);
4274 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4276 "authenticated: '%s' " MAC_FMT
4278 escape_essid(priv->essid,
4280 MAC_ARG(priv->bssid));
4285 if (priv->status & STATUS_AUTH) {
4287 ieee80211_assoc_response
4291 ieee80211_assoc_response
4293 IPW_DEBUG(IPW_DL_NOTIF |
4296 "association failed (0x%04X): %s\n",
4297 ntohs(resp->status),
4303 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4305 "disassociated: '%s' " MAC_FMT
4307 escape_essid(priv->essid,
4309 MAC_ARG(priv->bssid));
4312 ~(STATUS_DISASSOCIATING |
4313 STATUS_ASSOCIATING |
4314 STATUS_ASSOCIATED | STATUS_AUTH);
4315 if (priv->assoc_network
4316 && (priv->assoc_network->
4318 WLAN_CAPABILITY_IBSS))
4319 ipw_remove_current_network
4322 schedule_work(&priv->link_down);
4327 case CMAS_RX_ASSOC_RESP:
4331 IPW_ERROR("assoc: unknown (%d)\n",
4339 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4340 struct notif_authenticate *auth = ¬if->u.auth;
4341 switch (auth->state) {
4342 case CMAS_AUTHENTICATED:
4343 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4344 "authenticated: '%s' " MAC_FMT " \n",
4345 escape_essid(priv->essid,
4347 MAC_ARG(priv->bssid));
4348 priv->status |= STATUS_AUTH;
4352 if (priv->status & STATUS_AUTH) {
4353 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4355 "authentication failed (0x%04X): %s\n",
4356 ntohs(auth->status),
4357 ipw_get_status_code(ntohs
4361 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4363 "deauthenticated: '%s' " MAC_FMT "\n",
4364 escape_essid(priv->essid,
4366 MAC_ARG(priv->bssid));
4368 priv->status &= ~(STATUS_ASSOCIATING |
4372 schedule_work(&priv->link_down);
4375 case CMAS_TX_AUTH_SEQ_1:
4376 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4377 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4379 case CMAS_RX_AUTH_SEQ_2:
4380 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4381 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4383 case CMAS_AUTH_SEQ_1_PASS:
4384 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4385 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4387 case CMAS_AUTH_SEQ_1_FAIL:
4388 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4389 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4391 case CMAS_TX_AUTH_SEQ_3:
4392 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4393 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4395 case CMAS_RX_AUTH_SEQ_4:
4396 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4397 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4399 case CMAS_AUTH_SEQ_2_PASS:
4400 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4401 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4403 case CMAS_AUTH_SEQ_2_FAIL:
4404 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4405 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4408 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4409 IPW_DL_ASSOC, "TX_ASSOC\n");
4411 case CMAS_RX_ASSOC_RESP:
4412 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4413 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4416 case CMAS_ASSOCIATED:
4417 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4418 IPW_DL_ASSOC, "ASSOCIATED\n");
4421 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4428 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4429 struct notif_channel_result *x =
4430 ¬if->u.channel_result;
4432 if (notif->size == sizeof(*x)) {
4433 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4436 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4437 "(should be %zd)\n",
4438 notif->size, sizeof(*x));
4443 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4444 struct notif_scan_complete *x = ¬if->u.scan_complete;
4445 if (notif->size == sizeof(*x)) {
4447 ("Scan completed: type %d, %d channels, "
4448 "%d status\n", x->scan_type,
4449 x->num_channels, x->status);
4451 IPW_ERROR("Scan completed of wrong size %d "
4452 "(should be %zd)\n",
4453 notif->size, sizeof(*x));
4457 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4459 wake_up_interruptible(&priv->wait_state);
4460 cancel_delayed_work(&priv->scan_check);
4462 if (priv->status & STATUS_EXIT_PENDING)
4465 priv->ieee->scans++;
4467 #ifdef CONFIG_IPW2200_MONITOR
4468 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4469 priv->status |= STATUS_SCAN_FORCED;
4470 queue_work(priv->workqueue,
4471 &priv->request_scan);
4474 priv->status &= ~STATUS_SCAN_FORCED;
4475 #endif /* CONFIG_IPW2200_MONITOR */
4477 if (!(priv->status & (STATUS_ASSOCIATED |
4478 STATUS_ASSOCIATING |
4480 STATUS_DISASSOCIATING)))
4481 queue_work(priv->workqueue, &priv->associate);
4482 else if (priv->status & STATUS_ROAMING) {
4483 /* If a scan completed and we are in roam mode, then
4484 * the scan that completed was the one requested as a
4485 * result of entering roam... so, schedule the
4487 queue_work(priv->workqueue, &priv->roam);
4488 } else if (priv->status & STATUS_SCAN_PENDING)
4489 queue_work(priv->workqueue,
4490 &priv->request_scan);
4491 else if (priv->config & CFG_BACKGROUND_SCAN
4492 && priv->status & STATUS_ASSOCIATED)
4493 queue_delayed_work(priv->workqueue,
4494 &priv->request_scan, HZ);
4498 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4499 struct notif_frag_length *x = ¬if->u.frag_len;
4501 if (notif->size == sizeof(*x))
4502 IPW_ERROR("Frag length: %d\n",
4503 le16_to_cpu(x->frag_length));
4505 IPW_ERROR("Frag length of wrong size %d "
4506 "(should be %zd)\n",
4507 notif->size, sizeof(*x));
4511 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4512 struct notif_link_deterioration *x =
4513 ¬if->u.link_deterioration;
4515 if (notif->size == sizeof(*x)) {
4516 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4517 "link deterioration: '%s' " MAC_FMT
4518 " \n", escape_essid(priv->essid,
4520 MAC_ARG(priv->bssid));
4521 memcpy(&priv->last_link_deterioration, x,
4524 IPW_ERROR("Link Deterioration of wrong size %d "
4525 "(should be %zd)\n",
4526 notif->size, sizeof(*x));
4531 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4532 IPW_ERROR("Dino config\n");
4534 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4535 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4540 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4541 struct notif_beacon_state *x = ¬if->u.beacon_state;
4542 if (notif->size != sizeof(*x)) {
4544 ("Beacon state of wrong size %d (should "
4545 "be %zd)\n", notif->size, sizeof(*x));
4549 if (le32_to_cpu(x->state) ==
4550 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4551 ipw_handle_missed_beacon(priv,
4558 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4559 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4560 if (notif->size == sizeof(*x)) {
4561 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4562 "0x%02x station %d\n",
4563 x->key_state, x->security_type,
4569 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4570 notif->size, sizeof(*x));
4574 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4575 struct notif_calibration *x = ¬if->u.calibration;
4577 if (notif->size == sizeof(*x)) {
4578 memcpy(&priv->calib, x, sizeof(*x));
4579 IPW_DEBUG_INFO("TODO: Calibration\n");
4584 ("Calibration of wrong size %d (should be %zd)\n",
4585 notif->size, sizeof(*x));
4589 case HOST_NOTIFICATION_NOISE_STATS:{
4590 if (notif->size == sizeof(u32)) {
4592 (u8) (le32_to_cpu(notif->u.noise.value) &
4594 average_add(&priv->average_noise,
4600 ("Noise stat is wrong size %d (should be %zd)\n",
4601 notif->size, sizeof(u32));
4606 IPW_ERROR("Unknown notification: "
4607 "subtype=%d,flags=0x%2x,size=%d\n",
4608 notif->subtype, notif->flags, notif->size);
4613 * Destroys all DMA structures and initialise them again
4616 * @return error code
4618 static int ipw_queue_reset(struct ipw_priv *priv)
4621 /** @todo customize queue sizes */
4622 int nTx = 64, nTxCmd = 8;
4623 ipw_tx_queue_free(priv);
4625 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4626 IPW_TX_CMD_QUEUE_READ_INDEX,
4627 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4628 IPW_TX_CMD_QUEUE_BD_BASE,
4629 IPW_TX_CMD_QUEUE_BD_SIZE);
4631 IPW_ERROR("Tx Cmd queue init failed\n");
4635 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4636 IPW_TX_QUEUE_0_READ_INDEX,
4637 IPW_TX_QUEUE_0_WRITE_INDEX,
4638 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4640 IPW_ERROR("Tx 0 queue init failed\n");
4643 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4644 IPW_TX_QUEUE_1_READ_INDEX,
4645 IPW_TX_QUEUE_1_WRITE_INDEX,
4646 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4648 IPW_ERROR("Tx 1 queue init failed\n");
4651 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4652 IPW_TX_QUEUE_2_READ_INDEX,
4653 IPW_TX_QUEUE_2_WRITE_INDEX,
4654 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4656 IPW_ERROR("Tx 2 queue init failed\n");
4659 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4660 IPW_TX_QUEUE_3_READ_INDEX,
4661 IPW_TX_QUEUE_3_WRITE_INDEX,
4662 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4664 IPW_ERROR("Tx 3 queue init failed\n");
4668 priv->rx_bufs_min = 0;
4669 priv->rx_pend_max = 0;
4673 ipw_tx_queue_free(priv);
4678 * Reclaim Tx queue entries no more used by NIC.
4680 * When FW adwances 'R' index, all entries between old and
4681 * new 'R' index need to be reclaimed. As result, some free space
4682 * forms. If there is enough free space (> low mark), wake Tx queue.
4684 * @note Need to protect against garbage in 'R' index
4688 * @return Number of used entries remains in the queue
4690 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4691 struct clx2_tx_queue *txq, int qindex)
4695 struct clx2_queue *q = &txq->q;
4697 hw_tail = ipw_read32(priv, q->reg_r);
4698 if (hw_tail >= q->n_bd) {
4700 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4704 for (; q->last_used != hw_tail;
4705 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4706 ipw_queue_tx_free_tfd(priv, txq);
4710 if ((ipw_queue_space(q) > q->low_mark) &&
4712 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4713 netif_wake_queue(priv->net_dev);
4714 used = q->first_empty - q->last_used;
4721 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4724 struct clx2_tx_queue *txq = &priv->txq_cmd;
4725 struct clx2_queue *q = &txq->q;
4726 struct tfd_frame *tfd;
4728 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4729 IPW_ERROR("No space for Tx\n");
4733 tfd = &txq->bd[q->first_empty];
4734 txq->txb[q->first_empty] = NULL;
4736 memset(tfd, 0, sizeof(*tfd));
4737 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4738 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4740 tfd->u.cmd.index = hcmd;
4741 tfd->u.cmd.length = len;
4742 memcpy(tfd->u.cmd.payload, buf, len);
4743 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4744 ipw_write32(priv, q->reg_w, q->first_empty);
4745 _ipw_read32(priv, 0x90);
4751 * Rx theory of operation
4753 * The host allocates 32 DMA target addresses and passes the host address
4754 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4758 * The host/firmware share two index registers for managing the Rx buffers.
4760 * The READ index maps to the first position that the firmware may be writing
4761 * to -- the driver can read up to (but not including) this position and get
4763 * The READ index is managed by the firmware once the card is enabled.
4765 * The WRITE index maps to the last position the driver has read from -- the
4766 * position preceding WRITE is the last slot the firmware can place a packet.
4768 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4771 * During initialization the host sets up the READ queue position to the first
4772 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4774 * When the firmware places a packet in a buffer it will advance the READ index
4775 * and fire the RX interrupt. The driver can then query the READ index and
4776 * process as many packets as possible, moving the WRITE index forward as it
4777 * resets the Rx queue buffers with new memory.
4779 * The management in the driver is as follows:
4780 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
4781 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4782 * to replensish the ipw->rxq->rx_free.
4783 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4784 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4785 * 'processed' and 'read' driver indexes as well)
4786 * + A received packet is processed and handed to the kernel network stack,
4787 * detached from the ipw->rxq. The driver 'processed' index is updated.
4788 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4789 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4790 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
4791 * were enough free buffers and RX_STALLED is set it is cleared.
4796 * ipw_rx_queue_alloc() Allocates rx_free
4797 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4798 * ipw_rx_queue_restock
4799 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4800 * queue, updates firmware pointers, and updates
4801 * the WRITE index. If insufficient rx_free buffers
4802 * are available, schedules ipw_rx_queue_replenish
4804 * -- enable interrupts --
4805 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
4806 * READ INDEX, detaching the SKB from the pool.
4807 * Moves the packet buffer from queue to rx_used.
4808 * Calls ipw_rx_queue_restock to refill any empty
4815 * If there are slots in the RX queue that need to be restocked,
4816 * and we have free pre-allocated buffers, fill the ranks as much
4817 * as we can pulling from rx_free.
4819 * This moves the 'write' index forward to catch up with 'processed', and
4820 * also updates the memory address in the firmware to reference the new
4823 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4825 struct ipw_rx_queue *rxq = priv->rxq;
4826 struct list_head *element;
4827 struct ipw_rx_mem_buffer *rxb;
4828 unsigned long flags;
4831 spin_lock_irqsave(&rxq->lock, flags);
4833 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4834 element = rxq->rx_free.next;
4835 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4838 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4840 rxq->queue[rxq->write] = rxb;
4841 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4844 spin_unlock_irqrestore(&rxq->lock, flags);
4846 /* If the pre-allocated buffer pool is dropping low, schedule to
4848 if (rxq->free_count <= RX_LOW_WATERMARK)
4849 queue_work(priv->workqueue, &priv->rx_replenish);
4851 /* If we've added more space for the firmware to place data, tell it */
4852 if (write != rxq->write)
4853 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4857 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4858 * Also restock the Rx queue via ipw_rx_queue_restock.
4860 * This is called as a scheduled work item (except for during intialization)
4862 static void ipw_rx_queue_replenish(void *data)
4864 struct ipw_priv *priv = data;
4865 struct ipw_rx_queue *rxq = priv->rxq;
4866 struct list_head *element;
4867 struct ipw_rx_mem_buffer *rxb;
4868 unsigned long flags;
4870 spin_lock_irqsave(&rxq->lock, flags);
4871 while (!list_empty(&rxq->rx_used)) {
4872 element = rxq->rx_used.next;
4873 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4874 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4876 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4877 priv->net_dev->name);
4878 /* We don't reschedule replenish work here -- we will
4879 * call the restock method and if it still needs
4880 * more buffers it will schedule replenish */
4885 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4887 pci_map_single(priv->pci_dev, rxb->skb->data,
4888 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4890 list_add_tail(&rxb->list, &rxq->rx_free);
4893 spin_unlock_irqrestore(&rxq->lock, flags);
4895 ipw_rx_queue_restock(priv);
4898 static void ipw_bg_rx_queue_replenish(void *data)
4900 struct ipw_priv *priv = data;
4902 ipw_rx_queue_replenish(data);
4906 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4907 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL
4908 * This free routine walks the list of POOL entries and if SKB is set to
4909 * non NULL it is unmapped and freed
4911 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4918 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4919 if (rxq->pool[i].skb != NULL) {
4920 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4921 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4922 dev_kfree_skb(rxq->pool[i].skb);
4929 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4931 struct ipw_rx_queue *rxq;
4934 rxq = (struct ipw_rx_queue *)kmalloc(sizeof(*rxq), GFP_KERNEL);
4935 if (unlikely(!rxq)) {
4936 IPW_ERROR("memory allocation failed\n");
4939 memset(rxq, 0, sizeof(*rxq));
4940 spin_lock_init(&rxq->lock);
4941 INIT_LIST_HEAD(&rxq->rx_free);
4942 INIT_LIST_HEAD(&rxq->rx_used);
4944 /* Fill the rx_used queue with _all_ of the Rx buffers */
4945 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
4946 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4948 /* Set us so that we have processed and used all buffers, but have
4949 * not restocked the Rx queue with fresh buffers */
4950 rxq->read = rxq->write = 0;
4951 rxq->processed = RX_QUEUE_SIZE - 1;
4952 rxq->free_count = 0;
4957 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4959 rate &= ~IEEE80211_BASIC_RATE_MASK;
4960 if (ieee_mode == IEEE_A) {
4962 case IEEE80211_OFDM_RATE_6MB:
4963 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4965 case IEEE80211_OFDM_RATE_9MB:
4966 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4968 case IEEE80211_OFDM_RATE_12MB:
4970 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4971 case IEEE80211_OFDM_RATE_18MB:
4973 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
4974 case IEEE80211_OFDM_RATE_24MB:
4976 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
4977 case IEEE80211_OFDM_RATE_36MB:
4979 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
4980 case IEEE80211_OFDM_RATE_48MB:
4982 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
4983 case IEEE80211_OFDM_RATE_54MB:
4985 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
4993 case IEEE80211_CCK_RATE_1MB:
4994 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
4995 case IEEE80211_CCK_RATE_2MB:
4996 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
4997 case IEEE80211_CCK_RATE_5MB:
4998 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
4999 case IEEE80211_CCK_RATE_11MB:
5000 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5003 /* If we are limited to B modulations, bail at this point */
5004 if (ieee_mode == IEEE_B)
5009 case IEEE80211_OFDM_RATE_6MB:
5010 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5011 case IEEE80211_OFDM_RATE_9MB:
5012 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5013 case IEEE80211_OFDM_RATE_12MB:
5014 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5015 case IEEE80211_OFDM_RATE_18MB:
5016 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5017 case IEEE80211_OFDM_RATE_24MB:
5018 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5019 case IEEE80211_OFDM_RATE_36MB:
5020 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5021 case IEEE80211_OFDM_RATE_48MB:
5022 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5023 case IEEE80211_OFDM_RATE_54MB:
5024 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5030 static int ipw_compatible_rates(struct ipw_priv *priv,
5031 const struct ieee80211_network *network,
5032 struct ipw_supported_rates *rates)
5036 memset(rates, 0, sizeof(*rates));
5037 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5038 rates->num_rates = 0;
5039 for (i = 0; i < num_rates; i++) {
5040 if (!ipw_is_rate_in_mask(priv, network->mode,
5041 network->rates[i])) {
5043 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5044 IPW_DEBUG_SCAN("Adding masked mandatory "
5047 rates->supported_rates[rates->num_rates++] =
5052 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5053 network->rates[i], priv->rates_mask);
5057 rates->supported_rates[rates->num_rates++] = network->rates[i];
5060 num_rates = min(network->rates_ex_len,
5061 (u8) (IPW_MAX_RATES - num_rates));
5062 for (i = 0; i < num_rates; i++) {
5063 if (!ipw_is_rate_in_mask(priv, network->mode,
5064 network->rates_ex[i])) {
5065 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5066 IPW_DEBUG_SCAN("Adding masked mandatory "
5068 network->rates_ex[i]);
5069 rates->supported_rates[rates->num_rates++] =
5074 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5075 network->rates_ex[i], priv->rates_mask);
5079 rates->supported_rates[rates->num_rates++] =
5080 network->rates_ex[i];
5086 static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
5087 const struct ipw_supported_rates *src)
5090 for (i = 0; i < src->num_rates; i++)
5091 dest->supported_rates[i] = src->supported_rates[i];
5092 dest->num_rates = src->num_rates;
5095 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5096 * mask should ever be used -- right now all callers to add the scan rates are
5097 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5098 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5099 u8 modulation, u32 rate_mask)
5101 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5102 IEEE80211_BASIC_RATE_MASK : 0;
5104 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5105 rates->supported_rates[rates->num_rates++] =
5106 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5108 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5109 rates->supported_rates[rates->num_rates++] =
5110 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5112 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5113 rates->supported_rates[rates->num_rates++] = basic_mask |
5114 IEEE80211_CCK_RATE_5MB;
5116 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5117 rates->supported_rates[rates->num_rates++] = basic_mask |
5118 IEEE80211_CCK_RATE_11MB;
5121 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5122 u8 modulation, u32 rate_mask)
5124 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5125 IEEE80211_BASIC_RATE_MASK : 0;
5127 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5128 rates->supported_rates[rates->num_rates++] = basic_mask |
5129 IEEE80211_OFDM_RATE_6MB;
5131 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5132 rates->supported_rates[rates->num_rates++] =
5133 IEEE80211_OFDM_RATE_9MB;
5135 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5136 rates->supported_rates[rates->num_rates++] = basic_mask |
5137 IEEE80211_OFDM_RATE_12MB;
5139 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5140 rates->supported_rates[rates->num_rates++] =
5141 IEEE80211_OFDM_RATE_18MB;
5143 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5144 rates->supported_rates[rates->num_rates++] = basic_mask |
5145 IEEE80211_OFDM_RATE_24MB;
5147 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5148 rates->supported_rates[rates->num_rates++] =
5149 IEEE80211_OFDM_RATE_36MB;
5151 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5152 rates->supported_rates[rates->num_rates++] =
5153 IEEE80211_OFDM_RATE_48MB;
5155 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5156 rates->supported_rates[rates->num_rates++] =
5157 IEEE80211_OFDM_RATE_54MB;
5160 struct ipw_network_match {
5161 struct ieee80211_network *network;
5162 struct ipw_supported_rates rates;
5165 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5166 struct ipw_network_match *match,
5167 struct ieee80211_network *network,
5170 struct ipw_supported_rates rates;
5172 /* Verify that this network's capability is compatible with the
5173 * current mode (AdHoc or Infrastructure) */
5174 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5175 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5176 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5177 "capability mismatch.\n",
5178 escape_essid(network->ssid, network->ssid_len),
5179 MAC_ARG(network->bssid));
5183 /* If we do not have an ESSID for this AP, we can not associate with
5185 if (network->flags & NETWORK_EMPTY_ESSID) {
5186 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5187 "because of hidden ESSID.\n",
5188 escape_essid(network->ssid, network->ssid_len),
5189 MAC_ARG(network->bssid));
5193 if (unlikely(roaming)) {
5194 /* If we are roaming, then ensure check if this is a valid
5195 * network to try and roam to */
5196 if ((network->ssid_len != match->network->ssid_len) ||
5197 memcmp(network->ssid, match->network->ssid,
5198 network->ssid_len)) {
5199 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5200 "because of non-network ESSID.\n",
5201 escape_essid(network->ssid,
5203 MAC_ARG(network->bssid));
5207 /* If an ESSID has been configured then compare the broadcast
5209 if ((priv->config & CFG_STATIC_ESSID) &&
5210 ((network->ssid_len != priv->essid_len) ||
5211 memcmp(network->ssid, priv->essid,
5212 min(network->ssid_len, priv->essid_len)))) {
5213 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5216 escape_essid(network->ssid, network->ssid_len),
5218 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5219 "because of ESSID mismatch: '%s'.\n",
5220 escaped, MAC_ARG(network->bssid),
5221 escape_essid(priv->essid,
5227 /* If the old network rate is better than this one, don't bother
5228 * testing everything else. */
5230 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5231 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5232 "current network.\n",
5233 escape_essid(match->network->ssid,
5234 match->network->ssid_len));
5236 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5237 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5238 "current network.\n",
5239 escape_essid(match->network->ssid,
5240 match->network->ssid_len));
5244 /* Now go through and see if the requested network is valid... */
5245 if (priv->ieee->scan_age != 0 &&
5246 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5247 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5248 "because of age: %lums.\n",
5249 escape_essid(network->ssid, network->ssid_len),
5250 MAC_ARG(network->bssid),
5251 1000 * (jiffies - network->last_scanned) / HZ);
5255 if ((priv->config & CFG_STATIC_CHANNEL) &&
5256 (network->channel != priv->channel)) {
5257 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5258 "because of channel mismatch: %d != %d.\n",
5259 escape_essid(network->ssid, network->ssid_len),
5260 MAC_ARG(network->bssid),
5261 network->channel, priv->channel);
5265 /* Verify privacy compatability */
5266 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5267 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5268 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5269 "because of privacy mismatch: %s != %s.\n",
5270 escape_essid(network->ssid, network->ssid_len),
5271 MAC_ARG(network->bssid),
5273 capability & CAP_PRIVACY_ON ? "on" : "off",
5275 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5280 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5281 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5282 "because of the same BSSID match: " MAC_FMT
5283 ".\n", escape_essid(network->ssid,
5285 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5289 /* Filter out any incompatible freq / mode combinations */
5290 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5291 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5292 "because of invalid frequency/mode "
5294 escape_essid(network->ssid, network->ssid_len),
5295 MAC_ARG(network->bssid));
5299 /* Ensure that the rates supported by the driver are compatible with
5300 * this AP, including verification of basic rates (mandatory) */
5301 if (!ipw_compatible_rates(priv, network, &rates)) {
5302 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5303 "because configured rate mask excludes "
5304 "AP mandatory rate.\n",
5305 escape_essid(network->ssid, network->ssid_len),
5306 MAC_ARG(network->bssid));
5310 if (rates.num_rates == 0) {
5311 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5312 "because of no compatible rates.\n",
5313 escape_essid(network->ssid, network->ssid_len),
5314 MAC_ARG(network->bssid));
5318 /* TODO: Perform any further minimal comparititive tests. We do not
5319 * want to put too much policy logic here; intelligent scan selection
5320 * should occur within a generic IEEE 802.11 user space tool. */
5322 /* Set up 'new' AP to this network */
5323 ipw_copy_rates(&match->rates, &rates);
5324 match->network = network;
5325 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5326 escape_essid(network->ssid, network->ssid_len),
5327 MAC_ARG(network->bssid));
5332 static void ipw_merge_adhoc_network(void *data)
5334 struct ipw_priv *priv = data;
5335 struct ieee80211_network *network = NULL;
5336 struct ipw_network_match match = {
5337 .network = priv->assoc_network
5340 if ((priv->status & STATUS_ASSOCIATED) &&
5341 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5342 /* First pass through ROAM process -- look for a better
5344 unsigned long flags;
5346 spin_lock_irqsave(&priv->ieee->lock, flags);
5347 list_for_each_entry(network, &priv->ieee->network_list, list) {
5348 if (network != priv->assoc_network)
5349 ipw_find_adhoc_network(priv, &match, network,
5352 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5354 if (match.network == priv->assoc_network) {
5355 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5361 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5362 IPW_DEBUG_MERGE("remove network %s\n",
5363 escape_essid(priv->essid,
5365 ipw_remove_current_network(priv);
5368 ipw_disassociate(priv);
5369 priv->assoc_network = match.network;
5375 static int ipw_best_network(struct ipw_priv *priv,
5376 struct ipw_network_match *match,
5377 struct ieee80211_network *network, int roaming)
5379 struct ipw_supported_rates rates;
5381 /* Verify that this network's capability is compatible with the
5382 * current mode (AdHoc or Infrastructure) */
5383 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5384 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5385 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5386 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5387 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5388 "capability mismatch.\n",
5389 escape_essid(network->ssid, network->ssid_len),
5390 MAC_ARG(network->bssid));
5394 /* If we do not have an ESSID for this AP, we can not associate with
5396 if (network->flags & NETWORK_EMPTY_ESSID) {
5397 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5398 "because of hidden ESSID.\n",
5399 escape_essid(network->ssid, network->ssid_len),
5400 MAC_ARG(network->bssid));
5404 if (unlikely(roaming)) {
5405 /* If we are roaming, then ensure check if this is a valid
5406 * network to try and roam to */
5407 if ((network->ssid_len != match->network->ssid_len) ||
5408 memcmp(network->ssid, match->network->ssid,
5409 network->ssid_len)) {
5410 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5411 "because of non-network ESSID.\n",
5412 escape_essid(network->ssid,
5414 MAC_ARG(network->bssid));
5418 /* If an ESSID has been configured then compare the broadcast
5420 if ((priv->config & CFG_STATIC_ESSID) &&
5421 ((network->ssid_len != priv->essid_len) ||
5422 memcmp(network->ssid, priv->essid,
5423 min(network->ssid_len, priv->essid_len)))) {
5424 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5426 escape_essid(network->ssid, network->ssid_len),
5428 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5429 "because of ESSID mismatch: '%s'.\n",
5430 escaped, MAC_ARG(network->bssid),
5431 escape_essid(priv->essid,
5437 /* If the old network rate is better than this one, don't bother
5438 * testing everything else. */
5439 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5440 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5442 escape_essid(network->ssid, network->ssid_len),
5444 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5445 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5446 escaped, MAC_ARG(network->bssid),
5447 escape_essid(match->network->ssid,
5448 match->network->ssid_len),
5449 MAC_ARG(match->network->bssid));
5453 /* If this network has already had an association attempt within the
5454 * last 3 seconds, do not try and associate again... */
5455 if (network->last_associate &&
5456 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5457 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5458 "because of storming (%lus since last "
5459 "assoc attempt).\n",
5460 escape_essid(network->ssid, network->ssid_len),
5461 MAC_ARG(network->bssid),
5462 (jiffies - network->last_associate) / HZ);
5466 /* Now go through and see if the requested network is valid... */
5467 if (priv->ieee->scan_age != 0 &&
5468 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5469 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5470 "because of age: %lums.\n",
5471 escape_essid(network->ssid, network->ssid_len),
5472 MAC_ARG(network->bssid),
5473 1000 * (jiffies - network->last_scanned) / HZ);
5477 if ((priv->config & CFG_STATIC_CHANNEL) &&
5478 (network->channel != priv->channel)) {
5479 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5480 "because of channel mismatch: %d != %d.\n",
5481 escape_essid(network->ssid, network->ssid_len),
5482 MAC_ARG(network->bssid),
5483 network->channel, priv->channel);
5487 /* Verify privacy compatability */
5488 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5489 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5490 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5491 "because of privacy mismatch: %s != %s.\n",
5492 escape_essid(network->ssid, network->ssid_len),
5493 MAC_ARG(network->bssid),
5494 priv->capability & CAP_PRIVACY_ON ? "on" :
5496 network->capability &
5497 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5501 if (!priv->ieee->wpa_enabled && (network->wpa_ie_len > 0 ||
5502 network->rsn_ie_len > 0)) {
5503 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5504 "because of WPA capability mismatch.\n",
5505 escape_essid(network->ssid, network->ssid_len),
5506 MAC_ARG(network->bssid));
5510 if ((priv->config & CFG_STATIC_BSSID) &&
5511 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5512 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5513 "because of BSSID mismatch: " MAC_FMT ".\n",
5514 escape_essid(network->ssid, network->ssid_len),
5515 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5519 /* Filter out any incompatible freq / mode combinations */
5520 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5521 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5522 "because of invalid frequency/mode "
5524 escape_essid(network->ssid, network->ssid_len),
5525 MAC_ARG(network->bssid));
5529 /* Filter out invalid channel in current GEO */
5530 if (!ipw_is_valid_channel(priv->ieee, network->channel)) {
5531 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5532 "because of invalid channel in current GEO\n",
5533 escape_essid(network->ssid, network->ssid_len),
5534 MAC_ARG(network->bssid));
5538 /* Ensure that the rates supported by the driver are compatible with
5539 * this AP, including verification of basic rates (mandatory) */
5540 if (!ipw_compatible_rates(priv, network, &rates)) {
5541 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5542 "because configured rate mask excludes "
5543 "AP mandatory rate.\n",
5544 escape_essid(network->ssid, network->ssid_len),
5545 MAC_ARG(network->bssid));
5549 if (rates.num_rates == 0) {
5550 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5551 "because of no compatible rates.\n",
5552 escape_essid(network->ssid, network->ssid_len),
5553 MAC_ARG(network->bssid));
5557 /* TODO: Perform any further minimal comparititive tests. We do not
5558 * want to put too much policy logic here; intelligent scan selection
5559 * should occur within a generic IEEE 802.11 user space tool. */
5561 /* Set up 'new' AP to this network */
5562 ipw_copy_rates(&match->rates, &rates);
5563 match->network = network;
5565 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5566 escape_essid(network->ssid, network->ssid_len),
5567 MAC_ARG(network->bssid));
5572 static void ipw_adhoc_create(struct ipw_priv *priv,
5573 struct ieee80211_network *network)
5575 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5579 * For the purposes of scanning, we can set our wireless mode
5580 * to trigger scans across combinations of bands, but when it
5581 * comes to creating a new ad-hoc network, we have tell the FW
5582 * exactly which band to use.
5584 * We also have the possibility of an invalid channel for the
5585 * chossen band. Attempting to create a new ad-hoc network
5586 * with an invalid channel for wireless mode will trigger a
5590 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
5591 case IEEE80211_52GHZ_BAND:
5592 network->mode = IEEE_A;
5593 i = ipw_channel_to_index(priv->ieee, priv->channel);
5596 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5597 IPW_WARNING("Overriding invalid channel\n");
5598 priv->channel = geo->a[0].channel;
5602 case IEEE80211_24GHZ_BAND:
5603 if (priv->ieee->mode & IEEE_G)
5604 network->mode = IEEE_G;
5606 network->mode = IEEE_B;
5607 i = ipw_channel_to_index(priv->ieee, priv->channel);
5610 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5611 IPW_WARNING("Overriding invalid channel\n");
5612 priv->channel = geo->bg[0].channel;
5617 IPW_WARNING("Overriding invalid channel\n");
5618 if (priv->ieee->mode & IEEE_A) {
5619 network->mode = IEEE_A;
5620 priv->channel = geo->a[0].channel;
5621 } else if (priv->ieee->mode & IEEE_G) {
5622 network->mode = IEEE_G;
5623 priv->channel = geo->bg[0].channel;
5625 network->mode = IEEE_B;
5626 priv->channel = geo->bg[0].channel;
5631 network->channel = priv->channel;
5632 priv->config |= CFG_ADHOC_PERSIST;
5633 ipw_create_bssid(priv, network->bssid);
5634 network->ssid_len = priv->essid_len;
5635 memcpy(network->ssid, priv->essid, priv->essid_len);
5636 memset(&network->stats, 0, sizeof(network->stats));
5637 network->capability = WLAN_CAPABILITY_IBSS;
5638 if (!(priv->config & CFG_PREAMBLE_LONG))
5639 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5640 if (priv->capability & CAP_PRIVACY_ON)
5641 network->capability |= WLAN_CAPABILITY_PRIVACY;
5642 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5643 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5644 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5645 memcpy(network->rates_ex,
5646 &priv->rates.supported_rates[network->rates_len],
5647 network->rates_ex_len);
5648 network->last_scanned = 0;
5650 network->last_associate = 0;
5651 network->time_stamp[0] = 0;
5652 network->time_stamp[1] = 0;
5653 network->beacon_interval = 100; /* Default */
5654 network->listen_interval = 10; /* Default */
5655 network->atim_window = 0; /* Default */
5656 network->wpa_ie_len = 0;
5657 network->rsn_ie_len = 0;
5660 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5662 struct ipw_tgi_tx_key *key;
5663 struct host_cmd cmd = {
5664 .cmd = IPW_CMD_TGI_TX_KEY,
5668 if (!(priv->ieee->sec.flags & (1 << index)))
5671 key = (struct ipw_tgi_tx_key *)&cmd.param;
5672 key->key_id = index;
5673 memcpy(key->key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5674 key->security_type = type;
5675 key->station_index = 0; /* always 0 for BSS */
5677 /* 0 for new key; previous value of counter (after fatal error) */
5678 key->tx_counter[0] = 0;
5679 key->tx_counter[1] = 0;
5681 ipw_send_cmd(priv, &cmd);
5684 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5686 struct ipw_wep_key *key;
5688 struct host_cmd cmd = {
5689 .cmd = IPW_CMD_WEP_KEY,
5693 key = (struct ipw_wep_key *)&cmd.param;
5694 key->cmd_id = DINO_CMD_WEP_KEY;
5697 /* Note: AES keys cannot be set for multiple times.
5698 * Only set it at the first time. */
5699 for (i = 0; i < 4; i++) {
5700 key->key_index = i | type;
5701 if (!(priv->ieee->sec.flags & (1 << i))) {
5706 key->key_size = priv->ieee->sec.key_sizes[i];
5707 memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);
5709 ipw_send_cmd(priv, &cmd);
5713 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5715 if (priv->ieee->host_encrypt)
5720 priv->sys_config.disable_unicast_decryption = 0;
5721 priv->ieee->host_decrypt = 0;
5724 priv->sys_config.disable_unicast_decryption = 1;
5725 priv->ieee->host_decrypt = 1;
5728 priv->sys_config.disable_unicast_decryption = 0;
5729 priv->ieee->host_decrypt = 0;
5732 priv->sys_config.disable_unicast_decryption = 1;
5739 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5741 if (priv->ieee->host_encrypt)
5746 priv->sys_config.disable_multicast_decryption = 0;
5749 priv->sys_config.disable_multicast_decryption = 1;
5752 priv->sys_config.disable_multicast_decryption = 0;
5755 priv->sys_config.disable_multicast_decryption = 1;
5762 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5764 switch (priv->ieee->sec.level) {
5766 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5767 ipw_send_tgi_tx_key(priv,
5768 DCT_FLAG_EXT_SECURITY_CCM,
5769 priv->ieee->sec.active_key);
5771 if (!priv->ieee->host_mc_decrypt)
5772 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5775 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5776 ipw_send_tgi_tx_key(priv,
5777 DCT_FLAG_EXT_SECURITY_TKIP,
5778 priv->ieee->sec.active_key);
5781 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5782 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5783 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5791 static void ipw_adhoc_check(void *data)
5793 struct ipw_priv *priv = data;
5795 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5796 !(priv->config & CFG_ADHOC_PERSIST)) {
5797 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5798 IPW_DL_STATE | IPW_DL_ASSOC,
5799 "Missed beacon: %d - disassociate\n",
5800 priv->missed_adhoc_beacons);
5801 ipw_remove_current_network(priv);
5802 ipw_disassociate(priv);
5806 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5807 priv->assoc_request.beacon_interval);
5810 static void ipw_bg_adhoc_check(void *data)
5812 struct ipw_priv *priv = data;
5814 ipw_adhoc_check(data);
5818 #ifdef CONFIG_IPW_DEBUG
5819 static void ipw_debug_config(struct ipw_priv *priv)
5821 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5822 "[CFG 0x%08X]\n", priv->config);
5823 if (priv->config & CFG_STATIC_CHANNEL)
5824 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5826 IPW_DEBUG_INFO("Channel unlocked.\n");
5827 if (priv->config & CFG_STATIC_ESSID)
5828 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5829 escape_essid(priv->essid, priv->essid_len));
5831 IPW_DEBUG_INFO("ESSID unlocked.\n");
5832 if (priv->config & CFG_STATIC_BSSID)
5833 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5834 MAC_ARG(priv->bssid));
5836 IPW_DEBUG_INFO("BSSID unlocked.\n");
5837 if (priv->capability & CAP_PRIVACY_ON)
5838 IPW_DEBUG_INFO("PRIVACY on\n");
5840 IPW_DEBUG_INFO("PRIVACY off\n");
5841 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5844 #define ipw_debug_config(x) do {} while (0)
5847 static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5849 /* TODO: Verify that this works... */
5850 struct ipw_fixed_rate fr = {
5851 .tx_rates = priv->rates_mask
5856 /* Identify 'current FW band' and match it with the fixed
5859 switch (priv->ieee->freq_band) {
5860 case IEEE80211_52GHZ_BAND: /* A only */
5862 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5863 /* Invalid fixed rate mask */
5865 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5870 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5873 default: /* 2.4Ghz or Mixed */
5875 if (mode == IEEE_B) {
5876 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5877 /* Invalid fixed rate mask */
5879 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5886 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5887 IEEE80211_OFDM_RATES_MASK)) {
5888 /* Invalid fixed rate mask */
5890 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5895 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5896 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5897 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5900 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5901 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5902 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5905 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5906 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5907 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5910 fr.tx_rates |= mask;
5914 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5915 ipw_write_reg32(priv, reg, *(u32 *) & fr);
5918 static void ipw_abort_scan(struct ipw_priv *priv)
5922 if (priv->status & STATUS_SCAN_ABORTING) {
5923 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5926 priv->status |= STATUS_SCAN_ABORTING;
5928 err = ipw_send_scan_abort(priv);
5930 IPW_DEBUG_HC("Request to abort scan failed.\n");
5933 static void ipw_add_scan_channels(struct ipw_priv *priv,
5934 struct ipw_scan_request_ext *scan,
5937 int channel_index = 0;
5938 const struct ieee80211_geo *geo;
5941 geo = ipw_get_geo(priv->ieee);
5943 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5944 int start = channel_index;
5945 for (i = 0; i < geo->a_channels; i++) {
5946 if ((priv->status & STATUS_ASSOCIATED) &&
5947 geo->a[i].channel == priv->channel)
5950 scan->channels_list[channel_index] = geo->a[i].channel;
5951 ipw_set_scan_type(scan, channel_index,
5953 flags & IEEE80211_CH_PASSIVE_ONLY ?
5954 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5958 if (start != channel_index) {
5959 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5960 (channel_index - start);
5965 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5966 int start = channel_index;
5967 if (priv->config & CFG_SPEED_SCAN) {
5969 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5970 /* nop out the list */
5975 while (channel_index < IPW_SCAN_CHANNELS) {
5977 priv->speed_scan[priv->speed_scan_pos];
5979 priv->speed_scan_pos = 0;
5980 channel = priv->speed_scan[0];
5982 if ((priv->status & STATUS_ASSOCIATED) &&
5983 channel == priv->channel) {
5984 priv->speed_scan_pos++;
5988 /* If this channel has already been
5989 * added in scan, break from loop
5990 * and this will be the first channel
5993 if (channels[channel - 1] != 0)
5996 channels[channel - 1] = 1;
5997 priv->speed_scan_pos++;
5999 scan->channels_list[channel_index] = channel;
6001 ipw_channel_to_index(priv->ieee, channel);
6002 ipw_set_scan_type(scan, channel_index,
6005 IEEE80211_CH_PASSIVE_ONLY ?
6006 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6010 for (i = 0; i < geo->bg_channels; i++) {
6011 if ((priv->status & STATUS_ASSOCIATED) &&
6012 geo->bg[i].channel == priv->channel)
6015 scan->channels_list[channel_index] =
6017 ipw_set_scan_type(scan, channel_index,
6020 IEEE80211_CH_PASSIVE_ONLY ?
6021 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6026 if (start != channel_index) {
6027 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6028 (channel_index - start);
6033 static int ipw_request_scan(struct ipw_priv *priv)
6035 struct ipw_scan_request_ext scan;
6036 int err = 0, scan_type;
6038 if (!(priv->status & STATUS_INIT) ||
6039 (priv->status & STATUS_EXIT_PENDING))
6044 if (priv->status & STATUS_SCANNING) {
6045 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
6046 priv->status |= STATUS_SCAN_PENDING;
6050 if (!(priv->status & STATUS_SCAN_FORCED) &&
6051 priv->status & STATUS_SCAN_ABORTING) {
6052 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6053 priv->status |= STATUS_SCAN_PENDING;
6057 if (priv->status & STATUS_RF_KILL_MASK) {
6058 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6059 priv->status |= STATUS_SCAN_PENDING;
6063 memset(&scan, 0, sizeof(scan));
6065 if (priv->config & CFG_SPEED_SCAN)
6066 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6069 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6072 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6074 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6076 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6078 #ifdef CONFIG_IPW2200_MONITOR
6079 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6083 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
6084 case IEEE80211_52GHZ_BAND:
6085 band = (u8) (IPW_A_MODE << 6) | 1;
6086 channel = priv->channel;
6089 case IEEE80211_24GHZ_BAND:
6090 band = (u8) (IPW_B_MODE << 6) | 1;
6091 channel = priv->channel;
6095 band = (u8) (IPW_B_MODE << 6) | 1;
6100 scan.channels_list[0] = band;
6101 scan.channels_list[1] = channel;
6102 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6104 /* NOTE: The card will sit on this channel for this time
6105 * period. Scan aborts are timing sensitive and frequently
6106 * result in firmware restarts. As such, it is best to
6107 * set a small dwell_time here and just keep re-issuing
6108 * scans. Otherwise fast channel hopping will not actually
6111 * TODO: Move SPEED SCAN support to all modes and bands */
6112 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6115 #endif /* CONFIG_IPW2200_MONITOR */
6116 /* If we are roaming, then make this a directed scan for the
6117 * current network. Otherwise, ensure that every other scan
6118 * is a fast channel hop scan */
6119 if ((priv->status & STATUS_ROAMING)
6120 || (!(priv->status & STATUS_ASSOCIATED)
6121 && (priv->config & CFG_STATIC_ESSID)
6122 && (le32_to_cpu(scan.full_scan_index) % 2))) {
6123 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6125 IPW_DEBUG_HC("Attempt to send SSID command "
6130 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6132 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6134 ipw_add_scan_channels(priv, &scan, scan_type);
6135 #ifdef CONFIG_IPW2200_MONITOR
6139 err = ipw_send_scan_request_ext(priv, &scan);
6141 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6145 priv->status |= STATUS_SCANNING;
6146 priv->status &= ~STATUS_SCAN_PENDING;
6147 queue_delayed_work(priv->workqueue, &priv->scan_check,
6148 IPW_SCAN_CHECK_WATCHDOG);
6154 static void ipw_bg_abort_scan(void *data)
6156 struct ipw_priv *priv = data;
6158 ipw_abort_scan(data);
6162 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6164 /* This is called when wpa_supplicant loads and closes the driver
6166 priv->ieee->wpa_enabled = value;
6170 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6172 struct ieee80211_device *ieee = priv->ieee;
6173 struct ieee80211_security sec = {
6174 .flags = SEC_AUTH_MODE,
6178 if (value & IW_AUTH_ALG_SHARED_KEY) {
6179 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6181 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6182 sec.auth_mode = WLAN_AUTH_OPEN;
6187 if (ieee->set_security)
6188 ieee->set_security(ieee->dev, &sec);
6195 void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie, int wpa_ie_len)
6197 /* make sure WPA is enabled */
6198 ipw_wpa_enable(priv, 1);
6200 ipw_disassociate(priv);
6203 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6204 char *capabilities, int length)
6206 struct host_cmd cmd = {
6207 .cmd = IPW_CMD_RSN_CAPABILITIES,
6211 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6213 memcpy(cmd.param, capabilities, length);
6214 return ipw_send_cmd(priv, &cmd);
6222 static int ipw_wx_set_genie(struct net_device *dev,
6223 struct iw_request_info *info,
6224 union iwreq_data *wrqu, char *extra)
6226 struct ipw_priv *priv = ieee80211_priv(dev);
6227 struct ieee80211_device *ieee = priv->ieee;
6231 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6232 (wrqu->data.length && extra == NULL))
6237 //if (!ieee->wpa_enabled) {
6238 // err = -EOPNOTSUPP;
6242 if (wrqu->data.length) {
6243 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6249 memcpy(buf, extra, wrqu->data.length);
6250 kfree(ieee->wpa_ie);
6252 ieee->wpa_ie_len = wrqu->data.length;
6254 kfree(ieee->wpa_ie);
6255 ieee->wpa_ie = NULL;
6256 ieee->wpa_ie_len = 0;
6259 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6266 static int ipw_wx_get_genie(struct net_device *dev,
6267 struct iw_request_info *info,
6268 union iwreq_data *wrqu, char *extra)
6270 struct ipw_priv *priv = ieee80211_priv(dev);
6271 struct ieee80211_device *ieee = priv->ieee;
6276 //if (!ieee->wpa_enabled) {
6277 // err = -EOPNOTSUPP;
6281 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6282 wrqu->data.length = 0;
6286 if (wrqu->data.length < ieee->wpa_ie_len) {
6291 wrqu->data.length = ieee->wpa_ie_len;
6292 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6299 static int wext_cipher2level(int cipher)
6302 case IW_AUTH_CIPHER_NONE:
6304 case IW_AUTH_CIPHER_WEP40:
6305 case IW_AUTH_CIPHER_WEP104:
6307 case IW_AUTH_CIPHER_TKIP:
6309 case IW_AUTH_CIPHER_CCMP:
6317 static int ipw_wx_set_auth(struct net_device *dev,
6318 struct iw_request_info *info,
6319 union iwreq_data *wrqu, char *extra)
6321 struct ipw_priv *priv = ieee80211_priv(dev);
6322 struct ieee80211_device *ieee = priv->ieee;
6323 struct iw_param *param = &wrqu->param;
6324 struct ieee80211_crypt_data *crypt;
6325 unsigned long flags;
6328 switch (param->flags & IW_AUTH_INDEX) {
6329 case IW_AUTH_WPA_VERSION:
6331 case IW_AUTH_CIPHER_PAIRWISE:
6332 ipw_set_hw_decrypt_unicast(priv,
6333 wext_cipher2level(param->value));
6335 case IW_AUTH_CIPHER_GROUP:
6336 ipw_set_hw_decrypt_multicast(priv,
6337 wext_cipher2level(param->value));
6339 case IW_AUTH_KEY_MGMT:
6341 * ipw2200 does not use these parameters
6345 case IW_AUTH_TKIP_COUNTERMEASURES:
6346 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6347 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) {
6348 IPW_WARNING("Can't set TKIP countermeasures: "
6349 "crypt not set!\n");
6353 flags = crypt->ops->get_flags(crypt->priv);
6356 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6358 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6360 crypt->ops->set_flags(flags, crypt->priv);
6364 case IW_AUTH_DROP_UNENCRYPTED:{
6367 * wpa_supplicant calls set_wpa_enabled when the driver
6368 * is loaded and unloaded, regardless of if WPA is being
6369 * used. No other calls are made which can be used to
6370 * determine if encryption will be used or not prior to
6371 * association being expected. If encryption is not being
6372 * used, drop_unencrypted is set to false, else true -- we
6373 * can use this to determine if the CAP_PRIVACY_ON bit should
6376 struct ieee80211_security sec = {
6377 .flags = SEC_ENABLED,
6378 .enabled = param->value,
6380 priv->ieee->drop_unencrypted = param->value;
6381 /* We only change SEC_LEVEL for open mode. Others
6382 * are set by ipw_wpa_set_encryption.
6384 if (!param->value) {
6385 sec.flags |= SEC_LEVEL;
6386 sec.level = SEC_LEVEL_0;
6388 sec.flags |= SEC_LEVEL;
6389 sec.level = SEC_LEVEL_1;
6391 if (priv->ieee->set_security)
6392 priv->ieee->set_security(priv->ieee->dev, &sec);
6396 case IW_AUTH_80211_AUTH_ALG:
6397 ret = ipw_wpa_set_auth_algs(priv, param->value);
6400 case IW_AUTH_WPA_ENABLED:
6401 ret = ipw_wpa_enable(priv, param->value);
6404 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6405 ieee->ieee802_1x = param->value;
6408 //case IW_AUTH_ROAMING_CONTROL:
6409 case IW_AUTH_PRIVACY_INVOKED:
6410 ieee->privacy_invoked = param->value;
6420 static int ipw_wx_get_auth(struct net_device *dev,
6421 struct iw_request_info *info,
6422 union iwreq_data *wrqu, char *extra)
6424 struct ipw_priv *priv = ieee80211_priv(dev);
6425 struct ieee80211_device *ieee = priv->ieee;
6426 struct ieee80211_crypt_data *crypt;
6427 struct iw_param *param = &wrqu->param;
6430 switch (param->flags & IW_AUTH_INDEX) {
6431 case IW_AUTH_WPA_VERSION:
6432 case IW_AUTH_CIPHER_PAIRWISE:
6433 case IW_AUTH_CIPHER_GROUP:
6434 case IW_AUTH_KEY_MGMT:
6436 * wpa_supplicant will control these internally
6441 case IW_AUTH_TKIP_COUNTERMEASURES:
6442 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6443 if (!crypt || !crypt->ops->get_flags) {
6444 IPW_WARNING("Can't get TKIP countermeasures: "
6445 "crypt not set!\n");
6449 param->value = (crypt->ops->get_flags(crypt->priv) &
6450 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6454 case IW_AUTH_DROP_UNENCRYPTED:
6455 param->value = ieee->drop_unencrypted;
6458 case IW_AUTH_80211_AUTH_ALG:
6459 param->value = ieee->sec.auth_mode;
6462 case IW_AUTH_WPA_ENABLED:
6463 param->value = ieee->wpa_enabled;
6466 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6467 param->value = ieee->ieee802_1x;
6470 case IW_AUTH_ROAMING_CONTROL:
6471 case IW_AUTH_PRIVACY_INVOKED:
6472 param->value = ieee->privacy_invoked;
6481 /* SIOCSIWENCODEEXT */
6482 static int ipw_wx_set_encodeext(struct net_device *dev,
6483 struct iw_request_info *info,
6484 union iwreq_data *wrqu, char *extra)
6486 struct ipw_priv *priv = ieee80211_priv(dev);
6487 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6490 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6491 /* IPW HW can't build TKIP MIC,
6492 host decryption still needed */
6493 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6494 priv->ieee->host_mc_decrypt = 1;
6496 priv->ieee->host_encrypt = 0;
6497 priv->ieee->host_encrypt_msdu = 1;
6498 priv->ieee->host_decrypt = 1;
6501 priv->ieee->host_encrypt = 0;
6502 priv->ieee->host_encrypt_msdu = 0;
6503 priv->ieee->host_decrypt = 0;
6504 priv->ieee->host_mc_decrypt = 0;
6508 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6511 /* SIOCGIWENCODEEXT */
6512 static int ipw_wx_get_encodeext(struct net_device *dev,
6513 struct iw_request_info *info,
6514 union iwreq_data *wrqu, char *extra)
6516 struct ipw_priv *priv = ieee80211_priv(dev);
6517 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6521 static int ipw_wx_set_mlme(struct net_device *dev,
6522 struct iw_request_info *info,
6523 union iwreq_data *wrqu, char *extra)
6525 struct ipw_priv *priv = ieee80211_priv(dev);
6526 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6529 reason = cpu_to_le16(mlme->reason_code);
6531 switch (mlme->cmd) {
6532 case IW_MLME_DEAUTH:
6536 case IW_MLME_DISASSOC:
6537 ipw_disassociate(priv);
6546 #ifdef CONFIG_IPW_QOS
6550 * get the modulation type of the current network or
6551 * the card current mode
6553 u8 ipw_qos_current_mode(struct ipw_priv * priv)
6557 if (priv->status & STATUS_ASSOCIATED) {
6558 unsigned long flags;
6560 spin_lock_irqsave(&priv->ieee->lock, flags);
6561 mode = priv->assoc_network->mode;
6562 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6564 mode = priv->ieee->mode;
6566 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6571 * Handle management frame beacon and probe response
6573 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6575 struct ieee80211_network *network)
6577 u32 size = sizeof(struct ieee80211_qos_parameters);
6579 if (network->capability & WLAN_CAPABILITY_IBSS)
6580 network->qos_data.active = network->qos_data.supported;
6582 if (network->flags & NETWORK_HAS_QOS_MASK) {
6583 if (active_network &&
6584 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6585 network->qos_data.active = network->qos_data.supported;
6587 if ((network->qos_data.active == 1) && (active_network == 1) &&
6588 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6589 (network->qos_data.old_param_count !=
6590 network->qos_data.param_count)) {
6591 network->qos_data.old_param_count =
6592 network->qos_data.param_count;
6593 schedule_work(&priv->qos_activate);
6594 IPW_DEBUG_QOS("QoS parameters change call "
6598 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6599 memcpy(&network->qos_data.parameters,
6600 &def_parameters_CCK, size);
6602 memcpy(&network->qos_data.parameters,
6603 &def_parameters_OFDM, size);
6605 if ((network->qos_data.active == 1) && (active_network == 1)) {
6606 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6607 schedule_work(&priv->qos_activate);
6610 network->qos_data.active = 0;
6611 network->qos_data.supported = 0;
6613 if ((priv->status & STATUS_ASSOCIATED) &&
6614 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6615 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6616 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6617 !(network->flags & NETWORK_EMPTY_ESSID))
6618 if ((network->ssid_len ==
6619 priv->assoc_network->ssid_len) &&
6620 !memcmp(network->ssid,
6621 priv->assoc_network->ssid,
6622 network->ssid_len)) {
6623 queue_work(priv->workqueue,
6624 &priv->merge_networks);
6632 * This function set up the firmware to support QoS. It sends
6633 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6635 static int ipw_qos_activate(struct ipw_priv *priv,
6636 struct ieee80211_qos_data *qos_network_data)
6639 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6640 struct ieee80211_qos_parameters *active_one = NULL;
6641 u32 size = sizeof(struct ieee80211_qos_parameters);
6646 type = ipw_qos_current_mode(priv);
6648 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6649 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6650 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6651 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6653 if (qos_network_data == NULL) {
6654 if (type == IEEE_B) {
6655 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6656 active_one = &def_parameters_CCK;
6658 active_one = &def_parameters_OFDM;
6660 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6661 burst_duration = ipw_qos_get_burst_duration(priv);
6662 for (i = 0; i < QOS_QUEUE_NUM; i++)
6663 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6664 (u16) burst_duration;
6665 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6666 if (type == IEEE_B) {
6667 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6669 if (priv->qos_data.qos_enable == 0)
6670 active_one = &def_parameters_CCK;
6672 active_one = priv->qos_data.def_qos_parm_CCK;
6674 if (priv->qos_data.qos_enable == 0)
6675 active_one = &def_parameters_OFDM;
6677 active_one = priv->qos_data.def_qos_parm_OFDM;
6679 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6681 unsigned long flags;
6684 spin_lock_irqsave(&priv->ieee->lock, flags);
6685 active_one = &(qos_network_data->parameters);
6686 qos_network_data->old_param_count =
6687 qos_network_data->param_count;
6688 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6689 active = qos_network_data->supported;
6690 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6693 burst_duration = ipw_qos_get_burst_duration(priv);
6694 for (i = 0; i < QOS_QUEUE_NUM; i++)
6695 qos_parameters[QOS_PARAM_SET_ACTIVE].
6696 tx_op_limit[i] = (u16) burst_duration;
6700 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6701 err = ipw_send_qos_params_command(priv,
6702 (struct ieee80211_qos_parameters *)
6703 &(qos_parameters[0]));
6705 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6711 * send IPW_CMD_WME_INFO to the firmware
6713 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6716 struct ieee80211_qos_information_element qos_info;
6721 qos_info.elementID = QOS_ELEMENT_ID;
6722 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6724 qos_info.version = QOS_VERSION_1;
6725 qos_info.ac_info = 0;
6727 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6728 qos_info.qui_type = QOS_OUI_TYPE;
6729 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6731 ret = ipw_send_qos_info_command(priv, &qos_info);
6733 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6739 * Set the QoS parameter with the association request structure
6741 static int ipw_qos_association(struct ipw_priv *priv,
6742 struct ieee80211_network *network)
6745 struct ieee80211_qos_data *qos_data = NULL;
6746 struct ieee80211_qos_data ibss_data = {
6751 switch (priv->ieee->iw_mode) {
6753 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6756 qos_data = &ibss_data;
6760 qos_data = &network->qos_data;
6768 err = ipw_qos_activate(priv, qos_data);
6770 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6774 if (priv->qos_data.qos_enable && qos_data->supported) {
6775 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6776 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6777 return ipw_qos_set_info_element(priv);
6784 * handling the beaconing responces. if we get different QoS setting
6785 * of the network from the the associated setting adjust the QoS
6788 static int ipw_qos_association_resp(struct ipw_priv *priv,
6789 struct ieee80211_network *network)
6792 unsigned long flags;
6793 u32 size = sizeof(struct ieee80211_qos_parameters);
6794 int set_qos_param = 0;
6796 if ((priv == NULL) || (network == NULL) ||
6797 (priv->assoc_network == NULL))
6800 if (!(priv->status & STATUS_ASSOCIATED))
6803 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
6806 spin_lock_irqsave(&priv->ieee->lock, flags);
6807 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
6808 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
6809 sizeof(struct ieee80211_qos_data));
6810 priv->assoc_network->qos_data.active = 1;
6811 if ((network->qos_data.old_param_count !=
6812 network->qos_data.param_count)) {
6814 network->qos_data.old_param_count =
6815 network->qos_data.param_count;
6819 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6820 memcpy(&priv->assoc_network->qos_data.parameters,
6821 &def_parameters_CCK, size);
6823 memcpy(&priv->assoc_network->qos_data.parameters,
6824 &def_parameters_OFDM, size);
6825 priv->assoc_network->qos_data.active = 0;
6826 priv->assoc_network->qos_data.supported = 0;
6830 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6832 if (set_qos_param == 1)
6833 schedule_work(&priv->qos_activate);
6838 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6845 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
6846 ret = priv->qos_data.burst_duration_CCK;
6848 ret = priv->qos_data.burst_duration_OFDM;
6854 * Initialize the setting of QoS global
6856 static void ipw_qos_init(struct ipw_priv *priv, int enable,
6857 int burst_enable, u32 burst_duration_CCK,
6858 u32 burst_duration_OFDM)
6860 priv->qos_data.qos_enable = enable;
6862 if (priv->qos_data.qos_enable) {
6863 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6864 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6865 IPW_DEBUG_QOS("QoS is enabled\n");
6867 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6868 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6869 IPW_DEBUG_QOS("QoS is not enabled\n");
6872 priv->qos_data.burst_enable = burst_enable;
6875 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6876 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6878 priv->qos_data.burst_duration_CCK = 0;
6879 priv->qos_data.burst_duration_OFDM = 0;
6884 * map the packet priority to the right TX Queue
6886 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6888 if (priority > 7 || !priv->qos_data.qos_enable)
6891 return from_priority_to_tx_queue[priority] - 1;
6895 * add QoS parameter to the TX command
6897 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6899 struct tfd_data *tfd, u8 unicast)
6902 int tx_queue_id = 0;
6903 struct ieee80211_qos_data *qos_data = NULL;
6904 int active, supported;
6905 unsigned long flags;
6907 if (!(priv->status & STATUS_ASSOCIATED))
6910 qos_data = &priv->assoc_network->qos_data;
6912 spin_lock_irqsave(&priv->ieee->lock, flags);
6914 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6916 qos_data->active = 0;
6918 qos_data->active = qos_data->supported;
6921 active = qos_data->active;
6922 supported = qos_data->supported;
6924 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6926 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
6928 priv->qos_data.qos_enable, active, supported, unicast);
6929 if (active && priv->qos_data.qos_enable) {
6930 ret = from_priority_to_tx_queue[priority];
6931 tx_queue_id = ret - 1;
6932 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6933 if (priority <= 7) {
6934 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6935 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6936 tfd->tfd.tfd_26.mchdr.frame_ctl |=
6937 IEEE80211_STYPE_QOS_DATA;
6939 if (priv->qos_data.qos_no_ack_mask &
6940 (1UL << tx_queue_id)) {
6941 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6942 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6952 * background support to run QoS activate functionality
6954 static void ipw_bg_qos_activate(void *data)
6956 struct ipw_priv *priv = data;
6963 if (priv->status & STATUS_ASSOCIATED)
6964 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6969 static int ipw_handle_probe_response(struct net_device *dev,
6970 struct ieee80211_probe_response *resp,
6971 struct ieee80211_network *network)
6973 struct ipw_priv *priv = ieee80211_priv(dev);
6974 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6975 (network == priv->assoc_network));
6977 ipw_qos_handle_probe_response(priv, active_network, network);
6982 static int ipw_handle_beacon(struct net_device *dev,
6983 struct ieee80211_beacon *resp,
6984 struct ieee80211_network *network)
6986 struct ipw_priv *priv = ieee80211_priv(dev);
6987 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6988 (network == priv->assoc_network));
6990 ipw_qos_handle_probe_response(priv, active_network, network);
6995 static int ipw_handle_assoc_response(struct net_device *dev,
6996 struct ieee80211_assoc_response *resp,
6997 struct ieee80211_network *network)
6999 struct ipw_priv *priv = ieee80211_priv(dev);
7000 ipw_qos_association_resp(priv, network);
7004 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7007 struct host_cmd cmd = {
7008 .cmd = IPW_CMD_QOS_PARAMETERS,
7009 .len = (sizeof(struct ieee80211_qos_parameters) * 3)
7012 memcpy(cmd.param, qos_param, sizeof(*qos_param) * 3);
7013 return ipw_send_cmd(priv, &cmd);
7016 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7019 struct host_cmd cmd = {
7020 .cmd = IPW_CMD_WME_INFO,
7021 .len = sizeof(*qos_param)
7024 memcpy(cmd.param, qos_param, sizeof(*qos_param));
7025 return ipw_send_cmd(priv, &cmd);
7028 #endif /* CONFIG_IPW_QOS */
7030 static int ipw_associate_network(struct ipw_priv *priv,
7031 struct ieee80211_network *network,
7032 struct ipw_supported_rates *rates, int roaming)
7036 if (priv->config & CFG_FIXED_RATE)
7037 ipw_set_fixed_rate(priv, network->mode);
7039 if (!(priv->config & CFG_STATIC_ESSID)) {
7040 priv->essid_len = min(network->ssid_len,
7041 (u8) IW_ESSID_MAX_SIZE);
7042 memcpy(priv->essid, network->ssid, priv->essid_len);
7045 network->last_associate = jiffies;
7047 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7048 priv->assoc_request.channel = network->channel;
7049 if ((priv->capability & CAP_PRIVACY_ON) &&
7050 (priv->capability & CAP_SHARED_KEY)) {
7051 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7052 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7054 if ((priv->capability & CAP_PRIVACY_ON) &&
7055 (priv->ieee->sec.level == SEC_LEVEL_1) &&
7056 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
7057 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7059 priv->assoc_request.auth_type = AUTH_OPEN;
7060 priv->assoc_request.auth_key = 0;
7063 if (priv->ieee->wpa_ie_len) {
7064 priv->assoc_request.policy_support = 0x02; /* RSN active */
7065 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7066 priv->ieee->wpa_ie_len);
7070 * It is valid for our ieee device to support multiple modes, but
7071 * when it comes to associating to a given network we have to choose
7074 if (network->mode & priv->ieee->mode & IEEE_A)
7075 priv->assoc_request.ieee_mode = IPW_A_MODE;
7076 else if (network->mode & priv->ieee->mode & IEEE_G)
7077 priv->assoc_request.ieee_mode = IPW_G_MODE;
7078 else if (network->mode & priv->ieee->mode & IEEE_B)
7079 priv->assoc_request.ieee_mode = IPW_B_MODE;
7081 priv->assoc_request.capability = network->capability;
7082 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7083 && !(priv->config & CFG_PREAMBLE_LONG)) {
7084 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7086 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7088 /* Clear the short preamble if we won't be supporting it */
7089 priv->assoc_request.capability &=
7090 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7093 /* Clear capability bits that aren't used in Ad Hoc */
7094 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7095 priv->assoc_request.capability &=
7096 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7098 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7099 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7100 roaming ? "Rea" : "A",
7101 escape_essid(priv->essid, priv->essid_len),
7103 ipw_modes[priv->assoc_request.ieee_mode],
7105 (priv->assoc_request.preamble_length ==
7106 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7107 network->capability &
7108 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7109 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7110 priv->capability & CAP_PRIVACY_ON ?
7111 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7113 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7114 priv->capability & CAP_PRIVACY_ON ?
7115 '1' + priv->ieee->sec.active_key : '.',
7116 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7118 priv->assoc_request.beacon_interval = network->beacon_interval;
7119 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7120 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7121 priv->assoc_request.assoc_type = HC_IBSS_START;
7122 priv->assoc_request.assoc_tsf_msw = 0;
7123 priv->assoc_request.assoc_tsf_lsw = 0;
7125 if (unlikely(roaming))
7126 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7128 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7129 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7130 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7133 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7135 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7136 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7137 priv->assoc_request.atim_window = network->atim_window;
7139 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7140 priv->assoc_request.atim_window = 0;
7143 priv->assoc_request.listen_interval = network->listen_interval;
7145 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7147 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7151 rates->ieee_mode = priv->assoc_request.ieee_mode;
7152 rates->purpose = IPW_RATE_CONNECT;
7153 ipw_send_supported_rates(priv, rates);
7155 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7156 priv->sys_config.dot11g_auto_detection = 1;
7158 priv->sys_config.dot11g_auto_detection = 0;
7160 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7161 priv->sys_config.answer_broadcast_ssid_probe = 1;
7163 priv->sys_config.answer_broadcast_ssid_probe = 0;
7165 err = ipw_send_system_config(priv, &priv->sys_config);
7167 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7171 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7172 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7174 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7179 * If preemption is enabled, it is possible for the association
7180 * to complete before we return from ipw_send_associate. Therefore
7181 * we have to be sure and update our priviate data first.
7183 priv->channel = network->channel;
7184 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7185 priv->status |= STATUS_ASSOCIATING;
7186 priv->status &= ~STATUS_SECURITY_UPDATED;
7188 priv->assoc_network = network;
7190 #ifdef CONFIG_IPW_QOS
7191 ipw_qos_association(priv, network);
7194 err = ipw_send_associate(priv, &priv->assoc_request);
7196 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7200 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7201 escape_essid(priv->essid, priv->essid_len),
7202 MAC_ARG(priv->bssid));
7207 static void ipw_roam(void *data)
7209 struct ipw_priv *priv = data;
7210 struct ieee80211_network *network = NULL;
7211 struct ipw_network_match match = {
7212 .network = priv->assoc_network
7215 /* The roaming process is as follows:
7217 * 1. Missed beacon threshold triggers the roaming process by
7218 * setting the status ROAM bit and requesting a scan.
7219 * 2. When the scan completes, it schedules the ROAM work
7220 * 3. The ROAM work looks at all of the known networks for one that
7221 * is a better network than the currently associated. If none
7222 * found, the ROAM process is over (ROAM bit cleared)
7223 * 4. If a better network is found, a disassociation request is
7225 * 5. When the disassociation completes, the roam work is again
7226 * scheduled. The second time through, the driver is no longer
7227 * associated, and the newly selected network is sent an
7228 * association request.
7229 * 6. At this point ,the roaming process is complete and the ROAM
7230 * status bit is cleared.
7233 /* If we are no longer associated, and the roaming bit is no longer
7234 * set, then we are not actively roaming, so just return */
7235 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7238 if (priv->status & STATUS_ASSOCIATED) {
7239 /* First pass through ROAM process -- look for a better
7241 unsigned long flags;
7242 u8 rssi = priv->assoc_network->stats.rssi;
7243 priv->assoc_network->stats.rssi = -128;
7244 spin_lock_irqsave(&priv->ieee->lock, flags);
7245 list_for_each_entry(network, &priv->ieee->network_list, list) {
7246 if (network != priv->assoc_network)
7247 ipw_best_network(priv, &match, network, 1);
7249 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7250 priv->assoc_network->stats.rssi = rssi;
7252 if (match.network == priv->assoc_network) {
7253 IPW_DEBUG_ASSOC("No better APs in this network to "
7255 priv->status &= ~STATUS_ROAMING;
7256 ipw_debug_config(priv);
7260 ipw_send_disassociate(priv, 1);
7261 priv->assoc_network = match.network;
7266 /* Second pass through ROAM process -- request association */
7267 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7268 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7269 priv->status &= ~STATUS_ROAMING;
7272 static void ipw_bg_roam(void *data)
7274 struct ipw_priv *priv = data;
7280 static int ipw_associate(void *data)
7282 struct ipw_priv *priv = data;
7284 struct ieee80211_network *network = NULL;
7285 struct ipw_network_match match = {
7288 struct ipw_supported_rates *rates;
7289 struct list_head *element;
7290 unsigned long flags;
7292 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7293 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7297 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7298 IPW_DEBUG_ASSOC("Not attempting association (already in "
7303 if (priv->status & STATUS_DISASSOCIATING) {
7304 IPW_DEBUG_ASSOC("Not attempting association (in "
7305 "disassociating)\n ");
7306 queue_work(priv->workqueue, &priv->associate);
7310 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7311 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7316 if (!(priv->config & CFG_ASSOCIATE) &&
7317 !(priv->config & (CFG_STATIC_ESSID |
7318 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7319 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7323 /* Protect our use of the network_list */
7324 spin_lock_irqsave(&priv->ieee->lock, flags);
7325 list_for_each_entry(network, &priv->ieee->network_list, list)
7326 ipw_best_network(priv, &match, network, 0);
7328 network = match.network;
7329 rates = &match.rates;
7331 if (network == NULL &&
7332 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7333 priv->config & CFG_ADHOC_CREATE &&
7334 priv->config & CFG_STATIC_ESSID &&
7335 priv->config & CFG_STATIC_CHANNEL &&
7336 !list_empty(&priv->ieee->network_free_list)) {
7337 element = priv->ieee->network_free_list.next;
7338 network = list_entry(element, struct ieee80211_network, list);
7339 ipw_adhoc_create(priv, network);
7340 rates = &priv->rates;
7342 list_add_tail(&network->list, &priv->ieee->network_list);
7344 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7346 /* If we reached the end of the list, then we don't have any valid
7349 ipw_debug_config(priv);
7351 if (!(priv->status & STATUS_SCANNING)) {
7352 if (!(priv->config & CFG_SPEED_SCAN))
7353 queue_delayed_work(priv->workqueue,
7354 &priv->request_scan,
7357 queue_work(priv->workqueue,
7358 &priv->request_scan);
7364 ipw_associate_network(priv, network, rates, 0);
7369 static void ipw_bg_associate(void *data)
7371 struct ipw_priv *priv = data;
7373 ipw_associate(data);
7377 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7378 struct sk_buff *skb)
7380 struct ieee80211_hdr *hdr;
7383 hdr = (struct ieee80211_hdr *)skb->data;
7384 fc = le16_to_cpu(hdr->frame_ctl);
7385 if (!(fc & IEEE80211_FCTL_PROTECTED))
7388 fc &= ~IEEE80211_FCTL_PROTECTED;
7389 hdr->frame_ctl = cpu_to_le16(fc);
7390 switch (priv->ieee->sec.level) {
7392 /* Remove CCMP HDR */
7393 memmove(skb->data + IEEE80211_3ADDR_LEN,
7394 skb->data + IEEE80211_3ADDR_LEN + 8,
7395 skb->len - IEEE80211_3ADDR_LEN - 8);
7396 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7402 memmove(skb->data + IEEE80211_3ADDR_LEN,
7403 skb->data + IEEE80211_3ADDR_LEN + 4,
7404 skb->len - IEEE80211_3ADDR_LEN - 4);
7405 skb_trim(skb, skb->len - 8); /* IV + ICV */
7410 printk(KERN_ERR "Unknow security level %d\n",
7411 priv->ieee->sec.level);
7416 static void ipw_handle_data_packet(struct ipw_priv *priv,
7417 struct ipw_rx_mem_buffer *rxb,
7418 struct ieee80211_rx_stats *stats)
7420 struct ieee80211_hdr_4addr *hdr;
7421 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7423 /* We received data from the HW, so stop the watchdog */
7424 priv->net_dev->trans_start = jiffies;
7426 /* We only process data packets if the
7427 * interface is open */
7428 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7429 skb_tailroom(rxb->skb))) {
7430 priv->ieee->stats.rx_errors++;
7431 priv->wstats.discard.misc++;
7432 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7434 } else if (unlikely(!netif_running(priv->net_dev))) {
7435 priv->ieee->stats.rx_dropped++;
7436 priv->wstats.discard.misc++;
7437 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7441 /* Advance skb->data to the start of the actual payload */
7442 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7444 /* Set the size of the skb to the size of the frame */
7445 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7447 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7449 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7450 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7451 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7452 (is_multicast_ether_addr(hdr->addr1) ?
7453 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7454 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7456 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7457 priv->ieee->stats.rx_errors++;
7458 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7460 __ipw_led_activity_on(priv);
7464 #ifdef CONFIG_IEEE80211_RADIOTAP
7465 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7466 struct ipw_rx_mem_buffer *rxb,
7467 struct ieee80211_rx_stats *stats)
7469 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7470 struct ipw_rx_frame *frame = &pkt->u.frame;
7472 /* initial pull of some data */
7473 u16 received_channel = frame->received_channel;
7474 u8 antennaAndPhy = frame->antennaAndPhy;
7475 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7476 u16 pktrate = frame->rate;
7478 /* Magic struct that slots into the radiotap header -- no reason
7479 * to build this manually element by element, we can write it much
7480 * more efficiently than we can parse it. ORDER MATTERS HERE */
7482 struct ieee80211_radiotap_header rt_hdr;
7483 u8 rt_flags; /* radiotap packet flags */
7484 u8 rt_rate; /* rate in 500kb/s */
7485 u16 rt_channel; /* channel in mhz */
7486 u16 rt_chbitmask; /* channel bitfield */
7487 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7488 u8 rt_antenna; /* antenna number */
7491 short len = le16_to_cpu(pkt->u.frame.length);
7493 /* We received data from the HW, so stop the watchdog */
7494 priv->net_dev->trans_start = jiffies;
7496 /* We only process data packets if the
7497 * interface is open */
7498 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7499 skb_tailroom(rxb->skb))) {
7500 priv->ieee->stats.rx_errors++;
7501 priv->wstats.discard.misc++;
7502 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7504 } else if (unlikely(!netif_running(priv->net_dev))) {
7505 priv->ieee->stats.rx_dropped++;
7506 priv->wstats.discard.misc++;
7507 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7511 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7513 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7514 /* FIXME: Should alloc bigger skb instead */
7515 priv->ieee->stats.rx_dropped++;
7516 priv->wstats.discard.misc++;
7517 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7521 /* copy the frame itself */
7522 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7523 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7525 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7526 * part of our real header, saves a little time.
7528 * No longer necessary since we fill in all our data. Purge before merging
7530 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7531 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7534 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7536 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7537 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7538 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7540 /* Big bitfield of all the fields we provide in radiotap */
7541 ipw_rt->rt_hdr.it_present =
7542 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7543 (1 << IEEE80211_RADIOTAP_RATE) |
7544 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7545 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7546 (1 << IEEE80211_RADIOTAP_ANTENNA));
7548 /* Zero the flags, we'll add to them as we go */
7549 ipw_rt->rt_flags = 0;
7551 /* Convert signal to DBM */
7552 ipw_rt->rt_dbmsignal = antsignal;
7554 /* Convert the channel data and set the flags */
7555 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7556 if (received_channel > 14) { /* 802.11a */
7557 ipw_rt->rt_chbitmask =
7558 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7559 } else if (antennaAndPhy & 32) { /* 802.11b */
7560 ipw_rt->rt_chbitmask =
7561 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7562 } else { /* 802.11g */
7563 ipw_rt->rt_chbitmask =
7564 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7567 /* set the rate in multiples of 500k/s */
7569 case IPW_TX_RATE_1MB:
7570 ipw_rt->rt_rate = 2;
7572 case IPW_TX_RATE_2MB:
7573 ipw_rt->rt_rate = 4;
7575 case IPW_TX_RATE_5MB:
7576 ipw_rt->rt_rate = 10;
7578 case IPW_TX_RATE_6MB:
7579 ipw_rt->rt_rate = 12;
7581 case IPW_TX_RATE_9MB:
7582 ipw_rt->rt_rate = 18;
7584 case IPW_TX_RATE_11MB:
7585 ipw_rt->rt_rate = 22;
7587 case IPW_TX_RATE_12MB:
7588 ipw_rt->rt_rate = 24;
7590 case IPW_TX_RATE_18MB:
7591 ipw_rt->rt_rate = 36;
7593 case IPW_TX_RATE_24MB:
7594 ipw_rt->rt_rate = 48;
7596 case IPW_TX_RATE_36MB:
7597 ipw_rt->rt_rate = 72;
7599 case IPW_TX_RATE_48MB:
7600 ipw_rt->rt_rate = 96;
7602 case IPW_TX_RATE_54MB:
7603 ipw_rt->rt_rate = 108;
7606 ipw_rt->rt_rate = 0;
7610 /* antenna number */
7611 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7613 /* set the preamble flag if we have it */
7614 if ((antennaAndPhy & 64))
7615 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7617 /* Set the size of the skb to the size of the frame */
7618 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7620 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7622 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7623 priv->ieee->stats.rx_errors++;
7624 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7626 /* no LED during capture */
7631 static inline int is_network_packet(struct ipw_priv *priv,
7632 struct ieee80211_hdr_4addr *header)
7634 /* Filter incoming packets to determine if they are targetted toward
7635 * this network, discarding packets coming from ourselves */
7636 switch (priv->ieee->iw_mode) {
7637 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
7638 /* packets from our adapter are dropped (echo) */
7639 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7642 /* {broad,multi}cast packets to our BSSID go through */
7643 if (is_multicast_ether_addr(header->addr1) ||
7644 is_broadcast_ether_addr(header->addr1))
7645 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
7647 /* packets to our adapter go through */
7648 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7651 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
7652 /* packets from our adapter are dropped (echo) */
7653 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7656 /* {broad,multi}cast packets to our BSS go through */
7657 if (is_multicast_ether_addr(header->addr1) ||
7658 is_broadcast_ether_addr(header->addr1))
7659 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7661 /* packets to our adapter go through */
7662 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7669 #define IPW_PACKET_RETRY_TIME HZ
7671 static inline int is_duplicate_packet(struct ipw_priv *priv,
7672 struct ieee80211_hdr_4addr *header)
7674 u16 sc = le16_to_cpu(header->seq_ctl);
7675 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7676 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7677 u16 *last_seq, *last_frag;
7678 unsigned long *last_time;
7680 switch (priv->ieee->iw_mode) {
7683 struct list_head *p;
7684 struct ipw_ibss_seq *entry = NULL;
7685 u8 *mac = header->addr2;
7686 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7688 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7690 list_entry(p, struct ipw_ibss_seq, list);
7691 if (!memcmp(entry->mac, mac, ETH_ALEN))
7694 if (p == &priv->ibss_mac_hash[index]) {
7695 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7698 ("Cannot malloc new mac entry\n");
7701 memcpy(entry->mac, mac, ETH_ALEN);
7702 entry->seq_num = seq;
7703 entry->frag_num = frag;
7704 entry->packet_time = jiffies;
7705 list_add(&entry->list,
7706 &priv->ibss_mac_hash[index]);
7709 last_seq = &entry->seq_num;
7710 last_frag = &entry->frag_num;
7711 last_time = &entry->packet_time;
7715 last_seq = &priv->last_seq_num;
7716 last_frag = &priv->last_frag_num;
7717 last_time = &priv->last_packet_time;
7722 if ((*last_seq == seq) &&
7723 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7724 if (*last_frag == frag)
7726 if (*last_frag + 1 != frag)
7727 /* out-of-order fragment */
7733 *last_time = jiffies;
7737 /* Comment this line now since we observed the card receives
7738 * duplicate packets but the FCTL_RETRY bit is not set in the
7739 * IBSS mode with fragmentation enabled.
7740 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
7744 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7745 struct ipw_rx_mem_buffer *rxb,
7746 struct ieee80211_rx_stats *stats)
7748 struct sk_buff *skb = rxb->skb;
7749 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7750 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7751 (skb->data + IPW_RX_FRAME_SIZE);
7753 ieee80211_rx_mgt(priv->ieee, header, stats);
7755 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7756 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7757 IEEE80211_STYPE_PROBE_RESP) ||
7758 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7759 IEEE80211_STYPE_BEACON))) {
7760 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7761 ipw_add_station(priv, header->addr2);
7764 if (priv->config & CFG_NET_STATS) {
7765 IPW_DEBUG_HC("sending stat packet\n");
7767 /* Set the size of the skb to the size of the full
7768 * ipw header and 802.11 frame */
7769 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7772 /* Advance past the ipw packet header to the 802.11 frame */
7773 skb_pull(skb, IPW_RX_FRAME_SIZE);
7775 /* Push the ieee80211_rx_stats before the 802.11 frame */
7776 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7778 skb->dev = priv->ieee->dev;
7780 /* Point raw at the ieee80211_stats */
7781 skb->mac.raw = skb->data;
7783 skb->pkt_type = PACKET_OTHERHOST;
7784 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7785 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7792 * Main entry function for recieving a packet with 80211 headers. This
7793 * should be called when ever the FW has notified us that there is a new
7794 * skb in the recieve queue.
7796 static void ipw_rx(struct ipw_priv *priv)
7798 struct ipw_rx_mem_buffer *rxb;
7799 struct ipw_rx_packet *pkt;
7800 struct ieee80211_hdr_4addr *header;
7804 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7805 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
7806 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7809 rxb = priv->rxq->queue[i];
7810 #ifdef CONFIG_IPW_DEBUG
7811 if (unlikely(rxb == NULL)) {
7812 printk(KERN_CRIT "Queue not allocated!\n");
7816 priv->rxq->queue[i] = NULL;
7818 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
7820 PCI_DMA_FROMDEVICE);
7822 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7823 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7824 pkt->header.message_type,
7825 pkt->header.rx_seq_num, pkt->header.control_bits);
7827 switch (pkt->header.message_type) {
7828 case RX_FRAME_TYPE: /* 802.11 frame */ {
7829 struct ieee80211_rx_stats stats = {
7831 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7834 le16_to_cpu(pkt->u.frame.signal),
7836 le16_to_cpu(pkt->u.frame.noise),
7837 .rate = pkt->u.frame.rate,
7838 .mac_time = jiffies,
7840 pkt->u.frame.received_channel,
7843 control & (1 << 0)) ?
7844 IEEE80211_24GHZ_BAND :
7845 IEEE80211_52GHZ_BAND,
7846 .len = le16_to_cpu(pkt->u.frame.length),
7849 if (stats.rssi != 0)
7850 stats.mask |= IEEE80211_STATMASK_RSSI;
7851 if (stats.signal != 0)
7852 stats.mask |= IEEE80211_STATMASK_SIGNAL;
7853 if (stats.noise != 0)
7854 stats.mask |= IEEE80211_STATMASK_NOISE;
7855 if (stats.rate != 0)
7856 stats.mask |= IEEE80211_STATMASK_RATE;
7860 #ifdef CONFIG_IPW2200_MONITOR
7861 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7862 #ifdef CONFIG_IEEE80211_RADIOTAP
7863 ipw_handle_data_packet_monitor(priv,
7867 ipw_handle_data_packet(priv, rxb,
7875 (struct ieee80211_hdr_4addr *)(rxb->skb->
7878 /* TODO: Check Ad-Hoc dest/source and make sure
7879 * that we are actually parsing these packets
7880 * correctly -- we should probably use the
7881 * frame control of the packet and disregard
7882 * the current iw_mode */
7885 is_network_packet(priv, header);
7886 if (network_packet && priv->assoc_network) {
7887 priv->assoc_network->stats.rssi =
7889 average_add(&priv->average_rssi,
7891 priv->last_rx_rssi = stats.rssi;
7894 IPW_DEBUG_RX("Frame: len=%u\n",
7895 le16_to_cpu(pkt->u.frame.length));
7897 if (le16_to_cpu(pkt->u.frame.length) <
7898 frame_hdr_len(header)) {
7900 ("Received packet is too small. "
7902 priv->ieee->stats.rx_errors++;
7903 priv->wstats.discard.misc++;
7907 switch (WLAN_FC_GET_TYPE
7908 (le16_to_cpu(header->frame_ctl))) {
7910 case IEEE80211_FTYPE_MGMT:
7911 ipw_handle_mgmt_packet(priv, rxb,
7915 case IEEE80211_FTYPE_CTL:
7918 case IEEE80211_FTYPE_DATA:
7919 if (unlikely(!network_packet ||
7920 is_duplicate_packet(priv,
7923 IPW_DEBUG_DROP("Dropping: "
7936 ipw_handle_data_packet(priv, rxb,
7944 case RX_HOST_NOTIFICATION_TYPE:{
7946 ("Notification: subtype=%02X flags=%02X size=%d\n",
7947 pkt->u.notification.subtype,
7948 pkt->u.notification.flags,
7949 pkt->u.notification.size);
7950 ipw_rx_notification(priv, &pkt->u.notification);
7955 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7956 pkt->header.message_type);
7960 /* For now we just don't re-use anything. We can tweak this
7961 * later to try and re-use notification packets and SKBs that
7962 * fail to Rx correctly */
7963 if (rxb->skb != NULL) {
7964 dev_kfree_skb_any(rxb->skb);
7968 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
7969 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
7970 list_add_tail(&rxb->list, &priv->rxq->rx_used);
7972 i = (i + 1) % RX_QUEUE_SIZE;
7975 /* Backtrack one entry */
7976 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7978 ipw_rx_queue_restock(priv);
7981 #define DEFAULT_RTS_THRESHOLD 2304U
7982 #define MIN_RTS_THRESHOLD 1U
7983 #define MAX_RTS_THRESHOLD 2304U
7984 #define DEFAULT_BEACON_INTERVAL 100U
7985 #define DEFAULT_SHORT_RETRY_LIMIT 7U
7986 #define DEFAULT_LONG_RETRY_LIMIT 4U
7988 static int ipw_sw_reset(struct ipw_priv *priv, int init)
7990 int band, modulation;
7991 int old_mode = priv->ieee->iw_mode;
7993 /* Initialize module parameter values here */
7996 /* We default to disabling the LED code as right now it causes
7997 * too many systems to lock up... */
7999 priv->config |= CFG_NO_LED;
8002 priv->config |= CFG_ASSOCIATE;
8004 IPW_DEBUG_INFO("Auto associate disabled.\n");
8007 priv->config |= CFG_ADHOC_CREATE;
8009 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8012 priv->status |= STATUS_RF_KILL_SW;
8013 IPW_DEBUG_INFO("Radio disabled.\n");
8017 priv->config |= CFG_STATIC_CHANNEL;
8018 priv->channel = channel;
8019 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8020 /* TODO: Validate that provided channel is in range */
8022 #ifdef CONFIG_IPW_QOS
8023 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8024 burst_duration_CCK, burst_duration_OFDM);
8025 #endif /* CONFIG_IPW_QOS */
8029 priv->ieee->iw_mode = IW_MODE_ADHOC;
8030 priv->net_dev->type = ARPHRD_ETHER;
8033 #ifdef CONFIG_IPW2200_MONITOR
8035 priv->ieee->iw_mode = IW_MODE_MONITOR;
8036 #ifdef CONFIG_IEEE80211_RADIOTAP
8037 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8039 priv->net_dev->type = ARPHRD_IEEE80211;
8045 priv->net_dev->type = ARPHRD_ETHER;
8046 priv->ieee->iw_mode = IW_MODE_INFRA;
8051 priv->ieee->host_encrypt = 0;
8052 priv->ieee->host_encrypt_msdu = 0;
8053 priv->ieee->host_decrypt = 0;
8054 priv->ieee->host_mc_decrypt = 0;
8056 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8058 /* IPW2200/2915 is abled to do hardware fragmentation. */
8059 priv->ieee->host_open_frag = 0;
8061 if ((priv->pci_dev->device == 0x4223) ||
8062 (priv->pci_dev->device == 0x4224)) {
8064 printk(KERN_INFO DRV_NAME
8065 ": Detected Intel PRO/Wireless 2915ABG Network "
8067 priv->ieee->abg_true = 1;
8068 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8069 modulation = IEEE80211_OFDM_MODULATION |
8070 IEEE80211_CCK_MODULATION;
8071 priv->adapter = IPW_2915ABG;
8072 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8075 printk(KERN_INFO DRV_NAME
8076 ": Detected Intel PRO/Wireless 2200BG Network "
8079 priv->ieee->abg_true = 0;
8080 band = IEEE80211_24GHZ_BAND;
8081 modulation = IEEE80211_OFDM_MODULATION |
8082 IEEE80211_CCK_MODULATION;
8083 priv->adapter = IPW_2200BG;
8084 priv->ieee->mode = IEEE_G | IEEE_B;
8087 priv->ieee->freq_band = band;
8088 priv->ieee->modulation = modulation;
8090 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8092 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8093 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8095 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8096 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8097 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8099 /* If power management is turned on, default to AC mode */
8100 priv->power_mode = IPW_POWER_AC;
8101 priv->tx_power = IPW_TX_POWER_DEFAULT;
8103 return old_mode == priv->ieee->iw_mode;
8107 * This file defines the Wireless Extension handlers. It does not
8108 * define any methods of hardware manipulation and relies on the
8109 * functions defined in ipw_main to provide the HW interaction.
8111 * The exception to this is the use of the ipw_get_ordinal()
8112 * function used to poll the hardware vs. making unecessary calls.
8116 static int ipw_wx_get_name(struct net_device *dev,
8117 struct iw_request_info *info,
8118 union iwreq_data *wrqu, char *extra)
8120 struct ipw_priv *priv = ieee80211_priv(dev);
8122 if (priv->status & STATUS_RF_KILL_MASK)
8123 strcpy(wrqu->name, "radio off");
8124 else if (!(priv->status & STATUS_ASSOCIATED))
8125 strcpy(wrqu->name, "unassociated");
8127 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8128 ipw_modes[priv->assoc_request.ieee_mode]);
8129 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8134 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8137 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8138 priv->config &= ~CFG_STATIC_CHANNEL;
8139 IPW_DEBUG_ASSOC("Attempting to associate with new "
8141 ipw_associate(priv);
8145 priv->config |= CFG_STATIC_CHANNEL;
8147 if (priv->channel == channel) {
8148 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8153 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8154 priv->channel = channel;
8156 #ifdef CONFIG_IPW2200_MONITOR
8157 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8159 if (priv->status & STATUS_SCANNING) {
8160 IPW_DEBUG_SCAN("Scan abort triggered due to "
8161 "channel change.\n");
8162 ipw_abort_scan(priv);
8165 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8168 if (priv->status & STATUS_SCANNING)
8169 IPW_DEBUG_SCAN("Still scanning...\n");
8171 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8176 #endif /* CONFIG_IPW2200_MONITOR */
8178 /* Network configuration changed -- force [re]association */
8179 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8180 if (!ipw_disassociate(priv))
8181 ipw_associate(priv);
8186 static int ipw_wx_set_freq(struct net_device *dev,
8187 struct iw_request_info *info,
8188 union iwreq_data *wrqu, char *extra)
8190 struct ipw_priv *priv = ieee80211_priv(dev);
8191 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8192 struct iw_freq *fwrq = &wrqu->freq;
8198 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8200 ret = ipw_set_channel(priv, 0);
8204 /* if setting by freq convert to channel */
8206 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
8212 if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8215 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8216 i = ipw_channel_to_index(priv->ieee, channel);
8220 flags = (band == IEEE80211_24GHZ_BAND) ?
8221 geo->bg[i].flags : geo->a[i].flags;
8222 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8223 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8228 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8230 ret = ipw_set_channel(priv, channel);
8235 static int ipw_wx_get_freq(struct net_device *dev,
8236 struct iw_request_info *info,
8237 union iwreq_data *wrqu, char *extra)
8239 struct ipw_priv *priv = ieee80211_priv(dev);
8243 /* If we are associated, trying to associate, or have a statically
8244 * configured CHANNEL then return that; otherwise return ANY */
8246 if (priv->config & CFG_STATIC_CHANNEL ||
8247 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8248 wrqu->freq.m = priv->channel;
8253 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8257 static int ipw_wx_set_mode(struct net_device *dev,
8258 struct iw_request_info *info,
8259 union iwreq_data *wrqu, char *extra)
8261 struct ipw_priv *priv = ieee80211_priv(dev);
8264 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8266 switch (wrqu->mode) {
8267 #ifdef CONFIG_IPW2200_MONITOR
8268 case IW_MODE_MONITOR:
8274 wrqu->mode = IW_MODE_INFRA;
8279 if (wrqu->mode == priv->ieee->iw_mode)
8284 ipw_sw_reset(priv, 0);
8286 #ifdef CONFIG_IPW2200_MONITOR
8287 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8288 priv->net_dev->type = ARPHRD_ETHER;
8290 if (wrqu->mode == IW_MODE_MONITOR)
8291 #ifdef CONFIG_IEEE80211_RADIOTAP
8292 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8294 priv->net_dev->type = ARPHRD_IEEE80211;
8296 #endif /* CONFIG_IPW2200_MONITOR */
8298 /* Free the existing firmware and reset the fw_loaded
8299 * flag so ipw_load() will bring in the new firmawre */
8302 priv->ieee->iw_mode = wrqu->mode;
8304 queue_work(priv->workqueue, &priv->adapter_restart);
8309 static int ipw_wx_get_mode(struct net_device *dev,
8310 struct iw_request_info *info,
8311 union iwreq_data *wrqu, char *extra)
8313 struct ipw_priv *priv = ieee80211_priv(dev);
8315 wrqu->mode = priv->ieee->iw_mode;
8316 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8321 /* Values are in microsecond */
8322 static const s32 timeout_duration[] = {
8330 static const s32 period_duration[] = {
8338 static int ipw_wx_get_range(struct net_device *dev,
8339 struct iw_request_info *info,
8340 union iwreq_data *wrqu, char *extra)
8342 struct ipw_priv *priv = ieee80211_priv(dev);
8343 struct iw_range *range = (struct iw_range *)extra;
8344 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8347 wrqu->data.length = sizeof(*range);
8348 memset(range, 0, sizeof(*range));
8350 /* 54Mbs == ~27 Mb/s real (802.11g) */
8351 range->throughput = 27 * 1000 * 1000;
8353 range->max_qual.qual = 100;
8354 /* TODO: Find real max RSSI and stick here */
8355 range->max_qual.level = 0;
8356 range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
8357 range->max_qual.updated = 7; /* Updated all three */
8359 range->avg_qual.qual = 70;
8360 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8361 range->avg_qual.level = 0; /* FIXME to real average level */
8362 range->avg_qual.noise = 0;
8363 range->avg_qual.updated = 7; /* Updated all three */
8365 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8367 for (i = 0; i < range->num_bitrates; i++)
8368 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8371 range->max_rts = DEFAULT_RTS_THRESHOLD;
8372 range->min_frag = MIN_FRAG_THRESHOLD;
8373 range->max_frag = MAX_FRAG_THRESHOLD;
8375 range->encoding_size[0] = 5;
8376 range->encoding_size[1] = 13;
8377 range->num_encoding_sizes = 2;
8378 range->max_encoding_tokens = WEP_KEYS;
8380 /* Set the Wireless Extension versions */
8381 range->we_version_compiled = WIRELESS_EXT;
8382 range->we_version_source = 16;
8385 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8386 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8388 range->freq[i].i = geo->bg[j].channel;
8389 range->freq[i].m = geo->bg[j].freq * 100000;
8390 range->freq[i].e = 1;
8394 if (priv->ieee->mode & IEEE_A) {
8395 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8397 range->freq[i].i = geo->a[j].channel;
8398 range->freq[i].m = geo->a[j].freq * 100000;
8399 range->freq[i].e = 1;
8403 range->num_channels = i;
8404 range->num_frequency = i;
8408 /* Event capability (kernel + driver) */
8409 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8410 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8411 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8412 range->event_capa[1] = IW_EVENT_CAPA_K_1;
8414 IPW_DEBUG_WX("GET Range\n");
8418 static int ipw_wx_set_wap(struct net_device *dev,
8419 struct iw_request_info *info,
8420 union iwreq_data *wrqu, char *extra)
8422 struct ipw_priv *priv = ieee80211_priv(dev);
8424 static const unsigned char any[] = {
8425 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8427 static const unsigned char off[] = {
8428 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8431 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8434 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8435 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8436 /* we disable mandatory BSSID association */
8437 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8438 priv->config &= ~CFG_STATIC_BSSID;
8439 IPW_DEBUG_ASSOC("Attempting to associate with new "
8441 ipw_associate(priv);
8446 priv->config |= CFG_STATIC_BSSID;
8447 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8448 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8453 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8454 MAC_ARG(wrqu->ap_addr.sa_data));
8456 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8458 /* Network configuration changed -- force [re]association */
8459 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8460 if (!ipw_disassociate(priv))
8461 ipw_associate(priv);
8467 static int ipw_wx_get_wap(struct net_device *dev,
8468 struct iw_request_info *info,
8469 union iwreq_data *wrqu, char *extra)
8471 struct ipw_priv *priv = ieee80211_priv(dev);
8472 /* If we are associated, trying to associate, or have a statically
8473 * configured BSSID then return that; otherwise return ANY */
8475 if (priv->config & CFG_STATIC_BSSID ||
8476 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8477 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8478 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8480 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8482 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8483 MAC_ARG(wrqu->ap_addr.sa_data));
8488 static int ipw_wx_set_essid(struct net_device *dev,
8489 struct iw_request_info *info,
8490 union iwreq_data *wrqu, char *extra)
8492 struct ipw_priv *priv = ieee80211_priv(dev);
8493 char *essid = ""; /* ANY */
8496 if (wrqu->essid.flags && wrqu->essid.length) {
8497 length = wrqu->essid.length - 1;
8501 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8502 if ((priv->config & CFG_STATIC_ESSID) &&
8503 !(priv->status & (STATUS_ASSOCIATED |
8504 STATUS_ASSOCIATING))) {
8505 IPW_DEBUG_ASSOC("Attempting to associate with new "
8507 priv->config &= ~CFG_STATIC_ESSID;
8508 ipw_associate(priv);
8514 length = min(length, IW_ESSID_MAX_SIZE);
8516 priv->config |= CFG_STATIC_ESSID;
8518 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8519 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8524 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8527 priv->essid_len = length;
8528 memcpy(priv->essid, essid, priv->essid_len);
8530 /* Network configuration changed -- force [re]association */
8531 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8532 if (!ipw_disassociate(priv))
8533 ipw_associate(priv);
8539 static int ipw_wx_get_essid(struct net_device *dev,
8540 struct iw_request_info *info,
8541 union iwreq_data *wrqu, char *extra)
8543 struct ipw_priv *priv = ieee80211_priv(dev);
8545 /* If we are associated, trying to associate, or have a statically
8546 * configured ESSID then return that; otherwise return ANY */
8548 if (priv->config & CFG_STATIC_ESSID ||
8549 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8550 IPW_DEBUG_WX("Getting essid: '%s'\n",
8551 escape_essid(priv->essid, priv->essid_len));
8552 memcpy(extra, priv->essid, priv->essid_len);
8553 wrqu->essid.length = priv->essid_len;
8554 wrqu->essid.flags = 1; /* active */
8556 IPW_DEBUG_WX("Getting essid: ANY\n");
8557 wrqu->essid.length = 0;
8558 wrqu->essid.flags = 0; /* active */
8564 static int ipw_wx_set_nick(struct net_device *dev,
8565 struct iw_request_info *info,
8566 union iwreq_data *wrqu, char *extra)
8568 struct ipw_priv *priv = ieee80211_priv(dev);
8570 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8571 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8574 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
8575 memset(priv->nick, 0, sizeof(priv->nick));
8576 memcpy(priv->nick, extra, wrqu->data.length);
8577 IPW_DEBUG_TRACE("<<\n");
8583 static int ipw_wx_get_nick(struct net_device *dev,
8584 struct iw_request_info *info,
8585 union iwreq_data *wrqu, char *extra)
8587 struct ipw_priv *priv = ieee80211_priv(dev);
8588 IPW_DEBUG_WX("Getting nick\n");
8590 wrqu->data.length = strlen(priv->nick) + 1;
8591 memcpy(extra, priv->nick, wrqu->data.length);
8592 wrqu->data.flags = 1; /* active */
8597 static int ipw_wx_set_rate(struct net_device *dev,
8598 struct iw_request_info *info,
8599 union iwreq_data *wrqu, char *extra)
8601 /* TODO: We should use semaphores or locks for access to priv */
8602 struct ipw_priv *priv = ieee80211_priv(dev);
8603 u32 target_rate = wrqu->bitrate.value;
8606 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8607 /* value = X, fixed = 1 means only rate X */
8608 /* value = X, fixed = 0 means all rates lower equal X */
8610 if (target_rate == -1) {
8612 mask = IEEE80211_DEFAULT_RATES_MASK;
8613 /* Now we should reassociate */
8618 fixed = wrqu->bitrate.fixed;
8620 if (target_rate == 1000000 || !fixed)
8621 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8622 if (target_rate == 1000000)
8625 if (target_rate == 2000000 || !fixed)
8626 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8627 if (target_rate == 2000000)
8630 if (target_rate == 5500000 || !fixed)
8631 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8632 if (target_rate == 5500000)
8635 if (target_rate == 6000000 || !fixed)
8636 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8637 if (target_rate == 6000000)
8640 if (target_rate == 9000000 || !fixed)
8641 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8642 if (target_rate == 9000000)
8645 if (target_rate == 11000000 || !fixed)
8646 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8647 if (target_rate == 11000000)
8650 if (target_rate == 12000000 || !fixed)
8651 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8652 if (target_rate == 12000000)
8655 if (target_rate == 18000000 || !fixed)
8656 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8657 if (target_rate == 18000000)
8660 if (target_rate == 24000000 || !fixed)
8661 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8662 if (target_rate == 24000000)
8665 if (target_rate == 36000000 || !fixed)
8666 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8667 if (target_rate == 36000000)
8670 if (target_rate == 48000000 || !fixed)
8671 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8672 if (target_rate == 48000000)
8675 if (target_rate == 54000000 || !fixed)
8676 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8677 if (target_rate == 54000000)
8680 IPW_DEBUG_WX("invalid rate specified, returning error\n");
8684 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8685 mask, fixed ? "fixed" : "sub-rates");
8687 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
8688 priv->config &= ~CFG_FIXED_RATE;
8689 ipw_set_fixed_rate(priv, priv->ieee->mode);
8691 priv->config |= CFG_FIXED_RATE;
8693 if (priv->rates_mask == mask) {
8694 IPW_DEBUG_WX("Mask set to current mask.\n");
8699 priv->rates_mask = mask;
8701 /* Network configuration changed -- force [re]association */
8702 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8703 if (!ipw_disassociate(priv))
8704 ipw_associate(priv);
8710 static int ipw_wx_get_rate(struct net_device *dev,
8711 struct iw_request_info *info,
8712 union iwreq_data *wrqu, char *extra)
8714 struct ipw_priv *priv = ieee80211_priv(dev);
8716 wrqu->bitrate.value = priv->last_rate;
8718 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8722 static int ipw_wx_set_rts(struct net_device *dev,
8723 struct iw_request_info *info,
8724 union iwreq_data *wrqu, char *extra)
8726 struct ipw_priv *priv = ieee80211_priv(dev);
8728 if (wrqu->rts.disabled)
8729 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8731 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
8732 wrqu->rts.value > MAX_RTS_THRESHOLD) {
8736 priv->rts_threshold = wrqu->rts.value;
8739 ipw_send_rts_threshold(priv, priv->rts_threshold);
8741 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8745 static int ipw_wx_get_rts(struct net_device *dev,
8746 struct iw_request_info *info,
8747 union iwreq_data *wrqu, char *extra)
8749 struct ipw_priv *priv = ieee80211_priv(dev);
8751 wrqu->rts.value = priv->rts_threshold;
8752 wrqu->rts.fixed = 0; /* no auto select */
8753 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
8755 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8759 static int ipw_wx_set_txpow(struct net_device *dev,
8760 struct iw_request_info *info,
8761 union iwreq_data *wrqu, char *extra)
8763 struct ipw_priv *priv = ieee80211_priv(dev);
8767 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
8772 if (!wrqu->power.fixed)
8773 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8775 if (wrqu->power.flags != IW_TXPOW_DBM) {
8780 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
8781 (wrqu->power.value < IPW_TX_POWER_MIN)) {
8786 priv->tx_power = wrqu->power.value;
8787 err = ipw_set_tx_power(priv);
8793 static int ipw_wx_get_txpow(struct net_device *dev,
8794 struct iw_request_info *info,
8795 union iwreq_data *wrqu, char *extra)
8797 struct ipw_priv *priv = ieee80211_priv(dev);
8799 wrqu->power.value = priv->tx_power;
8800 wrqu->power.fixed = 1;
8801 wrqu->power.flags = IW_TXPOW_DBM;
8802 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
8805 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
8806 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
8811 static int ipw_wx_set_frag(struct net_device *dev,
8812 struct iw_request_info *info,
8813 union iwreq_data *wrqu, char *extra)
8815 struct ipw_priv *priv = ieee80211_priv(dev);
8817 if (wrqu->frag.disabled)
8818 priv->ieee->fts = DEFAULT_FTS;
8820 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
8821 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8826 priv->ieee->fts = wrqu->frag.value & ~0x1;
8829 ipw_send_frag_threshold(priv, wrqu->frag.value);
8831 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8835 static int ipw_wx_get_frag(struct net_device *dev,
8836 struct iw_request_info *info,
8837 union iwreq_data *wrqu, char *extra)
8839 struct ipw_priv *priv = ieee80211_priv(dev);
8841 wrqu->frag.value = priv->ieee->fts;
8842 wrqu->frag.fixed = 0; /* no auto select */
8843 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
8845 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8850 static int ipw_wx_set_retry(struct net_device *dev,
8851 struct iw_request_info *info,
8852 union iwreq_data *wrqu, char *extra)
8854 struct ipw_priv *priv = ieee80211_priv(dev);
8856 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8859 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8862 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8866 if (wrqu->retry.flags & IW_RETRY_MIN)
8867 priv->short_retry_limit = (u8) wrqu->retry.value;
8868 else if (wrqu->retry.flags & IW_RETRY_MAX)
8869 priv->long_retry_limit = (u8) wrqu->retry.value;
8871 priv->short_retry_limit = (u8) wrqu->retry.value;
8872 priv->long_retry_limit = (u8) wrqu->retry.value;
8875 ipw_send_retry_limit(priv, priv->short_retry_limit,
8876 priv->long_retry_limit);
8878 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8879 priv->short_retry_limit, priv->long_retry_limit);
8883 static int ipw_wx_get_retry(struct net_device *dev,
8884 struct iw_request_info *info,
8885 union iwreq_data *wrqu, char *extra)
8887 struct ipw_priv *priv = ieee80211_priv(dev);
8890 wrqu->retry.disabled = 0;
8892 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
8897 if (wrqu->retry.flags & IW_RETRY_MAX) {
8898 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8899 wrqu->retry.value = priv->long_retry_limit;
8900 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8901 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8902 wrqu->retry.value = priv->short_retry_limit;
8904 wrqu->retry.flags = IW_RETRY_LIMIT;
8905 wrqu->retry.value = priv->short_retry_limit;
8909 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8914 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8917 struct ipw_scan_request_ext scan;
8918 int err = 0, scan_type;
8922 if (priv->status & STATUS_RF_KILL_MASK) {
8923 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8924 priv->status |= STATUS_SCAN_PENDING;
8928 IPW_DEBUG_HC("starting request direct scan!\n");
8930 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
8931 err = wait_event_interruptible(priv->wait_state,
8933 status & (STATUS_SCANNING |
8934 STATUS_SCAN_ABORTING)));
8936 IPW_DEBUG_HC("aborting direct scan");
8940 memset(&scan, 0, sizeof(scan));
8942 if (priv->config & CFG_SPEED_SCAN)
8943 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8946 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8949 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8951 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8952 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8954 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8956 err = ipw_send_ssid(priv, essid, essid_len);
8958 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8961 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8963 ipw_add_scan_channels(priv, &scan, scan_type);
8965 err = ipw_send_scan_request_ext(priv, &scan);
8967 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8971 priv->status |= STATUS_SCANNING;
8978 static int ipw_wx_set_scan(struct net_device *dev,
8979 struct iw_request_info *info,
8980 union iwreq_data *wrqu, char *extra)
8982 struct ipw_priv *priv = ieee80211_priv(dev);
8983 struct iw_scan_req *req = NULL;
8984 if (wrqu->data.length
8985 && wrqu->data.length == sizeof(struct iw_scan_req)) {
8986 req = (struct iw_scan_req *)extra;
8987 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
8988 ipw_request_direct_scan(priv, req->essid,
8994 IPW_DEBUG_WX("Start scan\n");
8996 queue_work(priv->workqueue, &priv->request_scan);
9001 static int ipw_wx_get_scan(struct net_device *dev,
9002 struct iw_request_info *info,
9003 union iwreq_data *wrqu, char *extra)
9005 struct ipw_priv *priv = ieee80211_priv(dev);
9006 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9009 static int ipw_wx_set_encode(struct net_device *dev,
9010 struct iw_request_info *info,
9011 union iwreq_data *wrqu, char *key)
9013 struct ipw_priv *priv = ieee80211_priv(dev);
9015 u32 cap = priv->capability;
9018 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9020 /* In IBSS mode, we need to notify the firmware to update
9021 * the beacon info after we changed the capability. */
9022 if (cap != priv->capability &&
9023 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9024 priv->status & STATUS_ASSOCIATED)
9025 ipw_disassociate(priv);
9031 static int ipw_wx_get_encode(struct net_device *dev,
9032 struct iw_request_info *info,
9033 union iwreq_data *wrqu, char *key)
9035 struct ipw_priv *priv = ieee80211_priv(dev);
9036 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9039 static int ipw_wx_set_power(struct net_device *dev,
9040 struct iw_request_info *info,
9041 union iwreq_data *wrqu, char *extra)
9043 struct ipw_priv *priv = ieee80211_priv(dev);
9046 if (wrqu->power.disabled) {
9047 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9048 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9050 IPW_DEBUG_WX("failed setting power mode.\n");
9054 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9059 switch (wrqu->power.flags & IW_POWER_MODE) {
9060 case IW_POWER_ON: /* If not specified */
9061 case IW_POWER_MODE: /* If set all mask */
9062 case IW_POWER_ALL_R: /* If explicitely state all */
9064 default: /* Otherwise we don't support it */
9065 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9071 /* If the user hasn't specified a power management mode yet, default
9073 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9074 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9076 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9077 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9079 IPW_DEBUG_WX("failed setting power mode.\n");
9084 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9089 static int ipw_wx_get_power(struct net_device *dev,
9090 struct iw_request_info *info,
9091 union iwreq_data *wrqu, char *extra)
9093 struct ipw_priv *priv = ieee80211_priv(dev);
9095 if (!(priv->power_mode & IPW_POWER_ENABLED))
9096 wrqu->power.disabled = 1;
9098 wrqu->power.disabled = 0;
9101 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9106 static int ipw_wx_set_powermode(struct net_device *dev,
9107 struct iw_request_info *info,
9108 union iwreq_data *wrqu, char *extra)
9110 struct ipw_priv *priv = ieee80211_priv(dev);
9111 int mode = *(int *)extra;
9114 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9115 mode = IPW_POWER_AC;
9116 priv->power_mode = mode;
9118 priv->power_mode = IPW_POWER_ENABLED | mode;
9121 if (priv->power_mode != mode) {
9122 err = ipw_send_power_mode(priv, mode);
9125 IPW_DEBUG_WX("failed setting power mode.\n");
9134 #define MAX_WX_STRING 80
9135 static int ipw_wx_get_powermode(struct net_device *dev,
9136 struct iw_request_info *info,
9137 union iwreq_data *wrqu, char *extra)
9139 struct ipw_priv *priv = ieee80211_priv(dev);
9140 int level = IPW_POWER_LEVEL(priv->power_mode);
9143 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9147 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9149 case IPW_POWER_BATTERY:
9150 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9153 p += snprintf(p, MAX_WX_STRING - (p - extra),
9154 "(Timeout %dms, Period %dms)",
9155 timeout_duration[level - 1] / 1000,
9156 period_duration[level - 1] / 1000);
9159 if (!(priv->power_mode & IPW_POWER_ENABLED))
9160 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9162 wrqu->data.length = p - extra + 1;
9167 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9168 struct iw_request_info *info,
9169 union iwreq_data *wrqu, char *extra)
9171 struct ipw_priv *priv = ieee80211_priv(dev);
9172 int mode = *(int *)extra;
9173 u8 band = 0, modulation = 0;
9175 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9176 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9180 if (priv->adapter == IPW_2915ABG) {
9181 priv->ieee->abg_true = 1;
9182 if (mode & IEEE_A) {
9183 band |= IEEE80211_52GHZ_BAND;
9184 modulation |= IEEE80211_OFDM_MODULATION;
9186 priv->ieee->abg_true = 0;
9188 if (mode & IEEE_A) {
9189 IPW_WARNING("Attempt to set 2200BG into "
9195 priv->ieee->abg_true = 0;
9198 if (mode & IEEE_B) {
9199 band |= IEEE80211_24GHZ_BAND;
9200 modulation |= IEEE80211_CCK_MODULATION;
9202 priv->ieee->abg_true = 0;
9204 if (mode & IEEE_G) {
9205 band |= IEEE80211_24GHZ_BAND;
9206 modulation |= IEEE80211_OFDM_MODULATION;
9208 priv->ieee->abg_true = 0;
9210 priv->ieee->mode = mode;
9211 priv->ieee->freq_band = band;
9212 priv->ieee->modulation = modulation;
9213 init_supported_rates(priv, &priv->rates);
9215 /* Network configuration changed -- force [re]association */
9216 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9217 if (!ipw_disassociate(priv)) {
9218 ipw_send_supported_rates(priv, &priv->rates);
9219 ipw_associate(priv);
9222 /* Update the band LEDs */
9223 ipw_led_band_on(priv);
9225 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9226 mode & IEEE_A ? 'a' : '.',
9227 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9232 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9233 struct iw_request_info *info,
9234 union iwreq_data *wrqu, char *extra)
9236 struct ipw_priv *priv = ieee80211_priv(dev);
9238 switch (priv->ieee->mode) {
9240 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9243 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9245 case IEEE_A | IEEE_B:
9246 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9249 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9251 case IEEE_A | IEEE_G:
9252 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9254 case IEEE_B | IEEE_G:
9255 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9257 case IEEE_A | IEEE_B | IEEE_G:
9258 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9261 strncpy(extra, "unknown", MAX_WX_STRING);
9265 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9267 wrqu->data.length = strlen(extra) + 1;
9273 static int ipw_wx_set_preamble(struct net_device *dev,
9274 struct iw_request_info *info,
9275 union iwreq_data *wrqu, char *extra)
9277 struct ipw_priv *priv = ieee80211_priv(dev);
9278 int mode = *(int *)extra;
9280 /* Switching from SHORT -> LONG requires a disassociation */
9282 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9283 priv->config |= CFG_PREAMBLE_LONG;
9285 /* Network configuration changed -- force [re]association */
9287 ("[re]association triggered due to preamble change.\n");
9288 if (!ipw_disassociate(priv))
9289 ipw_associate(priv);
9295 priv->config &= ~CFG_PREAMBLE_LONG;
9306 static int ipw_wx_get_preamble(struct net_device *dev,
9307 struct iw_request_info *info,
9308 union iwreq_data *wrqu, char *extra)
9310 struct ipw_priv *priv = ieee80211_priv(dev);
9312 if (priv->config & CFG_PREAMBLE_LONG)
9313 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9315 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9320 #ifdef CONFIG_IPW2200_MONITOR
9321 static int ipw_wx_set_monitor(struct net_device *dev,
9322 struct iw_request_info *info,
9323 union iwreq_data *wrqu, char *extra)
9325 struct ipw_priv *priv = ieee80211_priv(dev);
9326 int *parms = (int *)extra;
9327 int enable = (parms[0] > 0);
9329 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9331 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9332 #ifdef CONFIG_IEEE80211_RADIOTAP
9333 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9335 priv->net_dev->type = ARPHRD_IEEE80211;
9337 queue_work(priv->workqueue, &priv->adapter_restart);
9340 ipw_set_channel(priv, parms[1]);
9342 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9346 priv->net_dev->type = ARPHRD_ETHER;
9347 queue_work(priv->workqueue, &priv->adapter_restart);
9353 #endif // CONFIG_IPW2200_MONITOR
9355 static int ipw_wx_reset(struct net_device *dev,
9356 struct iw_request_info *info,
9357 union iwreq_data *wrqu, char *extra)
9359 struct ipw_priv *priv = ieee80211_priv(dev);
9360 IPW_DEBUG_WX("RESET\n");
9361 queue_work(priv->workqueue, &priv->adapter_restart);
9365 static int ipw_wx_sw_reset(struct net_device *dev,
9366 struct iw_request_info *info,
9367 union iwreq_data *wrqu, char *extra)
9369 struct ipw_priv *priv = ieee80211_priv(dev);
9370 union iwreq_data wrqu_sec = {
9372 .flags = IW_ENCODE_DISABLED,
9377 IPW_DEBUG_WX("SW_RESET\n");
9381 ret = ipw_sw_reset(priv, 0);
9384 ipw_adapter_restart(priv);
9387 /* The SW reset bit might have been toggled on by the 'disable'
9388 * module parameter, so take appropriate action */
9389 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9392 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9395 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9396 /* Configuration likely changed -- force [re]association */
9397 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9399 if (!ipw_disassociate(priv))
9400 ipw_associate(priv);
9408 /* Rebase the WE IOCTLs to zero for the handler array */
9409 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9410 static iw_handler ipw_wx_handlers[] = {
9411 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9412 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9413 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9414 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9415 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9416 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9417 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9418 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9419 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9420 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9421 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9422 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9423 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9424 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9425 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9426 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9427 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9428 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9429 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9430 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9431 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9432 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9433 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9434 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9435 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9436 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9437 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9438 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9439 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9440 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9441 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9442 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9443 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9444 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9445 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9446 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9447 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9448 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9449 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9453 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9457 IPW_PRIV_SET_PREAMBLE,
9458 IPW_PRIV_GET_PREAMBLE,
9461 #ifdef CONFIG_IPW2200_MONITOR
9462 IPW_PRIV_SET_MONITOR,
9466 static struct iw_priv_args ipw_priv_args[] = {
9468 .cmd = IPW_PRIV_SET_POWER,
9469 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9470 .name = "set_power"},
9472 .cmd = IPW_PRIV_GET_POWER,
9473 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9474 .name = "get_power"},
9476 .cmd = IPW_PRIV_SET_MODE,
9477 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9478 .name = "set_mode"},
9480 .cmd = IPW_PRIV_GET_MODE,
9481 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9482 .name = "get_mode"},
9484 .cmd = IPW_PRIV_SET_PREAMBLE,
9485 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9486 .name = "set_preamble"},
9488 .cmd = IPW_PRIV_GET_PREAMBLE,
9489 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9490 .name = "get_preamble"},
9493 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9496 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9497 #ifdef CONFIG_IPW2200_MONITOR
9499 IPW_PRIV_SET_MONITOR,
9500 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9501 #endif /* CONFIG_IPW2200_MONITOR */
9504 static iw_handler ipw_priv_handler[] = {
9505 ipw_wx_set_powermode,
9506 ipw_wx_get_powermode,
9507 ipw_wx_set_wireless_mode,
9508 ipw_wx_get_wireless_mode,
9509 ipw_wx_set_preamble,
9510 ipw_wx_get_preamble,
9513 #ifdef CONFIG_IPW2200_MONITOR
9518 static struct iw_handler_def ipw_wx_handler_def = {
9519 .standard = ipw_wx_handlers,
9520 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9521 .num_private = ARRAY_SIZE(ipw_priv_handler),
9522 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9523 .private = ipw_priv_handler,
9524 .private_args = ipw_priv_args,
9525 .get_wireless_stats = ipw_get_wireless_stats,
9529 * Get wireless statistics.
9530 * Called by /proc/net/wireless
9531 * Also called by SIOCGIWSTATS
9533 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9535 struct ipw_priv *priv = ieee80211_priv(dev);
9536 struct iw_statistics *wstats;
9538 wstats = &priv->wstats;
9540 /* if hw is disabled, then ipw_get_ordinal() can't be called.
9541 * netdev->get_wireless_stats seems to be called before fw is
9542 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9543 * and associated; if not associcated, the values are all meaningless
9544 * anyway, so set them all to NULL and INVALID */
9545 if (!(priv->status & STATUS_ASSOCIATED)) {
9546 wstats->miss.beacon = 0;
9547 wstats->discard.retries = 0;
9548 wstats->qual.qual = 0;
9549 wstats->qual.level = 0;
9550 wstats->qual.noise = 0;
9551 wstats->qual.updated = 7;
9552 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9553 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9557 wstats->qual.qual = priv->quality;
9558 wstats->qual.level = average_value(&priv->average_rssi);
9559 wstats->qual.noise = average_value(&priv->average_noise);
9560 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9561 IW_QUAL_NOISE_UPDATED;
9563 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9564 wstats->discard.retries = priv->last_tx_failures;
9565 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9567 /* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9568 goto fail_get_ordinal;
9569 wstats->discard.retries += tx_retry; */
9574 /* net device stuff */
9576 static inline void init_sys_config(struct ipw_sys_config *sys_config)
9578 memset(sys_config, 0, sizeof(struct ipw_sys_config));
9579 sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
9580 sys_config->answer_broadcast_ssid_probe = 0;
9581 sys_config->accept_all_data_frames = 0;
9582 sys_config->accept_non_directed_frames = 1;
9583 sys_config->exclude_unicast_unencrypted = 0;
9584 sys_config->disable_unicast_decryption = 1;
9585 sys_config->exclude_multicast_unencrypted = 0;
9586 sys_config->disable_multicast_decryption = 1;
9587 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
9588 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
9589 sys_config->dot11g_auto_detection = 0;
9590 sys_config->enable_cts_to_self = 0;
9591 sys_config->bt_coexist_collision_thr = 0;
9592 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
9595 static int ipw_net_open(struct net_device *dev)
9597 struct ipw_priv *priv = ieee80211_priv(dev);
9598 IPW_DEBUG_INFO("dev->open\n");
9599 /* we should be verifying the device is ready to be opened */
9601 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9602 (priv->status & STATUS_ASSOCIATED))
9603 netif_start_queue(dev);
9608 static int ipw_net_stop(struct net_device *dev)
9610 IPW_DEBUG_INFO("dev->close\n");
9611 netif_stop_queue(dev);
9618 modify to send one tfd per fragment instead of using chunking. otherwise
9619 we need to heavily modify the ieee80211_skb_to_txb.
9622 static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9625 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9626 txb->fragments[0]->data;
9628 struct tfd_frame *tfd;
9629 #ifdef CONFIG_IPW_QOS
9630 int tx_id = ipw_get_tx_queue_number(priv, pri);
9631 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9633 struct clx2_tx_queue *txq = &priv->txq[0];
9635 struct clx2_queue *q = &txq->q;
9636 u8 id, hdr_len, unicast;
9637 u16 remaining_bytes;
9640 /* If there isn't room in the queue, we return busy and let the
9641 * network stack requeue the packet for us */
9642 if (ipw_queue_space(q) < q->high_mark)
9643 return NETDEV_TX_BUSY;
9645 switch (priv->ieee->iw_mode) {
9647 hdr_len = IEEE80211_3ADDR_LEN;
9648 unicast = !is_multicast_ether_addr(hdr->addr1);
9649 id = ipw_find_station(priv, hdr->addr1);
9650 if (id == IPW_INVALID_STATION) {
9651 id = ipw_add_station(priv, hdr->addr1);
9652 if (id == IPW_INVALID_STATION) {
9653 IPW_WARNING("Attempt to send data to "
9654 "invalid cell: " MAC_FMT "\n",
9655 MAC_ARG(hdr->addr1));
9663 unicast = !is_multicast_ether_addr(hdr->addr3);
9664 hdr_len = IEEE80211_3ADDR_LEN;
9669 tfd = &txq->bd[q->first_empty];
9670 txq->txb[q->first_empty] = txb;
9671 memset(tfd, 0, sizeof(*tfd));
9672 tfd->u.data.station_number = id;
9674 tfd->control_flags.message_type = TX_FRAME_TYPE;
9675 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9677 tfd->u.data.cmd_id = DINO_CMD_TX;
9678 tfd->u.data.len = cpu_to_le16(txb->payload_size);
9679 remaining_bytes = txb->payload_size;
9681 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9682 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9684 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9686 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9687 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9689 fc = le16_to_cpu(hdr->frame_ctl);
9690 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9692 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9694 if (likely(unicast))
9695 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9697 if (txb->encrypted && !priv->ieee->host_encrypt) {
9698 switch (priv->ieee->sec.level) {
9700 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9701 IEEE80211_FCTL_PROTECTED;
9702 /* XXX: ACK flag must be set for CCMP even if it
9703 * is a multicast/broadcast packet, because CCMP
9704 * group communication encrypted by GTK is
9705 * actually done by the AP. */
9707 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9709 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9710 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9711 tfd->u.data.key_index = 0;
9712 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9715 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9716 IEEE80211_FCTL_PROTECTED;
9717 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9718 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9719 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9722 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9723 IEEE80211_FCTL_PROTECTED;
9724 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9725 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9727 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9729 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9734 printk(KERN_ERR "Unknow security level %d\n",
9735 priv->ieee->sec.level);
9739 /* No hardware encryption */
9740 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9742 #ifdef CONFIG_IPW_QOS
9743 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9744 #endif /* CONFIG_IPW_QOS */
9747 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9749 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9750 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9751 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9752 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9753 i, le32_to_cpu(tfd->u.data.num_chunks),
9754 txb->fragments[i]->len - hdr_len);
9755 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9756 i, tfd->u.data.num_chunks,
9757 txb->fragments[i]->len - hdr_len);
9758 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9759 txb->fragments[i]->len - hdr_len);
9761 tfd->u.data.chunk_ptr[i] =
9762 cpu_to_le32(pci_map_single
9764 txb->fragments[i]->data + hdr_len,
9765 txb->fragments[i]->len - hdr_len,
9767 tfd->u.data.chunk_len[i] =
9768 cpu_to_le16(txb->fragments[i]->len - hdr_len);
9771 if (i != txb->nr_frags) {
9772 struct sk_buff *skb;
9773 u16 remaining_bytes = 0;
9776 for (j = i; j < txb->nr_frags; j++)
9777 remaining_bytes += txb->fragments[j]->len - hdr_len;
9779 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9781 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9783 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9784 for (j = i; j < txb->nr_frags; j++) {
9785 int size = txb->fragments[j]->len - hdr_len;
9787 printk(KERN_INFO "Adding frag %d %d...\n",
9789 memcpy(skb_put(skb, size),
9790 txb->fragments[j]->data + hdr_len, size);
9792 dev_kfree_skb_any(txb->fragments[i]);
9793 txb->fragments[i] = skb;
9794 tfd->u.data.chunk_ptr[i] =
9795 cpu_to_le32(pci_map_single
9796 (priv->pci_dev, skb->data,
9797 tfd->u.data.chunk_len[i],
9800 tfd->u.data.num_chunks =
9801 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9807 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9808 ipw_write32(priv, q->reg_w, q->first_empty);
9810 return NETDEV_TX_OK;
9813 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9814 ieee80211_txb_free(txb);
9815 return NETDEV_TX_OK;
9818 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9820 struct ipw_priv *priv = ieee80211_priv(dev);
9821 #ifdef CONFIG_IPW_QOS
9822 int tx_id = ipw_get_tx_queue_number(priv, pri);
9823 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9825 struct clx2_tx_queue *txq = &priv->txq[0];
9826 #endif /* CONFIG_IPW_QOS */
9828 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9834 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9835 struct net_device *dev, int pri)
9837 struct ipw_priv *priv = ieee80211_priv(dev);
9838 unsigned long flags;
9841 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9842 spin_lock_irqsave(&priv->lock, flags);
9844 if (!(priv->status & STATUS_ASSOCIATED)) {
9845 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9846 priv->ieee->stats.tx_carrier_errors++;
9847 netif_stop_queue(dev);
9851 ret = ipw_tx_skb(priv, txb, pri);
9852 if (ret == NETDEV_TX_OK)
9853 __ipw_led_activity_on(priv);
9854 spin_unlock_irqrestore(&priv->lock, flags);
9859 spin_unlock_irqrestore(&priv->lock, flags);
9863 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9865 struct ipw_priv *priv = ieee80211_priv(dev);
9867 priv->ieee->stats.tx_packets = priv->tx_packets;
9868 priv->ieee->stats.rx_packets = priv->rx_packets;
9869 return &priv->ieee->stats;
9872 static void ipw_net_set_multicast_list(struct net_device *dev)
9877 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9879 struct ipw_priv *priv = ieee80211_priv(dev);
9880 struct sockaddr *addr = p;
9881 if (!is_valid_ether_addr(addr->sa_data))
9882 return -EADDRNOTAVAIL;
9884 priv->config |= CFG_CUSTOM_MAC;
9885 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9886 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9887 priv->net_dev->name, MAC_ARG(priv->mac_addr));
9888 queue_work(priv->workqueue, &priv->adapter_restart);
9893 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9894 struct ethtool_drvinfo *info)
9896 struct ipw_priv *p = ieee80211_priv(dev);
9901 strcpy(info->driver, DRV_NAME);
9902 strcpy(info->version, DRV_VERSION);
9905 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9907 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9909 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9911 strcpy(info->bus_info, pci_name(p->pci_dev));
9912 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9915 static u32 ipw_ethtool_get_link(struct net_device *dev)
9917 struct ipw_priv *priv = ieee80211_priv(dev);
9918 return (priv->status & STATUS_ASSOCIATED) != 0;
9921 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9923 return IPW_EEPROM_IMAGE_SIZE;
9926 static int ipw_ethtool_get_eeprom(struct net_device *dev,
9927 struct ethtool_eeprom *eeprom, u8 * bytes)
9929 struct ipw_priv *p = ieee80211_priv(dev);
9931 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9934 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9939 static int ipw_ethtool_set_eeprom(struct net_device *dev,
9940 struct ethtool_eeprom *eeprom, u8 * bytes)
9942 struct ipw_priv *p = ieee80211_priv(dev);
9945 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9948 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
9949 for (i = IPW_EEPROM_DATA;
9950 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
9951 ipw_write8(p, i, p->eeprom[i]);
9956 static struct ethtool_ops ipw_ethtool_ops = {
9957 .get_link = ipw_ethtool_get_link,
9958 .get_drvinfo = ipw_ethtool_get_drvinfo,
9959 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9960 .get_eeprom = ipw_ethtool_get_eeprom,
9961 .set_eeprom = ipw_ethtool_set_eeprom,
9964 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9966 struct ipw_priv *priv = data;
9967 u32 inta, inta_mask;
9972 spin_lock(&priv->lock);
9974 if (!(priv->status & STATUS_INT_ENABLED)) {
9979 inta = ipw_read32(priv, IPW_INTA_RW);
9980 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
9982 if (inta == 0xFFFFFFFF) {
9983 /* Hardware disappeared */
9984 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
9988 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
9989 /* Shared interrupt */
9993 /* tell the device to stop sending interrupts */
9994 ipw_disable_interrupts(priv);
9996 /* ack current interrupts */
9997 inta &= (IPW_INTA_MASK_ALL & inta_mask);
9998 ipw_write32(priv, IPW_INTA_RW, inta);
10000 /* Cache INTA value for our tasklet */
10001 priv->isr_inta = inta;
10003 tasklet_schedule(&priv->irq_tasklet);
10005 spin_unlock(&priv->lock);
10007 return IRQ_HANDLED;
10009 spin_unlock(&priv->lock);
10013 static void ipw_rf_kill(void *adapter)
10015 struct ipw_priv *priv = adapter;
10016 unsigned long flags;
10018 spin_lock_irqsave(&priv->lock, flags);
10020 if (rf_kill_active(priv)) {
10021 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10022 if (priv->workqueue)
10023 queue_delayed_work(priv->workqueue,
10024 &priv->rf_kill, 2 * HZ);
10028 /* RF Kill is now disabled, so bring the device back up */
10030 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10031 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10034 /* we can not do an adapter restart while inside an irq lock */
10035 queue_work(priv->workqueue, &priv->adapter_restart);
10037 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10041 spin_unlock_irqrestore(&priv->lock, flags);
10044 static void ipw_bg_rf_kill(void *data)
10046 struct ipw_priv *priv = data;
10052 void ipw_link_up(struct ipw_priv *priv)
10054 priv->last_seq_num = -1;
10055 priv->last_frag_num = -1;
10056 priv->last_packet_time = 0;
10058 netif_carrier_on(priv->net_dev);
10059 if (netif_queue_stopped(priv->net_dev)) {
10060 IPW_DEBUG_NOTIF("waking queue\n");
10061 netif_wake_queue(priv->net_dev);
10063 IPW_DEBUG_NOTIF("starting queue\n");
10064 netif_start_queue(priv->net_dev);
10067 cancel_delayed_work(&priv->request_scan);
10068 ipw_reset_stats(priv);
10069 /* Ensure the rate is updated immediately */
10070 priv->last_rate = ipw_get_current_rate(priv);
10071 ipw_gather_stats(priv);
10072 ipw_led_link_up(priv);
10073 notify_wx_assoc_event(priv);
10075 if (priv->config & CFG_BACKGROUND_SCAN)
10076 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10079 static void ipw_bg_link_up(void *data)
10081 struct ipw_priv *priv = data;
10087 void ipw_link_down(struct ipw_priv *priv)
10089 ipw_led_link_down(priv);
10090 netif_carrier_off(priv->net_dev);
10091 netif_stop_queue(priv->net_dev);
10092 notify_wx_assoc_event(priv);
10094 /* Cancel any queued work ... */
10095 cancel_delayed_work(&priv->request_scan);
10096 cancel_delayed_work(&priv->adhoc_check);
10097 cancel_delayed_work(&priv->gather_stats);
10099 ipw_reset_stats(priv);
10101 if (!(priv->status & STATUS_EXIT_PENDING)) {
10102 /* Queue up another scan... */
10103 queue_work(priv->workqueue, &priv->request_scan);
10107 static void ipw_bg_link_down(void *data)
10109 struct ipw_priv *priv = data;
10111 ipw_link_down(data);
10115 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10119 priv->workqueue = create_workqueue(DRV_NAME);
10120 init_waitqueue_head(&priv->wait_command_queue);
10121 init_waitqueue_head(&priv->wait_state);
10123 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10124 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10125 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10126 INIT_WORK(&priv->system_config, ipw_system_config, priv);
10127 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10128 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10129 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10130 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10131 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10132 INIT_WORK(&priv->request_scan,
10133 (void (*)(void *))ipw_request_scan, priv);
10134 INIT_WORK(&priv->gather_stats,
10135 (void (*)(void *))ipw_bg_gather_stats, priv);
10136 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10137 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10138 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10139 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10140 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10141 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10143 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10145 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10147 INIT_WORK(&priv->merge_networks,
10148 (void (*)(void *))ipw_merge_adhoc_network, priv);
10150 #ifdef CONFIG_IPW_QOS
10151 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10153 #endif /* CONFIG_IPW_QOS */
10155 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10156 ipw_irq_tasklet, (unsigned long)priv);
10161 static void shim__set_security(struct net_device *dev,
10162 struct ieee80211_security *sec)
10164 struct ipw_priv *priv = ieee80211_priv(dev);
10166 for (i = 0; i < 4; i++) {
10167 if (sec->flags & (1 << i)) {
10168 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10169 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10170 if (sec->key_sizes[i] == 0)
10171 priv->ieee->sec.flags &= ~(1 << i);
10173 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10174 sec->key_sizes[i]);
10175 priv->ieee->sec.flags |= (1 << i);
10177 priv->status |= STATUS_SECURITY_UPDATED;
10178 } else if (sec->level != SEC_LEVEL_1)
10179 priv->ieee->sec.flags &= ~(1 << i);
10182 if (sec->flags & SEC_ACTIVE_KEY) {
10183 if (sec->active_key <= 3) {
10184 priv->ieee->sec.active_key = sec->active_key;
10185 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10187 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10188 priv->status |= STATUS_SECURITY_UPDATED;
10190 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10192 if ((sec->flags & SEC_AUTH_MODE) &&
10193 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10194 priv->ieee->sec.auth_mode = sec->auth_mode;
10195 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10196 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10197 priv->capability |= CAP_SHARED_KEY;
10199 priv->capability &= ~CAP_SHARED_KEY;
10200 priv->status |= STATUS_SECURITY_UPDATED;
10203 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10204 priv->ieee->sec.flags |= SEC_ENABLED;
10205 priv->ieee->sec.enabled = sec->enabled;
10206 priv->status |= STATUS_SECURITY_UPDATED;
10208 priv->capability |= CAP_PRIVACY_ON;
10210 priv->capability &= ~CAP_PRIVACY_ON;
10213 if (sec->flags & SEC_ENCRYPT)
10214 priv->ieee->sec.encrypt = sec->encrypt;
10216 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10217 priv->ieee->sec.level = sec->level;
10218 priv->ieee->sec.flags |= SEC_LEVEL;
10219 priv->status |= STATUS_SECURITY_UPDATED;
10222 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10223 ipw_set_hwcrypto_keys(priv);
10225 /* To match current functionality of ipw2100 (which works well w/
10226 * various supplicants, we don't force a disassociate if the
10227 * privacy capability changes ... */
10229 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10230 (((priv->assoc_request.capability &
10231 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10232 (!(priv->assoc_request.capability &
10233 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10234 IPW_DEBUG_ASSOC("Disassociating due to capability "
10236 ipw_disassociate(priv);
10241 static int init_supported_rates(struct ipw_priv *priv,
10242 struct ipw_supported_rates *rates)
10244 /* TODO: Mask out rates based on priv->rates_mask */
10246 memset(rates, 0, sizeof(*rates));
10247 /* configure supported rates */
10248 switch (priv->ieee->freq_band) {
10249 case IEEE80211_52GHZ_BAND:
10250 rates->ieee_mode = IPW_A_MODE;
10251 rates->purpose = IPW_RATE_CAPABILITIES;
10252 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10253 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10256 default: /* Mixed or 2.4Ghz */
10257 rates->ieee_mode = IPW_G_MODE;
10258 rates->purpose = IPW_RATE_CAPABILITIES;
10259 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10260 IEEE80211_CCK_DEFAULT_RATES_MASK);
10261 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10262 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10263 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10271 static int ipw_config(struct ipw_priv *priv)
10273 /* This is only called from ipw_up, which resets/reloads the firmware
10274 so, we don't need to first disable the card before we configure
10276 if (ipw_set_tx_power(priv))
10279 /* initialize adapter address */
10280 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10283 /* set basic system config settings */
10284 init_sys_config(&priv->sys_config);
10285 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10286 priv->sys_config.answer_broadcast_ssid_probe = 1;
10288 priv->sys_config.answer_broadcast_ssid_probe = 0;
10290 if (ipw_send_system_config(priv, &priv->sys_config))
10293 init_supported_rates(priv, &priv->rates);
10294 if (ipw_send_supported_rates(priv, &priv->rates))
10297 /* Set request-to-send threshold */
10298 if (priv->rts_threshold) {
10299 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10302 #ifdef CONFIG_IPW_QOS
10303 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10304 ipw_qos_activate(priv, NULL);
10305 #endif /* CONFIG_IPW_QOS */
10307 if (ipw_set_random_seed(priv))
10310 /* final state transition to the RUN state */
10311 if (ipw_send_host_complete(priv))
10314 priv->status |= STATUS_INIT;
10316 ipw_led_init(priv);
10317 ipw_led_radio_on(priv);
10318 priv->notif_missed_beacons = 0;
10320 /* Set hardware WEP key if it is configured. */
10321 if ((priv->capability & CAP_PRIVACY_ON) &&
10322 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10323 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10324 ipw_set_hwcrypto_keys(priv);
10335 * These tables have been tested in conjunction with the
10336 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10338 * Altering this values, using it on other hardware, or in geographies
10339 * not intended for resale of the above mentioned Intel adapters has
10343 static const struct ieee80211_geo ipw_geos[] = {
10347 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10348 {2427, 4}, {2432, 5}, {2437, 6},
10349 {2442, 7}, {2447, 8}, {2452, 9},
10350 {2457, 10}, {2462, 11}},
10353 { /* Custom US/Canada */
10356 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10357 {2427, 4}, {2432, 5}, {2437, 6},
10358 {2442, 7}, {2447, 8}, {2452, 9},
10359 {2457, 10}, {2462, 11}},
10365 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10366 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10367 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10368 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10371 { /* Rest of World */
10374 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10375 {2427, 4}, {2432, 5}, {2437, 6},
10376 {2442, 7}, {2447, 8}, {2452, 9},
10377 {2457, 10}, {2462, 11}, {2467, 12},
10381 { /* Custom USA & Europe & High */
10384 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10385 {2427, 4}, {2432, 5}, {2437, 6},
10386 {2442, 7}, {2447, 8}, {2452, 9},
10387 {2457, 10}, {2462, 11}},
10393 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10394 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10395 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10396 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10404 { /* Custom NA & Europe */
10407 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10408 {2427, 4}, {2432, 5}, {2437, 6},
10409 {2442, 7}, {2447, 8}, {2452, 9},
10410 {2457, 10}, {2462, 11}},
10416 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10417 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10418 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10419 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10420 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10421 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10422 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10423 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10424 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10427 { /* Custom Japan */
10430 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10431 {2427, 4}, {2432, 5}, {2437, 6},
10432 {2442, 7}, {2447, 8}, {2452, 9},
10433 {2457, 10}, {2462, 11}},
10435 .a = {{5170, 34}, {5190, 38},
10436 {5210, 42}, {5230, 46}},
10442 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10443 {2427, 4}, {2432, 5}, {2437, 6},
10444 {2442, 7}, {2447, 8}, {2452, 9},
10445 {2457, 10}, {2462, 11}},
10451 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10452 {2427, 4}, {2432, 5}, {2437, 6},
10453 {2442, 7}, {2447, 8}, {2452, 9},
10454 {2457, 10}, {2462, 11}, {2467, 12},
10461 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10462 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10463 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10464 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10465 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10466 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10467 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10468 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10469 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10470 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10471 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10472 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10473 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10474 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10475 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10478 { /* Custom Japan */
10481 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10482 {2427, 4}, {2432, 5}, {2437, 6},
10483 {2442, 7}, {2447, 8}, {2452, 9},
10484 {2457, 10}, {2462, 11}, {2467, 12},
10485 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10487 .a = {{5170, 34}, {5190, 38},
10488 {5210, 42}, {5230, 46}},
10494 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10495 {2427, 4}, {2432, 5}, {2437, 6},
10496 {2442, 7}, {2447, 8}, {2452, 9},
10497 {2457, 10}, {2462, 11},
10498 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10499 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10501 .a = {{5745, 149}, {5765, 153},
10502 {5785, 157}, {5805, 161}},
10505 { /* Custom Europe */
10508 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10509 {2427, 4}, {2432, 5}, {2437, 6},
10510 {2442, 7}, {2447, 8}, {2452, 9},
10511 {2457, 10}, {2462, 11},
10512 {2467, 12}, {2472, 13}},
10514 .a = {{5180, 36}, {5200, 40},
10515 {5220, 44}, {5240, 48}},
10521 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10522 {2427, 4}, {2432, 5}, {2437, 6},
10523 {2442, 7}, {2447, 8}, {2452, 9},
10524 {2457, 10}, {2462, 11},
10525 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10526 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10528 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10529 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10530 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10531 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10532 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10533 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10534 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10535 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10536 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10537 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10538 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10539 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10540 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10541 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10542 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10543 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10544 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10545 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10546 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10547 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10548 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10549 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10550 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10551 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10557 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10558 {2427, 4}, {2432, 5}, {2437, 6},
10559 {2442, 7}, {2447, 8}, {2452, 9},
10560 {2457, 10}, {2462, 11}},
10562 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10563 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10564 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10565 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10566 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10567 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10568 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10569 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10570 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10571 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10572 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10573 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10574 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10578 /* GEO code borrowed from ieee80211_geo.c */
10579 static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
10583 /* Driver needs to initialize the geography map before using
10584 * these helper functions */
10585 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10587 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10588 for (i = 0; i < ieee->geo.bg_channels; i++)
10589 /* NOTE: If G mode is currently supported but
10590 * this is a B only channel, we don't see it
10592 if ((ieee->geo.bg[i].channel == channel) &&
10593 (!(ieee->mode & IEEE_G) ||
10594 !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
10595 return IEEE80211_24GHZ_BAND;
10597 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10598 for (i = 0; i < ieee->geo.a_channels; i++)
10599 if (ieee->geo.a[i].channel == channel)
10600 return IEEE80211_52GHZ_BAND;
10605 static int ipw_channel_to_index(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 if (ieee->geo.bg[i].channel == channel)
10618 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10619 for (i = 0; i < ieee->geo.a_channels; i++)
10620 if (ieee->geo.a[i].channel == channel)
10626 static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
10630 /* Driver needs to initialize the geography map before using
10631 * these helper functions */
10632 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10636 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10637 for (i = 0; i < ieee->geo.bg_channels; i++)
10638 if (ieee->geo.bg[i].freq == freq)
10639 return ieee->geo.bg[i].channel;
10641 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10642 for (i = 0; i < ieee->geo.a_channels; i++)
10643 if (ieee->geo.a[i].freq == freq)
10644 return ieee->geo.a[i].channel;
10649 static int ipw_set_geo(struct ieee80211_device *ieee,
10650 const struct ieee80211_geo *geo)
10652 memcpy(ieee->geo.name, geo->name, 3);
10653 ieee->geo.name[3] = '\0';
10654 ieee->geo.bg_channels = geo->bg_channels;
10655 ieee->geo.a_channels = geo->a_channels;
10656 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
10657 sizeof(struct ieee80211_channel));
10658 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
10659 sizeof(struct ieee80211_channel));
10663 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
10668 #define MAX_HW_RESTARTS 5
10669 static int ipw_up(struct ipw_priv *priv)
10673 if (priv->status & STATUS_EXIT_PENDING)
10676 if (cmdlog && !priv->cmdlog) {
10677 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10679 if (priv->cmdlog == NULL) {
10680 IPW_ERROR("Error allocating %d command log entries.\n",
10683 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10684 priv->cmdlog_len = cmdlog;
10688 for (i = 0; i < MAX_HW_RESTARTS; i++) {
10689 /* Load the microcode, firmware, and eeprom.
10690 * Also start the clocks. */
10691 rc = ipw_load(priv);
10693 IPW_ERROR("Unable to load firmware: %d\n", rc);
10697 ipw_init_ordinals(priv);
10698 if (!(priv->config & CFG_CUSTOM_MAC))
10699 eeprom_parse_mac(priv, priv->mac_addr);
10700 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10702 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10703 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10704 ipw_geos[j].name, 3))
10707 if (j == ARRAY_SIZE(ipw_geos))
10709 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
10710 IPW_WARNING("Could not set geography.");
10714 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
10715 j, priv->ieee->geo.name);
10717 if (priv->status & STATUS_RF_KILL_SW) {
10718 IPW_WARNING("Radio disabled by module parameter.\n");
10720 } else if (rf_kill_active(priv)) {
10721 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10722 "Kill switch must be turned off for "
10723 "wireless networking to work.\n");
10724 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10729 rc = ipw_config(priv);
10731 IPW_DEBUG_INFO("Configured device on count %i\n", i);
10733 /* If configure to try and auto-associate, kick
10735 queue_work(priv->workqueue, &priv->request_scan);
10740 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10741 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10742 i, MAX_HW_RESTARTS);
10744 /* We had an error bringing up the hardware, so take it
10745 * all the way back down so we can try again */
10749 /* tried to restart and config the device for as long as our
10750 * patience could withstand */
10751 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10756 static void ipw_bg_up(void *data)
10758 struct ipw_priv *priv = data;
10764 static void ipw_deinit(struct ipw_priv *priv)
10768 if (priv->status & STATUS_SCANNING) {
10769 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10770 ipw_abort_scan(priv);
10773 if (priv->status & STATUS_ASSOCIATED) {
10774 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10775 ipw_disassociate(priv);
10778 ipw_led_shutdown(priv);
10780 /* Wait up to 1s for status to change to not scanning and not
10781 * associated (disassociation can take a while for a ful 802.11
10783 for (i = 1000; i && (priv->status &
10784 (STATUS_DISASSOCIATING |
10785 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10788 if (priv->status & (STATUS_DISASSOCIATING |
10789 STATUS_ASSOCIATED | STATUS_SCANNING))
10790 IPW_DEBUG_INFO("Still associated or scanning...\n");
10792 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10794 /* Attempt to disable the card */
10795 ipw_send_card_disable(priv, 0);
10797 priv->status &= ~STATUS_INIT;
10800 static void ipw_down(struct ipw_priv *priv)
10802 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10804 priv->status |= STATUS_EXIT_PENDING;
10806 if (ipw_is_init(priv))
10809 /* Wipe out the EXIT_PENDING status bit if we are not actually
10810 * exiting the module */
10812 priv->status &= ~STATUS_EXIT_PENDING;
10814 /* tell the device to stop sending interrupts */
10815 ipw_disable_interrupts(priv);
10817 /* Clear all bits but the RF Kill */
10818 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10819 netif_carrier_off(priv->net_dev);
10820 netif_stop_queue(priv->net_dev);
10822 ipw_stop_nic(priv);
10824 ipw_led_radio_off(priv);
10827 static void ipw_bg_down(void *data)
10829 struct ipw_priv *priv = data;
10835 /* Called by register_netdev() */
10836 static int ipw_net_init(struct net_device *dev)
10838 struct ipw_priv *priv = ieee80211_priv(dev);
10841 if (ipw_up(priv)) {
10850 /* PCI driver stuff */
10851 static struct pci_device_id card_ids[] = {
10852 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10853 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10854 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10855 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10856 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10857 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10858 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10859 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10860 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10861 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10862 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10863 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10864 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10865 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10866 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10867 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10868 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10869 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10870 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10871 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10872 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10873 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10875 /* required last entry */
10879 MODULE_DEVICE_TABLE(pci, card_ids);
10881 static struct attribute *ipw_sysfs_entries[] = {
10882 &dev_attr_rf_kill.attr,
10883 &dev_attr_direct_dword.attr,
10884 &dev_attr_indirect_byte.attr,
10885 &dev_attr_indirect_dword.attr,
10886 &dev_attr_mem_gpio_reg.attr,
10887 &dev_attr_command_event_reg.attr,
10888 &dev_attr_nic_type.attr,
10889 &dev_attr_status.attr,
10890 &dev_attr_cfg.attr,
10891 &dev_attr_error.attr,
10892 &dev_attr_event_log.attr,
10893 &dev_attr_cmd_log.attr,
10894 &dev_attr_eeprom_delay.attr,
10895 &dev_attr_ucode_version.attr,
10896 &dev_attr_rtc.attr,
10897 &dev_attr_scan_age.attr,
10898 &dev_attr_led.attr,
10899 &dev_attr_speed_scan.attr,
10900 &dev_attr_net_stats.attr,
10904 static struct attribute_group ipw_attribute_group = {
10905 .name = NULL, /* put in device directory */
10906 .attrs = ipw_sysfs_entries,
10909 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
10912 struct net_device *net_dev;
10913 void __iomem *base;
10915 struct ipw_priv *priv;
10918 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10919 if (net_dev == NULL) {
10924 priv = ieee80211_priv(net_dev);
10925 priv->ieee = netdev_priv(net_dev);
10927 priv->net_dev = net_dev;
10928 priv->pci_dev = pdev;
10929 #ifdef CONFIG_IPW_DEBUG
10930 ipw_debug_level = debug;
10932 spin_lock_init(&priv->lock);
10933 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10934 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
10936 init_MUTEX(&priv->sem);
10937 if (pci_enable_device(pdev)) {
10939 goto out_free_ieee80211;
10942 pci_set_master(pdev);
10944 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
10946 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
10948 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10949 goto out_pci_disable_device;
10952 pci_set_drvdata(pdev, priv);
10954 err = pci_request_regions(pdev, DRV_NAME);
10956 goto out_pci_disable_device;
10958 /* We disable the RETRY_TIMEOUT register (0x41) to keep
10959 * PCI Tx retries from interfering with C3 CPU state */
10960 pci_read_config_dword(pdev, 0x40, &val);
10961 if ((val & 0x0000ff00) != 0)
10962 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
10964 length = pci_resource_len(pdev, 0);
10965 priv->hw_len = length;
10967 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10970 goto out_pci_release_regions;
10973 priv->hw_base = base;
10974 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
10975 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
10977 err = ipw_setup_deferred_work(priv);
10979 IPW_ERROR("Unable to setup deferred work\n");
10983 ipw_sw_reset(priv, 1);
10985 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
10987 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
10988 goto out_destroy_workqueue;
10991 SET_MODULE_OWNER(net_dev);
10992 SET_NETDEV_DEV(net_dev, &pdev->dev);
10996 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
10997 priv->ieee->set_security = shim__set_security;
10998 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11000 #ifdef CONFIG_IPW_QOS
11001 priv->ieee->handle_probe_response = ipw_handle_beacon;
11002 priv->ieee->handle_beacon = ipw_handle_probe_response;
11003 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11004 #endif /* CONFIG_IPW_QOS */
11006 priv->ieee->perfect_rssi = -20;
11007 priv->ieee->worst_rssi = -85;
11009 net_dev->open = ipw_net_open;
11010 net_dev->stop = ipw_net_stop;
11011 net_dev->init = ipw_net_init;
11012 net_dev->get_stats = ipw_net_get_stats;
11013 net_dev->set_multicast_list = ipw_net_set_multicast_list;
11014 net_dev->set_mac_address = ipw_net_set_mac_address;
11015 priv->wireless_data.spy_data = &priv->ieee->spy_data;
11016 priv->wireless_data.ieee80211 = priv->ieee;
11017 net_dev->wireless_data = &priv->wireless_data;
11018 net_dev->wireless_handlers = &ipw_wx_handler_def;
11019 net_dev->ethtool_ops = &ipw_ethtool_ops;
11020 net_dev->irq = pdev->irq;
11021 net_dev->base_addr = (unsigned long)priv->hw_base;
11022 net_dev->mem_start = pci_resource_start(pdev, 0);
11023 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11025 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11027 IPW_ERROR("failed to create sysfs device attributes\n");
11029 goto out_release_irq;
11033 err = register_netdev(net_dev);
11035 IPW_ERROR("failed to register network device\n");
11036 goto out_remove_sysfs;
11041 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11043 free_irq(pdev->irq, priv);
11044 out_destroy_workqueue:
11045 destroy_workqueue(priv->workqueue);
11046 priv->workqueue = NULL;
11048 iounmap(priv->hw_base);
11049 out_pci_release_regions:
11050 pci_release_regions(pdev);
11051 out_pci_disable_device:
11052 pci_disable_device(pdev);
11053 pci_set_drvdata(pdev, NULL);
11054 out_free_ieee80211:
11055 free_ieee80211(priv->net_dev);
11060 static void ipw_pci_remove(struct pci_dev *pdev)
11062 struct ipw_priv *priv = pci_get_drvdata(pdev);
11063 struct list_head *p, *q;
11071 priv->status |= STATUS_EXIT_PENDING;
11073 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11077 unregister_netdev(priv->net_dev);
11080 ipw_rx_queue_free(priv, priv->rxq);
11083 ipw_tx_queue_free(priv);
11085 if (priv->cmdlog) {
11086 kfree(priv->cmdlog);
11087 priv->cmdlog = NULL;
11089 /* ipw_down will ensure that there is no more pending work
11090 * in the workqueue's, so we can safely remove them now. */
11091 cancel_delayed_work(&priv->adhoc_check);
11092 cancel_delayed_work(&priv->gather_stats);
11093 cancel_delayed_work(&priv->request_scan);
11094 cancel_delayed_work(&priv->rf_kill);
11095 cancel_delayed_work(&priv->scan_check);
11096 destroy_workqueue(priv->workqueue);
11097 priv->workqueue = NULL;
11099 /* Free MAC hash list for ADHOC */
11100 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11101 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11102 kfree(list_entry(p, struct ipw_ibss_seq, list));
11108 ipw_free_error_log(priv->error);
11109 priv->error = NULL;
11112 free_irq(pdev->irq, priv);
11113 iounmap(priv->hw_base);
11114 pci_release_regions(pdev);
11115 pci_disable_device(pdev);
11116 pci_set_drvdata(pdev, NULL);
11117 free_ieee80211(priv->net_dev);
11122 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11124 struct ipw_priv *priv = pci_get_drvdata(pdev);
11125 struct net_device *dev = priv->net_dev;
11127 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11129 /* Take down the device; powers it off, etc. */
11132 /* Remove the PRESENT state of the device */
11133 netif_device_detach(dev);
11135 pci_save_state(pdev);
11136 pci_disable_device(pdev);
11137 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11142 static int ipw_pci_resume(struct pci_dev *pdev)
11144 struct ipw_priv *priv = pci_get_drvdata(pdev);
11145 struct net_device *dev = priv->net_dev;
11148 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11150 pci_set_power_state(pdev, PCI_D0);
11151 pci_enable_device(pdev);
11152 pci_restore_state(pdev);
11155 * Suspend/Resume resets the PCI configuration space, so we have to
11156 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11157 * from interfering with C3 CPU state. pci_restore_state won't help
11158 * here since it only restores the first 64 bytes pci config header.
11160 pci_read_config_dword(pdev, 0x40, &val);
11161 if ((val & 0x0000ff00) != 0)
11162 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11164 /* Set the device back into the PRESENT state; this will also wake
11165 * the queue of needed */
11166 netif_device_attach(dev);
11168 /* Bring the device back up */
11169 queue_work(priv->workqueue, &priv->up);
11175 /* driver initialization stuff */
11176 static struct pci_driver ipw_driver = {
11178 .id_table = card_ids,
11179 .probe = ipw_pci_probe,
11180 .remove = __devexit_p(ipw_pci_remove),
11182 .suspend = ipw_pci_suspend,
11183 .resume = ipw_pci_resume,
11187 static int __init ipw_init(void)
11191 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11192 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11194 ret = pci_module_init(&ipw_driver);
11196 IPW_ERROR("Unable to initialize PCI module\n");
11200 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11202 IPW_ERROR("Unable to create driver sysfs file\n");
11203 pci_unregister_driver(&ipw_driver);
11210 static void __exit ipw_exit(void)
11212 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11213 pci_unregister_driver(&ipw_driver);
11216 module_param(disable, int, 0444);
11217 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11219 module_param(associate, int, 0444);
11220 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11222 module_param(auto_create, int, 0444);
11223 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11225 module_param(led, int, 0444);
11226 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11228 module_param(debug, int, 0444);
11229 MODULE_PARM_DESC(debug, "debug output mask");
11231 module_param(channel, int, 0444);
11232 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11234 #ifdef CONFIG_IPW_QOS
11235 module_param(qos_enable, int, 0444);
11236 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11238 module_param(qos_burst_enable, int, 0444);
11239 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11241 module_param(qos_no_ack_mask, int, 0444);
11242 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11244 module_param(burst_duration_CCK, int, 0444);
11245 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11247 module_param(burst_duration_OFDM, int, 0444);
11248 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11249 #endif /* CONFIG_IPW_QOS */
11251 #ifdef CONFIG_IPW2200_MONITOR
11252 module_param(mode, int, 0444);
11253 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11255 module_param(mode, int, 0444);
11256 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11259 module_param(hwcrypto, int, 0444);
11260 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11262 module_param(cmdlog, int, 0444);
11263 MODULE_PARM_DESC(cmdlog,
11264 "allocate a ring buffer for logging firmware commands");
11266 module_exit(ipw_exit);
11267 module_init(ipw_init);