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 #ifdef CONFIG_IPW_DEBUG
1813 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1814 static char *get_cmd_string(u8 cmd)
1817 IPW_CMD(HOST_COMPLETE);
1818 IPW_CMD(POWER_DOWN);
1819 IPW_CMD(SYSTEM_CONFIG);
1820 IPW_CMD(MULTICAST_ADDRESS);
1822 IPW_CMD(ADAPTER_ADDRESS);
1824 IPW_CMD(RTS_THRESHOLD);
1825 IPW_CMD(FRAG_THRESHOLD);
1826 IPW_CMD(POWER_MODE);
1828 IPW_CMD(TGI_TX_KEY);
1829 IPW_CMD(SCAN_REQUEST);
1830 IPW_CMD(SCAN_REQUEST_EXT);
1832 IPW_CMD(SUPPORTED_RATES);
1833 IPW_CMD(SCAN_ABORT);
1835 IPW_CMD(QOS_PARAMETERS);
1836 IPW_CMD(DINO_CONFIG);
1837 IPW_CMD(RSN_CAPABILITIES);
1839 IPW_CMD(CARD_DISABLE);
1840 IPW_CMD(SEED_NUMBER);
1842 IPW_CMD(COUNTRY_INFO);
1843 IPW_CMD(AIRONET_INFO);
1844 IPW_CMD(AP_TX_POWER);
1846 IPW_CMD(CCX_VER_INFO);
1847 IPW_CMD(SET_CALIBRATION);
1848 IPW_CMD(SENSITIVITY_CALIB);
1849 IPW_CMD(RETRY_LIMIT);
1850 IPW_CMD(IPW_PRE_POWER_DOWN);
1851 IPW_CMD(VAP_BEACON_TEMPLATE);
1852 IPW_CMD(VAP_DTIM_PERIOD);
1853 IPW_CMD(EXT_SUPPORTED_RATES);
1854 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1855 IPW_CMD(VAP_QUIET_INTERVALS);
1856 IPW_CMD(VAP_CHANNEL_SWITCH);
1857 IPW_CMD(VAP_MANDATORY_CHANNELS);
1858 IPW_CMD(VAP_CELL_PWR_LIMIT);
1859 IPW_CMD(VAP_CF_PARAM_SET);
1860 IPW_CMD(VAP_SET_BEACONING_STATE);
1861 IPW_CMD(MEASUREMENT);
1862 IPW_CMD(POWER_CAPABILITY);
1863 IPW_CMD(SUPPORTED_CHANNELS);
1864 IPW_CMD(TPC_REPORT);
1866 IPW_CMD(PRODUCTION_COMMAND);
1873 #define HOST_COMPLETE_TIMEOUT HZ
1874 static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
1877 unsigned long flags;
1879 spin_lock_irqsave(&priv->lock, flags);
1880 if (priv->status & STATUS_HCMD_ACTIVE) {
1881 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1882 get_cmd_string(cmd->cmd));
1883 spin_unlock_irqrestore(&priv->lock, flags);
1887 if (priv->status & STATUS_ASSOCIATING) {
1888 IPW_DEBUG_HC("abandon a command while associating\n");
1889 spin_unlock_irqrestore(&priv->lock, flags);
1893 if (priv->status & STATUS_DISASSOCIATING) {
1894 IPW_DEBUG_HC("abandon a command while disassociating\n");
1895 spin_unlock_irqrestore(&priv->lock, flags);
1899 priv->status |= STATUS_HCMD_ACTIVE;
1902 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1903 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1904 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1905 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1907 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1910 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1911 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1913 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1915 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
1917 priv->status &= ~STATUS_HCMD_ACTIVE;
1918 IPW_ERROR("Failed to send %s: Reason %d\n",
1919 get_cmd_string(cmd->cmd), rc);
1920 spin_unlock_irqrestore(&priv->lock, flags);
1923 spin_unlock_irqrestore(&priv->lock, flags);
1925 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1927 status & STATUS_HCMD_ACTIVE),
1928 HOST_COMPLETE_TIMEOUT);
1930 spin_lock_irqsave(&priv->lock, flags);
1931 if (priv->status & STATUS_HCMD_ACTIVE) {
1932 IPW_ERROR("Failed to send %s: Command timed out.\n",
1933 get_cmd_string(cmd->cmd));
1934 priv->status &= ~STATUS_HCMD_ACTIVE;
1935 spin_unlock_irqrestore(&priv->lock, flags);
1939 spin_unlock_irqrestore(&priv->lock, flags);
1943 if (priv->status & STATUS_RF_KILL_HW) {
1944 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1945 get_cmd_string(cmd->cmd));
1952 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1953 priv->cmdlog_pos %= priv->cmdlog_len;
1958 static int ipw_send_host_complete(struct ipw_priv *priv)
1960 struct host_cmd cmd = {
1961 .cmd = IPW_CMD_HOST_COMPLETE,
1966 IPW_ERROR("Invalid args\n");
1970 return ipw_send_cmd(priv, &cmd);
1973 static int ipw_send_system_config(struct ipw_priv *priv,
1974 struct ipw_sys_config *config)
1976 struct host_cmd cmd = {
1977 .cmd = IPW_CMD_SYSTEM_CONFIG,
1978 .len = sizeof(*config)
1981 if (!priv || !config) {
1982 IPW_ERROR("Invalid args\n");
1986 memcpy(cmd.param, config, sizeof(*config));
1987 return ipw_send_cmd(priv, &cmd);
1990 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
1992 struct host_cmd cmd = {
1993 .cmd = IPW_CMD_SSID,
1994 .len = min(len, IW_ESSID_MAX_SIZE)
1997 if (!priv || !ssid) {
1998 IPW_ERROR("Invalid args\n");
2002 memcpy(cmd.param, ssid, cmd.len);
2003 return ipw_send_cmd(priv, &cmd);
2006 static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
2008 struct host_cmd cmd = {
2009 .cmd = IPW_CMD_ADAPTER_ADDRESS,
2013 if (!priv || !mac) {
2014 IPW_ERROR("Invalid args\n");
2018 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2019 priv->net_dev->name, MAC_ARG(mac));
2021 memcpy(cmd.param, mac, ETH_ALEN);
2022 return ipw_send_cmd(priv, &cmd);
2026 * NOTE: This must be executed from our workqueue as it results in udelay
2027 * being called which may corrupt the keyboard if executed on default
2030 static void ipw_adapter_restart(void *adapter)
2032 struct ipw_priv *priv = adapter;
2034 if (priv->status & STATUS_RF_KILL_MASK)
2039 if (priv->assoc_network &&
2040 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2041 ipw_remove_current_network(priv);
2044 IPW_ERROR("Failed to up device\n");
2049 static void ipw_bg_adapter_restart(void *data)
2051 struct ipw_priv *priv = data;
2053 ipw_adapter_restart(data);
2057 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2059 static void ipw_scan_check(void *data)
2061 struct ipw_priv *priv = data;
2062 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2063 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2064 "adapter (%dms).\n",
2065 IPW_SCAN_CHECK_WATCHDOG / 100);
2066 queue_work(priv->workqueue, &priv->adapter_restart);
2070 static void ipw_bg_scan_check(void *data)
2072 struct ipw_priv *priv = data;
2074 ipw_scan_check(data);
2078 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2079 struct ipw_scan_request_ext *request)
2081 struct host_cmd cmd = {
2082 .cmd = IPW_CMD_SCAN_REQUEST_EXT,
2083 .len = sizeof(*request)
2086 memcpy(cmd.param, request, sizeof(*request));
2087 return ipw_send_cmd(priv, &cmd);
2090 static int ipw_send_scan_abort(struct ipw_priv *priv)
2092 struct host_cmd cmd = {
2093 .cmd = IPW_CMD_SCAN_ABORT,
2098 IPW_ERROR("Invalid args\n");
2102 return ipw_send_cmd(priv, &cmd);
2105 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2107 struct host_cmd cmd = {
2108 .cmd = IPW_CMD_SENSITIVITY_CALIB,
2109 .len = sizeof(struct ipw_sensitivity_calib)
2111 struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
2113 calib->beacon_rssi_raw = sens;
2114 return ipw_send_cmd(priv, &cmd);
2117 static int ipw_send_associate(struct ipw_priv *priv,
2118 struct ipw_associate *associate)
2120 struct host_cmd cmd = {
2121 .cmd = IPW_CMD_ASSOCIATE,
2122 .len = sizeof(*associate)
2125 struct ipw_associate tmp_associate;
2126 memcpy(&tmp_associate, associate, sizeof(*associate));
2127 tmp_associate.policy_support =
2128 cpu_to_le16(tmp_associate.policy_support);
2129 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2130 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2131 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2132 tmp_associate.listen_interval =
2133 cpu_to_le16(tmp_associate.listen_interval);
2134 tmp_associate.beacon_interval =
2135 cpu_to_le16(tmp_associate.beacon_interval);
2136 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2138 if (!priv || !associate) {
2139 IPW_ERROR("Invalid args\n");
2143 memcpy(cmd.param, &tmp_associate, sizeof(*associate));
2144 return ipw_send_cmd(priv, &cmd);
2147 static int ipw_send_supported_rates(struct ipw_priv *priv,
2148 struct ipw_supported_rates *rates)
2150 struct host_cmd cmd = {
2151 .cmd = IPW_CMD_SUPPORTED_RATES,
2152 .len = sizeof(*rates)
2155 if (!priv || !rates) {
2156 IPW_ERROR("Invalid args\n");
2160 memcpy(cmd.param, rates, sizeof(*rates));
2161 return ipw_send_cmd(priv, &cmd);
2164 static int ipw_set_random_seed(struct ipw_priv *priv)
2166 struct host_cmd cmd = {
2167 .cmd = IPW_CMD_SEED_NUMBER,
2172 IPW_ERROR("Invalid args\n");
2176 get_random_bytes(&cmd.param, sizeof(u32));
2178 return ipw_send_cmd(priv, &cmd);
2181 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2183 struct host_cmd cmd = {
2184 .cmd = IPW_CMD_CARD_DISABLE,
2189 IPW_ERROR("Invalid args\n");
2193 *((u32 *) & cmd.param) = phy_off;
2195 return ipw_send_cmd(priv, &cmd);
2198 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2200 struct host_cmd cmd = {
2201 .cmd = IPW_CMD_TX_POWER,
2202 .len = sizeof(*power)
2205 if (!priv || !power) {
2206 IPW_ERROR("Invalid args\n");
2210 memcpy(cmd.param, power, sizeof(*power));
2211 return ipw_send_cmd(priv, &cmd);
2214 static int ipw_set_tx_power(struct ipw_priv *priv)
2216 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
2217 struct ipw_tx_power tx_power;
2221 memset(&tx_power, 0, sizeof(tx_power));
2223 /* configure device for 'G' band */
2224 tx_power.ieee_mode = IPW_G_MODE;
2225 tx_power.num_channels = geo->bg_channels;
2226 for (i = 0; i < geo->bg_channels; i++) {
2227 max_power = geo->bg[i].max_power;
2228 tx_power.channels_tx_power[i].channel_number =
2230 tx_power.channels_tx_power[i].tx_power = max_power ?
2231 min(max_power, priv->tx_power) : priv->tx_power;
2233 if (ipw_send_tx_power(priv, &tx_power))
2236 /* configure device to also handle 'B' band */
2237 tx_power.ieee_mode = IPW_B_MODE;
2238 if (ipw_send_tx_power(priv, &tx_power))
2241 /* configure device to also handle 'A' band */
2242 if (priv->ieee->abg_true) {
2243 tx_power.ieee_mode = IPW_A_MODE;
2244 tx_power.num_channels = geo->a_channels;
2245 for (i = 0; i < tx_power.num_channels; i++) {
2246 max_power = geo->a[i].max_power;
2247 tx_power.channels_tx_power[i].channel_number =
2249 tx_power.channels_tx_power[i].tx_power = max_power ?
2250 min(max_power, priv->tx_power) : priv->tx_power;
2252 if (ipw_send_tx_power(priv, &tx_power))
2258 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2260 struct ipw_rts_threshold rts_threshold = {
2261 .rts_threshold = rts,
2263 struct host_cmd cmd = {
2264 .cmd = IPW_CMD_RTS_THRESHOLD,
2265 .len = sizeof(rts_threshold)
2269 IPW_ERROR("Invalid args\n");
2273 memcpy(cmd.param, &rts_threshold, sizeof(rts_threshold));
2274 return ipw_send_cmd(priv, &cmd);
2277 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2279 struct ipw_frag_threshold frag_threshold = {
2280 .frag_threshold = frag,
2282 struct host_cmd cmd = {
2283 .cmd = IPW_CMD_FRAG_THRESHOLD,
2284 .len = sizeof(frag_threshold)
2288 IPW_ERROR("Invalid args\n");
2292 memcpy(cmd.param, &frag_threshold, sizeof(frag_threshold));
2293 return ipw_send_cmd(priv, &cmd);
2296 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2298 struct host_cmd cmd = {
2299 .cmd = IPW_CMD_POWER_MODE,
2302 u32 *param = (u32 *) (&cmd.param);
2305 IPW_ERROR("Invalid args\n");
2309 /* If on battery, set to 3, if AC set to CAM, else user
2312 case IPW_POWER_BATTERY:
2313 *param = IPW_POWER_INDEX_3;
2316 *param = IPW_POWER_MODE_CAM;
2323 return ipw_send_cmd(priv, &cmd);
2326 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2328 struct ipw_retry_limit retry_limit = {
2329 .short_retry_limit = slimit,
2330 .long_retry_limit = llimit
2332 struct host_cmd cmd = {
2333 .cmd = IPW_CMD_RETRY_LIMIT,
2334 .len = sizeof(retry_limit)
2338 IPW_ERROR("Invalid args\n");
2342 memcpy(cmd.param, &retry_limit, sizeof(retry_limit));
2343 return ipw_send_cmd(priv, &cmd);
2347 * The IPW device contains a Microwire compatible EEPROM that stores
2348 * various data like the MAC address. Usually the firmware has exclusive
2349 * access to the eeprom, but during device initialization (before the
2350 * device driver has sent the HostComplete command to the firmware) the
2351 * device driver has read access to the EEPROM by way of indirect addressing
2352 * through a couple of memory mapped registers.
2354 * The following is a simplified implementation for pulling data out of the
2355 * the eeprom, along with some helper functions to find information in
2356 * the per device private data's copy of the eeprom.
2358 * NOTE: To better understand how these functions work (i.e what is a chip
2359 * select and why do have to keep driving the eeprom clock?), read
2360 * just about any data sheet for a Microwire compatible EEPROM.
2363 /* write a 32 bit value into the indirect accessor register */
2364 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2366 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2368 /* the eeprom requires some time to complete the operation */
2369 udelay(p->eeprom_delay);
2374 /* perform a chip select operation */
2375 static inline void eeprom_cs(struct ipw_priv *priv)
2377 eeprom_write_reg(priv, 0);
2378 eeprom_write_reg(priv, EEPROM_BIT_CS);
2379 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2380 eeprom_write_reg(priv, EEPROM_BIT_CS);
2383 /* perform a chip select operation */
2384 static inline void eeprom_disable_cs(struct ipw_priv *priv)
2386 eeprom_write_reg(priv, EEPROM_BIT_CS);
2387 eeprom_write_reg(priv, 0);
2388 eeprom_write_reg(priv, EEPROM_BIT_SK);
2391 /* push a single bit down to the eeprom */
2392 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2394 int d = (bit ? EEPROM_BIT_DI : 0);
2395 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2396 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2399 /* push an opcode followed by an address down to the eeprom */
2400 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2405 eeprom_write_bit(priv, 1);
2406 eeprom_write_bit(priv, op & 2);
2407 eeprom_write_bit(priv, op & 1);
2408 for (i = 7; i >= 0; i--) {
2409 eeprom_write_bit(priv, addr & (1 << i));
2413 /* pull 16 bits off the eeprom, one bit at a time */
2414 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2419 /* Send READ Opcode */
2420 eeprom_op(priv, EEPROM_CMD_READ, addr);
2422 /* Send dummy bit */
2423 eeprom_write_reg(priv, EEPROM_BIT_CS);
2425 /* Read the byte off the eeprom one bit at a time */
2426 for (i = 0; i < 16; i++) {
2428 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2429 eeprom_write_reg(priv, EEPROM_BIT_CS);
2430 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2431 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2434 /* Send another dummy bit */
2435 eeprom_write_reg(priv, 0);
2436 eeprom_disable_cs(priv);
2441 /* helper function for pulling the mac address out of the private */
2442 /* data's copy of the eeprom data */
2443 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2445 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
2449 * Either the device driver (i.e. the host) or the firmware can
2450 * load eeprom data into the designated region in SRAM. If neither
2451 * happens then the FW will shutdown with a fatal error.
2453 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2454 * bit needs region of shared SRAM needs to be non-zero.
2456 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2459 u16 *eeprom = (u16 *) priv->eeprom;
2461 IPW_DEBUG_TRACE(">>\n");
2463 /* read entire contents of eeprom into private buffer */
2464 for (i = 0; i < 128; i++)
2465 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
2468 If the data looks correct, then copy it to our private
2469 copy. Otherwise let the firmware know to perform the operation
2472 if ((priv->eeprom + EEPROM_VERSION) != 0) {
2473 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2475 /* write the eeprom data to sram */
2476 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2477 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2479 /* Do not load eeprom data on fatal error or suspend */
2480 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2482 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2484 /* Load eeprom data on fatal error or suspend */
2485 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2488 IPW_DEBUG_TRACE("<<\n");
2491 static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2496 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2498 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2501 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2503 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2504 CB_NUMBER_OF_ELEMENTS_SMALL *
2505 sizeof(struct command_block));
2508 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2509 { /* start dma engine but no transfers yet */
2511 IPW_DEBUG_FW(">> : \n");
2514 ipw_fw_dma_reset_command_blocks(priv);
2516 /* Write CB base address */
2517 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2519 IPW_DEBUG_FW("<< : \n");
2523 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2527 IPW_DEBUG_FW(">> :\n");
2529 //set the Stop and Abort bit
2530 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2531 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2532 priv->sram_desc.last_cb_index = 0;
2534 IPW_DEBUG_FW("<< \n");
2537 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2538 struct command_block *cb)
2541 IPW_SHARED_SRAM_DMA_CONTROL +
2542 (sizeof(struct command_block) * index);
2543 IPW_DEBUG_FW(">> :\n");
2545 ipw_write_indirect(priv, address, (u8 *) cb,
2546 (int)sizeof(struct command_block));
2548 IPW_DEBUG_FW("<< :\n");
2553 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2558 IPW_DEBUG_FW(">> :\n");
2560 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2561 ipw_fw_dma_write_command_block(priv, index,
2562 &priv->sram_desc.cb_list[index]);
2564 /* Enable the DMA in the CSR register */
2565 ipw_clear_bit(priv, IPW_RESET_REG,
2566 IPW_RESET_REG_MASTER_DISABLED |
2567 IPW_RESET_REG_STOP_MASTER);
2569 /* Set the Start bit. */
2570 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2571 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2573 IPW_DEBUG_FW("<< :\n");
2577 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2580 u32 register_value = 0;
2581 u32 cb_fields_address = 0;
2583 IPW_DEBUG_FW(">> :\n");
2584 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2585 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
2587 /* Read the DMA Controlor register */
2588 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2589 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
2591 /* Print the CB values */
2592 cb_fields_address = address;
2593 register_value = ipw_read_reg32(priv, cb_fields_address);
2594 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
2596 cb_fields_address += sizeof(u32);
2597 register_value = ipw_read_reg32(priv, cb_fields_address);
2598 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
2600 cb_fields_address += sizeof(u32);
2601 register_value = ipw_read_reg32(priv, cb_fields_address);
2602 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2605 cb_fields_address += sizeof(u32);
2606 register_value = ipw_read_reg32(priv, cb_fields_address);
2607 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
2609 IPW_DEBUG_FW(">> :\n");
2612 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2614 u32 current_cb_address = 0;
2615 u32 current_cb_index = 0;
2617 IPW_DEBUG_FW("<< :\n");
2618 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2620 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2621 sizeof(struct command_block);
2623 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
2624 current_cb_index, current_cb_address);
2626 IPW_DEBUG_FW(">> :\n");
2627 return current_cb_index;
2631 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2635 int interrupt_enabled, int is_last)
2638 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2639 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2641 struct command_block *cb;
2642 u32 last_cb_element = 0;
2644 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2645 src_address, dest_address, length);
2647 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2650 last_cb_element = priv->sram_desc.last_cb_index;
2651 cb = &priv->sram_desc.cb_list[last_cb_element];
2652 priv->sram_desc.last_cb_index++;
2654 /* Calculate the new CB control word */
2655 if (interrupt_enabled)
2656 control |= CB_INT_ENABLED;
2659 control |= CB_LAST_VALID;
2663 /* Calculate the CB Element's checksum value */
2664 cb->status = control ^ src_address ^ dest_address;
2666 /* Copy the Source and Destination addresses */
2667 cb->dest_addr = dest_address;
2668 cb->source_addr = src_address;
2670 /* Copy the Control Word last */
2671 cb->control = control;
2676 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
2677 u32 src_phys, u32 dest_address, u32 length)
2679 u32 bytes_left = length;
2681 u32 dest_offset = 0;
2683 IPW_DEBUG_FW(">> \n");
2684 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2685 src_phys, dest_address, length);
2686 while (bytes_left > CB_MAX_LENGTH) {
2687 status = ipw_fw_dma_add_command_block(priv,
2688 src_phys + src_offset,
2691 CB_MAX_LENGTH, 0, 0);
2693 IPW_DEBUG_FW_INFO(": Failed\n");
2696 IPW_DEBUG_FW_INFO(": Added new cb\n");
2698 src_offset += CB_MAX_LENGTH;
2699 dest_offset += CB_MAX_LENGTH;
2700 bytes_left -= CB_MAX_LENGTH;
2703 /* add the buffer tail */
2704 if (bytes_left > 0) {
2706 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2707 dest_address + dest_offset,
2710 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2714 (": Adding new cb - the buffer tail\n");
2717 IPW_DEBUG_FW("<< \n");
2721 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2723 u32 current_index = 0;
2726 IPW_DEBUG_FW(">> : \n");
2728 current_index = ipw_fw_dma_command_block_index(priv);
2729 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%8X\n",
2730 (int)priv->sram_desc.last_cb_index);
2732 while (current_index < priv->sram_desc.last_cb_index) {
2734 current_index = ipw_fw_dma_command_block_index(priv);
2738 if (watchdog > 400) {
2739 IPW_DEBUG_FW_INFO("Timeout\n");
2740 ipw_fw_dma_dump_command_block(priv);
2741 ipw_fw_dma_abort(priv);
2746 ipw_fw_dma_abort(priv);
2748 /*Disable the DMA in the CSR register */
2749 ipw_set_bit(priv, IPW_RESET_REG,
2750 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2752 IPW_DEBUG_FW("<< dmaWaitSync \n");
2756 static void ipw_remove_current_network(struct ipw_priv *priv)
2758 struct list_head *element, *safe;
2759 struct ieee80211_network *network = NULL;
2760 unsigned long flags;
2762 spin_lock_irqsave(&priv->ieee->lock, flags);
2763 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2764 network = list_entry(element, struct ieee80211_network, list);
2765 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2767 list_add_tail(&network->list,
2768 &priv->ieee->network_free_list);
2771 spin_unlock_irqrestore(&priv->ieee->lock, flags);
2775 * Check that card is still alive.
2776 * Reads debug register from domain0.
2777 * If card is present, pre-defined value should
2781 * @return 1 if card is present, 0 otherwise
2783 static inline int ipw_alive(struct ipw_priv *priv)
2785 return ipw_read32(priv, 0x90) == 0xd55555d5;
2788 static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2794 if ((ipw_read32(priv, addr) & mask) == mask)
2798 } while (i < timeout);
2803 /* These functions load the firmware and micro code for the operation of
2804 * the ipw hardware. It assumes the buffer has all the bits for the
2805 * image and the caller is handling the memory allocation and clean up.
2808 static int ipw_stop_master(struct ipw_priv *priv)
2812 IPW_DEBUG_TRACE(">> \n");
2813 /* stop master. typical delay - 0 */
2814 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2816 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2817 IPW_RESET_REG_MASTER_DISABLED, 100);
2819 IPW_ERROR("stop master failed in 10ms\n");
2823 IPW_DEBUG_INFO("stop master %dms\n", rc);
2828 static void ipw_arc_release(struct ipw_priv *priv)
2830 IPW_DEBUG_TRACE(">> \n");
2833 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2835 /* no one knows timing, for safety add some delay */
2849 #define IPW_FW_MAJOR_VERSION 2
2850 #define IPW_FW_MINOR_VERSION 3
2852 #define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2853 #define IPW_FW_MAJOR(x) (x & 0xff)
2855 #define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2857 #define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2858 "." __stringify(IPW_FW_MINOR_VERSION) "-"
2860 #if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2861 #define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2863 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2866 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2868 int rc = 0, i, addr;
2872 image = (u16 *) data;
2874 IPW_DEBUG_TRACE(">> \n");
2876 rc = ipw_stop_master(priv);
2881 // spin_lock_irqsave(&priv->lock, flags);
2883 for (addr = IPW_SHARED_LOWER_BOUND;
2884 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2885 ipw_write32(priv, addr, 0);
2888 /* no ucode (yet) */
2889 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2890 /* destroy DMA queues */
2891 /* reset sequence */
2893 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2894 ipw_arc_release(priv);
2895 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2899 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2902 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2905 /* enable ucode store */
2906 ipw_write_reg8(priv, DINO_CONTROL_REG, 0x0);
2907 ipw_write_reg8(priv, DINO_CONTROL_REG, DINO_ENABLE_CS);
2913 * Do NOT set indirect address register once and then
2914 * store data to indirect data register in the loop.
2915 * It seems very reasonable, but in this case DINO do not
2916 * accept ucode. It is essential to set address each time.
2918 /* load new ipw uCode */
2919 for (i = 0; i < len / 2; i++)
2920 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2921 cpu_to_le16(image[i]));
2924 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2925 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2927 /* this is where the igx / win driver deveates from the VAP driver. */
2929 /* wait for alive response */
2930 for (i = 0; i < 100; i++) {
2931 /* poll for incoming data */
2932 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2933 if (cr & DINO_RXFIFO_DATA)
2938 if (cr & DINO_RXFIFO_DATA) {
2939 /* alive_command_responce size is NOT multiple of 4 */
2940 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2942 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2943 response_buffer[i] =
2944 le32_to_cpu(ipw_read_reg32(priv,
2945 IPW_BASEBAND_RX_FIFO_READ));
2946 memcpy(&priv->dino_alive, response_buffer,
2947 sizeof(priv->dino_alive));
2948 if (priv->dino_alive.alive_command == 1
2949 && priv->dino_alive.ucode_valid == 1) {
2952 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2953 "of %02d/%02d/%02d %02d:%02d\n",
2954 priv->dino_alive.software_revision,
2955 priv->dino_alive.software_revision,
2956 priv->dino_alive.device_identifier,
2957 priv->dino_alive.device_identifier,
2958 priv->dino_alive.time_stamp[0],
2959 priv->dino_alive.time_stamp[1],
2960 priv->dino_alive.time_stamp[2],
2961 priv->dino_alive.time_stamp[3],
2962 priv->dino_alive.time_stamp[4]);
2964 IPW_DEBUG_INFO("Microcode is not alive\n");
2968 IPW_DEBUG_INFO("No alive response from DINO\n");
2972 /* disable DINO, otherwise for some reason
2973 firmware have problem getting alive resp. */
2974 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2976 // spin_unlock_irqrestore(&priv->lock, flags);
2981 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
2985 struct fw_chunk *chunk;
2986 dma_addr_t shared_phys;
2989 IPW_DEBUG_TRACE("<< : \n");
2990 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2995 memmove(shared_virt, data, len);
2998 rc = ipw_fw_dma_enable(priv);
3000 if (priv->sram_desc.last_cb_index > 0) {
3001 /* the DMA is already ready this would be a bug. */
3007 chunk = (struct fw_chunk *)(data + offset);
3008 offset += sizeof(struct fw_chunk);
3009 /* build DMA packet and queue up for sending */
3010 /* dma to chunk->address, the chunk->length bytes from data +
3013 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3014 le32_to_cpu(chunk->address),
3015 le32_to_cpu(chunk->length));
3017 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3021 offset += le32_to_cpu(chunk->length);
3022 } while (offset < len);
3024 /* Run the DMA and wait for the answer */
3025 rc = ipw_fw_dma_kick(priv);
3027 IPW_ERROR("dmaKick Failed\n");
3031 rc = ipw_fw_dma_wait(priv);
3033 IPW_ERROR("dmaWaitSync Failed\n");
3037 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
3042 static int ipw_stop_nic(struct ipw_priv *priv)
3047 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3049 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3050 IPW_RESET_REG_MASTER_DISABLED, 500);
3052 IPW_ERROR("wait for reg master disabled failed\n");
3056 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3061 static void ipw_start_nic(struct ipw_priv *priv)
3063 IPW_DEBUG_TRACE(">>\n");
3065 /* prvHwStartNic release ARC */
3066 ipw_clear_bit(priv, IPW_RESET_REG,
3067 IPW_RESET_REG_MASTER_DISABLED |
3068 IPW_RESET_REG_STOP_MASTER |
3069 CBD_RESET_REG_PRINCETON_RESET);
3071 /* enable power management */
3072 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3073 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3075 IPW_DEBUG_TRACE("<<\n");
3078 static int ipw_init_nic(struct ipw_priv *priv)
3082 IPW_DEBUG_TRACE(">>\n");
3085 /* set "initialization complete" bit to move adapter to D0 state */
3086 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3088 /* low-level PLL activation */
3089 ipw_write32(priv, IPW_READ_INT_REGISTER,
3090 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3092 /* wait for clock stabilization */
3093 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3094 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3096 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3098 /* assert SW reset */
3099 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3103 /* set "initialization complete" bit to move adapter to D0 state */
3104 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3106 IPW_DEBUG_TRACE(">>\n");
3110 /* Call this function from process context, it will sleep in request_firmware.
3111 * Probe is an ok place to call this from.
3113 static int ipw_reset_nic(struct ipw_priv *priv)
3116 unsigned long flags;
3118 IPW_DEBUG_TRACE(">>\n");
3120 rc = ipw_init_nic(priv);
3122 spin_lock_irqsave(&priv->lock, flags);
3123 /* Clear the 'host command active' bit... */
3124 priv->status &= ~STATUS_HCMD_ACTIVE;
3125 wake_up_interruptible(&priv->wait_command_queue);
3126 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3127 wake_up_interruptible(&priv->wait_state);
3128 spin_unlock_irqrestore(&priv->lock, flags);
3130 IPW_DEBUG_TRACE("<<\n");
3134 static int ipw_get_fw(struct ipw_priv *priv,
3135 const struct firmware **fw, const char *name)
3137 struct fw_header *header;
3140 /* ask firmware_class module to get the boot firmware off disk */
3141 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3143 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3147 header = (struct fw_header *)(*fw)->data;
3148 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
3149 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3151 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3152 IPW_FW_MAJOR_VERSION);
3156 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
3158 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3159 IPW_FW_MINOR(le32_to_cpu(header->version)),
3160 (*fw)->size - sizeof(struct fw_header));
3164 #define IPW_RX_BUF_SIZE (3000)
3166 static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
3167 struct ipw_rx_queue *rxq)
3169 unsigned long flags;
3172 spin_lock_irqsave(&rxq->lock, flags);
3174 INIT_LIST_HEAD(&rxq->rx_free);
3175 INIT_LIST_HEAD(&rxq->rx_used);
3177 /* Fill the rx_used queue with _all_ of the Rx buffers */
3178 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3179 /* In the reset function, these buffers may have been allocated
3180 * to an SKB, so we need to unmap and free potential storage */
3181 if (rxq->pool[i].skb != NULL) {
3182 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3183 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3184 dev_kfree_skb(rxq->pool[i].skb);
3185 rxq->pool[i].skb = NULL;
3187 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3190 /* Set us so that we have processed and used all buffers, but have
3191 * not restocked the Rx queue with fresh buffers */
3192 rxq->read = rxq->write = 0;
3193 rxq->processed = RX_QUEUE_SIZE - 1;
3194 rxq->free_count = 0;
3195 spin_unlock_irqrestore(&rxq->lock, flags);
3199 static int fw_loaded = 0;
3200 static const struct firmware *bootfw = NULL;
3201 static const struct firmware *firmware = NULL;
3202 static const struct firmware *ucode = NULL;
3204 static void free_firmware(void)
3207 release_firmware(bootfw);
3208 release_firmware(ucode);
3209 release_firmware(firmware);
3210 bootfw = ucode = firmware = NULL;
3215 #define free_firmware() do {} while (0)
3218 static int ipw_load(struct ipw_priv *priv)
3221 const struct firmware *bootfw = NULL;
3222 const struct firmware *firmware = NULL;
3223 const struct firmware *ucode = NULL;
3225 int rc = 0, retries = 3;
3230 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3234 switch (priv->ieee->iw_mode) {
3236 rc = ipw_get_fw(priv, &ucode,
3237 IPW_FW_NAME("ibss_ucode"));
3241 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
3244 #ifdef CONFIG_IPW2200_MONITOR
3245 case IW_MODE_MONITOR:
3246 rc = ipw_get_fw(priv, &ucode,
3247 IPW_FW_NAME("sniffer_ucode"));
3251 rc = ipw_get_fw(priv, &firmware,
3252 IPW_FW_NAME("sniffer"));
3256 rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
3260 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("bss"));
3276 priv->rxq = ipw_rx_queue_alloc(priv);
3278 ipw_rx_queue_reset(priv, priv->rxq);
3280 IPW_ERROR("Unable to initialize Rx queue\n");
3285 /* Ensure interrupts are disabled */
3286 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3287 priv->status &= ~STATUS_INT_ENABLED;
3289 /* ack pending interrupts */
3290 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3294 rc = ipw_reset_nic(priv);
3296 IPW_ERROR("Unable to reset NIC\n");
3300 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3301 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3303 /* DMA the initial boot firmware into the device */
3304 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
3305 bootfw->size - sizeof(struct fw_header));
3307 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3311 /* kick start the device */
3312 ipw_start_nic(priv);
3314 /* wait for the device to finish it's initial startup sequence */
3315 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3316 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3318 IPW_ERROR("device failed to boot initial fw image\n");
3321 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3323 /* ack fw init done interrupt */
3324 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3326 /* DMA the ucode into the device */
3327 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
3328 ucode->size - sizeof(struct fw_header));
3330 IPW_ERROR("Unable to load ucode: %d\n", rc);
3337 /* DMA bss firmware into the device */
3338 rc = ipw_load_firmware(priv, firmware->data +
3339 sizeof(struct fw_header),
3340 firmware->size - sizeof(struct fw_header));
3342 IPW_ERROR("Unable to load firmware: %d\n", rc);
3346 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3348 rc = ipw_queue_reset(priv);
3350 IPW_ERROR("Unable to initialize queues\n");
3354 /* Ensure interrupts are disabled */
3355 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3356 /* ack pending interrupts */
3357 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3359 /* kick start the device */
3360 ipw_start_nic(priv);
3362 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3364 IPW_WARNING("Parity error. Retrying init.\n");
3369 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3374 /* wait for the device */
3375 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3376 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3378 IPW_ERROR("device failed to start after 500ms\n");
3381 IPW_DEBUG_INFO("device response after %dms\n", rc);
3383 /* ack fw init done interrupt */
3384 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3386 /* read eeprom data and initialize the eeprom region of sram */
3387 priv->eeprom_delay = 1;
3388 ipw_eeprom_init_sram(priv);
3390 /* enable interrupts */
3391 ipw_enable_interrupts(priv);
3393 /* Ensure our queue has valid packets */
3394 ipw_rx_queue_replenish(priv);
3396 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3398 /* ack pending interrupts */
3399 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3402 release_firmware(bootfw);
3403 release_firmware(ucode);
3404 release_firmware(firmware);
3410 ipw_rx_queue_free(priv, priv->rxq);
3413 ipw_tx_queue_free(priv);
3415 release_firmware(bootfw);
3417 release_firmware(ucode);
3419 release_firmware(firmware);
3422 bootfw = ucode = firmware = NULL;
3431 * Theory of operation
3433 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3434 * 2 empty entries always kept in the buffer to protect from overflow.
3436 * For Tx queue, there are low mark and high mark limits. If, after queuing
3437 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3438 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3441 * The IPW operates with six queues, one receive queue in the device's
3442 * sram, one transmit queue for sending commands to the device firmware,
3443 * and four transmit queues for data.
3445 * The four transmit queues allow for performing quality of service (qos)
3446 * transmissions as per the 802.11 protocol. Currently Linux does not
3447 * provide a mechanism to the user for utilizing prioritized queues, so
3448 * we only utilize the first data transmit queue (queue1).
3452 * Driver allocates buffers of this size for Rx
3455 static inline int ipw_queue_space(const struct clx2_queue *q)
3457 int s = q->last_used - q->first_empty;
3460 s -= 2; /* keep some reserve to not confuse empty and full situations */
3466 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3468 return (++index == n_bd) ? 0 : index;
3472 * Initialize common DMA queue structure
3474 * @param q queue to init
3475 * @param count Number of BD's to allocate. Should be power of 2
3476 * @param read_register Address for 'read' register
3477 * (not offset within BAR, full address)
3478 * @param write_register Address for 'write' register
3479 * (not offset within BAR, full address)
3480 * @param base_register Address for 'base' register
3481 * (not offset within BAR, full address)
3482 * @param size Address for 'size' register
3483 * (not offset within BAR, full address)
3485 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3486 int count, u32 read, u32 write, u32 base, u32 size)
3490 q->low_mark = q->n_bd / 4;
3491 if (q->low_mark < 4)
3494 q->high_mark = q->n_bd / 8;
3495 if (q->high_mark < 2)
3498 q->first_empty = q->last_used = 0;
3502 ipw_write32(priv, base, q->dma_addr);
3503 ipw_write32(priv, size, count);
3504 ipw_write32(priv, read, 0);
3505 ipw_write32(priv, write, 0);
3507 _ipw_read32(priv, 0x90);
3510 static int ipw_queue_tx_init(struct ipw_priv *priv,
3511 struct clx2_tx_queue *q,
3512 int count, u32 read, u32 write, u32 base, u32 size)
3514 struct pci_dev *dev = priv->pci_dev;
3516 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3518 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3523 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3525 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3526 sizeof(q->bd[0]) * count);
3532 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3537 * Free one TFD, those at index [txq->q.last_used].
3538 * Do NOT advance any indexes
3543 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3544 struct clx2_tx_queue *txq)
3546 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3547 struct pci_dev *dev = priv->pci_dev;
3551 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3552 /* nothing to cleanup after for host commands */
3556 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3557 IPW_ERROR("Too many chunks: %i\n",
3558 le32_to_cpu(bd->u.data.num_chunks));
3559 /** @todo issue fatal error, it is quite serious situation */
3563 /* unmap chunks if any */
3564 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3565 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3566 le16_to_cpu(bd->u.data.chunk_len[i]),
3568 if (txq->txb[txq->q.last_used]) {
3569 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3570 txq->txb[txq->q.last_used] = NULL;
3576 * Deallocate DMA queue.
3578 * Empty queue by removing and destroying all BD's.
3584 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3586 struct clx2_queue *q = &txq->q;
3587 struct pci_dev *dev = priv->pci_dev;
3592 /* first, empty all BD's */
3593 for (; q->first_empty != q->last_used;
3594 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3595 ipw_queue_tx_free_tfd(priv, txq);
3598 /* free buffers belonging to queue itself */
3599 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3603 /* 0 fill whole structure */
3604 memset(txq, 0, sizeof(*txq));
3608 * Destroy all DMA queues and structures
3612 static void ipw_tx_queue_free(struct ipw_priv *priv)
3615 ipw_queue_tx_free(priv, &priv->txq_cmd);
3618 ipw_queue_tx_free(priv, &priv->txq[0]);
3619 ipw_queue_tx_free(priv, &priv->txq[1]);
3620 ipw_queue_tx_free(priv, &priv->txq[2]);
3621 ipw_queue_tx_free(priv, &priv->txq[3]);
3624 static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3626 /* First 3 bytes are manufacturer */
3627 bssid[0] = priv->mac_addr[0];
3628 bssid[1] = priv->mac_addr[1];
3629 bssid[2] = priv->mac_addr[2];
3631 /* Last bytes are random */
3632 get_random_bytes(&bssid[3], ETH_ALEN - 3);
3634 bssid[0] &= 0xfe; /* clear multicast bit */
3635 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
3638 static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3640 struct ipw_station_entry entry;
3643 for (i = 0; i < priv->num_stations; i++) {
3644 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3645 /* Another node is active in network */
3646 priv->missed_adhoc_beacons = 0;
3647 if (!(priv->config & CFG_STATIC_CHANNEL))
3648 /* when other nodes drop out, we drop out */
3649 priv->config &= ~CFG_ADHOC_PERSIST;
3655 if (i == MAX_STATIONS)
3656 return IPW_INVALID_STATION;
3658 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3661 entry.support_mode = 0;
3662 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3663 memcpy(priv->stations[i], bssid, ETH_ALEN);
3664 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3665 &entry, sizeof(entry));
3666 priv->num_stations++;
3671 static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3675 for (i = 0; i < priv->num_stations; i++)
3676 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3679 return IPW_INVALID_STATION;
3682 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3686 if (priv->status & STATUS_ASSOCIATING) {
3687 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3688 queue_work(priv->workqueue, &priv->disassociate);
3692 if (!(priv->status & STATUS_ASSOCIATED)) {
3693 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3697 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3699 MAC_ARG(priv->assoc_request.bssid),
3700 priv->assoc_request.channel);
3703 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3705 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3706 err = ipw_send_associate(priv, &priv->assoc_request);
3708 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3713 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3714 priv->status |= STATUS_DISASSOCIATING;
3718 static int ipw_disassociate(void *data)
3720 struct ipw_priv *priv = data;
3721 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3723 ipw_send_disassociate(data, 0);
3727 static void ipw_bg_disassociate(void *data)
3729 struct ipw_priv *priv = data;
3731 ipw_disassociate(data);
3735 static void ipw_system_config(void *data)
3737 struct ipw_priv *priv = data;
3738 ipw_send_system_config(priv, &priv->sys_config);
3741 struct ipw_status_code {
3746 static const struct ipw_status_code ipw_status_codes[] = {
3747 {0x00, "Successful"},
3748 {0x01, "Unspecified failure"},
3749 {0x0A, "Cannot support all requested capabilities in the "
3750 "Capability information field"},
3751 {0x0B, "Reassociation denied due to inability to confirm that "
3752 "association exists"},
3753 {0x0C, "Association denied due to reason outside the scope of this "
3756 "Responding station does not support the specified authentication "
3759 "Received an Authentication frame with authentication sequence "
3760 "transaction sequence number out of expected sequence"},
3761 {0x0F, "Authentication rejected because of challenge failure"},
3762 {0x10, "Authentication rejected due to timeout waiting for next "
3763 "frame in sequence"},
3764 {0x11, "Association denied because AP is unable to handle additional "
3765 "associated stations"},
3767 "Association denied due to requesting station not supporting all "
3768 "of the datarates in the BSSBasicServiceSet Parameter"},
3770 "Association denied due to requesting station not supporting "
3771 "short preamble operation"},
3773 "Association denied due to requesting station not supporting "
3776 "Association denied due to requesting station not supporting "
3779 "Association denied due to requesting station not supporting "
3780 "short slot operation"},
3782 "Association denied due to requesting station not supporting "
3783 "DSSS-OFDM operation"},
3784 {0x28, "Invalid Information Element"},
3785 {0x29, "Group Cipher is not valid"},
3786 {0x2A, "Pairwise Cipher is not valid"},
3787 {0x2B, "AKMP is not valid"},
3788 {0x2C, "Unsupported RSN IE version"},
3789 {0x2D, "Invalid RSN IE Capabilities"},
3790 {0x2E, "Cipher suite is rejected per security policy"},
3793 #ifdef CONFIG_IPW_DEBUG
3794 static const char *ipw_get_status_code(u16 status)
3797 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3798 if (ipw_status_codes[i].status == (status & 0xff))
3799 return ipw_status_codes[i].reason;
3800 return "Unknown status value.";
3804 static void inline average_init(struct average *avg)
3806 memset(avg, 0, sizeof(*avg));
3809 static void inline average_add(struct average *avg, s16 val)
3811 avg->sum -= avg->entries[avg->pos];
3813 avg->entries[avg->pos++] = val;
3814 if (unlikely(avg->pos == AVG_ENTRIES)) {
3820 static s16 inline average_value(struct average *avg)
3822 if (!unlikely(avg->init)) {
3824 return avg->sum / avg->pos;
3828 return avg->sum / AVG_ENTRIES;
3831 static void ipw_reset_stats(struct ipw_priv *priv)
3833 u32 len = sizeof(u32);
3837 average_init(&priv->average_missed_beacons);
3838 average_init(&priv->average_rssi);
3839 average_init(&priv->average_noise);
3841 priv->last_rate = 0;
3842 priv->last_missed_beacons = 0;
3843 priv->last_rx_packets = 0;
3844 priv->last_tx_packets = 0;
3845 priv->last_tx_failures = 0;
3847 /* Firmware managed, reset only when NIC is restarted, so we have to
3848 * normalize on the current value */
3849 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
3850 &priv->last_rx_err, &len);
3851 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
3852 &priv->last_tx_failures, &len);
3854 /* Driver managed, reset with each association */
3855 priv->missed_adhoc_beacons = 0;
3856 priv->missed_beacons = 0;
3857 priv->tx_packets = 0;
3858 priv->rx_packets = 0;
3862 static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
3865 u32 mask = priv->rates_mask;
3866 /* If currently associated in B mode, restrict the maximum
3867 * rate match to B rates */
3868 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3869 mask &= IEEE80211_CCK_RATES_MASK;
3871 /* TODO: Verify that the rate is supported by the current rates
3874 while (i && !(mask & i))
3877 case IEEE80211_CCK_RATE_1MB_MASK:
3879 case IEEE80211_CCK_RATE_2MB_MASK:
3881 case IEEE80211_CCK_RATE_5MB_MASK:
3883 case IEEE80211_OFDM_RATE_6MB_MASK:
3885 case IEEE80211_OFDM_RATE_9MB_MASK:
3887 case IEEE80211_CCK_RATE_11MB_MASK:
3889 case IEEE80211_OFDM_RATE_12MB_MASK:
3891 case IEEE80211_OFDM_RATE_18MB_MASK:
3893 case IEEE80211_OFDM_RATE_24MB_MASK:
3895 case IEEE80211_OFDM_RATE_36MB_MASK:
3897 case IEEE80211_OFDM_RATE_48MB_MASK:
3899 case IEEE80211_OFDM_RATE_54MB_MASK:
3903 if (priv->ieee->mode == IEEE_B)
3909 static u32 ipw_get_current_rate(struct ipw_priv *priv)
3911 u32 rate, len = sizeof(rate);
3914 if (!(priv->status & STATUS_ASSOCIATED))
3917 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3918 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
3921 IPW_DEBUG_INFO("failed querying ordinals.\n");
3925 return ipw_get_max_rate(priv);
3928 case IPW_TX_RATE_1MB:
3930 case IPW_TX_RATE_2MB:
3932 case IPW_TX_RATE_5MB:
3934 case IPW_TX_RATE_6MB:
3936 case IPW_TX_RATE_9MB:
3938 case IPW_TX_RATE_11MB:
3940 case IPW_TX_RATE_12MB:
3942 case IPW_TX_RATE_18MB:
3944 case IPW_TX_RATE_24MB:
3946 case IPW_TX_RATE_36MB:
3948 case IPW_TX_RATE_48MB:
3950 case IPW_TX_RATE_54MB:
3957 #define IPW_STATS_INTERVAL (2 * HZ)
3958 static void ipw_gather_stats(struct ipw_priv *priv)
3960 u32 rx_err, rx_err_delta, rx_packets_delta;
3961 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3962 u32 missed_beacons_percent, missed_beacons_delta;
3964 u32 len = sizeof(u32);
3966 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3970 if (!(priv->status & STATUS_ASSOCIATED)) {
3975 /* Update the statistics */
3976 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
3977 &priv->missed_beacons, &len);
3978 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
3979 priv->last_missed_beacons = priv->missed_beacons;
3980 if (priv->assoc_request.beacon_interval) {
3981 missed_beacons_percent = missed_beacons_delta *
3982 (HZ * priv->assoc_request.beacon_interval) /
3983 (IPW_STATS_INTERVAL * 10);
3985 missed_beacons_percent = 0;
3987 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3989 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3990 rx_err_delta = rx_err - priv->last_rx_err;
3991 priv->last_rx_err = rx_err;
3993 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3994 tx_failures_delta = tx_failures - priv->last_tx_failures;
3995 priv->last_tx_failures = tx_failures;
3997 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
3998 priv->last_rx_packets = priv->rx_packets;
4000 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4001 priv->last_tx_packets = priv->tx_packets;
4003 /* Calculate quality based on the following:
4005 * Missed beacon: 100% = 0, 0% = 70% missed
4006 * Rate: 60% = 1Mbs, 100% = Max
4007 * Rx and Tx errors represent a straight % of total Rx/Tx
4008 * RSSI: 100% = > -50, 0% = < -80
4009 * Rx errors: 100% = 0, 0% = 50% missed
4011 * The lowest computed quality is used.
4014 #define BEACON_THRESHOLD 5
4015 beacon_quality = 100 - missed_beacons_percent;
4016 if (beacon_quality < BEACON_THRESHOLD)
4019 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4020 (100 - BEACON_THRESHOLD);
4021 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4022 beacon_quality, missed_beacons_percent);
4024 priv->last_rate = ipw_get_current_rate(priv);
4025 max_rate = ipw_get_max_rate(priv);
4026 rate_quality = priv->last_rate * 40 / max_rate + 60;
4027 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4028 rate_quality, priv->last_rate / 1000000);
4030 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4031 rx_quality = 100 - (rx_err_delta * 100) /
4032 (rx_packets_delta + rx_err_delta);
4035 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4036 rx_quality, rx_err_delta, rx_packets_delta);
4038 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4039 tx_quality = 100 - (tx_failures_delta * 100) /
4040 (tx_packets_delta + tx_failures_delta);
4043 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4044 tx_quality, tx_failures_delta, tx_packets_delta);
4046 rssi = average_value(&priv->average_rssi);
4049 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4050 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4051 (priv->ieee->perfect_rssi - rssi) *
4052 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4053 62 * (priv->ieee->perfect_rssi - rssi))) /
4054 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4055 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4056 if (signal_quality > 100)
4057 signal_quality = 100;
4058 else if (signal_quality < 1)
4061 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4062 signal_quality, rssi);
4064 quality = min(beacon_quality,
4066 min(tx_quality, min(rx_quality, signal_quality))));
4067 if (quality == beacon_quality)
4068 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4070 if (quality == rate_quality)
4071 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4073 if (quality == tx_quality)
4074 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4076 if (quality == rx_quality)
4077 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4079 if (quality == signal_quality)
4080 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4083 priv->quality = quality;
4085 queue_delayed_work(priv->workqueue, &priv->gather_stats,
4086 IPW_STATS_INTERVAL);
4089 static void ipw_bg_gather_stats(void *data)
4091 struct ipw_priv *priv = data;
4093 ipw_gather_stats(data);
4097 static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
4100 priv->notif_missed_beacons = missed_count;
4102 if (missed_count > priv->disassociate_threshold &&
4103 priv->status & STATUS_ASSOCIATED) {
4104 /* If associated and we've hit the missed
4105 * beacon threshold, disassociate, turn
4106 * off roaming, and abort any active scans */
4107 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4108 IPW_DL_STATE | IPW_DL_ASSOC,
4109 "Missed beacon: %d - disassociate\n", missed_count);
4110 priv->status &= ~STATUS_ROAMING;
4111 if (priv->status & STATUS_SCANNING) {
4112 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4114 "Aborting scan with missed beacon.\n");
4115 queue_work(priv->workqueue, &priv->abort_scan);
4118 queue_work(priv->workqueue, &priv->disassociate);
4122 if (priv->status & STATUS_ROAMING) {
4123 /* If we are currently roaming, then just
4124 * print a debug statement... */
4125 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4126 "Missed beacon: %d - roam in progress\n",
4131 if (missed_count > priv->roaming_threshold) {
4132 /* If we are not already roaming, set the ROAM
4133 * bit in the status and kick off a scan */
4134 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4135 "Missed beacon: %d - initiate "
4136 "roaming\n", missed_count);
4137 if (!(priv->status & STATUS_ROAMING)) {
4138 priv->status |= STATUS_ROAMING;
4139 if (!(priv->status & STATUS_SCANNING))
4140 queue_work(priv->workqueue,
4141 &priv->request_scan);
4146 if (priv->status & STATUS_SCANNING) {
4147 /* Stop scan to keep fw from getting
4148 * stuck (only if we aren't roaming --
4149 * otherwise we'll never scan more than 2 or 3
4151 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4152 "Aborting scan with missed beacon.\n");
4153 queue_work(priv->workqueue, &priv->abort_scan);
4156 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4161 * Handle host notification packet.
4162 * Called from interrupt routine
4164 static inline void ipw_rx_notification(struct ipw_priv *priv,
4165 struct ipw_rx_notification *notif)
4167 notif->size = le16_to_cpu(notif->size);
4169 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4171 switch (notif->subtype) {
4172 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4173 struct notif_association *assoc = ¬if->u.assoc;
4175 switch (assoc->state) {
4176 case CMAS_ASSOCIATED:{
4177 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4179 "associated: '%s' " MAC_FMT
4181 escape_essid(priv->essid,
4183 MAC_ARG(priv->bssid));
4185 switch (priv->ieee->iw_mode) {
4187 memcpy(priv->ieee->bssid,
4188 priv->bssid, ETH_ALEN);
4192 memcpy(priv->ieee->bssid,
4193 priv->bssid, ETH_ALEN);
4195 /* clear out the station table */
4196 priv->num_stations = 0;
4199 ("queueing adhoc check\n");
4200 queue_delayed_work(priv->
4210 priv->status &= ~STATUS_ASSOCIATING;
4211 priv->status |= STATUS_ASSOCIATED;
4212 queue_work(priv->workqueue,
4213 &priv->system_config);
4215 #ifdef CONFIG_IPW_QOS
4216 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4217 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4218 if ((priv->status & STATUS_AUTH) &&
4219 (IPW_GET_PACKET_STYPE(¬if->u.raw)
4220 == IEEE80211_STYPE_ASSOC_RESP)) {
4223 ieee80211_assoc_response)
4225 && (notif->size <= 2314)) {
4238 ieee80211_rx_mgt(priv->
4243 ¬if->u.raw, &stats);
4248 schedule_work(&priv->link_up);
4253 case CMAS_AUTHENTICATED:{
4255 status & (STATUS_ASSOCIATED |
4257 #ifdef CONFIG_IPW_DEBUG
4258 struct notif_authenticate *auth
4260 IPW_DEBUG(IPW_DL_NOTIF |
4263 "deauthenticated: '%s' "
4265 ": (0x%04X) - %s \n",
4270 MAC_ARG(priv->bssid),
4271 ntohs(auth->status),
4278 ~(STATUS_ASSOCIATING |
4282 schedule_work(&priv->link_down);
4286 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4288 "authenticated: '%s' " MAC_FMT
4290 escape_essid(priv->essid,
4292 MAC_ARG(priv->bssid));
4297 if (priv->status & STATUS_AUTH) {
4299 ieee80211_assoc_response
4303 ieee80211_assoc_response
4305 IPW_DEBUG(IPW_DL_NOTIF |
4308 "association failed (0x%04X): %s\n",
4309 ntohs(resp->status),
4315 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4317 "disassociated: '%s' " MAC_FMT
4319 escape_essid(priv->essid,
4321 MAC_ARG(priv->bssid));
4324 ~(STATUS_DISASSOCIATING |
4325 STATUS_ASSOCIATING |
4326 STATUS_ASSOCIATED | STATUS_AUTH);
4327 if (priv->assoc_network
4328 && (priv->assoc_network->
4330 WLAN_CAPABILITY_IBSS))
4331 ipw_remove_current_network
4334 schedule_work(&priv->link_down);
4339 case CMAS_RX_ASSOC_RESP:
4343 IPW_ERROR("assoc: unknown (%d)\n",
4351 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4352 struct notif_authenticate *auth = ¬if->u.auth;
4353 switch (auth->state) {
4354 case CMAS_AUTHENTICATED:
4355 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4356 "authenticated: '%s' " MAC_FMT " \n",
4357 escape_essid(priv->essid,
4359 MAC_ARG(priv->bssid));
4360 priv->status |= STATUS_AUTH;
4364 if (priv->status & STATUS_AUTH) {
4365 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4367 "authentication failed (0x%04X): %s\n",
4368 ntohs(auth->status),
4369 ipw_get_status_code(ntohs
4373 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4375 "deauthenticated: '%s' " MAC_FMT "\n",
4376 escape_essid(priv->essid,
4378 MAC_ARG(priv->bssid));
4380 priv->status &= ~(STATUS_ASSOCIATING |
4384 schedule_work(&priv->link_down);
4387 case CMAS_TX_AUTH_SEQ_1:
4388 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4389 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4391 case CMAS_RX_AUTH_SEQ_2:
4392 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4393 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4395 case CMAS_AUTH_SEQ_1_PASS:
4396 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4397 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4399 case CMAS_AUTH_SEQ_1_FAIL:
4400 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4401 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4403 case CMAS_TX_AUTH_SEQ_3:
4404 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4405 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4407 case CMAS_RX_AUTH_SEQ_4:
4408 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4409 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4411 case CMAS_AUTH_SEQ_2_PASS:
4412 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4413 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4415 case CMAS_AUTH_SEQ_2_FAIL:
4416 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4417 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4420 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4421 IPW_DL_ASSOC, "TX_ASSOC\n");
4423 case CMAS_RX_ASSOC_RESP:
4424 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4425 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4428 case CMAS_ASSOCIATED:
4429 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4430 IPW_DL_ASSOC, "ASSOCIATED\n");
4433 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4440 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4441 struct notif_channel_result *x =
4442 ¬if->u.channel_result;
4444 if (notif->size == sizeof(*x)) {
4445 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4448 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4449 "(should be %zd)\n",
4450 notif->size, sizeof(*x));
4455 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4456 struct notif_scan_complete *x = ¬if->u.scan_complete;
4457 if (notif->size == sizeof(*x)) {
4459 ("Scan completed: type %d, %d channels, "
4460 "%d status\n", x->scan_type,
4461 x->num_channels, x->status);
4463 IPW_ERROR("Scan completed of wrong size %d "
4464 "(should be %zd)\n",
4465 notif->size, sizeof(*x));
4469 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4471 wake_up_interruptible(&priv->wait_state);
4472 cancel_delayed_work(&priv->scan_check);
4474 if (priv->status & STATUS_EXIT_PENDING)
4477 priv->ieee->scans++;
4479 #ifdef CONFIG_IPW2200_MONITOR
4480 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4481 priv->status |= STATUS_SCAN_FORCED;
4482 queue_work(priv->workqueue,
4483 &priv->request_scan);
4486 priv->status &= ~STATUS_SCAN_FORCED;
4487 #endif /* CONFIG_IPW2200_MONITOR */
4489 if (!(priv->status & (STATUS_ASSOCIATED |
4490 STATUS_ASSOCIATING |
4492 STATUS_DISASSOCIATING)))
4493 queue_work(priv->workqueue, &priv->associate);
4494 else if (priv->status & STATUS_ROAMING) {
4495 /* If a scan completed and we are in roam mode, then
4496 * the scan that completed was the one requested as a
4497 * result of entering roam... so, schedule the
4499 queue_work(priv->workqueue, &priv->roam);
4500 } else if (priv->status & STATUS_SCAN_PENDING)
4501 queue_work(priv->workqueue,
4502 &priv->request_scan);
4503 else if (priv->config & CFG_BACKGROUND_SCAN
4504 && priv->status & STATUS_ASSOCIATED)
4505 queue_delayed_work(priv->workqueue,
4506 &priv->request_scan, HZ);
4510 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4511 struct notif_frag_length *x = ¬if->u.frag_len;
4513 if (notif->size == sizeof(*x))
4514 IPW_ERROR("Frag length: %d\n",
4515 le16_to_cpu(x->frag_length));
4517 IPW_ERROR("Frag length of wrong size %d "
4518 "(should be %zd)\n",
4519 notif->size, sizeof(*x));
4523 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4524 struct notif_link_deterioration *x =
4525 ¬if->u.link_deterioration;
4527 if (notif->size == sizeof(*x)) {
4528 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4529 "link deterioration: '%s' " MAC_FMT
4530 " \n", escape_essid(priv->essid,
4532 MAC_ARG(priv->bssid));
4533 memcpy(&priv->last_link_deterioration, x,
4536 IPW_ERROR("Link Deterioration of wrong size %d "
4537 "(should be %zd)\n",
4538 notif->size, sizeof(*x));
4543 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4544 IPW_ERROR("Dino config\n");
4546 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4547 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4552 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4553 struct notif_beacon_state *x = ¬if->u.beacon_state;
4554 if (notif->size != sizeof(*x)) {
4556 ("Beacon state of wrong size %d (should "
4557 "be %zd)\n", notif->size, sizeof(*x));
4561 if (le32_to_cpu(x->state) ==
4562 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4563 ipw_handle_missed_beacon(priv,
4570 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4571 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4572 if (notif->size == sizeof(*x)) {
4573 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4574 "0x%02x station %d\n",
4575 x->key_state, x->security_type,
4581 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4582 notif->size, sizeof(*x));
4586 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4587 struct notif_calibration *x = ¬if->u.calibration;
4589 if (notif->size == sizeof(*x)) {
4590 memcpy(&priv->calib, x, sizeof(*x));
4591 IPW_DEBUG_INFO("TODO: Calibration\n");
4596 ("Calibration of wrong size %d (should be %zd)\n",
4597 notif->size, sizeof(*x));
4601 case HOST_NOTIFICATION_NOISE_STATS:{
4602 if (notif->size == sizeof(u32)) {
4604 (u8) (le32_to_cpu(notif->u.noise.value) &
4606 average_add(&priv->average_noise,
4612 ("Noise stat is wrong size %d (should be %zd)\n",
4613 notif->size, sizeof(u32));
4618 IPW_ERROR("Unknown notification: "
4619 "subtype=%d,flags=0x%2x,size=%d\n",
4620 notif->subtype, notif->flags, notif->size);
4625 * Destroys all DMA structures and initialise them again
4628 * @return error code
4630 static int ipw_queue_reset(struct ipw_priv *priv)
4633 /** @todo customize queue sizes */
4634 int nTx = 64, nTxCmd = 8;
4635 ipw_tx_queue_free(priv);
4637 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4638 IPW_TX_CMD_QUEUE_READ_INDEX,
4639 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4640 IPW_TX_CMD_QUEUE_BD_BASE,
4641 IPW_TX_CMD_QUEUE_BD_SIZE);
4643 IPW_ERROR("Tx Cmd queue init failed\n");
4647 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4648 IPW_TX_QUEUE_0_READ_INDEX,
4649 IPW_TX_QUEUE_0_WRITE_INDEX,
4650 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4652 IPW_ERROR("Tx 0 queue init failed\n");
4655 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4656 IPW_TX_QUEUE_1_READ_INDEX,
4657 IPW_TX_QUEUE_1_WRITE_INDEX,
4658 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4660 IPW_ERROR("Tx 1 queue init failed\n");
4663 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4664 IPW_TX_QUEUE_2_READ_INDEX,
4665 IPW_TX_QUEUE_2_WRITE_INDEX,
4666 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4668 IPW_ERROR("Tx 2 queue init failed\n");
4671 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4672 IPW_TX_QUEUE_3_READ_INDEX,
4673 IPW_TX_QUEUE_3_WRITE_INDEX,
4674 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4676 IPW_ERROR("Tx 3 queue init failed\n");
4680 priv->rx_bufs_min = 0;
4681 priv->rx_pend_max = 0;
4685 ipw_tx_queue_free(priv);
4690 * Reclaim Tx queue entries no more used by NIC.
4692 * When FW adwances 'R' index, all entries between old and
4693 * new 'R' index need to be reclaimed. As result, some free space
4694 * forms. If there is enough free space (> low mark), wake Tx queue.
4696 * @note Need to protect against garbage in 'R' index
4700 * @return Number of used entries remains in the queue
4702 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4703 struct clx2_tx_queue *txq, int qindex)
4707 struct clx2_queue *q = &txq->q;
4709 hw_tail = ipw_read32(priv, q->reg_r);
4710 if (hw_tail >= q->n_bd) {
4712 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4716 for (; q->last_used != hw_tail;
4717 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4718 ipw_queue_tx_free_tfd(priv, txq);
4722 if ((ipw_queue_space(q) > q->low_mark) &&
4724 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4725 netif_wake_queue(priv->net_dev);
4726 used = q->first_empty - q->last_used;
4733 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4736 struct clx2_tx_queue *txq = &priv->txq_cmd;
4737 struct clx2_queue *q = &txq->q;
4738 struct tfd_frame *tfd;
4740 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4741 IPW_ERROR("No space for Tx\n");
4745 tfd = &txq->bd[q->first_empty];
4746 txq->txb[q->first_empty] = NULL;
4748 memset(tfd, 0, sizeof(*tfd));
4749 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4750 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4752 tfd->u.cmd.index = hcmd;
4753 tfd->u.cmd.length = len;
4754 memcpy(tfd->u.cmd.payload, buf, len);
4755 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4756 ipw_write32(priv, q->reg_w, q->first_empty);
4757 _ipw_read32(priv, 0x90);
4763 * Rx theory of operation
4765 * The host allocates 32 DMA target addresses and passes the host address
4766 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4770 * The host/firmware share two index registers for managing the Rx buffers.
4772 * The READ index maps to the first position that the firmware may be writing
4773 * to -- the driver can read up to (but not including) this position and get
4775 * The READ index is managed by the firmware once the card is enabled.
4777 * The WRITE index maps to the last position the driver has read from -- the
4778 * position preceding WRITE is the last slot the firmware can place a packet.
4780 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4783 * During initialization the host sets up the READ queue position to the first
4784 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4786 * When the firmware places a packet in a buffer it will advance the READ index
4787 * and fire the RX interrupt. The driver can then query the READ index and
4788 * process as many packets as possible, moving the WRITE index forward as it
4789 * resets the Rx queue buffers with new memory.
4791 * The management in the driver is as follows:
4792 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
4793 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4794 * to replensish the ipw->rxq->rx_free.
4795 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4796 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4797 * 'processed' and 'read' driver indexes as well)
4798 * + A received packet is processed and handed to the kernel network stack,
4799 * detached from the ipw->rxq. The driver 'processed' index is updated.
4800 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4801 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4802 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
4803 * were enough free buffers and RX_STALLED is set it is cleared.
4808 * ipw_rx_queue_alloc() Allocates rx_free
4809 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4810 * ipw_rx_queue_restock
4811 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4812 * queue, updates firmware pointers, and updates
4813 * the WRITE index. If insufficient rx_free buffers
4814 * are available, schedules ipw_rx_queue_replenish
4816 * -- enable interrupts --
4817 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
4818 * READ INDEX, detaching the SKB from the pool.
4819 * Moves the packet buffer from queue to rx_used.
4820 * Calls ipw_rx_queue_restock to refill any empty
4827 * If there are slots in the RX queue that need to be restocked,
4828 * and we have free pre-allocated buffers, fill the ranks as much
4829 * as we can pulling from rx_free.
4831 * This moves the 'write' index forward to catch up with 'processed', and
4832 * also updates the memory address in the firmware to reference the new
4835 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4837 struct ipw_rx_queue *rxq = priv->rxq;
4838 struct list_head *element;
4839 struct ipw_rx_mem_buffer *rxb;
4840 unsigned long flags;
4843 spin_lock_irqsave(&rxq->lock, flags);
4845 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4846 element = rxq->rx_free.next;
4847 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4850 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4852 rxq->queue[rxq->write] = rxb;
4853 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4856 spin_unlock_irqrestore(&rxq->lock, flags);
4858 /* If the pre-allocated buffer pool is dropping low, schedule to
4860 if (rxq->free_count <= RX_LOW_WATERMARK)
4861 queue_work(priv->workqueue, &priv->rx_replenish);
4863 /* If we've added more space for the firmware to place data, tell it */
4864 if (write != rxq->write)
4865 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4869 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4870 * Also restock the Rx queue via ipw_rx_queue_restock.
4872 * This is called as a scheduled work item (except for during intialization)
4874 static void ipw_rx_queue_replenish(void *data)
4876 struct ipw_priv *priv = data;
4877 struct ipw_rx_queue *rxq = priv->rxq;
4878 struct list_head *element;
4879 struct ipw_rx_mem_buffer *rxb;
4880 unsigned long flags;
4882 spin_lock_irqsave(&rxq->lock, flags);
4883 while (!list_empty(&rxq->rx_used)) {
4884 element = rxq->rx_used.next;
4885 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4886 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4888 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4889 priv->net_dev->name);
4890 /* We don't reschedule replenish work here -- we will
4891 * call the restock method and if it still needs
4892 * more buffers it will schedule replenish */
4897 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4899 pci_map_single(priv->pci_dev, rxb->skb->data,
4900 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4902 list_add_tail(&rxb->list, &rxq->rx_free);
4905 spin_unlock_irqrestore(&rxq->lock, flags);
4907 ipw_rx_queue_restock(priv);
4910 static void ipw_bg_rx_queue_replenish(void *data)
4912 struct ipw_priv *priv = data;
4914 ipw_rx_queue_replenish(data);
4918 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4919 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL
4920 * This free routine walks the list of POOL entries and if SKB is set to
4921 * non NULL it is unmapped and freed
4923 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4930 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4931 if (rxq->pool[i].skb != NULL) {
4932 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4933 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4934 dev_kfree_skb(rxq->pool[i].skb);
4941 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4943 struct ipw_rx_queue *rxq;
4946 rxq = (struct ipw_rx_queue *)kmalloc(sizeof(*rxq), GFP_KERNEL);
4947 if (unlikely(!rxq)) {
4948 IPW_ERROR("memory allocation failed\n");
4951 memset(rxq, 0, sizeof(*rxq));
4952 spin_lock_init(&rxq->lock);
4953 INIT_LIST_HEAD(&rxq->rx_free);
4954 INIT_LIST_HEAD(&rxq->rx_used);
4956 /* Fill the rx_used queue with _all_ of the Rx buffers */
4957 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
4958 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4960 /* Set us so that we have processed and used all buffers, but have
4961 * not restocked the Rx queue with fresh buffers */
4962 rxq->read = rxq->write = 0;
4963 rxq->processed = RX_QUEUE_SIZE - 1;
4964 rxq->free_count = 0;
4969 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4971 rate &= ~IEEE80211_BASIC_RATE_MASK;
4972 if (ieee_mode == IEEE_A) {
4974 case IEEE80211_OFDM_RATE_6MB:
4975 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4977 case IEEE80211_OFDM_RATE_9MB:
4978 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4980 case IEEE80211_OFDM_RATE_12MB:
4982 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4983 case IEEE80211_OFDM_RATE_18MB:
4985 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
4986 case IEEE80211_OFDM_RATE_24MB:
4988 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
4989 case IEEE80211_OFDM_RATE_36MB:
4991 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
4992 case IEEE80211_OFDM_RATE_48MB:
4994 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
4995 case IEEE80211_OFDM_RATE_54MB:
4997 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5005 case IEEE80211_CCK_RATE_1MB:
5006 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5007 case IEEE80211_CCK_RATE_2MB:
5008 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5009 case IEEE80211_CCK_RATE_5MB:
5010 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5011 case IEEE80211_CCK_RATE_11MB:
5012 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5015 /* If we are limited to B modulations, bail at this point */
5016 if (ieee_mode == IEEE_B)
5021 case IEEE80211_OFDM_RATE_6MB:
5022 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5023 case IEEE80211_OFDM_RATE_9MB:
5024 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5025 case IEEE80211_OFDM_RATE_12MB:
5026 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5027 case IEEE80211_OFDM_RATE_18MB:
5028 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5029 case IEEE80211_OFDM_RATE_24MB:
5030 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5031 case IEEE80211_OFDM_RATE_36MB:
5032 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5033 case IEEE80211_OFDM_RATE_48MB:
5034 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5035 case IEEE80211_OFDM_RATE_54MB:
5036 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5042 static int ipw_compatible_rates(struct ipw_priv *priv,
5043 const struct ieee80211_network *network,
5044 struct ipw_supported_rates *rates)
5048 memset(rates, 0, sizeof(*rates));
5049 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5050 rates->num_rates = 0;
5051 for (i = 0; i < num_rates; i++) {
5052 if (!ipw_is_rate_in_mask(priv, network->mode,
5053 network->rates[i])) {
5055 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5056 IPW_DEBUG_SCAN("Adding masked mandatory "
5059 rates->supported_rates[rates->num_rates++] =
5064 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5065 network->rates[i], priv->rates_mask);
5069 rates->supported_rates[rates->num_rates++] = network->rates[i];
5072 num_rates = min(network->rates_ex_len,
5073 (u8) (IPW_MAX_RATES - num_rates));
5074 for (i = 0; i < num_rates; i++) {
5075 if (!ipw_is_rate_in_mask(priv, network->mode,
5076 network->rates_ex[i])) {
5077 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5078 IPW_DEBUG_SCAN("Adding masked mandatory "
5080 network->rates_ex[i]);
5081 rates->supported_rates[rates->num_rates++] =
5086 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5087 network->rates_ex[i], priv->rates_mask);
5091 rates->supported_rates[rates->num_rates++] =
5092 network->rates_ex[i];
5098 static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
5099 const struct ipw_supported_rates *src)
5102 for (i = 0; i < src->num_rates; i++)
5103 dest->supported_rates[i] = src->supported_rates[i];
5104 dest->num_rates = src->num_rates;
5107 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5108 * mask should ever be used -- right now all callers to add the scan rates are
5109 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5110 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5111 u8 modulation, u32 rate_mask)
5113 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5114 IEEE80211_BASIC_RATE_MASK : 0;
5116 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5117 rates->supported_rates[rates->num_rates++] =
5118 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5120 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5121 rates->supported_rates[rates->num_rates++] =
5122 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5124 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5125 rates->supported_rates[rates->num_rates++] = basic_mask |
5126 IEEE80211_CCK_RATE_5MB;
5128 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5129 rates->supported_rates[rates->num_rates++] = basic_mask |
5130 IEEE80211_CCK_RATE_11MB;
5133 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5134 u8 modulation, u32 rate_mask)
5136 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5137 IEEE80211_BASIC_RATE_MASK : 0;
5139 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5140 rates->supported_rates[rates->num_rates++] = basic_mask |
5141 IEEE80211_OFDM_RATE_6MB;
5143 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5144 rates->supported_rates[rates->num_rates++] =
5145 IEEE80211_OFDM_RATE_9MB;
5147 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5148 rates->supported_rates[rates->num_rates++] = basic_mask |
5149 IEEE80211_OFDM_RATE_12MB;
5151 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5152 rates->supported_rates[rates->num_rates++] =
5153 IEEE80211_OFDM_RATE_18MB;
5155 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5156 rates->supported_rates[rates->num_rates++] = basic_mask |
5157 IEEE80211_OFDM_RATE_24MB;
5159 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5160 rates->supported_rates[rates->num_rates++] =
5161 IEEE80211_OFDM_RATE_36MB;
5163 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5164 rates->supported_rates[rates->num_rates++] =
5165 IEEE80211_OFDM_RATE_48MB;
5167 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5168 rates->supported_rates[rates->num_rates++] =
5169 IEEE80211_OFDM_RATE_54MB;
5172 struct ipw_network_match {
5173 struct ieee80211_network *network;
5174 struct ipw_supported_rates rates;
5177 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5178 struct ipw_network_match *match,
5179 struct ieee80211_network *network,
5182 struct ipw_supported_rates rates;
5184 /* Verify that this network's capability is compatible with the
5185 * current mode (AdHoc or Infrastructure) */
5186 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5187 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5188 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5189 "capability mismatch.\n",
5190 escape_essid(network->ssid, network->ssid_len),
5191 MAC_ARG(network->bssid));
5195 /* If we do not have an ESSID for this AP, we can not associate with
5197 if (network->flags & NETWORK_EMPTY_ESSID) {
5198 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5199 "because of hidden ESSID.\n",
5200 escape_essid(network->ssid, network->ssid_len),
5201 MAC_ARG(network->bssid));
5205 if (unlikely(roaming)) {
5206 /* If we are roaming, then ensure check if this is a valid
5207 * network to try and roam to */
5208 if ((network->ssid_len != match->network->ssid_len) ||
5209 memcmp(network->ssid, match->network->ssid,
5210 network->ssid_len)) {
5211 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5212 "because of non-network ESSID.\n",
5213 escape_essid(network->ssid,
5215 MAC_ARG(network->bssid));
5219 /* If an ESSID has been configured then compare the broadcast
5221 if ((priv->config & CFG_STATIC_ESSID) &&
5222 ((network->ssid_len != priv->essid_len) ||
5223 memcmp(network->ssid, priv->essid,
5224 min(network->ssid_len, priv->essid_len)))) {
5225 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5228 escape_essid(network->ssid, network->ssid_len),
5230 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5231 "because of ESSID mismatch: '%s'.\n",
5232 escaped, MAC_ARG(network->bssid),
5233 escape_essid(priv->essid,
5239 /* If the old network rate is better than this one, don't bother
5240 * testing everything else. */
5242 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5243 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5244 "current network.\n",
5245 escape_essid(match->network->ssid,
5246 match->network->ssid_len));
5248 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5249 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5250 "current network.\n",
5251 escape_essid(match->network->ssid,
5252 match->network->ssid_len));
5256 /* Now go through and see if the requested network is valid... */
5257 if (priv->ieee->scan_age != 0 &&
5258 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5259 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5260 "because of age: %lums.\n",
5261 escape_essid(network->ssid, network->ssid_len),
5262 MAC_ARG(network->bssid),
5263 1000 * (jiffies - network->last_scanned) / HZ);
5267 if ((priv->config & CFG_STATIC_CHANNEL) &&
5268 (network->channel != priv->channel)) {
5269 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5270 "because of channel mismatch: %d != %d.\n",
5271 escape_essid(network->ssid, network->ssid_len),
5272 MAC_ARG(network->bssid),
5273 network->channel, priv->channel);
5277 /* Verify privacy compatability */
5278 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5279 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5280 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5281 "because of privacy mismatch: %s != %s.\n",
5282 escape_essid(network->ssid, network->ssid_len),
5283 MAC_ARG(network->bssid),
5285 capability & CAP_PRIVACY_ON ? "on" : "off",
5287 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5292 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5293 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5294 "because of the same BSSID match: " MAC_FMT
5295 ".\n", escape_essid(network->ssid,
5297 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5301 /* Filter out any incompatible freq / mode combinations */
5302 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5303 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5304 "because of invalid frequency/mode "
5306 escape_essid(network->ssid, network->ssid_len),
5307 MAC_ARG(network->bssid));
5311 /* Ensure that the rates supported by the driver are compatible with
5312 * this AP, including verification of basic rates (mandatory) */
5313 if (!ipw_compatible_rates(priv, network, &rates)) {
5314 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5315 "because configured rate mask excludes "
5316 "AP mandatory rate.\n",
5317 escape_essid(network->ssid, network->ssid_len),
5318 MAC_ARG(network->bssid));
5322 if (rates.num_rates == 0) {
5323 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5324 "because of no compatible rates.\n",
5325 escape_essid(network->ssid, network->ssid_len),
5326 MAC_ARG(network->bssid));
5330 /* TODO: Perform any further minimal comparititive tests. We do not
5331 * want to put too much policy logic here; intelligent scan selection
5332 * should occur within a generic IEEE 802.11 user space tool. */
5334 /* Set up 'new' AP to this network */
5335 ipw_copy_rates(&match->rates, &rates);
5336 match->network = network;
5337 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5338 escape_essid(network->ssid, network->ssid_len),
5339 MAC_ARG(network->bssid));
5344 static void ipw_merge_adhoc_network(void *data)
5346 struct ipw_priv *priv = data;
5347 struct ieee80211_network *network = NULL;
5348 struct ipw_network_match match = {
5349 .network = priv->assoc_network
5352 if ((priv->status & STATUS_ASSOCIATED) &&
5353 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5354 /* First pass through ROAM process -- look for a better
5356 unsigned long flags;
5358 spin_lock_irqsave(&priv->ieee->lock, flags);
5359 list_for_each_entry(network, &priv->ieee->network_list, list) {
5360 if (network != priv->assoc_network)
5361 ipw_find_adhoc_network(priv, &match, network,
5364 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5366 if (match.network == priv->assoc_network) {
5367 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5373 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5374 IPW_DEBUG_MERGE("remove network %s\n",
5375 escape_essid(priv->essid,
5377 ipw_remove_current_network(priv);
5380 ipw_disassociate(priv);
5381 priv->assoc_network = match.network;
5387 static int ipw_best_network(struct ipw_priv *priv,
5388 struct ipw_network_match *match,
5389 struct ieee80211_network *network, int roaming)
5391 struct ipw_supported_rates rates;
5393 /* Verify that this network's capability is compatible with the
5394 * current mode (AdHoc or Infrastructure) */
5395 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5396 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5397 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5398 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5399 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5400 "capability mismatch.\n",
5401 escape_essid(network->ssid, network->ssid_len),
5402 MAC_ARG(network->bssid));
5406 /* If we do not have an ESSID for this AP, we can not associate with
5408 if (network->flags & NETWORK_EMPTY_ESSID) {
5409 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5410 "because of hidden ESSID.\n",
5411 escape_essid(network->ssid, network->ssid_len),
5412 MAC_ARG(network->bssid));
5416 if (unlikely(roaming)) {
5417 /* If we are roaming, then ensure check if this is a valid
5418 * network to try and roam to */
5419 if ((network->ssid_len != match->network->ssid_len) ||
5420 memcmp(network->ssid, match->network->ssid,
5421 network->ssid_len)) {
5422 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5423 "because of non-network ESSID.\n",
5424 escape_essid(network->ssid,
5426 MAC_ARG(network->bssid));
5430 /* If an ESSID has been configured then compare the broadcast
5432 if ((priv->config & CFG_STATIC_ESSID) &&
5433 ((network->ssid_len != priv->essid_len) ||
5434 memcmp(network->ssid, priv->essid,
5435 min(network->ssid_len, priv->essid_len)))) {
5436 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5438 escape_essid(network->ssid, network->ssid_len),
5440 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5441 "because of ESSID mismatch: '%s'.\n",
5442 escaped, MAC_ARG(network->bssid),
5443 escape_essid(priv->essid,
5449 /* If the old network rate is better than this one, don't bother
5450 * testing everything else. */
5451 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5452 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5454 escape_essid(network->ssid, network->ssid_len),
5456 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5457 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5458 escaped, MAC_ARG(network->bssid),
5459 escape_essid(match->network->ssid,
5460 match->network->ssid_len),
5461 MAC_ARG(match->network->bssid));
5465 /* If this network has already had an association attempt within the
5466 * last 3 seconds, do not try and associate again... */
5467 if (network->last_associate &&
5468 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5469 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5470 "because of storming (%lus since last "
5471 "assoc attempt).\n",
5472 escape_essid(network->ssid, network->ssid_len),
5473 MAC_ARG(network->bssid),
5474 (jiffies - network->last_associate) / HZ);
5478 /* Now go through and see if the requested network is valid... */
5479 if (priv->ieee->scan_age != 0 &&
5480 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5481 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5482 "because of age: %lums.\n",
5483 escape_essid(network->ssid, network->ssid_len),
5484 MAC_ARG(network->bssid),
5485 1000 * (jiffies - network->last_scanned) / HZ);
5489 if ((priv->config & CFG_STATIC_CHANNEL) &&
5490 (network->channel != priv->channel)) {
5491 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5492 "because of channel mismatch: %d != %d.\n",
5493 escape_essid(network->ssid, network->ssid_len),
5494 MAC_ARG(network->bssid),
5495 network->channel, priv->channel);
5499 /* Verify privacy compatability */
5500 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5501 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5502 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5503 "because of privacy mismatch: %s != %s.\n",
5504 escape_essid(network->ssid, network->ssid_len),
5505 MAC_ARG(network->bssid),
5506 priv->capability & CAP_PRIVACY_ON ? "on" :
5508 network->capability &
5509 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5513 if ((priv->config & CFG_STATIC_BSSID) &&
5514 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5515 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5516 "because of BSSID mismatch: " MAC_FMT ".\n",
5517 escape_essid(network->ssid, network->ssid_len),
5518 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5522 /* Filter out any incompatible freq / mode combinations */
5523 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5524 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5525 "because of invalid frequency/mode "
5527 escape_essid(network->ssid, network->ssid_len),
5528 MAC_ARG(network->bssid));
5532 /* Filter out invalid channel in current GEO */
5533 if (!ipw_is_valid_channel(priv->ieee, network->channel)) {
5534 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5535 "because of invalid channel in current GEO\n",
5536 escape_essid(network->ssid, network->ssid_len),
5537 MAC_ARG(network->bssid));
5541 /* Ensure that the rates supported by the driver are compatible with
5542 * this AP, including verification of basic rates (mandatory) */
5543 if (!ipw_compatible_rates(priv, network, &rates)) {
5544 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5545 "because configured rate mask excludes "
5546 "AP mandatory rate.\n",
5547 escape_essid(network->ssid, network->ssid_len),
5548 MAC_ARG(network->bssid));
5552 if (rates.num_rates == 0) {
5553 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5554 "because of no compatible rates.\n",
5555 escape_essid(network->ssid, network->ssid_len),
5556 MAC_ARG(network->bssid));
5560 /* TODO: Perform any further minimal comparititive tests. We do not
5561 * want to put too much policy logic here; intelligent scan selection
5562 * should occur within a generic IEEE 802.11 user space tool. */
5564 /* Set up 'new' AP to this network */
5565 ipw_copy_rates(&match->rates, &rates);
5566 match->network = network;
5568 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5569 escape_essid(network->ssid, network->ssid_len),
5570 MAC_ARG(network->bssid));
5575 static void ipw_adhoc_create(struct ipw_priv *priv,
5576 struct ieee80211_network *network)
5578 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5582 * For the purposes of scanning, we can set our wireless mode
5583 * to trigger scans across combinations of bands, but when it
5584 * comes to creating a new ad-hoc network, we have tell the FW
5585 * exactly which band to use.
5587 * We also have the possibility of an invalid channel for the
5588 * chossen band. Attempting to create a new ad-hoc network
5589 * with an invalid channel for wireless mode will trigger a
5593 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
5594 case IEEE80211_52GHZ_BAND:
5595 network->mode = IEEE_A;
5596 i = ipw_channel_to_index(priv->ieee, priv->channel);
5599 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5600 IPW_WARNING("Overriding invalid channel\n");
5601 priv->channel = geo->a[0].channel;
5605 case IEEE80211_24GHZ_BAND:
5606 if (priv->ieee->mode & IEEE_G)
5607 network->mode = IEEE_G;
5609 network->mode = IEEE_B;
5610 i = ipw_channel_to_index(priv->ieee, priv->channel);
5613 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5614 IPW_WARNING("Overriding invalid channel\n");
5615 priv->channel = geo->bg[0].channel;
5620 IPW_WARNING("Overriding invalid channel\n");
5621 if (priv->ieee->mode & IEEE_A) {
5622 network->mode = IEEE_A;
5623 priv->channel = geo->a[0].channel;
5624 } else if (priv->ieee->mode & IEEE_G) {
5625 network->mode = IEEE_G;
5626 priv->channel = geo->bg[0].channel;
5628 network->mode = IEEE_B;
5629 priv->channel = geo->bg[0].channel;
5634 network->channel = priv->channel;
5635 priv->config |= CFG_ADHOC_PERSIST;
5636 ipw_create_bssid(priv, network->bssid);
5637 network->ssid_len = priv->essid_len;
5638 memcpy(network->ssid, priv->essid, priv->essid_len);
5639 memset(&network->stats, 0, sizeof(network->stats));
5640 network->capability = WLAN_CAPABILITY_IBSS;
5641 if (!(priv->config & CFG_PREAMBLE_LONG))
5642 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5643 if (priv->capability & CAP_PRIVACY_ON)
5644 network->capability |= WLAN_CAPABILITY_PRIVACY;
5645 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5646 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5647 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5648 memcpy(network->rates_ex,
5649 &priv->rates.supported_rates[network->rates_len],
5650 network->rates_ex_len);
5651 network->last_scanned = 0;
5653 network->last_associate = 0;
5654 network->time_stamp[0] = 0;
5655 network->time_stamp[1] = 0;
5656 network->beacon_interval = 100; /* Default */
5657 network->listen_interval = 10; /* Default */
5658 network->atim_window = 0; /* Default */
5659 network->wpa_ie_len = 0;
5660 network->rsn_ie_len = 0;
5663 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5665 struct ipw_tgi_tx_key *key;
5666 struct host_cmd cmd = {
5667 .cmd = IPW_CMD_TGI_TX_KEY,
5671 if (!(priv->ieee->sec.flags & (1 << index)))
5674 key = (struct ipw_tgi_tx_key *)&cmd.param;
5675 key->key_id = index;
5676 memcpy(key->key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5677 key->security_type = type;
5678 key->station_index = 0; /* always 0 for BSS */
5680 /* 0 for new key; previous value of counter (after fatal error) */
5681 key->tx_counter[0] = 0;
5682 key->tx_counter[1] = 0;
5684 ipw_send_cmd(priv, &cmd);
5687 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5689 struct ipw_wep_key *key;
5691 struct host_cmd cmd = {
5692 .cmd = IPW_CMD_WEP_KEY,
5696 key = (struct ipw_wep_key *)&cmd.param;
5697 key->cmd_id = DINO_CMD_WEP_KEY;
5700 /* Note: AES keys cannot be set for multiple times.
5701 * Only set it at the first time. */
5702 for (i = 0; i < 4; i++) {
5703 key->key_index = i | type;
5704 if (!(priv->ieee->sec.flags & (1 << i))) {
5709 key->key_size = priv->ieee->sec.key_sizes[i];
5710 memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);
5712 ipw_send_cmd(priv, &cmd);
5716 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5718 if (priv->ieee->host_encrypt)
5723 priv->sys_config.disable_unicast_decryption = 0;
5724 priv->ieee->host_decrypt = 0;
5727 priv->sys_config.disable_unicast_decryption = 1;
5728 priv->ieee->host_decrypt = 1;
5731 priv->sys_config.disable_unicast_decryption = 0;
5732 priv->ieee->host_decrypt = 0;
5735 priv->sys_config.disable_unicast_decryption = 1;
5742 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5744 if (priv->ieee->host_encrypt)
5749 priv->sys_config.disable_multicast_decryption = 0;
5752 priv->sys_config.disable_multicast_decryption = 1;
5755 priv->sys_config.disable_multicast_decryption = 0;
5758 priv->sys_config.disable_multicast_decryption = 1;
5765 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5767 switch (priv->ieee->sec.level) {
5769 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5770 ipw_send_tgi_tx_key(priv,
5771 DCT_FLAG_EXT_SECURITY_CCM,
5772 priv->ieee->sec.active_key);
5774 if (!priv->ieee->host_mc_decrypt)
5775 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5778 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5779 ipw_send_tgi_tx_key(priv,
5780 DCT_FLAG_EXT_SECURITY_TKIP,
5781 priv->ieee->sec.active_key);
5784 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5792 static void ipw_adhoc_check(void *data)
5794 struct ipw_priv *priv = data;
5796 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5797 !(priv->config & CFG_ADHOC_PERSIST)) {
5798 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5799 IPW_DL_STATE | IPW_DL_ASSOC,
5800 "Missed beacon: %d - disassociate\n",
5801 priv->missed_adhoc_beacons);
5802 ipw_remove_current_network(priv);
5803 ipw_disassociate(priv);
5807 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5808 priv->assoc_request.beacon_interval);
5811 static void ipw_bg_adhoc_check(void *data)
5813 struct ipw_priv *priv = data;
5815 ipw_adhoc_check(data);
5819 #ifdef CONFIG_IPW_DEBUG
5820 static void ipw_debug_config(struct ipw_priv *priv)
5822 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5823 "[CFG 0x%08X]\n", priv->config);
5824 if (priv->config & CFG_STATIC_CHANNEL)
5825 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5827 IPW_DEBUG_INFO("Channel unlocked.\n");
5828 if (priv->config & CFG_STATIC_ESSID)
5829 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5830 escape_essid(priv->essid, priv->essid_len));
5832 IPW_DEBUG_INFO("ESSID unlocked.\n");
5833 if (priv->config & CFG_STATIC_BSSID)
5834 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5835 MAC_ARG(priv->bssid));
5837 IPW_DEBUG_INFO("BSSID unlocked.\n");
5838 if (priv->capability & CAP_PRIVACY_ON)
5839 IPW_DEBUG_INFO("PRIVACY on\n");
5841 IPW_DEBUG_INFO("PRIVACY off\n");
5842 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5845 #define ipw_debug_config(x) do {} while (0)
5848 static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5850 /* TODO: Verify that this works... */
5851 struct ipw_fixed_rate fr = {
5852 .tx_rates = priv->rates_mask
5857 /* Identify 'current FW band' and match it with the fixed
5860 switch (priv->ieee->freq_band) {
5861 case IEEE80211_52GHZ_BAND: /* A only */
5863 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5864 /* Invalid fixed rate mask */
5866 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5871 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5874 default: /* 2.4Ghz or Mixed */
5876 if (mode == IEEE_B) {
5877 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5878 /* Invalid fixed rate mask */
5880 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5887 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5888 IEEE80211_OFDM_RATES_MASK)) {
5889 /* Invalid fixed rate mask */
5891 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5896 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5897 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5898 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5901 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5902 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5903 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5906 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5907 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5908 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5911 fr.tx_rates |= mask;
5915 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5916 ipw_write_reg32(priv, reg, *(u32 *) & fr);
5919 static void ipw_abort_scan(struct ipw_priv *priv)
5923 if (priv->status & STATUS_SCAN_ABORTING) {
5924 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5927 priv->status |= STATUS_SCAN_ABORTING;
5929 err = ipw_send_scan_abort(priv);
5931 IPW_DEBUG_HC("Request to abort scan failed.\n");
5934 static void ipw_add_scan_channels(struct ipw_priv *priv,
5935 struct ipw_scan_request_ext *scan,
5938 int channel_index = 0;
5939 const struct ieee80211_geo *geo;
5942 geo = ipw_get_geo(priv->ieee);
5944 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5945 int start = channel_index;
5946 for (i = 0; i < geo->a_channels; i++) {
5947 if ((priv->status & STATUS_ASSOCIATED) &&
5948 geo->a[i].channel == priv->channel)
5951 scan->channels_list[channel_index] = geo->a[i].channel;
5952 ipw_set_scan_type(scan, channel_index,
5954 flags & IEEE80211_CH_PASSIVE_ONLY ?
5955 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5959 if (start != channel_index) {
5960 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5961 (channel_index - start);
5966 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5967 int start = channel_index;
5968 if (priv->config & CFG_SPEED_SCAN) {
5970 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5971 /* nop out the list */
5976 while (channel_index < IPW_SCAN_CHANNELS) {
5978 priv->speed_scan[priv->speed_scan_pos];
5980 priv->speed_scan_pos = 0;
5981 channel = priv->speed_scan[0];
5983 if ((priv->status & STATUS_ASSOCIATED) &&
5984 channel == priv->channel) {
5985 priv->speed_scan_pos++;
5989 /* If this channel has already been
5990 * added in scan, break from loop
5991 * and this will be the first channel
5994 if (channels[channel - 1] != 0)
5997 channels[channel - 1] = 1;
5998 priv->speed_scan_pos++;
6000 scan->channels_list[channel_index] = channel;
6002 ipw_channel_to_index(priv->ieee, channel);
6003 ipw_set_scan_type(scan, channel_index,
6006 IEEE80211_CH_PASSIVE_ONLY ?
6007 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6011 for (i = 0; i < geo->bg_channels; i++) {
6012 if ((priv->status & STATUS_ASSOCIATED) &&
6013 geo->bg[i].channel == priv->channel)
6016 scan->channels_list[channel_index] =
6018 ipw_set_scan_type(scan, channel_index,
6021 IEEE80211_CH_PASSIVE_ONLY ?
6022 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6027 if (start != channel_index) {
6028 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6029 (channel_index - start);
6034 static int ipw_request_scan(struct ipw_priv *priv)
6036 struct ipw_scan_request_ext scan;
6037 int err = 0, scan_type;
6039 if (!(priv->status & STATUS_INIT) ||
6040 (priv->status & STATUS_EXIT_PENDING))
6045 if (priv->status & STATUS_SCANNING) {
6046 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
6047 priv->status |= STATUS_SCAN_PENDING;
6051 if (!(priv->status & STATUS_SCAN_FORCED) &&
6052 priv->status & STATUS_SCAN_ABORTING) {
6053 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6054 priv->status |= STATUS_SCAN_PENDING;
6058 if (priv->status & STATUS_RF_KILL_MASK) {
6059 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6060 priv->status |= STATUS_SCAN_PENDING;
6064 memset(&scan, 0, sizeof(scan));
6066 if (priv->config & CFG_SPEED_SCAN)
6067 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6070 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6073 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6075 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6077 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6079 #ifdef CONFIG_IPW2200_MONITOR
6080 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6084 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
6085 case IEEE80211_52GHZ_BAND:
6086 band = (u8) (IPW_A_MODE << 6) | 1;
6087 channel = priv->channel;
6090 case IEEE80211_24GHZ_BAND:
6091 band = (u8) (IPW_B_MODE << 6) | 1;
6092 channel = priv->channel;
6096 band = (u8) (IPW_B_MODE << 6) | 1;
6101 scan.channels_list[0] = band;
6102 scan.channels_list[1] = channel;
6103 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6105 /* NOTE: The card will sit on this channel for this time
6106 * period. Scan aborts are timing sensitive and frequently
6107 * result in firmware restarts. As such, it is best to
6108 * set a small dwell_time here and just keep re-issuing
6109 * scans. Otherwise fast channel hopping will not actually
6112 * TODO: Move SPEED SCAN support to all modes and bands */
6113 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6116 #endif /* CONFIG_IPW2200_MONITOR */
6117 /* If we are roaming, then make this a directed scan for the
6118 * current network. Otherwise, ensure that every other scan
6119 * is a fast channel hop scan */
6120 if ((priv->status & STATUS_ROAMING)
6121 || (!(priv->status & STATUS_ASSOCIATED)
6122 && (priv->config & CFG_STATIC_ESSID)
6123 && (le32_to_cpu(scan.full_scan_index) % 2))) {
6124 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6126 IPW_DEBUG_HC("Attempt to send SSID command "
6131 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6133 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6135 ipw_add_scan_channels(priv, &scan, scan_type);
6136 #ifdef CONFIG_IPW2200_MONITOR
6140 err = ipw_send_scan_request_ext(priv, &scan);
6142 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6146 priv->status |= STATUS_SCANNING;
6147 priv->status &= ~STATUS_SCAN_PENDING;
6148 queue_delayed_work(priv->workqueue, &priv->scan_check,
6149 IPW_SCAN_CHECK_WATCHDOG);
6155 static void ipw_bg_abort_scan(void *data)
6157 struct ipw_priv *priv = data;
6159 ipw_abort_scan(data);
6163 #if WIRELESS_EXT < 18
6164 /* Support for wpa_supplicant before WE-18, deprecated. */
6166 /* following definitions must match definitions in driver_ipw.c */
6168 #define IPW_IOCTL_WPA_SUPPLICANT SIOCIWFIRSTPRIV+30
6170 #define IPW_CMD_SET_WPA_PARAM 1
6171 #define IPW_CMD_SET_WPA_IE 2
6172 #define IPW_CMD_SET_ENCRYPTION 3
6173 #define IPW_CMD_MLME 4
6175 #define IPW_PARAM_WPA_ENABLED 1
6176 #define IPW_PARAM_TKIP_COUNTERMEASURES 2
6177 #define IPW_PARAM_DROP_UNENCRYPTED 3
6178 #define IPW_PARAM_PRIVACY_INVOKED 4
6179 #define IPW_PARAM_AUTH_ALGS 5
6180 #define IPW_PARAM_IEEE_802_1X 6
6182 #define IPW_MLME_STA_DEAUTH 1
6183 #define IPW_MLME_STA_DISASSOC 2
6185 #define IPW_CRYPT_ERR_UNKNOWN_ALG 2
6186 #define IPW_CRYPT_ERR_UNKNOWN_ADDR 3
6187 #define IPW_CRYPT_ERR_CRYPT_INIT_FAILED 4
6188 #define IPW_CRYPT_ERR_KEY_SET_FAILED 5
6189 #define IPW_CRYPT_ERR_TX_KEY_SET_FAILED 6
6190 #define IPW_CRYPT_ERR_CARD_CONF_FAILED 7
6192 #define IPW_CRYPT_ALG_NAME_LEN 16
6196 u8 sta_addr[ETH_ALEN];
6212 u8 alg[IPW_CRYPT_ALG_NAME_LEN];
6216 u8 seq[8]; /* sequence counter (set: RX, get: TX) */
6224 /* end of driver_ipw.c code */
6227 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6229 /* This is called when wpa_supplicant loads and closes the driver
6234 #if WIRELESS_EXT < 18
6235 #define IW_AUTH_ALG_OPEN_SYSTEM 0x1
6236 #define IW_AUTH_ALG_SHARED_KEY 0x2
6239 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6241 struct ieee80211_device *ieee = priv->ieee;
6242 struct ieee80211_security sec = {
6243 .flags = SEC_AUTH_MODE,
6247 if (value & IW_AUTH_ALG_SHARED_KEY) {
6248 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6250 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6251 sec.auth_mode = WLAN_AUTH_OPEN;
6256 if (ieee->set_security)
6257 ieee->set_security(ieee->dev, &sec);
6264 void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie, int wpa_ie_len)
6266 /* make sure WPA is enabled */
6267 ipw_wpa_enable(priv, 1);
6269 ipw_disassociate(priv);
6272 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6273 char *capabilities, int length)
6275 struct host_cmd cmd = {
6276 .cmd = IPW_CMD_RSN_CAPABILITIES,
6280 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6282 memcpy(cmd.param, capabilities, length);
6283 return ipw_send_cmd(priv, &cmd);
6286 #if WIRELESS_EXT < 18
6287 static int ipw_wpa_set_param(struct net_device *dev, u8 name, u32 value)
6289 struct ipw_priv *priv = ieee80211_priv(dev);
6290 struct ieee80211_crypt_data *crypt;
6291 unsigned long flags;
6295 case IPW_PARAM_WPA_ENABLED:
6296 ret = ipw_wpa_enable(priv, value);
6299 case IPW_PARAM_TKIP_COUNTERMEASURES:
6300 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6301 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) {
6302 IPW_WARNING("Can't set TKIP countermeasures: "
6303 "crypt not set!\n");
6307 flags = crypt->ops->get_flags(crypt->priv);
6310 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6312 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6314 crypt->ops->set_flags(flags, crypt->priv);
6318 case IPW_PARAM_DROP_UNENCRYPTED:{
6321 * wpa_supplicant calls set_wpa_enabled when the driver
6322 * is loaded and unloaded, regardless of if WPA is being
6323 * used. No other calls are made which can be used to
6324 * determine if encryption will be used or not prior to
6325 * association being expected. If encryption is not being
6326 * used, drop_unencrypted is set to false, else true -- we
6327 * can use this to determine if the CAP_PRIVACY_ON bit should
6330 struct ieee80211_security sec = {
6331 .flags = SEC_ENABLED,
6334 priv->ieee->drop_unencrypted = value;
6335 /* We only change SEC_LEVEL for open mode. Others
6336 * are set by ipw_wpa_set_encryption.
6339 sec.flags |= SEC_LEVEL;
6340 sec.level = SEC_LEVEL_0;
6342 sec.flags |= SEC_LEVEL;
6343 sec.level = SEC_LEVEL_1;
6345 if (priv->ieee->set_security)
6346 priv->ieee->set_security(priv->ieee->dev, &sec);
6350 case IPW_PARAM_PRIVACY_INVOKED:
6351 priv->ieee->privacy_invoked = value;
6354 case IPW_PARAM_AUTH_ALGS:
6355 ret = ipw_wpa_set_auth_algs(priv, value);
6358 case IPW_PARAM_IEEE_802_1X:
6359 priv->ieee->ieee802_1x = value;
6363 IPW_ERROR("%s: Unknown WPA param: %d\n", dev->name, name);
6370 static int ipw_wpa_mlme(struct net_device *dev, int command, int reason)
6372 struct ipw_priv *priv = ieee80211_priv(dev);
6376 case IPW_MLME_STA_DEAUTH:
6380 case IPW_MLME_STA_DISASSOC:
6381 ipw_disassociate(priv);
6385 IPW_ERROR("%s: Unknown MLME request: %d\n", dev->name, command);
6392 static int ipw_wpa_ie_cipher2level(u8 cipher)
6399 case 5: /* WEP104 */
6409 static int ipw_wpa_set_wpa_ie(struct net_device *dev,
6410 struct ipw_param *param, int plen)
6412 struct ipw_priv *priv = ieee80211_priv(dev);
6413 struct ieee80211_device *ieee = priv->ieee;
6418 if (param->u.wpa_ie.len > MAX_WPA_IE_LEN ||
6419 (param->u.wpa_ie.len && param->u.wpa_ie.data == NULL))
6422 if (param->u.wpa_ie.len) {
6423 buf = kmalloc(param->u.wpa_ie.len, GFP_KERNEL);
6427 memcpy(buf, param->u.wpa_ie.data, param->u.wpa_ie.len);
6428 kfree(ieee->wpa_ie);
6430 ieee->wpa_ie_len = param->u.wpa_ie.len;
6432 kfree(ieee->wpa_ie);
6433 ieee->wpa_ie = NULL;
6434 ieee->wpa_ie_len = 0;
6438 if (priv->ieee->host_encrypt)
6441 /* HACK: Parse wpa_ie here to get pairwise suite, otherwise
6442 * we need to change driver_ipw.c from wpa_supplicant. This
6443 * is OK since -Dipw is deprecated. The -Dwext driver has a
6444 * clean way to handle this. */
6445 gtk = ptk = (u8 *) ieee->wpa_ie;
6446 if (ieee->wpa_ie[0] == 0x30) { /* RSN IE */
6448 ptk += 4 + 4 + 2 + 3;
6449 } else { /* WPA IE */
6451 ptk += 8 + 4 + 2 + 3;
6454 if (ptk - (u8 *) ieee->wpa_ie > ieee->wpa_ie_len)
6457 level = ipw_wpa_ie_cipher2level(*gtk);
6458 ipw_set_hw_decrypt_multicast(priv, level);
6460 level = ipw_wpa_ie_cipher2level(*ptk);
6461 ipw_set_hw_decrypt_unicast(priv, level);
6464 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6468 /* implementation borrowed from hostap driver */
6470 static int ipw_wpa_set_encryption(struct net_device *dev,
6471 struct ipw_param *param, int param_len)
6475 struct ipw_priv *priv = ieee80211_priv(dev);
6476 struct ieee80211_device *ieee = priv->ieee;
6477 struct ieee80211_crypto_ops *ops;
6478 struct ieee80211_crypt_data **crypt;
6480 struct ieee80211_security sec = {
6484 param->u.crypt.err = 0;
6485 param->u.crypt.alg[IPW_CRYPT_ALG_NAME_LEN - 1] = '\0';
6488 (int)((char *)param->u.crypt.key - (char *)param) +
6489 param->u.crypt.key_len) {
6490 IPW_DEBUG_INFO("Len mismatch %d, %d\n", param_len,
6491 param->u.crypt.key_len);
6494 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
6495 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
6496 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
6497 if (param->u.crypt.idx >= WEP_KEYS)
6499 crypt = &ieee->crypt[param->u.crypt.idx];
6504 if (param->u.crypt.idx != 0)
6507 sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
6508 if (strcmp(param->u.crypt.alg, "none") == 0) {
6512 sec.level = SEC_LEVEL_0;
6513 sec.flags |= SEC_LEVEL;
6514 ieee80211_crypt_delayed_deinit(ieee, crypt);
6521 /* IPW HW cannot build TKIP MIC, host decryption still needed. */
6522 if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
6524 ieee->host_mc_decrypt = 1;
6526 ieee->host_encrypt_msdu = 1;
6529 /*if (!(ieee->host_encrypt || ieee->host_encrypt_msdu ||
6530 ieee->host_decrypt))
6531 goto skip_host_crypt; */
6532 if (group_key ? !ieee->host_mc_decrypt :
6533 !(ieee->host_encrypt || ieee->host_decrypt ||
6534 ieee->host_encrypt_msdu))
6535 goto skip_host_crypt;
6537 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
6538 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) {
6539 request_module("ieee80211_crypt_wep");
6540 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
6541 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) {
6542 request_module("ieee80211_crypt_tkip");
6543 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
6544 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) {
6545 request_module("ieee80211_crypt_ccmp");
6546 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
6549 IPW_DEBUG_INFO("%s: unknown crypto alg '%s'\n",
6550 dev->name, param->u.crypt.alg);
6551 param->u.crypt.err = IPW_CRYPT_ERR_UNKNOWN_ALG;
6556 if (*crypt == NULL || (*crypt)->ops != ops) {
6557 struct ieee80211_crypt_data *new_crypt;
6559 ieee80211_crypt_delayed_deinit(ieee, crypt);
6561 new_crypt = (struct ieee80211_crypt_data *)
6562 kmalloc(sizeof(*new_crypt), GFP_KERNEL);
6563 if (new_crypt == NULL) {
6567 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
6568 new_crypt->ops = ops;
6569 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
6571 new_crypt->ops->init(param->u.crypt.idx);
6573 if (new_crypt->priv == NULL) {
6575 param->u.crypt.err = IPW_CRYPT_ERR_CRYPT_INIT_FAILED;
6583 if (param->u.crypt.key_len > 0 && (*crypt)->ops->set_key &&
6584 (*crypt)->ops->set_key(param->u.crypt.key,
6585 param->u.crypt.key_len, param->u.crypt.seq,
6586 (*crypt)->priv) < 0) {
6587 IPW_DEBUG_INFO("%s: key setting failed\n", dev->name);
6588 param->u.crypt.err = IPW_CRYPT_ERR_KEY_SET_FAILED;
6594 if (param->u.crypt.set_tx) {
6595 ieee->tx_keyidx = param->u.crypt.idx;
6596 sec.active_key = param->u.crypt.idx;
6597 sec.flags |= SEC_ACTIVE_KEY;
6599 sec.flags &= ~SEC_ACTIVE_KEY;
6601 if (param->u.crypt.alg != NULL) {
6602 memcpy(sec.keys[param->u.crypt.idx],
6603 param->u.crypt.key, param->u.crypt.key_len);
6604 sec.key_sizes[param->u.crypt.idx] = param->u.crypt.key_len;
6605 sec.flags |= (1 << param->u.crypt.idx);
6607 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
6608 sec.flags |= SEC_LEVEL;
6609 sec.level = SEC_LEVEL_1;
6610 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
6611 sec.flags |= SEC_LEVEL;
6612 sec.level = SEC_LEVEL_2;
6613 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
6614 sec.flags |= SEC_LEVEL;
6615 sec.level = SEC_LEVEL_3;
6617 /* Don't set sec level for group keys. */
6619 sec.flags &= ~SEC_LEVEL;
6622 if (ieee->set_security)
6623 ieee->set_security(ieee->dev, &sec);
6625 /* Do not reset port if card is in Managed mode since resetting will
6626 * generate new IEEE 802.11 authentication which may end up in looping
6627 * with IEEE 802.1X. If your hardware requires a reset after WEP
6628 * configuration (for example... Prism2), implement the reset_port in
6629 * the callbacks structures used to initialize the 802.11 stack. */
6630 if (ieee->reset_on_keychange &&
6631 ieee->iw_mode != IW_MODE_INFRA &&
6632 ieee->reset_port && ieee->reset_port(dev)) {
6633 IPW_DEBUG_INFO("%s: reset_port failed\n", dev->name);
6634 param->u.crypt.err = IPW_CRYPT_ERR_CARD_CONF_FAILED;
6641 static int ipw_wpa_supplicant(struct net_device *dev, struct iw_point *p)
6643 struct ipw_param *param;
6644 struct ipw_priv *priv = ieee80211_priv(dev);
6647 IPW_DEBUG_INFO("wpa_supplicant: len=%d\n", p->length);
6649 if (p->length < sizeof(struct ipw_param) || !p->pointer)
6652 param = (struct ipw_param *)kmalloc(p->length, GFP_KERNEL);
6656 if (copy_from_user(param, p->pointer, p->length)) {
6662 switch (param->cmd) {
6664 case IPW_CMD_SET_WPA_PARAM:
6665 ret = ipw_wpa_set_param(dev, param->u.wpa_param.name,
6666 param->u.wpa_param.value);
6669 case IPW_CMD_SET_WPA_IE:
6670 ret = ipw_wpa_set_wpa_ie(dev, param, p->length);
6673 case IPW_CMD_SET_ENCRYPTION:
6674 ret = ipw_wpa_set_encryption(dev, param, p->length);
6678 ret = ipw_wpa_mlme(dev, param->u.mlme.command,
6679 param->u.mlme.reason_code);
6683 IPW_ERROR("%s: Unknown WPA supplicant request: %d\n",
6684 dev->name, param->cmd);
6689 if (ret == 0 && copy_to_user(p->pointer, param, p->length))
6701 static int ipw_wx_set_genie(struct net_device *dev,
6702 struct iw_request_info *info,
6703 union iwreq_data *wrqu, char *extra)
6705 struct ipw_priv *priv = ieee80211_priv(dev);
6706 struct ieee80211_device *ieee = priv->ieee;
6710 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6711 (wrqu->data.length && extra == NULL))
6716 //if (!ieee->wpa_enabled) {
6717 // err = -EOPNOTSUPP;
6721 if (wrqu->data.length) {
6722 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6728 memcpy(buf, extra, wrqu->data.length);
6729 kfree(ieee->wpa_ie);
6731 ieee->wpa_ie_len = wrqu->data.length;
6733 kfree(ieee->wpa_ie);
6734 ieee->wpa_ie = NULL;
6735 ieee->wpa_ie_len = 0;
6738 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6745 static int ipw_wx_get_genie(struct net_device *dev,
6746 struct iw_request_info *info,
6747 union iwreq_data *wrqu, char *extra)
6749 struct ipw_priv *priv = ieee80211_priv(dev);
6750 struct ieee80211_device *ieee = priv->ieee;
6755 //if (!ieee->wpa_enabled) {
6756 // err = -EOPNOTSUPP;
6760 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6761 wrqu->data.length = 0;
6765 if (wrqu->data.length < ieee->wpa_ie_len) {
6770 wrqu->data.length = ieee->wpa_ie_len;
6771 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6778 static int wext_cipher2level(int cipher)
6781 case IW_AUTH_CIPHER_NONE:
6783 case IW_AUTH_CIPHER_WEP40:
6784 case IW_AUTH_CIPHER_WEP104:
6786 case IW_AUTH_CIPHER_TKIP:
6788 case IW_AUTH_CIPHER_CCMP:
6796 static int ipw_wx_set_auth(struct net_device *dev,
6797 struct iw_request_info *info,
6798 union iwreq_data *wrqu, char *extra)
6800 struct ipw_priv *priv = ieee80211_priv(dev);
6801 struct ieee80211_device *ieee = priv->ieee;
6802 struct iw_param *param = &wrqu->param;
6803 struct ieee80211_crypt_data *crypt;
6804 unsigned long flags;
6807 switch (param->flags & IW_AUTH_INDEX) {
6808 case IW_AUTH_WPA_VERSION:
6810 case IW_AUTH_CIPHER_PAIRWISE:
6811 ipw_set_hw_decrypt_unicast(priv,
6812 wext_cipher2level(param->value));
6814 case IW_AUTH_CIPHER_GROUP:
6815 ipw_set_hw_decrypt_multicast(priv,
6816 wext_cipher2level(param->value));
6818 case IW_AUTH_KEY_MGMT:
6820 * ipw2200 does not use these parameters
6824 case IW_AUTH_TKIP_COUNTERMEASURES:
6825 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6826 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) {
6827 IPW_WARNING("Can't set TKIP countermeasures: "
6828 "crypt not set!\n");
6832 flags = crypt->ops->get_flags(crypt->priv);
6835 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6837 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6839 crypt->ops->set_flags(flags, crypt->priv);
6843 case IW_AUTH_DROP_UNENCRYPTED:{
6846 * wpa_supplicant calls set_wpa_enabled when the driver
6847 * is loaded and unloaded, regardless of if WPA is being
6848 * used. No other calls are made which can be used to
6849 * determine if encryption will be used or not prior to
6850 * association being expected. If encryption is not being
6851 * used, drop_unencrypted is set to false, else true -- we
6852 * can use this to determine if the CAP_PRIVACY_ON bit should
6855 struct ieee80211_security sec = {
6856 .flags = SEC_ENABLED,
6857 .enabled = param->value,
6859 priv->ieee->drop_unencrypted = param->value;
6860 /* We only change SEC_LEVEL for open mode. Others
6861 * are set by ipw_wpa_set_encryption.
6863 if (!param->value) {
6864 sec.flags |= SEC_LEVEL;
6865 sec.level = SEC_LEVEL_0;
6867 sec.flags |= SEC_LEVEL;
6868 sec.level = SEC_LEVEL_1;
6870 if (priv->ieee->set_security)
6871 priv->ieee->set_security(priv->ieee->dev, &sec);
6875 case IW_AUTH_80211_AUTH_ALG:
6876 ret = ipw_wpa_set_auth_algs(priv, param->value);
6879 case IW_AUTH_WPA_ENABLED:
6880 ret = ipw_wpa_enable(priv, param->value);
6883 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6884 ieee->ieee802_1x = param->value;
6887 //case IW_AUTH_ROAMING_CONTROL:
6888 case IW_AUTH_PRIVACY_INVOKED:
6889 ieee->privacy_invoked = param->value;
6899 static int ipw_wx_get_auth(struct net_device *dev,
6900 struct iw_request_info *info,
6901 union iwreq_data *wrqu, char *extra)
6903 struct ipw_priv *priv = ieee80211_priv(dev);
6904 struct ieee80211_device *ieee = priv->ieee;
6905 struct ieee80211_crypt_data *crypt;
6906 struct iw_param *param = &wrqu->param;
6909 switch (param->flags & IW_AUTH_INDEX) {
6910 case IW_AUTH_WPA_VERSION:
6911 case IW_AUTH_CIPHER_PAIRWISE:
6912 case IW_AUTH_CIPHER_GROUP:
6913 case IW_AUTH_KEY_MGMT:
6915 * wpa_supplicant will control these internally
6920 case IW_AUTH_TKIP_COUNTERMEASURES:
6921 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6922 if (!crypt || !crypt->ops->get_flags) {
6923 IPW_WARNING("Can't get TKIP countermeasures: "
6924 "crypt not set!\n");
6928 param->value = (crypt->ops->get_flags(crypt->priv) &
6929 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6933 case IW_AUTH_DROP_UNENCRYPTED:
6934 param->value = ieee->drop_unencrypted;
6937 case IW_AUTH_80211_AUTH_ALG:
6938 param->value = ieee->sec.auth_mode;
6941 case IW_AUTH_WPA_ENABLED:
6942 param->value = ieee->wpa_enabled;
6945 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6946 param->value = ieee->ieee802_1x;
6949 case IW_AUTH_ROAMING_CONTROL:
6950 case IW_AUTH_PRIVACY_INVOKED:
6951 param->value = ieee->privacy_invoked;
6960 /* SIOCSIWENCODEEXT */
6961 static int ipw_wx_set_encodeext(struct net_device *dev,
6962 struct iw_request_info *info,
6963 union iwreq_data *wrqu, char *extra)
6965 struct ipw_priv *priv = ieee80211_priv(dev);
6966 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6969 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6970 /* IPW HW can't build TKIP MIC,
6971 host decryption still needed */
6972 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6973 priv->ieee->host_mc_decrypt = 1;
6975 priv->ieee->host_encrypt = 0;
6976 priv->ieee->host_encrypt_msdu = 1;
6977 priv->ieee->host_decrypt = 1;
6980 priv->ieee->host_encrypt = 0;
6981 priv->ieee->host_encrypt_msdu = 0;
6982 priv->ieee->host_decrypt = 0;
6983 priv->ieee->host_mc_decrypt = 0;
6987 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6990 /* SIOCGIWENCODEEXT */
6991 static int ipw_wx_get_encodeext(struct net_device *dev,
6992 struct iw_request_info *info,
6993 union iwreq_data *wrqu, char *extra)
6995 struct ipw_priv *priv = ieee80211_priv(dev);
6996 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
7000 static int ipw_wx_set_mlme(struct net_device *dev,
7001 struct iw_request_info *info,
7002 union iwreq_data *wrqu, char *extra)
7004 struct ipw_priv *priv = ieee80211_priv(dev);
7005 struct iw_mlme *mlme = (struct iw_mlme *)extra;
7008 reason = cpu_to_le16(mlme->reason_code);
7010 switch (mlme->cmd) {
7011 case IW_MLME_DEAUTH:
7015 case IW_MLME_DISASSOC:
7016 ipw_disassociate(priv);
7026 #ifdef CONFIG_IPW_QOS
7030 * get the modulation type of the current network or
7031 * the card current mode
7033 u8 ipw_qos_current_mode(struct ipw_priv * priv)
7037 if (priv->status & STATUS_ASSOCIATED) {
7038 unsigned long flags;
7040 spin_lock_irqsave(&priv->ieee->lock, flags);
7041 mode = priv->assoc_network->mode;
7042 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7044 mode = priv->ieee->mode;
7046 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
7051 * Handle management frame beacon and probe response
7053 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
7055 struct ieee80211_network *network)
7057 u32 size = sizeof(struct ieee80211_qos_parameters);
7059 if (network->capability & WLAN_CAPABILITY_IBSS)
7060 network->qos_data.active = network->qos_data.supported;
7062 if (network->flags & NETWORK_HAS_QOS_MASK) {
7063 if (active_network &&
7064 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
7065 network->qos_data.active = network->qos_data.supported;
7067 if ((network->qos_data.active == 1) && (active_network == 1) &&
7068 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
7069 (network->qos_data.old_param_count !=
7070 network->qos_data.param_count)) {
7071 network->qos_data.old_param_count =
7072 network->qos_data.param_count;
7073 schedule_work(&priv->qos_activate);
7074 IPW_DEBUG_QOS("QoS parameters change call "
7078 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
7079 memcpy(&network->qos_data.parameters,
7080 &def_parameters_CCK, size);
7082 memcpy(&network->qos_data.parameters,
7083 &def_parameters_OFDM, size);
7085 if ((network->qos_data.active == 1) && (active_network == 1)) {
7086 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
7087 schedule_work(&priv->qos_activate);
7090 network->qos_data.active = 0;
7091 network->qos_data.supported = 0;
7093 if ((priv->status & STATUS_ASSOCIATED) &&
7094 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
7095 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
7096 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
7097 !(network->flags & NETWORK_EMPTY_ESSID))
7098 if ((network->ssid_len ==
7099 priv->assoc_network->ssid_len) &&
7100 !memcmp(network->ssid,
7101 priv->assoc_network->ssid,
7102 network->ssid_len)) {
7103 queue_work(priv->workqueue,
7104 &priv->merge_networks);
7112 * This function set up the firmware to support QoS. It sends
7113 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
7115 static int ipw_qos_activate(struct ipw_priv *priv,
7116 struct ieee80211_qos_data *qos_network_data)
7119 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
7120 struct ieee80211_qos_parameters *active_one = NULL;
7121 u32 size = sizeof(struct ieee80211_qos_parameters);
7126 type = ipw_qos_current_mode(priv);
7128 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
7129 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
7130 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
7131 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
7133 if (qos_network_data == NULL) {
7134 if (type == IEEE_B) {
7135 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
7136 active_one = &def_parameters_CCK;
7138 active_one = &def_parameters_OFDM;
7140 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7141 burst_duration = ipw_qos_get_burst_duration(priv);
7142 for (i = 0; i < QOS_QUEUE_NUM; i++)
7143 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
7144 (u16) burst_duration;
7145 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7146 if (type == IEEE_B) {
7147 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
7149 if (priv->qos_data.qos_enable == 0)
7150 active_one = &def_parameters_CCK;
7152 active_one = priv->qos_data.def_qos_parm_CCK;
7154 if (priv->qos_data.qos_enable == 0)
7155 active_one = &def_parameters_OFDM;
7157 active_one = priv->qos_data.def_qos_parm_OFDM;
7159 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7161 unsigned long flags;
7164 spin_lock_irqsave(&priv->ieee->lock, flags);
7165 active_one = &(qos_network_data->parameters);
7166 qos_network_data->old_param_count =
7167 qos_network_data->param_count;
7168 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7169 active = qos_network_data->supported;
7170 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7173 burst_duration = ipw_qos_get_burst_duration(priv);
7174 for (i = 0; i < QOS_QUEUE_NUM; i++)
7175 qos_parameters[QOS_PARAM_SET_ACTIVE].
7176 tx_op_limit[i] = (u16) burst_duration;
7180 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
7181 err = ipw_send_qos_params_command(priv,
7182 (struct ieee80211_qos_parameters *)
7183 &(qos_parameters[0]));
7185 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
7191 * send IPW_CMD_WME_INFO to the firmware
7193 static int ipw_qos_set_info_element(struct ipw_priv *priv)
7196 struct ieee80211_qos_information_element qos_info;
7201 qos_info.elementID = QOS_ELEMENT_ID;
7202 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
7204 qos_info.version = QOS_VERSION_1;
7205 qos_info.ac_info = 0;
7207 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
7208 qos_info.qui_type = QOS_OUI_TYPE;
7209 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
7211 ret = ipw_send_qos_info_command(priv, &qos_info);
7213 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
7219 * Set the QoS parameter with the association request structure
7221 static int ipw_qos_association(struct ipw_priv *priv,
7222 struct ieee80211_network *network)
7225 struct ieee80211_qos_data *qos_data = NULL;
7226 struct ieee80211_qos_data ibss_data = {
7231 switch (priv->ieee->iw_mode) {
7233 if (!(network->capability & WLAN_CAPABILITY_IBSS))
7236 qos_data = &ibss_data;
7240 qos_data = &network->qos_data;
7248 err = ipw_qos_activate(priv, qos_data);
7250 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
7254 if (priv->qos_data.qos_enable && qos_data->supported) {
7255 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
7256 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
7257 return ipw_qos_set_info_element(priv);
7264 * handling the beaconing responces. if we get different QoS setting
7265 * of the network from the the associated setting adjust the QoS
7268 static int ipw_qos_association_resp(struct ipw_priv *priv,
7269 struct ieee80211_network *network)
7272 unsigned long flags;
7273 u32 size = sizeof(struct ieee80211_qos_parameters);
7274 int set_qos_param = 0;
7276 if ((priv == NULL) || (network == NULL) ||
7277 (priv->assoc_network == NULL))
7280 if (!(priv->status & STATUS_ASSOCIATED))
7283 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
7286 spin_lock_irqsave(&priv->ieee->lock, flags);
7287 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
7288 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
7289 sizeof(struct ieee80211_qos_data));
7290 priv->assoc_network->qos_data.active = 1;
7291 if ((network->qos_data.old_param_count !=
7292 network->qos_data.param_count)) {
7294 network->qos_data.old_param_count =
7295 network->qos_data.param_count;
7299 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7300 memcpy(&priv->assoc_network->qos_data.parameters,
7301 &def_parameters_CCK, size);
7303 memcpy(&priv->assoc_network->qos_data.parameters,
7304 &def_parameters_OFDM, size);
7305 priv->assoc_network->qos_data.active = 0;
7306 priv->assoc_network->qos_data.supported = 0;
7310 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7312 if (set_qos_param == 1)
7313 schedule_work(&priv->qos_activate);
7318 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
7325 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
7326 ret = priv->qos_data.burst_duration_CCK;
7328 ret = priv->qos_data.burst_duration_OFDM;
7334 * Initialize the setting of QoS global
7336 static void ipw_qos_init(struct ipw_priv *priv, int enable,
7337 int burst_enable, u32 burst_duration_CCK,
7338 u32 burst_duration_OFDM)
7340 priv->qos_data.qos_enable = enable;
7342 if (priv->qos_data.qos_enable) {
7343 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7344 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7345 IPW_DEBUG_QOS("QoS is enabled\n");
7347 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7348 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7349 IPW_DEBUG_QOS("QoS is not enabled\n");
7352 priv->qos_data.burst_enable = burst_enable;
7355 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7356 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7358 priv->qos_data.burst_duration_CCK = 0;
7359 priv->qos_data.burst_duration_OFDM = 0;
7364 * map the packet priority to the right TX Queue
7366 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
7368 if (priority > 7 || !priv->qos_data.qos_enable)
7371 return from_priority_to_tx_queue[priority] - 1;
7375 * add QoS parameter to the TX command
7377 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
7379 struct tfd_data *tfd, u8 unicast)
7382 int tx_queue_id = 0;
7383 struct ieee80211_qos_data *qos_data = NULL;
7384 int active, supported;
7385 unsigned long flags;
7387 if (!(priv->status & STATUS_ASSOCIATED))
7390 qos_data = &priv->assoc_network->qos_data;
7392 spin_lock_irqsave(&priv->ieee->lock, flags);
7394 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7396 qos_data->active = 0;
7398 qos_data->active = qos_data->supported;
7401 active = qos_data->active;
7402 supported = qos_data->supported;
7404 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7406 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
7408 priv->qos_data.qos_enable, active, supported, unicast);
7409 if (active && priv->qos_data.qos_enable) {
7410 ret = from_priority_to_tx_queue[priority];
7411 tx_queue_id = ret - 1;
7412 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
7413 if (priority <= 7) {
7414 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7415 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
7416 tfd->tfd.tfd_26.mchdr.frame_ctl |=
7417 IEEE80211_STYPE_QOS_DATA;
7419 if (priv->qos_data.qos_no_ack_mask &
7420 (1UL << tx_queue_id)) {
7421 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
7422 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
7432 * background support to run QoS activate functionality
7434 static void ipw_bg_qos_activate(void *data)
7436 struct ipw_priv *priv = data;
7443 if (priv->status & STATUS_ASSOCIATED)
7444 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7449 static int ipw_handle_probe_response(struct net_device *dev,
7450 struct ieee80211_probe_response *resp,
7451 struct ieee80211_network *network)
7453 struct ipw_priv *priv = ieee80211_priv(dev);
7454 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7455 (network == priv->assoc_network));
7457 ipw_qos_handle_probe_response(priv, active_network, network);
7462 static int ipw_handle_beacon(struct net_device *dev,
7463 struct ieee80211_beacon *resp,
7464 struct ieee80211_network *network)
7466 struct ipw_priv *priv = ieee80211_priv(dev);
7467 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7468 (network == priv->assoc_network));
7470 ipw_qos_handle_probe_response(priv, active_network, network);
7475 static int ipw_handle_assoc_response(struct net_device *dev,
7476 struct ieee80211_assoc_response *resp,
7477 struct ieee80211_network *network)
7479 struct ipw_priv *priv = ieee80211_priv(dev);
7480 ipw_qos_association_resp(priv, network);
7484 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7487 struct host_cmd cmd = {
7488 .cmd = IPW_CMD_QOS_PARAMETERS,
7489 .len = (sizeof(struct ieee80211_qos_parameters) * 3)
7492 memcpy(cmd.param, qos_param, sizeof(*qos_param) * 3);
7493 return ipw_send_cmd(priv, &cmd);
7496 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7499 struct host_cmd cmd = {
7500 .cmd = IPW_CMD_WME_INFO,
7501 .len = sizeof(*qos_param)
7504 memcpy(cmd.param, qos_param, sizeof(*qos_param));
7505 return ipw_send_cmd(priv, &cmd);
7508 #endif /* CONFIG_IPW_QOS */
7510 static int ipw_associate_network(struct ipw_priv *priv,
7511 struct ieee80211_network *network,
7512 struct ipw_supported_rates *rates, int roaming)
7516 if (priv->config & CFG_FIXED_RATE)
7517 ipw_set_fixed_rate(priv, network->mode);
7519 if (!(priv->config & CFG_STATIC_ESSID)) {
7520 priv->essid_len = min(network->ssid_len,
7521 (u8) IW_ESSID_MAX_SIZE);
7522 memcpy(priv->essid, network->ssid, priv->essid_len);
7525 network->last_associate = jiffies;
7527 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7528 priv->assoc_request.channel = network->channel;
7529 if ((priv->capability & CAP_PRIVACY_ON) &&
7530 (priv->capability & CAP_SHARED_KEY)) {
7531 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7532 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7534 if ((priv->capability & CAP_PRIVACY_ON) &&
7535 (priv->ieee->sec.level == SEC_LEVEL_1) &&
7536 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
7537 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7539 priv->assoc_request.auth_type = AUTH_OPEN;
7540 priv->assoc_request.auth_key = 0;
7543 if (priv->ieee->wpa_ie_len) {
7544 priv->assoc_request.policy_support = 0x02; /* RSN active */
7545 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7546 priv->ieee->wpa_ie_len);
7550 * It is valid for our ieee device to support multiple modes, but
7551 * when it comes to associating to a given network we have to choose
7554 if (network->mode & priv->ieee->mode & IEEE_A)
7555 priv->assoc_request.ieee_mode = IPW_A_MODE;
7556 else if (network->mode & priv->ieee->mode & IEEE_G)
7557 priv->assoc_request.ieee_mode = IPW_G_MODE;
7558 else if (network->mode & priv->ieee->mode & IEEE_B)
7559 priv->assoc_request.ieee_mode = IPW_B_MODE;
7561 priv->assoc_request.capability = network->capability;
7562 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7563 && !(priv->config & CFG_PREAMBLE_LONG)) {
7564 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7566 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7568 /* Clear the short preamble if we won't be supporting it */
7569 priv->assoc_request.capability &=
7570 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7573 /* Clear capability bits that aren't used in Ad Hoc */
7574 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7575 priv->assoc_request.capability &=
7576 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7578 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7579 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7580 roaming ? "Rea" : "A",
7581 escape_essid(priv->essid, priv->essid_len),
7583 ipw_modes[priv->assoc_request.ieee_mode],
7585 (priv->assoc_request.preamble_length ==
7586 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7587 network->capability &
7588 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7589 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7590 priv->capability & CAP_PRIVACY_ON ?
7591 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7593 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7594 priv->capability & CAP_PRIVACY_ON ?
7595 '1' + priv->ieee->sec.active_key : '.',
7596 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7598 priv->assoc_request.beacon_interval = network->beacon_interval;
7599 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7600 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7601 priv->assoc_request.assoc_type = HC_IBSS_START;
7602 priv->assoc_request.assoc_tsf_msw = 0;
7603 priv->assoc_request.assoc_tsf_lsw = 0;
7605 if (unlikely(roaming))
7606 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7608 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7609 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7610 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7613 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7615 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7616 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7617 priv->assoc_request.atim_window = network->atim_window;
7619 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7620 priv->assoc_request.atim_window = 0;
7623 priv->assoc_request.listen_interval = network->listen_interval;
7625 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7627 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7631 rates->ieee_mode = priv->assoc_request.ieee_mode;
7632 rates->purpose = IPW_RATE_CONNECT;
7633 ipw_send_supported_rates(priv, rates);
7635 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7636 priv->sys_config.dot11g_auto_detection = 1;
7638 priv->sys_config.dot11g_auto_detection = 0;
7640 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7641 priv->sys_config.answer_broadcast_ssid_probe = 1;
7643 priv->sys_config.answer_broadcast_ssid_probe = 0;
7645 err = ipw_send_system_config(priv, &priv->sys_config);
7647 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7651 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7652 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7654 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7659 * If preemption is enabled, it is possible for the association
7660 * to complete before we return from ipw_send_associate. Therefore
7661 * we have to be sure and update our priviate data first.
7663 priv->channel = network->channel;
7664 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7666 priv->assoc_network = network;
7668 #ifdef CONFIG_IPW_QOS
7669 ipw_qos_association(priv, network);
7672 err = ipw_send_associate(priv, &priv->assoc_request);
7674 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7678 priv->status |= STATUS_ASSOCIATING;
7679 priv->status &= ~STATUS_SECURITY_UPDATED;
7681 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7682 escape_essid(priv->essid, priv->essid_len),
7683 MAC_ARG(priv->bssid));
7688 static void ipw_roam(void *data)
7690 struct ipw_priv *priv = data;
7691 struct ieee80211_network *network = NULL;
7692 struct ipw_network_match match = {
7693 .network = priv->assoc_network
7696 /* The roaming process is as follows:
7698 * 1. Missed beacon threshold triggers the roaming process by
7699 * setting the status ROAM bit and requesting a scan.
7700 * 2. When the scan completes, it schedules the ROAM work
7701 * 3. The ROAM work looks at all of the known networks for one that
7702 * is a better network than the currently associated. If none
7703 * found, the ROAM process is over (ROAM bit cleared)
7704 * 4. If a better network is found, a disassociation request is
7706 * 5. When the disassociation completes, the roam work is again
7707 * scheduled. The second time through, the driver is no longer
7708 * associated, and the newly selected network is sent an
7709 * association request.
7710 * 6. At this point ,the roaming process is complete and the ROAM
7711 * status bit is cleared.
7714 /* If we are no longer associated, and the roaming bit is no longer
7715 * set, then we are not actively roaming, so just return */
7716 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7719 if (priv->status & STATUS_ASSOCIATED) {
7720 /* First pass through ROAM process -- look for a better
7722 unsigned long flags;
7723 u8 rssi = priv->assoc_network->stats.rssi;
7724 priv->assoc_network->stats.rssi = -128;
7725 spin_lock_irqsave(&priv->ieee->lock, flags);
7726 list_for_each_entry(network, &priv->ieee->network_list, list) {
7727 if (network != priv->assoc_network)
7728 ipw_best_network(priv, &match, network, 1);
7730 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7731 priv->assoc_network->stats.rssi = rssi;
7733 if (match.network == priv->assoc_network) {
7734 IPW_DEBUG_ASSOC("No better APs in this network to "
7736 priv->status &= ~STATUS_ROAMING;
7737 ipw_debug_config(priv);
7741 ipw_send_disassociate(priv, 1);
7742 priv->assoc_network = match.network;
7747 /* Second pass through ROAM process -- request association */
7748 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7749 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7750 priv->status &= ~STATUS_ROAMING;
7753 static void ipw_bg_roam(void *data)
7755 struct ipw_priv *priv = data;
7761 static int ipw_associate(void *data)
7763 struct ipw_priv *priv = data;
7765 struct ieee80211_network *network = NULL;
7766 struct ipw_network_match match = {
7769 struct ipw_supported_rates *rates;
7770 struct list_head *element;
7771 unsigned long flags;
7773 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7774 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7778 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7779 IPW_DEBUG_ASSOC("Not attempting association (already in "
7784 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7785 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7790 if (!(priv->config & CFG_ASSOCIATE) &&
7791 !(priv->config & (CFG_STATIC_ESSID |
7792 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7793 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7797 /* Protect our use of the network_list */
7798 spin_lock_irqsave(&priv->ieee->lock, flags);
7799 list_for_each_entry(network, &priv->ieee->network_list, list)
7800 ipw_best_network(priv, &match, network, 0);
7802 network = match.network;
7803 rates = &match.rates;
7805 if (network == NULL &&
7806 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7807 priv->config & CFG_ADHOC_CREATE &&
7808 priv->config & CFG_STATIC_ESSID &&
7809 priv->config & CFG_STATIC_CHANNEL &&
7810 !list_empty(&priv->ieee->network_free_list)) {
7811 element = priv->ieee->network_free_list.next;
7812 network = list_entry(element, struct ieee80211_network, list);
7813 ipw_adhoc_create(priv, network);
7814 rates = &priv->rates;
7816 list_add_tail(&network->list, &priv->ieee->network_list);
7818 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7820 /* If we reached the end of the list, then we don't have any valid
7823 ipw_debug_config(priv);
7825 if (!(priv->status & STATUS_SCANNING)) {
7826 if (!(priv->config & CFG_SPEED_SCAN))
7827 queue_delayed_work(priv->workqueue,
7828 &priv->request_scan,
7831 queue_work(priv->workqueue,
7832 &priv->request_scan);
7838 ipw_associate_network(priv, network, rates, 0);
7843 static void ipw_bg_associate(void *data)
7845 struct ipw_priv *priv = data;
7847 ipw_associate(data);
7851 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7852 struct sk_buff *skb)
7854 struct ieee80211_hdr *hdr;
7857 hdr = (struct ieee80211_hdr *)skb->data;
7858 fc = le16_to_cpu(hdr->frame_ctl);
7859 if (!(fc & IEEE80211_FCTL_PROTECTED))
7862 fc &= ~IEEE80211_FCTL_PROTECTED;
7863 hdr->frame_ctl = cpu_to_le16(fc);
7864 switch (priv->ieee->sec.level) {
7866 /* Remove CCMP HDR */
7867 memmove(skb->data + IEEE80211_3ADDR_LEN,
7868 skb->data + IEEE80211_3ADDR_LEN + 8,
7869 skb->len - IEEE80211_3ADDR_LEN - 8);
7870 if (fc & IEEE80211_FCTL_MOREFRAGS)
7871 skb_trim(skb, skb->len - 16); /* 2*MIC */
7873 skb_trim(skb, skb->len - 8); /* MIC */
7879 memmove(skb->data + IEEE80211_3ADDR_LEN,
7880 skb->data + IEEE80211_3ADDR_LEN + 4,
7881 skb->len - IEEE80211_3ADDR_LEN - 4);
7882 if (fc & IEEE80211_FCTL_MOREFRAGS)
7883 skb_trim(skb, skb->len - 8); /* 2*ICV */
7885 skb_trim(skb, skb->len - 4); /* ICV */
7890 printk(KERN_ERR "Unknow security level %d\n",
7891 priv->ieee->sec.level);
7896 static void ipw_handle_data_packet(struct ipw_priv *priv,
7897 struct ipw_rx_mem_buffer *rxb,
7898 struct ieee80211_rx_stats *stats)
7900 struct ieee80211_hdr_4addr *hdr;
7901 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7903 /* We received data from the HW, so stop the watchdog */
7904 priv->net_dev->trans_start = jiffies;
7906 /* We only process data packets if the
7907 * interface is open */
7908 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7909 skb_tailroom(rxb->skb))) {
7910 priv->ieee->stats.rx_errors++;
7911 priv->wstats.discard.misc++;
7912 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7914 } else if (unlikely(!netif_running(priv->net_dev))) {
7915 priv->ieee->stats.rx_dropped++;
7916 priv->wstats.discard.misc++;
7917 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7921 /* Advance skb->data to the start of the actual payload */
7922 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7924 /* Set the size of the skb to the size of the frame */
7925 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7927 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7929 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7930 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7931 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7932 (is_multicast_ether_addr(hdr->addr1) ?
7933 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7934 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7936 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7937 priv->ieee->stats.rx_errors++;
7938 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7940 __ipw_led_activity_on(priv);
7944 #ifdef CONFIG_IEEE80211_RADIOTAP
7945 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7946 struct ipw_rx_mem_buffer *rxb,
7947 struct ieee80211_rx_stats *stats)
7949 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7950 struct ipw_rx_frame *frame = &pkt->u.frame;
7952 /* initial pull of some data */
7953 u16 received_channel = frame->received_channel;
7954 u8 antennaAndPhy = frame->antennaAndPhy;
7955 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7956 u16 pktrate = frame->rate;
7958 /* Magic struct that slots into the radiotap header -- no reason
7959 * to build this manually element by element, we can write it much
7960 * more efficiently than we can parse it. ORDER MATTERS HERE */
7962 struct ieee80211_radiotap_header rt_hdr;
7963 u8 rt_flags; /* radiotap packet flags */
7964 u8 rt_rate; /* rate in 500kb/s */
7965 u16 rt_channel; /* channel in mhz */
7966 u16 rt_chbitmask; /* channel bitfield */
7967 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7968 u8 rt_antenna; /* antenna number */
7971 short len = le16_to_cpu(pkt->u.frame.length);
7973 /* We received data from the HW, so stop the watchdog */
7974 priv->net_dev->trans_start = jiffies;
7976 /* We only process data packets if the
7977 * interface is open */
7978 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7979 skb_tailroom(rxb->skb))) {
7980 priv->ieee->stats.rx_errors++;
7981 priv->wstats.discard.misc++;
7982 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7984 } else if (unlikely(!netif_running(priv->net_dev))) {
7985 priv->ieee->stats.rx_dropped++;
7986 priv->wstats.discard.misc++;
7987 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7991 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7993 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7994 /* FIXME: Should alloc bigger skb instead */
7995 priv->ieee->stats.rx_dropped++;
7996 priv->wstats.discard.misc++;
7997 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
8001 /* copy the frame itself */
8002 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
8003 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
8005 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
8006 * part of our real header, saves a little time.
8008 * No longer necessary since we fill in all our data. Purge before merging
8010 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
8011 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
8014 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
8016 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
8017 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
8018 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
8020 /* Big bitfield of all the fields we provide in radiotap */
8021 ipw_rt->rt_hdr.it_present =
8022 ((1 << IEEE80211_RADIOTAP_FLAGS) |
8023 (1 << IEEE80211_RADIOTAP_RATE) |
8024 (1 << IEEE80211_RADIOTAP_CHANNEL) |
8025 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
8026 (1 << IEEE80211_RADIOTAP_ANTENNA));
8028 /* Zero the flags, we'll add to them as we go */
8029 ipw_rt->rt_flags = 0;
8031 /* Convert signal to DBM */
8032 ipw_rt->rt_dbmsignal = antsignal;
8034 /* Convert the channel data and set the flags */
8035 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
8036 if (received_channel > 14) { /* 802.11a */
8037 ipw_rt->rt_chbitmask =
8038 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
8039 } else if (antennaAndPhy & 32) { /* 802.11b */
8040 ipw_rt->rt_chbitmask =
8041 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
8042 } else { /* 802.11g */
8043 ipw_rt->rt_chbitmask =
8044 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
8047 /* set the rate in multiples of 500k/s */
8049 case IPW_TX_RATE_1MB:
8050 ipw_rt->rt_rate = 2;
8052 case IPW_TX_RATE_2MB:
8053 ipw_rt->rt_rate = 4;
8055 case IPW_TX_RATE_5MB:
8056 ipw_rt->rt_rate = 10;
8058 case IPW_TX_RATE_6MB:
8059 ipw_rt->rt_rate = 12;
8061 case IPW_TX_RATE_9MB:
8062 ipw_rt->rt_rate = 18;
8064 case IPW_TX_RATE_11MB:
8065 ipw_rt->rt_rate = 22;
8067 case IPW_TX_RATE_12MB:
8068 ipw_rt->rt_rate = 24;
8070 case IPW_TX_RATE_18MB:
8071 ipw_rt->rt_rate = 36;
8073 case IPW_TX_RATE_24MB:
8074 ipw_rt->rt_rate = 48;
8076 case IPW_TX_RATE_36MB:
8077 ipw_rt->rt_rate = 72;
8079 case IPW_TX_RATE_48MB:
8080 ipw_rt->rt_rate = 96;
8082 case IPW_TX_RATE_54MB:
8083 ipw_rt->rt_rate = 108;
8086 ipw_rt->rt_rate = 0;
8090 /* antenna number */
8091 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
8093 /* set the preamble flag if we have it */
8094 if ((antennaAndPhy & 64))
8095 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8097 /* Set the size of the skb to the size of the frame */
8098 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
8100 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
8102 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
8103 priv->ieee->stats.rx_errors++;
8104 else { /* ieee80211_rx succeeded, so it now owns the SKB */
8106 /* no LED during capture */
8111 static inline int is_network_packet(struct ipw_priv *priv,
8112 struct ieee80211_hdr_4addr *header)
8114 /* Filter incoming packets to determine if they are targetted toward
8115 * this network, discarding packets coming from ourselves */
8116 switch (priv->ieee->iw_mode) {
8117 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
8118 /* packets from our adapter are dropped (echo) */
8119 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
8122 /* {broad,multi}cast packets to our BSSID go through */
8123 if (is_multicast_ether_addr(header->addr1) ||
8124 is_broadcast_ether_addr(header->addr1))
8125 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
8127 /* packets to our adapter go through */
8128 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8131 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
8132 /* packets from our adapter are dropped (echo) */
8133 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
8136 /* {broad,multi}cast packets to our BSS go through */
8137 if (is_multicast_ether_addr(header->addr1) ||
8138 is_broadcast_ether_addr(header->addr1))
8139 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
8141 /* packets to our adapter go through */
8142 return !memcmp(header->addr1, priv->net_dev->dev_addr,
8149 #define IPW_PACKET_RETRY_TIME HZ
8151 static inline int is_duplicate_packet(struct ipw_priv *priv,
8152 struct ieee80211_hdr_4addr *header)
8154 u16 sc = le16_to_cpu(header->seq_ctl);
8155 u16 seq = WLAN_GET_SEQ_SEQ(sc);
8156 u16 frag = WLAN_GET_SEQ_FRAG(sc);
8157 u16 *last_seq, *last_frag;
8158 unsigned long *last_time;
8160 switch (priv->ieee->iw_mode) {
8163 struct list_head *p;
8164 struct ipw_ibss_seq *entry = NULL;
8165 u8 *mac = header->addr2;
8166 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
8168 __list_for_each(p, &priv->ibss_mac_hash[index]) {
8170 list_entry(p, struct ipw_ibss_seq, list);
8171 if (!memcmp(entry->mac, mac, ETH_ALEN))
8174 if (p == &priv->ibss_mac_hash[index]) {
8175 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
8178 ("Cannot malloc new mac entry\n");
8181 memcpy(entry->mac, mac, ETH_ALEN);
8182 entry->seq_num = seq;
8183 entry->frag_num = frag;
8184 entry->packet_time = jiffies;
8185 list_add(&entry->list,
8186 &priv->ibss_mac_hash[index]);
8189 last_seq = &entry->seq_num;
8190 last_frag = &entry->frag_num;
8191 last_time = &entry->packet_time;
8195 last_seq = &priv->last_seq_num;
8196 last_frag = &priv->last_frag_num;
8197 last_time = &priv->last_packet_time;
8202 if ((*last_seq == seq) &&
8203 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
8204 if (*last_frag == frag)
8206 if (*last_frag + 1 != frag)
8207 /* out-of-order fragment */
8213 *last_time = jiffies;
8217 /* Comment this line now since we observed the card receives
8218 * duplicate packets but the FCTL_RETRY bit is not set in the
8219 * IBSS mode with fragmentation enabled.
8220 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
8224 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
8225 struct ipw_rx_mem_buffer *rxb,
8226 struct ieee80211_rx_stats *stats)
8228 struct sk_buff *skb = rxb->skb;
8229 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
8230 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
8231 (skb->data + IPW_RX_FRAME_SIZE);
8233 ieee80211_rx_mgt(priv->ieee, header, stats);
8235 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8236 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8237 IEEE80211_STYPE_PROBE_RESP) ||
8238 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8239 IEEE80211_STYPE_BEACON))) {
8240 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
8241 ipw_add_station(priv, header->addr2);
8244 if (priv->config & CFG_NET_STATS) {
8245 IPW_DEBUG_HC("sending stat packet\n");
8247 /* Set the size of the skb to the size of the full
8248 * ipw header and 802.11 frame */
8249 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8252 /* Advance past the ipw packet header to the 802.11 frame */
8253 skb_pull(skb, IPW_RX_FRAME_SIZE);
8255 /* Push the ieee80211_rx_stats before the 802.11 frame */
8256 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
8258 skb->dev = priv->ieee->dev;
8260 /* Point raw at the ieee80211_stats */
8261 skb->mac.raw = skb->data;
8263 skb->pkt_type = PACKET_OTHERHOST;
8264 skb->protocol = __constant_htons(ETH_P_80211_STATS);
8265 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8272 * Main entry function for recieving a packet with 80211 headers. This
8273 * should be called when ever the FW has notified us that there is a new
8274 * skb in the recieve queue.
8276 static void ipw_rx(struct ipw_priv *priv)
8278 struct ipw_rx_mem_buffer *rxb;
8279 struct ipw_rx_packet *pkt;
8280 struct ieee80211_hdr_4addr *header;
8284 r = ipw_read32(priv, IPW_RX_READ_INDEX);
8285 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
8286 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
8289 rxb = priv->rxq->queue[i];
8290 #ifdef CONFIG_IPW_DEBUG
8291 if (unlikely(rxb == NULL)) {
8292 printk(KERN_CRIT "Queue not allocated!\n");
8296 priv->rxq->queue[i] = NULL;
8298 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
8300 PCI_DMA_FROMDEVICE);
8302 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8303 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
8304 pkt->header.message_type,
8305 pkt->header.rx_seq_num, pkt->header.control_bits);
8307 switch (pkt->header.message_type) {
8308 case RX_FRAME_TYPE: /* 802.11 frame */ {
8309 struct ieee80211_rx_stats stats = {
8311 le16_to_cpu(pkt->u.frame.rssi_dbm) -
8314 le16_to_cpu(pkt->u.frame.signal),
8316 le16_to_cpu(pkt->u.frame.noise),
8317 .rate = pkt->u.frame.rate,
8318 .mac_time = jiffies,
8320 pkt->u.frame.received_channel,
8323 control & (1 << 0)) ?
8324 IEEE80211_24GHZ_BAND :
8325 IEEE80211_52GHZ_BAND,
8326 .len = le16_to_cpu(pkt->u.frame.length),
8329 if (stats.rssi != 0)
8330 stats.mask |= IEEE80211_STATMASK_RSSI;
8331 if (stats.signal != 0)
8332 stats.mask |= IEEE80211_STATMASK_SIGNAL;
8333 if (stats.noise != 0)
8334 stats.mask |= IEEE80211_STATMASK_NOISE;
8335 if (stats.rate != 0)
8336 stats.mask |= IEEE80211_STATMASK_RATE;
8340 #ifdef CONFIG_IPW2200_MONITOR
8341 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8342 #ifdef CONFIG_IEEE80211_RADIOTAP
8343 ipw_handle_data_packet_monitor(priv,
8347 ipw_handle_data_packet(priv, rxb,
8355 (struct ieee80211_hdr_4addr *)(rxb->skb->
8358 /* TODO: Check Ad-Hoc dest/source and make sure
8359 * that we are actually parsing these packets
8360 * correctly -- we should probably use the
8361 * frame control of the packet and disregard
8362 * the current iw_mode */
8365 is_network_packet(priv, header);
8366 if (network_packet && priv->assoc_network) {
8367 priv->assoc_network->stats.rssi =
8369 average_add(&priv->average_rssi,
8371 priv->last_rx_rssi = stats.rssi;
8374 IPW_DEBUG_RX("Frame: len=%u\n",
8375 le16_to_cpu(pkt->u.frame.length));
8377 if (le16_to_cpu(pkt->u.frame.length) <
8378 frame_hdr_len(header)) {
8380 ("Received packet is too small. "
8382 priv->ieee->stats.rx_errors++;
8383 priv->wstats.discard.misc++;
8387 switch (WLAN_FC_GET_TYPE
8388 (le16_to_cpu(header->frame_ctl))) {
8390 case IEEE80211_FTYPE_MGMT:
8391 ipw_handle_mgmt_packet(priv, rxb,
8395 case IEEE80211_FTYPE_CTL:
8398 case IEEE80211_FTYPE_DATA:
8399 if (unlikely(!network_packet ||
8400 is_duplicate_packet(priv,
8403 IPW_DEBUG_DROP("Dropping: "
8416 ipw_handle_data_packet(priv, rxb,
8424 case RX_HOST_NOTIFICATION_TYPE:{
8426 ("Notification: subtype=%02X flags=%02X size=%d\n",
8427 pkt->u.notification.subtype,
8428 pkt->u.notification.flags,
8429 pkt->u.notification.size);
8430 ipw_rx_notification(priv, &pkt->u.notification);
8435 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8436 pkt->header.message_type);
8440 /* For now we just don't re-use anything. We can tweak this
8441 * later to try and re-use notification packets and SKBs that
8442 * fail to Rx correctly */
8443 if (rxb->skb != NULL) {
8444 dev_kfree_skb_any(rxb->skb);
8448 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
8449 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
8450 list_add_tail(&rxb->list, &priv->rxq->rx_used);
8452 i = (i + 1) % RX_QUEUE_SIZE;
8455 /* Backtrack one entry */
8456 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
8458 ipw_rx_queue_restock(priv);
8461 #define DEFAULT_RTS_THRESHOLD 2304U
8462 #define MIN_RTS_THRESHOLD 1U
8463 #define MAX_RTS_THRESHOLD 2304U
8464 #define DEFAULT_BEACON_INTERVAL 100U
8465 #define DEFAULT_SHORT_RETRY_LIMIT 7U
8466 #define DEFAULT_LONG_RETRY_LIMIT 4U
8468 static int ipw_sw_reset(struct ipw_priv *priv, int init)
8470 int band, modulation;
8471 int old_mode = priv->ieee->iw_mode;
8473 /* Initialize module parameter values here */
8476 /* We default to disabling the LED code as right now it causes
8477 * too many systems to lock up... */
8479 priv->config |= CFG_NO_LED;
8482 priv->config |= CFG_ASSOCIATE;
8484 IPW_DEBUG_INFO("Auto associate disabled.\n");
8487 priv->config |= CFG_ADHOC_CREATE;
8489 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8492 priv->status |= STATUS_RF_KILL_SW;
8493 IPW_DEBUG_INFO("Radio disabled.\n");
8497 priv->config |= CFG_STATIC_CHANNEL;
8498 priv->channel = channel;
8499 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8500 /* TODO: Validate that provided channel is in range */
8502 #ifdef CONFIG_IPW_QOS
8503 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8504 burst_duration_CCK, burst_duration_OFDM);
8505 #endif /* CONFIG_IPW_QOS */
8509 priv->ieee->iw_mode = IW_MODE_ADHOC;
8510 priv->net_dev->type = ARPHRD_ETHER;
8513 #ifdef CONFIG_IPW2200_MONITOR
8515 priv->ieee->iw_mode = IW_MODE_MONITOR;
8516 #ifdef CONFIG_IEEE80211_RADIOTAP
8517 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8519 priv->net_dev->type = ARPHRD_IEEE80211;
8525 priv->net_dev->type = ARPHRD_ETHER;
8526 priv->ieee->iw_mode = IW_MODE_INFRA;
8531 priv->ieee->host_encrypt = 0;
8532 priv->ieee->host_encrypt_msdu = 0;
8533 priv->ieee->host_decrypt = 0;
8534 priv->ieee->host_mc_decrypt = 0;
8536 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8538 /* IPW2200/2915 is abled to do hardware fragmentation. */
8539 priv->ieee->host_open_frag = 0;
8541 if ((priv->pci_dev->device == 0x4223) ||
8542 (priv->pci_dev->device == 0x4224)) {
8544 printk(KERN_INFO DRV_NAME
8545 ": Detected Intel PRO/Wireless 2915ABG Network "
8547 priv->ieee->abg_true = 1;
8548 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8549 modulation = IEEE80211_OFDM_MODULATION |
8550 IEEE80211_CCK_MODULATION;
8551 priv->adapter = IPW_2915ABG;
8552 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8555 printk(KERN_INFO DRV_NAME
8556 ": Detected Intel PRO/Wireless 2200BG Network "
8559 priv->ieee->abg_true = 0;
8560 band = IEEE80211_24GHZ_BAND;
8561 modulation = IEEE80211_OFDM_MODULATION |
8562 IEEE80211_CCK_MODULATION;
8563 priv->adapter = IPW_2200BG;
8564 priv->ieee->mode = IEEE_G | IEEE_B;
8567 priv->ieee->freq_band = band;
8568 priv->ieee->modulation = modulation;
8570 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8572 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8573 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8575 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8576 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8577 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8579 /* If power management is turned on, default to AC mode */
8580 priv->power_mode = IPW_POWER_AC;
8581 priv->tx_power = IPW_TX_POWER_DEFAULT;
8583 return old_mode == priv->ieee->iw_mode;
8587 * This file defines the Wireless Extension handlers. It does not
8588 * define any methods of hardware manipulation and relies on the
8589 * functions defined in ipw_main to provide the HW interaction.
8591 * The exception to this is the use of the ipw_get_ordinal()
8592 * function used to poll the hardware vs. making unecessary calls.
8596 static int ipw_wx_get_name(struct net_device *dev,
8597 struct iw_request_info *info,
8598 union iwreq_data *wrqu, char *extra)
8600 struct ipw_priv *priv = ieee80211_priv(dev);
8602 if (priv->status & STATUS_RF_KILL_MASK)
8603 strcpy(wrqu->name, "radio off");
8604 else if (!(priv->status & STATUS_ASSOCIATED))
8605 strcpy(wrqu->name, "unassociated");
8607 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8608 ipw_modes[priv->assoc_request.ieee_mode]);
8609 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8614 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8617 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8618 priv->config &= ~CFG_STATIC_CHANNEL;
8619 IPW_DEBUG_ASSOC("Attempting to associate with new "
8621 ipw_associate(priv);
8625 priv->config |= CFG_STATIC_CHANNEL;
8627 if (priv->channel == channel) {
8628 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8633 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8634 priv->channel = channel;
8636 #ifdef CONFIG_IPW2200_MONITOR
8637 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8639 if (priv->status & STATUS_SCANNING) {
8640 IPW_DEBUG_SCAN("Scan abort triggered due to "
8641 "channel change.\n");
8642 ipw_abort_scan(priv);
8645 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8648 if (priv->status & STATUS_SCANNING)
8649 IPW_DEBUG_SCAN("Still scanning...\n");
8651 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8656 #endif /* CONFIG_IPW2200_MONITOR */
8658 /* Network configuration changed -- force [re]association */
8659 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8660 if (!ipw_disassociate(priv))
8661 ipw_associate(priv);
8666 static int ipw_wx_set_freq(struct net_device *dev,
8667 struct iw_request_info *info,
8668 union iwreq_data *wrqu, char *extra)
8670 struct ipw_priv *priv = ieee80211_priv(dev);
8671 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8672 struct iw_freq *fwrq = &wrqu->freq;
8678 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8680 ret = ipw_set_channel(priv, 0);
8684 /* if setting by freq convert to channel */
8686 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
8692 if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8695 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8696 i = ipw_channel_to_index(priv->ieee, channel);
8700 flags = (band == IEEE80211_24GHZ_BAND) ?
8701 geo->bg[i].flags : geo->a[i].flags;
8702 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8703 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8708 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8710 ret = ipw_set_channel(priv, channel);
8715 static int ipw_wx_get_freq(struct net_device *dev,
8716 struct iw_request_info *info,
8717 union iwreq_data *wrqu, char *extra)
8719 struct ipw_priv *priv = ieee80211_priv(dev);
8723 /* If we are associated, trying to associate, or have a statically
8724 * configured CHANNEL then return that; otherwise return ANY */
8726 if (priv->config & CFG_STATIC_CHANNEL ||
8727 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8728 wrqu->freq.m = priv->channel;
8733 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8737 static int ipw_wx_set_mode(struct net_device *dev,
8738 struct iw_request_info *info,
8739 union iwreq_data *wrqu, char *extra)
8741 struct ipw_priv *priv = ieee80211_priv(dev);
8744 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8746 switch (wrqu->mode) {
8747 #ifdef CONFIG_IPW2200_MONITOR
8748 case IW_MODE_MONITOR:
8754 wrqu->mode = IW_MODE_INFRA;
8759 if (wrqu->mode == priv->ieee->iw_mode)
8764 ipw_sw_reset(priv, 0);
8766 #ifdef CONFIG_IPW2200_MONITOR
8767 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8768 priv->net_dev->type = ARPHRD_ETHER;
8770 if (wrqu->mode == IW_MODE_MONITOR)
8771 #ifdef CONFIG_IEEE80211_RADIOTAP
8772 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8774 priv->net_dev->type = ARPHRD_IEEE80211;
8776 #endif /* CONFIG_IPW2200_MONITOR */
8778 /* Free the existing firmware and reset the fw_loaded
8779 * flag so ipw_load() will bring in the new firmawre */
8782 priv->ieee->iw_mode = wrqu->mode;
8784 queue_work(priv->workqueue, &priv->adapter_restart);
8789 static int ipw_wx_get_mode(struct net_device *dev,
8790 struct iw_request_info *info,
8791 union iwreq_data *wrqu, char *extra)
8793 struct ipw_priv *priv = ieee80211_priv(dev);
8795 wrqu->mode = priv->ieee->iw_mode;
8796 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8801 /* Values are in microsecond */
8802 static const s32 timeout_duration[] = {
8810 static const s32 period_duration[] = {
8818 static int ipw_wx_get_range(struct net_device *dev,
8819 struct iw_request_info *info,
8820 union iwreq_data *wrqu, char *extra)
8822 struct ipw_priv *priv = ieee80211_priv(dev);
8823 struct iw_range *range = (struct iw_range *)extra;
8824 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8827 wrqu->data.length = sizeof(*range);
8828 memset(range, 0, sizeof(*range));
8830 /* 54Mbs == ~27 Mb/s real (802.11g) */
8831 range->throughput = 27 * 1000 * 1000;
8833 range->max_qual.qual = 100;
8834 /* TODO: Find real max RSSI and stick here */
8835 range->max_qual.level = 0;
8836 range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
8837 range->max_qual.updated = 7; /* Updated all three */
8839 range->avg_qual.qual = 70;
8840 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8841 range->avg_qual.level = 0; /* FIXME to real average level */
8842 range->avg_qual.noise = 0;
8843 range->avg_qual.updated = 7; /* Updated all three */
8845 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8847 for (i = 0; i < range->num_bitrates; i++)
8848 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8851 range->max_rts = DEFAULT_RTS_THRESHOLD;
8852 range->min_frag = MIN_FRAG_THRESHOLD;
8853 range->max_frag = MAX_FRAG_THRESHOLD;
8855 range->encoding_size[0] = 5;
8856 range->encoding_size[1] = 13;
8857 range->num_encoding_sizes = 2;
8858 range->max_encoding_tokens = WEP_KEYS;
8860 /* Set the Wireless Extension versions */
8861 range->we_version_compiled = WIRELESS_EXT;
8862 range->we_version_source = 16;
8865 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8866 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8868 range->freq[i].i = geo->bg[j].channel;
8869 range->freq[i].m = geo->bg[j].freq * 100000;
8870 range->freq[i].e = 1;
8874 if (priv->ieee->mode & IEEE_A) {
8875 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8877 range->freq[i].i = geo->a[j].channel;
8878 range->freq[i].m = geo->a[j].freq * 100000;
8879 range->freq[i].e = 1;
8883 range->num_channels = i;
8884 range->num_frequency = i;
8887 IPW_DEBUG_WX("GET Range\n");
8891 static int ipw_wx_set_wap(struct net_device *dev,
8892 struct iw_request_info *info,
8893 union iwreq_data *wrqu, char *extra)
8895 struct ipw_priv *priv = ieee80211_priv(dev);
8897 static const unsigned char any[] = {
8898 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8900 static const unsigned char off[] = {
8901 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8904 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8907 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8908 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8909 /* we disable mandatory BSSID association */
8910 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8911 priv->config &= ~CFG_STATIC_BSSID;
8912 IPW_DEBUG_ASSOC("Attempting to associate with new "
8914 ipw_associate(priv);
8919 priv->config |= CFG_STATIC_BSSID;
8920 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8921 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8926 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8927 MAC_ARG(wrqu->ap_addr.sa_data));
8929 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8931 /* Network configuration changed -- force [re]association */
8932 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8933 if (!ipw_disassociate(priv))
8934 ipw_associate(priv);
8940 static int ipw_wx_get_wap(struct net_device *dev,
8941 struct iw_request_info *info,
8942 union iwreq_data *wrqu, char *extra)
8944 struct ipw_priv *priv = ieee80211_priv(dev);
8945 /* If we are associated, trying to associate, or have a statically
8946 * configured BSSID then return that; otherwise return ANY */
8948 if (priv->config & CFG_STATIC_BSSID ||
8949 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8950 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8951 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8953 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8955 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8956 MAC_ARG(wrqu->ap_addr.sa_data));
8961 static int ipw_wx_set_essid(struct net_device *dev,
8962 struct iw_request_info *info,
8963 union iwreq_data *wrqu, char *extra)
8965 struct ipw_priv *priv = ieee80211_priv(dev);
8966 char *essid = ""; /* ANY */
8969 if (wrqu->essid.flags && wrqu->essid.length) {
8970 length = wrqu->essid.length - 1;
8974 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8975 if ((priv->config & CFG_STATIC_ESSID) &&
8976 !(priv->status & (STATUS_ASSOCIATED |
8977 STATUS_ASSOCIATING))) {
8978 IPW_DEBUG_ASSOC("Attempting to associate with new "
8980 priv->config &= ~CFG_STATIC_ESSID;
8981 ipw_associate(priv);
8987 length = min(length, IW_ESSID_MAX_SIZE);
8989 priv->config |= CFG_STATIC_ESSID;
8991 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8992 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8997 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
9000 priv->essid_len = length;
9001 memcpy(priv->essid, essid, priv->essid_len);
9003 /* Network configuration changed -- force [re]association */
9004 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
9005 if (!ipw_disassociate(priv))
9006 ipw_associate(priv);
9012 static int ipw_wx_get_essid(struct net_device *dev,
9013 struct iw_request_info *info,
9014 union iwreq_data *wrqu, char *extra)
9016 struct ipw_priv *priv = ieee80211_priv(dev);
9018 /* If we are associated, trying to associate, or have a statically
9019 * configured ESSID then return that; otherwise return ANY */
9021 if (priv->config & CFG_STATIC_ESSID ||
9022 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
9023 IPW_DEBUG_WX("Getting essid: '%s'\n",
9024 escape_essid(priv->essid, priv->essid_len));
9025 memcpy(extra, priv->essid, priv->essid_len);
9026 wrqu->essid.length = priv->essid_len;
9027 wrqu->essid.flags = 1; /* active */
9029 IPW_DEBUG_WX("Getting essid: ANY\n");
9030 wrqu->essid.length = 0;
9031 wrqu->essid.flags = 0; /* active */
9037 static int ipw_wx_set_nick(struct net_device *dev,
9038 struct iw_request_info *info,
9039 union iwreq_data *wrqu, char *extra)
9041 struct ipw_priv *priv = ieee80211_priv(dev);
9043 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
9044 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9047 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
9048 memset(priv->nick, 0, sizeof(priv->nick));
9049 memcpy(priv->nick, extra, wrqu->data.length);
9050 IPW_DEBUG_TRACE("<<\n");
9056 static int ipw_wx_get_nick(struct net_device *dev,
9057 struct iw_request_info *info,
9058 union iwreq_data *wrqu, char *extra)
9060 struct ipw_priv *priv = ieee80211_priv(dev);
9061 IPW_DEBUG_WX("Getting nick\n");
9063 wrqu->data.length = strlen(priv->nick) + 1;
9064 memcpy(extra, priv->nick, wrqu->data.length);
9065 wrqu->data.flags = 1; /* active */
9070 static int ipw_wx_set_rate(struct net_device *dev,
9071 struct iw_request_info *info,
9072 union iwreq_data *wrqu, char *extra)
9074 /* TODO: We should use semaphores or locks for access to priv */
9075 struct ipw_priv *priv = ieee80211_priv(dev);
9076 u32 target_rate = wrqu->bitrate.value;
9079 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
9080 /* value = X, fixed = 1 means only rate X */
9081 /* value = X, fixed = 0 means all rates lower equal X */
9083 if (target_rate == -1) {
9085 mask = IEEE80211_DEFAULT_RATES_MASK;
9086 /* Now we should reassociate */
9091 fixed = wrqu->bitrate.fixed;
9093 if (target_rate == 1000000 || !fixed)
9094 mask |= IEEE80211_CCK_RATE_1MB_MASK;
9095 if (target_rate == 1000000)
9098 if (target_rate == 2000000 || !fixed)
9099 mask |= IEEE80211_CCK_RATE_2MB_MASK;
9100 if (target_rate == 2000000)
9103 if (target_rate == 5500000 || !fixed)
9104 mask |= IEEE80211_CCK_RATE_5MB_MASK;
9105 if (target_rate == 5500000)
9108 if (target_rate == 6000000 || !fixed)
9109 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
9110 if (target_rate == 6000000)
9113 if (target_rate == 9000000 || !fixed)
9114 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
9115 if (target_rate == 9000000)
9118 if (target_rate == 11000000 || !fixed)
9119 mask |= IEEE80211_CCK_RATE_11MB_MASK;
9120 if (target_rate == 11000000)
9123 if (target_rate == 12000000 || !fixed)
9124 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
9125 if (target_rate == 12000000)
9128 if (target_rate == 18000000 || !fixed)
9129 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
9130 if (target_rate == 18000000)
9133 if (target_rate == 24000000 || !fixed)
9134 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
9135 if (target_rate == 24000000)
9138 if (target_rate == 36000000 || !fixed)
9139 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
9140 if (target_rate == 36000000)
9143 if (target_rate == 48000000 || !fixed)
9144 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
9145 if (target_rate == 48000000)
9148 if (target_rate == 54000000 || !fixed)
9149 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
9150 if (target_rate == 54000000)
9153 IPW_DEBUG_WX("invalid rate specified, returning error\n");
9157 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
9158 mask, fixed ? "fixed" : "sub-rates");
9160 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
9161 priv->config &= ~CFG_FIXED_RATE;
9162 ipw_set_fixed_rate(priv, priv->ieee->mode);
9164 priv->config |= CFG_FIXED_RATE;
9166 if (priv->rates_mask == mask) {
9167 IPW_DEBUG_WX("Mask set to current mask.\n");
9172 priv->rates_mask = mask;
9174 /* Network configuration changed -- force [re]association */
9175 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
9176 if (!ipw_disassociate(priv))
9177 ipw_associate(priv);
9183 static int ipw_wx_get_rate(struct net_device *dev,
9184 struct iw_request_info *info,
9185 union iwreq_data *wrqu, char *extra)
9187 struct ipw_priv *priv = ieee80211_priv(dev);
9189 wrqu->bitrate.value = priv->last_rate;
9191 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
9195 static int ipw_wx_set_rts(struct net_device *dev,
9196 struct iw_request_info *info,
9197 union iwreq_data *wrqu, char *extra)
9199 struct ipw_priv *priv = ieee80211_priv(dev);
9201 if (wrqu->rts.disabled)
9202 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9204 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
9205 wrqu->rts.value > MAX_RTS_THRESHOLD) {
9209 priv->rts_threshold = wrqu->rts.value;
9212 ipw_send_rts_threshold(priv, priv->rts_threshold);
9214 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
9218 static int ipw_wx_get_rts(struct net_device *dev,
9219 struct iw_request_info *info,
9220 union iwreq_data *wrqu, char *extra)
9222 struct ipw_priv *priv = ieee80211_priv(dev);
9224 wrqu->rts.value = priv->rts_threshold;
9225 wrqu->rts.fixed = 0; /* no auto select */
9226 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
9228 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
9232 static int ipw_wx_set_txpow(struct net_device *dev,
9233 struct iw_request_info *info,
9234 union iwreq_data *wrqu, char *extra)
9236 struct ipw_priv *priv = ieee80211_priv(dev);
9240 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
9245 if (!wrqu->power.fixed)
9246 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9248 if (wrqu->power.flags != IW_TXPOW_DBM) {
9253 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
9254 (wrqu->power.value < IPW_TX_POWER_MIN)) {
9259 priv->tx_power = wrqu->power.value;
9260 err = ipw_set_tx_power(priv);
9266 static int ipw_wx_get_txpow(struct net_device *dev,
9267 struct iw_request_info *info,
9268 union iwreq_data *wrqu, char *extra)
9270 struct ipw_priv *priv = ieee80211_priv(dev);
9272 wrqu->power.value = priv->tx_power;
9273 wrqu->power.fixed = 1;
9274 wrqu->power.flags = IW_TXPOW_DBM;
9275 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
9278 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
9279 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9284 static int ipw_wx_set_frag(struct net_device *dev,
9285 struct iw_request_info *info,
9286 union iwreq_data *wrqu, char *extra)
9288 struct ipw_priv *priv = ieee80211_priv(dev);
9290 if (wrqu->frag.disabled)
9291 priv->ieee->fts = DEFAULT_FTS;
9293 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
9294 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
9299 priv->ieee->fts = wrqu->frag.value & ~0x1;
9302 ipw_send_frag_threshold(priv, wrqu->frag.value);
9304 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
9308 static int ipw_wx_get_frag(struct net_device *dev,
9309 struct iw_request_info *info,
9310 union iwreq_data *wrqu, char *extra)
9312 struct ipw_priv *priv = ieee80211_priv(dev);
9314 wrqu->frag.value = priv->ieee->fts;
9315 wrqu->frag.fixed = 0; /* no auto select */
9316 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
9318 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
9323 static int ipw_wx_set_retry(struct net_device *dev,
9324 struct iw_request_info *info,
9325 union iwreq_data *wrqu, char *extra)
9327 struct ipw_priv *priv = ieee80211_priv(dev);
9329 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9332 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9335 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
9339 if (wrqu->retry.flags & IW_RETRY_MIN)
9340 priv->short_retry_limit = (u8) wrqu->retry.value;
9341 else if (wrqu->retry.flags & IW_RETRY_MAX)
9342 priv->long_retry_limit = (u8) wrqu->retry.value;
9344 priv->short_retry_limit = (u8) wrqu->retry.value;
9345 priv->long_retry_limit = (u8) wrqu->retry.value;
9348 ipw_send_retry_limit(priv, priv->short_retry_limit,
9349 priv->long_retry_limit);
9351 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9352 priv->short_retry_limit, priv->long_retry_limit);
9356 static int ipw_wx_get_retry(struct net_device *dev,
9357 struct iw_request_info *info,
9358 union iwreq_data *wrqu, char *extra)
9360 struct ipw_priv *priv = ieee80211_priv(dev);
9363 wrqu->retry.disabled = 0;
9365 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
9370 if (wrqu->retry.flags & IW_RETRY_MAX) {
9371 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
9372 wrqu->retry.value = priv->long_retry_limit;
9373 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
9374 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
9375 wrqu->retry.value = priv->short_retry_limit;
9377 wrqu->retry.flags = IW_RETRY_LIMIT;
9378 wrqu->retry.value = priv->short_retry_limit;
9382 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
9387 #if WIRELESS_EXT > 17
9388 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
9391 struct ipw_scan_request_ext scan;
9392 int err = 0, scan_type;
9396 if (priv->status & STATUS_RF_KILL_MASK) {
9397 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
9398 priv->status |= STATUS_SCAN_PENDING;
9402 IPW_DEBUG_HC("starting request direct scan!\n");
9404 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
9405 err = wait_event_interruptible(priv->wait_state,
9407 status & (STATUS_SCANNING |
9408 STATUS_SCAN_ABORTING)));
9410 IPW_DEBUG_HC("aborting direct scan");
9414 memset(&scan, 0, sizeof(scan));
9416 if (priv->config & CFG_SPEED_SCAN)
9417 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
9420 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
9423 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
9425 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
9426 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
9428 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
9430 err = ipw_send_ssid(priv, essid, essid_len);
9432 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
9435 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
9437 ipw_add_scan_channels(priv, &scan, scan_type);
9439 err = ipw_send_scan_request_ext(priv, &scan);
9441 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
9445 priv->status |= STATUS_SCANNING;
9451 #endif /* WIRELESS_EXT > 17 */
9453 static int ipw_wx_set_scan(struct net_device *dev,
9454 struct iw_request_info *info,
9455 union iwreq_data *wrqu, char *extra)
9457 struct ipw_priv *priv = ieee80211_priv(dev);
9458 #if WIRELESS_EXT > 17
9459 struct iw_scan_req *req = NULL;
9460 if (wrqu->data.length
9461 && wrqu->data.length == sizeof(struct iw_scan_req)) {
9462 req = (struct iw_scan_req *)extra;
9463 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9464 ipw_request_direct_scan(priv, req->essid,
9470 IPW_DEBUG_WX("Start scan\n");
9472 queue_work(priv->workqueue, &priv->request_scan);
9477 static int ipw_wx_get_scan(struct net_device *dev,
9478 struct iw_request_info *info,
9479 union iwreq_data *wrqu, char *extra)
9481 struct ipw_priv *priv = ieee80211_priv(dev);
9482 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9485 static int ipw_wx_set_encode(struct net_device *dev,
9486 struct iw_request_info *info,
9487 union iwreq_data *wrqu, char *key)
9489 struct ipw_priv *priv = ieee80211_priv(dev);
9491 u32 cap = priv->capability;
9494 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9496 /* In IBSS mode, we need to notify the firmware to update
9497 * the beacon info after we changed the capability. */
9498 if (cap != priv->capability &&
9499 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9500 priv->status & STATUS_ASSOCIATED)
9501 ipw_disassociate(priv);
9507 static int ipw_wx_get_encode(struct net_device *dev,
9508 struct iw_request_info *info,
9509 union iwreq_data *wrqu, char *key)
9511 struct ipw_priv *priv = ieee80211_priv(dev);
9512 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9515 static int ipw_wx_set_power(struct net_device *dev,
9516 struct iw_request_info *info,
9517 union iwreq_data *wrqu, char *extra)
9519 struct ipw_priv *priv = ieee80211_priv(dev);
9522 if (wrqu->power.disabled) {
9523 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9524 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9526 IPW_DEBUG_WX("failed setting power mode.\n");
9530 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9535 switch (wrqu->power.flags & IW_POWER_MODE) {
9536 case IW_POWER_ON: /* If not specified */
9537 case IW_POWER_MODE: /* If set all mask */
9538 case IW_POWER_ALL_R: /* If explicitely state all */
9540 default: /* Otherwise we don't support it */
9541 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9547 /* If the user hasn't specified a power management mode yet, default
9549 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9550 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9552 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9553 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9555 IPW_DEBUG_WX("failed setting power mode.\n");
9560 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9565 static int ipw_wx_get_power(struct net_device *dev,
9566 struct iw_request_info *info,
9567 union iwreq_data *wrqu, char *extra)
9569 struct ipw_priv *priv = ieee80211_priv(dev);
9571 if (!(priv->power_mode & IPW_POWER_ENABLED))
9572 wrqu->power.disabled = 1;
9574 wrqu->power.disabled = 0;
9577 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9582 static int ipw_wx_set_powermode(struct net_device *dev,
9583 struct iw_request_info *info,
9584 union iwreq_data *wrqu, char *extra)
9586 struct ipw_priv *priv = ieee80211_priv(dev);
9587 int mode = *(int *)extra;
9590 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9591 mode = IPW_POWER_AC;
9592 priv->power_mode = mode;
9594 priv->power_mode = IPW_POWER_ENABLED | mode;
9597 if (priv->power_mode != mode) {
9598 err = ipw_send_power_mode(priv, mode);
9601 IPW_DEBUG_WX("failed setting power mode.\n");
9610 #define MAX_WX_STRING 80
9611 static int ipw_wx_get_powermode(struct net_device *dev,
9612 struct iw_request_info *info,
9613 union iwreq_data *wrqu, char *extra)
9615 struct ipw_priv *priv = ieee80211_priv(dev);
9616 int level = IPW_POWER_LEVEL(priv->power_mode);
9619 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9623 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9625 case IPW_POWER_BATTERY:
9626 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9629 p += snprintf(p, MAX_WX_STRING - (p - extra),
9630 "(Timeout %dms, Period %dms)",
9631 timeout_duration[level - 1] / 1000,
9632 period_duration[level - 1] / 1000);
9635 if (!(priv->power_mode & IPW_POWER_ENABLED))
9636 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9638 wrqu->data.length = p - extra + 1;
9643 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9644 struct iw_request_info *info,
9645 union iwreq_data *wrqu, char *extra)
9647 struct ipw_priv *priv = ieee80211_priv(dev);
9648 int mode = *(int *)extra;
9649 u8 band = 0, modulation = 0;
9651 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9652 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9656 if (priv->adapter == IPW_2915ABG) {
9657 priv->ieee->abg_true = 1;
9658 if (mode & IEEE_A) {
9659 band |= IEEE80211_52GHZ_BAND;
9660 modulation |= IEEE80211_OFDM_MODULATION;
9662 priv->ieee->abg_true = 0;
9664 if (mode & IEEE_A) {
9665 IPW_WARNING("Attempt to set 2200BG into "
9671 priv->ieee->abg_true = 0;
9674 if (mode & IEEE_B) {
9675 band |= IEEE80211_24GHZ_BAND;
9676 modulation |= IEEE80211_CCK_MODULATION;
9678 priv->ieee->abg_true = 0;
9680 if (mode & IEEE_G) {
9681 band |= IEEE80211_24GHZ_BAND;
9682 modulation |= IEEE80211_OFDM_MODULATION;
9684 priv->ieee->abg_true = 0;
9686 priv->ieee->mode = mode;
9687 priv->ieee->freq_band = band;
9688 priv->ieee->modulation = modulation;
9689 init_supported_rates(priv, &priv->rates);
9691 /* Network configuration changed -- force [re]association */
9692 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9693 if (!ipw_disassociate(priv)) {
9694 ipw_send_supported_rates(priv, &priv->rates);
9695 ipw_associate(priv);
9698 /* Update the band LEDs */
9699 ipw_led_band_on(priv);
9701 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9702 mode & IEEE_A ? 'a' : '.',
9703 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9708 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9709 struct iw_request_info *info,
9710 union iwreq_data *wrqu, char *extra)
9712 struct ipw_priv *priv = ieee80211_priv(dev);
9714 switch (priv->ieee->mode) {
9716 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9719 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9721 case IEEE_A | IEEE_B:
9722 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9725 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9727 case IEEE_A | IEEE_G:
9728 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9730 case IEEE_B | IEEE_G:
9731 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9733 case IEEE_A | IEEE_B | IEEE_G:
9734 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9737 strncpy(extra, "unknown", MAX_WX_STRING);
9741 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9743 wrqu->data.length = strlen(extra) + 1;
9749 static int ipw_wx_set_preamble(struct net_device *dev,
9750 struct iw_request_info *info,
9751 union iwreq_data *wrqu, char *extra)
9753 struct ipw_priv *priv = ieee80211_priv(dev);
9754 int mode = *(int *)extra;
9756 /* Switching from SHORT -> LONG requires a disassociation */
9758 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9759 priv->config |= CFG_PREAMBLE_LONG;
9761 /* Network configuration changed -- force [re]association */
9763 ("[re]association triggered due to preamble change.\n");
9764 if (!ipw_disassociate(priv))
9765 ipw_associate(priv);
9771 priv->config &= ~CFG_PREAMBLE_LONG;
9782 static int ipw_wx_get_preamble(struct net_device *dev,
9783 struct iw_request_info *info,
9784 union iwreq_data *wrqu, char *extra)
9786 struct ipw_priv *priv = ieee80211_priv(dev);
9788 if (priv->config & CFG_PREAMBLE_LONG)
9789 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9791 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9796 #ifdef CONFIG_IPW2200_MONITOR
9797 static int ipw_wx_set_monitor(struct net_device *dev,
9798 struct iw_request_info *info,
9799 union iwreq_data *wrqu, char *extra)
9801 struct ipw_priv *priv = ieee80211_priv(dev);
9802 int *parms = (int *)extra;
9803 int enable = (parms[0] > 0);
9805 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9807 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9808 #ifdef CONFIG_IEEE80211_RADIOTAP
9809 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9811 priv->net_dev->type = ARPHRD_IEEE80211;
9813 queue_work(priv->workqueue, &priv->adapter_restart);
9816 ipw_set_channel(priv, parms[1]);
9818 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9822 priv->net_dev->type = ARPHRD_ETHER;
9823 queue_work(priv->workqueue, &priv->adapter_restart);
9829 #endif // CONFIG_IPW2200_MONITOR
9831 static int ipw_wx_reset(struct net_device *dev,
9832 struct iw_request_info *info,
9833 union iwreq_data *wrqu, char *extra)
9835 struct ipw_priv *priv = ieee80211_priv(dev);
9836 IPW_DEBUG_WX("RESET\n");
9837 queue_work(priv->workqueue, &priv->adapter_restart);
9841 static int ipw_wx_sw_reset(struct net_device *dev,
9842 struct iw_request_info *info,
9843 union iwreq_data *wrqu, char *extra)
9845 struct ipw_priv *priv = ieee80211_priv(dev);
9846 union iwreq_data wrqu_sec = {
9848 .flags = IW_ENCODE_DISABLED,
9853 IPW_DEBUG_WX("SW_RESET\n");
9857 ret = ipw_sw_reset(priv, 0);
9860 ipw_adapter_restart(priv);
9863 /* The SW reset bit might have been toggled on by the 'disable'
9864 * module parameter, so take appropriate action */
9865 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9868 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9871 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9872 /* Configuration likely changed -- force [re]association */
9873 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9875 if (!ipw_disassociate(priv))
9876 ipw_associate(priv);
9884 /* Rebase the WE IOCTLs to zero for the handler array */
9885 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9886 static iw_handler ipw_wx_handlers[] = {
9887 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9888 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9889 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9890 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9891 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9892 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9893 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9894 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9895 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9896 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9897 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9898 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9899 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9900 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9901 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9902 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9903 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9904 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9905 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9906 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9907 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9908 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9909 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9910 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9911 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9912 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9913 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9914 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9915 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9916 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9917 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9918 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9919 #if WIRELESS_EXT > 17
9920 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9921 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9922 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9923 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9924 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9925 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9926 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9931 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9935 IPW_PRIV_SET_PREAMBLE,
9936 IPW_PRIV_GET_PREAMBLE,
9939 #ifdef CONFIG_IPW2200_MONITOR
9940 IPW_PRIV_SET_MONITOR,
9944 static struct iw_priv_args ipw_priv_args[] = {
9946 .cmd = IPW_PRIV_SET_POWER,
9947 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9948 .name = "set_power"},
9950 .cmd = IPW_PRIV_GET_POWER,
9951 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9952 .name = "get_power"},
9954 .cmd = IPW_PRIV_SET_MODE,
9955 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9956 .name = "set_mode"},
9958 .cmd = IPW_PRIV_GET_MODE,
9959 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9960 .name = "get_mode"},
9962 .cmd = IPW_PRIV_SET_PREAMBLE,
9963 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9964 .name = "set_preamble"},
9966 .cmd = IPW_PRIV_GET_PREAMBLE,
9967 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9968 .name = "get_preamble"},
9971 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9974 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9975 #ifdef CONFIG_IPW2200_MONITOR
9977 IPW_PRIV_SET_MONITOR,
9978 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9979 #endif /* CONFIG_IPW2200_MONITOR */
9982 static iw_handler ipw_priv_handler[] = {
9983 ipw_wx_set_powermode,
9984 ipw_wx_get_powermode,
9985 ipw_wx_set_wireless_mode,
9986 ipw_wx_get_wireless_mode,
9987 ipw_wx_set_preamble,
9988 ipw_wx_get_preamble,
9991 #ifdef CONFIG_IPW2200_MONITOR
9996 static struct iw_handler_def ipw_wx_handler_def = {
9997 .standard = ipw_wx_handlers,
9998 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9999 .num_private = ARRAY_SIZE(ipw_priv_handler),
10000 .num_private_args = ARRAY_SIZE(ipw_priv_args),
10001 .private = ipw_priv_handler,
10002 .private_args = ipw_priv_args,
10005 static struct iw_public_data ipw_wx_data;
10008 * Get wireless statistics.
10009 * Called by /proc/net/wireless
10010 * Also called by SIOCGIWSTATS
10012 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
10014 struct ipw_priv *priv = ieee80211_priv(dev);
10015 struct iw_statistics *wstats;
10017 wstats = &priv->wstats;
10019 /* if hw is disabled, then ipw_get_ordinal() can't be called.
10020 * netdev->get_wireless_stats seems to be called before fw is
10021 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
10022 * and associated; if not associcated, the values are all meaningless
10023 * anyway, so set them all to NULL and INVALID */
10024 if (!(priv->status & STATUS_ASSOCIATED)) {
10025 wstats->miss.beacon = 0;
10026 wstats->discard.retries = 0;
10027 wstats->qual.qual = 0;
10028 wstats->qual.level = 0;
10029 wstats->qual.noise = 0;
10030 wstats->qual.updated = 7;
10031 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
10032 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
10036 wstats->qual.qual = priv->quality;
10037 wstats->qual.level = average_value(&priv->average_rssi);
10038 wstats->qual.noise = average_value(&priv->average_noise);
10039 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
10040 IW_QUAL_NOISE_UPDATED;
10042 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
10043 wstats->discard.retries = priv->last_tx_failures;
10044 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
10046 /* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
10047 goto fail_get_ordinal;
10048 wstats->discard.retries += tx_retry; */
10053 /* net device stuff */
10055 static inline void init_sys_config(struct ipw_sys_config *sys_config)
10057 memset(sys_config, 0, sizeof(struct ipw_sys_config));
10058 sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
10059 sys_config->answer_broadcast_ssid_probe = 0;
10060 sys_config->accept_all_data_frames = 0;
10061 sys_config->accept_non_directed_frames = 1;
10062 sys_config->exclude_unicast_unencrypted = 0;
10063 sys_config->disable_unicast_decryption = 1;
10064 sys_config->exclude_multicast_unencrypted = 0;
10065 sys_config->disable_multicast_decryption = 1;
10066 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
10067 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
10068 sys_config->dot11g_auto_detection = 0;
10069 sys_config->enable_cts_to_self = 0;
10070 sys_config->bt_coexist_collision_thr = 0;
10071 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
10074 static int ipw_net_open(struct net_device *dev)
10076 struct ipw_priv *priv = ieee80211_priv(dev);
10077 IPW_DEBUG_INFO("dev->open\n");
10078 /* we should be verifying the device is ready to be opened */
10080 if (!(priv->status & STATUS_RF_KILL_MASK) &&
10081 (priv->status & STATUS_ASSOCIATED))
10082 netif_start_queue(dev);
10087 static int ipw_net_stop(struct net_device *dev)
10089 IPW_DEBUG_INFO("dev->close\n");
10090 netif_stop_queue(dev);
10097 modify to send one tfd per fragment instead of using chunking. otherwise
10098 we need to heavily modify the ieee80211_skb_to_txb.
10101 static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
10104 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
10105 txb->fragments[0]->data;
10107 struct tfd_frame *tfd;
10108 #ifdef CONFIG_IPW_QOS
10109 int tx_id = ipw_get_tx_queue_number(priv, pri);
10110 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10112 struct clx2_tx_queue *txq = &priv->txq[0];
10114 struct clx2_queue *q = &txq->q;
10115 u8 id, hdr_len, unicast;
10116 u16 remaining_bytes;
10119 /* If there isn't room in the queue, we return busy and let the
10120 * network stack requeue the packet for us */
10121 if (ipw_queue_space(q) < q->high_mark)
10122 return NETDEV_TX_BUSY;
10124 switch (priv->ieee->iw_mode) {
10125 case IW_MODE_ADHOC:
10126 hdr_len = IEEE80211_3ADDR_LEN;
10127 unicast = !is_multicast_ether_addr(hdr->addr1);
10128 id = ipw_find_station(priv, hdr->addr1);
10129 if (id == IPW_INVALID_STATION) {
10130 id = ipw_add_station(priv, hdr->addr1);
10131 if (id == IPW_INVALID_STATION) {
10132 IPW_WARNING("Attempt to send data to "
10133 "invalid cell: " MAC_FMT "\n",
10134 MAC_ARG(hdr->addr1));
10140 case IW_MODE_INFRA:
10142 unicast = !is_multicast_ether_addr(hdr->addr3);
10143 hdr_len = IEEE80211_3ADDR_LEN;
10148 tfd = &txq->bd[q->first_empty];
10149 txq->txb[q->first_empty] = txb;
10150 memset(tfd, 0, sizeof(*tfd));
10151 tfd->u.data.station_number = id;
10153 tfd->control_flags.message_type = TX_FRAME_TYPE;
10154 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10156 tfd->u.data.cmd_id = DINO_CMD_TX;
10157 tfd->u.data.len = cpu_to_le16(txb->payload_size);
10158 remaining_bytes = txb->payload_size;
10160 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
10161 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
10163 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
10165 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10166 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
10168 fc = le16_to_cpu(hdr->frame_ctl);
10169 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
10171 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10173 if (likely(unicast))
10174 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10176 if (txb->encrypted && !priv->ieee->host_encrypt) {
10177 switch (priv->ieee->sec.level) {
10179 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10180 IEEE80211_FCTL_PROTECTED;
10181 /* XXX: ACK flag must be set for CCMP even if it
10182 * is a multicast/broadcast packet, because CCMP
10183 * group communication encrypted by GTK is
10184 * actually done by the AP. */
10186 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10188 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10189 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10190 tfd->u.data.key_index = 0;
10191 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10194 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10195 IEEE80211_FCTL_PROTECTED;
10196 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10197 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10198 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10201 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10202 IEEE80211_FCTL_PROTECTED;
10203 tfd->u.data.key_index = priv->ieee->tx_keyidx;
10204 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
10206 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10208 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10213 printk(KERN_ERR "Unknow security level %d\n",
10214 priv->ieee->sec.level);
10218 /* No hardware encryption */
10219 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10221 #ifdef CONFIG_IPW_QOS
10222 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
10223 #endif /* CONFIG_IPW_QOS */
10226 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10228 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
10229 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10230 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10231 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
10232 i, le32_to_cpu(tfd->u.data.num_chunks),
10233 txb->fragments[i]->len - hdr_len);
10234 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
10235 i, tfd->u.data.num_chunks,
10236 txb->fragments[i]->len - hdr_len);
10237 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
10238 txb->fragments[i]->len - hdr_len);
10240 tfd->u.data.chunk_ptr[i] =
10241 cpu_to_le32(pci_map_single
10243 txb->fragments[i]->data + hdr_len,
10244 txb->fragments[i]->len - hdr_len,
10245 PCI_DMA_TODEVICE));
10246 tfd->u.data.chunk_len[i] =
10247 cpu_to_le16(txb->fragments[i]->len - hdr_len);
10250 if (i != txb->nr_frags) {
10251 struct sk_buff *skb;
10252 u16 remaining_bytes = 0;
10255 for (j = i; j < txb->nr_frags; j++)
10256 remaining_bytes += txb->fragments[j]->len - hdr_len;
10258 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
10260 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
10262 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
10263 for (j = i; j < txb->nr_frags; j++) {
10264 int size = txb->fragments[j]->len - hdr_len;
10266 printk(KERN_INFO "Adding frag %d %d...\n",
10268 memcpy(skb_put(skb, size),
10269 txb->fragments[j]->data + hdr_len, size);
10271 dev_kfree_skb_any(txb->fragments[i]);
10272 txb->fragments[i] = skb;
10273 tfd->u.data.chunk_ptr[i] =
10274 cpu_to_le32(pci_map_single
10275 (priv->pci_dev, skb->data,
10276 tfd->u.data.chunk_len[i],
10277 PCI_DMA_TODEVICE));
10279 tfd->u.data.num_chunks =
10280 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
10286 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10287 ipw_write32(priv, q->reg_w, q->first_empty);
10289 return NETDEV_TX_OK;
10292 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
10293 ieee80211_txb_free(txb);
10294 return NETDEV_TX_OK;
10297 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
10299 struct ipw_priv *priv = ieee80211_priv(dev);
10300 #ifdef CONFIG_IPW_QOS
10301 int tx_id = ipw_get_tx_queue_number(priv, pri);
10302 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10304 struct clx2_tx_queue *txq = &priv->txq[0];
10305 #endif /* CONFIG_IPW_QOS */
10307 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
10313 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
10314 struct net_device *dev, int pri)
10316 struct ipw_priv *priv = ieee80211_priv(dev);
10317 unsigned long flags;
10320 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
10321 spin_lock_irqsave(&priv->lock, flags);
10323 if (!(priv->status & STATUS_ASSOCIATED)) {
10324 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
10325 priv->ieee->stats.tx_carrier_errors++;
10326 netif_stop_queue(dev);
10330 ret = ipw_tx_skb(priv, txb, pri);
10331 if (ret == NETDEV_TX_OK)
10332 __ipw_led_activity_on(priv);
10333 spin_unlock_irqrestore(&priv->lock, flags);
10338 spin_unlock_irqrestore(&priv->lock, flags);
10342 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
10344 struct ipw_priv *priv = ieee80211_priv(dev);
10346 priv->ieee->stats.tx_packets = priv->tx_packets;
10347 priv->ieee->stats.rx_packets = priv->rx_packets;
10348 return &priv->ieee->stats;
10351 static void ipw_net_set_multicast_list(struct net_device *dev)
10356 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
10358 struct ipw_priv *priv = ieee80211_priv(dev);
10359 struct sockaddr *addr = p;
10360 if (!is_valid_ether_addr(addr->sa_data))
10361 return -EADDRNOTAVAIL;
10363 priv->config |= CFG_CUSTOM_MAC;
10364 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
10365 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
10366 priv->net_dev->name, MAC_ARG(priv->mac_addr));
10367 queue_work(priv->workqueue, &priv->adapter_restart);
10372 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
10373 struct ethtool_drvinfo *info)
10375 struct ipw_priv *p = ieee80211_priv(dev);
10380 strcpy(info->driver, DRV_NAME);
10381 strcpy(info->version, DRV_VERSION);
10383 len = sizeof(vers);
10384 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
10385 len = sizeof(date);
10386 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
10388 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
10390 strcpy(info->bus_info, pci_name(p->pci_dev));
10391 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
10394 static u32 ipw_ethtool_get_link(struct net_device *dev)
10396 struct ipw_priv *priv = ieee80211_priv(dev);
10397 return (priv->status & STATUS_ASSOCIATED) != 0;
10400 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10402 return IPW_EEPROM_IMAGE_SIZE;
10405 static int ipw_ethtool_get_eeprom(struct net_device *dev,
10406 struct ethtool_eeprom *eeprom, u8 * bytes)
10408 struct ipw_priv *p = ieee80211_priv(dev);
10410 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10413 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
10418 static int ipw_ethtool_set_eeprom(struct net_device *dev,
10419 struct ethtool_eeprom *eeprom, u8 * bytes)
10421 struct ipw_priv *p = ieee80211_priv(dev);
10424 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10427 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
10428 for (i = IPW_EEPROM_DATA;
10429 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
10430 ipw_write8(p, i, p->eeprom[i]);
10435 static struct ethtool_ops ipw_ethtool_ops = {
10436 .get_link = ipw_ethtool_get_link,
10437 .get_drvinfo = ipw_ethtool_get_drvinfo,
10438 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10439 .get_eeprom = ipw_ethtool_get_eeprom,
10440 .set_eeprom = ipw_ethtool_set_eeprom,
10443 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
10445 struct ipw_priv *priv = data;
10446 u32 inta, inta_mask;
10451 spin_lock(&priv->lock);
10453 if (!(priv->status & STATUS_INT_ENABLED)) {
10458 inta = ipw_read32(priv, IPW_INTA_RW);
10459 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
10461 if (inta == 0xFFFFFFFF) {
10462 /* Hardware disappeared */
10463 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10467 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10468 /* Shared interrupt */
10472 /* tell the device to stop sending interrupts */
10473 ipw_disable_interrupts(priv);
10475 /* ack current interrupts */
10476 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10477 ipw_write32(priv, IPW_INTA_RW, inta);
10479 /* Cache INTA value for our tasklet */
10480 priv->isr_inta = inta;
10482 tasklet_schedule(&priv->irq_tasklet);
10484 spin_unlock(&priv->lock);
10486 return IRQ_HANDLED;
10488 spin_unlock(&priv->lock);
10492 static void ipw_rf_kill(void *adapter)
10494 struct ipw_priv *priv = adapter;
10495 unsigned long flags;
10497 spin_lock_irqsave(&priv->lock, flags);
10499 if (rf_kill_active(priv)) {
10500 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10501 if (priv->workqueue)
10502 queue_delayed_work(priv->workqueue,
10503 &priv->rf_kill, 2 * HZ);
10507 /* RF Kill is now disabled, so bring the device back up */
10509 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10510 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10513 /* we can not do an adapter restart while inside an irq lock */
10514 queue_work(priv->workqueue, &priv->adapter_restart);
10516 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10520 spin_unlock_irqrestore(&priv->lock, flags);
10523 static void ipw_bg_rf_kill(void *data)
10525 struct ipw_priv *priv = data;
10531 void ipw_link_up(struct ipw_priv *priv)
10533 priv->last_seq_num = -1;
10534 priv->last_frag_num = -1;
10535 priv->last_packet_time = 0;
10537 netif_carrier_on(priv->net_dev);
10538 if (netif_queue_stopped(priv->net_dev)) {
10539 IPW_DEBUG_NOTIF("waking queue\n");
10540 netif_wake_queue(priv->net_dev);
10542 IPW_DEBUG_NOTIF("starting queue\n");
10543 netif_start_queue(priv->net_dev);
10546 cancel_delayed_work(&priv->request_scan);
10547 ipw_reset_stats(priv);
10548 /* Ensure the rate is updated immediately */
10549 priv->last_rate = ipw_get_current_rate(priv);
10550 ipw_gather_stats(priv);
10551 ipw_led_link_up(priv);
10552 notify_wx_assoc_event(priv);
10554 if (priv->config & CFG_BACKGROUND_SCAN)
10555 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10558 static void ipw_bg_link_up(void *data)
10560 struct ipw_priv *priv = data;
10566 void ipw_link_down(struct ipw_priv *priv)
10568 ipw_led_link_down(priv);
10569 netif_carrier_off(priv->net_dev);
10570 netif_stop_queue(priv->net_dev);
10571 notify_wx_assoc_event(priv);
10573 /* Cancel any queued work ... */
10574 cancel_delayed_work(&priv->request_scan);
10575 cancel_delayed_work(&priv->adhoc_check);
10576 cancel_delayed_work(&priv->gather_stats);
10578 ipw_reset_stats(priv);
10580 if (!(priv->status & STATUS_EXIT_PENDING)) {
10581 /* Queue up another scan... */
10582 queue_work(priv->workqueue, &priv->request_scan);
10586 static void ipw_bg_link_down(void *data)
10588 struct ipw_priv *priv = data;
10590 ipw_link_down(data);
10594 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10598 priv->workqueue = create_workqueue(DRV_NAME);
10599 init_waitqueue_head(&priv->wait_command_queue);
10600 init_waitqueue_head(&priv->wait_state);
10602 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10603 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10604 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10605 INIT_WORK(&priv->system_config, ipw_system_config, priv);
10606 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10607 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10608 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10609 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10610 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10611 INIT_WORK(&priv->request_scan,
10612 (void (*)(void *))ipw_request_scan, priv);
10613 INIT_WORK(&priv->gather_stats,
10614 (void (*)(void *))ipw_bg_gather_stats, priv);
10615 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10616 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10617 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10618 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10619 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10620 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10622 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10624 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10626 INIT_WORK(&priv->merge_networks,
10627 (void (*)(void *))ipw_merge_adhoc_network, priv);
10629 #ifdef CONFIG_IPW_QOS
10630 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10632 #endif /* CONFIG_IPW_QOS */
10634 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10635 ipw_irq_tasklet, (unsigned long)priv);
10640 static void shim__set_security(struct net_device *dev,
10641 struct ieee80211_security *sec)
10643 struct ipw_priv *priv = ieee80211_priv(dev);
10645 for (i = 0; i < 4; i++) {
10646 if (sec->flags & (1 << i)) {
10647 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10648 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10649 if (sec->key_sizes[i] == 0)
10650 priv->ieee->sec.flags &= ~(1 << i);
10652 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10653 sec->key_sizes[i]);
10654 priv->ieee->sec.flags |= (1 << i);
10656 priv->status |= STATUS_SECURITY_UPDATED;
10657 } else if (sec->level != SEC_LEVEL_1)
10658 priv->ieee->sec.flags &= ~(1 << i);
10661 if (sec->flags & SEC_ACTIVE_KEY) {
10662 if (sec->active_key <= 3) {
10663 priv->ieee->sec.active_key = sec->active_key;
10664 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10666 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10667 priv->status |= STATUS_SECURITY_UPDATED;
10669 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10671 if ((sec->flags & SEC_AUTH_MODE) &&
10672 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10673 priv->ieee->sec.auth_mode = sec->auth_mode;
10674 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10675 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10676 priv->capability |= CAP_SHARED_KEY;
10678 priv->capability &= ~CAP_SHARED_KEY;
10679 priv->status |= STATUS_SECURITY_UPDATED;
10682 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10683 priv->ieee->sec.flags |= SEC_ENABLED;
10684 priv->ieee->sec.enabled = sec->enabled;
10685 priv->status |= STATUS_SECURITY_UPDATED;
10687 priv->capability |= CAP_PRIVACY_ON;
10689 priv->capability &= ~CAP_PRIVACY_ON;
10692 if (sec->flags & SEC_ENCRYPT)
10693 priv->ieee->sec.encrypt = sec->encrypt;
10695 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10696 priv->ieee->sec.level = sec->level;
10697 priv->ieee->sec.flags |= SEC_LEVEL;
10698 priv->status |= STATUS_SECURITY_UPDATED;
10701 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10702 ipw_set_hwcrypto_keys(priv);
10704 /* To match current functionality of ipw2100 (which works well w/
10705 * various supplicants, we don't force a disassociate if the
10706 * privacy capability changes ... */
10708 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10709 (((priv->assoc_request.capability &
10710 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10711 (!(priv->assoc_request.capability &
10712 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10713 IPW_DEBUG_ASSOC("Disassociating due to capability "
10715 ipw_disassociate(priv);
10720 static int init_supported_rates(struct ipw_priv *priv,
10721 struct ipw_supported_rates *rates)
10723 /* TODO: Mask out rates based on priv->rates_mask */
10725 memset(rates, 0, sizeof(*rates));
10726 /* configure supported rates */
10727 switch (priv->ieee->freq_band) {
10728 case IEEE80211_52GHZ_BAND:
10729 rates->ieee_mode = IPW_A_MODE;
10730 rates->purpose = IPW_RATE_CAPABILITIES;
10731 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10732 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10735 default: /* Mixed or 2.4Ghz */
10736 rates->ieee_mode = IPW_G_MODE;
10737 rates->purpose = IPW_RATE_CAPABILITIES;
10738 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10739 IEEE80211_CCK_DEFAULT_RATES_MASK);
10740 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10741 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10742 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10750 static int ipw_config(struct ipw_priv *priv)
10752 /* This is only called from ipw_up, which resets/reloads the firmware
10753 so, we don't need to first disable the card before we configure
10755 if (ipw_set_tx_power(priv))
10758 /* initialize adapter address */
10759 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10762 /* set basic system config settings */
10763 init_sys_config(&priv->sys_config);
10764 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10765 priv->sys_config.answer_broadcast_ssid_probe = 1;
10767 priv->sys_config.answer_broadcast_ssid_probe = 0;
10769 if (ipw_send_system_config(priv, &priv->sys_config))
10772 init_supported_rates(priv, &priv->rates);
10773 if (ipw_send_supported_rates(priv, &priv->rates))
10776 /* Set request-to-send threshold */
10777 if (priv->rts_threshold) {
10778 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10781 #ifdef CONFIG_IPW_QOS
10782 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10783 ipw_qos_activate(priv, NULL);
10784 #endif /* CONFIG_IPW_QOS */
10786 if (ipw_set_random_seed(priv))
10789 /* final state transition to the RUN state */
10790 if (ipw_send_host_complete(priv))
10793 priv->status |= STATUS_INIT;
10795 ipw_led_init(priv);
10796 ipw_led_radio_on(priv);
10797 priv->notif_missed_beacons = 0;
10799 /* Set hardware WEP key if it is configured. */
10800 if ((priv->capability & CAP_PRIVACY_ON) &&
10801 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10802 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10803 ipw_set_hwcrypto_keys(priv);
10814 * These tables have been tested in conjunction with the
10815 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10817 * Altering this values, using it on other hardware, or in geographies
10818 * not intended for resale of the above mentioned Intel adapters has
10822 static const struct ieee80211_geo ipw_geos[] = {
10826 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10827 {2427, 4}, {2432, 5}, {2437, 6},
10828 {2442, 7}, {2447, 8}, {2452, 9},
10829 {2457, 10}, {2462, 11}},
10832 { /* Custom US/Canada */
10835 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10836 {2427, 4}, {2432, 5}, {2437, 6},
10837 {2442, 7}, {2447, 8}, {2452, 9},
10838 {2457, 10}, {2462, 11}},
10844 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10845 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10846 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10847 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10850 { /* Rest of World */
10853 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10854 {2427, 4}, {2432, 5}, {2437, 6},
10855 {2442, 7}, {2447, 8}, {2452, 9},
10856 {2457, 10}, {2462, 11}, {2467, 12},
10860 { /* Custom USA & Europe & High */
10863 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10864 {2427, 4}, {2432, 5}, {2437, 6},
10865 {2442, 7}, {2447, 8}, {2452, 9},
10866 {2457, 10}, {2462, 11}},
10872 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10873 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10874 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10875 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10883 { /* Custom NA & Europe */
10886 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10887 {2427, 4}, {2432, 5}, {2437, 6},
10888 {2442, 7}, {2447, 8}, {2452, 9},
10889 {2457, 10}, {2462, 11}},
10895 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10896 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10897 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10898 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10899 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10900 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10901 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10902 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10903 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10906 { /* Custom Japan */
10909 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10910 {2427, 4}, {2432, 5}, {2437, 6},
10911 {2442, 7}, {2447, 8}, {2452, 9},
10912 {2457, 10}, {2462, 11}},
10914 .a = {{5170, 34}, {5190, 38},
10915 {5210, 42}, {5230, 46}},
10921 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10922 {2427, 4}, {2432, 5}, {2437, 6},
10923 {2442, 7}, {2447, 8}, {2452, 9},
10924 {2457, 10}, {2462, 11}},
10930 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10931 {2427, 4}, {2432, 5}, {2437, 6},
10932 {2442, 7}, {2447, 8}, {2452, 9},
10933 {2457, 10}, {2462, 11}, {2467, 12},
10940 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10941 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10942 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10943 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10944 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10945 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10946 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10947 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10948 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10949 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10950 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10951 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10952 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10953 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10954 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10957 { /* Custom Japan */
10960 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10961 {2427, 4}, {2432, 5}, {2437, 6},
10962 {2442, 7}, {2447, 8}, {2452, 9},
10963 {2457, 10}, {2462, 11}, {2467, 12},
10964 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10966 .a = {{5170, 34}, {5190, 38},
10967 {5210, 42}, {5230, 46}},
10973 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10974 {2427, 4}, {2432, 5}, {2437, 6},
10975 {2442, 7}, {2447, 8}, {2452, 9},
10976 {2457, 10}, {2462, 11},
10977 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10978 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10980 .a = {{5745, 149}, {5765, 153},
10981 {5785, 157}, {5805, 161}},
10984 { /* Custom Europe */
10987 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10988 {2427, 4}, {2432, 5}, {2437, 6},
10989 {2442, 7}, {2447, 8}, {2452, 9},
10990 {2457, 10}, {2462, 11},
10991 {2467, 12}, {2472, 13}},
10993 .a = {{5180, 36}, {5200, 40},
10994 {5220, 44}, {5240, 48}},
11000 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11001 {2427, 4}, {2432, 5}, {2437, 6},
11002 {2442, 7}, {2447, 8}, {2452, 9},
11003 {2457, 10}, {2462, 11},
11004 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
11005 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
11007 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
11008 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
11009 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
11010 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
11011 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
11012 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
11013 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
11014 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
11015 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
11016 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
11017 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
11018 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
11019 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
11020 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
11021 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
11022 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
11023 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
11024 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
11025 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
11026 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
11027 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
11028 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
11029 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
11030 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
11036 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11037 {2427, 4}, {2432, 5}, {2437, 6},
11038 {2442, 7}, {2447, 8}, {2452, 9},
11039 {2457, 10}, {2462, 11}},
11041 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
11042 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
11043 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
11044 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
11045 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
11046 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
11047 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
11048 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
11049 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
11050 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
11051 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
11052 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
11053 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
11057 /* GEO code borrowed from ieee80211_geo.c */
11058 static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
11062 /* Driver needs to initialize the geography map before using
11063 * these helper functions */
11064 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
11066 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
11067 for (i = 0; i < ieee->geo.bg_channels; i++)
11068 /* NOTE: If G mode is currently supported but
11069 * this is a B only channel, we don't see it
11071 if ((ieee->geo.bg[i].channel == channel) &&
11072 (!(ieee->mode & IEEE_G) ||
11073 !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
11074 return IEEE80211_24GHZ_BAND;
11076 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
11077 for (i = 0; i < ieee->geo.a_channels; i++)
11078 if (ieee->geo.a[i].channel == channel)
11079 return IEEE80211_52GHZ_BAND;
11084 static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
11088 /* Driver needs to initialize the geography map before using
11089 * these helper functions */
11090 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
11092 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
11093 for (i = 0; i < ieee->geo.bg_channels; i++)
11094 if (ieee->geo.bg[i].channel == channel)
11097 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
11098 for (i = 0; i < ieee->geo.a_channels; i++)
11099 if (ieee->geo.a[i].channel == channel)
11105 static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
11109 /* Driver needs to initialize the geography map before using
11110 * these helper functions */
11111 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
11115 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
11116 for (i = 0; i < ieee->geo.bg_channels; i++)
11117 if (ieee->geo.bg[i].freq == freq)
11118 return ieee->geo.bg[i].channel;
11120 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
11121 for (i = 0; i < ieee->geo.a_channels; i++)
11122 if (ieee->geo.a[i].freq == freq)
11123 return ieee->geo.a[i].channel;
11128 static int ipw_set_geo(struct ieee80211_device *ieee,
11129 const struct ieee80211_geo *geo)
11131 memcpy(ieee->geo.name, geo->name, 3);
11132 ieee->geo.name[3] = '\0';
11133 ieee->geo.bg_channels = geo->bg_channels;
11134 ieee->geo.a_channels = geo->a_channels;
11135 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
11136 sizeof(struct ieee80211_channel));
11137 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
11138 sizeof(struct ieee80211_channel));
11142 static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
11147 #define MAX_HW_RESTARTS 5
11148 static int ipw_up(struct ipw_priv *priv)
11152 if (priv->status & STATUS_EXIT_PENDING)
11155 if (cmdlog && !priv->cmdlog) {
11156 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
11158 if (priv->cmdlog == NULL) {
11159 IPW_ERROR("Error allocating %d command log entries.\n",
11162 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
11163 priv->cmdlog_len = cmdlog;
11167 for (i = 0; i < MAX_HW_RESTARTS; i++) {
11168 /* Load the microcode, firmware, and eeprom.
11169 * Also start the clocks. */
11170 rc = ipw_load(priv);
11172 IPW_ERROR("Unable to load firmware: %d\n", rc);
11176 ipw_init_ordinals(priv);
11177 if (!(priv->config & CFG_CUSTOM_MAC))
11178 eeprom_parse_mac(priv, priv->mac_addr);
11179 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
11181 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
11182 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11183 ipw_geos[j].name, 3))
11186 if (j == ARRAY_SIZE(ipw_geos))
11188 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
11189 IPW_WARNING("Could not set geography.");
11193 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
11194 j, priv->ieee->geo.name);
11196 if (priv->status & STATUS_RF_KILL_SW) {
11197 IPW_WARNING("Radio disabled by module parameter.\n");
11199 } else if (rf_kill_active(priv)) {
11200 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
11201 "Kill switch must be turned off for "
11202 "wireless networking to work.\n");
11203 queue_delayed_work(priv->workqueue, &priv->rf_kill,
11208 rc = ipw_config(priv);
11210 IPW_DEBUG_INFO("Configured device on count %i\n", i);
11212 /* If configure to try and auto-associate, kick
11214 queue_work(priv->workqueue, &priv->request_scan);
11219 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
11220 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
11221 i, MAX_HW_RESTARTS);
11223 /* We had an error bringing up the hardware, so take it
11224 * all the way back down so we can try again */
11228 /* tried to restart and config the device for as long as our
11229 * patience could withstand */
11230 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
11235 static void ipw_bg_up(void *data)
11237 struct ipw_priv *priv = data;
11243 static void ipw_deinit(struct ipw_priv *priv)
11247 if (priv->status & STATUS_SCANNING) {
11248 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
11249 ipw_abort_scan(priv);
11252 if (priv->status & STATUS_ASSOCIATED) {
11253 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
11254 ipw_disassociate(priv);
11257 ipw_led_shutdown(priv);
11259 /* Wait up to 1s for status to change to not scanning and not
11260 * associated (disassociation can take a while for a ful 802.11
11262 for (i = 1000; i && (priv->status &
11263 (STATUS_DISASSOCIATING |
11264 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11267 if (priv->status & (STATUS_DISASSOCIATING |
11268 STATUS_ASSOCIATED | STATUS_SCANNING))
11269 IPW_DEBUG_INFO("Still associated or scanning...\n");
11271 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11273 /* Attempt to disable the card */
11274 ipw_send_card_disable(priv, 0);
11276 priv->status &= ~STATUS_INIT;
11279 static void ipw_down(struct ipw_priv *priv)
11281 int exit_pending = priv->status & STATUS_EXIT_PENDING;
11283 priv->status |= STATUS_EXIT_PENDING;
11285 if (ipw_is_init(priv))
11288 /* Wipe out the EXIT_PENDING status bit if we are not actually
11289 * exiting the module */
11291 priv->status &= ~STATUS_EXIT_PENDING;
11293 /* tell the device to stop sending interrupts */
11294 ipw_disable_interrupts(priv);
11296 /* Clear all bits but the RF Kill */
11297 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
11298 netif_carrier_off(priv->net_dev);
11299 netif_stop_queue(priv->net_dev);
11301 ipw_stop_nic(priv);
11303 ipw_led_radio_off(priv);
11306 static void ipw_bg_down(void *data)
11308 struct ipw_priv *priv = data;
11314 #if WIRELESS_EXT < 18
11315 static int ipw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
11317 struct iwreq *wrq = (struct iwreq *)rq;
11320 case IPW_IOCTL_WPA_SUPPLICANT:
11321 ret = ipw_wpa_supplicant(dev, &wrq->u.data);
11325 return -EOPNOTSUPP;
11328 return -EOPNOTSUPP;
11332 /* Called by register_netdev() */
11333 static int ipw_net_init(struct net_device *dev)
11335 struct ipw_priv *priv = ieee80211_priv(dev);
11338 if (ipw_up(priv)) {
11347 /* PCI driver stuff */
11348 static struct pci_device_id card_ids[] = {
11349 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
11350 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
11351 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
11352 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
11353 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
11354 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
11355 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
11356 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
11357 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
11358 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
11359 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
11360 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
11361 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
11362 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
11363 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
11364 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
11365 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
11366 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
11367 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
11368 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
11369 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
11370 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
11372 /* required last entry */
11376 MODULE_DEVICE_TABLE(pci, card_ids);
11378 static struct attribute *ipw_sysfs_entries[] = {
11379 &dev_attr_rf_kill.attr,
11380 &dev_attr_direct_dword.attr,
11381 &dev_attr_indirect_byte.attr,
11382 &dev_attr_indirect_dword.attr,
11383 &dev_attr_mem_gpio_reg.attr,
11384 &dev_attr_command_event_reg.attr,
11385 &dev_attr_nic_type.attr,
11386 &dev_attr_status.attr,
11387 &dev_attr_cfg.attr,
11388 &dev_attr_error.attr,
11389 &dev_attr_event_log.attr,
11390 &dev_attr_cmd_log.attr,
11391 &dev_attr_eeprom_delay.attr,
11392 &dev_attr_ucode_version.attr,
11393 &dev_attr_rtc.attr,
11394 &dev_attr_scan_age.attr,
11395 &dev_attr_led.attr,
11396 &dev_attr_speed_scan.attr,
11397 &dev_attr_net_stats.attr,
11401 static struct attribute_group ipw_attribute_group = {
11402 .name = NULL, /* put in device directory */
11403 .attrs = ipw_sysfs_entries,
11406 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
11409 struct net_device *net_dev;
11410 void __iomem *base;
11412 struct ipw_priv *priv;
11415 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
11416 if (net_dev == NULL) {
11421 priv = ieee80211_priv(net_dev);
11422 priv->ieee = netdev_priv(net_dev);
11424 priv->net_dev = net_dev;
11425 priv->pci_dev = pdev;
11426 #ifdef CONFIG_IPW_DEBUG
11427 ipw_debug_level = debug;
11429 spin_lock_init(&priv->lock);
11430 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11431 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
11433 init_MUTEX(&priv->sem);
11434 if (pci_enable_device(pdev)) {
11436 goto out_free_ieee80211;
11439 pci_set_master(pdev);
11441 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
11443 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
11445 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11446 goto out_pci_disable_device;
11449 pci_set_drvdata(pdev, priv);
11451 err = pci_request_regions(pdev, DRV_NAME);
11453 goto out_pci_disable_device;
11455 /* We disable the RETRY_TIMEOUT register (0x41) to keep
11456 * PCI Tx retries from interfering with C3 CPU state */
11457 pci_read_config_dword(pdev, 0x40, &val);
11458 if ((val & 0x0000ff00) != 0)
11459 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11461 length = pci_resource_len(pdev, 0);
11462 priv->hw_len = length;
11464 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
11467 goto out_pci_release_regions;
11470 priv->hw_base = base;
11471 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11472 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11474 err = ipw_setup_deferred_work(priv);
11476 IPW_ERROR("Unable to setup deferred work\n");
11480 ipw_sw_reset(priv, 1);
11482 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
11484 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11485 goto out_destroy_workqueue;
11488 SET_MODULE_OWNER(net_dev);
11489 SET_NETDEV_DEV(net_dev, &pdev->dev);
11491 ipw_wx_data.spy_data = &priv->ieee->spy_data;
11492 ipw_wx_data.ieee80211 = priv->ieee;
11496 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11497 priv->ieee->set_security = shim__set_security;
11498 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11500 #ifdef CONFIG_IPW_QOS
11501 priv->ieee->handle_probe_response = ipw_handle_beacon;
11502 priv->ieee->handle_beacon = ipw_handle_probe_response;
11503 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11504 #endif /* CONFIG_IPW_QOS */
11506 priv->ieee->perfect_rssi = -20;
11507 priv->ieee->worst_rssi = -85;
11509 net_dev->open = ipw_net_open;
11510 net_dev->stop = ipw_net_stop;
11511 net_dev->init = ipw_net_init;
11512 #if WIRELESS_EXT < 18
11513 net_dev->do_ioctl = ipw_ioctl;
11515 net_dev->get_stats = ipw_net_get_stats;
11516 net_dev->set_multicast_list = ipw_net_set_multicast_list;
11517 net_dev->set_mac_address = ipw_net_set_mac_address;
11518 net_dev->get_wireless_stats = ipw_get_wireless_stats;
11519 net_dev->wireless_data = &ipw_wx_data;
11520 net_dev->wireless_handlers = &ipw_wx_handler_def;
11521 net_dev->ethtool_ops = &ipw_ethtool_ops;
11522 net_dev->irq = pdev->irq;
11523 net_dev->base_addr = (unsigned long)priv->hw_base;
11524 net_dev->mem_start = pci_resource_start(pdev, 0);
11525 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11527 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11529 IPW_ERROR("failed to create sysfs device attributes\n");
11531 goto out_release_irq;
11535 err = register_netdev(net_dev);
11537 IPW_ERROR("failed to register network device\n");
11538 goto out_remove_sysfs;
11543 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11545 free_irq(pdev->irq, priv);
11546 out_destroy_workqueue:
11547 destroy_workqueue(priv->workqueue);
11548 priv->workqueue = NULL;
11550 iounmap(priv->hw_base);
11551 out_pci_release_regions:
11552 pci_release_regions(pdev);
11553 out_pci_disable_device:
11554 pci_disable_device(pdev);
11555 pci_set_drvdata(pdev, NULL);
11556 out_free_ieee80211:
11557 free_ieee80211(priv->net_dev);
11562 static void ipw_pci_remove(struct pci_dev *pdev)
11564 struct ipw_priv *priv = pci_get_drvdata(pdev);
11565 struct list_head *p, *q;
11573 priv->status |= STATUS_EXIT_PENDING;
11575 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11579 unregister_netdev(priv->net_dev);
11582 ipw_rx_queue_free(priv, priv->rxq);
11585 ipw_tx_queue_free(priv);
11587 if (priv->cmdlog) {
11588 kfree(priv->cmdlog);
11589 priv->cmdlog = NULL;
11591 /* ipw_down will ensure that there is no more pending work
11592 * in the workqueue's, so we can safely remove them now. */
11593 cancel_delayed_work(&priv->adhoc_check);
11594 cancel_delayed_work(&priv->gather_stats);
11595 cancel_delayed_work(&priv->request_scan);
11596 cancel_delayed_work(&priv->rf_kill);
11597 cancel_delayed_work(&priv->scan_check);
11598 destroy_workqueue(priv->workqueue);
11599 priv->workqueue = NULL;
11601 /* Free MAC hash list for ADHOC */
11602 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11603 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11604 kfree(list_entry(p, struct ipw_ibss_seq, list));
11610 ipw_free_error_log(priv->error);
11611 priv->error = NULL;
11614 free_irq(pdev->irq, priv);
11615 iounmap(priv->hw_base);
11616 pci_release_regions(pdev);
11617 pci_disable_device(pdev);
11618 pci_set_drvdata(pdev, NULL);
11619 free_ieee80211(priv->net_dev);
11624 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11626 struct ipw_priv *priv = pci_get_drvdata(pdev);
11627 struct net_device *dev = priv->net_dev;
11629 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11631 /* Take down the device; powers it off, etc. */
11634 /* Remove the PRESENT state of the device */
11635 netif_device_detach(dev);
11637 pci_save_state(pdev);
11638 pci_disable_device(pdev);
11639 pci_set_power_state(pdev, pci_choose_state(pdev, state));
11644 static int ipw_pci_resume(struct pci_dev *pdev)
11646 struct ipw_priv *priv = pci_get_drvdata(pdev);
11647 struct net_device *dev = priv->net_dev;
11650 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11652 pci_set_power_state(pdev, PCI_D0);
11653 pci_enable_device(pdev);
11654 pci_restore_state(pdev);
11657 * Suspend/Resume resets the PCI configuration space, so we have to
11658 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11659 * from interfering with C3 CPU state. pci_restore_state won't help
11660 * here since it only restores the first 64 bytes pci config header.
11662 pci_read_config_dword(pdev, 0x40, &val);
11663 if ((val & 0x0000ff00) != 0)
11664 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11666 /* Set the device back into the PRESENT state; this will also wake
11667 * the queue of needed */
11668 netif_device_attach(dev);
11670 /* Bring the device back up */
11671 queue_work(priv->workqueue, &priv->up);
11677 /* driver initialization stuff */
11678 static struct pci_driver ipw_driver = {
11680 .id_table = card_ids,
11681 .probe = ipw_pci_probe,
11682 .remove = __devexit_p(ipw_pci_remove),
11684 .suspend = ipw_pci_suspend,
11685 .resume = ipw_pci_resume,
11689 static int __init ipw_init(void)
11693 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11694 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11696 ret = pci_module_init(&ipw_driver);
11698 IPW_ERROR("Unable to initialize PCI module\n");
11702 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11704 IPW_ERROR("Unable to create driver sysfs file\n");
11705 pci_unregister_driver(&ipw_driver);
11712 static void __exit ipw_exit(void)
11714 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11715 pci_unregister_driver(&ipw_driver);
11718 module_param(disable, int, 0444);
11719 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11721 module_param(associate, int, 0444);
11722 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11724 module_param(auto_create, int, 0444);
11725 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11727 module_param(led, int, 0444);
11728 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11730 module_param(debug, int, 0444);
11731 MODULE_PARM_DESC(debug, "debug output mask");
11733 module_param(channel, int, 0444);
11734 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11736 #ifdef CONFIG_IPW_QOS
11737 module_param(qos_enable, int, 0444);
11738 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11740 module_param(qos_burst_enable, int, 0444);
11741 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11743 module_param(qos_no_ack_mask, int, 0444);
11744 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11746 module_param(burst_duration_CCK, int, 0444);
11747 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11749 module_param(burst_duration_OFDM, int, 0444);
11750 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11751 #endif /* CONFIG_IPW_QOS */
11753 #ifdef CONFIG_IPW2200_MONITOR
11754 module_param(mode, int, 0444);
11755 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11757 module_param(mode, int, 0444);
11758 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11761 module_param(hwcrypto, int, 0444);
11762 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11764 module_param(cmdlog, int, 0444);
11765 MODULE_PARM_DESC(cmdlog,
11766 "allocate a ring buffer for logging firmware commands");
11768 module_exit(ipw_exit);
11769 module_init(ipw_init);