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.5"
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 void ipw_remove_current_network(struct ipw_priv *priv);
129 static void ipw_rx(struct ipw_priv *priv);
130 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
131 struct clx2_tx_queue *txq, int qindex);
132 static int ipw_queue_reset(struct ipw_priv *priv);
134 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
137 static void ipw_tx_queue_free(struct ipw_priv *);
139 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
140 static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
141 static void ipw_rx_queue_replenish(void *);
142 static int ipw_up(struct ipw_priv *);
143 static void ipw_bg_up(void *);
144 static void ipw_down(struct ipw_priv *);
145 static void ipw_bg_down(void *);
146 static int ipw_config(struct ipw_priv *);
147 static int init_supported_rates(struct ipw_priv *priv,
148 struct ipw_supported_rates *prates);
149 static void ipw_set_hwcrypto_keys(struct ipw_priv *);
150 static void ipw_send_wep_keys(struct ipw_priv *, int);
152 static int ipw_is_valid_channel(struct ieee80211_device *, u8);
153 static int ipw_channel_to_index(struct ieee80211_device *, u8);
154 static u8 ipw_freq_to_channel(struct ieee80211_device *, u32);
155 static int ipw_set_geo(struct ieee80211_device *, const struct ieee80211_geo *);
156 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *);
158 static int snprint_line(char *buf, size_t count,
159 const u8 * data, u32 len, u32 ofs)
164 out = snprintf(buf, count, "%08X", ofs);
166 for (l = 0, i = 0; i < 2; i++) {
167 out += snprintf(buf + out, count - out, " ");
168 for (j = 0; j < 8 && l < len; j++, l++)
169 out += snprintf(buf + out, count - out, "%02X ",
172 out += snprintf(buf + out, count - out, " ");
175 out += snprintf(buf + out, count - out, " ");
176 for (l = 0, i = 0; i < 2; i++) {
177 out += snprintf(buf + out, count - out, " ");
178 for (j = 0; j < 8 && l < len; j++, l++) {
179 c = data[(i * 8 + j)];
180 if (!isascii(c) || !isprint(c))
183 out += snprintf(buf + out, count - out, "%c", c);
187 out += snprintf(buf + out, count - out, " ");
193 static void printk_buf(int level, const u8 * data, u32 len)
197 if (!(ipw_debug_level & level))
201 snprint_line(line, sizeof(line), &data[ofs],
203 printk(KERN_DEBUG "%s\n", line);
205 len -= min(len, 16U);
209 static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
215 while (size && len) {
216 out = snprint_line(output, size, &data[ofs],
217 min_t(size_t, len, 16U), ofs);
222 len -= min_t(size_t, len, 16U);
228 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
229 #define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
231 static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
232 #define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
234 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
235 static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
237 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
238 __LINE__, (u32) (b), (u32) (c));
239 _ipw_write_reg8(a, b, c);
242 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
243 static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
245 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
246 __LINE__, (u32) (b), (u32) (c));
247 _ipw_write_reg16(a, b, c);
250 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
251 static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
253 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
254 __LINE__, (u32) (b), (u32) (c));
255 _ipw_write_reg32(a, b, c);
258 #define _ipw_write8(ipw, ofs, val) writeb((val), (ipw)->hw_base + (ofs))
259 #define ipw_write8(ipw, ofs, val) \
260 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
261 _ipw_write8(ipw, ofs, val)
263 #define _ipw_write16(ipw, ofs, val) writew((val), (ipw)->hw_base + (ofs))
264 #define ipw_write16(ipw, ofs, val) \
265 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
266 _ipw_write16(ipw, ofs, val)
268 #define _ipw_write32(ipw, ofs, val) writel((val), (ipw)->hw_base + (ofs))
269 #define ipw_write32(ipw, ofs, val) \
270 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
271 _ipw_write32(ipw, ofs, val)
273 #define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
274 static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
276 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
277 return _ipw_read8(ipw, ofs);
280 #define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)
282 #define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
283 static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
285 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
286 return _ipw_read16(ipw, ofs);
289 #define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)
291 #define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
292 static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
294 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
295 return _ipw_read32(ipw, ofs);
298 #define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
300 static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
301 static inline void __ipw_read_indirect(const char *f, int l,
302 struct ipw_priv *a, u32 b, u8 * c, int d)
304 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
306 _ipw_read_indirect(a, b, c, d);
309 #define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
311 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
313 #define ipw_write_indirect(a, b, c, d) \
314 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
315 _ipw_write_indirect(a, b, c, d)
317 /* indirect write s */
318 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
320 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
321 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
322 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
325 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
327 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
328 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
329 _ipw_write8(priv, IPW_INDIRECT_DATA, value);
332 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
334 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
335 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
336 _ipw_write16(priv, IPW_INDIRECT_DATA, value);
339 /* indirect read s */
341 static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
344 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
345 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
346 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
347 return (word >> ((reg & 0x3) * 8)) & 0xff;
350 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
354 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
356 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
357 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
358 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
362 /* iterative/auto-increment 32 bit reads and writes */
363 static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
366 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
367 u32 dif_len = addr - aligned_addr;
370 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
376 /* Read the first nibble byte by byte */
377 if (unlikely(dif_len)) {
378 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
379 /* Start reading at aligned_addr + dif_len */
380 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
381 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
385 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
386 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
387 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
389 /* Copy the last nibble */
391 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
392 for (i = 0; num > 0; i++, num--)
393 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
397 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
400 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
401 u32 dif_len = addr - aligned_addr;
404 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
410 /* Write the first nibble byte by byte */
411 if (unlikely(dif_len)) {
412 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
413 /* Start reading at aligned_addr + dif_len */
414 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
415 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
419 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
420 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
421 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
423 /* Copy the last nibble */
425 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
426 for (i = 0; num > 0; i++, num--, buf++)
427 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
431 static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
434 memcpy_toio((priv->hw_base + addr), buf, num);
437 static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
439 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
442 static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
444 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
447 static inline void ipw_enable_interrupts(struct ipw_priv *priv)
449 if (priv->status & STATUS_INT_ENABLED)
451 priv->status |= STATUS_INT_ENABLED;
452 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
455 static inline void ipw_disable_interrupts(struct ipw_priv *priv)
457 if (!(priv->status & STATUS_INT_ENABLED))
459 priv->status &= ~STATUS_INT_ENABLED;
460 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
463 #ifdef CONFIG_IPW_DEBUG
464 static char *ipw_error_desc(u32 val)
467 case IPW_FW_ERROR_OK:
469 case IPW_FW_ERROR_FAIL:
471 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
472 return "MEMORY_UNDERFLOW";
473 case IPW_FW_ERROR_MEMORY_OVERFLOW:
474 return "MEMORY_OVERFLOW";
475 case IPW_FW_ERROR_BAD_PARAM:
477 case IPW_FW_ERROR_BAD_CHECKSUM:
478 return "BAD_CHECKSUM";
479 case IPW_FW_ERROR_NMI_INTERRUPT:
480 return "NMI_INTERRUPT";
481 case IPW_FW_ERROR_BAD_DATABASE:
482 return "BAD_DATABASE";
483 case IPW_FW_ERROR_ALLOC_FAIL:
485 case IPW_FW_ERROR_DMA_UNDERRUN:
486 return "DMA_UNDERRUN";
487 case IPW_FW_ERROR_DMA_STATUS:
489 case IPW_FW_ERROR_DINO_ERROR:
491 case IPW_FW_ERROR_EEPROM_ERROR:
492 return "EEPROM_ERROR";
493 case IPW_FW_ERROR_SYSASSERT:
495 case IPW_FW_ERROR_FATAL_ERROR:
496 return "FATAL_ERROR";
498 return "UNKNOWN_ERROR";
502 static void ipw_dump_error_log(struct ipw_priv *priv,
503 struct ipw_fw_error *error)
508 IPW_ERROR("Error allocating and capturing error log. "
509 "Nothing to dump.\n");
513 IPW_ERROR("Start IPW Error Log Dump:\n");
514 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
515 error->status, error->config);
517 for (i = 0; i < error->elem_len; i++)
518 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
519 ipw_error_desc(error->elem[i].desc),
521 error->elem[i].blink1,
522 error->elem[i].blink2,
523 error->elem[i].link1,
524 error->elem[i].link2, error->elem[i].data);
525 for (i = 0; i < error->log_len; i++)
526 IPW_ERROR("%i\t0x%08x\t%i\n",
528 error->log[i].event, error->log[i].data);
532 static inline int ipw_is_init(struct ipw_priv *priv)
534 return (priv->status & STATUS_INIT) ? 1 : 0;
537 static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
539 u32 addr, field_info, field_len, field_count, total_len;
541 IPW_DEBUG_ORD("ordinal = %i\n", ord);
543 if (!priv || !val || !len) {
544 IPW_DEBUG_ORD("Invalid argument\n");
548 /* verify device ordinal tables have been initialized */
549 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
550 IPW_DEBUG_ORD("Access ordinals before initialization\n");
554 switch (IPW_ORD_TABLE_ID_MASK & ord) {
555 case IPW_ORD_TABLE_0_MASK:
557 * TABLE 0: Direct access to a table of 32 bit values
559 * This is a very simple table with the data directly
560 * read from the table
563 /* remove the table id from the ordinal */
564 ord &= IPW_ORD_TABLE_VALUE_MASK;
567 if (ord > priv->table0_len) {
568 IPW_DEBUG_ORD("ordinal value (%i) longer then "
569 "max (%i)\n", ord, priv->table0_len);
573 /* verify we have enough room to store the value */
574 if (*len < sizeof(u32)) {
575 IPW_DEBUG_ORD("ordinal buffer length too small, "
576 "need %zd\n", sizeof(u32));
580 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
581 ord, priv->table0_addr + (ord << 2));
585 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
588 case IPW_ORD_TABLE_1_MASK:
590 * TABLE 1: Indirect access to a table of 32 bit values
592 * This is a fairly large table of u32 values each
593 * representing starting addr for the data (which is
597 /* remove the table id from the ordinal */
598 ord &= IPW_ORD_TABLE_VALUE_MASK;
601 if (ord > priv->table1_len) {
602 IPW_DEBUG_ORD("ordinal value too long\n");
606 /* verify we have enough room to store the value */
607 if (*len < sizeof(u32)) {
608 IPW_DEBUG_ORD("ordinal buffer length too small, "
609 "need %zd\n", sizeof(u32));
614 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
618 case IPW_ORD_TABLE_2_MASK:
620 * TABLE 2: Indirect access to a table of variable sized values
622 * This table consist of six values, each containing
623 * - dword containing the starting offset of the data
624 * - dword containing the lengh in the first 16bits
625 * and the count in the second 16bits
628 /* remove the table id from the ordinal */
629 ord &= IPW_ORD_TABLE_VALUE_MASK;
632 if (ord > priv->table2_len) {
633 IPW_DEBUG_ORD("ordinal value too long\n");
637 /* get the address of statistic */
638 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
640 /* get the second DW of statistics ;
641 * two 16-bit words - first is length, second is count */
644 priv->table2_addr + (ord << 3) +
647 /* get each entry length */
648 field_len = *((u16 *) & field_info);
650 /* get number of entries */
651 field_count = *(((u16 *) & field_info) + 1);
653 /* abort if not enought memory */
654 total_len = field_len * field_count;
655 if (total_len > *len) {
664 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
665 "field_info = 0x%08x\n",
666 addr, total_len, field_info);
667 ipw_read_indirect(priv, addr, val, total_len);
671 IPW_DEBUG_ORD("Invalid ordinal!\n");
679 static void ipw_init_ordinals(struct ipw_priv *priv)
681 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
682 priv->table0_len = ipw_read32(priv, priv->table0_addr);
684 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
685 priv->table0_addr, priv->table0_len);
687 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
688 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
690 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
691 priv->table1_addr, priv->table1_len);
693 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
694 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
695 priv->table2_len &= 0x0000ffff; /* use first two bytes */
697 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
698 priv->table2_addr, priv->table2_len);
702 u32 ipw_register_toggle(u32 reg)
704 reg &= ~IPW_START_STANDBY;
705 if (reg & IPW_GATE_ODMA)
706 reg &= ~IPW_GATE_ODMA;
707 if (reg & IPW_GATE_IDMA)
708 reg &= ~IPW_GATE_IDMA;
709 if (reg & IPW_GATE_ADMA)
710 reg &= ~IPW_GATE_ADMA;
716 * - On radio ON, turn on any LEDs that require to be on during start
717 * - On initialization, start unassociated blink
718 * - On association, disable unassociated blink
719 * - On disassociation, start unassociated blink
720 * - On radio OFF, turn off any LEDs started during radio on
723 #define LD_TIME_LINK_ON 300
724 #define LD_TIME_LINK_OFF 2700
725 #define LD_TIME_ACT_ON 250
727 void ipw_led_link_on(struct ipw_priv *priv)
732 /* If configured to not use LEDs, or nic_type is 1,
733 * then we don't toggle a LINK led */
734 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
737 spin_lock_irqsave(&priv->lock, flags);
739 if (!(priv->status & STATUS_RF_KILL_MASK) &&
740 !(priv->status & STATUS_LED_LINK_ON)) {
741 IPW_DEBUG_LED("Link LED On\n");
742 led = ipw_read_reg32(priv, IPW_EVENT_REG);
743 led |= priv->led_association_on;
745 led = ipw_register_toggle(led);
747 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
748 ipw_write_reg32(priv, IPW_EVENT_REG, led);
750 priv->status |= STATUS_LED_LINK_ON;
752 /* If we aren't associated, schedule turning the LED off */
753 if (!(priv->status & STATUS_ASSOCIATED))
754 queue_delayed_work(priv->workqueue,
759 spin_unlock_irqrestore(&priv->lock, flags);
762 static void ipw_bg_led_link_on(void *data)
764 struct ipw_priv *priv = data;
766 ipw_led_link_on(data);
770 void ipw_led_link_off(struct ipw_priv *priv)
775 /* If configured not to use LEDs, or nic type is 1,
776 * then we don't goggle the LINK led. */
777 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
780 spin_lock_irqsave(&priv->lock, flags);
782 if (priv->status & STATUS_LED_LINK_ON) {
783 led = ipw_read_reg32(priv, IPW_EVENT_REG);
784 led &= priv->led_association_off;
785 led = ipw_register_toggle(led);
787 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
788 ipw_write_reg32(priv, IPW_EVENT_REG, led);
790 IPW_DEBUG_LED("Link LED Off\n");
792 priv->status &= ~STATUS_LED_LINK_ON;
794 /* If we aren't associated and the radio is on, schedule
795 * turning the LED on (blink while unassociated) */
796 if (!(priv->status & STATUS_RF_KILL_MASK) &&
797 !(priv->status & STATUS_ASSOCIATED))
798 queue_delayed_work(priv->workqueue, &priv->led_link_on,
803 spin_unlock_irqrestore(&priv->lock, flags);
806 static void ipw_bg_led_link_off(void *data)
808 struct ipw_priv *priv = data;
810 ipw_led_link_off(data);
814 static inline void __ipw_led_activity_on(struct ipw_priv *priv)
818 if (priv->config & CFG_NO_LED)
821 if (priv->status & STATUS_RF_KILL_MASK)
824 if (!(priv->status & STATUS_LED_ACT_ON)) {
825 led = ipw_read_reg32(priv, IPW_EVENT_REG);
826 led |= priv->led_activity_on;
828 led = ipw_register_toggle(led);
830 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
831 ipw_write_reg32(priv, IPW_EVENT_REG, led);
833 IPW_DEBUG_LED("Activity LED On\n");
835 priv->status |= STATUS_LED_ACT_ON;
837 cancel_delayed_work(&priv->led_act_off);
838 queue_delayed_work(priv->workqueue, &priv->led_act_off,
841 /* Reschedule LED off for full time period */
842 cancel_delayed_work(&priv->led_act_off);
843 queue_delayed_work(priv->workqueue, &priv->led_act_off,
848 void ipw_led_activity_on(struct ipw_priv *priv)
851 spin_lock_irqsave(&priv->lock, flags);
852 __ipw_led_activity_on(priv);
853 spin_unlock_irqrestore(&priv->lock, flags);
856 void ipw_led_activity_off(struct ipw_priv *priv)
861 if (priv->config & CFG_NO_LED)
864 spin_lock_irqsave(&priv->lock, flags);
866 if (priv->status & STATUS_LED_ACT_ON) {
867 led = ipw_read_reg32(priv, IPW_EVENT_REG);
868 led &= priv->led_activity_off;
870 led = ipw_register_toggle(led);
872 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
873 ipw_write_reg32(priv, IPW_EVENT_REG, led);
875 IPW_DEBUG_LED("Activity LED Off\n");
877 priv->status &= ~STATUS_LED_ACT_ON;
880 spin_unlock_irqrestore(&priv->lock, flags);
883 static void ipw_bg_led_activity_off(void *data)
885 struct ipw_priv *priv = data;
887 ipw_led_activity_off(data);
891 void ipw_led_band_on(struct ipw_priv *priv)
896 /* Only nic type 1 supports mode LEDs */
897 if (priv->config & CFG_NO_LED ||
898 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
901 spin_lock_irqsave(&priv->lock, flags);
903 led = ipw_read_reg32(priv, IPW_EVENT_REG);
904 if (priv->assoc_network->mode == IEEE_A) {
905 led |= priv->led_ofdm_on;
906 led &= priv->led_association_off;
907 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
908 } else if (priv->assoc_network->mode == IEEE_G) {
909 led |= priv->led_ofdm_on;
910 led |= priv->led_association_on;
911 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
913 led &= priv->led_ofdm_off;
914 led |= priv->led_association_on;
915 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
918 led = ipw_register_toggle(led);
920 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
921 ipw_write_reg32(priv, IPW_EVENT_REG, led);
923 spin_unlock_irqrestore(&priv->lock, flags);
926 void ipw_led_band_off(struct ipw_priv *priv)
931 /* Only nic type 1 supports mode LEDs */
932 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
935 spin_lock_irqsave(&priv->lock, flags);
937 led = ipw_read_reg32(priv, IPW_EVENT_REG);
938 led &= priv->led_ofdm_off;
939 led &= priv->led_association_off;
941 led = ipw_register_toggle(led);
943 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
944 ipw_write_reg32(priv, IPW_EVENT_REG, led);
946 spin_unlock_irqrestore(&priv->lock, flags);
949 void ipw_led_radio_on(struct ipw_priv *priv)
951 ipw_led_link_on(priv);
954 void ipw_led_radio_off(struct ipw_priv *priv)
956 ipw_led_activity_off(priv);
957 ipw_led_link_off(priv);
960 void ipw_led_link_up(struct ipw_priv *priv)
962 /* Set the Link Led on for all nic types */
963 ipw_led_link_on(priv);
966 void ipw_led_link_down(struct ipw_priv *priv)
968 ipw_led_activity_off(priv);
969 ipw_led_link_off(priv);
971 if (priv->status & STATUS_RF_KILL_MASK)
972 ipw_led_radio_off(priv);
975 void ipw_led_init(struct ipw_priv *priv)
977 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
979 /* Set the default PINs for the link and activity leds */
980 priv->led_activity_on = IPW_ACTIVITY_LED;
981 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
983 priv->led_association_on = IPW_ASSOCIATED_LED;
984 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
986 /* Set the default PINs for the OFDM leds */
987 priv->led_ofdm_on = IPW_OFDM_LED;
988 priv->led_ofdm_off = ~(IPW_OFDM_LED);
990 switch (priv->nic_type) {
991 case EEPROM_NIC_TYPE_1:
992 /* In this NIC type, the LEDs are reversed.... */
993 priv->led_activity_on = IPW_ASSOCIATED_LED;
994 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
995 priv->led_association_on = IPW_ACTIVITY_LED;
996 priv->led_association_off = ~(IPW_ACTIVITY_LED);
998 if (!(priv->config & CFG_NO_LED))
999 ipw_led_band_on(priv);
1001 /* And we don't blink link LEDs for this nic, so
1002 * just return here */
1005 case EEPROM_NIC_TYPE_3:
1006 case EEPROM_NIC_TYPE_2:
1007 case EEPROM_NIC_TYPE_4:
1008 case EEPROM_NIC_TYPE_0:
1012 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1014 priv->nic_type = EEPROM_NIC_TYPE_0;
1018 if (!(priv->config & CFG_NO_LED)) {
1019 if (priv->status & STATUS_ASSOCIATED)
1020 ipw_led_link_on(priv);
1022 ipw_led_link_off(priv);
1026 void ipw_led_shutdown(struct ipw_priv *priv)
1028 ipw_led_activity_off(priv);
1029 ipw_led_link_off(priv);
1030 ipw_led_band_off(priv);
1031 cancel_delayed_work(&priv->led_link_on);
1032 cancel_delayed_work(&priv->led_link_off);
1033 cancel_delayed_work(&priv->led_act_off);
1037 * The following adds a new attribute to the sysfs representation
1038 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1039 * used for controling the debug level.
1041 * See the level definitions in ipw for details.
1043 static ssize_t show_debug_level(struct device_driver *d, char *buf)
1045 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1048 static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1051 char *p = (char *)buf;
1054 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1056 if (p[0] == 'x' || p[0] == 'X')
1058 val = simple_strtoul(p, &p, 16);
1060 val = simple_strtoul(p, &p, 10);
1062 printk(KERN_INFO DRV_NAME
1063 ": %s is not in hex or decimal form.\n", buf);
1065 ipw_debug_level = val;
1067 return strnlen(buf, count);
1070 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
1071 show_debug_level, store_debug_level);
1073 static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
1075 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
1078 static void ipw_capture_event_log(struct ipw_priv *priv,
1079 u32 log_len, struct ipw_event *log)
1084 base = ipw_read32(priv, IPW_EVENT_LOG);
1085 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1086 (u8 *) log, sizeof(*log) * log_len);
1090 static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
1092 struct ipw_fw_error *error;
1093 u32 log_len = ipw_get_event_log_len(priv);
1094 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1095 u32 elem_len = ipw_read_reg32(priv, base);
1097 error = kmalloc(sizeof(*error) +
1098 sizeof(*error->elem) * elem_len +
1099 sizeof(*error->log) * log_len, GFP_ATOMIC);
1101 IPW_ERROR("Memory allocation for firmware error log "
1105 error->jiffies = jiffies;
1106 error->status = priv->status;
1107 error->config = priv->config;
1108 error->elem_len = elem_len;
1109 error->log_len = log_len;
1110 error->elem = (struct ipw_error_elem *)error->payload;
1111 error->log = (struct ipw_event *)(error->elem +
1112 (sizeof(*error->elem) * elem_len));
1114 ipw_capture_event_log(priv, log_len, error->log);
1117 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1118 sizeof(*error->elem) * elem_len);
1123 static void ipw_free_error_log(struct ipw_fw_error *error)
1129 static ssize_t show_event_log(struct device *d,
1130 struct device_attribute *attr, char *buf)
1132 struct ipw_priv *priv = dev_get_drvdata(d);
1133 u32 log_len = ipw_get_event_log_len(priv);
1134 struct ipw_event log[log_len];
1137 ipw_capture_event_log(priv, log_len, log);
1139 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1140 for (i = 0; i < log_len; i++)
1141 len += snprintf(buf + len, PAGE_SIZE - len,
1143 log[i].time, log[i].event, log[i].data);
1144 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1148 static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
1150 static ssize_t show_error(struct device *d,
1151 struct device_attribute *attr, char *buf)
1153 struct ipw_priv *priv = dev_get_drvdata(d);
1157 len += snprintf(buf + len, PAGE_SIZE - len,
1158 "%08lX%08X%08X%08X",
1159 priv->error->jiffies,
1160 priv->error->status,
1161 priv->error->config, priv->error->elem_len);
1162 for (i = 0; i < priv->error->elem_len; i++)
1163 len += snprintf(buf + len, PAGE_SIZE - len,
1164 "\n%08X%08X%08X%08X%08X%08X%08X",
1165 priv->error->elem[i].time,
1166 priv->error->elem[i].desc,
1167 priv->error->elem[i].blink1,
1168 priv->error->elem[i].blink2,
1169 priv->error->elem[i].link1,
1170 priv->error->elem[i].link2,
1171 priv->error->elem[i].data);
1173 len += snprintf(buf + len, PAGE_SIZE - len,
1174 "\n%08X", priv->error->log_len);
1175 for (i = 0; i < priv->error->log_len; i++)
1176 len += snprintf(buf + len, PAGE_SIZE - len,
1178 priv->error->log[i].time,
1179 priv->error->log[i].event,
1180 priv->error->log[i].data);
1181 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1185 static ssize_t clear_error(struct device *d,
1186 struct device_attribute *attr,
1187 const char *buf, size_t count)
1189 struct ipw_priv *priv = dev_get_drvdata(d);
1191 ipw_free_error_log(priv->error);
1197 static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
1199 static ssize_t show_cmd_log(struct device *d,
1200 struct device_attribute *attr, char *buf)
1202 struct ipw_priv *priv = dev_get_drvdata(d);
1206 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1207 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1208 i = (i + 1) % priv->cmdlog_len) {
1210 snprintf(buf + len, PAGE_SIZE - len,
1211 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1212 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1213 priv->cmdlog[i].cmd.len);
1215 snprintk_buf(buf + len, PAGE_SIZE - len,
1216 (u8 *) priv->cmdlog[i].cmd.param,
1217 priv->cmdlog[i].cmd.len);
1218 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1220 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1224 static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
1226 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1229 struct ipw_priv *priv = dev_get_drvdata(d);
1230 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1233 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1234 const char *buf, size_t count)
1236 struct ipw_priv *priv = dev_get_drvdata(d);
1237 #ifdef CONFIG_IPW_DEBUG
1238 struct net_device *dev = priv->net_dev;
1240 char buffer[] = "00000000";
1242 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1246 IPW_DEBUG_INFO("enter\n");
1248 strncpy(buffer, buf, len);
1251 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1253 if (p[0] == 'x' || p[0] == 'X')
1255 val = simple_strtoul(p, &p, 16);
1257 val = simple_strtoul(p, &p, 10);
1259 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1261 priv->ieee->scan_age = val;
1262 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1265 IPW_DEBUG_INFO("exit\n");
1269 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1271 static ssize_t show_led(struct device *d, struct device_attribute *attr,
1274 struct ipw_priv *priv = dev_get_drvdata(d);
1275 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1278 static ssize_t store_led(struct device *d, struct device_attribute *attr,
1279 const char *buf, size_t count)
1281 struct ipw_priv *priv = dev_get_drvdata(d);
1283 IPW_DEBUG_INFO("enter\n");
1289 IPW_DEBUG_LED("Disabling LED control.\n");
1290 priv->config |= CFG_NO_LED;
1291 ipw_led_shutdown(priv);
1293 IPW_DEBUG_LED("Enabling LED control.\n");
1294 priv->config &= ~CFG_NO_LED;
1298 IPW_DEBUG_INFO("exit\n");
1302 static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1304 static ssize_t show_status(struct device *d,
1305 struct device_attribute *attr, char *buf)
1307 struct ipw_priv *p = d->driver_data;
1308 return sprintf(buf, "0x%08x\n", (int)p->status);
1311 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1313 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1316 struct ipw_priv *p = d->driver_data;
1317 return sprintf(buf, "0x%08x\n", (int)p->config);
1320 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1322 static ssize_t show_nic_type(struct device *d,
1323 struct device_attribute *attr, char *buf)
1325 struct ipw_priv *priv = d->driver_data;
1326 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1329 static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1331 static ssize_t show_ucode_version(struct device *d,
1332 struct device_attribute *attr, char *buf)
1334 u32 len = sizeof(u32), tmp = 0;
1335 struct ipw_priv *p = d->driver_data;
1337 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
1340 return sprintf(buf, "0x%08x\n", tmp);
1343 static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
1345 static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1348 u32 len = sizeof(u32), tmp = 0;
1349 struct ipw_priv *p = d->driver_data;
1351 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
1354 return sprintf(buf, "0x%08x\n", tmp);
1357 static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
1360 * Add a device attribute to view/control the delay between eeprom
1363 static ssize_t show_eeprom_delay(struct device *d,
1364 struct device_attribute *attr, char *buf)
1366 int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
1367 return sprintf(buf, "%i\n", n);
1369 static ssize_t store_eeprom_delay(struct device *d,
1370 struct device_attribute *attr,
1371 const char *buf, size_t count)
1373 struct ipw_priv *p = d->driver_data;
1374 sscanf(buf, "%i", &p->eeprom_delay);
1375 return strnlen(buf, count);
1378 static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1379 show_eeprom_delay, store_eeprom_delay);
1381 static ssize_t show_command_event_reg(struct device *d,
1382 struct device_attribute *attr, char *buf)
1385 struct ipw_priv *p = d->driver_data;
1387 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
1388 return sprintf(buf, "0x%08x\n", reg);
1390 static ssize_t store_command_event_reg(struct device *d,
1391 struct device_attribute *attr,
1392 const char *buf, size_t count)
1395 struct ipw_priv *p = d->driver_data;
1397 sscanf(buf, "%x", ®);
1398 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
1399 return strnlen(buf, count);
1402 static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1403 show_command_event_reg, store_command_event_reg);
1405 static ssize_t show_mem_gpio_reg(struct device *d,
1406 struct device_attribute *attr, char *buf)
1409 struct ipw_priv *p = d->driver_data;
1411 reg = ipw_read_reg32(p, 0x301100);
1412 return sprintf(buf, "0x%08x\n", reg);
1414 static ssize_t store_mem_gpio_reg(struct device *d,
1415 struct device_attribute *attr,
1416 const char *buf, size_t count)
1419 struct ipw_priv *p = d->driver_data;
1421 sscanf(buf, "%x", ®);
1422 ipw_write_reg32(p, 0x301100, reg);
1423 return strnlen(buf, count);
1426 static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1427 show_mem_gpio_reg, store_mem_gpio_reg);
1429 static ssize_t show_indirect_dword(struct device *d,
1430 struct device_attribute *attr, char *buf)
1433 struct ipw_priv *priv = d->driver_data;
1435 if (priv->status & STATUS_INDIRECT_DWORD)
1436 reg = ipw_read_reg32(priv, priv->indirect_dword);
1440 return sprintf(buf, "0x%08x\n", reg);
1442 static ssize_t store_indirect_dword(struct device *d,
1443 struct device_attribute *attr,
1444 const char *buf, size_t count)
1446 struct ipw_priv *priv = d->driver_data;
1448 sscanf(buf, "%x", &priv->indirect_dword);
1449 priv->status |= STATUS_INDIRECT_DWORD;
1450 return strnlen(buf, count);
1453 static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1454 show_indirect_dword, store_indirect_dword);
1456 static ssize_t show_indirect_byte(struct device *d,
1457 struct device_attribute *attr, char *buf)
1460 struct ipw_priv *priv = d->driver_data;
1462 if (priv->status & STATUS_INDIRECT_BYTE)
1463 reg = ipw_read_reg8(priv, priv->indirect_byte);
1467 return sprintf(buf, "0x%02x\n", reg);
1469 static ssize_t store_indirect_byte(struct device *d,
1470 struct device_attribute *attr,
1471 const char *buf, size_t count)
1473 struct ipw_priv *priv = d->driver_data;
1475 sscanf(buf, "%x", &priv->indirect_byte);
1476 priv->status |= STATUS_INDIRECT_BYTE;
1477 return strnlen(buf, count);
1480 static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
1481 show_indirect_byte, store_indirect_byte);
1483 static ssize_t show_direct_dword(struct device *d,
1484 struct device_attribute *attr, char *buf)
1487 struct ipw_priv *priv = d->driver_data;
1489 if (priv->status & STATUS_DIRECT_DWORD)
1490 reg = ipw_read32(priv, priv->direct_dword);
1494 return sprintf(buf, "0x%08x\n", reg);
1496 static ssize_t store_direct_dword(struct device *d,
1497 struct device_attribute *attr,
1498 const char *buf, size_t count)
1500 struct ipw_priv *priv = d->driver_data;
1502 sscanf(buf, "%x", &priv->direct_dword);
1503 priv->status |= STATUS_DIRECT_DWORD;
1504 return strnlen(buf, count);
1507 static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1508 show_direct_dword, store_direct_dword);
1510 static inline int rf_kill_active(struct ipw_priv *priv)
1512 if (0 == (ipw_read32(priv, 0x30) & 0x10000))
1513 priv->status |= STATUS_RF_KILL_HW;
1515 priv->status &= ~STATUS_RF_KILL_HW;
1517 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1520 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
1523 /* 0 - RF kill not enabled
1524 1 - SW based RF kill active (sysfs)
1525 2 - HW based RF kill active
1526 3 - Both HW and SW baed RF kill active */
1527 struct ipw_priv *priv = d->driver_data;
1528 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1529 (rf_kill_active(priv) ? 0x2 : 0x0);
1530 return sprintf(buf, "%i\n", val);
1533 static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1535 if ((disable_radio ? 1 : 0) ==
1536 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1539 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1540 disable_radio ? "OFF" : "ON");
1542 if (disable_radio) {
1543 priv->status |= STATUS_RF_KILL_SW;
1545 if (priv->workqueue)
1546 cancel_delayed_work(&priv->request_scan);
1547 queue_work(priv->workqueue, &priv->down);
1549 priv->status &= ~STATUS_RF_KILL_SW;
1550 if (rf_kill_active(priv)) {
1551 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1552 "disabled by HW switch\n");
1553 /* Make sure the RF_KILL check timer is running */
1554 cancel_delayed_work(&priv->rf_kill);
1555 queue_delayed_work(priv->workqueue, &priv->rf_kill,
1558 queue_work(priv->workqueue, &priv->up);
1564 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1565 const char *buf, size_t count)
1567 struct ipw_priv *priv = d->driver_data;
1569 ipw_radio_kill_sw(priv, buf[0] == '1');
1574 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
1576 static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1579 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1580 int pos = 0, len = 0;
1581 if (priv->config & CFG_SPEED_SCAN) {
1582 while (priv->speed_scan[pos] != 0)
1583 len += sprintf(&buf[len], "%d ",
1584 priv->speed_scan[pos++]);
1585 return len + sprintf(&buf[len], "\n");
1588 return sprintf(buf, "0\n");
1591 static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1592 const char *buf, size_t count)
1594 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1595 int channel, pos = 0;
1596 const char *p = buf;
1598 /* list of space separated channels to scan, optionally ending with 0 */
1599 while ((channel = simple_strtol(p, NULL, 0))) {
1600 if (pos == MAX_SPEED_SCAN - 1) {
1601 priv->speed_scan[pos] = 0;
1605 if (ipw_is_valid_channel(priv->ieee, channel))
1606 priv->speed_scan[pos++] = channel;
1608 IPW_WARNING("Skipping invalid channel request: %d\n",
1613 while (*p == ' ' || *p == '\t')
1618 priv->config &= ~CFG_SPEED_SCAN;
1620 priv->speed_scan_pos = 0;
1621 priv->config |= CFG_SPEED_SCAN;
1627 static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1630 static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1633 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1634 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1637 static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1638 const char *buf, size_t count)
1640 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1642 priv->config |= CFG_NET_STATS;
1644 priv->config &= ~CFG_NET_STATS;
1649 static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1650 show_net_stats, store_net_stats);
1652 static void notify_wx_assoc_event(struct ipw_priv *priv)
1654 union iwreq_data wrqu;
1655 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1656 if (priv->status & STATUS_ASSOCIATED)
1657 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1659 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1660 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1663 static void ipw_irq_tasklet(struct ipw_priv *priv)
1665 u32 inta, inta_mask, handled = 0;
1666 unsigned long flags;
1669 spin_lock_irqsave(&priv->lock, flags);
1671 inta = ipw_read32(priv, IPW_INTA_RW);
1672 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1673 inta &= (IPW_INTA_MASK_ALL & inta_mask);
1675 /* Add any cached INTA values that need to be handled */
1676 inta |= priv->isr_inta;
1678 /* handle all the justifications for the interrupt */
1679 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1681 handled |= IPW_INTA_BIT_RX_TRANSFER;
1684 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1685 IPW_DEBUG_HC("Command completed.\n");
1686 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1687 priv->status &= ~STATUS_HCMD_ACTIVE;
1688 wake_up_interruptible(&priv->wait_command_queue);
1689 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1692 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
1693 IPW_DEBUG_TX("TX_QUEUE_1\n");
1694 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1695 handled |= IPW_INTA_BIT_TX_QUEUE_1;
1698 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
1699 IPW_DEBUG_TX("TX_QUEUE_2\n");
1700 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1701 handled |= IPW_INTA_BIT_TX_QUEUE_2;
1704 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
1705 IPW_DEBUG_TX("TX_QUEUE_3\n");
1706 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1707 handled |= IPW_INTA_BIT_TX_QUEUE_3;
1710 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
1711 IPW_DEBUG_TX("TX_QUEUE_4\n");
1712 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
1713 handled |= IPW_INTA_BIT_TX_QUEUE_4;
1716 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
1717 IPW_WARNING("STATUS_CHANGE\n");
1718 handled |= IPW_INTA_BIT_STATUS_CHANGE;
1721 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
1722 IPW_WARNING("TX_PERIOD_EXPIRED\n");
1723 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
1726 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
1727 IPW_WARNING("HOST_CMD_DONE\n");
1728 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
1731 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
1732 IPW_WARNING("FW_INITIALIZATION_DONE\n");
1733 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
1736 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
1737 IPW_WARNING("PHY_OFF_DONE\n");
1738 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
1741 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
1742 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1743 priv->status |= STATUS_RF_KILL_HW;
1744 wake_up_interruptible(&priv->wait_command_queue);
1745 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1746 cancel_delayed_work(&priv->request_scan);
1747 schedule_work(&priv->link_down);
1748 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
1749 handled |= IPW_INTA_BIT_RF_KILL_DONE;
1752 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1753 IPW_ERROR("Firmware error detected. Restarting.\n");
1755 IPW_ERROR("Sysfs 'error' log already exists.\n");
1756 #ifdef CONFIG_IPW_DEBUG
1757 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1758 struct ipw_fw_error *error =
1759 ipw_alloc_error_log(priv);
1760 ipw_dump_error_log(priv, error);
1762 ipw_free_error_log(error);
1766 priv->error = ipw_alloc_error_log(priv);
1768 IPW_ERROR("Sysfs 'error' log captured.\n");
1770 IPW_ERROR("Error allocating sysfs 'error' "
1772 #ifdef CONFIG_IPW_DEBUG
1773 if (ipw_debug_level & IPW_DL_FW_ERRORS)
1774 ipw_dump_error_log(priv, priv->error);
1778 /* XXX: If hardware encryption is for WPA/WPA2,
1779 * we have to notify the supplicant. */
1780 if (priv->ieee->sec.encrypt) {
1781 priv->status &= ~STATUS_ASSOCIATED;
1782 notify_wx_assoc_event(priv);
1785 /* Keep the restart process from trying to send host
1786 * commands by clearing the INIT status bit */
1787 priv->status &= ~STATUS_INIT;
1789 /* Cancel currently queued command. */
1790 priv->status &= ~STATUS_HCMD_ACTIVE;
1791 wake_up_interruptible(&priv->wait_command_queue);
1793 queue_work(priv->workqueue, &priv->adapter_restart);
1794 handled |= IPW_INTA_BIT_FATAL_ERROR;
1797 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
1798 IPW_ERROR("Parity error\n");
1799 handled |= IPW_INTA_BIT_PARITY_ERROR;
1802 if (handled != inta) {
1803 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
1806 /* enable all interrupts */
1807 ipw_enable_interrupts(priv);
1809 spin_unlock_irqrestore(&priv->lock, flags);
1812 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1813 static char *get_cmd_string(u8 cmd)
1816 IPW_CMD(HOST_COMPLETE);
1817 IPW_CMD(POWER_DOWN);
1818 IPW_CMD(SYSTEM_CONFIG);
1819 IPW_CMD(MULTICAST_ADDRESS);
1821 IPW_CMD(ADAPTER_ADDRESS);
1823 IPW_CMD(RTS_THRESHOLD);
1824 IPW_CMD(FRAG_THRESHOLD);
1825 IPW_CMD(POWER_MODE);
1827 IPW_CMD(TGI_TX_KEY);
1828 IPW_CMD(SCAN_REQUEST);
1829 IPW_CMD(SCAN_REQUEST_EXT);
1831 IPW_CMD(SUPPORTED_RATES);
1832 IPW_CMD(SCAN_ABORT);
1834 IPW_CMD(QOS_PARAMETERS);
1835 IPW_CMD(DINO_CONFIG);
1836 IPW_CMD(RSN_CAPABILITIES);
1838 IPW_CMD(CARD_DISABLE);
1839 IPW_CMD(SEED_NUMBER);
1841 IPW_CMD(COUNTRY_INFO);
1842 IPW_CMD(AIRONET_INFO);
1843 IPW_CMD(AP_TX_POWER);
1845 IPW_CMD(CCX_VER_INFO);
1846 IPW_CMD(SET_CALIBRATION);
1847 IPW_CMD(SENSITIVITY_CALIB);
1848 IPW_CMD(RETRY_LIMIT);
1849 IPW_CMD(IPW_PRE_POWER_DOWN);
1850 IPW_CMD(VAP_BEACON_TEMPLATE);
1851 IPW_CMD(VAP_DTIM_PERIOD);
1852 IPW_CMD(EXT_SUPPORTED_RATES);
1853 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1854 IPW_CMD(VAP_QUIET_INTERVALS);
1855 IPW_CMD(VAP_CHANNEL_SWITCH);
1856 IPW_CMD(VAP_MANDATORY_CHANNELS);
1857 IPW_CMD(VAP_CELL_PWR_LIMIT);
1858 IPW_CMD(VAP_CF_PARAM_SET);
1859 IPW_CMD(VAP_SET_BEACONING_STATE);
1860 IPW_CMD(MEASUREMENT);
1861 IPW_CMD(POWER_CAPABILITY);
1862 IPW_CMD(SUPPORTED_CHANNELS);
1863 IPW_CMD(TPC_REPORT);
1865 IPW_CMD(PRODUCTION_COMMAND);
1871 #define HOST_COMPLETE_TIMEOUT HZ
1872 static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
1875 unsigned long flags;
1877 spin_lock_irqsave(&priv->lock, flags);
1878 if (priv->status & STATUS_HCMD_ACTIVE) {
1879 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1880 get_cmd_string(cmd->cmd));
1881 spin_unlock_irqrestore(&priv->lock, flags);
1885 if (priv->status & STATUS_ASSOCIATING) {
1886 IPW_DEBUG_HC("abandon a command while associating\n");
1887 spin_unlock_irqrestore(&priv->lock, flags);
1891 if (priv->status & STATUS_DISASSOCIATING) {
1892 IPW_DEBUG_HC("abandon a command while disassociating\n");
1893 spin_unlock_irqrestore(&priv->lock, flags);
1897 priv->status |= STATUS_HCMD_ACTIVE;
1900 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1901 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1902 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1903 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1905 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1908 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1909 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1911 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1913 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
1915 priv->status &= ~STATUS_HCMD_ACTIVE;
1916 IPW_ERROR("Failed to send %s: Reason %d\n",
1917 get_cmd_string(cmd->cmd), rc);
1918 spin_unlock_irqrestore(&priv->lock, flags);
1921 spin_unlock_irqrestore(&priv->lock, flags);
1923 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1925 status & STATUS_HCMD_ACTIVE),
1926 HOST_COMPLETE_TIMEOUT);
1928 spin_lock_irqsave(&priv->lock, flags);
1929 if (priv->status & STATUS_HCMD_ACTIVE) {
1930 IPW_ERROR("Failed to send %s: Command timed out.\n",
1931 get_cmd_string(cmd->cmd));
1932 priv->status &= ~STATUS_HCMD_ACTIVE;
1933 spin_unlock_irqrestore(&priv->lock, flags);
1937 spin_unlock_irqrestore(&priv->lock, flags);
1941 if (priv->status & STATUS_RF_KILL_HW) {
1942 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1943 get_cmd_string(cmd->cmd));
1950 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1951 priv->cmdlog_pos %= priv->cmdlog_len;
1956 static int ipw_send_host_complete(struct ipw_priv *priv)
1958 struct host_cmd cmd = {
1959 .cmd = IPW_CMD_HOST_COMPLETE,
1964 IPW_ERROR("Invalid args\n");
1968 return ipw_send_cmd(priv, &cmd);
1971 static int ipw_send_system_config(struct ipw_priv *priv,
1972 struct ipw_sys_config *config)
1974 struct host_cmd cmd = {
1975 .cmd = IPW_CMD_SYSTEM_CONFIG,
1976 .len = sizeof(*config)
1979 if (!priv || !config) {
1980 IPW_ERROR("Invalid args\n");
1984 memcpy(cmd.param, config, sizeof(*config));
1985 return ipw_send_cmd(priv, &cmd);
1988 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
1990 struct host_cmd cmd = {
1991 .cmd = IPW_CMD_SSID,
1992 .len = min(len, IW_ESSID_MAX_SIZE)
1995 if (!priv || !ssid) {
1996 IPW_ERROR("Invalid args\n");
2000 memcpy(cmd.param, ssid, cmd.len);
2001 return ipw_send_cmd(priv, &cmd);
2004 static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
2006 struct host_cmd cmd = {
2007 .cmd = IPW_CMD_ADAPTER_ADDRESS,
2011 if (!priv || !mac) {
2012 IPW_ERROR("Invalid args\n");
2016 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2017 priv->net_dev->name, MAC_ARG(mac));
2019 memcpy(cmd.param, mac, ETH_ALEN);
2020 return ipw_send_cmd(priv, &cmd);
2024 * NOTE: This must be executed from our workqueue as it results in udelay
2025 * being called which may corrupt the keyboard if executed on default
2028 static void ipw_adapter_restart(void *adapter)
2030 struct ipw_priv *priv = adapter;
2032 if (priv->status & STATUS_RF_KILL_MASK)
2037 if (priv->assoc_network &&
2038 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2039 ipw_remove_current_network(priv);
2042 IPW_ERROR("Failed to up device\n");
2047 static void ipw_bg_adapter_restart(void *data)
2049 struct ipw_priv *priv = data;
2051 ipw_adapter_restart(data);
2055 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2057 static void ipw_scan_check(void *data)
2059 struct ipw_priv *priv = data;
2060 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2061 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2062 "adapter (%dms).\n",
2063 IPW_SCAN_CHECK_WATCHDOG / 100);
2064 queue_work(priv->workqueue, &priv->adapter_restart);
2068 static void ipw_bg_scan_check(void *data)
2070 struct ipw_priv *priv = data;
2072 ipw_scan_check(data);
2076 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2077 struct ipw_scan_request_ext *request)
2079 struct host_cmd cmd = {
2080 .cmd = IPW_CMD_SCAN_REQUEST_EXT,
2081 .len = sizeof(*request)
2084 memcpy(cmd.param, request, sizeof(*request));
2085 return ipw_send_cmd(priv, &cmd);
2088 static int ipw_send_scan_abort(struct ipw_priv *priv)
2090 struct host_cmd cmd = {
2091 .cmd = IPW_CMD_SCAN_ABORT,
2096 IPW_ERROR("Invalid args\n");
2100 return ipw_send_cmd(priv, &cmd);
2103 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2105 struct host_cmd cmd = {
2106 .cmd = IPW_CMD_SENSITIVITY_CALIB,
2107 .len = sizeof(struct ipw_sensitivity_calib)
2109 struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
2111 calib->beacon_rssi_raw = sens;
2112 return ipw_send_cmd(priv, &cmd);
2115 static int ipw_send_associate(struct ipw_priv *priv,
2116 struct ipw_associate *associate)
2118 struct host_cmd cmd = {
2119 .cmd = IPW_CMD_ASSOCIATE,
2120 .len = sizeof(*associate)
2123 struct ipw_associate tmp_associate;
2124 memcpy(&tmp_associate, associate, sizeof(*associate));
2125 tmp_associate.policy_support =
2126 cpu_to_le16(tmp_associate.policy_support);
2127 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2128 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2129 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2130 tmp_associate.listen_interval =
2131 cpu_to_le16(tmp_associate.listen_interval);
2132 tmp_associate.beacon_interval =
2133 cpu_to_le16(tmp_associate.beacon_interval);
2134 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2136 if (!priv || !associate) {
2137 IPW_ERROR("Invalid args\n");
2141 memcpy(cmd.param, &tmp_associate, sizeof(*associate));
2142 return ipw_send_cmd(priv, &cmd);
2145 static int ipw_send_supported_rates(struct ipw_priv *priv,
2146 struct ipw_supported_rates *rates)
2148 struct host_cmd cmd = {
2149 .cmd = IPW_CMD_SUPPORTED_RATES,
2150 .len = sizeof(*rates)
2153 if (!priv || !rates) {
2154 IPW_ERROR("Invalid args\n");
2158 memcpy(cmd.param, rates, sizeof(*rates));
2159 return ipw_send_cmd(priv, &cmd);
2162 static int ipw_set_random_seed(struct ipw_priv *priv)
2164 struct host_cmd cmd = {
2165 .cmd = IPW_CMD_SEED_NUMBER,
2170 IPW_ERROR("Invalid args\n");
2174 get_random_bytes(&cmd.param, sizeof(u32));
2176 return ipw_send_cmd(priv, &cmd);
2179 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2181 struct host_cmd cmd = {
2182 .cmd = IPW_CMD_CARD_DISABLE,
2187 IPW_ERROR("Invalid args\n");
2191 *((u32 *) & cmd.param) = phy_off;
2193 return ipw_send_cmd(priv, &cmd);
2196 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2198 struct host_cmd cmd = {
2199 .cmd = IPW_CMD_TX_POWER,
2200 .len = sizeof(*power)
2203 if (!priv || !power) {
2204 IPW_ERROR("Invalid args\n");
2208 memcpy(cmd.param, power, sizeof(*power));
2209 return ipw_send_cmd(priv, &cmd);
2212 static int ipw_set_tx_power(struct ipw_priv *priv)
2214 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
2215 struct ipw_tx_power tx_power;
2219 memset(&tx_power, 0, sizeof(tx_power));
2221 /* configure device for 'G' band */
2222 tx_power.ieee_mode = IPW_G_MODE;
2223 tx_power.num_channels = geo->bg_channels;
2224 for (i = 0; i < geo->bg_channels; i++) {
2225 max_power = geo->bg[i].max_power;
2226 tx_power.channels_tx_power[i].channel_number =
2228 tx_power.channels_tx_power[i].tx_power = max_power ?
2229 min(max_power, priv->tx_power) : priv->tx_power;
2231 if (ipw_send_tx_power(priv, &tx_power))
2234 /* configure device to also handle 'B' band */
2235 tx_power.ieee_mode = IPW_B_MODE;
2236 if (ipw_send_tx_power(priv, &tx_power))
2239 /* configure device to also handle 'A' band */
2240 if (priv->ieee->abg_true) {
2241 tx_power.ieee_mode = IPW_A_MODE;
2242 tx_power.num_channels = geo->a_channels;
2243 for (i = 0; i < tx_power.num_channels; i++) {
2244 max_power = geo->a[i].max_power;
2245 tx_power.channels_tx_power[i].channel_number =
2247 tx_power.channels_tx_power[i].tx_power = max_power ?
2248 min(max_power, priv->tx_power) : priv->tx_power;
2250 if (ipw_send_tx_power(priv, &tx_power))
2256 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2258 struct ipw_rts_threshold rts_threshold = {
2259 .rts_threshold = rts,
2261 struct host_cmd cmd = {
2262 .cmd = IPW_CMD_RTS_THRESHOLD,
2263 .len = sizeof(rts_threshold)
2267 IPW_ERROR("Invalid args\n");
2271 memcpy(cmd.param, &rts_threshold, sizeof(rts_threshold));
2272 return ipw_send_cmd(priv, &cmd);
2275 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2277 struct ipw_frag_threshold frag_threshold = {
2278 .frag_threshold = frag,
2280 struct host_cmd cmd = {
2281 .cmd = IPW_CMD_FRAG_THRESHOLD,
2282 .len = sizeof(frag_threshold)
2286 IPW_ERROR("Invalid args\n");
2290 memcpy(cmd.param, &frag_threshold, sizeof(frag_threshold));
2291 return ipw_send_cmd(priv, &cmd);
2294 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2296 struct host_cmd cmd = {
2297 .cmd = IPW_CMD_POWER_MODE,
2300 u32 *param = (u32 *) (&cmd.param);
2303 IPW_ERROR("Invalid args\n");
2307 /* If on battery, set to 3, if AC set to CAM, else user
2310 case IPW_POWER_BATTERY:
2311 *param = IPW_POWER_INDEX_3;
2314 *param = IPW_POWER_MODE_CAM;
2321 return ipw_send_cmd(priv, &cmd);
2324 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2326 struct ipw_retry_limit retry_limit = {
2327 .short_retry_limit = slimit,
2328 .long_retry_limit = llimit
2330 struct host_cmd cmd = {
2331 .cmd = IPW_CMD_RETRY_LIMIT,
2332 .len = sizeof(retry_limit)
2336 IPW_ERROR("Invalid args\n");
2340 memcpy(cmd.param, &retry_limit, sizeof(retry_limit));
2341 return ipw_send_cmd(priv, &cmd);
2345 * The IPW device contains a Microwire compatible EEPROM that stores
2346 * various data like the MAC address. Usually the firmware has exclusive
2347 * access to the eeprom, but during device initialization (before the
2348 * device driver has sent the HostComplete command to the firmware) the
2349 * device driver has read access to the EEPROM by way of indirect addressing
2350 * through a couple of memory mapped registers.
2352 * The following is a simplified implementation for pulling data out of the
2353 * the eeprom, along with some helper functions to find information in
2354 * the per device private data's copy of the eeprom.
2356 * NOTE: To better understand how these functions work (i.e what is a chip
2357 * select and why do have to keep driving the eeprom clock?), read
2358 * just about any data sheet for a Microwire compatible EEPROM.
2361 /* write a 32 bit value into the indirect accessor register */
2362 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2364 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2366 /* the eeprom requires some time to complete the operation */
2367 udelay(p->eeprom_delay);
2372 /* perform a chip select operation */
2373 static inline void eeprom_cs(struct ipw_priv *priv)
2375 eeprom_write_reg(priv, 0);
2376 eeprom_write_reg(priv, EEPROM_BIT_CS);
2377 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2378 eeprom_write_reg(priv, EEPROM_BIT_CS);
2381 /* perform a chip select operation */
2382 static inline void eeprom_disable_cs(struct ipw_priv *priv)
2384 eeprom_write_reg(priv, EEPROM_BIT_CS);
2385 eeprom_write_reg(priv, 0);
2386 eeprom_write_reg(priv, EEPROM_BIT_SK);
2389 /* push a single bit down to the eeprom */
2390 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2392 int d = (bit ? EEPROM_BIT_DI : 0);
2393 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2394 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2397 /* push an opcode followed by an address down to the eeprom */
2398 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2403 eeprom_write_bit(priv, 1);
2404 eeprom_write_bit(priv, op & 2);
2405 eeprom_write_bit(priv, op & 1);
2406 for (i = 7; i >= 0; i--) {
2407 eeprom_write_bit(priv, addr & (1 << i));
2411 /* pull 16 bits off the eeprom, one bit at a time */
2412 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2417 /* Send READ Opcode */
2418 eeprom_op(priv, EEPROM_CMD_READ, addr);
2420 /* Send dummy bit */
2421 eeprom_write_reg(priv, EEPROM_BIT_CS);
2423 /* Read the byte off the eeprom one bit at a time */
2424 for (i = 0; i < 16; i++) {
2426 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2427 eeprom_write_reg(priv, EEPROM_BIT_CS);
2428 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2429 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2432 /* Send another dummy bit */
2433 eeprom_write_reg(priv, 0);
2434 eeprom_disable_cs(priv);
2439 /* helper function for pulling the mac address out of the private */
2440 /* data's copy of the eeprom data */
2441 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2443 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
2447 * Either the device driver (i.e. the host) or the firmware can
2448 * load eeprom data into the designated region in SRAM. If neither
2449 * happens then the FW will shutdown with a fatal error.
2451 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2452 * bit needs region of shared SRAM needs to be non-zero.
2454 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2457 u16 *eeprom = (u16 *) priv->eeprom;
2459 IPW_DEBUG_TRACE(">>\n");
2461 /* read entire contents of eeprom into private buffer */
2462 for (i = 0; i < 128; i++)
2463 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
2466 If the data looks correct, then copy it to our private
2467 copy. Otherwise let the firmware know to perform the operation
2470 if ((priv->eeprom + EEPROM_VERSION) != 0) {
2471 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2473 /* write the eeprom data to sram */
2474 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2475 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2477 /* Do not load eeprom data on fatal error or suspend */
2478 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2480 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2482 /* Load eeprom data on fatal error or suspend */
2483 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2486 IPW_DEBUG_TRACE("<<\n");
2489 static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2494 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2496 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2499 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2501 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2502 CB_NUMBER_OF_ELEMENTS_SMALL *
2503 sizeof(struct command_block));
2506 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2507 { /* start dma engine but no transfers yet */
2509 IPW_DEBUG_FW(">> : \n");
2512 ipw_fw_dma_reset_command_blocks(priv);
2514 /* Write CB base address */
2515 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2517 IPW_DEBUG_FW("<< : \n");
2521 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2525 IPW_DEBUG_FW(">> :\n");
2527 //set the Stop and Abort bit
2528 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2529 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2530 priv->sram_desc.last_cb_index = 0;
2532 IPW_DEBUG_FW("<< \n");
2535 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2536 struct command_block *cb)
2539 IPW_SHARED_SRAM_DMA_CONTROL +
2540 (sizeof(struct command_block) * index);
2541 IPW_DEBUG_FW(">> :\n");
2543 ipw_write_indirect(priv, address, (u8 *) cb,
2544 (int)sizeof(struct command_block));
2546 IPW_DEBUG_FW("<< :\n");
2551 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2556 IPW_DEBUG_FW(">> :\n");
2558 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2559 ipw_fw_dma_write_command_block(priv, index,
2560 &priv->sram_desc.cb_list[index]);
2562 /* Enable the DMA in the CSR register */
2563 ipw_clear_bit(priv, IPW_RESET_REG,
2564 IPW_RESET_REG_MASTER_DISABLED |
2565 IPW_RESET_REG_STOP_MASTER);
2567 /* Set the Start bit. */
2568 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2569 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2571 IPW_DEBUG_FW("<< :\n");
2575 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2578 u32 register_value = 0;
2579 u32 cb_fields_address = 0;
2581 IPW_DEBUG_FW(">> :\n");
2582 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2583 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
2585 /* Read the DMA Controlor register */
2586 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2587 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
2589 /* Print the CB values */
2590 cb_fields_address = address;
2591 register_value = ipw_read_reg32(priv, cb_fields_address);
2592 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
2594 cb_fields_address += sizeof(u32);
2595 register_value = ipw_read_reg32(priv, cb_fields_address);
2596 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
2598 cb_fields_address += sizeof(u32);
2599 register_value = ipw_read_reg32(priv, cb_fields_address);
2600 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2603 cb_fields_address += sizeof(u32);
2604 register_value = ipw_read_reg32(priv, cb_fields_address);
2605 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
2607 IPW_DEBUG_FW(">> :\n");
2610 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2612 u32 current_cb_address = 0;
2613 u32 current_cb_index = 0;
2615 IPW_DEBUG_FW("<< :\n");
2616 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2618 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2619 sizeof(struct command_block);
2621 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
2622 current_cb_index, current_cb_address);
2624 IPW_DEBUG_FW(">> :\n");
2625 return current_cb_index;
2629 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2633 int interrupt_enabled, int is_last)
2636 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2637 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2639 struct command_block *cb;
2640 u32 last_cb_element = 0;
2642 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2643 src_address, dest_address, length);
2645 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2648 last_cb_element = priv->sram_desc.last_cb_index;
2649 cb = &priv->sram_desc.cb_list[last_cb_element];
2650 priv->sram_desc.last_cb_index++;
2652 /* Calculate the new CB control word */
2653 if (interrupt_enabled)
2654 control |= CB_INT_ENABLED;
2657 control |= CB_LAST_VALID;
2661 /* Calculate the CB Element's checksum value */
2662 cb->status = control ^ src_address ^ dest_address;
2664 /* Copy the Source and Destination addresses */
2665 cb->dest_addr = dest_address;
2666 cb->source_addr = src_address;
2668 /* Copy the Control Word last */
2669 cb->control = control;
2674 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
2675 u32 src_phys, u32 dest_address, u32 length)
2677 u32 bytes_left = length;
2679 u32 dest_offset = 0;
2681 IPW_DEBUG_FW(">> \n");
2682 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2683 src_phys, dest_address, length);
2684 while (bytes_left > CB_MAX_LENGTH) {
2685 status = ipw_fw_dma_add_command_block(priv,
2686 src_phys + src_offset,
2689 CB_MAX_LENGTH, 0, 0);
2691 IPW_DEBUG_FW_INFO(": Failed\n");
2694 IPW_DEBUG_FW_INFO(": Added new cb\n");
2696 src_offset += CB_MAX_LENGTH;
2697 dest_offset += CB_MAX_LENGTH;
2698 bytes_left -= CB_MAX_LENGTH;
2701 /* add the buffer tail */
2702 if (bytes_left > 0) {
2704 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2705 dest_address + dest_offset,
2708 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2712 (": Adding new cb - the buffer tail\n");
2715 IPW_DEBUG_FW("<< \n");
2719 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2721 u32 current_index = 0;
2724 IPW_DEBUG_FW(">> : \n");
2726 current_index = ipw_fw_dma_command_block_index(priv);
2727 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%8X\n",
2728 (int)priv->sram_desc.last_cb_index);
2730 while (current_index < priv->sram_desc.last_cb_index) {
2732 current_index = ipw_fw_dma_command_block_index(priv);
2736 if (watchdog > 400) {
2737 IPW_DEBUG_FW_INFO("Timeout\n");
2738 ipw_fw_dma_dump_command_block(priv);
2739 ipw_fw_dma_abort(priv);
2744 ipw_fw_dma_abort(priv);
2746 /*Disable the DMA in the CSR register */
2747 ipw_set_bit(priv, IPW_RESET_REG,
2748 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2750 IPW_DEBUG_FW("<< dmaWaitSync \n");
2754 static void ipw_remove_current_network(struct ipw_priv *priv)
2756 struct list_head *element, *safe;
2757 struct ieee80211_network *network = NULL;
2758 unsigned long flags;
2760 spin_lock_irqsave(&priv->ieee->lock, flags);
2761 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2762 network = list_entry(element, struct ieee80211_network, list);
2763 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2765 list_add_tail(&network->list,
2766 &priv->ieee->network_free_list);
2769 spin_unlock_irqrestore(&priv->ieee->lock, flags);
2773 * Check that card is still alive.
2774 * Reads debug register from domain0.
2775 * If card is present, pre-defined value should
2779 * @return 1 if card is present, 0 otherwise
2781 static inline int ipw_alive(struct ipw_priv *priv)
2783 return ipw_read32(priv, 0x90) == 0xd55555d5;
2786 static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2792 if ((ipw_read32(priv, addr) & mask) == mask)
2796 } while (i < timeout);
2801 /* These functions load the firmware and micro code for the operation of
2802 * the ipw hardware. It assumes the buffer has all the bits for the
2803 * image and the caller is handling the memory allocation and clean up.
2806 static int ipw_stop_master(struct ipw_priv *priv)
2810 IPW_DEBUG_TRACE(">> \n");
2811 /* stop master. typical delay - 0 */
2812 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2814 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2815 IPW_RESET_REG_MASTER_DISABLED, 100);
2817 IPW_ERROR("stop master failed in 10ms\n");
2821 IPW_DEBUG_INFO("stop master %dms\n", rc);
2826 static void ipw_arc_release(struct ipw_priv *priv)
2828 IPW_DEBUG_TRACE(">> \n");
2831 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2833 /* no one knows timing, for safety add some delay */
2847 #define IPW_FW_MAJOR_VERSION 2
2848 #define IPW_FW_MINOR_VERSION 3
2850 #define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2851 #define IPW_FW_MAJOR(x) (x & 0xff)
2853 #define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2855 #define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2856 "." __stringify(IPW_FW_MINOR_VERSION) "-"
2858 #if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2859 #define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2861 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2864 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2866 int rc = 0, i, addr;
2870 image = (u16 *) data;
2872 IPW_DEBUG_TRACE(">> \n");
2874 rc = ipw_stop_master(priv);
2879 // spin_lock_irqsave(&priv->lock, flags);
2881 for (addr = IPW_SHARED_LOWER_BOUND;
2882 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2883 ipw_write32(priv, addr, 0);
2886 /* no ucode (yet) */
2887 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2888 /* destroy DMA queues */
2889 /* reset sequence */
2891 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2892 ipw_arc_release(priv);
2893 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2897 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2900 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2903 /* enable ucode store */
2904 ipw_write_reg8(priv, DINO_CONTROL_REG, 0x0);
2905 ipw_write_reg8(priv, DINO_CONTROL_REG, DINO_ENABLE_CS);
2911 * Do NOT set indirect address register once and then
2912 * store data to indirect data register in the loop.
2913 * It seems very reasonable, but in this case DINO do not
2914 * accept ucode. It is essential to set address each time.
2916 /* load new ipw uCode */
2917 for (i = 0; i < len / 2; i++)
2918 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2919 cpu_to_le16(image[i]));
2922 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2923 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2925 /* this is where the igx / win driver deveates from the VAP driver. */
2927 /* wait for alive response */
2928 for (i = 0; i < 100; i++) {
2929 /* poll for incoming data */
2930 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2931 if (cr & DINO_RXFIFO_DATA)
2936 if (cr & DINO_RXFIFO_DATA) {
2937 /* alive_command_responce size is NOT multiple of 4 */
2938 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2940 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2941 response_buffer[i] =
2942 le32_to_cpu(ipw_read_reg32(priv,
2943 IPW_BASEBAND_RX_FIFO_READ));
2944 memcpy(&priv->dino_alive, response_buffer,
2945 sizeof(priv->dino_alive));
2946 if (priv->dino_alive.alive_command == 1
2947 && priv->dino_alive.ucode_valid == 1) {
2950 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2951 "of %02d/%02d/%02d %02d:%02d\n",
2952 priv->dino_alive.software_revision,
2953 priv->dino_alive.software_revision,
2954 priv->dino_alive.device_identifier,
2955 priv->dino_alive.device_identifier,
2956 priv->dino_alive.time_stamp[0],
2957 priv->dino_alive.time_stamp[1],
2958 priv->dino_alive.time_stamp[2],
2959 priv->dino_alive.time_stamp[3],
2960 priv->dino_alive.time_stamp[4]);
2962 IPW_DEBUG_INFO("Microcode is not alive\n");
2966 IPW_DEBUG_INFO("No alive response from DINO\n");
2970 /* disable DINO, otherwise for some reason
2971 firmware have problem getting alive resp. */
2972 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2974 // spin_unlock_irqrestore(&priv->lock, flags);
2979 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
2983 struct fw_chunk *chunk;
2984 dma_addr_t shared_phys;
2987 IPW_DEBUG_TRACE("<< : \n");
2988 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2993 memmove(shared_virt, data, len);
2996 rc = ipw_fw_dma_enable(priv);
2998 if (priv->sram_desc.last_cb_index > 0) {
2999 /* the DMA is already ready this would be a bug. */
3005 chunk = (struct fw_chunk *)(data + offset);
3006 offset += sizeof(struct fw_chunk);
3007 /* build DMA packet and queue up for sending */
3008 /* dma to chunk->address, the chunk->length bytes from data +
3011 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3012 le32_to_cpu(chunk->address),
3013 le32_to_cpu(chunk->length));
3015 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3019 offset += le32_to_cpu(chunk->length);
3020 } while (offset < len);
3022 /* Run the DMA and wait for the answer */
3023 rc = ipw_fw_dma_kick(priv);
3025 IPW_ERROR("dmaKick Failed\n");
3029 rc = ipw_fw_dma_wait(priv);
3031 IPW_ERROR("dmaWaitSync Failed\n");
3035 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
3040 static int ipw_stop_nic(struct ipw_priv *priv)
3045 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3047 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3048 IPW_RESET_REG_MASTER_DISABLED, 500);
3050 IPW_ERROR("wait for reg master disabled failed\n");
3054 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3059 static void ipw_start_nic(struct ipw_priv *priv)
3061 IPW_DEBUG_TRACE(">>\n");
3063 /* prvHwStartNic release ARC */
3064 ipw_clear_bit(priv, IPW_RESET_REG,
3065 IPW_RESET_REG_MASTER_DISABLED |
3066 IPW_RESET_REG_STOP_MASTER |
3067 CBD_RESET_REG_PRINCETON_RESET);
3069 /* enable power management */
3070 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3071 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3073 IPW_DEBUG_TRACE("<<\n");
3076 static int ipw_init_nic(struct ipw_priv *priv)
3080 IPW_DEBUG_TRACE(">>\n");
3083 /* set "initialization complete" bit to move adapter to D0 state */
3084 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3086 /* low-level PLL activation */
3087 ipw_write32(priv, IPW_READ_INT_REGISTER,
3088 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3090 /* wait for clock stabilization */
3091 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3092 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3094 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3096 /* assert SW reset */
3097 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3101 /* set "initialization complete" bit to move adapter to D0 state */
3102 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3104 IPW_DEBUG_TRACE(">>\n");
3108 /* Call this function from process context, it will sleep in request_firmware.
3109 * Probe is an ok place to call this from.
3111 static int ipw_reset_nic(struct ipw_priv *priv)
3114 unsigned long flags;
3116 IPW_DEBUG_TRACE(">>\n");
3118 rc = ipw_init_nic(priv);
3120 spin_lock_irqsave(&priv->lock, flags);
3121 /* Clear the 'host command active' bit... */
3122 priv->status &= ~STATUS_HCMD_ACTIVE;
3123 wake_up_interruptible(&priv->wait_command_queue);
3124 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3125 wake_up_interruptible(&priv->wait_state);
3126 spin_unlock_irqrestore(&priv->lock, flags);
3128 IPW_DEBUG_TRACE("<<\n");
3132 static int ipw_get_fw(struct ipw_priv *priv,
3133 const struct firmware **fw, const char *name)
3135 struct fw_header *header;
3138 /* ask firmware_class module to get the boot firmware off disk */
3139 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3141 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3145 header = (struct fw_header *)(*fw)->data;
3146 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
3147 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3149 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3150 IPW_FW_MAJOR_VERSION);
3154 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
3156 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3157 IPW_FW_MINOR(le32_to_cpu(header->version)),
3158 (*fw)->size - sizeof(struct fw_header));
3162 #define IPW_RX_BUF_SIZE (3000)
3164 static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
3165 struct ipw_rx_queue *rxq)
3167 unsigned long flags;
3170 spin_lock_irqsave(&rxq->lock, flags);
3172 INIT_LIST_HEAD(&rxq->rx_free);
3173 INIT_LIST_HEAD(&rxq->rx_used);
3175 /* Fill the rx_used queue with _all_ of the Rx buffers */
3176 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3177 /* In the reset function, these buffers may have been allocated
3178 * to an SKB, so we need to unmap and free potential storage */
3179 if (rxq->pool[i].skb != NULL) {
3180 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3181 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3182 dev_kfree_skb(rxq->pool[i].skb);
3183 rxq->pool[i].skb = NULL;
3185 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3188 /* Set us so that we have processed and used all buffers, but have
3189 * not restocked the Rx queue with fresh buffers */
3190 rxq->read = rxq->write = 0;
3191 rxq->processed = RX_QUEUE_SIZE - 1;
3192 rxq->free_count = 0;
3193 spin_unlock_irqrestore(&rxq->lock, flags);
3197 static int fw_loaded = 0;
3198 static const struct firmware *bootfw = NULL;
3199 static const struct firmware *firmware = NULL;
3200 static const struct firmware *ucode = NULL;
3202 static void free_firmware(void)
3205 release_firmware(bootfw);
3206 release_firmware(ucode);
3207 release_firmware(firmware);
3208 bootfw = ucode = firmware = NULL;
3213 #define free_firmware() do {} while (0)
3216 static int ipw_load(struct ipw_priv *priv)
3219 const struct firmware *bootfw = NULL;
3220 const struct firmware *firmware = NULL;
3221 const struct firmware *ucode = NULL;
3223 int rc = 0, retries = 3;
3228 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3232 switch (priv->ieee->iw_mode) {
3234 rc = ipw_get_fw(priv, &ucode,
3235 IPW_FW_NAME("ibss_ucode"));
3239 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
3242 #ifdef CONFIG_IPW2200_MONITOR
3243 case IW_MODE_MONITOR:
3244 rc = ipw_get_fw(priv, &ucode,
3245 IPW_FW_NAME("sniffer_ucode"));
3249 rc = ipw_get_fw(priv, &firmware,
3250 IPW_FW_NAME("sniffer"));
3254 rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
3258 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("bss"));
3274 priv->rxq = ipw_rx_queue_alloc(priv);
3276 ipw_rx_queue_reset(priv, priv->rxq);
3278 IPW_ERROR("Unable to initialize Rx queue\n");
3283 /* Ensure interrupts are disabled */
3284 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3285 priv->status &= ~STATUS_INT_ENABLED;
3287 /* ack pending interrupts */
3288 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3292 rc = ipw_reset_nic(priv);
3294 IPW_ERROR("Unable to reset NIC\n");
3298 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3299 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3301 /* DMA the initial boot firmware into the device */
3302 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
3303 bootfw->size - sizeof(struct fw_header));
3305 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3309 /* kick start the device */
3310 ipw_start_nic(priv);
3312 /* wait for the device to finish it's initial startup sequence */
3313 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3314 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3316 IPW_ERROR("device failed to boot initial fw image\n");
3319 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3321 /* ack fw init done interrupt */
3322 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3324 /* DMA the ucode into the device */
3325 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
3326 ucode->size - sizeof(struct fw_header));
3328 IPW_ERROR("Unable to load ucode: %d\n", rc);
3335 /* DMA bss firmware into the device */
3336 rc = ipw_load_firmware(priv, firmware->data +
3337 sizeof(struct fw_header),
3338 firmware->size - sizeof(struct fw_header));
3340 IPW_ERROR("Unable to load firmware: %d\n", rc);
3344 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3346 rc = ipw_queue_reset(priv);
3348 IPW_ERROR("Unable to initialize queues\n");
3352 /* Ensure interrupts are disabled */
3353 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3354 /* ack pending interrupts */
3355 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3357 /* kick start the device */
3358 ipw_start_nic(priv);
3360 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3362 IPW_WARNING("Parity error. Retrying init.\n");
3367 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3372 /* wait for the device */
3373 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3374 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3376 IPW_ERROR("device failed to start after 500ms\n");
3379 IPW_DEBUG_INFO("device response after %dms\n", rc);
3381 /* ack fw init done interrupt */
3382 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3384 /* read eeprom data and initialize the eeprom region of sram */
3385 priv->eeprom_delay = 1;
3386 ipw_eeprom_init_sram(priv);
3388 /* enable interrupts */
3389 ipw_enable_interrupts(priv);
3391 /* Ensure our queue has valid packets */
3392 ipw_rx_queue_replenish(priv);
3394 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3396 /* ack pending interrupts */
3397 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3400 release_firmware(bootfw);
3401 release_firmware(ucode);
3402 release_firmware(firmware);
3408 ipw_rx_queue_free(priv, priv->rxq);
3411 ipw_tx_queue_free(priv);
3413 release_firmware(bootfw);
3415 release_firmware(ucode);
3417 release_firmware(firmware);
3420 bootfw = ucode = firmware = NULL;
3429 * Theory of operation
3431 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3432 * 2 empty entries always kept in the buffer to protect from overflow.
3434 * For Tx queue, there are low mark and high mark limits. If, after queuing
3435 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3436 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3439 * The IPW operates with six queues, one receive queue in the device's
3440 * sram, one transmit queue for sending commands to the device firmware,
3441 * and four transmit queues for data.
3443 * The four transmit queues allow for performing quality of service (qos)
3444 * transmissions as per the 802.11 protocol. Currently Linux does not
3445 * provide a mechanism to the user for utilizing prioritized queues, so
3446 * we only utilize the first data transmit queue (queue1).
3450 * Driver allocates buffers of this size for Rx
3453 static inline int ipw_queue_space(const struct clx2_queue *q)
3455 int s = q->last_used - q->first_empty;
3458 s -= 2; /* keep some reserve to not confuse empty and full situations */
3464 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3466 return (++index == n_bd) ? 0 : index;
3470 * Initialize common DMA queue structure
3472 * @param q queue to init
3473 * @param count Number of BD's to allocate. Should be power of 2
3474 * @param read_register Address for 'read' register
3475 * (not offset within BAR, full address)
3476 * @param write_register Address for 'write' register
3477 * (not offset within BAR, full address)
3478 * @param base_register Address for 'base' register
3479 * (not offset within BAR, full address)
3480 * @param size Address for 'size' register
3481 * (not offset within BAR, full address)
3483 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3484 int count, u32 read, u32 write, u32 base, u32 size)
3488 q->low_mark = q->n_bd / 4;
3489 if (q->low_mark < 4)
3492 q->high_mark = q->n_bd / 8;
3493 if (q->high_mark < 2)
3496 q->first_empty = q->last_used = 0;
3500 ipw_write32(priv, base, q->dma_addr);
3501 ipw_write32(priv, size, count);
3502 ipw_write32(priv, read, 0);
3503 ipw_write32(priv, write, 0);
3505 _ipw_read32(priv, 0x90);
3508 static int ipw_queue_tx_init(struct ipw_priv *priv,
3509 struct clx2_tx_queue *q,
3510 int count, u32 read, u32 write, u32 base, u32 size)
3512 struct pci_dev *dev = priv->pci_dev;
3514 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3516 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3521 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3523 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3524 sizeof(q->bd[0]) * count);
3530 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3535 * Free one TFD, those at index [txq->q.last_used].
3536 * Do NOT advance any indexes
3541 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3542 struct clx2_tx_queue *txq)
3544 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3545 struct pci_dev *dev = priv->pci_dev;
3549 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3550 /* nothing to cleanup after for host commands */
3554 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3555 IPW_ERROR("Too many chunks: %i\n",
3556 le32_to_cpu(bd->u.data.num_chunks));
3557 /** @todo issue fatal error, it is quite serious situation */
3561 /* unmap chunks if any */
3562 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3563 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3564 le16_to_cpu(bd->u.data.chunk_len[i]),
3566 if (txq->txb[txq->q.last_used]) {
3567 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3568 txq->txb[txq->q.last_used] = NULL;
3574 * Deallocate DMA queue.
3576 * Empty queue by removing and destroying all BD's.
3582 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3584 struct clx2_queue *q = &txq->q;
3585 struct pci_dev *dev = priv->pci_dev;
3590 /* first, empty all BD's */
3591 for (; q->first_empty != q->last_used;
3592 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3593 ipw_queue_tx_free_tfd(priv, txq);
3596 /* free buffers belonging to queue itself */
3597 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3601 /* 0 fill whole structure */
3602 memset(txq, 0, sizeof(*txq));
3606 * Destroy all DMA queues and structures
3610 static void ipw_tx_queue_free(struct ipw_priv *priv)
3613 ipw_queue_tx_free(priv, &priv->txq_cmd);
3616 ipw_queue_tx_free(priv, &priv->txq[0]);
3617 ipw_queue_tx_free(priv, &priv->txq[1]);
3618 ipw_queue_tx_free(priv, &priv->txq[2]);
3619 ipw_queue_tx_free(priv, &priv->txq[3]);
3622 static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3624 /* First 3 bytes are manufacturer */
3625 bssid[0] = priv->mac_addr[0];
3626 bssid[1] = priv->mac_addr[1];
3627 bssid[2] = priv->mac_addr[2];
3629 /* Last bytes are random */
3630 get_random_bytes(&bssid[3], ETH_ALEN - 3);
3632 bssid[0] &= 0xfe; /* clear multicast bit */
3633 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
3636 static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3638 struct ipw_station_entry entry;
3641 for (i = 0; i < priv->num_stations; i++) {
3642 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3643 /* Another node is active in network */
3644 priv->missed_adhoc_beacons = 0;
3645 if (!(priv->config & CFG_STATIC_CHANNEL))
3646 /* when other nodes drop out, we drop out */
3647 priv->config &= ~CFG_ADHOC_PERSIST;
3653 if (i == MAX_STATIONS)
3654 return IPW_INVALID_STATION;
3656 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3659 entry.support_mode = 0;
3660 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3661 memcpy(priv->stations[i], bssid, ETH_ALEN);
3662 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3663 &entry, sizeof(entry));
3664 priv->num_stations++;
3669 static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3673 for (i = 0; i < priv->num_stations; i++)
3674 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3677 return IPW_INVALID_STATION;
3680 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3684 if (priv->status & STATUS_ASSOCIATING) {
3685 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3686 queue_work(priv->workqueue, &priv->disassociate);
3690 if (!(priv->status & STATUS_ASSOCIATED)) {
3691 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3695 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3697 MAC_ARG(priv->assoc_request.bssid),
3698 priv->assoc_request.channel);
3701 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3703 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3704 err = ipw_send_associate(priv, &priv->assoc_request);
3706 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3711 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3712 priv->status |= STATUS_DISASSOCIATING;
3716 static int ipw_disassociate(void *data)
3718 struct ipw_priv *priv = data;
3719 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3721 ipw_send_disassociate(data, 0);
3725 static void ipw_bg_disassociate(void *data)
3727 struct ipw_priv *priv = data;
3729 ipw_disassociate(data);
3733 static void ipw_system_config(void *data)
3735 struct ipw_priv *priv = data;
3736 ipw_send_system_config(priv, &priv->sys_config);
3739 struct ipw_status_code {
3744 static const struct ipw_status_code ipw_status_codes[] = {
3745 {0x00, "Successful"},
3746 {0x01, "Unspecified failure"},
3747 {0x0A, "Cannot support all requested capabilities in the "
3748 "Capability information field"},
3749 {0x0B, "Reassociation denied due to inability to confirm that "
3750 "association exists"},
3751 {0x0C, "Association denied due to reason outside the scope of this "
3754 "Responding station does not support the specified authentication "
3757 "Received an Authentication frame with authentication sequence "
3758 "transaction sequence number out of expected sequence"},
3759 {0x0F, "Authentication rejected because of challenge failure"},
3760 {0x10, "Authentication rejected due to timeout waiting for next "
3761 "frame in sequence"},
3762 {0x11, "Association denied because AP is unable to handle additional "
3763 "associated stations"},
3765 "Association denied due to requesting station not supporting all "
3766 "of the datarates in the BSSBasicServiceSet Parameter"},
3768 "Association denied due to requesting station not supporting "
3769 "short preamble operation"},
3771 "Association denied due to requesting station not supporting "
3774 "Association denied due to requesting station not supporting "
3777 "Association denied due to requesting station not supporting "
3778 "short slot operation"},
3780 "Association denied due to requesting station not supporting "
3781 "DSSS-OFDM operation"},
3782 {0x28, "Invalid Information Element"},
3783 {0x29, "Group Cipher is not valid"},
3784 {0x2A, "Pairwise Cipher is not valid"},
3785 {0x2B, "AKMP is not valid"},
3786 {0x2C, "Unsupported RSN IE version"},
3787 {0x2D, "Invalid RSN IE Capabilities"},
3788 {0x2E, "Cipher suite is rejected per security policy"},
3791 #ifdef CONFIG_IPW_DEBUG
3792 static const char *ipw_get_status_code(u16 status)
3795 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3796 if (ipw_status_codes[i].status == (status & 0xff))
3797 return ipw_status_codes[i].reason;
3798 return "Unknown status value.";
3802 static void inline average_init(struct average *avg)
3804 memset(avg, 0, sizeof(*avg));
3807 static void inline average_add(struct average *avg, s16 val)
3809 avg->sum -= avg->entries[avg->pos];
3811 avg->entries[avg->pos++] = val;
3812 if (unlikely(avg->pos == AVG_ENTRIES)) {
3818 static s16 inline average_value(struct average *avg)
3820 if (!unlikely(avg->init)) {
3822 return avg->sum / avg->pos;
3826 return avg->sum / AVG_ENTRIES;
3829 static void ipw_reset_stats(struct ipw_priv *priv)
3831 u32 len = sizeof(u32);
3835 average_init(&priv->average_missed_beacons);
3836 average_init(&priv->average_rssi);
3837 average_init(&priv->average_noise);
3839 priv->last_rate = 0;
3840 priv->last_missed_beacons = 0;
3841 priv->last_rx_packets = 0;
3842 priv->last_tx_packets = 0;
3843 priv->last_tx_failures = 0;
3845 /* Firmware managed, reset only when NIC is restarted, so we have to
3846 * normalize on the current value */
3847 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
3848 &priv->last_rx_err, &len);
3849 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
3850 &priv->last_tx_failures, &len);
3852 /* Driver managed, reset with each association */
3853 priv->missed_adhoc_beacons = 0;
3854 priv->missed_beacons = 0;
3855 priv->tx_packets = 0;
3856 priv->rx_packets = 0;
3860 static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
3863 u32 mask = priv->rates_mask;
3864 /* If currently associated in B mode, restrict the maximum
3865 * rate match to B rates */
3866 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3867 mask &= IEEE80211_CCK_RATES_MASK;
3869 /* TODO: Verify that the rate is supported by the current rates
3872 while (i && !(mask & i))
3875 case IEEE80211_CCK_RATE_1MB_MASK:
3877 case IEEE80211_CCK_RATE_2MB_MASK:
3879 case IEEE80211_CCK_RATE_5MB_MASK:
3881 case IEEE80211_OFDM_RATE_6MB_MASK:
3883 case IEEE80211_OFDM_RATE_9MB_MASK:
3885 case IEEE80211_CCK_RATE_11MB_MASK:
3887 case IEEE80211_OFDM_RATE_12MB_MASK:
3889 case IEEE80211_OFDM_RATE_18MB_MASK:
3891 case IEEE80211_OFDM_RATE_24MB_MASK:
3893 case IEEE80211_OFDM_RATE_36MB_MASK:
3895 case IEEE80211_OFDM_RATE_48MB_MASK:
3897 case IEEE80211_OFDM_RATE_54MB_MASK:
3901 if (priv->ieee->mode == IEEE_B)
3907 static u32 ipw_get_current_rate(struct ipw_priv *priv)
3909 u32 rate, len = sizeof(rate);
3912 if (!(priv->status & STATUS_ASSOCIATED))
3915 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3916 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
3919 IPW_DEBUG_INFO("failed querying ordinals.\n");
3923 return ipw_get_max_rate(priv);
3926 case IPW_TX_RATE_1MB:
3928 case IPW_TX_RATE_2MB:
3930 case IPW_TX_RATE_5MB:
3932 case IPW_TX_RATE_6MB:
3934 case IPW_TX_RATE_9MB:
3936 case IPW_TX_RATE_11MB:
3938 case IPW_TX_RATE_12MB:
3940 case IPW_TX_RATE_18MB:
3942 case IPW_TX_RATE_24MB:
3944 case IPW_TX_RATE_36MB:
3946 case IPW_TX_RATE_48MB:
3948 case IPW_TX_RATE_54MB:
3955 #define IPW_STATS_INTERVAL (2 * HZ)
3956 static void ipw_gather_stats(struct ipw_priv *priv)
3958 u32 rx_err, rx_err_delta, rx_packets_delta;
3959 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3960 u32 missed_beacons_percent, missed_beacons_delta;
3962 u32 len = sizeof(u32);
3964 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3968 if (!(priv->status & STATUS_ASSOCIATED)) {
3973 /* Update the statistics */
3974 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
3975 &priv->missed_beacons, &len);
3976 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
3977 priv->last_missed_beacons = priv->missed_beacons;
3978 if (priv->assoc_request.beacon_interval) {
3979 missed_beacons_percent = missed_beacons_delta *
3980 (HZ * priv->assoc_request.beacon_interval) /
3981 (IPW_STATS_INTERVAL * 10);
3983 missed_beacons_percent = 0;
3985 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3987 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3988 rx_err_delta = rx_err - priv->last_rx_err;
3989 priv->last_rx_err = rx_err;
3991 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3992 tx_failures_delta = tx_failures - priv->last_tx_failures;
3993 priv->last_tx_failures = tx_failures;
3995 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
3996 priv->last_rx_packets = priv->rx_packets;
3998 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
3999 priv->last_tx_packets = priv->tx_packets;
4001 /* Calculate quality based on the following:
4003 * Missed beacon: 100% = 0, 0% = 70% missed
4004 * Rate: 60% = 1Mbs, 100% = Max
4005 * Rx and Tx errors represent a straight % of total Rx/Tx
4006 * RSSI: 100% = > -50, 0% = < -80
4007 * Rx errors: 100% = 0, 0% = 50% missed
4009 * The lowest computed quality is used.
4012 #define BEACON_THRESHOLD 5
4013 beacon_quality = 100 - missed_beacons_percent;
4014 if (beacon_quality < BEACON_THRESHOLD)
4017 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4018 (100 - BEACON_THRESHOLD);
4019 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4020 beacon_quality, missed_beacons_percent);
4022 priv->last_rate = ipw_get_current_rate(priv);
4023 max_rate = ipw_get_max_rate(priv);
4024 rate_quality = priv->last_rate * 40 / max_rate + 60;
4025 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4026 rate_quality, priv->last_rate / 1000000);
4028 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4029 rx_quality = 100 - (rx_err_delta * 100) /
4030 (rx_packets_delta + rx_err_delta);
4033 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4034 rx_quality, rx_err_delta, rx_packets_delta);
4036 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4037 tx_quality = 100 - (tx_failures_delta * 100) /
4038 (tx_packets_delta + tx_failures_delta);
4041 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4042 tx_quality, tx_failures_delta, tx_packets_delta);
4044 rssi = average_value(&priv->average_rssi);
4047 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4048 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4049 (priv->ieee->perfect_rssi - rssi) *
4050 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4051 62 * (priv->ieee->perfect_rssi - rssi))) /
4052 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4053 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4054 if (signal_quality > 100)
4055 signal_quality = 100;
4056 else if (signal_quality < 1)
4059 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4060 signal_quality, rssi);
4062 quality = min(beacon_quality,
4064 min(tx_quality, min(rx_quality, signal_quality))));
4065 if (quality == beacon_quality)
4066 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4068 if (quality == rate_quality)
4069 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4071 if (quality == tx_quality)
4072 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4074 if (quality == rx_quality)
4075 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4077 if (quality == signal_quality)
4078 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4081 priv->quality = quality;
4083 queue_delayed_work(priv->workqueue, &priv->gather_stats,
4084 IPW_STATS_INTERVAL);
4087 static void ipw_bg_gather_stats(void *data)
4089 struct ipw_priv *priv = data;
4091 ipw_gather_stats(data);
4095 static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
4098 priv->notif_missed_beacons = missed_count;
4100 if (missed_count > priv->disassociate_threshold &&
4101 priv->status & STATUS_ASSOCIATED) {
4102 /* If associated and we've hit the missed
4103 * beacon threshold, disassociate, turn
4104 * off roaming, and abort any active scans */
4105 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4106 IPW_DL_STATE | IPW_DL_ASSOC,
4107 "Missed beacon: %d - disassociate\n", missed_count);
4108 priv->status &= ~STATUS_ROAMING;
4109 if (priv->status & STATUS_SCANNING) {
4110 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4112 "Aborting scan with missed beacon.\n");
4113 queue_work(priv->workqueue, &priv->abort_scan);
4116 queue_work(priv->workqueue, &priv->disassociate);
4120 if (priv->status & STATUS_ROAMING) {
4121 /* If we are currently roaming, then just
4122 * print a debug statement... */
4123 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4124 "Missed beacon: %d - roam in progress\n",
4129 if (missed_count > priv->roaming_threshold) {
4130 /* If we are not already roaming, set the ROAM
4131 * bit in the status and kick off a scan */
4132 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4133 "Missed beacon: %d - initiate "
4134 "roaming\n", missed_count);
4135 if (!(priv->status & STATUS_ROAMING)) {
4136 priv->status |= STATUS_ROAMING;
4137 if (!(priv->status & STATUS_SCANNING))
4138 queue_work(priv->workqueue,
4139 &priv->request_scan);
4144 if (priv->status & STATUS_SCANNING) {
4145 /* Stop scan to keep fw from getting
4146 * stuck (only if we aren't roaming --
4147 * otherwise we'll never scan more than 2 or 3
4149 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4150 "Aborting scan with missed beacon.\n");
4151 queue_work(priv->workqueue, &priv->abort_scan);
4154 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4159 * Handle host notification packet.
4160 * Called from interrupt routine
4162 static inline void ipw_rx_notification(struct ipw_priv *priv,
4163 struct ipw_rx_notification *notif)
4165 notif->size = le16_to_cpu(notif->size);
4167 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4169 switch (notif->subtype) {
4170 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4171 struct notif_association *assoc = ¬if->u.assoc;
4173 switch (assoc->state) {
4174 case CMAS_ASSOCIATED:{
4175 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4177 "associated: '%s' " MAC_FMT
4179 escape_essid(priv->essid,
4181 MAC_ARG(priv->bssid));
4183 switch (priv->ieee->iw_mode) {
4185 memcpy(priv->ieee->bssid,
4186 priv->bssid, ETH_ALEN);
4190 memcpy(priv->ieee->bssid,
4191 priv->bssid, ETH_ALEN);
4193 /* clear out the station table */
4194 priv->num_stations = 0;
4197 ("queueing adhoc check\n");
4198 queue_delayed_work(priv->
4208 priv->status &= ~STATUS_ASSOCIATING;
4209 priv->status |= STATUS_ASSOCIATED;
4210 queue_work(priv->workqueue,
4211 &priv->system_config);
4213 #ifdef CONFIG_IPW_QOS
4214 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4215 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4216 if ((priv->status & STATUS_AUTH) &&
4217 (IPW_GET_PACKET_STYPE(¬if->u.raw)
4218 == IEEE80211_STYPE_ASSOC_RESP)) {
4221 ieee80211_assoc_response)
4223 && (notif->size <= 2314)) {
4236 ieee80211_rx_mgt(priv->
4241 ¬if->u.raw, &stats);
4246 schedule_work(&priv->link_up);
4251 case CMAS_AUTHENTICATED:{
4253 status & (STATUS_ASSOCIATED |
4255 #ifdef CONFIG_IPW_DEBUG
4256 struct notif_authenticate *auth
4258 IPW_DEBUG(IPW_DL_NOTIF |
4261 "deauthenticated: '%s' "
4263 ": (0x%04X) - %s \n",
4268 MAC_ARG(priv->bssid),
4269 ntohs(auth->status),
4276 ~(STATUS_ASSOCIATING |
4280 schedule_work(&priv->link_down);
4284 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4286 "authenticated: '%s' " MAC_FMT
4288 escape_essid(priv->essid,
4290 MAC_ARG(priv->bssid));
4295 if (priv->status & STATUS_AUTH) {
4297 ieee80211_assoc_response
4301 ieee80211_assoc_response
4303 IPW_DEBUG(IPW_DL_NOTIF |
4306 "association failed (0x%04X): %s\n",
4307 ntohs(resp->status),
4313 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4315 "disassociated: '%s' " MAC_FMT
4317 escape_essid(priv->essid,
4319 MAC_ARG(priv->bssid));
4322 ~(STATUS_DISASSOCIATING |
4323 STATUS_ASSOCIATING |
4324 STATUS_ASSOCIATED | STATUS_AUTH);
4325 if (priv->assoc_network
4326 && (priv->assoc_network->
4328 WLAN_CAPABILITY_IBSS))
4329 ipw_remove_current_network
4332 schedule_work(&priv->link_down);
4337 case CMAS_RX_ASSOC_RESP:
4341 IPW_ERROR("assoc: unknown (%d)\n",
4349 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4350 struct notif_authenticate *auth = ¬if->u.auth;
4351 switch (auth->state) {
4352 case CMAS_AUTHENTICATED:
4353 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4354 "authenticated: '%s' " MAC_FMT " \n",
4355 escape_essid(priv->essid,
4357 MAC_ARG(priv->bssid));
4358 priv->status |= STATUS_AUTH;
4362 if (priv->status & STATUS_AUTH) {
4363 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4365 "authentication failed (0x%04X): %s\n",
4366 ntohs(auth->status),
4367 ipw_get_status_code(ntohs
4371 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4373 "deauthenticated: '%s' " MAC_FMT "\n",
4374 escape_essid(priv->essid,
4376 MAC_ARG(priv->bssid));
4378 priv->status &= ~(STATUS_ASSOCIATING |
4382 schedule_work(&priv->link_down);
4385 case CMAS_TX_AUTH_SEQ_1:
4386 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4387 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4389 case CMAS_RX_AUTH_SEQ_2:
4390 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4391 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4393 case CMAS_AUTH_SEQ_1_PASS:
4394 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4395 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4397 case CMAS_AUTH_SEQ_1_FAIL:
4398 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4399 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4401 case CMAS_TX_AUTH_SEQ_3:
4402 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4403 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4405 case CMAS_RX_AUTH_SEQ_4:
4406 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4407 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4409 case CMAS_AUTH_SEQ_2_PASS:
4410 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4411 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4413 case CMAS_AUTH_SEQ_2_FAIL:
4414 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4415 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4418 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4419 IPW_DL_ASSOC, "TX_ASSOC\n");
4421 case CMAS_RX_ASSOC_RESP:
4422 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4423 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4426 case CMAS_ASSOCIATED:
4427 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4428 IPW_DL_ASSOC, "ASSOCIATED\n");
4431 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4438 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4439 struct notif_channel_result *x =
4440 ¬if->u.channel_result;
4442 if (notif->size == sizeof(*x)) {
4443 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4446 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4447 "(should be %zd)\n",
4448 notif->size, sizeof(*x));
4453 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4454 struct notif_scan_complete *x = ¬if->u.scan_complete;
4455 if (notif->size == sizeof(*x)) {
4457 ("Scan completed: type %d, %d channels, "
4458 "%d status\n", x->scan_type,
4459 x->num_channels, x->status);
4461 IPW_ERROR("Scan completed of wrong size %d "
4462 "(should be %zd)\n",
4463 notif->size, sizeof(*x));
4467 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4469 wake_up_interruptible(&priv->wait_state);
4470 cancel_delayed_work(&priv->scan_check);
4472 if (priv->status & STATUS_EXIT_PENDING)
4475 priv->ieee->scans++;
4477 #ifdef CONFIG_IPW2200_MONITOR
4478 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4479 priv->status |= STATUS_SCAN_FORCED;
4480 queue_work(priv->workqueue,
4481 &priv->request_scan);
4484 priv->status &= ~STATUS_SCAN_FORCED;
4485 #endif /* CONFIG_IPW2200_MONITOR */
4487 if (!(priv->status & (STATUS_ASSOCIATED |
4488 STATUS_ASSOCIATING |
4490 STATUS_DISASSOCIATING)))
4491 queue_work(priv->workqueue, &priv->associate);
4492 else if (priv->status & STATUS_ROAMING) {
4493 /* If a scan completed and we are in roam mode, then
4494 * the scan that completed was the one requested as a
4495 * result of entering roam... so, schedule the
4497 queue_work(priv->workqueue, &priv->roam);
4498 } else if (priv->status & STATUS_SCAN_PENDING)
4499 queue_work(priv->workqueue,
4500 &priv->request_scan);
4501 else if (priv->config & CFG_BACKGROUND_SCAN
4502 && priv->status & STATUS_ASSOCIATED)
4503 queue_delayed_work(priv->workqueue,
4504 &priv->request_scan, HZ);
4508 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4509 struct notif_frag_length *x = ¬if->u.frag_len;
4511 if (notif->size == sizeof(*x))
4512 IPW_ERROR("Frag length: %d\n",
4513 le16_to_cpu(x->frag_length));
4515 IPW_ERROR("Frag length of wrong size %d "
4516 "(should be %zd)\n",
4517 notif->size, sizeof(*x));
4521 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4522 struct notif_link_deterioration *x =
4523 ¬if->u.link_deterioration;
4525 if (notif->size == sizeof(*x)) {
4526 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4527 "link deterioration: '%s' " MAC_FMT
4528 " \n", escape_essid(priv->essid,
4530 MAC_ARG(priv->bssid));
4531 memcpy(&priv->last_link_deterioration, x,
4534 IPW_ERROR("Link Deterioration of wrong size %d "
4535 "(should be %zd)\n",
4536 notif->size, sizeof(*x));
4541 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4542 IPW_ERROR("Dino config\n");
4544 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4545 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4550 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4551 struct notif_beacon_state *x = ¬if->u.beacon_state;
4552 if (notif->size != sizeof(*x)) {
4554 ("Beacon state of wrong size %d (should "
4555 "be %zd)\n", notif->size, sizeof(*x));
4559 if (le32_to_cpu(x->state) ==
4560 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4561 ipw_handle_missed_beacon(priv,
4568 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4569 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4570 if (notif->size == sizeof(*x)) {
4571 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4572 "0x%02x station %d\n",
4573 x->key_state, x->security_type,
4579 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4580 notif->size, sizeof(*x));
4584 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4585 struct notif_calibration *x = ¬if->u.calibration;
4587 if (notif->size == sizeof(*x)) {
4588 memcpy(&priv->calib, x, sizeof(*x));
4589 IPW_DEBUG_INFO("TODO: Calibration\n");
4594 ("Calibration of wrong size %d (should be %zd)\n",
4595 notif->size, sizeof(*x));
4599 case HOST_NOTIFICATION_NOISE_STATS:{
4600 if (notif->size == sizeof(u32)) {
4602 (u8) (le32_to_cpu(notif->u.noise.value) &
4604 average_add(&priv->average_noise,
4610 ("Noise stat is wrong size %d (should be %zd)\n",
4611 notif->size, sizeof(u32));
4616 IPW_ERROR("Unknown notification: "
4617 "subtype=%d,flags=0x%2x,size=%d\n",
4618 notif->subtype, notif->flags, notif->size);
4623 * Destroys all DMA structures and initialise them again
4626 * @return error code
4628 static int ipw_queue_reset(struct ipw_priv *priv)
4631 /** @todo customize queue sizes */
4632 int nTx = 64, nTxCmd = 8;
4633 ipw_tx_queue_free(priv);
4635 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4636 IPW_TX_CMD_QUEUE_READ_INDEX,
4637 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4638 IPW_TX_CMD_QUEUE_BD_BASE,
4639 IPW_TX_CMD_QUEUE_BD_SIZE);
4641 IPW_ERROR("Tx Cmd queue init failed\n");
4645 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4646 IPW_TX_QUEUE_0_READ_INDEX,
4647 IPW_TX_QUEUE_0_WRITE_INDEX,
4648 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4650 IPW_ERROR("Tx 0 queue init failed\n");
4653 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4654 IPW_TX_QUEUE_1_READ_INDEX,
4655 IPW_TX_QUEUE_1_WRITE_INDEX,
4656 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4658 IPW_ERROR("Tx 1 queue init failed\n");
4661 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4662 IPW_TX_QUEUE_2_READ_INDEX,
4663 IPW_TX_QUEUE_2_WRITE_INDEX,
4664 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4666 IPW_ERROR("Tx 2 queue init failed\n");
4669 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4670 IPW_TX_QUEUE_3_READ_INDEX,
4671 IPW_TX_QUEUE_3_WRITE_INDEX,
4672 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4674 IPW_ERROR("Tx 3 queue init failed\n");
4678 priv->rx_bufs_min = 0;
4679 priv->rx_pend_max = 0;
4683 ipw_tx_queue_free(priv);
4688 * Reclaim Tx queue entries no more used by NIC.
4690 * When FW adwances 'R' index, all entries between old and
4691 * new 'R' index need to be reclaimed. As result, some free space
4692 * forms. If there is enough free space (> low mark), wake Tx queue.
4694 * @note Need to protect against garbage in 'R' index
4698 * @return Number of used entries remains in the queue
4700 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4701 struct clx2_tx_queue *txq, int qindex)
4705 struct clx2_queue *q = &txq->q;
4707 hw_tail = ipw_read32(priv, q->reg_r);
4708 if (hw_tail >= q->n_bd) {
4710 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4714 for (; q->last_used != hw_tail;
4715 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4716 ipw_queue_tx_free_tfd(priv, txq);
4720 if ((ipw_queue_space(q) > q->low_mark) &&
4722 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4723 netif_wake_queue(priv->net_dev);
4724 used = q->first_empty - q->last_used;
4731 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4734 struct clx2_tx_queue *txq = &priv->txq_cmd;
4735 struct clx2_queue *q = &txq->q;
4736 struct tfd_frame *tfd;
4738 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4739 IPW_ERROR("No space for Tx\n");
4743 tfd = &txq->bd[q->first_empty];
4744 txq->txb[q->first_empty] = NULL;
4746 memset(tfd, 0, sizeof(*tfd));
4747 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4748 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4750 tfd->u.cmd.index = hcmd;
4751 tfd->u.cmd.length = len;
4752 memcpy(tfd->u.cmd.payload, buf, len);
4753 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4754 ipw_write32(priv, q->reg_w, q->first_empty);
4755 _ipw_read32(priv, 0x90);
4761 * Rx theory of operation
4763 * The host allocates 32 DMA target addresses and passes the host address
4764 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4768 * The host/firmware share two index registers for managing the Rx buffers.
4770 * The READ index maps to the first position that the firmware may be writing
4771 * to -- the driver can read up to (but not including) this position and get
4773 * The READ index is managed by the firmware once the card is enabled.
4775 * The WRITE index maps to the last position the driver has read from -- the
4776 * position preceding WRITE is the last slot the firmware can place a packet.
4778 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4781 * During initialization the host sets up the READ queue position to the first
4782 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4784 * When the firmware places a packet in a buffer it will advance the READ index
4785 * and fire the RX interrupt. The driver can then query the READ index and
4786 * process as many packets as possible, moving the WRITE index forward as it
4787 * resets the Rx queue buffers with new memory.
4789 * The management in the driver is as follows:
4790 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
4791 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4792 * to replensish the ipw->rxq->rx_free.
4793 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4794 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4795 * 'processed' and 'read' driver indexes as well)
4796 * + A received packet is processed and handed to the kernel network stack,
4797 * detached from the ipw->rxq. The driver 'processed' index is updated.
4798 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4799 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4800 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
4801 * were enough free buffers and RX_STALLED is set it is cleared.
4806 * ipw_rx_queue_alloc() Allocates rx_free
4807 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4808 * ipw_rx_queue_restock
4809 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4810 * queue, updates firmware pointers, and updates
4811 * the WRITE index. If insufficient rx_free buffers
4812 * are available, schedules ipw_rx_queue_replenish
4814 * -- enable interrupts --
4815 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
4816 * READ INDEX, detaching the SKB from the pool.
4817 * Moves the packet buffer from queue to rx_used.
4818 * Calls ipw_rx_queue_restock to refill any empty
4825 * If there are slots in the RX queue that need to be restocked,
4826 * and we have free pre-allocated buffers, fill the ranks as much
4827 * as we can pulling from rx_free.
4829 * This moves the 'write' index forward to catch up with 'processed', and
4830 * also updates the memory address in the firmware to reference the new
4833 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4835 struct ipw_rx_queue *rxq = priv->rxq;
4836 struct list_head *element;
4837 struct ipw_rx_mem_buffer *rxb;
4838 unsigned long flags;
4841 spin_lock_irqsave(&rxq->lock, flags);
4843 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4844 element = rxq->rx_free.next;
4845 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4848 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4850 rxq->queue[rxq->write] = rxb;
4851 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4854 spin_unlock_irqrestore(&rxq->lock, flags);
4856 /* If the pre-allocated buffer pool is dropping low, schedule to
4858 if (rxq->free_count <= RX_LOW_WATERMARK)
4859 queue_work(priv->workqueue, &priv->rx_replenish);
4861 /* If we've added more space for the firmware to place data, tell it */
4862 if (write != rxq->write)
4863 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4867 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4868 * Also restock the Rx queue via ipw_rx_queue_restock.
4870 * This is called as a scheduled work item (except for during intialization)
4872 static void ipw_rx_queue_replenish(void *data)
4874 struct ipw_priv *priv = data;
4875 struct ipw_rx_queue *rxq = priv->rxq;
4876 struct list_head *element;
4877 struct ipw_rx_mem_buffer *rxb;
4878 unsigned long flags;
4880 spin_lock_irqsave(&rxq->lock, flags);
4881 while (!list_empty(&rxq->rx_used)) {
4882 element = rxq->rx_used.next;
4883 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4884 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4886 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4887 priv->net_dev->name);
4888 /* We don't reschedule replenish work here -- we will
4889 * call the restock method and if it still needs
4890 * more buffers it will schedule replenish */
4895 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4897 pci_map_single(priv->pci_dev, rxb->skb->data,
4898 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4900 list_add_tail(&rxb->list, &rxq->rx_free);
4903 spin_unlock_irqrestore(&rxq->lock, flags);
4905 ipw_rx_queue_restock(priv);
4908 static void ipw_bg_rx_queue_replenish(void *data)
4910 struct ipw_priv *priv = data;
4912 ipw_rx_queue_replenish(data);
4916 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4917 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL
4918 * This free routine walks the list of POOL entries and if SKB is set to
4919 * non NULL it is unmapped and freed
4921 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4928 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4929 if (rxq->pool[i].skb != NULL) {
4930 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4931 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4932 dev_kfree_skb(rxq->pool[i].skb);
4939 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4941 struct ipw_rx_queue *rxq;
4944 rxq = (struct ipw_rx_queue *)kmalloc(sizeof(*rxq), GFP_KERNEL);
4945 if (unlikely(!rxq)) {
4946 IPW_ERROR("memory allocation failed\n");
4949 memset(rxq, 0, sizeof(*rxq));
4950 spin_lock_init(&rxq->lock);
4951 INIT_LIST_HEAD(&rxq->rx_free);
4952 INIT_LIST_HEAD(&rxq->rx_used);
4954 /* Fill the rx_used queue with _all_ of the Rx buffers */
4955 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
4956 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4958 /* Set us so that we have processed and used all buffers, but have
4959 * not restocked the Rx queue with fresh buffers */
4960 rxq->read = rxq->write = 0;
4961 rxq->processed = RX_QUEUE_SIZE - 1;
4962 rxq->free_count = 0;
4967 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4969 rate &= ~IEEE80211_BASIC_RATE_MASK;
4970 if (ieee_mode == IEEE_A) {
4972 case IEEE80211_OFDM_RATE_6MB:
4973 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4975 case IEEE80211_OFDM_RATE_9MB:
4976 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4978 case IEEE80211_OFDM_RATE_12MB:
4980 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4981 case IEEE80211_OFDM_RATE_18MB:
4983 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
4984 case IEEE80211_OFDM_RATE_24MB:
4986 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
4987 case IEEE80211_OFDM_RATE_36MB:
4989 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
4990 case IEEE80211_OFDM_RATE_48MB:
4992 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
4993 case IEEE80211_OFDM_RATE_54MB:
4995 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5003 case IEEE80211_CCK_RATE_1MB:
5004 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5005 case IEEE80211_CCK_RATE_2MB:
5006 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5007 case IEEE80211_CCK_RATE_5MB:
5008 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5009 case IEEE80211_CCK_RATE_11MB:
5010 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5013 /* If we are limited to B modulations, bail at this point */
5014 if (ieee_mode == IEEE_B)
5019 case IEEE80211_OFDM_RATE_6MB:
5020 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5021 case IEEE80211_OFDM_RATE_9MB:
5022 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5023 case IEEE80211_OFDM_RATE_12MB:
5024 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5025 case IEEE80211_OFDM_RATE_18MB:
5026 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5027 case IEEE80211_OFDM_RATE_24MB:
5028 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5029 case IEEE80211_OFDM_RATE_36MB:
5030 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5031 case IEEE80211_OFDM_RATE_48MB:
5032 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5033 case IEEE80211_OFDM_RATE_54MB:
5034 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5040 static int ipw_compatible_rates(struct ipw_priv *priv,
5041 const struct ieee80211_network *network,
5042 struct ipw_supported_rates *rates)
5046 memset(rates, 0, sizeof(*rates));
5047 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5048 rates->num_rates = 0;
5049 for (i = 0; i < num_rates; i++) {
5050 if (!ipw_is_rate_in_mask(priv, network->mode,
5051 network->rates[i])) {
5053 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5054 IPW_DEBUG_SCAN("Adding masked mandatory "
5057 rates->supported_rates[rates->num_rates++] =
5062 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5063 network->rates[i], priv->rates_mask);
5067 rates->supported_rates[rates->num_rates++] = network->rates[i];
5070 num_rates = min(network->rates_ex_len,
5071 (u8) (IPW_MAX_RATES - num_rates));
5072 for (i = 0; i < num_rates; i++) {
5073 if (!ipw_is_rate_in_mask(priv, network->mode,
5074 network->rates_ex[i])) {
5075 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5076 IPW_DEBUG_SCAN("Adding masked mandatory "
5078 network->rates_ex[i]);
5079 rates->supported_rates[rates->num_rates++] =
5084 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5085 network->rates_ex[i], priv->rates_mask);
5089 rates->supported_rates[rates->num_rates++] =
5090 network->rates_ex[i];
5096 static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
5097 const struct ipw_supported_rates *src)
5100 for (i = 0; i < src->num_rates; i++)
5101 dest->supported_rates[i] = src->supported_rates[i];
5102 dest->num_rates = src->num_rates;
5105 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5106 * mask should ever be used -- right now all callers to add the scan rates are
5107 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5108 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5109 u8 modulation, u32 rate_mask)
5111 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5112 IEEE80211_BASIC_RATE_MASK : 0;
5114 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5115 rates->supported_rates[rates->num_rates++] =
5116 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5118 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5119 rates->supported_rates[rates->num_rates++] =
5120 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5122 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5123 rates->supported_rates[rates->num_rates++] = basic_mask |
5124 IEEE80211_CCK_RATE_5MB;
5126 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5127 rates->supported_rates[rates->num_rates++] = basic_mask |
5128 IEEE80211_CCK_RATE_11MB;
5131 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5132 u8 modulation, u32 rate_mask)
5134 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5135 IEEE80211_BASIC_RATE_MASK : 0;
5137 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5138 rates->supported_rates[rates->num_rates++] = basic_mask |
5139 IEEE80211_OFDM_RATE_6MB;
5141 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5142 rates->supported_rates[rates->num_rates++] =
5143 IEEE80211_OFDM_RATE_9MB;
5145 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5146 rates->supported_rates[rates->num_rates++] = basic_mask |
5147 IEEE80211_OFDM_RATE_12MB;
5149 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5150 rates->supported_rates[rates->num_rates++] =
5151 IEEE80211_OFDM_RATE_18MB;
5153 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5154 rates->supported_rates[rates->num_rates++] = basic_mask |
5155 IEEE80211_OFDM_RATE_24MB;
5157 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5158 rates->supported_rates[rates->num_rates++] =
5159 IEEE80211_OFDM_RATE_36MB;
5161 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5162 rates->supported_rates[rates->num_rates++] =
5163 IEEE80211_OFDM_RATE_48MB;
5165 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5166 rates->supported_rates[rates->num_rates++] =
5167 IEEE80211_OFDM_RATE_54MB;
5170 struct ipw_network_match {
5171 struct ieee80211_network *network;
5172 struct ipw_supported_rates rates;
5175 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5176 struct ipw_network_match *match,
5177 struct ieee80211_network *network,
5180 struct ipw_supported_rates rates;
5182 /* Verify that this network's capability is compatible with the
5183 * current mode (AdHoc or Infrastructure) */
5184 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5185 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5186 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5187 "capability mismatch.\n",
5188 escape_essid(network->ssid, network->ssid_len),
5189 MAC_ARG(network->bssid));
5193 /* If we do not have an ESSID for this AP, we can not associate with
5195 if (network->flags & NETWORK_EMPTY_ESSID) {
5196 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5197 "because of hidden ESSID.\n",
5198 escape_essid(network->ssid, network->ssid_len),
5199 MAC_ARG(network->bssid));
5203 if (unlikely(roaming)) {
5204 /* If we are roaming, then ensure check if this is a valid
5205 * network to try and roam to */
5206 if ((network->ssid_len != match->network->ssid_len) ||
5207 memcmp(network->ssid, match->network->ssid,
5208 network->ssid_len)) {
5209 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5210 "because of non-network ESSID.\n",
5211 escape_essid(network->ssid,
5213 MAC_ARG(network->bssid));
5217 /* If an ESSID has been configured then compare the broadcast
5219 if ((priv->config & CFG_STATIC_ESSID) &&
5220 ((network->ssid_len != priv->essid_len) ||
5221 memcmp(network->ssid, priv->essid,
5222 min(network->ssid_len, priv->essid_len)))) {
5223 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5226 escape_essid(network->ssid, network->ssid_len),
5228 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5229 "because of ESSID mismatch: '%s'.\n",
5230 escaped, MAC_ARG(network->bssid),
5231 escape_essid(priv->essid,
5237 /* If the old network rate is better than this one, don't bother
5238 * testing everything else. */
5240 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5241 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5242 "current network.\n",
5243 escape_essid(match->network->ssid,
5244 match->network->ssid_len));
5246 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5247 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5248 "current network.\n",
5249 escape_essid(match->network->ssid,
5250 match->network->ssid_len));
5254 /* Now go through and see if the requested network is valid... */
5255 if (priv->ieee->scan_age != 0 &&
5256 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5257 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5258 "because of age: %lums.\n",
5259 escape_essid(network->ssid, network->ssid_len),
5260 MAC_ARG(network->bssid),
5261 1000 * (jiffies - network->last_scanned) / HZ);
5265 if ((priv->config & CFG_STATIC_CHANNEL) &&
5266 (network->channel != priv->channel)) {
5267 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5268 "because of channel mismatch: %d != %d.\n",
5269 escape_essid(network->ssid, network->ssid_len),
5270 MAC_ARG(network->bssid),
5271 network->channel, priv->channel);
5275 /* Verify privacy compatability */
5276 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5277 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5278 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5279 "because of privacy mismatch: %s != %s.\n",
5280 escape_essid(network->ssid, network->ssid_len),
5281 MAC_ARG(network->bssid),
5283 capability & CAP_PRIVACY_ON ? "on" : "off",
5285 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5290 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5291 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5292 "because of the same BSSID match: " MAC_FMT
5293 ".\n", escape_essid(network->ssid,
5295 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5299 /* Filter out any incompatible freq / mode combinations */
5300 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5301 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5302 "because of invalid frequency/mode "
5304 escape_essid(network->ssid, network->ssid_len),
5305 MAC_ARG(network->bssid));
5309 /* Ensure that the rates supported by the driver are compatible with
5310 * this AP, including verification of basic rates (mandatory) */
5311 if (!ipw_compatible_rates(priv, network, &rates)) {
5312 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5313 "because configured rate mask excludes "
5314 "AP mandatory rate.\n",
5315 escape_essid(network->ssid, network->ssid_len),
5316 MAC_ARG(network->bssid));
5320 if (rates.num_rates == 0) {
5321 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5322 "because of no compatible rates.\n",
5323 escape_essid(network->ssid, network->ssid_len),
5324 MAC_ARG(network->bssid));
5328 /* TODO: Perform any further minimal comparititive tests. We do not
5329 * want to put too much policy logic here; intelligent scan selection
5330 * should occur within a generic IEEE 802.11 user space tool. */
5332 /* Set up 'new' AP to this network */
5333 ipw_copy_rates(&match->rates, &rates);
5334 match->network = network;
5335 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5336 escape_essid(network->ssid, network->ssid_len),
5337 MAC_ARG(network->bssid));
5342 static void ipw_merge_adhoc_network(void *data)
5344 struct ipw_priv *priv = data;
5345 struct ieee80211_network *network = NULL;
5346 struct ipw_network_match match = {
5347 .network = priv->assoc_network
5350 if ((priv->status & STATUS_ASSOCIATED) &&
5351 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5352 /* First pass through ROAM process -- look for a better
5354 unsigned long flags;
5356 spin_lock_irqsave(&priv->ieee->lock, flags);
5357 list_for_each_entry(network, &priv->ieee->network_list, list) {
5358 if (network != priv->assoc_network)
5359 ipw_find_adhoc_network(priv, &match, network,
5362 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5364 if (match.network == priv->assoc_network) {
5365 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5371 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5372 IPW_DEBUG_MERGE("remove network %s\n",
5373 escape_essid(priv->essid,
5375 ipw_remove_current_network(priv);
5378 ipw_disassociate(priv);
5379 priv->assoc_network = match.network;
5385 static int ipw_best_network(struct ipw_priv *priv,
5386 struct ipw_network_match *match,
5387 struct ieee80211_network *network, int roaming)
5389 struct ipw_supported_rates rates;
5391 /* Verify that this network's capability is compatible with the
5392 * current mode (AdHoc or Infrastructure) */
5393 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5394 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5395 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5396 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5397 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5398 "capability mismatch.\n",
5399 escape_essid(network->ssid, network->ssid_len),
5400 MAC_ARG(network->bssid));
5404 /* If we do not have an ESSID for this AP, we can not associate with
5406 if (network->flags & NETWORK_EMPTY_ESSID) {
5407 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5408 "because of hidden ESSID.\n",
5409 escape_essid(network->ssid, network->ssid_len),
5410 MAC_ARG(network->bssid));
5414 if (unlikely(roaming)) {
5415 /* If we are roaming, then ensure check if this is a valid
5416 * network to try and roam to */
5417 if ((network->ssid_len != match->network->ssid_len) ||
5418 memcmp(network->ssid, match->network->ssid,
5419 network->ssid_len)) {
5420 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5421 "because of non-network ESSID.\n",
5422 escape_essid(network->ssid,
5424 MAC_ARG(network->bssid));
5428 /* If an ESSID has been configured then compare the broadcast
5430 if ((priv->config & CFG_STATIC_ESSID) &&
5431 ((network->ssid_len != priv->essid_len) ||
5432 memcmp(network->ssid, priv->essid,
5433 min(network->ssid_len, priv->essid_len)))) {
5434 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5436 escape_essid(network->ssid, network->ssid_len),
5438 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5439 "because of ESSID mismatch: '%s'.\n",
5440 escaped, MAC_ARG(network->bssid),
5441 escape_essid(priv->essid,
5447 /* If the old network rate is better than this one, don't bother
5448 * testing everything else. */
5449 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5450 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5452 escape_essid(network->ssid, network->ssid_len),
5454 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5455 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5456 escaped, MAC_ARG(network->bssid),
5457 escape_essid(match->network->ssid,
5458 match->network->ssid_len),
5459 MAC_ARG(match->network->bssid));
5463 /* If this network has already had an association attempt within the
5464 * last 3 seconds, do not try and associate again... */
5465 if (network->last_associate &&
5466 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5467 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5468 "because of storming (%lus since last "
5469 "assoc attempt).\n",
5470 escape_essid(network->ssid, network->ssid_len),
5471 MAC_ARG(network->bssid),
5472 (jiffies - network->last_associate) / HZ);
5476 /* Now go through and see if the requested network is valid... */
5477 if (priv->ieee->scan_age != 0 &&
5478 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5479 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5480 "because of age: %lums.\n",
5481 escape_essid(network->ssid, network->ssid_len),
5482 MAC_ARG(network->bssid),
5483 1000 * (jiffies - network->last_scanned) / HZ);
5487 if ((priv->config & CFG_STATIC_CHANNEL) &&
5488 (network->channel != priv->channel)) {
5489 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5490 "because of channel mismatch: %d != %d.\n",
5491 escape_essid(network->ssid, network->ssid_len),
5492 MAC_ARG(network->bssid),
5493 network->channel, priv->channel);
5497 /* Verify privacy compatability */
5498 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5499 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5500 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5501 "because of privacy mismatch: %s != %s.\n",
5502 escape_essid(network->ssid, network->ssid_len),
5503 MAC_ARG(network->bssid),
5504 priv->capability & CAP_PRIVACY_ON ? "on" :
5506 network->capability &
5507 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5511 if (!priv->ieee->wpa_enabled && (network->wpa_ie_len > 0 ||
5512 network->rsn_ie_len > 0)) {
5513 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5514 "because of WPA capability mismatch.\n",
5515 escape_essid(network->ssid, network->ssid_len),
5516 MAC_ARG(network->bssid));
5520 if ((priv->config & CFG_STATIC_BSSID) &&
5521 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5522 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5523 "because of BSSID mismatch: " MAC_FMT ".\n",
5524 escape_essid(network->ssid, network->ssid_len),
5525 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5529 /* Filter out any incompatible freq / mode combinations */
5530 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5531 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5532 "because of invalid frequency/mode "
5534 escape_essid(network->ssid, network->ssid_len),
5535 MAC_ARG(network->bssid));
5539 /* Filter out invalid channel in current GEO */
5540 if (!ipw_is_valid_channel(priv->ieee, network->channel)) {
5541 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5542 "because of invalid channel in current GEO\n",
5543 escape_essid(network->ssid, network->ssid_len),
5544 MAC_ARG(network->bssid));
5548 /* Ensure that the rates supported by the driver are compatible with
5549 * this AP, including verification of basic rates (mandatory) */
5550 if (!ipw_compatible_rates(priv, network, &rates)) {
5551 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5552 "because configured rate mask excludes "
5553 "AP mandatory rate.\n",
5554 escape_essid(network->ssid, network->ssid_len),
5555 MAC_ARG(network->bssid));
5559 if (rates.num_rates == 0) {
5560 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5561 "because of no compatible rates.\n",
5562 escape_essid(network->ssid, network->ssid_len),
5563 MAC_ARG(network->bssid));
5567 /* TODO: Perform any further minimal comparititive tests. We do not
5568 * want to put too much policy logic here; intelligent scan selection
5569 * should occur within a generic IEEE 802.11 user space tool. */
5571 /* Set up 'new' AP to this network */
5572 ipw_copy_rates(&match->rates, &rates);
5573 match->network = network;
5575 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5576 escape_essid(network->ssid, network->ssid_len),
5577 MAC_ARG(network->bssid));
5582 static void ipw_adhoc_create(struct ipw_priv *priv,
5583 struct ieee80211_network *network)
5585 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5589 * For the purposes of scanning, we can set our wireless mode
5590 * to trigger scans across combinations of bands, but when it
5591 * comes to creating a new ad-hoc network, we have tell the FW
5592 * exactly which band to use.
5594 * We also have the possibility of an invalid channel for the
5595 * chossen band. Attempting to create a new ad-hoc network
5596 * with an invalid channel for wireless mode will trigger a
5600 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
5601 case IEEE80211_52GHZ_BAND:
5602 network->mode = IEEE_A;
5603 i = ipw_channel_to_index(priv->ieee, priv->channel);
5606 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5607 IPW_WARNING("Overriding invalid channel\n");
5608 priv->channel = geo->a[0].channel;
5612 case IEEE80211_24GHZ_BAND:
5613 if (priv->ieee->mode & IEEE_G)
5614 network->mode = IEEE_G;
5616 network->mode = IEEE_B;
5617 i = ipw_channel_to_index(priv->ieee, priv->channel);
5620 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5621 IPW_WARNING("Overriding invalid channel\n");
5622 priv->channel = geo->bg[0].channel;
5627 IPW_WARNING("Overriding invalid channel\n");
5628 if (priv->ieee->mode & IEEE_A) {
5629 network->mode = IEEE_A;
5630 priv->channel = geo->a[0].channel;
5631 } else if (priv->ieee->mode & IEEE_G) {
5632 network->mode = IEEE_G;
5633 priv->channel = geo->bg[0].channel;
5635 network->mode = IEEE_B;
5636 priv->channel = geo->bg[0].channel;
5641 network->channel = priv->channel;
5642 priv->config |= CFG_ADHOC_PERSIST;
5643 ipw_create_bssid(priv, network->bssid);
5644 network->ssid_len = priv->essid_len;
5645 memcpy(network->ssid, priv->essid, priv->essid_len);
5646 memset(&network->stats, 0, sizeof(network->stats));
5647 network->capability = WLAN_CAPABILITY_IBSS;
5648 if (!(priv->config & CFG_PREAMBLE_LONG))
5649 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5650 if (priv->capability & CAP_PRIVACY_ON)
5651 network->capability |= WLAN_CAPABILITY_PRIVACY;
5652 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5653 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5654 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5655 memcpy(network->rates_ex,
5656 &priv->rates.supported_rates[network->rates_len],
5657 network->rates_ex_len);
5658 network->last_scanned = 0;
5660 network->last_associate = 0;
5661 network->time_stamp[0] = 0;
5662 network->time_stamp[1] = 0;
5663 network->beacon_interval = 100; /* Default */
5664 network->listen_interval = 10; /* Default */
5665 network->atim_window = 0; /* Default */
5666 network->wpa_ie_len = 0;
5667 network->rsn_ie_len = 0;
5670 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5672 struct ipw_tgi_tx_key *key;
5673 struct host_cmd cmd = {
5674 .cmd = IPW_CMD_TGI_TX_KEY,
5678 if (!(priv->ieee->sec.flags & (1 << index)))
5681 key = (struct ipw_tgi_tx_key *)&cmd.param;
5682 key->key_id = index;
5683 memcpy(key->key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5684 key->security_type = type;
5685 key->station_index = 0; /* always 0 for BSS */
5687 /* 0 for new key; previous value of counter (after fatal error) */
5688 key->tx_counter[0] = 0;
5689 key->tx_counter[1] = 0;
5691 ipw_send_cmd(priv, &cmd);
5694 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5696 struct ipw_wep_key *key;
5698 struct host_cmd cmd = {
5699 .cmd = IPW_CMD_WEP_KEY,
5703 key = (struct ipw_wep_key *)&cmd.param;
5704 key->cmd_id = DINO_CMD_WEP_KEY;
5707 /* Note: AES keys cannot be set for multiple times.
5708 * Only set it at the first time. */
5709 for (i = 0; i < 4; i++) {
5710 key->key_index = i | type;
5711 if (!(priv->ieee->sec.flags & (1 << i))) {
5716 key->key_size = priv->ieee->sec.key_sizes[i];
5717 memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);
5719 ipw_send_cmd(priv, &cmd);
5723 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5725 if (priv->ieee->host_encrypt)
5730 priv->sys_config.disable_unicast_decryption = 0;
5731 priv->ieee->host_decrypt = 0;
5734 priv->sys_config.disable_unicast_decryption = 1;
5735 priv->ieee->host_decrypt = 1;
5738 priv->sys_config.disable_unicast_decryption = 0;
5739 priv->ieee->host_decrypt = 0;
5742 priv->sys_config.disable_unicast_decryption = 1;
5749 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5751 if (priv->ieee->host_encrypt)
5756 priv->sys_config.disable_multicast_decryption = 0;
5759 priv->sys_config.disable_multicast_decryption = 1;
5762 priv->sys_config.disable_multicast_decryption = 0;
5765 priv->sys_config.disable_multicast_decryption = 1;
5772 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5774 switch (priv->ieee->sec.level) {
5776 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5777 ipw_send_tgi_tx_key(priv,
5778 DCT_FLAG_EXT_SECURITY_CCM,
5779 priv->ieee->sec.active_key);
5781 if (!priv->ieee->host_mc_decrypt)
5782 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5785 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5786 ipw_send_tgi_tx_key(priv,
5787 DCT_FLAG_EXT_SECURITY_TKIP,
5788 priv->ieee->sec.active_key);
5791 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5792 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5793 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5801 static void ipw_adhoc_check(void *data)
5803 struct ipw_priv *priv = data;
5805 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5806 !(priv->config & CFG_ADHOC_PERSIST)) {
5807 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5808 IPW_DL_STATE | IPW_DL_ASSOC,
5809 "Missed beacon: %d - disassociate\n",
5810 priv->missed_adhoc_beacons);
5811 ipw_remove_current_network(priv);
5812 ipw_disassociate(priv);
5816 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5817 priv->assoc_request.beacon_interval);
5820 static void ipw_bg_adhoc_check(void *data)
5822 struct ipw_priv *priv = data;
5824 ipw_adhoc_check(data);
5828 #ifdef CONFIG_IPW_DEBUG
5829 static void ipw_debug_config(struct ipw_priv *priv)
5831 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5832 "[CFG 0x%08X]\n", priv->config);
5833 if (priv->config & CFG_STATIC_CHANNEL)
5834 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5836 IPW_DEBUG_INFO("Channel unlocked.\n");
5837 if (priv->config & CFG_STATIC_ESSID)
5838 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5839 escape_essid(priv->essid, priv->essid_len));
5841 IPW_DEBUG_INFO("ESSID unlocked.\n");
5842 if (priv->config & CFG_STATIC_BSSID)
5843 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5844 MAC_ARG(priv->bssid));
5846 IPW_DEBUG_INFO("BSSID unlocked.\n");
5847 if (priv->capability & CAP_PRIVACY_ON)
5848 IPW_DEBUG_INFO("PRIVACY on\n");
5850 IPW_DEBUG_INFO("PRIVACY off\n");
5851 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5854 #define ipw_debug_config(x) do {} while (0)
5857 static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5859 /* TODO: Verify that this works... */
5860 struct ipw_fixed_rate fr = {
5861 .tx_rates = priv->rates_mask
5866 /* Identify 'current FW band' and match it with the fixed
5869 switch (priv->ieee->freq_band) {
5870 case IEEE80211_52GHZ_BAND: /* A only */
5872 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5873 /* Invalid fixed rate mask */
5875 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5880 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5883 default: /* 2.4Ghz or Mixed */
5885 if (mode == IEEE_B) {
5886 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5887 /* Invalid fixed rate mask */
5889 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5896 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5897 IEEE80211_OFDM_RATES_MASK)) {
5898 /* Invalid fixed rate mask */
5900 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5905 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5906 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5907 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5910 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5911 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5912 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5915 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5916 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5917 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5920 fr.tx_rates |= mask;
5924 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5925 ipw_write_reg32(priv, reg, *(u32 *) & fr);
5928 static void ipw_abort_scan(struct ipw_priv *priv)
5932 if (priv->status & STATUS_SCAN_ABORTING) {
5933 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5936 priv->status |= STATUS_SCAN_ABORTING;
5938 err = ipw_send_scan_abort(priv);
5940 IPW_DEBUG_HC("Request to abort scan failed.\n");
5943 static void ipw_add_scan_channels(struct ipw_priv *priv,
5944 struct ipw_scan_request_ext *scan,
5947 int channel_index = 0;
5948 const struct ieee80211_geo *geo;
5951 geo = ipw_get_geo(priv->ieee);
5953 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5954 int start = channel_index;
5955 for (i = 0; i < geo->a_channels; i++) {
5956 if ((priv->status & STATUS_ASSOCIATED) &&
5957 geo->a[i].channel == priv->channel)
5960 scan->channels_list[channel_index] = geo->a[i].channel;
5961 ipw_set_scan_type(scan, channel_index,
5963 flags & IEEE80211_CH_PASSIVE_ONLY ?
5964 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5968 if (start != channel_index) {
5969 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5970 (channel_index - start);
5975 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5976 int start = channel_index;
5977 if (priv->config & CFG_SPEED_SCAN) {
5979 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5980 /* nop out the list */
5985 while (channel_index < IPW_SCAN_CHANNELS) {
5987 priv->speed_scan[priv->speed_scan_pos];
5989 priv->speed_scan_pos = 0;
5990 channel = priv->speed_scan[0];
5992 if ((priv->status & STATUS_ASSOCIATED) &&
5993 channel == priv->channel) {
5994 priv->speed_scan_pos++;
5998 /* If this channel has already been
5999 * added in scan, break from loop
6000 * and this will be the first channel
6003 if (channels[channel - 1] != 0)
6006 channels[channel - 1] = 1;
6007 priv->speed_scan_pos++;
6009 scan->channels_list[channel_index] = channel;
6011 ipw_channel_to_index(priv->ieee, channel);
6012 ipw_set_scan_type(scan, channel_index,
6015 IEEE80211_CH_PASSIVE_ONLY ?
6016 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6020 for (i = 0; i < geo->bg_channels; i++) {
6021 if ((priv->status & STATUS_ASSOCIATED) &&
6022 geo->bg[i].channel == priv->channel)
6025 scan->channels_list[channel_index] =
6027 ipw_set_scan_type(scan, channel_index,
6030 IEEE80211_CH_PASSIVE_ONLY ?
6031 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6036 if (start != channel_index) {
6037 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6038 (channel_index - start);
6043 static int ipw_request_scan(struct ipw_priv *priv)
6045 struct ipw_scan_request_ext scan;
6046 int err = 0, scan_type;
6048 if (!(priv->status & STATUS_INIT) ||
6049 (priv->status & STATUS_EXIT_PENDING))
6054 if (priv->status & STATUS_SCANNING) {
6055 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
6056 priv->status |= STATUS_SCAN_PENDING;
6060 if (!(priv->status & STATUS_SCAN_FORCED) &&
6061 priv->status & STATUS_SCAN_ABORTING) {
6062 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6063 priv->status |= STATUS_SCAN_PENDING;
6067 if (priv->status & STATUS_RF_KILL_MASK) {
6068 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6069 priv->status |= STATUS_SCAN_PENDING;
6073 memset(&scan, 0, sizeof(scan));
6075 if (priv->config & CFG_SPEED_SCAN)
6076 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6079 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6082 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6084 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6086 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6088 #ifdef CONFIG_IPW2200_MONITOR
6089 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6093 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
6094 case IEEE80211_52GHZ_BAND:
6095 band = (u8) (IPW_A_MODE << 6) | 1;
6096 channel = priv->channel;
6099 case IEEE80211_24GHZ_BAND:
6100 band = (u8) (IPW_B_MODE << 6) | 1;
6101 channel = priv->channel;
6105 band = (u8) (IPW_B_MODE << 6) | 1;
6110 scan.channels_list[0] = band;
6111 scan.channels_list[1] = channel;
6112 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6114 /* NOTE: The card will sit on this channel for this time
6115 * period. Scan aborts are timing sensitive and frequently
6116 * result in firmware restarts. As such, it is best to
6117 * set a small dwell_time here and just keep re-issuing
6118 * scans. Otherwise fast channel hopping will not actually
6121 * TODO: Move SPEED SCAN support to all modes and bands */
6122 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6125 #endif /* CONFIG_IPW2200_MONITOR */
6126 /* If we are roaming, then make this a directed scan for the
6127 * current network. Otherwise, ensure that every other scan
6128 * is a fast channel hop scan */
6129 if ((priv->status & STATUS_ROAMING)
6130 || (!(priv->status & STATUS_ASSOCIATED)
6131 && (priv->config & CFG_STATIC_ESSID)
6132 && (le32_to_cpu(scan.full_scan_index) % 2))) {
6133 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6135 IPW_DEBUG_HC("Attempt to send SSID command "
6140 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6142 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6144 ipw_add_scan_channels(priv, &scan, scan_type);
6145 #ifdef CONFIG_IPW2200_MONITOR
6149 err = ipw_send_scan_request_ext(priv, &scan);
6151 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6155 priv->status |= STATUS_SCANNING;
6156 priv->status &= ~STATUS_SCAN_PENDING;
6157 queue_delayed_work(priv->workqueue, &priv->scan_check,
6158 IPW_SCAN_CHECK_WATCHDOG);
6164 static void ipw_bg_abort_scan(void *data)
6166 struct ipw_priv *priv = data;
6168 ipw_abort_scan(data);
6172 #if WIRELESS_EXT < 18
6173 /* Support for wpa_supplicant before WE-18, deprecated. */
6175 /* following definitions must match definitions in driver_ipw.c */
6177 #define IPW_IOCTL_WPA_SUPPLICANT SIOCIWFIRSTPRIV+30
6179 #define IPW_CMD_SET_WPA_PARAM 1
6180 #define IPW_CMD_SET_WPA_IE 2
6181 #define IPW_CMD_SET_ENCRYPTION 3
6182 #define IPW_CMD_MLME 4
6184 #define IPW_PARAM_WPA_ENABLED 1
6185 #define IPW_PARAM_TKIP_COUNTERMEASURES 2
6186 #define IPW_PARAM_DROP_UNENCRYPTED 3
6187 #define IPW_PARAM_PRIVACY_INVOKED 4
6188 #define IPW_PARAM_AUTH_ALGS 5
6189 #define IPW_PARAM_IEEE_802_1X 6
6191 #define IPW_MLME_STA_DEAUTH 1
6192 #define IPW_MLME_STA_DISASSOC 2
6194 #define IPW_CRYPT_ERR_UNKNOWN_ALG 2
6195 #define IPW_CRYPT_ERR_UNKNOWN_ADDR 3
6196 #define IPW_CRYPT_ERR_CRYPT_INIT_FAILED 4
6197 #define IPW_CRYPT_ERR_KEY_SET_FAILED 5
6198 #define IPW_CRYPT_ERR_TX_KEY_SET_FAILED 6
6199 #define IPW_CRYPT_ERR_CARD_CONF_FAILED 7
6201 #define IPW_CRYPT_ALG_NAME_LEN 16
6205 u8 sta_addr[ETH_ALEN];
6221 u8 alg[IPW_CRYPT_ALG_NAME_LEN];
6225 u8 seq[8]; /* sequence counter (set: RX, get: TX) */
6233 /* end of driver_ipw.c code */
6236 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6238 /* This is called when wpa_supplicant loads and closes the driver
6240 priv->ieee->wpa_enabled = value;
6244 #if WIRELESS_EXT < 18
6245 #define IW_AUTH_ALG_OPEN_SYSTEM 0x1
6246 #define IW_AUTH_ALG_SHARED_KEY 0x2
6249 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6251 struct ieee80211_device *ieee = priv->ieee;
6252 struct ieee80211_security sec = {
6253 .flags = SEC_AUTH_MODE,
6257 if (value & IW_AUTH_ALG_SHARED_KEY) {
6258 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6260 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6261 sec.auth_mode = WLAN_AUTH_OPEN;
6266 if (ieee->set_security)
6267 ieee->set_security(ieee->dev, &sec);
6274 void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie, int wpa_ie_len)
6276 /* make sure WPA is enabled */
6277 ipw_wpa_enable(priv, 1);
6279 ipw_disassociate(priv);
6282 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6283 char *capabilities, int length)
6285 struct host_cmd cmd = {
6286 .cmd = IPW_CMD_RSN_CAPABILITIES,
6290 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6292 memcpy(cmd.param, capabilities, length);
6293 return ipw_send_cmd(priv, &cmd);
6296 #if WIRELESS_EXT < 18
6297 static int ipw_wpa_set_param(struct net_device *dev, u8 name, u32 value)
6299 struct ipw_priv *priv = ieee80211_priv(dev);
6300 struct ieee80211_crypt_data *crypt;
6301 unsigned long flags;
6305 case IPW_PARAM_WPA_ENABLED:
6306 ret = ipw_wpa_enable(priv, value);
6309 case IPW_PARAM_TKIP_COUNTERMEASURES:
6310 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6311 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) {
6312 IPW_WARNING("Can't set TKIP countermeasures: "
6313 "crypt not set!\n");
6317 flags = crypt->ops->get_flags(crypt->priv);
6320 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6322 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6324 crypt->ops->set_flags(flags, crypt->priv);
6328 case IPW_PARAM_DROP_UNENCRYPTED:{
6331 * wpa_supplicant calls set_wpa_enabled when the driver
6332 * is loaded and unloaded, regardless of if WPA is being
6333 * used. No other calls are made which can be used to
6334 * determine if encryption will be used or not prior to
6335 * association being expected. If encryption is not being
6336 * used, drop_unencrypted is set to false, else true -- we
6337 * can use this to determine if the CAP_PRIVACY_ON bit should
6340 struct ieee80211_security sec = {
6341 .flags = SEC_ENABLED,
6344 priv->ieee->drop_unencrypted = value;
6345 /* We only change SEC_LEVEL for open mode. Others
6346 * are set by ipw_wpa_set_encryption.
6349 sec.flags |= SEC_LEVEL;
6350 sec.level = SEC_LEVEL_0;
6352 sec.flags |= SEC_LEVEL;
6353 sec.level = SEC_LEVEL_1;
6355 if (priv->ieee->set_security)
6356 priv->ieee->set_security(priv->ieee->dev, &sec);
6360 case IPW_PARAM_PRIVACY_INVOKED:
6361 priv->ieee->privacy_invoked = value;
6364 case IPW_PARAM_AUTH_ALGS:
6365 ret = ipw_wpa_set_auth_algs(priv, value);
6368 case IPW_PARAM_IEEE_802_1X:
6369 priv->ieee->ieee802_1x = value;
6373 IPW_ERROR("%s: Unknown WPA param: %d\n", dev->name, name);
6380 static int ipw_wpa_mlme(struct net_device *dev, int command, int reason)
6382 struct ipw_priv *priv = ieee80211_priv(dev);
6386 case IPW_MLME_STA_DEAUTH:
6390 case IPW_MLME_STA_DISASSOC:
6391 ipw_disassociate(priv);
6395 IPW_ERROR("%s: Unknown MLME request: %d\n", dev->name, command);
6402 static int ipw_wpa_ie_cipher2level(u8 cipher)
6409 case 5: /* WEP104 */
6419 static int ipw_wpa_set_wpa_ie(struct net_device *dev,
6420 struct ipw_param *param, int plen)
6422 struct ipw_priv *priv = ieee80211_priv(dev);
6423 struct ieee80211_device *ieee = priv->ieee;
6428 if (param->u.wpa_ie.len > MAX_WPA_IE_LEN ||
6429 (param->u.wpa_ie.len && param->u.wpa_ie.data == NULL))
6432 if (param->u.wpa_ie.len) {
6433 buf = kmalloc(param->u.wpa_ie.len, GFP_KERNEL);
6437 memcpy(buf, param->u.wpa_ie.data, param->u.wpa_ie.len);
6438 kfree(ieee->wpa_ie);
6440 ieee->wpa_ie_len = param->u.wpa_ie.len;
6442 kfree(ieee->wpa_ie);
6443 ieee->wpa_ie = NULL;
6444 ieee->wpa_ie_len = 0;
6448 if (priv->ieee->host_encrypt)
6451 /* HACK: Parse wpa_ie here to get pairwise suite, otherwise
6452 * we need to change driver_ipw.c from wpa_supplicant. This
6453 * is OK since -Dipw is deprecated. The -Dwext driver has a
6454 * clean way to handle this. */
6455 gtk = ptk = (u8 *) ieee->wpa_ie;
6456 if (ieee->wpa_ie[0] == 0x30) { /* RSN IE */
6458 ptk += 4 + 4 + 2 + 3;
6459 } else { /* WPA IE */
6461 ptk += 8 + 4 + 2 + 3;
6464 if (ptk - (u8 *) ieee->wpa_ie > ieee->wpa_ie_len)
6467 level = ipw_wpa_ie_cipher2level(*gtk);
6468 ipw_set_hw_decrypt_multicast(priv, level);
6470 level = ipw_wpa_ie_cipher2level(*ptk);
6471 ipw_set_hw_decrypt_unicast(priv, level);
6474 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6478 /* implementation borrowed from hostap driver */
6480 static int ipw_wpa_set_encryption(struct net_device *dev,
6481 struct ipw_param *param, int param_len)
6485 struct ipw_priv *priv = ieee80211_priv(dev);
6486 struct ieee80211_device *ieee = priv->ieee;
6487 struct ieee80211_crypto_ops *ops;
6488 struct ieee80211_crypt_data **crypt;
6490 struct ieee80211_security sec = {
6494 param->u.crypt.err = 0;
6495 param->u.crypt.alg[IPW_CRYPT_ALG_NAME_LEN - 1] = '\0';
6498 (int)((char *)param->u.crypt.key - (char *)param) +
6499 param->u.crypt.key_len) {
6500 IPW_DEBUG_INFO("Len mismatch %d, %d\n", param_len,
6501 param->u.crypt.key_len);
6504 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
6505 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
6506 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
6507 if (param->u.crypt.idx >= WEP_KEYS)
6509 crypt = &ieee->crypt[param->u.crypt.idx];
6514 if (param->u.crypt.idx != 0)
6517 sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
6518 if (strcmp(param->u.crypt.alg, "none") == 0) {
6522 sec.level = SEC_LEVEL_0;
6523 sec.flags |= SEC_LEVEL;
6524 ieee80211_crypt_delayed_deinit(ieee, crypt);
6531 /* IPW HW cannot build TKIP MIC, host decryption still needed. */
6532 if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
6534 ieee->host_mc_decrypt = 1;
6536 ieee->host_encrypt_msdu = 1;
6539 /*if (!(ieee->host_encrypt || ieee->host_encrypt_msdu ||
6540 ieee->host_decrypt))
6541 goto skip_host_crypt; */
6542 if (group_key ? !ieee->host_mc_decrypt :
6543 !(ieee->host_encrypt || ieee->host_decrypt ||
6544 ieee->host_encrypt_msdu))
6545 goto skip_host_crypt;
6547 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
6548 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) {
6549 request_module("ieee80211_crypt_wep");
6550 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
6551 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) {
6552 request_module("ieee80211_crypt_tkip");
6553 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
6554 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) {
6555 request_module("ieee80211_crypt_ccmp");
6556 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
6559 IPW_DEBUG_INFO("%s: unknown crypto alg '%s'\n",
6560 dev->name, param->u.crypt.alg);
6561 param->u.crypt.err = IPW_CRYPT_ERR_UNKNOWN_ALG;
6566 if (*crypt == NULL || (*crypt)->ops != ops) {
6567 struct ieee80211_crypt_data *new_crypt;
6569 ieee80211_crypt_delayed_deinit(ieee, crypt);
6571 new_crypt = (struct ieee80211_crypt_data *)
6572 kmalloc(sizeof(*new_crypt), GFP_KERNEL);
6573 if (new_crypt == NULL) {
6577 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
6578 new_crypt->ops = ops;
6579 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
6581 new_crypt->ops->init(param->u.crypt.idx);
6583 if (new_crypt->priv == NULL) {
6585 param->u.crypt.err = IPW_CRYPT_ERR_CRYPT_INIT_FAILED;
6593 if (param->u.crypt.key_len > 0 && (*crypt)->ops->set_key &&
6594 (*crypt)->ops->set_key(param->u.crypt.key,
6595 param->u.crypt.key_len, param->u.crypt.seq,
6596 (*crypt)->priv) < 0) {
6597 IPW_DEBUG_INFO("%s: key setting failed\n", dev->name);
6598 param->u.crypt.err = IPW_CRYPT_ERR_KEY_SET_FAILED;
6604 if (param->u.crypt.set_tx) {
6605 ieee->tx_keyidx = param->u.crypt.idx;
6606 sec.active_key = param->u.crypt.idx;
6607 sec.flags |= SEC_ACTIVE_KEY;
6609 sec.flags &= ~SEC_ACTIVE_KEY;
6611 if (param->u.crypt.alg != NULL) {
6612 memcpy(sec.keys[param->u.crypt.idx],
6613 param->u.crypt.key, param->u.crypt.key_len);
6614 sec.key_sizes[param->u.crypt.idx] = param->u.crypt.key_len;
6615 sec.flags |= (1 << param->u.crypt.idx);
6617 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
6618 sec.flags |= SEC_LEVEL;
6619 sec.level = SEC_LEVEL_1;
6620 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
6621 sec.flags |= SEC_LEVEL;
6622 sec.level = SEC_LEVEL_2;
6623 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
6624 sec.flags |= SEC_LEVEL;
6625 sec.level = SEC_LEVEL_3;
6627 /* Don't set sec level for group keys. */
6629 sec.flags &= ~SEC_LEVEL;
6632 if (ieee->set_security)
6633 ieee->set_security(ieee->dev, &sec);
6635 /* Do not reset port if card is in Managed mode since resetting will
6636 * generate new IEEE 802.11 authentication which may end up in looping
6637 * with IEEE 802.1X. If your hardware requires a reset after WEP
6638 * configuration (for example... Prism2), implement the reset_port in
6639 * the callbacks structures used to initialize the 802.11 stack. */
6640 if (ieee->reset_on_keychange &&
6641 ieee->iw_mode != IW_MODE_INFRA &&
6642 ieee->reset_port && ieee->reset_port(dev)) {
6643 IPW_DEBUG_INFO("%s: reset_port failed\n", dev->name);
6644 param->u.crypt.err = IPW_CRYPT_ERR_CARD_CONF_FAILED;
6651 static int ipw_wpa_supplicant(struct net_device *dev, struct iw_point *p)
6653 struct ipw_param *param;
6654 struct ipw_priv *priv = ieee80211_priv(dev);
6657 IPW_DEBUG_INFO("wpa_supplicant: len=%d\n", p->length);
6659 if (p->length < sizeof(struct ipw_param) || !p->pointer)
6662 param = (struct ipw_param *)kmalloc(p->length, GFP_KERNEL);
6666 if (copy_from_user(param, p->pointer, p->length)) {
6672 switch (param->cmd) {
6674 case IPW_CMD_SET_WPA_PARAM:
6675 ret = ipw_wpa_set_param(dev, param->u.wpa_param.name,
6676 param->u.wpa_param.value);
6679 case IPW_CMD_SET_WPA_IE:
6680 ret = ipw_wpa_set_wpa_ie(dev, param, p->length);
6683 case IPW_CMD_SET_ENCRYPTION:
6684 ret = ipw_wpa_set_encryption(dev, param, p->length);
6688 ret = ipw_wpa_mlme(dev, param->u.mlme.command,
6689 param->u.mlme.reason_code);
6693 IPW_ERROR("%s: Unknown WPA supplicant request: %d\n",
6694 dev->name, param->cmd);
6699 if (ret == 0 && copy_to_user(p->pointer, param, p->length))
6711 static int ipw_wx_set_genie(struct net_device *dev,
6712 struct iw_request_info *info,
6713 union iwreq_data *wrqu, char *extra)
6715 struct ipw_priv *priv = ieee80211_priv(dev);
6716 struct ieee80211_device *ieee = priv->ieee;
6720 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6721 (wrqu->data.length && extra == NULL))
6726 //if (!ieee->wpa_enabled) {
6727 // err = -EOPNOTSUPP;
6731 if (wrqu->data.length) {
6732 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6738 memcpy(buf, extra, wrqu->data.length);
6739 kfree(ieee->wpa_ie);
6741 ieee->wpa_ie_len = wrqu->data.length;
6743 kfree(ieee->wpa_ie);
6744 ieee->wpa_ie = NULL;
6745 ieee->wpa_ie_len = 0;
6748 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6755 static int ipw_wx_get_genie(struct net_device *dev,
6756 struct iw_request_info *info,
6757 union iwreq_data *wrqu, char *extra)
6759 struct ipw_priv *priv = ieee80211_priv(dev);
6760 struct ieee80211_device *ieee = priv->ieee;
6765 //if (!ieee->wpa_enabled) {
6766 // err = -EOPNOTSUPP;
6770 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6771 wrqu->data.length = 0;
6775 if (wrqu->data.length < ieee->wpa_ie_len) {
6780 wrqu->data.length = ieee->wpa_ie_len;
6781 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6788 static int wext_cipher2level(int cipher)
6791 case IW_AUTH_CIPHER_NONE:
6793 case IW_AUTH_CIPHER_WEP40:
6794 case IW_AUTH_CIPHER_WEP104:
6796 case IW_AUTH_CIPHER_TKIP:
6798 case IW_AUTH_CIPHER_CCMP:
6806 static int ipw_wx_set_auth(struct net_device *dev,
6807 struct iw_request_info *info,
6808 union iwreq_data *wrqu, char *extra)
6810 struct ipw_priv *priv = ieee80211_priv(dev);
6811 struct ieee80211_device *ieee = priv->ieee;
6812 struct iw_param *param = &wrqu->param;
6813 struct ieee80211_crypt_data *crypt;
6814 unsigned long flags;
6817 switch (param->flags & IW_AUTH_INDEX) {
6818 case IW_AUTH_WPA_VERSION:
6820 case IW_AUTH_CIPHER_PAIRWISE:
6821 ipw_set_hw_decrypt_unicast(priv,
6822 wext_cipher2level(param->value));
6824 case IW_AUTH_CIPHER_GROUP:
6825 ipw_set_hw_decrypt_multicast(priv,
6826 wext_cipher2level(param->value));
6828 case IW_AUTH_KEY_MGMT:
6830 * ipw2200 does not use these parameters
6834 case IW_AUTH_TKIP_COUNTERMEASURES:
6835 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6836 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) {
6837 IPW_WARNING("Can't set TKIP countermeasures: "
6838 "crypt not set!\n");
6842 flags = crypt->ops->get_flags(crypt->priv);
6845 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6847 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6849 crypt->ops->set_flags(flags, crypt->priv);
6853 case IW_AUTH_DROP_UNENCRYPTED:{
6856 * wpa_supplicant calls set_wpa_enabled when the driver
6857 * is loaded and unloaded, regardless of if WPA is being
6858 * used. No other calls are made which can be used to
6859 * determine if encryption will be used or not prior to
6860 * association being expected. If encryption is not being
6861 * used, drop_unencrypted is set to false, else true -- we
6862 * can use this to determine if the CAP_PRIVACY_ON bit should
6865 struct ieee80211_security sec = {
6866 .flags = SEC_ENABLED,
6867 .enabled = param->value,
6869 priv->ieee->drop_unencrypted = param->value;
6870 /* We only change SEC_LEVEL for open mode. Others
6871 * are set by ipw_wpa_set_encryption.
6873 if (!param->value) {
6874 sec.flags |= SEC_LEVEL;
6875 sec.level = SEC_LEVEL_0;
6877 sec.flags |= SEC_LEVEL;
6878 sec.level = SEC_LEVEL_1;
6880 if (priv->ieee->set_security)
6881 priv->ieee->set_security(priv->ieee->dev, &sec);
6885 case IW_AUTH_80211_AUTH_ALG:
6886 ret = ipw_wpa_set_auth_algs(priv, param->value);
6889 case IW_AUTH_WPA_ENABLED:
6890 ret = ipw_wpa_enable(priv, param->value);
6893 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6894 ieee->ieee802_1x = param->value;
6897 //case IW_AUTH_ROAMING_CONTROL:
6898 case IW_AUTH_PRIVACY_INVOKED:
6899 ieee->privacy_invoked = param->value;
6909 static int ipw_wx_get_auth(struct net_device *dev,
6910 struct iw_request_info *info,
6911 union iwreq_data *wrqu, char *extra)
6913 struct ipw_priv *priv = ieee80211_priv(dev);
6914 struct ieee80211_device *ieee = priv->ieee;
6915 struct ieee80211_crypt_data *crypt;
6916 struct iw_param *param = &wrqu->param;
6919 switch (param->flags & IW_AUTH_INDEX) {
6920 case IW_AUTH_WPA_VERSION:
6921 case IW_AUTH_CIPHER_PAIRWISE:
6922 case IW_AUTH_CIPHER_GROUP:
6923 case IW_AUTH_KEY_MGMT:
6925 * wpa_supplicant will control these internally
6930 case IW_AUTH_TKIP_COUNTERMEASURES:
6931 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6932 if (!crypt || !crypt->ops->get_flags) {
6933 IPW_WARNING("Can't get TKIP countermeasures: "
6934 "crypt not set!\n");
6938 param->value = (crypt->ops->get_flags(crypt->priv) &
6939 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6943 case IW_AUTH_DROP_UNENCRYPTED:
6944 param->value = ieee->drop_unencrypted;
6947 case IW_AUTH_80211_AUTH_ALG:
6948 param->value = ieee->sec.auth_mode;
6951 case IW_AUTH_WPA_ENABLED:
6952 param->value = ieee->wpa_enabled;
6955 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6956 param->value = ieee->ieee802_1x;
6959 case IW_AUTH_ROAMING_CONTROL:
6960 case IW_AUTH_PRIVACY_INVOKED:
6961 param->value = ieee->privacy_invoked;
6970 /* SIOCSIWENCODEEXT */
6971 static int ipw_wx_set_encodeext(struct net_device *dev,
6972 struct iw_request_info *info,
6973 union iwreq_data *wrqu, char *extra)
6975 struct ipw_priv *priv = ieee80211_priv(dev);
6976 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6979 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6980 /* IPW HW can't build TKIP MIC,
6981 host decryption still needed */
6982 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6983 priv->ieee->host_mc_decrypt = 1;
6985 priv->ieee->host_encrypt = 0;
6986 priv->ieee->host_encrypt_msdu = 1;
6987 priv->ieee->host_decrypt = 1;
6990 priv->ieee->host_encrypt = 0;
6991 priv->ieee->host_encrypt_msdu = 0;
6992 priv->ieee->host_decrypt = 0;
6993 priv->ieee->host_mc_decrypt = 0;
6997 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
7000 /* SIOCGIWENCODEEXT */
7001 static int ipw_wx_get_encodeext(struct net_device *dev,
7002 struct iw_request_info *info,
7003 union iwreq_data *wrqu, char *extra)
7005 struct ipw_priv *priv = ieee80211_priv(dev);
7006 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
7010 static int ipw_wx_set_mlme(struct net_device *dev,
7011 struct iw_request_info *info,
7012 union iwreq_data *wrqu, char *extra)
7014 struct ipw_priv *priv = ieee80211_priv(dev);
7015 struct iw_mlme *mlme = (struct iw_mlme *)extra;
7018 reason = cpu_to_le16(mlme->reason_code);
7020 switch (mlme->cmd) {
7021 case IW_MLME_DEAUTH:
7025 case IW_MLME_DISASSOC:
7026 ipw_disassociate(priv);
7036 #ifdef CONFIG_IPW_QOS
7040 * get the modulation type of the current network or
7041 * the card current mode
7043 u8 ipw_qos_current_mode(struct ipw_priv * priv)
7047 if (priv->status & STATUS_ASSOCIATED) {
7048 unsigned long flags;
7050 spin_lock_irqsave(&priv->ieee->lock, flags);
7051 mode = priv->assoc_network->mode;
7052 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7054 mode = priv->ieee->mode;
7056 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
7061 * Handle management frame beacon and probe response
7063 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
7065 struct ieee80211_network *network)
7067 u32 size = sizeof(struct ieee80211_qos_parameters);
7069 if (network->capability & WLAN_CAPABILITY_IBSS)
7070 network->qos_data.active = network->qos_data.supported;
7072 if (network->flags & NETWORK_HAS_QOS_MASK) {
7073 if (active_network &&
7074 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
7075 network->qos_data.active = network->qos_data.supported;
7077 if ((network->qos_data.active == 1) && (active_network == 1) &&
7078 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
7079 (network->qos_data.old_param_count !=
7080 network->qos_data.param_count)) {
7081 network->qos_data.old_param_count =
7082 network->qos_data.param_count;
7083 schedule_work(&priv->qos_activate);
7084 IPW_DEBUG_QOS("QoS parameters change call "
7088 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
7089 memcpy(&network->qos_data.parameters,
7090 &def_parameters_CCK, size);
7092 memcpy(&network->qos_data.parameters,
7093 &def_parameters_OFDM, size);
7095 if ((network->qos_data.active == 1) && (active_network == 1)) {
7096 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
7097 schedule_work(&priv->qos_activate);
7100 network->qos_data.active = 0;
7101 network->qos_data.supported = 0;
7103 if ((priv->status & STATUS_ASSOCIATED) &&
7104 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
7105 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
7106 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
7107 !(network->flags & NETWORK_EMPTY_ESSID))
7108 if ((network->ssid_len ==
7109 priv->assoc_network->ssid_len) &&
7110 !memcmp(network->ssid,
7111 priv->assoc_network->ssid,
7112 network->ssid_len)) {
7113 queue_work(priv->workqueue,
7114 &priv->merge_networks);
7122 * This function set up the firmware to support QoS. It sends
7123 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
7125 static int ipw_qos_activate(struct ipw_priv *priv,
7126 struct ieee80211_qos_data *qos_network_data)
7129 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
7130 struct ieee80211_qos_parameters *active_one = NULL;
7131 u32 size = sizeof(struct ieee80211_qos_parameters);
7136 type = ipw_qos_current_mode(priv);
7138 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
7139 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
7140 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
7141 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
7143 if (qos_network_data == NULL) {
7144 if (type == IEEE_B) {
7145 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
7146 active_one = &def_parameters_CCK;
7148 active_one = &def_parameters_OFDM;
7150 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7151 burst_duration = ipw_qos_get_burst_duration(priv);
7152 for (i = 0; i < QOS_QUEUE_NUM; i++)
7153 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
7154 (u16) burst_duration;
7155 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7156 if (type == IEEE_B) {
7157 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
7159 if (priv->qos_data.qos_enable == 0)
7160 active_one = &def_parameters_CCK;
7162 active_one = priv->qos_data.def_qos_parm_CCK;
7164 if (priv->qos_data.qos_enable == 0)
7165 active_one = &def_parameters_OFDM;
7167 active_one = priv->qos_data.def_qos_parm_OFDM;
7169 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7171 unsigned long flags;
7174 spin_lock_irqsave(&priv->ieee->lock, flags);
7175 active_one = &(qos_network_data->parameters);
7176 qos_network_data->old_param_count =
7177 qos_network_data->param_count;
7178 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7179 active = qos_network_data->supported;
7180 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7183 burst_duration = ipw_qos_get_burst_duration(priv);
7184 for (i = 0; i < QOS_QUEUE_NUM; i++)
7185 qos_parameters[QOS_PARAM_SET_ACTIVE].
7186 tx_op_limit[i] = (u16) burst_duration;
7190 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
7191 err = ipw_send_qos_params_command(priv,
7192 (struct ieee80211_qos_parameters *)
7193 &(qos_parameters[0]));
7195 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
7201 * send IPW_CMD_WME_INFO to the firmware
7203 static int ipw_qos_set_info_element(struct ipw_priv *priv)
7206 struct ieee80211_qos_information_element qos_info;
7211 qos_info.elementID = QOS_ELEMENT_ID;
7212 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
7214 qos_info.version = QOS_VERSION_1;
7215 qos_info.ac_info = 0;
7217 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
7218 qos_info.qui_type = QOS_OUI_TYPE;
7219 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
7221 ret = ipw_send_qos_info_command(priv, &qos_info);
7223 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
7229 * Set the QoS parameter with the association request structure
7231 static int ipw_qos_association(struct ipw_priv *priv,
7232 struct ieee80211_network *network)
7235 struct ieee80211_qos_data *qos_data = NULL;
7236 struct ieee80211_qos_data ibss_data = {
7241 switch (priv->ieee->iw_mode) {
7243 if (!(network->capability & WLAN_CAPABILITY_IBSS))
7246 qos_data = &ibss_data;
7250 qos_data = &network->qos_data;
7258 err = ipw_qos_activate(priv, qos_data);
7260 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
7264 if (priv->qos_data.qos_enable && qos_data->supported) {
7265 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
7266 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
7267 return ipw_qos_set_info_element(priv);
7274 * handling the beaconing responces. if we get different QoS setting
7275 * of the network from the the associated setting adjust the QoS
7278 static int ipw_qos_association_resp(struct ipw_priv *priv,
7279 struct ieee80211_network *network)
7282 unsigned long flags;
7283 u32 size = sizeof(struct ieee80211_qos_parameters);
7284 int set_qos_param = 0;
7286 if ((priv == NULL) || (network == NULL) ||
7287 (priv->assoc_network == NULL))
7290 if (!(priv->status & STATUS_ASSOCIATED))
7293 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
7296 spin_lock_irqsave(&priv->ieee->lock, flags);
7297 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
7298 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
7299 sizeof(struct ieee80211_qos_data));
7300 priv->assoc_network->qos_data.active = 1;
7301 if ((network->qos_data.old_param_count !=
7302 network->qos_data.param_count)) {
7304 network->qos_data.old_param_count =
7305 network->qos_data.param_count;
7309 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7310 memcpy(&priv->assoc_network->qos_data.parameters,
7311 &def_parameters_CCK, size);
7313 memcpy(&priv->assoc_network->qos_data.parameters,
7314 &def_parameters_OFDM, size);
7315 priv->assoc_network->qos_data.active = 0;
7316 priv->assoc_network->qos_data.supported = 0;
7320 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7322 if (set_qos_param == 1)
7323 schedule_work(&priv->qos_activate);
7328 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
7335 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
7336 ret = priv->qos_data.burst_duration_CCK;
7338 ret = priv->qos_data.burst_duration_OFDM;
7344 * Initialize the setting of QoS global
7346 static void ipw_qos_init(struct ipw_priv *priv, int enable,
7347 int burst_enable, u32 burst_duration_CCK,
7348 u32 burst_duration_OFDM)
7350 priv->qos_data.qos_enable = enable;
7352 if (priv->qos_data.qos_enable) {
7353 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7354 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7355 IPW_DEBUG_QOS("QoS is enabled\n");
7357 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7358 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7359 IPW_DEBUG_QOS("QoS is not enabled\n");
7362 priv->qos_data.burst_enable = burst_enable;
7365 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7366 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7368 priv->qos_data.burst_duration_CCK = 0;
7369 priv->qos_data.burst_duration_OFDM = 0;
7374 * map the packet priority to the right TX Queue
7376 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
7378 if (priority > 7 || !priv->qos_data.qos_enable)
7381 return from_priority_to_tx_queue[priority] - 1;
7385 * add QoS parameter to the TX command
7387 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
7389 struct tfd_data *tfd, u8 unicast)
7392 int tx_queue_id = 0;
7393 struct ieee80211_qos_data *qos_data = NULL;
7394 int active, supported;
7395 unsigned long flags;
7397 if (!(priv->status & STATUS_ASSOCIATED))
7400 qos_data = &priv->assoc_network->qos_data;
7402 spin_lock_irqsave(&priv->ieee->lock, flags);
7404 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7406 qos_data->active = 0;
7408 qos_data->active = qos_data->supported;
7411 active = qos_data->active;
7412 supported = qos_data->supported;
7414 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7416 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
7418 priv->qos_data.qos_enable, active, supported, unicast);
7419 if (active && priv->qos_data.qos_enable) {
7420 ret = from_priority_to_tx_queue[priority];
7421 tx_queue_id = ret - 1;
7422 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
7423 if (priority <= 7) {
7424 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7425 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
7426 tfd->tfd.tfd_26.mchdr.frame_ctl |=
7427 IEEE80211_STYPE_QOS_DATA;
7429 if (priv->qos_data.qos_no_ack_mask &
7430 (1UL << tx_queue_id)) {
7431 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
7432 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
7442 * background support to run QoS activate functionality
7444 static void ipw_bg_qos_activate(void *data)
7446 struct ipw_priv *priv = data;
7453 if (priv->status & STATUS_ASSOCIATED)
7454 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7459 static int ipw_handle_probe_response(struct net_device *dev,
7460 struct ieee80211_probe_response *resp,
7461 struct ieee80211_network *network)
7463 struct ipw_priv *priv = ieee80211_priv(dev);
7464 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7465 (network == priv->assoc_network));
7467 ipw_qos_handle_probe_response(priv, active_network, network);
7472 static int ipw_handle_beacon(struct net_device *dev,
7473 struct ieee80211_beacon *resp,
7474 struct ieee80211_network *network)
7476 struct ipw_priv *priv = ieee80211_priv(dev);
7477 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7478 (network == priv->assoc_network));
7480 ipw_qos_handle_probe_response(priv, active_network, network);
7485 static int ipw_handle_assoc_response(struct net_device *dev,
7486 struct ieee80211_assoc_response *resp,
7487 struct ieee80211_network *network)
7489 struct ipw_priv *priv = ieee80211_priv(dev);
7490 ipw_qos_association_resp(priv, network);
7494 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7497 struct host_cmd cmd = {
7498 .cmd = IPW_CMD_QOS_PARAMETERS,
7499 .len = (sizeof(struct ieee80211_qos_parameters) * 3)
7502 memcpy(cmd.param, qos_param, sizeof(*qos_param) * 3);
7503 return ipw_send_cmd(priv, &cmd);
7506 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7509 struct host_cmd cmd = {
7510 .cmd = IPW_CMD_WME_INFO,
7511 .len = sizeof(*qos_param)
7514 memcpy(cmd.param, qos_param, sizeof(*qos_param));
7515 return ipw_send_cmd(priv, &cmd);
7518 #endif /* CONFIG_IPW_QOS */
7520 static int ipw_associate_network(struct ipw_priv *priv,
7521 struct ieee80211_network *network,
7522 struct ipw_supported_rates *rates, int roaming)
7526 if (priv->config & CFG_FIXED_RATE)
7527 ipw_set_fixed_rate(priv, network->mode);
7529 if (!(priv->config & CFG_STATIC_ESSID)) {
7530 priv->essid_len = min(network->ssid_len,
7531 (u8) IW_ESSID_MAX_SIZE);
7532 memcpy(priv->essid, network->ssid, priv->essid_len);
7535 network->last_associate = jiffies;
7537 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7538 priv->assoc_request.channel = network->channel;
7539 if ((priv->capability & CAP_PRIVACY_ON) &&
7540 (priv->capability & CAP_SHARED_KEY)) {
7541 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7542 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7544 if ((priv->capability & CAP_PRIVACY_ON) &&
7545 (priv->ieee->sec.level == SEC_LEVEL_1) &&
7546 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
7547 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7549 priv->assoc_request.auth_type = AUTH_OPEN;
7550 priv->assoc_request.auth_key = 0;
7553 if (priv->ieee->wpa_ie_len) {
7554 priv->assoc_request.policy_support = 0x02; /* RSN active */
7555 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7556 priv->ieee->wpa_ie_len);
7560 * It is valid for our ieee device to support multiple modes, but
7561 * when it comes to associating to a given network we have to choose
7564 if (network->mode & priv->ieee->mode & IEEE_A)
7565 priv->assoc_request.ieee_mode = IPW_A_MODE;
7566 else if (network->mode & priv->ieee->mode & IEEE_G)
7567 priv->assoc_request.ieee_mode = IPW_G_MODE;
7568 else if (network->mode & priv->ieee->mode & IEEE_B)
7569 priv->assoc_request.ieee_mode = IPW_B_MODE;
7571 priv->assoc_request.capability = network->capability;
7572 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7573 && !(priv->config & CFG_PREAMBLE_LONG)) {
7574 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7576 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7578 /* Clear the short preamble if we won't be supporting it */
7579 priv->assoc_request.capability &=
7580 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7583 /* Clear capability bits that aren't used in Ad Hoc */
7584 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7585 priv->assoc_request.capability &=
7586 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7588 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7589 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7590 roaming ? "Rea" : "A",
7591 escape_essid(priv->essid, priv->essid_len),
7593 ipw_modes[priv->assoc_request.ieee_mode],
7595 (priv->assoc_request.preamble_length ==
7596 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7597 network->capability &
7598 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7599 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7600 priv->capability & CAP_PRIVACY_ON ?
7601 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7603 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7604 priv->capability & CAP_PRIVACY_ON ?
7605 '1' + priv->ieee->sec.active_key : '.',
7606 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7608 priv->assoc_request.beacon_interval = network->beacon_interval;
7609 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7610 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7611 priv->assoc_request.assoc_type = HC_IBSS_START;
7612 priv->assoc_request.assoc_tsf_msw = 0;
7613 priv->assoc_request.assoc_tsf_lsw = 0;
7615 if (unlikely(roaming))
7616 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7618 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7619 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7620 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7623 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7625 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7626 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7627 priv->assoc_request.atim_window = network->atim_window;
7629 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7630 priv->assoc_request.atim_window = 0;
7633 priv->assoc_request.listen_interval = network->listen_interval;
7635 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7637 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7641 rates->ieee_mode = priv->assoc_request.ieee_mode;
7642 rates->purpose = IPW_RATE_CONNECT;
7643 ipw_send_supported_rates(priv, rates);
7645 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7646 priv->sys_config.dot11g_auto_detection = 1;
7648 priv->sys_config.dot11g_auto_detection = 0;
7650 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7651 priv->sys_config.answer_broadcast_ssid_probe = 1;
7653 priv->sys_config.answer_broadcast_ssid_probe = 0;
7655 err = ipw_send_system_config(priv, &priv->sys_config);
7657 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7661 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7662 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7664 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7669 * If preemption is enabled, it is possible for the association
7670 * to complete before we return from ipw_send_associate. Therefore
7671 * we have to be sure and update our priviate data first.
7673 priv->channel = network->channel;
7674 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7676 priv->assoc_network = network;
7678 #ifdef CONFIG_IPW_QOS
7679 ipw_qos_association(priv, network);
7682 err = ipw_send_associate(priv, &priv->assoc_request);
7684 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7688 priv->status |= STATUS_ASSOCIATING;
7689 priv->status &= ~STATUS_SECURITY_UPDATED;
7691 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7692 escape_essid(priv->essid, priv->essid_len),
7693 MAC_ARG(priv->bssid));
7698 static void ipw_roam(void *data)
7700 struct ipw_priv *priv = data;
7701 struct ieee80211_network *network = NULL;
7702 struct ipw_network_match match = {
7703 .network = priv->assoc_network
7706 /* The roaming process is as follows:
7708 * 1. Missed beacon threshold triggers the roaming process by
7709 * setting the status ROAM bit and requesting a scan.
7710 * 2. When the scan completes, it schedules the ROAM work
7711 * 3. The ROAM work looks at all of the known networks for one that
7712 * is a better network than the currently associated. If none
7713 * found, the ROAM process is over (ROAM bit cleared)
7714 * 4. If a better network is found, a disassociation request is
7716 * 5. When the disassociation completes, the roam work is again
7717 * scheduled. The second time through, the driver is no longer
7718 * associated, and the newly selected network is sent an
7719 * association request.
7720 * 6. At this point ,the roaming process is complete and the ROAM
7721 * status bit is cleared.
7724 /* If we are no longer associated, and the roaming bit is no longer
7725 * set, then we are not actively roaming, so just return */
7726 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7729 if (priv->status & STATUS_ASSOCIATED) {
7730 /* First pass through ROAM process -- look for a better
7732 unsigned long flags;
7733 u8 rssi = priv->assoc_network->stats.rssi;
7734 priv->assoc_network->stats.rssi = -128;
7735 spin_lock_irqsave(&priv->ieee->lock, flags);
7736 list_for_each_entry(network, &priv->ieee->network_list, list) {
7737 if (network != priv->assoc_network)
7738 ipw_best_network(priv, &match, network, 1);
7740 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7741 priv->assoc_network->stats.rssi = rssi;
7743 if (match.network == priv->assoc_network) {
7744 IPW_DEBUG_ASSOC("No better APs in this network to "
7746 priv->status &= ~STATUS_ROAMING;
7747 ipw_debug_config(priv);
7751 ipw_send_disassociate(priv, 1);
7752 priv->assoc_network = match.network;
7757 /* Second pass through ROAM process -- request association */
7758 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7759 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7760 priv->status &= ~STATUS_ROAMING;
7763 static void ipw_bg_roam(void *data)
7765 struct ipw_priv *priv = data;
7771 static int ipw_associate(void *data)
7773 struct ipw_priv *priv = data;
7775 struct ieee80211_network *network = NULL;
7776 struct ipw_network_match match = {
7779 struct ipw_supported_rates *rates;
7780 struct list_head *element;
7781 unsigned long flags;
7783 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7784 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7788 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7789 IPW_DEBUG_ASSOC("Not attempting association (already in "
7794 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7795 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7800 if (!(priv->config & CFG_ASSOCIATE) &&
7801 !(priv->config & (CFG_STATIC_ESSID |
7802 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7803 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7807 /* Protect our use of the network_list */
7808 spin_lock_irqsave(&priv->ieee->lock, flags);
7809 list_for_each_entry(network, &priv->ieee->network_list, list)
7810 ipw_best_network(priv, &match, network, 0);
7812 network = match.network;
7813 rates = &match.rates;
7815 if (network == NULL &&
7816 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7817 priv->config & CFG_ADHOC_CREATE &&
7818 priv->config & CFG_STATIC_ESSID &&
7819 priv->config & CFG_STATIC_CHANNEL &&
7820 !list_empty(&priv->ieee->network_free_list)) {
7821 element = priv->ieee->network_free_list.next;
7822 network = list_entry(element, struct ieee80211_network, list);
7823 ipw_adhoc_create(priv, network);
7824 rates = &priv->rates;
7826 list_add_tail(&network->list, &priv->ieee->network_list);
7828 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7830 /* If we reached the end of the list, then we don't have any valid
7833 ipw_debug_config(priv);
7835 if (!(priv->status & STATUS_SCANNING)) {
7836 if (!(priv->config & CFG_SPEED_SCAN))
7837 queue_delayed_work(priv->workqueue,
7838 &priv->request_scan,
7841 queue_work(priv->workqueue,
7842 &priv->request_scan);
7848 ipw_associate_network(priv, network, rates, 0);
7853 static void ipw_bg_associate(void *data)
7855 struct ipw_priv *priv = data;
7857 ipw_associate(data);
7861 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7862 struct sk_buff *skb)
7864 struct ieee80211_hdr *hdr;
7867 hdr = (struct ieee80211_hdr *)skb->data;
7868 fc = le16_to_cpu(hdr->frame_ctl);
7869 if (!(fc & IEEE80211_FCTL_PROTECTED))
7872 fc &= ~IEEE80211_FCTL_PROTECTED;
7873 hdr->frame_ctl = cpu_to_le16(fc);
7874 switch (priv->ieee->sec.level) {
7876 /* Remove CCMP HDR */
7877 memmove(skb->data + IEEE80211_3ADDR_LEN,
7878 skb->data + IEEE80211_3ADDR_LEN + 8,
7879 skb->len - IEEE80211_3ADDR_LEN - 8);
7880 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7886 memmove(skb->data + IEEE80211_3ADDR_LEN,
7887 skb->data + IEEE80211_3ADDR_LEN + 4,
7888 skb->len - IEEE80211_3ADDR_LEN - 4);
7889 skb_trim(skb, skb->len - 8); /* IV + ICV */
7894 printk(KERN_ERR "Unknow security level %d\n",
7895 priv->ieee->sec.level);
7900 static void ipw_handle_data_packet(struct ipw_priv *priv,
7901 struct ipw_rx_mem_buffer *rxb,
7902 struct ieee80211_rx_stats *stats)
7904 struct ieee80211_hdr_4addr *hdr;
7905 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7907 /* We received data from the HW, so stop the watchdog */
7908 priv->net_dev->trans_start = jiffies;
7910 /* We only process data packets if the
7911 * interface is open */
7912 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7913 skb_tailroom(rxb->skb))) {
7914 priv->ieee->stats.rx_errors++;
7915 priv->wstats.discard.misc++;
7916 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7918 } else if (unlikely(!netif_running(priv->net_dev))) {
7919 priv->ieee->stats.rx_dropped++;
7920 priv->wstats.discard.misc++;
7921 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7925 /* Advance skb->data to the start of the actual payload */
7926 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7928 /* Set the size of the skb to the size of the frame */
7929 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7931 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7933 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7934 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7935 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7936 (is_multicast_ether_addr(hdr->addr1) ?
7937 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7938 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7940 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7941 priv->ieee->stats.rx_errors++;
7942 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7944 __ipw_led_activity_on(priv);
7948 #ifdef CONFIG_IEEE80211_RADIOTAP
7949 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7950 struct ipw_rx_mem_buffer *rxb,
7951 struct ieee80211_rx_stats *stats)
7953 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7954 struct ipw_rx_frame *frame = &pkt->u.frame;
7956 /* initial pull of some data */
7957 u16 received_channel = frame->received_channel;
7958 u8 antennaAndPhy = frame->antennaAndPhy;
7959 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7960 u16 pktrate = frame->rate;
7962 /* Magic struct that slots into the radiotap header -- no reason
7963 * to build this manually element by element, we can write it much
7964 * more efficiently than we can parse it. ORDER MATTERS HERE */
7966 struct ieee80211_radiotap_header rt_hdr;
7967 u8 rt_flags; /* radiotap packet flags */
7968 u8 rt_rate; /* rate in 500kb/s */
7969 u16 rt_channel; /* channel in mhz */
7970 u16 rt_chbitmask; /* channel bitfield */
7971 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7972 u8 rt_antenna; /* antenna number */
7975 short len = le16_to_cpu(pkt->u.frame.length);
7977 /* We received data from the HW, so stop the watchdog */
7978 priv->net_dev->trans_start = jiffies;
7980 /* We only process data packets if the
7981 * interface is open */
7982 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7983 skb_tailroom(rxb->skb))) {
7984 priv->ieee->stats.rx_errors++;
7985 priv->wstats.discard.misc++;
7986 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7988 } else if (unlikely(!netif_running(priv->net_dev))) {
7989 priv->ieee->stats.rx_dropped++;
7990 priv->wstats.discard.misc++;
7991 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7995 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7997 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7998 /* FIXME: Should alloc bigger skb instead */
7999 priv->ieee->stats.rx_dropped++;
8000 priv->wstats.discard.misc++;
8001 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
8005 /* copy the frame itself */
8006 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
8007 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
8009 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
8010 * part of our real header, saves a little time.
8012 * No longer necessary since we fill in all our data. Purge before merging
8014 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
8015 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
8018 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
8020 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
8021 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
8022 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
8024 /* Big bitfield of all the fields we provide in radiotap */
8025 ipw_rt->rt_hdr.it_present =
8026 ((1 << IEEE80211_RADIOTAP_FLAGS) |
8027 (1 << IEEE80211_RADIOTAP_RATE) |
8028 (1 << IEEE80211_RADIOTAP_CHANNEL) |
8029 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
8030 (1 << IEEE80211_RADIOTAP_ANTENNA));
8032 /* Zero the flags, we'll add to them as we go */
8033 ipw_rt->rt_flags = 0;
8035 /* Convert signal to DBM */
8036 ipw_rt->rt_dbmsignal = antsignal;
8038 /* Convert the channel data and set the flags */
8039 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
8040 if (received_channel > 14) { /* 802.11a */
8041 ipw_rt->rt_chbitmask =
8042 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
8043 } else if (antennaAndPhy & 32) { /* 802.11b */
8044 ipw_rt->rt_chbitmask =
8045 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
8046 } else { /* 802.11g */
8047 ipw_rt->rt_chbitmask =
8048 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
8051 /* set the rate in multiples of 500k/s */
8053 case IPW_TX_RATE_1MB:
8054 ipw_rt->rt_rate = 2;
8056 case IPW_TX_RATE_2MB:
8057 ipw_rt->rt_rate = 4;
8059 case IPW_TX_RATE_5MB:
8060 ipw_rt->rt_rate = 10;
8062 case IPW_TX_RATE_6MB:
8063 ipw_rt->rt_rate = 12;
8065 case IPW_TX_RATE_9MB:
8066 ipw_rt->rt_rate = 18;
8068 case IPW_TX_RATE_11MB:
8069 ipw_rt->rt_rate = 22;
8071 case IPW_TX_RATE_12MB:
8072 ipw_rt->rt_rate = 24;
8074 case IPW_TX_RATE_18MB:
8075 ipw_rt->rt_rate = 36;
8077 case IPW_TX_RATE_24MB:
8078 ipw_rt->rt_rate = 48;
8080 case IPW_TX_RATE_36MB:
8081 ipw_rt->rt_rate = 72;
8083 case IPW_TX_RATE_48MB:
8084 ipw_rt->rt_rate = 96;
8086 case IPW_TX_RATE_54MB:
8087 ipw_rt->rt_rate = 108;
8090 ipw_rt->rt_rate = 0;
8094 /* antenna number */
8095 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
8097 /* set the preamble flag if we have it */
8098 if ((antennaAndPhy & 64))
8099 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8101 /* Set the size of the skb to the size of the frame */
8102 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
8104 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
8106 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
8107 priv->ieee->stats.rx_errors++;
8108 else { /* ieee80211_rx succeeded, so it now owns the SKB */
8110 /* no LED during capture */
8115 static inline int is_network_packet(struct ipw_priv *priv,
8116 struct ieee80211_hdr_4addr *header)
8118 /* Filter incoming packets to determine if they are targetted toward
8119 * this network, discarding packets coming from ourselves */
8120 switch (priv->ieee->iw_mode) {
8121 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
8122 /* packets from our adapter are dropped (echo) */
8123 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
8126 /* {broad,multi}cast packets to our BSSID go through */
8127 if (is_multicast_ether_addr(header->addr1) ||
8128 is_broadcast_ether_addr(header->addr1))
8129 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
8131 /* packets to our adapter go through */
8132 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8135 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
8136 /* packets from our adapter are dropped (echo) */
8137 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
8140 /* {broad,multi}cast packets to our BSS go through */
8141 if (is_multicast_ether_addr(header->addr1) ||
8142 is_broadcast_ether_addr(header->addr1))
8143 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
8145 /* packets to our adapter go through */
8146 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8153 #define IPW_PACKET_RETRY_TIME HZ
8155 static inline int is_duplicate_packet(struct ipw_priv *priv,
8156 struct ieee80211_hdr_4addr *header)
8158 u16 sc = le16_to_cpu(header->seq_ctl);
8159 u16 seq = WLAN_GET_SEQ_SEQ(sc);
8160 u16 frag = WLAN_GET_SEQ_FRAG(sc);
8161 u16 *last_seq, *last_frag;
8162 unsigned long *last_time;
8164 switch (priv->ieee->iw_mode) {
8167 struct list_head *p;
8168 struct ipw_ibss_seq *entry = NULL;
8169 u8 *mac = header->addr2;
8170 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
8172 __list_for_each(p, &priv->ibss_mac_hash[index]) {
8174 list_entry(p, struct ipw_ibss_seq, list);
8175 if (!memcmp(entry->mac, mac, ETH_ALEN))
8178 if (p == &priv->ibss_mac_hash[index]) {
8179 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
8182 ("Cannot malloc new mac entry\n");
8185 memcpy(entry->mac, mac, ETH_ALEN);
8186 entry->seq_num = seq;
8187 entry->frag_num = frag;
8188 entry->packet_time = jiffies;
8189 list_add(&entry->list,
8190 &priv->ibss_mac_hash[index]);
8193 last_seq = &entry->seq_num;
8194 last_frag = &entry->frag_num;
8195 last_time = &entry->packet_time;
8199 last_seq = &priv->last_seq_num;
8200 last_frag = &priv->last_frag_num;
8201 last_time = &priv->last_packet_time;
8206 if ((*last_seq == seq) &&
8207 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
8208 if (*last_frag == frag)
8210 if (*last_frag + 1 != frag)
8211 /* out-of-order fragment */
8217 *last_time = jiffies;
8221 /* Comment this line now since we observed the card receives
8222 * duplicate packets but the FCTL_RETRY bit is not set in the
8223 * IBSS mode with fragmentation enabled.
8224 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
8228 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
8229 struct ipw_rx_mem_buffer *rxb,
8230 struct ieee80211_rx_stats *stats)
8232 struct sk_buff *skb = rxb->skb;
8233 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
8234 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
8235 (skb->data + IPW_RX_FRAME_SIZE);
8237 ieee80211_rx_mgt(priv->ieee, header, stats);
8239 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8240 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8241 IEEE80211_STYPE_PROBE_RESP) ||
8242 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8243 IEEE80211_STYPE_BEACON))) {
8244 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
8245 ipw_add_station(priv, header->addr2);
8248 if (priv->config & CFG_NET_STATS) {
8249 IPW_DEBUG_HC("sending stat packet\n");
8251 /* Set the size of the skb to the size of the full
8252 * ipw header and 802.11 frame */
8253 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8256 /* Advance past the ipw packet header to the 802.11 frame */
8257 skb_pull(skb, IPW_RX_FRAME_SIZE);
8259 /* Push the ieee80211_rx_stats before the 802.11 frame */
8260 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
8262 skb->dev = priv->ieee->dev;
8264 /* Point raw at the ieee80211_stats */
8265 skb->mac.raw = skb->data;
8267 skb->pkt_type = PACKET_OTHERHOST;
8268 skb->protocol = __constant_htons(ETH_P_80211_STATS);
8269 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8276 * Main entry function for recieving a packet with 80211 headers. This
8277 * should be called when ever the FW has notified us that there is a new
8278 * skb in the recieve queue.
8280 static void ipw_rx(struct ipw_priv *priv)
8282 struct ipw_rx_mem_buffer *rxb;
8283 struct ipw_rx_packet *pkt;
8284 struct ieee80211_hdr_4addr *header;
8288 r = ipw_read32(priv, IPW_RX_READ_INDEX);
8289 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
8290 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
8293 rxb = priv->rxq->queue[i];
8294 #ifdef CONFIG_IPW_DEBUG
8295 if (unlikely(rxb == NULL)) {
8296 printk(KERN_CRIT "Queue not allocated!\n");
8300 priv->rxq->queue[i] = NULL;
8302 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
8304 PCI_DMA_FROMDEVICE);
8306 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8307 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
8308 pkt->header.message_type,
8309 pkt->header.rx_seq_num, pkt->header.control_bits);
8311 switch (pkt->header.message_type) {
8312 case RX_FRAME_TYPE: /* 802.11 frame */ {
8313 struct ieee80211_rx_stats stats = {
8315 le16_to_cpu(pkt->u.frame.rssi_dbm) -
8318 le16_to_cpu(pkt->u.frame.signal),
8320 le16_to_cpu(pkt->u.frame.noise),
8321 .rate = pkt->u.frame.rate,
8322 .mac_time = jiffies,
8324 pkt->u.frame.received_channel,
8327 control & (1 << 0)) ?
8328 IEEE80211_24GHZ_BAND :
8329 IEEE80211_52GHZ_BAND,
8330 .len = le16_to_cpu(pkt->u.frame.length),
8333 if (stats.rssi != 0)
8334 stats.mask |= IEEE80211_STATMASK_RSSI;
8335 if (stats.signal != 0)
8336 stats.mask |= IEEE80211_STATMASK_SIGNAL;
8337 if (stats.noise != 0)
8338 stats.mask |= IEEE80211_STATMASK_NOISE;
8339 if (stats.rate != 0)
8340 stats.mask |= IEEE80211_STATMASK_RATE;
8344 #ifdef CONFIG_IPW2200_MONITOR
8345 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8346 #ifdef CONFIG_IEEE80211_RADIOTAP
8347 ipw_handle_data_packet_monitor(priv,
8351 ipw_handle_data_packet(priv, rxb,
8359 (struct ieee80211_hdr_4addr *)(rxb->skb->
8362 /* TODO: Check Ad-Hoc dest/source and make sure
8363 * that we are actually parsing these packets
8364 * correctly -- we should probably use the
8365 * frame control of the packet and disregard
8366 * the current iw_mode */
8369 is_network_packet(priv, header);
8370 if (network_packet && priv->assoc_network) {
8371 priv->assoc_network->stats.rssi =
8373 average_add(&priv->average_rssi,
8375 priv->last_rx_rssi = stats.rssi;
8378 IPW_DEBUG_RX("Frame: len=%u\n",
8379 le16_to_cpu(pkt->u.frame.length));
8381 if (le16_to_cpu(pkt->u.frame.length) <
8382 frame_hdr_len(header)) {
8384 ("Received packet is too small. "
8386 priv->ieee->stats.rx_errors++;
8387 priv->wstats.discard.misc++;
8391 switch (WLAN_FC_GET_TYPE
8392 (le16_to_cpu(header->frame_ctl))) {
8394 case IEEE80211_FTYPE_MGMT:
8395 ipw_handle_mgmt_packet(priv, rxb,
8399 case IEEE80211_FTYPE_CTL:
8402 case IEEE80211_FTYPE_DATA:
8403 if (unlikely(!network_packet ||
8404 is_duplicate_packet(priv,
8407 IPW_DEBUG_DROP("Dropping: "
8420 ipw_handle_data_packet(priv, rxb,
8428 case RX_HOST_NOTIFICATION_TYPE:{
8430 ("Notification: subtype=%02X flags=%02X size=%d\n",
8431 pkt->u.notification.subtype,
8432 pkt->u.notification.flags,
8433 pkt->u.notification.size);
8434 ipw_rx_notification(priv, &pkt->u.notification);
8439 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8440 pkt->header.message_type);
8444 /* For now we just don't re-use anything. We can tweak this
8445 * later to try and re-use notification packets and SKBs that
8446 * fail to Rx correctly */
8447 if (rxb->skb != NULL) {
8448 dev_kfree_skb_any(rxb->skb);
8452 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
8453 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
8454 list_add_tail(&rxb->list, &priv->rxq->rx_used);
8456 i = (i + 1) % RX_QUEUE_SIZE;
8459 /* Backtrack one entry */
8460 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
8462 ipw_rx_queue_restock(priv);
8465 #define DEFAULT_RTS_THRESHOLD 2304U
8466 #define MIN_RTS_THRESHOLD 1U
8467 #define MAX_RTS_THRESHOLD 2304U
8468 #define DEFAULT_BEACON_INTERVAL 100U
8469 #define DEFAULT_SHORT_RETRY_LIMIT 7U
8470 #define DEFAULT_LONG_RETRY_LIMIT 4U
8472 static int ipw_sw_reset(struct ipw_priv *priv, int init)
8474 int band, modulation;
8475 int old_mode = priv->ieee->iw_mode;
8477 /* Initialize module parameter values here */
8480 /* We default to disabling the LED code as right now it causes
8481 * too many systems to lock up... */
8483 priv->config |= CFG_NO_LED;
8486 priv->config |= CFG_ASSOCIATE;
8488 IPW_DEBUG_INFO("Auto associate disabled.\n");
8491 priv->config |= CFG_ADHOC_CREATE;
8493 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8496 priv->status |= STATUS_RF_KILL_SW;
8497 IPW_DEBUG_INFO("Radio disabled.\n");
8501 priv->config |= CFG_STATIC_CHANNEL;
8502 priv->channel = channel;
8503 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8504 /* TODO: Validate that provided channel is in range */
8506 #ifdef CONFIG_IPW_QOS
8507 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8508 burst_duration_CCK, burst_duration_OFDM);
8509 #endif /* CONFIG_IPW_QOS */
8513 priv->ieee->iw_mode = IW_MODE_ADHOC;
8514 priv->net_dev->type = ARPHRD_ETHER;
8517 #ifdef CONFIG_IPW2200_MONITOR
8519 priv->ieee->iw_mode = IW_MODE_MONITOR;
8520 #ifdef CONFIG_IEEE80211_RADIOTAP
8521 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8523 priv->net_dev->type = ARPHRD_IEEE80211;
8529 priv->net_dev->type = ARPHRD_ETHER;
8530 priv->ieee->iw_mode = IW_MODE_INFRA;
8535 priv->ieee->host_encrypt = 0;
8536 priv->ieee->host_encrypt_msdu = 0;
8537 priv->ieee->host_decrypt = 0;
8538 priv->ieee->host_mc_decrypt = 0;
8540 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8542 /* IPW2200/2915 is abled to do hardware fragmentation. */
8543 priv->ieee->host_open_frag = 0;
8545 if ((priv->pci_dev->device == 0x4223) ||
8546 (priv->pci_dev->device == 0x4224)) {
8548 printk(KERN_INFO DRV_NAME
8549 ": Detected Intel PRO/Wireless 2915ABG Network "
8551 priv->ieee->abg_true = 1;
8552 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8553 modulation = IEEE80211_OFDM_MODULATION |
8554 IEEE80211_CCK_MODULATION;
8555 priv->adapter = IPW_2915ABG;
8556 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8559 printk(KERN_INFO DRV_NAME
8560 ": Detected Intel PRO/Wireless 2200BG Network "
8563 priv->ieee->abg_true = 0;
8564 band = IEEE80211_24GHZ_BAND;
8565 modulation = IEEE80211_OFDM_MODULATION |
8566 IEEE80211_CCK_MODULATION;
8567 priv->adapter = IPW_2200BG;
8568 priv->ieee->mode = IEEE_G | IEEE_B;
8571 priv->ieee->freq_band = band;
8572 priv->ieee->modulation = modulation;
8574 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8576 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8577 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8579 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8580 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8581 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8583 /* If power management is turned on, default to AC mode */
8584 priv->power_mode = IPW_POWER_AC;
8585 priv->tx_power = IPW_TX_POWER_DEFAULT;
8587 return old_mode == priv->ieee->iw_mode;
8591 * This file defines the Wireless Extension handlers. It does not
8592 * define any methods of hardware manipulation and relies on the
8593 * functions defined in ipw_main to provide the HW interaction.
8595 * The exception to this is the use of the ipw_get_ordinal()
8596 * function used to poll the hardware vs. making unecessary calls.
8600 static int ipw_wx_get_name(struct net_device *dev,
8601 struct iw_request_info *info,
8602 union iwreq_data *wrqu, char *extra)
8604 struct ipw_priv *priv = ieee80211_priv(dev);
8606 if (priv->status & STATUS_RF_KILL_MASK)
8607 strcpy(wrqu->name, "radio off");
8608 else if (!(priv->status & STATUS_ASSOCIATED))
8609 strcpy(wrqu->name, "unassociated");
8611 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8612 ipw_modes[priv->assoc_request.ieee_mode]);
8613 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8618 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8621 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8622 priv->config &= ~CFG_STATIC_CHANNEL;
8623 IPW_DEBUG_ASSOC("Attempting to associate with new "
8625 ipw_associate(priv);
8629 priv->config |= CFG_STATIC_CHANNEL;
8631 if (priv->channel == channel) {
8632 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8637 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8638 priv->channel = channel;
8640 #ifdef CONFIG_IPW2200_MONITOR
8641 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8643 if (priv->status & STATUS_SCANNING) {
8644 IPW_DEBUG_SCAN("Scan abort triggered due to "
8645 "channel change.\n");
8646 ipw_abort_scan(priv);
8649 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8652 if (priv->status & STATUS_SCANNING)
8653 IPW_DEBUG_SCAN("Still scanning...\n");
8655 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8660 #endif /* CONFIG_IPW2200_MONITOR */
8662 /* Network configuration changed -- force [re]association */
8663 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8664 if (!ipw_disassociate(priv))
8665 ipw_associate(priv);
8670 static int ipw_wx_set_freq(struct net_device *dev,
8671 struct iw_request_info *info,
8672 union iwreq_data *wrqu, char *extra)
8674 struct ipw_priv *priv = ieee80211_priv(dev);
8675 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8676 struct iw_freq *fwrq = &wrqu->freq;
8682 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8684 ret = ipw_set_channel(priv, 0);
8688 /* if setting by freq convert to channel */
8690 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
8696 if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8699 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8700 i = ipw_channel_to_index(priv->ieee, channel);
8704 flags = (band == IEEE80211_24GHZ_BAND) ?
8705 geo->bg[i].flags : geo->a[i].flags;
8706 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8707 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8712 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8714 ret = ipw_set_channel(priv, channel);
8719 static int ipw_wx_get_freq(struct net_device *dev,
8720 struct iw_request_info *info,
8721 union iwreq_data *wrqu, char *extra)
8723 struct ipw_priv *priv = ieee80211_priv(dev);
8727 /* If we are associated, trying to associate, or have a statically
8728 * configured CHANNEL then return that; otherwise return ANY */
8730 if (priv->config & CFG_STATIC_CHANNEL ||
8731 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8732 wrqu->freq.m = priv->channel;
8737 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8741 static int ipw_wx_set_mode(struct net_device *dev,
8742 struct iw_request_info *info,
8743 union iwreq_data *wrqu, char *extra)
8745 struct ipw_priv *priv = ieee80211_priv(dev);
8748 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8750 switch (wrqu->mode) {
8751 #ifdef CONFIG_IPW2200_MONITOR
8752 case IW_MODE_MONITOR:
8758 wrqu->mode = IW_MODE_INFRA;
8763 if (wrqu->mode == priv->ieee->iw_mode)
8768 ipw_sw_reset(priv, 0);
8770 #ifdef CONFIG_IPW2200_MONITOR
8771 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8772 priv->net_dev->type = ARPHRD_ETHER;
8774 if (wrqu->mode == IW_MODE_MONITOR)
8775 #ifdef CONFIG_IEEE80211_RADIOTAP
8776 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8778 priv->net_dev->type = ARPHRD_IEEE80211;
8780 #endif /* CONFIG_IPW2200_MONITOR */
8782 /* Free the existing firmware and reset the fw_loaded
8783 * flag so ipw_load() will bring in the new firmawre */
8786 priv->ieee->iw_mode = wrqu->mode;
8788 queue_work(priv->workqueue, &priv->adapter_restart);
8793 static int ipw_wx_get_mode(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->mode = priv->ieee->iw_mode;
8800 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8805 /* Values are in microsecond */
8806 static const s32 timeout_duration[] = {
8814 static const s32 period_duration[] = {
8822 static int ipw_wx_get_range(struct net_device *dev,
8823 struct iw_request_info *info,
8824 union iwreq_data *wrqu, char *extra)
8826 struct ipw_priv *priv = ieee80211_priv(dev);
8827 struct iw_range *range = (struct iw_range *)extra;
8828 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8831 wrqu->data.length = sizeof(*range);
8832 memset(range, 0, sizeof(*range));
8834 /* 54Mbs == ~27 Mb/s real (802.11g) */
8835 range->throughput = 27 * 1000 * 1000;
8837 range->max_qual.qual = 100;
8838 /* TODO: Find real max RSSI and stick here */
8839 range->max_qual.level = 0;
8840 range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
8841 range->max_qual.updated = 7; /* Updated all three */
8843 range->avg_qual.qual = 70;
8844 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8845 range->avg_qual.level = 0; /* FIXME to real average level */
8846 range->avg_qual.noise = 0;
8847 range->avg_qual.updated = 7; /* Updated all three */
8849 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8851 for (i = 0; i < range->num_bitrates; i++)
8852 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8855 range->max_rts = DEFAULT_RTS_THRESHOLD;
8856 range->min_frag = MIN_FRAG_THRESHOLD;
8857 range->max_frag = MAX_FRAG_THRESHOLD;
8859 range->encoding_size[0] = 5;
8860 range->encoding_size[1] = 13;
8861 range->num_encoding_sizes = 2;
8862 range->max_encoding_tokens = WEP_KEYS;
8864 /* Set the Wireless Extension versions */
8865 range->we_version_compiled = WIRELESS_EXT;
8866 range->we_version_source = 16;
8869 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8870 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8872 range->freq[i].i = geo->bg[j].channel;
8873 range->freq[i].m = geo->bg[j].freq * 100000;
8874 range->freq[i].e = 1;
8878 if (priv->ieee->mode & IEEE_A) {
8879 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8881 range->freq[i].i = geo->a[j].channel;
8882 range->freq[i].m = geo->a[j].freq * 100000;
8883 range->freq[i].e = 1;
8887 range->num_channels = i;
8888 range->num_frequency = i;
8891 IPW_DEBUG_WX("GET Range\n");
8895 static int ipw_wx_set_wap(struct net_device *dev,
8896 struct iw_request_info *info,
8897 union iwreq_data *wrqu, char *extra)
8899 struct ipw_priv *priv = ieee80211_priv(dev);
8901 static const unsigned char any[] = {
8902 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8904 static const unsigned char off[] = {
8905 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8908 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8911 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8912 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8913 /* we disable mandatory BSSID association */
8914 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8915 priv->config &= ~CFG_STATIC_BSSID;
8916 IPW_DEBUG_ASSOC("Attempting to associate with new "
8918 ipw_associate(priv);
8923 priv->config |= CFG_STATIC_BSSID;
8924 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8925 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8930 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8931 MAC_ARG(wrqu->ap_addr.sa_data));
8933 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8935 /* Network configuration changed -- force [re]association */
8936 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8937 if (!ipw_disassociate(priv))
8938 ipw_associate(priv);
8944 static int ipw_wx_get_wap(struct net_device *dev,
8945 struct iw_request_info *info,
8946 union iwreq_data *wrqu, char *extra)
8948 struct ipw_priv *priv = ieee80211_priv(dev);
8949 /* If we are associated, trying to associate, or have a statically
8950 * configured BSSID then return that; otherwise return ANY */
8952 if (priv->config & CFG_STATIC_BSSID ||
8953 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8954 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8955 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8957 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8959 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8960 MAC_ARG(wrqu->ap_addr.sa_data));
8965 static int ipw_wx_set_essid(struct net_device *dev,
8966 struct iw_request_info *info,
8967 union iwreq_data *wrqu, char *extra)
8969 struct ipw_priv *priv = ieee80211_priv(dev);
8970 char *essid = ""; /* ANY */
8973 if (wrqu->essid.flags && wrqu->essid.length) {
8974 length = wrqu->essid.length - 1;
8978 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8979 if ((priv->config & CFG_STATIC_ESSID) &&
8980 !(priv->status & (STATUS_ASSOCIATED |
8981 STATUS_ASSOCIATING))) {
8982 IPW_DEBUG_ASSOC("Attempting to associate with new "
8984 priv->config &= ~CFG_STATIC_ESSID;
8985 ipw_associate(priv);
8991 length = min(length, IW_ESSID_MAX_SIZE);
8993 priv->config |= CFG_STATIC_ESSID;
8995 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8996 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
9001 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
9004 priv->essid_len = length;
9005 memcpy(priv->essid, essid, priv->essid_len);
9007 /* Network configuration changed -- force [re]association */
9008 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
9009 if (!ipw_disassociate(priv))
9010 ipw_associate(priv);
9016 static int ipw_wx_get_essid(struct net_device *dev,
9017 struct iw_request_info *info,
9018 union iwreq_data *wrqu, char *extra)
9020 struct ipw_priv *priv = ieee80211_priv(dev);
9022 /* If we are associated, trying to associate, or have a statically
9023 * configured ESSID then return that; otherwise return ANY */
9025 if (priv->config & CFG_STATIC_ESSID ||
9026 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9027 IPW_DEBUG_WX("Getting essid: '%s'\n",
9028 escape_essid(priv->essid, priv->essid_len));
9029 memcpy(extra, priv->essid, priv->essid_len);
9030 wrqu->essid.length = priv->essid_len;
9031 wrqu->essid.flags = 1; /* active */
9033 IPW_DEBUG_WX("Getting essid: ANY\n");
9034 wrqu->essid.length = 0;
9035 wrqu->essid.flags = 0; /* active */
9041 static int ipw_wx_set_nick(struct net_device *dev,
9042 struct iw_request_info *info,
9043 union iwreq_data *wrqu, char *extra)
9045 struct ipw_priv *priv = ieee80211_priv(dev);
9047 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
9048 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9051 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
9052 memset(priv->nick, 0, sizeof(priv->nick));
9053 memcpy(priv->nick, extra, wrqu->data.length);
9054 IPW_DEBUG_TRACE("<<\n");
9060 static int ipw_wx_get_nick(struct net_device *dev,
9061 struct iw_request_info *info,
9062 union iwreq_data *wrqu, char *extra)
9064 struct ipw_priv *priv = ieee80211_priv(dev);
9065 IPW_DEBUG_WX("Getting nick\n");
9067 wrqu->data.length = strlen(priv->nick) + 1;
9068 memcpy(extra, priv->nick, wrqu->data.length);
9069 wrqu->data.flags = 1; /* active */
9074 static int ipw_wx_set_rate(struct net_device *dev,
9075 struct iw_request_info *info,
9076 union iwreq_data *wrqu, char *extra)
9078 /* TODO: We should use semaphores or locks for access to priv */
9079 struct ipw_priv *priv = ieee80211_priv(dev);
9080 u32 target_rate = wrqu->bitrate.value;
9083 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
9084 /* value = X, fixed = 1 means only rate X */
9085 /* value = X, fixed = 0 means all rates lower equal X */
9087 if (target_rate == -1) {
9089 mask = IEEE80211_DEFAULT_RATES_MASK;
9090 /* Now we should reassociate */
9095 fixed = wrqu->bitrate.fixed;
9097 if (target_rate == 1000000 || !fixed)
9098 mask |= IEEE80211_CCK_RATE_1MB_MASK;
9099 if (target_rate == 1000000)
9102 if (target_rate == 2000000 || !fixed)
9103 mask |= IEEE80211_CCK_RATE_2MB_MASK;
9104 if (target_rate == 2000000)
9107 if (target_rate == 5500000 || !fixed)
9108 mask |= IEEE80211_CCK_RATE_5MB_MASK;
9109 if (target_rate == 5500000)
9112 if (target_rate == 6000000 || !fixed)
9113 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
9114 if (target_rate == 6000000)
9117 if (target_rate == 9000000 || !fixed)
9118 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
9119 if (target_rate == 9000000)
9122 if (target_rate == 11000000 || !fixed)
9123 mask |= IEEE80211_CCK_RATE_11MB_MASK;
9124 if (target_rate == 11000000)
9127 if (target_rate == 12000000 || !fixed)
9128 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
9129 if (target_rate == 12000000)
9132 if (target_rate == 18000000 || !fixed)
9133 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
9134 if (target_rate == 18000000)
9137 if (target_rate == 24000000 || !fixed)
9138 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
9139 if (target_rate == 24000000)
9142 if (target_rate == 36000000 || !fixed)
9143 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
9144 if (target_rate == 36000000)
9147 if (target_rate == 48000000 || !fixed)
9148 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
9149 if (target_rate == 48000000)
9152 if (target_rate == 54000000 || !fixed)
9153 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
9154 if (target_rate == 54000000)
9157 IPW_DEBUG_WX("invalid rate specified, returning error\n");
9161 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
9162 mask, fixed ? "fixed" : "sub-rates");
9164 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
9165 priv->config &= ~CFG_FIXED_RATE;
9166 ipw_set_fixed_rate(priv, priv->ieee->mode);
9168 priv->config |= CFG_FIXED_RATE;
9170 if (priv->rates_mask == mask) {
9171 IPW_DEBUG_WX("Mask set to current mask.\n");
9176 priv->rates_mask = mask;
9178 /* Network configuration changed -- force [re]association */
9179 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
9180 if (!ipw_disassociate(priv))
9181 ipw_associate(priv);
9187 static int ipw_wx_get_rate(struct net_device *dev,
9188 struct iw_request_info *info,
9189 union iwreq_data *wrqu, char *extra)
9191 struct ipw_priv *priv = ieee80211_priv(dev);
9193 wrqu->bitrate.value = priv->last_rate;
9195 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
9199 static int ipw_wx_set_rts(struct net_device *dev,
9200 struct iw_request_info *info,
9201 union iwreq_data *wrqu, char *extra)
9203 struct ipw_priv *priv = ieee80211_priv(dev);
9205 if (wrqu->rts.disabled)
9206 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9208 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
9209 wrqu->rts.value > MAX_RTS_THRESHOLD) {
9213 priv->rts_threshold = wrqu->rts.value;
9216 ipw_send_rts_threshold(priv, priv->rts_threshold);
9218 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
9222 static int ipw_wx_get_rts(struct net_device *dev,
9223 struct iw_request_info *info,
9224 union iwreq_data *wrqu, char *extra)
9226 struct ipw_priv *priv = ieee80211_priv(dev);
9228 wrqu->rts.value = priv->rts_threshold;
9229 wrqu->rts.fixed = 0; /* no auto select */
9230 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
9232 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
9236 static int ipw_wx_set_txpow(struct net_device *dev,
9237 struct iw_request_info *info,
9238 union iwreq_data *wrqu, char *extra)
9240 struct ipw_priv *priv = ieee80211_priv(dev);
9244 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
9249 if (!wrqu->power.fixed)
9250 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9252 if (wrqu->power.flags != IW_TXPOW_DBM) {
9257 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
9258 (wrqu->power.value < IPW_TX_POWER_MIN)) {
9263 priv->tx_power = wrqu->power.value;
9264 err = ipw_set_tx_power(priv);
9270 static int ipw_wx_get_txpow(struct net_device *dev,
9271 struct iw_request_info *info,
9272 union iwreq_data *wrqu, char *extra)
9274 struct ipw_priv *priv = ieee80211_priv(dev);
9276 wrqu->power.value = priv->tx_power;
9277 wrqu->power.fixed = 1;
9278 wrqu->power.flags = IW_TXPOW_DBM;
9279 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
9282 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
9283 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9288 static int ipw_wx_set_frag(struct net_device *dev,
9289 struct iw_request_info *info,
9290 union iwreq_data *wrqu, char *extra)
9292 struct ipw_priv *priv = ieee80211_priv(dev);
9294 if (wrqu->frag.disabled)
9295 priv->ieee->fts = DEFAULT_FTS;
9297 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
9298 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
9303 priv->ieee->fts = wrqu->frag.value & ~0x1;
9306 ipw_send_frag_threshold(priv, wrqu->frag.value);
9308 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
9312 static int ipw_wx_get_frag(struct net_device *dev,
9313 struct iw_request_info *info,
9314 union iwreq_data *wrqu, char *extra)
9316 struct ipw_priv *priv = ieee80211_priv(dev);
9318 wrqu->frag.value = priv->ieee->fts;
9319 wrqu->frag.fixed = 0; /* no auto select */
9320 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
9322 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
9327 static int ipw_wx_set_retry(struct net_device *dev,
9328 struct iw_request_info *info,
9329 union iwreq_data *wrqu, char *extra)
9331 struct ipw_priv *priv = ieee80211_priv(dev);
9333 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9336 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9339 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
9343 if (wrqu->retry.flags & IW_RETRY_MIN)
9344 priv->short_retry_limit = (u8) wrqu->retry.value;
9345 else if (wrqu->retry.flags & IW_RETRY_MAX)
9346 priv->long_retry_limit = (u8) wrqu->retry.value;
9348 priv->short_retry_limit = (u8) wrqu->retry.value;
9349 priv->long_retry_limit = (u8) wrqu->retry.value;
9352 ipw_send_retry_limit(priv, priv->short_retry_limit,
9353 priv->long_retry_limit);
9355 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9356 priv->short_retry_limit, priv->long_retry_limit);
9360 static int ipw_wx_get_retry(struct net_device *dev,
9361 struct iw_request_info *info,
9362 union iwreq_data *wrqu, char *extra)
9364 struct ipw_priv *priv = ieee80211_priv(dev);
9367 wrqu->retry.disabled = 0;
9369 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
9374 if (wrqu->retry.flags & IW_RETRY_MAX) {
9375 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
9376 wrqu->retry.value = priv->long_retry_limit;
9377 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
9378 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
9379 wrqu->retry.value = priv->short_retry_limit;
9381 wrqu->retry.flags = IW_RETRY_LIMIT;
9382 wrqu->retry.value = priv->short_retry_limit;
9386 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
9391 #if WIRELESS_EXT > 17
9392 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
9395 struct ipw_scan_request_ext scan;
9396 int err = 0, scan_type;
9400 if (priv->status & STATUS_RF_KILL_MASK) {
9401 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
9402 priv->status |= STATUS_SCAN_PENDING;
9406 IPW_DEBUG_HC("starting request direct scan!\n");
9408 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
9409 err = wait_event_interruptible(priv->wait_state,
9411 status & (STATUS_SCANNING |
9412 STATUS_SCAN_ABORTING)));
9414 IPW_DEBUG_HC("aborting direct scan");
9418 memset(&scan, 0, sizeof(scan));
9420 if (priv->config & CFG_SPEED_SCAN)
9421 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
9424 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
9427 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
9429 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
9430 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
9432 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
9434 err = ipw_send_ssid(priv, essid, essid_len);
9436 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
9439 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
9441 ipw_add_scan_channels(priv, &scan, scan_type);
9443 err = ipw_send_scan_request_ext(priv, &scan);
9445 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
9449 priv->status |= STATUS_SCANNING;
9455 #endif /* WIRELESS_EXT > 17 */
9457 static int ipw_wx_set_scan(struct net_device *dev,
9458 struct iw_request_info *info,
9459 union iwreq_data *wrqu, char *extra)
9461 struct ipw_priv *priv = ieee80211_priv(dev);
9462 #if WIRELESS_EXT > 17
9463 struct iw_scan_req *req = NULL;
9464 if (wrqu->data.length
9465 && wrqu->data.length == sizeof(struct iw_scan_req)) {
9466 req = (struct iw_scan_req *)extra;
9467 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9468 ipw_request_direct_scan(priv, req->essid,
9474 IPW_DEBUG_WX("Start scan\n");
9476 queue_work(priv->workqueue, &priv->request_scan);
9481 static int ipw_wx_get_scan(struct net_device *dev,
9482 struct iw_request_info *info,
9483 union iwreq_data *wrqu, char *extra)
9485 struct ipw_priv *priv = ieee80211_priv(dev);
9486 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9489 static int ipw_wx_set_encode(struct net_device *dev,
9490 struct iw_request_info *info,
9491 union iwreq_data *wrqu, char *key)
9493 struct ipw_priv *priv = ieee80211_priv(dev);
9495 u32 cap = priv->capability;
9498 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9500 /* In IBSS mode, we need to notify the firmware to update
9501 * the beacon info after we changed the capability. */
9502 if (cap != priv->capability &&
9503 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9504 priv->status & STATUS_ASSOCIATED)
9505 ipw_disassociate(priv);
9511 static int ipw_wx_get_encode(struct net_device *dev,
9512 struct iw_request_info *info,
9513 union iwreq_data *wrqu, char *key)
9515 struct ipw_priv *priv = ieee80211_priv(dev);
9516 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9519 static int ipw_wx_set_power(struct net_device *dev,
9520 struct iw_request_info *info,
9521 union iwreq_data *wrqu, char *extra)
9523 struct ipw_priv *priv = ieee80211_priv(dev);
9526 if (wrqu->power.disabled) {
9527 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9528 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9530 IPW_DEBUG_WX("failed setting power mode.\n");
9534 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9539 switch (wrqu->power.flags & IW_POWER_MODE) {
9540 case IW_POWER_ON: /* If not specified */
9541 case IW_POWER_MODE: /* If set all mask */
9542 case IW_POWER_ALL_R: /* If explicitely state all */
9544 default: /* Otherwise we don't support it */
9545 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9551 /* If the user hasn't specified a power management mode yet, default
9553 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9554 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9556 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9557 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9559 IPW_DEBUG_WX("failed setting power mode.\n");
9564 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9569 static int ipw_wx_get_power(struct net_device *dev,
9570 struct iw_request_info *info,
9571 union iwreq_data *wrqu, char *extra)
9573 struct ipw_priv *priv = ieee80211_priv(dev);
9575 if (!(priv->power_mode & IPW_POWER_ENABLED))
9576 wrqu->power.disabled = 1;
9578 wrqu->power.disabled = 0;
9581 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9586 static int ipw_wx_set_powermode(struct net_device *dev,
9587 struct iw_request_info *info,
9588 union iwreq_data *wrqu, char *extra)
9590 struct ipw_priv *priv = ieee80211_priv(dev);
9591 int mode = *(int *)extra;
9594 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9595 mode = IPW_POWER_AC;
9596 priv->power_mode = mode;
9598 priv->power_mode = IPW_POWER_ENABLED | mode;
9601 if (priv->power_mode != mode) {
9602 err = ipw_send_power_mode(priv, mode);
9605 IPW_DEBUG_WX("failed setting power mode.\n");
9614 #define MAX_WX_STRING 80
9615 static int ipw_wx_get_powermode(struct net_device *dev,
9616 struct iw_request_info *info,
9617 union iwreq_data *wrqu, char *extra)
9619 struct ipw_priv *priv = ieee80211_priv(dev);
9620 int level = IPW_POWER_LEVEL(priv->power_mode);
9623 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9627 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9629 case IPW_POWER_BATTERY:
9630 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9633 p += snprintf(p, MAX_WX_STRING - (p - extra),
9634 "(Timeout %dms, Period %dms)",
9635 timeout_duration[level - 1] / 1000,
9636 period_duration[level - 1] / 1000);
9639 if (!(priv->power_mode & IPW_POWER_ENABLED))
9640 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9642 wrqu->data.length = p - extra + 1;
9647 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9648 struct iw_request_info *info,
9649 union iwreq_data *wrqu, char *extra)
9651 struct ipw_priv *priv = ieee80211_priv(dev);
9652 int mode = *(int *)extra;
9653 u8 band = 0, modulation = 0;
9655 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9656 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9660 if (priv->adapter == IPW_2915ABG) {
9661 priv->ieee->abg_true = 1;
9662 if (mode & IEEE_A) {
9663 band |= IEEE80211_52GHZ_BAND;
9664 modulation |= IEEE80211_OFDM_MODULATION;
9666 priv->ieee->abg_true = 0;
9668 if (mode & IEEE_A) {
9669 IPW_WARNING("Attempt to set 2200BG into "
9675 priv->ieee->abg_true = 0;
9678 if (mode & IEEE_B) {
9679 band |= IEEE80211_24GHZ_BAND;
9680 modulation |= IEEE80211_CCK_MODULATION;
9682 priv->ieee->abg_true = 0;
9684 if (mode & IEEE_G) {
9685 band |= IEEE80211_24GHZ_BAND;
9686 modulation |= IEEE80211_OFDM_MODULATION;
9688 priv->ieee->abg_true = 0;
9690 priv->ieee->mode = mode;
9691 priv->ieee->freq_band = band;
9692 priv->ieee->modulation = modulation;
9693 init_supported_rates(priv, &priv->rates);
9695 /* Network configuration changed -- force [re]association */
9696 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9697 if (!ipw_disassociate(priv)) {
9698 ipw_send_supported_rates(priv, &priv->rates);
9699 ipw_associate(priv);
9702 /* Update the band LEDs */
9703 ipw_led_band_on(priv);
9705 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9706 mode & IEEE_A ? 'a' : '.',
9707 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9712 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9713 struct iw_request_info *info,
9714 union iwreq_data *wrqu, char *extra)
9716 struct ipw_priv *priv = ieee80211_priv(dev);
9718 switch (priv->ieee->mode) {
9720 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9723 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9725 case IEEE_A | IEEE_B:
9726 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9729 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9731 case IEEE_A | IEEE_G:
9732 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9734 case IEEE_B | IEEE_G:
9735 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9737 case IEEE_A | IEEE_B | IEEE_G:
9738 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9741 strncpy(extra, "unknown", MAX_WX_STRING);
9745 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9747 wrqu->data.length = strlen(extra) + 1;
9753 static int ipw_wx_set_preamble(struct net_device *dev,
9754 struct iw_request_info *info,
9755 union iwreq_data *wrqu, char *extra)
9757 struct ipw_priv *priv = ieee80211_priv(dev);
9758 int mode = *(int *)extra;
9760 /* Switching from SHORT -> LONG requires a disassociation */
9762 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9763 priv->config |= CFG_PREAMBLE_LONG;
9765 /* Network configuration changed -- force [re]association */
9767 ("[re]association triggered due to preamble change.\n");
9768 if (!ipw_disassociate(priv))
9769 ipw_associate(priv);
9775 priv->config &= ~CFG_PREAMBLE_LONG;
9786 static int ipw_wx_get_preamble(struct net_device *dev,
9787 struct iw_request_info *info,
9788 union iwreq_data *wrqu, char *extra)
9790 struct ipw_priv *priv = ieee80211_priv(dev);
9792 if (priv->config & CFG_PREAMBLE_LONG)
9793 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9795 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9800 #ifdef CONFIG_IPW2200_MONITOR
9801 static int ipw_wx_set_monitor(struct net_device *dev,
9802 struct iw_request_info *info,
9803 union iwreq_data *wrqu, char *extra)
9805 struct ipw_priv *priv = ieee80211_priv(dev);
9806 int *parms = (int *)extra;
9807 int enable = (parms[0] > 0);
9809 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9811 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9812 #ifdef CONFIG_IEEE80211_RADIOTAP
9813 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9815 priv->net_dev->type = ARPHRD_IEEE80211;
9817 queue_work(priv->workqueue, &priv->adapter_restart);
9820 ipw_set_channel(priv, parms[1]);
9822 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9826 priv->net_dev->type = ARPHRD_ETHER;
9827 queue_work(priv->workqueue, &priv->adapter_restart);
9833 #endif // CONFIG_IPW2200_MONITOR
9835 static int ipw_wx_reset(struct net_device *dev,
9836 struct iw_request_info *info,
9837 union iwreq_data *wrqu, char *extra)
9839 struct ipw_priv *priv = ieee80211_priv(dev);
9840 IPW_DEBUG_WX("RESET\n");
9841 queue_work(priv->workqueue, &priv->adapter_restart);
9845 static int ipw_wx_sw_reset(struct net_device *dev,
9846 struct iw_request_info *info,
9847 union iwreq_data *wrqu, char *extra)
9849 struct ipw_priv *priv = ieee80211_priv(dev);
9850 union iwreq_data wrqu_sec = {
9852 .flags = IW_ENCODE_DISABLED,
9857 IPW_DEBUG_WX("SW_RESET\n");
9861 ret = ipw_sw_reset(priv, 0);
9864 ipw_adapter_restart(priv);
9867 /* The SW reset bit might have been toggled on by the 'disable'
9868 * module parameter, so take appropriate action */
9869 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9872 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9875 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9876 /* Configuration likely changed -- force [re]association */
9877 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9879 if (!ipw_disassociate(priv))
9880 ipw_associate(priv);
9888 /* Rebase the WE IOCTLs to zero for the handler array */
9889 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9890 static iw_handler ipw_wx_handlers[] = {
9891 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9892 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9893 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9894 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9895 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9896 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9897 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9898 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9899 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9900 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9901 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9902 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9903 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9904 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9905 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9906 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9907 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9908 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9909 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9910 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9911 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9912 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9913 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9914 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9915 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9916 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9917 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9918 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9919 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9920 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9921 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9922 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9923 #if WIRELESS_EXT > 17
9924 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9925 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9926 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9927 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9928 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9929 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9930 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9935 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9939 IPW_PRIV_SET_PREAMBLE,
9940 IPW_PRIV_GET_PREAMBLE,
9943 #ifdef CONFIG_IPW2200_MONITOR
9944 IPW_PRIV_SET_MONITOR,
9948 static struct iw_priv_args ipw_priv_args[] = {
9950 .cmd = IPW_PRIV_SET_POWER,
9951 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9952 .name = "set_power"},
9954 .cmd = IPW_PRIV_GET_POWER,
9955 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9956 .name = "get_power"},
9958 .cmd = IPW_PRIV_SET_MODE,
9959 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9960 .name = "set_mode"},
9962 .cmd = IPW_PRIV_GET_MODE,
9963 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9964 .name = "get_mode"},
9966 .cmd = IPW_PRIV_SET_PREAMBLE,
9967 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9968 .name = "set_preamble"},
9970 .cmd = IPW_PRIV_GET_PREAMBLE,
9971 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9972 .name = "get_preamble"},
9975 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9978 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9979 #ifdef CONFIG_IPW2200_MONITOR
9981 IPW_PRIV_SET_MONITOR,
9982 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9983 #endif /* CONFIG_IPW2200_MONITOR */
9986 static iw_handler ipw_priv_handler[] = {
9987 ipw_wx_set_powermode,
9988 ipw_wx_get_powermode,
9989 ipw_wx_set_wireless_mode,
9990 ipw_wx_get_wireless_mode,
9991 ipw_wx_set_preamble,
9992 ipw_wx_get_preamble,
9995 #ifdef CONFIG_IPW2200_MONITOR
10000 static struct iw_handler_def ipw_wx_handler_def = {
10001 .standard = ipw_wx_handlers,
10002 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
10003 .num_private = ARRAY_SIZE(ipw_priv_handler),
10004 .num_private_args = ARRAY_SIZE(ipw_priv_args),
10005 .private = ipw_priv_handler,
10006 .private_args = ipw_priv_args,
10009 static struct iw_public_data ipw_wx_data;
10012 * Get wireless statistics.
10013 * Called by /proc/net/wireless
10014 * Also called by SIOCGIWSTATS
10016 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
10018 struct ipw_priv *priv = ieee80211_priv(dev);
10019 struct iw_statistics *wstats;
10021 wstats = &priv->wstats;
10023 /* if hw is disabled, then ipw_get_ordinal() can't be called.
10024 * netdev->get_wireless_stats seems to be called before fw is
10025 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
10026 * and associated; if not associcated, the values are all meaningless
10027 * anyway, so set them all to NULL and INVALID */
10028 if (!(priv->status & STATUS_ASSOCIATED)) {
10029 wstats->miss.beacon = 0;
10030 wstats->discard.retries = 0;
10031 wstats->qual.qual = 0;
10032 wstats->qual.level = 0;
10033 wstats->qual.noise = 0;
10034 wstats->qual.updated = 7;
10035 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
10036 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
10040 wstats->qual.qual = priv->quality;
10041 wstats->qual.level = average_value(&priv->average_rssi);
10042 wstats->qual.noise = average_value(&priv->average_noise);
10043 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
10044 IW_QUAL_NOISE_UPDATED;
10046 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
10047 wstats->discard.retries = priv->last_tx_failures;
10048 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
10050 /* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
10051 goto fail_get_ordinal;
10052 wstats->discard.retries += tx_retry; */
10057 /* net device stuff */
10059 static inline void init_sys_config(struct ipw_sys_config *sys_config)
10061 memset(sys_config, 0, sizeof(struct ipw_sys_config));
10062 sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
10063 sys_config->answer_broadcast_ssid_probe = 0;
10064 sys_config->accept_all_data_frames = 0;
10065 sys_config->accept_non_directed_frames = 1;
10066 sys_config->exclude_unicast_unencrypted = 0;
10067 sys_config->disable_unicast_decryption = 1;
10068 sys_config->exclude_multicast_unencrypted = 0;
10069 sys_config->disable_multicast_decryption = 1;
10070 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
10071 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
10072 sys_config->dot11g_auto_detection = 0;
10073 sys_config->enable_cts_to_self = 0;
10074 sys_config->bt_coexist_collision_thr = 0;
10075 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
10078 static int ipw_net_open(struct net_device *dev)
10080 struct ipw_priv *priv = ieee80211_priv(dev);
10081 IPW_DEBUG_INFO("dev->open\n");
10082 /* we should be verifying the device is ready to be opened */
10084 if (!(priv->status & STATUS_RF_KILL_MASK) &&
10085 (priv->status & STATUS_ASSOCIATED))
10086 netif_start_queue(dev);
10091 static int ipw_net_stop(struct net_device *dev)
10093 IPW_DEBUG_INFO("dev->close\n");
10094 netif_stop_queue(dev);
10101 modify to send one tfd per fragment instead of using chunking. otherwise
10102 we need to heavily modify the ieee80211_skb_to_txb.
10105 static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
10108 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
10109 txb->fragments[0]->data;
10111 struct tfd_frame *tfd;
10112 #ifdef CONFIG_IPW_QOS
10113 int tx_id = ipw_get_tx_queue_number(priv, pri);
10114 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10116 struct clx2_tx_queue *txq = &priv->txq[0];
10118 struct clx2_queue *q = &txq->q;
10119 u8 id, hdr_len, unicast;
10120 u16 remaining_bytes;
10123 /* If there isn't room in the queue, we return busy and let the
10124 * network stack requeue the packet for us */
10125 if (ipw_queue_space(q) < q->high_mark)
10126 return NETDEV_TX_BUSY;
10128 switch (priv->ieee->iw_mode) {
10129 case IW_MODE_ADHOC:
10130 hdr_len = IEEE80211_3ADDR_LEN;
10131 unicast = !is_multicast_ether_addr(hdr->addr1);
10132 id = ipw_find_station(priv, hdr->addr1);
10133 if (id == IPW_INVALID_STATION) {
10134 id = ipw_add_station(priv, hdr->addr1);
10135 if (id == IPW_INVALID_STATION) {
10136 IPW_WARNING("Attempt to send data to "
10137 "invalid cell: " MAC_FMT "\n",
10138 MAC_ARG(hdr->addr1));
10144 case IW_MODE_INFRA:
10146 unicast = !is_multicast_ether_addr(hdr->addr3);
10147 hdr_len = IEEE80211_3ADDR_LEN;
10152 tfd = &txq->bd[q->first_empty];
10153 txq->txb[q->first_empty] = txb;
10154 memset(tfd, 0, sizeof(*tfd));
10155 tfd->u.data.station_number = id;
10157 tfd->control_flags.message_type = TX_FRAME_TYPE;
10158 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10160 tfd->u.data.cmd_id = DINO_CMD_TX;
10161 tfd->u.data.len = cpu_to_le16(txb->payload_size);
10162 remaining_bytes = txb->payload_size;
10164 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
10165 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
10167 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
10169 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10170 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
10172 fc = le16_to_cpu(hdr->frame_ctl);
10173 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
10175 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10177 if (likely(unicast))
10178 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10180 if (txb->encrypted && !priv->ieee->host_encrypt) {
10181 switch (priv->ieee->sec.level) {
10183 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10184 IEEE80211_FCTL_PROTECTED;
10185 /* XXX: ACK flag must be set for CCMP even if it
10186 * is a multicast/broadcast packet, because CCMP
10187 * group communication encrypted by GTK is
10188 * actually done by the AP. */
10190 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10192 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10193 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10194 tfd->u.data.key_index = 0;
10195 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10198 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10199 IEEE80211_FCTL_PROTECTED;
10200 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10201 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10202 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10205 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10206 IEEE80211_FCTL_PROTECTED;
10207 tfd->u.data.key_index = priv->ieee->tx_keyidx;
10208 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
10210 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10212 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10217 printk(KERN_ERR "Unknow security level %d\n",
10218 priv->ieee->sec.level);
10222 /* No hardware encryption */
10223 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10225 #ifdef CONFIG_IPW_QOS
10226 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
10227 #endif /* CONFIG_IPW_QOS */
10230 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10232 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
10233 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10234 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10235 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
10236 i, le32_to_cpu(tfd->u.data.num_chunks),
10237 txb->fragments[i]->len - hdr_len);
10238 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
10239 i, tfd->u.data.num_chunks,
10240 txb->fragments[i]->len - hdr_len);
10241 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
10242 txb->fragments[i]->len - hdr_len);
10244 tfd->u.data.chunk_ptr[i] =
10245 cpu_to_le32(pci_map_single
10247 txb->fragments[i]->data + hdr_len,
10248 txb->fragments[i]->len - hdr_len,
10249 PCI_DMA_TODEVICE));
10250 tfd->u.data.chunk_len[i] =
10251 cpu_to_le16(txb->fragments[i]->len - hdr_len);
10254 if (i != txb->nr_frags) {
10255 struct sk_buff *skb;
10256 u16 remaining_bytes = 0;
10259 for (j = i; j < txb->nr_frags; j++)
10260 remaining_bytes += txb->fragments[j]->len - hdr_len;
10262 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
10264 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
10266 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
10267 for (j = i; j < txb->nr_frags; j++) {
10268 int size = txb->fragments[j]->len - hdr_len;
10270 printk(KERN_INFO "Adding frag %d %d...\n",
10272 memcpy(skb_put(skb, size),
10273 txb->fragments[j]->data + hdr_len, size);
10275 dev_kfree_skb_any(txb->fragments[i]);
10276 txb->fragments[i] = skb;
10277 tfd->u.data.chunk_ptr[i] =
10278 cpu_to_le32(pci_map_single
10279 (priv->pci_dev, skb->data,
10280 tfd->u.data.chunk_len[i],
10281 PCI_DMA_TODEVICE));
10283 tfd->u.data.num_chunks =
10284 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
10290 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10291 ipw_write32(priv, q->reg_w, q->first_empty);
10293 return NETDEV_TX_OK;
10296 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
10297 ieee80211_txb_free(txb);
10298 return NETDEV_TX_OK;
10301 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
10303 struct ipw_priv *priv = ieee80211_priv(dev);
10304 #ifdef CONFIG_IPW_QOS
10305 int tx_id = ipw_get_tx_queue_number(priv, pri);
10306 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10308 struct clx2_tx_queue *txq = &priv->txq[0];
10309 #endif /* CONFIG_IPW_QOS */
10311 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
10317 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
10318 struct net_device *dev, int pri)
10320 struct ipw_priv *priv = ieee80211_priv(dev);
10321 unsigned long flags;
10324 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
10325 spin_lock_irqsave(&priv->lock, flags);
10327 if (!(priv->status & STATUS_ASSOCIATED)) {
10328 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
10329 priv->ieee->stats.tx_carrier_errors++;
10330 netif_stop_queue(dev);
10334 ret = ipw_tx_skb(priv, txb, pri);
10335 if (ret == NETDEV_TX_OK)
10336 __ipw_led_activity_on(priv);
10337 spin_unlock_irqrestore(&priv->lock, flags);
10342 spin_unlock_irqrestore(&priv->lock, flags);
10346 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
10348 struct ipw_priv *priv = ieee80211_priv(dev);
10350 priv->ieee->stats.tx_packets = priv->tx_packets;
10351 priv->ieee->stats.rx_packets = priv->rx_packets;
10352 return &priv->ieee->stats;
10355 static void ipw_net_set_multicast_list(struct net_device *dev)
10360 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
10362 struct ipw_priv *priv = ieee80211_priv(dev);
10363 struct sockaddr *addr = p;
10364 if (!is_valid_ether_addr(addr->sa_data))
10365 return -EADDRNOTAVAIL;
10367 priv->config |= CFG_CUSTOM_MAC;
10368 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
10369 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
10370 priv->net_dev->name, MAC_ARG(priv->mac_addr));
10371 queue_work(priv->workqueue, &priv->adapter_restart);
10376 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
10377 struct ethtool_drvinfo *info)
10379 struct ipw_priv *p = ieee80211_priv(dev);
10384 strcpy(info->driver, DRV_NAME);
10385 strcpy(info->version, DRV_VERSION);
10387 len = sizeof(vers);
10388 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
10389 len = sizeof(date);
10390 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
10392 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
10394 strcpy(info->bus_info, pci_name(p->pci_dev));
10395 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
10398 static u32 ipw_ethtool_get_link(struct net_device *dev)
10400 struct ipw_priv *priv = ieee80211_priv(dev);
10401 return (priv->status & STATUS_ASSOCIATED) != 0;
10404 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10406 return IPW_EEPROM_IMAGE_SIZE;
10409 static int ipw_ethtool_get_eeprom(struct net_device *dev,
10410 struct ethtool_eeprom *eeprom, u8 * bytes)
10412 struct ipw_priv *p = ieee80211_priv(dev);
10414 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10417 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
10422 static int ipw_ethtool_set_eeprom(struct net_device *dev,
10423 struct ethtool_eeprom *eeprom, u8 * bytes)
10425 struct ipw_priv *p = ieee80211_priv(dev);
10428 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10431 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
10432 for (i = IPW_EEPROM_DATA;
10433 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
10434 ipw_write8(p, i, p->eeprom[i]);
10439 static struct ethtool_ops ipw_ethtool_ops = {
10440 .get_link = ipw_ethtool_get_link,
10441 .get_drvinfo = ipw_ethtool_get_drvinfo,
10442 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10443 .get_eeprom = ipw_ethtool_get_eeprom,
10444 .set_eeprom = ipw_ethtool_set_eeprom,
10447 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
10449 struct ipw_priv *priv = data;
10450 u32 inta, inta_mask;
10455 spin_lock(&priv->lock);
10457 if (!(priv->status & STATUS_INT_ENABLED)) {
10462 inta = ipw_read32(priv, IPW_INTA_RW);
10463 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
10465 if (inta == 0xFFFFFFFF) {
10466 /* Hardware disappeared */
10467 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10471 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10472 /* Shared interrupt */
10476 /* tell the device to stop sending interrupts */
10477 ipw_disable_interrupts(priv);
10479 /* ack current interrupts */
10480 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10481 ipw_write32(priv, IPW_INTA_RW, inta);
10483 /* Cache INTA value for our tasklet */
10484 priv->isr_inta = inta;
10486 tasklet_schedule(&priv->irq_tasklet);
10488 spin_unlock(&priv->lock);
10490 return IRQ_HANDLED;
10492 spin_unlock(&priv->lock);
10496 static void ipw_rf_kill(void *adapter)
10498 struct ipw_priv *priv = adapter;
10499 unsigned long flags;
10501 spin_lock_irqsave(&priv->lock, flags);
10503 if (rf_kill_active(priv)) {
10504 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10505 if (priv->workqueue)
10506 queue_delayed_work(priv->workqueue,
10507 &priv->rf_kill, 2 * HZ);
10511 /* RF Kill is now disabled, so bring the device back up */
10513 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10514 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10517 /* we can not do an adapter restart while inside an irq lock */
10518 queue_work(priv->workqueue, &priv->adapter_restart);
10520 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10524 spin_unlock_irqrestore(&priv->lock, flags);
10527 static void ipw_bg_rf_kill(void *data)
10529 struct ipw_priv *priv = data;
10535 void ipw_link_up(struct ipw_priv *priv)
10537 priv->last_seq_num = -1;
10538 priv->last_frag_num = -1;
10539 priv->last_packet_time = 0;
10541 netif_carrier_on(priv->net_dev);
10542 if (netif_queue_stopped(priv->net_dev)) {
10543 IPW_DEBUG_NOTIF("waking queue\n");
10544 netif_wake_queue(priv->net_dev);
10546 IPW_DEBUG_NOTIF("starting queue\n");
10547 netif_start_queue(priv->net_dev);
10550 cancel_delayed_work(&priv->request_scan);
10551 ipw_reset_stats(priv);
10552 /* Ensure the rate is updated immediately */
10553 priv->last_rate = ipw_get_current_rate(priv);
10554 ipw_gather_stats(priv);
10555 ipw_led_link_up(priv);
10556 notify_wx_assoc_event(priv);
10558 if (priv->config & CFG_BACKGROUND_SCAN)
10559 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10562 static void ipw_bg_link_up(void *data)
10564 struct ipw_priv *priv = data;
10570 void ipw_link_down(struct ipw_priv *priv)
10572 ipw_led_link_down(priv);
10573 netif_carrier_off(priv->net_dev);
10574 netif_stop_queue(priv->net_dev);
10575 notify_wx_assoc_event(priv);
10577 /* Cancel any queued work ... */
10578 cancel_delayed_work(&priv->request_scan);
10579 cancel_delayed_work(&priv->adhoc_check);
10580 cancel_delayed_work(&priv->gather_stats);
10582 ipw_reset_stats(priv);
10584 if (!(priv->status & STATUS_EXIT_PENDING)) {
10585 /* Queue up another scan... */
10586 queue_work(priv->workqueue, &priv->request_scan);
10590 static void ipw_bg_link_down(void *data)
10592 struct ipw_priv *priv = data;
10594 ipw_link_down(data);
10598 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10602 priv->workqueue = create_workqueue(DRV_NAME);
10603 init_waitqueue_head(&priv->wait_command_queue);
10604 init_waitqueue_head(&priv->wait_state);
10606 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10607 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10608 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10609 INIT_WORK(&priv->system_config, ipw_system_config, priv);
10610 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10611 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10612 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10613 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10614 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10615 INIT_WORK(&priv->request_scan,
10616 (void (*)(void *))ipw_request_scan, priv);
10617 INIT_WORK(&priv->gather_stats,
10618 (void (*)(void *))ipw_bg_gather_stats, priv);
10619 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10620 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10621 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10622 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10623 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10624 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10626 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10628 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10630 INIT_WORK(&priv->merge_networks,
10631 (void (*)(void *))ipw_merge_adhoc_network, priv);
10633 #ifdef CONFIG_IPW_QOS
10634 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10636 #endif /* CONFIG_IPW_QOS */
10638 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10639 ipw_irq_tasklet, (unsigned long)priv);
10644 static void shim__set_security(struct net_device *dev,
10645 struct ieee80211_security *sec)
10647 struct ipw_priv *priv = ieee80211_priv(dev);
10649 for (i = 0; i < 4; i++) {
10650 if (sec->flags & (1 << i)) {
10651 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10652 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10653 if (sec->key_sizes[i] == 0)
10654 priv->ieee->sec.flags &= ~(1 << i);
10656 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10657 sec->key_sizes[i]);
10658 priv->ieee->sec.flags |= (1 << i);
10660 priv->status |= STATUS_SECURITY_UPDATED;
10661 } else if (sec->level != SEC_LEVEL_1)
10662 priv->ieee->sec.flags &= ~(1 << i);
10665 if (sec->flags & SEC_ACTIVE_KEY) {
10666 if (sec->active_key <= 3) {
10667 priv->ieee->sec.active_key = sec->active_key;
10668 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10670 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10671 priv->status |= STATUS_SECURITY_UPDATED;
10673 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10675 if ((sec->flags & SEC_AUTH_MODE) &&
10676 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10677 priv->ieee->sec.auth_mode = sec->auth_mode;
10678 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10679 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10680 priv->capability |= CAP_SHARED_KEY;
10682 priv->capability &= ~CAP_SHARED_KEY;
10683 priv->status |= STATUS_SECURITY_UPDATED;
10686 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10687 priv->ieee->sec.flags |= SEC_ENABLED;
10688 priv->ieee->sec.enabled = sec->enabled;
10689 priv->status |= STATUS_SECURITY_UPDATED;
10691 priv->capability |= CAP_PRIVACY_ON;
10693 priv->capability &= ~CAP_PRIVACY_ON;
10696 if (sec->flags & SEC_ENCRYPT)
10697 priv->ieee->sec.encrypt = sec->encrypt;
10699 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10700 priv->ieee->sec.level = sec->level;
10701 priv->ieee->sec.flags |= SEC_LEVEL;
10702 priv->status |= STATUS_SECURITY_UPDATED;
10705 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10706 ipw_set_hwcrypto_keys(priv);
10708 /* To match current functionality of ipw2100 (which works well w/
10709 * various supplicants, we don't force a disassociate if the
10710 * privacy capability changes ... */
10712 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10713 (((priv->assoc_request.capability &
10714 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10715 (!(priv->assoc_request.capability &
10716 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10717 IPW_DEBUG_ASSOC("Disassociating due to capability "
10719 ipw_disassociate(priv);
10724 static int init_supported_rates(struct ipw_priv *priv,
10725 struct ipw_supported_rates *rates)
10727 /* TODO: Mask out rates based on priv->rates_mask */
10729 memset(rates, 0, sizeof(*rates));
10730 /* configure supported rates */
10731 switch (priv->ieee->freq_band) {
10732 case IEEE80211_52GHZ_BAND:
10733 rates->ieee_mode = IPW_A_MODE;
10734 rates->purpose = IPW_RATE_CAPABILITIES;
10735 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10736 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10739 default: /* Mixed or 2.4Ghz */
10740 rates->ieee_mode = IPW_G_MODE;
10741 rates->purpose = IPW_RATE_CAPABILITIES;
10742 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10743 IEEE80211_CCK_DEFAULT_RATES_MASK);
10744 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10745 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10746 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10754 static int ipw_config(struct ipw_priv *priv)
10756 /* This is only called from ipw_up, which resets/reloads the firmware
10757 so, we don't need to first disable the card before we configure
10759 if (ipw_set_tx_power(priv))
10762 /* initialize adapter address */
10763 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10766 /* set basic system config settings */
10767 init_sys_config(&priv->sys_config);
10768 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10769 priv->sys_config.answer_broadcast_ssid_probe = 1;
10771 priv->sys_config.answer_broadcast_ssid_probe = 0;
10773 if (ipw_send_system_config(priv, &priv->sys_config))
10776 init_supported_rates(priv, &priv->rates);
10777 if (ipw_send_supported_rates(priv, &priv->rates))
10780 /* Set request-to-send threshold */
10781 if (priv->rts_threshold) {
10782 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10785 #ifdef CONFIG_IPW_QOS
10786 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10787 ipw_qos_activate(priv, NULL);
10788 #endif /* CONFIG_IPW_QOS */
10790 if (ipw_set_random_seed(priv))
10793 /* final state transition to the RUN state */
10794 if (ipw_send_host_complete(priv))
10797 priv->status |= STATUS_INIT;
10799 ipw_led_init(priv);
10800 ipw_led_radio_on(priv);
10801 priv->notif_missed_beacons = 0;
10803 /* Set hardware WEP key if it is configured. */
10804 if ((priv->capability & CAP_PRIVACY_ON) &&
10805 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10806 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10807 ipw_set_hwcrypto_keys(priv);
10818 * These tables have been tested in conjunction with the
10819 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10821 * Altering this values, using it on other hardware, or in geographies
10822 * not intended for resale of the above mentioned Intel adapters has
10826 static const struct ieee80211_geo ipw_geos[] = {
10830 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10831 {2427, 4}, {2432, 5}, {2437, 6},
10832 {2442, 7}, {2447, 8}, {2452, 9},
10833 {2457, 10}, {2462, 11}},
10836 { /* Custom US/Canada */
10839 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10840 {2427, 4}, {2432, 5}, {2437, 6},
10841 {2442, 7}, {2447, 8}, {2452, 9},
10842 {2457, 10}, {2462, 11}},
10848 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10849 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10850 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10851 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10854 { /* Rest of World */
10857 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10858 {2427, 4}, {2432, 5}, {2437, 6},
10859 {2442, 7}, {2447, 8}, {2452, 9},
10860 {2457, 10}, {2462, 11}, {2467, 12},
10864 { /* Custom USA & Europe & High */
10867 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10868 {2427, 4}, {2432, 5}, {2437, 6},
10869 {2442, 7}, {2447, 8}, {2452, 9},
10870 {2457, 10}, {2462, 11}},
10876 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10877 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10878 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10879 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10887 { /* Custom NA & Europe */
10890 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10891 {2427, 4}, {2432, 5}, {2437, 6},
10892 {2442, 7}, {2447, 8}, {2452, 9},
10893 {2457, 10}, {2462, 11}},
10899 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10900 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10901 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10902 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10903 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10904 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10905 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10906 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10907 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10910 { /* Custom Japan */
10913 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10914 {2427, 4}, {2432, 5}, {2437, 6},
10915 {2442, 7}, {2447, 8}, {2452, 9},
10916 {2457, 10}, {2462, 11}},
10918 .a = {{5170, 34}, {5190, 38},
10919 {5210, 42}, {5230, 46}},
10925 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10926 {2427, 4}, {2432, 5}, {2437, 6},
10927 {2442, 7}, {2447, 8}, {2452, 9},
10928 {2457, 10}, {2462, 11}},
10934 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10935 {2427, 4}, {2432, 5}, {2437, 6},
10936 {2442, 7}, {2447, 8}, {2452, 9},
10937 {2457, 10}, {2462, 11}, {2467, 12},
10944 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10945 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10946 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10947 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10948 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10949 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10950 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10951 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10952 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10953 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10954 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10955 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10956 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10957 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10958 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10961 { /* Custom Japan */
10964 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10965 {2427, 4}, {2432, 5}, {2437, 6},
10966 {2442, 7}, {2447, 8}, {2452, 9},
10967 {2457, 10}, {2462, 11}, {2467, 12},
10968 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10970 .a = {{5170, 34}, {5190, 38},
10971 {5210, 42}, {5230, 46}},
10977 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10978 {2427, 4}, {2432, 5}, {2437, 6},
10979 {2442, 7}, {2447, 8}, {2452, 9},
10980 {2457, 10}, {2462, 11},
10981 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10982 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10984 .a = {{5745, 149}, {5765, 153},
10985 {5785, 157}, {5805, 161}},
10988 { /* Custom Europe */
10991 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10992 {2427, 4}, {2432, 5}, {2437, 6},
10993 {2442, 7}, {2447, 8}, {2452, 9},
10994 {2457, 10}, {2462, 11},
10995 {2467, 12}, {2472, 13}},
10997 .a = {{5180, 36}, {5200, 40},
10998 {5220, 44}, {5240, 48}},
11004 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11005 {2427, 4}, {2432, 5}, {2437, 6},
11006 {2442, 7}, {2447, 8}, {2452, 9},
11007 {2457, 10}, {2462, 11},
11008 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
11009 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
11011 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
11012 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
11013 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
11014 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
11015 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
11016 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
11017 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
11018 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
11019 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
11020 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
11021 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
11022 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
11023 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
11024 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
11025 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
11026 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
11027 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
11028 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
11029 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
11030 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
11031 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
11032 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
11033 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
11034 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
11040 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11041 {2427, 4}, {2432, 5}, {2437, 6},
11042 {2442, 7}, {2447, 8}, {2452, 9},
11043 {2457, 10}, {2462, 11}},
11045 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
11046 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
11047 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
11048 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
11049 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
11050 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
11051 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
11052 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
11053 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
11054 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
11055 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
11056 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
11057 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
11061 /* GEO code borrowed from ieee80211_geo.c */
11062 static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
11066 /* Driver needs to initialize the geography map before using
11067 * these helper functions */
11068 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
11070 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
11071 for (i = 0; i < ieee->geo.bg_channels; i++)
11072 /* NOTE: If G mode is currently supported but
11073 * this is a B only channel, we don't see it
11075 if ((ieee->geo.bg[i].channel == channel) &&
11076 (!(ieee->mode & IEEE_G) ||
11077 !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
11078 return IEEE80211_24GHZ_BAND;
11080 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
11081 for (i = 0; i < ieee->geo.a_channels; i++)
11082 if (ieee->geo.a[i].channel == channel)
11083 return IEEE80211_52GHZ_BAND;
11088 static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
11092 /* Driver needs to initialize the geography map before using
11093 * these helper functions */
11094 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
11096 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
11097 for (i = 0; i < ieee->geo.bg_channels; i++)
11098 if (ieee->geo.bg[i].channel == channel)
11101 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
11102 for (i = 0; i < ieee->geo.a_channels; i++)
11103 if (ieee->geo.a[i].channel == channel)
11109 static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
11113 /* Driver needs to initialize the geography map before using
11114 * these helper functions */
11115 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
11119 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
11120 for (i = 0; i < ieee->geo.bg_channels; i++)
11121 if (ieee->geo.bg[i].freq == freq)
11122 return ieee->geo.bg[i].channel;
11124 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
11125 for (i = 0; i < ieee->geo.a_channels; i++)
11126 if (ieee->geo.a[i].freq == freq)
11127 return ieee->geo.a[i].channel;
11132 static int ipw_set_geo(struct ieee80211_device *ieee,
11133 const struct ieee80211_geo *geo)
11135 memcpy(ieee->geo.name, geo->name, 3);
11136 ieee->geo.name[3] = '\0';
11137 ieee->geo.bg_channels = geo->bg_channels;
11138 ieee->geo.a_channels = geo->a_channels;
11139 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
11140 sizeof(struct ieee80211_channel));
11141 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
11142 sizeof(struct ieee80211_channel));
11146 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
11151 #define MAX_HW_RESTARTS 5
11152 static int ipw_up(struct ipw_priv *priv)
11156 if (priv->status & STATUS_EXIT_PENDING)
11159 if (cmdlog && !priv->cmdlog) {
11160 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
11162 if (priv->cmdlog == NULL) {
11163 IPW_ERROR("Error allocating %d command log entries.\n",
11166 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
11167 priv->cmdlog_len = cmdlog;
11171 for (i = 0; i < MAX_HW_RESTARTS; i++) {
11172 /* Load the microcode, firmware, and eeprom.
11173 * Also start the clocks. */
11174 rc = ipw_load(priv);
11176 IPW_ERROR("Unable to load firmware: %d\n", rc);
11180 ipw_init_ordinals(priv);
11181 if (!(priv->config & CFG_CUSTOM_MAC))
11182 eeprom_parse_mac(priv, priv->mac_addr);
11183 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
11185 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
11186 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11187 ipw_geos[j].name, 3))
11190 if (j == ARRAY_SIZE(ipw_geos))
11192 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
11193 IPW_WARNING("Could not set geography.");
11197 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
11198 j, priv->ieee->geo.name);
11200 if (priv->status & STATUS_RF_KILL_SW) {
11201 IPW_WARNING("Radio disabled by module parameter.\n");
11203 } else if (rf_kill_active(priv)) {
11204 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
11205 "Kill switch must be turned off for "
11206 "wireless networking to work.\n");
11207 queue_delayed_work(priv->workqueue, &priv->rf_kill,
11212 rc = ipw_config(priv);
11214 IPW_DEBUG_INFO("Configured device on count %i\n", i);
11216 /* If configure to try and auto-associate, kick
11218 queue_work(priv->workqueue, &priv->request_scan);
11223 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
11224 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
11225 i, MAX_HW_RESTARTS);
11227 /* We had an error bringing up the hardware, so take it
11228 * all the way back down so we can try again */
11232 /* tried to restart and config the device for as long as our
11233 * patience could withstand */
11234 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
11239 static void ipw_bg_up(void *data)
11241 struct ipw_priv *priv = data;
11247 static void ipw_deinit(struct ipw_priv *priv)
11251 if (priv->status & STATUS_SCANNING) {
11252 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
11253 ipw_abort_scan(priv);
11256 if (priv->status & STATUS_ASSOCIATED) {
11257 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
11258 ipw_disassociate(priv);
11261 ipw_led_shutdown(priv);
11263 /* Wait up to 1s for status to change to not scanning and not
11264 * associated (disassociation can take a while for a ful 802.11
11266 for (i = 1000; i && (priv->status &
11267 (STATUS_DISASSOCIATING |
11268 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11271 if (priv->status & (STATUS_DISASSOCIATING |
11272 STATUS_ASSOCIATED | STATUS_SCANNING))
11273 IPW_DEBUG_INFO("Still associated or scanning...\n");
11275 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11277 /* Attempt to disable the card */
11278 ipw_send_card_disable(priv, 0);
11280 priv->status &= ~STATUS_INIT;
11283 static void ipw_down(struct ipw_priv *priv)
11285 int exit_pending = priv->status & STATUS_EXIT_PENDING;
11287 priv->status |= STATUS_EXIT_PENDING;
11289 if (ipw_is_init(priv))
11292 /* Wipe out the EXIT_PENDING status bit if we are not actually
11293 * exiting the module */
11295 priv->status &= ~STATUS_EXIT_PENDING;
11297 /* tell the device to stop sending interrupts */
11298 ipw_disable_interrupts(priv);
11300 /* Clear all bits but the RF Kill */
11301 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
11302 netif_carrier_off(priv->net_dev);
11303 netif_stop_queue(priv->net_dev);
11305 ipw_stop_nic(priv);
11307 ipw_led_radio_off(priv);
11310 static void ipw_bg_down(void *data)
11312 struct ipw_priv *priv = data;
11318 #if WIRELESS_EXT < 18
11319 static int ipw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
11321 struct iwreq *wrq = (struct iwreq *)rq;
11324 case IPW_IOCTL_WPA_SUPPLICANT:
11325 ret = ipw_wpa_supplicant(dev, &wrq->u.data);
11329 return -EOPNOTSUPP;
11332 return -EOPNOTSUPP;
11336 /* Called by register_netdev() */
11337 static int ipw_net_init(struct net_device *dev)
11339 struct ipw_priv *priv = ieee80211_priv(dev);
11342 if (ipw_up(priv)) {
11351 /* PCI driver stuff */
11352 static struct pci_device_id card_ids[] = {
11353 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
11354 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
11355 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
11356 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
11357 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
11358 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
11359 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
11360 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
11361 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
11362 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
11363 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
11364 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
11365 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
11366 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
11367 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
11368 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
11369 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
11370 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
11371 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
11372 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
11373 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
11374 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
11376 /* required last entry */
11380 MODULE_DEVICE_TABLE(pci, card_ids);
11382 static struct attribute *ipw_sysfs_entries[] = {
11383 &dev_attr_rf_kill.attr,
11384 &dev_attr_direct_dword.attr,
11385 &dev_attr_indirect_byte.attr,
11386 &dev_attr_indirect_dword.attr,
11387 &dev_attr_mem_gpio_reg.attr,
11388 &dev_attr_command_event_reg.attr,
11389 &dev_attr_nic_type.attr,
11390 &dev_attr_status.attr,
11391 &dev_attr_cfg.attr,
11392 &dev_attr_error.attr,
11393 &dev_attr_event_log.attr,
11394 &dev_attr_cmd_log.attr,
11395 &dev_attr_eeprom_delay.attr,
11396 &dev_attr_ucode_version.attr,
11397 &dev_attr_rtc.attr,
11398 &dev_attr_scan_age.attr,
11399 &dev_attr_led.attr,
11400 &dev_attr_speed_scan.attr,
11401 &dev_attr_net_stats.attr,
11405 static struct attribute_group ipw_attribute_group = {
11406 .name = NULL, /* put in device directory */
11407 .attrs = ipw_sysfs_entries,
11410 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
11413 struct net_device *net_dev;
11414 void __iomem *base;
11416 struct ipw_priv *priv;
11419 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
11420 if (net_dev == NULL) {
11425 priv = ieee80211_priv(net_dev);
11426 priv->ieee = netdev_priv(net_dev);
11428 priv->net_dev = net_dev;
11429 priv->pci_dev = pdev;
11430 #ifdef CONFIG_IPW_DEBUG
11431 ipw_debug_level = debug;
11433 spin_lock_init(&priv->lock);
11434 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11435 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
11437 init_MUTEX(&priv->sem);
11438 if (pci_enable_device(pdev)) {
11440 goto out_free_ieee80211;
11443 pci_set_master(pdev);
11445 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
11447 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
11449 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11450 goto out_pci_disable_device;
11453 pci_set_drvdata(pdev, priv);
11455 err = pci_request_regions(pdev, DRV_NAME);
11457 goto out_pci_disable_device;
11459 /* We disable the RETRY_TIMEOUT register (0x41) to keep
11460 * PCI Tx retries from interfering with C3 CPU state */
11461 pci_read_config_dword(pdev, 0x40, &val);
11462 if ((val & 0x0000ff00) != 0)
11463 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11465 length = pci_resource_len(pdev, 0);
11466 priv->hw_len = length;
11468 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
11471 goto out_pci_release_regions;
11474 priv->hw_base = base;
11475 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11476 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11478 err = ipw_setup_deferred_work(priv);
11480 IPW_ERROR("Unable to setup deferred work\n");
11484 ipw_sw_reset(priv, 1);
11486 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
11488 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11489 goto out_destroy_workqueue;
11492 SET_MODULE_OWNER(net_dev);
11493 SET_NETDEV_DEV(net_dev, &pdev->dev);
11495 ipw_wx_data.spy_data = &priv->ieee->spy_data;
11496 ipw_wx_data.ieee80211 = priv->ieee;
11500 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11501 priv->ieee->set_security = shim__set_security;
11502 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11504 #ifdef CONFIG_IPW_QOS
11505 priv->ieee->handle_probe_response = ipw_handle_beacon;
11506 priv->ieee->handle_beacon = ipw_handle_probe_response;
11507 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11508 #endif /* CONFIG_IPW_QOS */
11510 priv->ieee->perfect_rssi = -20;
11511 priv->ieee->worst_rssi = -85;
11513 net_dev->open = ipw_net_open;
11514 net_dev->stop = ipw_net_stop;
11515 net_dev->init = ipw_net_init;
11516 #if WIRELESS_EXT < 18
11517 net_dev->do_ioctl = ipw_ioctl;
11519 net_dev->get_stats = ipw_net_get_stats;
11520 net_dev->set_multicast_list = ipw_net_set_multicast_list;
11521 net_dev->set_mac_address = ipw_net_set_mac_address;
11522 net_dev->get_wireless_stats = ipw_get_wireless_stats;
11523 net_dev->wireless_data = &ipw_wx_data;
11524 net_dev->wireless_handlers = &ipw_wx_handler_def;
11525 net_dev->ethtool_ops = &ipw_ethtool_ops;
11526 net_dev->irq = pdev->irq;
11527 net_dev->base_addr = (unsigned long)priv->hw_base;
11528 net_dev->mem_start = pci_resource_start(pdev, 0);
11529 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11531 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11533 IPW_ERROR("failed to create sysfs device attributes\n");
11535 goto out_release_irq;
11539 err = register_netdev(net_dev);
11541 IPW_ERROR("failed to register network device\n");
11542 goto out_remove_sysfs;
11547 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11549 free_irq(pdev->irq, priv);
11550 out_destroy_workqueue:
11551 destroy_workqueue(priv->workqueue);
11552 priv->workqueue = NULL;
11554 iounmap(priv->hw_base);
11555 out_pci_release_regions:
11556 pci_release_regions(pdev);
11557 out_pci_disable_device:
11558 pci_disable_device(pdev);
11559 pci_set_drvdata(pdev, NULL);
11560 out_free_ieee80211:
11561 free_ieee80211(priv->net_dev);
11566 static void ipw_pci_remove(struct pci_dev *pdev)
11568 struct ipw_priv *priv = pci_get_drvdata(pdev);
11569 struct list_head *p, *q;
11577 priv->status |= STATUS_EXIT_PENDING;
11579 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11583 unregister_netdev(priv->net_dev);
11586 ipw_rx_queue_free(priv, priv->rxq);
11589 ipw_tx_queue_free(priv);
11591 if (priv->cmdlog) {
11592 kfree(priv->cmdlog);
11593 priv->cmdlog = NULL;
11595 /* ipw_down will ensure that there is no more pending work
11596 * in the workqueue's, so we can safely remove them now. */
11597 cancel_delayed_work(&priv->adhoc_check);
11598 cancel_delayed_work(&priv->gather_stats);
11599 cancel_delayed_work(&priv->request_scan);
11600 cancel_delayed_work(&priv->rf_kill);
11601 cancel_delayed_work(&priv->scan_check);
11602 destroy_workqueue(priv->workqueue);
11603 priv->workqueue = NULL;
11605 /* Free MAC hash list for ADHOC */
11606 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11607 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11608 kfree(list_entry(p, struct ipw_ibss_seq, list));
11614 ipw_free_error_log(priv->error);
11615 priv->error = NULL;
11618 free_irq(pdev->irq, priv);
11619 iounmap(priv->hw_base);
11620 pci_release_regions(pdev);
11621 pci_disable_device(pdev);
11622 pci_set_drvdata(pdev, NULL);
11623 free_ieee80211(priv->net_dev);
11628 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11630 struct ipw_priv *priv = pci_get_drvdata(pdev);
11631 struct net_device *dev = priv->net_dev;
11633 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11635 /* Take down the device; powers it off, etc. */
11638 /* Remove the PRESENT state of the device */
11639 netif_device_detach(dev);
11641 pci_save_state(pdev);
11642 pci_disable_device(pdev);
11643 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11648 static int ipw_pci_resume(struct pci_dev *pdev)
11650 struct ipw_priv *priv = pci_get_drvdata(pdev);
11651 struct net_device *dev = priv->net_dev;
11654 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11656 pci_set_power_state(pdev, PCI_D0);
11657 pci_enable_device(pdev);
11658 pci_restore_state(pdev);
11661 * Suspend/Resume resets the PCI configuration space, so we have to
11662 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11663 * from interfering with C3 CPU state. pci_restore_state won't help
11664 * here since it only restores the first 64 bytes pci config header.
11666 pci_read_config_dword(pdev, 0x40, &val);
11667 if ((val & 0x0000ff00) != 0)
11668 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11670 /* Set the device back into the PRESENT state; this will also wake
11671 * the queue of needed */
11672 netif_device_attach(dev);
11674 /* Bring the device back up */
11675 queue_work(priv->workqueue, &priv->up);
11681 /* driver initialization stuff */
11682 static struct pci_driver ipw_driver = {
11684 .id_table = card_ids,
11685 .probe = ipw_pci_probe,
11686 .remove = __devexit_p(ipw_pci_remove),
11688 .suspend = ipw_pci_suspend,
11689 .resume = ipw_pci_resume,
11693 static int __init ipw_init(void)
11697 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11698 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11700 ret = pci_module_init(&ipw_driver);
11702 IPW_ERROR("Unable to initialize PCI module\n");
11706 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11708 IPW_ERROR("Unable to create driver sysfs file\n");
11709 pci_unregister_driver(&ipw_driver);
11716 static void __exit ipw_exit(void)
11718 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11719 pci_unregister_driver(&ipw_driver);
11722 module_param(disable, int, 0444);
11723 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11725 module_param(associate, int, 0444);
11726 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11728 module_param(auto_create, int, 0444);
11729 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11731 module_param(led, int, 0444);
11732 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11734 module_param(debug, int, 0444);
11735 MODULE_PARM_DESC(debug, "debug output mask");
11737 module_param(channel, int, 0444);
11738 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11740 #ifdef CONFIG_IPW_QOS
11741 module_param(qos_enable, int, 0444);
11742 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11744 module_param(qos_burst_enable, int, 0444);
11745 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11747 module_param(qos_no_ack_mask, int, 0444);
11748 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11750 module_param(burst_duration_CCK, int, 0444);
11751 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11753 module_param(burst_duration_OFDM, int, 0444);
11754 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11755 #endif /* CONFIG_IPW_QOS */
11757 #ifdef CONFIG_IPW2200_MONITOR
11758 module_param(mode, int, 0444);
11759 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11761 module_param(mode, int, 0444);
11762 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11765 module_param(hwcrypto, int, 0444);
11766 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11768 module_param(cmdlog, int, 0444);
11769 MODULE_PARM_DESC(cmdlog,
11770 "allocate a ring buffer for logging firmware commands");
11772 module_exit(ipw_exit);
11773 module_init(ipw_init);