blob: b80ebd37483e0930f43ea988b742fdb28bd8a6ff [file] [log] [blame]
James Ketrenos43f66a62005-03-25 12:31:53 -06001/******************************************************************************
Jeff Garzikbf794512005-07-31 13:07:26 -04002
James Ketrenosafbf30a2005-08-25 00:05:33 -05003 Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
James Ketrenos43f66a62005-03-25 12:31:53 -06004
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
10
Jeff Garzikbf794512005-07-31 13:07:26 -040011 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
James Ketrenos43f66a62005-03-25 12:31:53 -060013 published by the Free Software Foundation.
Jeff Garzikbf794512005-07-31 13:07:26 -040014
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
James Ketrenos43f66a62005-03-25 12:31:53 -060018 more details.
Jeff Garzikbf794512005-07-31 13:07:26 -040019
James Ketrenos43f66a62005-03-25 12:31:53 -060020 You should have received a copy of the GNU General Public License along with
Jeff Garzikbf794512005-07-31 13:07:26 -040021 this program; if not, write to the Free Software Foundation, Inc., 59
James Ketrenos43f66a62005-03-25 12:31:53 -060022 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Jeff Garzikbf794512005-07-31 13:07:26 -040023
James Ketrenos43f66a62005-03-25 12:31:53 -060024 The full GNU General Public License is included in this distribution in the
25 file called LICENSE.
Jeff Garzikbf794512005-07-31 13:07:26 -040026
James Ketrenos43f66a62005-03-25 12:31:53 -060027 Contact Information:
28 James P. Ketrenos <ipw2100-admin@linux.intel.com>
29 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30
31******************************************************************************/
32
33#include "ipw2200.h"
Olaf Hering733482e2005-11-08 21:34:55 -080034#include <linux/version.h>
James Ketrenos43f66a62005-03-25 12:31:53 -060035
Zhu Yi7c97eb32006-01-24 16:37:47 +080036#define IPW2200_VERSION "git-1.0.10"
James Ketrenos43f66a62005-03-25 12:31:53 -060037#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
James Ketrenos2b184d52005-08-03 20:33:14 -050038#define DRV_COPYRIGHT "Copyright(c) 2003-2005 Intel Corporation"
James Ketrenos43f66a62005-03-25 12:31:53 -060039#define DRV_VERSION IPW2200_VERSION
40
James Ketrenosb095c382005-08-24 22:04:42 -050041#define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
42
James Ketrenos43f66a62005-03-25 12:31:53 -060043MODULE_DESCRIPTION(DRV_DESCRIPTION);
44MODULE_VERSION(DRV_VERSION);
45MODULE_AUTHOR(DRV_COPYRIGHT);
46MODULE_LICENSE("GPL");
47
James Ketrenosf6c5cb72005-08-25 00:39:09 -050048static int cmdlog = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -060049static int debug = 0;
50static int channel = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -060051static int mode = 0;
52
53static u32 ipw_debug_level;
54static int associate = 1;
55static int auto_create = 1;
James Ketrenosa613bff2005-08-24 21:43:11 -050056static int led = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -060057static int disable = 0;
Zhu Yi810dabd2006-01-24 16:36:59 +080058static int bt_coexist = 0;
Zhu Yibde37d02006-01-24 16:38:08 +080059static int hwcrypto = 0;
Zhu Yi4bfdb912006-01-24 16:37:16 +080060static int roaming = 1;
James Ketrenos43f66a62005-03-25 12:31:53 -060061static const char ipw_modes[] = {
62 'a', 'b', 'g', '?'
63};
64
James Ketrenosb095c382005-08-24 22:04:42 -050065#ifdef CONFIG_IPW_QOS
66static int qos_enable = 0;
67static int qos_burst_enable = 0;
68static int qos_no_ack_mask = 0;
69static int burst_duration_CCK = 0;
70static int burst_duration_OFDM = 0;
71
72static struct ieee80211_qos_parameters def_qos_parameters_OFDM = {
73 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
74 QOS_TX3_CW_MIN_OFDM},
75 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
76 QOS_TX3_CW_MAX_OFDM},
77 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
78 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
79 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
80 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
81};
82
83static struct ieee80211_qos_parameters def_qos_parameters_CCK = {
84 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
85 QOS_TX3_CW_MIN_CCK},
86 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
87 QOS_TX3_CW_MAX_CCK},
88 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
89 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
90 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
91 QOS_TX3_TXOP_LIMIT_CCK}
92};
93
94static struct ieee80211_qos_parameters def_parameters_OFDM = {
95 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
96 DEF_TX3_CW_MIN_OFDM},
97 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
98 DEF_TX3_CW_MAX_OFDM},
99 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
100 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
101 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
102 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
103};
104
105static struct ieee80211_qos_parameters def_parameters_CCK = {
106 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
107 DEF_TX3_CW_MIN_CCK},
108 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
109 DEF_TX3_CW_MAX_CCK},
110 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
111 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
112 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
113 DEF_TX3_TXOP_LIMIT_CCK}
114};
115
116static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
117
118static int from_priority_to_tx_queue[] = {
119 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
120 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
121};
122
123static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
124
125static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
126 *qos_param);
127static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
128 *qos_param);
129#endif /* CONFIG_IPW_QOS */
130
Benoit Boissinot97a78ca2005-09-15 17:30:28 +0000131static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
James Ketrenosb095c382005-08-24 22:04:42 -0500132static void ipw_remove_current_network(struct ipw_priv *priv);
James Ketrenos43f66a62005-03-25 12:31:53 -0600133static void ipw_rx(struct ipw_priv *priv);
Jeff Garzikbf794512005-07-31 13:07:26 -0400134static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -0600135 struct clx2_tx_queue *txq, int qindex);
136static int ipw_queue_reset(struct ipw_priv *priv);
137
138static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
139 int len, int sync);
140
141static void ipw_tx_queue_free(struct ipw_priv *);
142
143static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
144static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
145static void ipw_rx_queue_replenish(void *);
James Ketrenos43f66a62005-03-25 12:31:53 -0600146static int ipw_up(struct ipw_priv *);
James Ketrenosc848d0a2005-08-24 21:56:24 -0500147static void ipw_bg_up(void *);
James Ketrenos43f66a62005-03-25 12:31:53 -0600148static void ipw_down(struct ipw_priv *);
James Ketrenosc848d0a2005-08-24 21:56:24 -0500149static void ipw_bg_down(void *);
James Ketrenos43f66a62005-03-25 12:31:53 -0600150static int ipw_config(struct ipw_priv *);
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400151static int init_supported_rates(struct ipw_priv *priv,
152 struct ipw_supported_rates *prates);
James Ketrenosb095c382005-08-24 22:04:42 -0500153static void ipw_set_hwcrypto_keys(struct ipw_priv *);
154static void ipw_send_wep_keys(struct ipw_priv *, int);
James Ketrenos43f66a62005-03-25 12:31:53 -0600155
James Ketrenosf6c5cb72005-08-25 00:39:09 -0500156static int snprint_line(char *buf, size_t count,
157 const u8 * data, u32 len, u32 ofs)
James Ketrenos43f66a62005-03-25 12:31:53 -0600158{
159 int out, i, j, l;
160 char c;
Jeff Garzikbf794512005-07-31 13:07:26 -0400161
James Ketrenos43f66a62005-03-25 12:31:53 -0600162 out = snprintf(buf, count, "%08X", ofs);
163
164 for (l = 0, i = 0; i < 2; i++) {
165 out += snprintf(buf + out, count - out, " ");
Jeff Garzikbf794512005-07-31 13:07:26 -0400166 for (j = 0; j < 8 && l < len; j++, l++)
167 out += snprintf(buf + out, count - out, "%02X ",
James Ketrenos43f66a62005-03-25 12:31:53 -0600168 data[(i * 8 + j)]);
169 for (; j < 8; j++)
170 out += snprintf(buf + out, count - out, " ");
171 }
Jeff Garzikbf794512005-07-31 13:07:26 -0400172
James Ketrenos43f66a62005-03-25 12:31:53 -0600173 out += snprintf(buf + out, count - out, " ");
174 for (l = 0, i = 0; i < 2; i++) {
175 out += snprintf(buf + out, count - out, " ");
176 for (j = 0; j < 8 && l < len; j++, l++) {
177 c = data[(i * 8 + j)];
178 if (!isascii(c) || !isprint(c))
179 c = '.';
Jeff Garzikbf794512005-07-31 13:07:26 -0400180
James Ketrenos43f66a62005-03-25 12:31:53 -0600181 out += snprintf(buf + out, count - out, "%c", c);
182 }
183
184 for (; j < 8; j++)
185 out += snprintf(buf + out, count - out, " ");
186 }
Jeff Garzikbf794512005-07-31 13:07:26 -0400187
James Ketrenosf6c5cb72005-08-25 00:39:09 -0500188 return out;
James Ketrenos43f66a62005-03-25 12:31:53 -0600189}
190
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400191static void printk_buf(int level, const u8 * data, u32 len)
James Ketrenos43f66a62005-03-25 12:31:53 -0600192{
193 char line[81];
194 u32 ofs = 0;
195 if (!(ipw_debug_level & level))
196 return;
197
198 while (len) {
James Ketrenosf6c5cb72005-08-25 00:39:09 -0500199 snprint_line(line, sizeof(line), &data[ofs],
200 min(len, 16U), ofs);
201 printk(KERN_DEBUG "%s\n", line);
James Ketrenos43f66a62005-03-25 12:31:53 -0600202 ofs += 16;
203 len -= min(len, 16U);
204 }
205}
206
James Ketrenosf6c5cb72005-08-25 00:39:09 -0500207static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
208{
209 size_t out = size;
210 u32 ofs = 0;
211 int total = 0;
212
213 while (size && len) {
214 out = snprint_line(output, size, &data[ofs],
215 min_t(size_t, len, 16U), ofs);
216
217 ofs += 16;
218 output += out;
219 size -= out;
220 len -= min_t(size_t, len, 16U);
221 total += out;
222 }
223 return total;
224}
225
Zhu Yic8fe6672006-01-24 16:36:36 +0800226/* alias for 32-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600227static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
228#define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
229
Zhu Yic8fe6672006-01-24 16:36:36 +0800230/* alias for 8-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600231static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
232#define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
233
Zhu Yic8fe6672006-01-24 16:36:36 +0800234/* 8-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600235static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
236static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
237{
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400238 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
239 __LINE__, (u32) (b), (u32) (c));
James Ketrenos43f66a62005-03-25 12:31:53 -0600240 _ipw_write_reg8(a, b, c);
241}
242
Zhu Yic8fe6672006-01-24 16:36:36 +0800243/* 16-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600244static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
245static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
246{
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400247 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
248 __LINE__, (u32) (b), (u32) (c));
James Ketrenos43f66a62005-03-25 12:31:53 -0600249 _ipw_write_reg16(a, b, c);
250}
251
Zhu Yic8fe6672006-01-24 16:36:36 +0800252/* 32-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600253static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
254static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
255{
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400256 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
257 __LINE__, (u32) (b), (u32) (c));
James Ketrenos43f66a62005-03-25 12:31:53 -0600258 _ipw_write_reg32(a, b, c);
259}
260
Zhu Yic8fe6672006-01-24 16:36:36 +0800261/* 8-bit direct write (low 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600262#define _ipw_write8(ipw, ofs, val) writeb((val), (ipw)->hw_base + (ofs))
Zhu Yic8fe6672006-01-24 16:36:36 +0800263
264/* 8-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600265#define ipw_write8(ipw, ofs, val) \
266 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
267 _ipw_write8(ipw, ofs, val)
268
Zhu Yic8fe6672006-01-24 16:36:36 +0800269/* 16-bit direct write (low 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600270#define _ipw_write16(ipw, ofs, val) writew((val), (ipw)->hw_base + (ofs))
Zhu Yic8fe6672006-01-24 16:36:36 +0800271
272/* 16-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600273#define ipw_write16(ipw, ofs, val) \
274 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
275 _ipw_write16(ipw, ofs, val)
276
Zhu Yic8fe6672006-01-24 16:36:36 +0800277/* 32-bit direct write (low 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600278#define _ipw_write32(ipw, ofs, val) writel((val), (ipw)->hw_base + (ofs))
Zhu Yic8fe6672006-01-24 16:36:36 +0800279
280/* 32-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600281#define ipw_write32(ipw, ofs, val) \
282 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
283 _ipw_write32(ipw, ofs, val)
284
Zhu Yic8fe6672006-01-24 16:36:36 +0800285/* 8-bit direct read (low 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600286#define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
Zhu Yic8fe6672006-01-24 16:36:36 +0800287
288/* 8-bit direct read (low 4K), with debug wrapper */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400289static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
290{
291 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
James Ketrenos43f66a62005-03-25 12:31:53 -0600292 return _ipw_read8(ipw, ofs);
293}
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400294
Zhu Yic8fe6672006-01-24 16:36:36 +0800295/* alias to 8-bit direct read (low 4K of SRAM/regs), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600296#define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)
297
Zhu Yic8fe6672006-01-24 16:36:36 +0800298/* 16-bit direct read (low 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600299#define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
Zhu Yic8fe6672006-01-24 16:36:36 +0800300
301/* 16-bit direct read (low 4K), with debug wrapper */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400302static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
303{
304 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
James Ketrenos43f66a62005-03-25 12:31:53 -0600305 return _ipw_read16(ipw, ofs);
306}
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400307
Zhu Yic8fe6672006-01-24 16:36:36 +0800308/* alias to 16-bit direct read (low 4K of SRAM/regs), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600309#define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)
310
Zhu Yic8fe6672006-01-24 16:36:36 +0800311/* 32-bit direct read (low 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600312#define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
Zhu Yic8fe6672006-01-24 16:36:36 +0800313
314/* 32-bit direct read (low 4K), with debug wrapper */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400315static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
316{
317 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
James Ketrenos43f66a62005-03-25 12:31:53 -0600318 return _ipw_read32(ipw, ofs);
319}
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400320
Zhu Yic8fe6672006-01-24 16:36:36 +0800321/* alias to 32-bit direct read (low 4K of SRAM/regs), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600322#define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
323
Zhu Yic8fe6672006-01-24 16:36:36 +0800324/* multi-byte read (above 4K), with debug wrapper */
James Ketrenos43f66a62005-03-25 12:31:53 -0600325static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
James Ketrenosf6c5cb72005-08-25 00:39:09 -0500326static inline void __ipw_read_indirect(const char *f, int l,
327 struct ipw_priv *a, u32 b, u8 * c, int d)
328{
329 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
330 d);
331 _ipw_read_indirect(a, b, c, d);
332}
333
Zhu Yic8fe6672006-01-24 16:36:36 +0800334/* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
James Ketrenosf6c5cb72005-08-25 00:39:09 -0500335#define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
James Ketrenos43f66a62005-03-25 12:31:53 -0600336
Zhu Yic8fe6672006-01-24 16:36:36 +0800337/* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400338static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
339 int num);
James Ketrenos43f66a62005-03-25 12:31:53 -0600340#define ipw_write_indirect(a, b, c, d) \
341 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
James Ketrenosafbf30a2005-08-25 00:05:33 -0500342 _ipw_write_indirect(a, b, c, d)
James Ketrenos43f66a62005-03-25 12:31:53 -0600343
Zhu Yic8fe6672006-01-24 16:36:36 +0800344/* 32-bit indirect write (above 4K) */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400345static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
James Ketrenos43f66a62005-03-25 12:31:53 -0600346{
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400347 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
James Ketrenosb095c382005-08-24 22:04:42 -0500348 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
349 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
James Ketrenos43f66a62005-03-25 12:31:53 -0600350}
351
Zhu Yic8fe6672006-01-24 16:36:36 +0800352/* 8-bit indirect write (above 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600353static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
354{
Zhu Yi2638bc32006-01-24 16:37:52 +0800355 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
Zhu Yic8fe6672006-01-24 16:36:36 +0800356 u32 dif_len = reg - aligned_addr;
357
James Ketrenos43f66a62005-03-25 12:31:53 -0600358 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
Zhu Yic8fe6672006-01-24 16:36:36 +0800359 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
360 _ipw_write8(priv, IPW_INDIRECT_DATA + dif_len, value);
James Ketrenos43f66a62005-03-25 12:31:53 -0600361}
362
Zhu Yic8fe6672006-01-24 16:36:36 +0800363/* 16-bit indirect write (above 4K) */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400364static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
James Ketrenos43f66a62005-03-25 12:31:53 -0600365{
Zhu Yi2638bc32006-01-24 16:37:52 +0800366 u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK; /* dword align */
Zhu Yic8fe6672006-01-24 16:36:36 +0800367 u32 dif_len = (reg - aligned_addr) & (~0x1ul);
368
James Ketrenos43f66a62005-03-25 12:31:53 -0600369 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
Zhu Yic8fe6672006-01-24 16:36:36 +0800370 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
371 _ipw_write16(priv, IPW_INDIRECT_DATA + dif_len, value);
James Ketrenos43f66a62005-03-25 12:31:53 -0600372}
373
Zhu Yic8fe6672006-01-24 16:36:36 +0800374/* 8-bit indirect read (above 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600375static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
376{
377 u32 word;
James Ketrenosb095c382005-08-24 22:04:42 -0500378 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
James Ketrenos43f66a62005-03-25 12:31:53 -0600379 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
James Ketrenosb095c382005-08-24 22:04:42 -0500380 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400381 return (word >> ((reg & 0x3) * 8)) & 0xff;
James Ketrenos43f66a62005-03-25 12:31:53 -0600382}
383
Zhu Yic8fe6672006-01-24 16:36:36 +0800384/* 32-bit indirect read (above 4K) */
James Ketrenos43f66a62005-03-25 12:31:53 -0600385static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
386{
387 u32 value;
388
389 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
390
James Ketrenosb095c382005-08-24 22:04:42 -0500391 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
392 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
James Ketrenos43f66a62005-03-25 12:31:53 -0600393 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
394 return value;
395}
396
Zhu Yic8fe6672006-01-24 16:36:36 +0800397/* General purpose, no alignment requirement, iterative (multi-byte) read, */
398/* for area above 1st 4K of SRAM/reg space */
James Ketrenos43f66a62005-03-25 12:31:53 -0600399static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
400 int num)
401{
Zhu Yi2638bc32006-01-24 16:37:52 +0800402 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
James Ketrenos43f66a62005-03-25 12:31:53 -0600403 u32 dif_len = addr - aligned_addr;
James Ketrenos43f66a62005-03-25 12:31:53 -0600404 u32 i;
Jeff Garzikbf794512005-07-31 13:07:26 -0400405
James Ketrenos43f66a62005-03-25 12:31:53 -0600406 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
407
James Ketrenosea2b26e2005-08-24 21:25:16 -0500408 if (num <= 0) {
409 return;
410 }
411
Zhu Yic8fe6672006-01-24 16:36:36 +0800412 /* Read the first dword (or portion) byte by byte */
James Ketrenos43f66a62005-03-25 12:31:53 -0600413 if (unlikely(dif_len)) {
James Ketrenosb095c382005-08-24 22:04:42 -0500414 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
James Ketrenos43f66a62005-03-25 12:31:53 -0600415 /* Start reading at aligned_addr + dif_len */
James Ketrenosea2b26e2005-08-24 21:25:16 -0500416 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
James Ketrenosb095c382005-08-24 22:04:42 -0500417 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
James Ketrenos43f66a62005-03-25 12:31:53 -0600418 aligned_addr += 4;
419 }
420
Zhu Yic8fe6672006-01-24 16:36:36 +0800421 /* Read all of the middle dwords as dwords, with auto-increment */
James Ketrenosb095c382005-08-24 22:04:42 -0500422 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
James Ketrenosea2b26e2005-08-24 21:25:16 -0500423 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
James Ketrenosb095c382005-08-24 22:04:42 -0500424 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
Jeff Garzikbf794512005-07-31 13:07:26 -0400425
Zhu Yic8fe6672006-01-24 16:36:36 +0800426 /* Read the last dword (or portion) byte by byte */
James Ketrenosea2b26e2005-08-24 21:25:16 -0500427 if (unlikely(num)) {
James Ketrenosb095c382005-08-24 22:04:42 -0500428 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
James Ketrenosea2b26e2005-08-24 21:25:16 -0500429 for (i = 0; num > 0; i++, num--)
James Ketrenosb095c382005-08-24 22:04:42 -0500430 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
James Ketrenosea2b26e2005-08-24 21:25:16 -0500431 }
James Ketrenos43f66a62005-03-25 12:31:53 -0600432}
433
Zhu Yic8fe6672006-01-24 16:36:36 +0800434/* General purpose, no alignment requirement, iterative (multi-byte) write, */
435/* for area above 1st 4K of SRAM/reg space */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400436static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
James Ketrenos43f66a62005-03-25 12:31:53 -0600437 int num)
438{
Zhu Yi2638bc32006-01-24 16:37:52 +0800439 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK; /* dword align */
James Ketrenos43f66a62005-03-25 12:31:53 -0600440 u32 dif_len = addr - aligned_addr;
James Ketrenos43f66a62005-03-25 12:31:53 -0600441 u32 i;
Jeff Garzikbf794512005-07-31 13:07:26 -0400442
James Ketrenos43f66a62005-03-25 12:31:53 -0600443 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
Jeff Garzikbf794512005-07-31 13:07:26 -0400444
James Ketrenosea2b26e2005-08-24 21:25:16 -0500445 if (num <= 0) {
446 return;
447 }
448
Zhu Yic8fe6672006-01-24 16:36:36 +0800449 /* Write the first dword (or portion) byte by byte */
James Ketrenos43f66a62005-03-25 12:31:53 -0600450 if (unlikely(dif_len)) {
James Ketrenosb095c382005-08-24 22:04:42 -0500451 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
Zhu Yic8fe6672006-01-24 16:36:36 +0800452 /* Start writing at aligned_addr + dif_len */
James Ketrenosea2b26e2005-08-24 21:25:16 -0500453 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
James Ketrenosb095c382005-08-24 22:04:42 -0500454 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
James Ketrenos43f66a62005-03-25 12:31:53 -0600455 aligned_addr += 4;
456 }
Jeff Garzikbf794512005-07-31 13:07:26 -0400457
Zhu Yic8fe6672006-01-24 16:36:36 +0800458 /* Write all of the middle dwords as dwords, with auto-increment */
James Ketrenosb095c382005-08-24 22:04:42 -0500459 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
James Ketrenosea2b26e2005-08-24 21:25:16 -0500460 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
James Ketrenosb095c382005-08-24 22:04:42 -0500461 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
Jeff Garzikbf794512005-07-31 13:07:26 -0400462
Zhu Yic8fe6672006-01-24 16:36:36 +0800463 /* Write the last dword (or portion) byte by byte */
James Ketrenosea2b26e2005-08-24 21:25:16 -0500464 if (unlikely(num)) {
James Ketrenosb095c382005-08-24 22:04:42 -0500465 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
James Ketrenosea2b26e2005-08-24 21:25:16 -0500466 for (i = 0; num > 0; i++, num--, buf++)
James Ketrenosb095c382005-08-24 22:04:42 -0500467 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
James Ketrenosea2b26e2005-08-24 21:25:16 -0500468 }
James Ketrenos43f66a62005-03-25 12:31:53 -0600469}
470
Zhu Yic8fe6672006-01-24 16:36:36 +0800471/* General purpose, no alignment requirement, iterative (multi-byte) write, */
472/* for 1st 4K of SRAM/regs space */
Jeff Garzikbf794512005-07-31 13:07:26 -0400473static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
James Ketrenos43f66a62005-03-25 12:31:53 -0600474 int num)
475{
476 memcpy_toio((priv->hw_base + addr), buf, num);
477}
478
Zhu Yic8fe6672006-01-24 16:36:36 +0800479/* Set bit(s) in low 4K of SRAM/regs */
James Ketrenos43f66a62005-03-25 12:31:53 -0600480static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
481{
482 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
483}
484
Zhu Yic8fe6672006-01-24 16:36:36 +0800485/* Clear bit(s) in low 4K of SRAM/regs */
James Ketrenos43f66a62005-03-25 12:31:53 -0600486static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
487{
488 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
489}
490
491static inline void ipw_enable_interrupts(struct ipw_priv *priv)
492{
493 if (priv->status & STATUS_INT_ENABLED)
494 return;
495 priv->status |= STATUS_INT_ENABLED;
James Ketrenosb095c382005-08-24 22:04:42 -0500496 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
James Ketrenos43f66a62005-03-25 12:31:53 -0600497}
498
499static inline void ipw_disable_interrupts(struct ipw_priv *priv)
500{
501 if (!(priv->status & STATUS_INT_ENABLED))
502 return;
503 priv->status &= ~STATUS_INT_ENABLED;
James Ketrenosb095c382005-08-24 22:04:42 -0500504 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
James Ketrenos43f66a62005-03-25 12:31:53 -0600505}
506
Brice Goglin0f52bf92005-12-01 01:41:46 -0800507#ifdef CONFIG_IPW2200_DEBUG
James Ketrenos43f66a62005-03-25 12:31:53 -0600508static char *ipw_error_desc(u32 val)
509{
510 switch (val) {
Jeff Garzikbf794512005-07-31 13:07:26 -0400511 case IPW_FW_ERROR_OK:
James Ketrenos43f66a62005-03-25 12:31:53 -0600512 return "ERROR_OK";
Jeff Garzikbf794512005-07-31 13:07:26 -0400513 case IPW_FW_ERROR_FAIL:
James Ketrenos43f66a62005-03-25 12:31:53 -0600514 return "ERROR_FAIL";
Jeff Garzikbf794512005-07-31 13:07:26 -0400515 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
James Ketrenos43f66a62005-03-25 12:31:53 -0600516 return "MEMORY_UNDERFLOW";
Jeff Garzikbf794512005-07-31 13:07:26 -0400517 case IPW_FW_ERROR_MEMORY_OVERFLOW:
James Ketrenos43f66a62005-03-25 12:31:53 -0600518 return "MEMORY_OVERFLOW";
Jeff Garzikbf794512005-07-31 13:07:26 -0400519 case IPW_FW_ERROR_BAD_PARAM:
James Ketrenosb095c382005-08-24 22:04:42 -0500520 return "BAD_PARAM";
Jeff Garzikbf794512005-07-31 13:07:26 -0400521 case IPW_FW_ERROR_BAD_CHECKSUM:
James Ketrenosb095c382005-08-24 22:04:42 -0500522 return "BAD_CHECKSUM";
Jeff Garzikbf794512005-07-31 13:07:26 -0400523 case IPW_FW_ERROR_NMI_INTERRUPT:
James Ketrenosb095c382005-08-24 22:04:42 -0500524 return "NMI_INTERRUPT";
Jeff Garzikbf794512005-07-31 13:07:26 -0400525 case IPW_FW_ERROR_BAD_DATABASE:
James Ketrenosb095c382005-08-24 22:04:42 -0500526 return "BAD_DATABASE";
Jeff Garzikbf794512005-07-31 13:07:26 -0400527 case IPW_FW_ERROR_ALLOC_FAIL:
James Ketrenosb095c382005-08-24 22:04:42 -0500528 return "ALLOC_FAIL";
Jeff Garzikbf794512005-07-31 13:07:26 -0400529 case IPW_FW_ERROR_DMA_UNDERRUN:
James Ketrenosb095c382005-08-24 22:04:42 -0500530 return "DMA_UNDERRUN";
Jeff Garzikbf794512005-07-31 13:07:26 -0400531 case IPW_FW_ERROR_DMA_STATUS:
James Ketrenosb095c382005-08-24 22:04:42 -0500532 return "DMA_STATUS";
533 case IPW_FW_ERROR_DINO_ERROR:
534 return "DINO_ERROR";
535 case IPW_FW_ERROR_EEPROM_ERROR:
536 return "EEPROM_ERROR";
Jeff Garzikbf794512005-07-31 13:07:26 -0400537 case IPW_FW_ERROR_SYSASSERT:
James Ketrenosb095c382005-08-24 22:04:42 -0500538 return "SYSASSERT";
Jeff Garzikbf794512005-07-31 13:07:26 -0400539 case IPW_FW_ERROR_FATAL_ERROR:
James Ketrenosb095c382005-08-24 22:04:42 -0500540 return "FATAL_ERROR";
Jeff Garzikbf794512005-07-31 13:07:26 -0400541 default:
James Ketrenosb095c382005-08-24 22:04:42 -0500542 return "UNKNOWN_ERROR";
James Ketrenos43f66a62005-03-25 12:31:53 -0600543 }
544}
545
James Ketrenosb39860c2005-08-12 09:36:32 -0500546static void ipw_dump_error_log(struct ipw_priv *priv,
547 struct ipw_fw_error *error)
James Ketrenos43f66a62005-03-25 12:31:53 -0600548{
James Ketrenosb39860c2005-08-12 09:36:32 -0500549 u32 i;
James Ketrenos43f66a62005-03-25 12:31:53 -0600550
James Ketrenosb39860c2005-08-12 09:36:32 -0500551 if (!error) {
552 IPW_ERROR("Error allocating and capturing error log. "
553 "Nothing to dump.\n");
554 return;
James Ketrenos43f66a62005-03-25 12:31:53 -0600555 }
556
James Ketrenosb39860c2005-08-12 09:36:32 -0500557 IPW_ERROR("Start IPW Error Log Dump:\n");
558 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
559 error->status, error->config);
James Ketrenos43f66a62005-03-25 12:31:53 -0600560
James Ketrenosb39860c2005-08-12 09:36:32 -0500561 for (i = 0; i < error->elem_len; i++)
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400562 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
James Ketrenosb39860c2005-08-12 09:36:32 -0500563 ipw_error_desc(error->elem[i].desc),
564 error->elem[i].time,
565 error->elem[i].blink1,
566 error->elem[i].blink2,
567 error->elem[i].link1,
568 error->elem[i].link2, error->elem[i].data);
569 for (i = 0; i < error->log_len; i++)
570 IPW_ERROR("%i\t0x%08x\t%i\n",
571 error->log[i].time,
James Ketrenos286568a2005-08-30 10:34:25 -0500572 error->log[i].data, error->log[i].event);
James Ketrenos43f66a62005-03-25 12:31:53 -0600573}
James Ketrenos43f66a62005-03-25 12:31:53 -0600574#endif
James Ketrenos43f66a62005-03-25 12:31:53 -0600575
James Ketrenosc848d0a2005-08-24 21:56:24 -0500576static inline int ipw_is_init(struct ipw_priv *priv)
577{
578 return (priv->status & STATUS_INIT) ? 1 : 0;
James Ketrenos43f66a62005-03-25 12:31:53 -0600579}
580
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400581static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
James Ketrenos43f66a62005-03-25 12:31:53 -0600582{
583 u32 addr, field_info, field_len, field_count, total_len;
584
585 IPW_DEBUG_ORD("ordinal = %i\n", ord);
586
587 if (!priv || !val || !len) {
588 IPW_DEBUG_ORD("Invalid argument\n");
589 return -EINVAL;
590 }
Jeff Garzikbf794512005-07-31 13:07:26 -0400591
James Ketrenos43f66a62005-03-25 12:31:53 -0600592 /* verify device ordinal tables have been initialized */
593 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
594 IPW_DEBUG_ORD("Access ordinals before initialization\n");
595 return -EINVAL;
596 }
597
598 switch (IPW_ORD_TABLE_ID_MASK & ord) {
599 case IPW_ORD_TABLE_0_MASK:
600 /*
601 * TABLE 0: Direct access to a table of 32 bit values
602 *
Jeff Garzikbf794512005-07-31 13:07:26 -0400603 * This is a very simple table with the data directly
James Ketrenos43f66a62005-03-25 12:31:53 -0600604 * read from the table
605 */
606
607 /* remove the table id from the ordinal */
608 ord &= IPW_ORD_TABLE_VALUE_MASK;
609
610 /* boundary check */
611 if (ord > priv->table0_len) {
612 IPW_DEBUG_ORD("ordinal value (%i) longer then "
613 "max (%i)\n", ord, priv->table0_len);
614 return -EINVAL;
615 }
616
617 /* verify we have enough room to store the value */
618 if (*len < sizeof(u32)) {
619 IPW_DEBUG_ORD("ordinal buffer length too small, "
Jiri Bencaaa4d302005-06-07 14:58:41 +0200620 "need %zd\n", sizeof(u32));
James Ketrenos43f66a62005-03-25 12:31:53 -0600621 return -EINVAL;
622 }
623
624 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400625 ord, priv->table0_addr + (ord << 2));
James Ketrenos43f66a62005-03-25 12:31:53 -0600626
627 *len = sizeof(u32);
628 ord <<= 2;
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400629 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
James Ketrenos43f66a62005-03-25 12:31:53 -0600630 break;
631
632 case IPW_ORD_TABLE_1_MASK:
633 /*
634 * TABLE 1: Indirect access to a table of 32 bit values
Jeff Garzikbf794512005-07-31 13:07:26 -0400635 *
636 * This is a fairly large table of u32 values each
James Ketrenos43f66a62005-03-25 12:31:53 -0600637 * representing starting addr for the data (which is
638 * also a u32)
639 */
640
641 /* remove the table id from the ordinal */
642 ord &= IPW_ORD_TABLE_VALUE_MASK;
Jeff Garzikbf794512005-07-31 13:07:26 -0400643
James Ketrenos43f66a62005-03-25 12:31:53 -0600644 /* boundary check */
645 if (ord > priv->table1_len) {
646 IPW_DEBUG_ORD("ordinal value too long\n");
647 return -EINVAL;
648 }
649
650 /* verify we have enough room to store the value */
651 if (*len < sizeof(u32)) {
652 IPW_DEBUG_ORD("ordinal buffer length too small, "
Jiri Bencaaa4d302005-06-07 14:58:41 +0200653 "need %zd\n", sizeof(u32));
James Ketrenos43f66a62005-03-25 12:31:53 -0600654 return -EINVAL;
655 }
656
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400657 *((u32 *) val) =
658 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
James Ketrenos43f66a62005-03-25 12:31:53 -0600659 *len = sizeof(u32);
660 break;
661
662 case IPW_ORD_TABLE_2_MASK:
663 /*
664 * TABLE 2: Indirect access to a table of variable sized values
665 *
666 * This table consist of six values, each containing
667 * - dword containing the starting offset of the data
668 * - dword containing the lengh in the first 16bits
669 * and the count in the second 16bits
670 */
671
672 /* remove the table id from the ordinal */
673 ord &= IPW_ORD_TABLE_VALUE_MASK;
674
675 /* boundary check */
676 if (ord > priv->table2_len) {
677 IPW_DEBUG_ORD("ordinal value too long\n");
678 return -EINVAL;
679 }
680
681 /* get the address of statistic */
682 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
Jeff Garzikbf794512005-07-31 13:07:26 -0400683
684 /* get the second DW of statistics ;
James Ketrenos43f66a62005-03-25 12:31:53 -0600685 * two 16-bit words - first is length, second is count */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400686 field_info =
687 ipw_read_reg32(priv,
688 priv->table2_addr + (ord << 3) +
689 sizeof(u32));
Jeff Garzikbf794512005-07-31 13:07:26 -0400690
James Ketrenos43f66a62005-03-25 12:31:53 -0600691 /* get each entry length */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400692 field_len = *((u16 *) & field_info);
Jeff Garzikbf794512005-07-31 13:07:26 -0400693
James Ketrenos43f66a62005-03-25 12:31:53 -0600694 /* get number of entries */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400695 field_count = *(((u16 *) & field_info) + 1);
Jeff Garzikbf794512005-07-31 13:07:26 -0400696
James Ketrenos43f66a62005-03-25 12:31:53 -0600697 /* abort if not enought memory */
698 total_len = field_len * field_count;
699 if (total_len > *len) {
700 *len = total_len;
701 return -EINVAL;
702 }
Jeff Garzikbf794512005-07-31 13:07:26 -0400703
James Ketrenos43f66a62005-03-25 12:31:53 -0600704 *len = total_len;
705 if (!total_len)
706 return 0;
707
708 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
Jeff Garzikbf794512005-07-31 13:07:26 -0400709 "field_info = 0x%08x\n",
James Ketrenos43f66a62005-03-25 12:31:53 -0600710 addr, total_len, field_info);
711 ipw_read_indirect(priv, addr, val, total_len);
712 break;
713
714 default:
715 IPW_DEBUG_ORD("Invalid ordinal!\n");
716 return -EINVAL;
717
718 }
719
James Ketrenos43f66a62005-03-25 12:31:53 -0600720 return 0;
721}
722
723static void ipw_init_ordinals(struct ipw_priv *priv)
724{
725 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
Jeff Garzikbf794512005-07-31 13:07:26 -0400726 priv->table0_len = ipw_read32(priv, priv->table0_addr);
James Ketrenos43f66a62005-03-25 12:31:53 -0600727
728 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
729 priv->table0_addr, priv->table0_len);
730
731 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
732 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
733
734 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
735 priv->table1_addr, priv->table1_len);
736
737 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
738 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400739 priv->table2_len &= 0x0000ffff; /* use first two bytes */
James Ketrenos43f66a62005-03-25 12:31:53 -0600740
741 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
742 priv->table2_addr, priv->table2_len);
743
744}
745
Adrian Bunka73e22b2006-01-21 01:39:42 +0100746static u32 ipw_register_toggle(u32 reg)
James Ketrenosa613bff2005-08-24 21:43:11 -0500747{
James Ketrenosb095c382005-08-24 22:04:42 -0500748 reg &= ~IPW_START_STANDBY;
749 if (reg & IPW_GATE_ODMA)
750 reg &= ~IPW_GATE_ODMA;
751 if (reg & IPW_GATE_IDMA)
752 reg &= ~IPW_GATE_IDMA;
753 if (reg & IPW_GATE_ADMA)
754 reg &= ~IPW_GATE_ADMA;
James Ketrenosa613bff2005-08-24 21:43:11 -0500755 return reg;
756}
757
758/*
759 * LED behavior:
760 * - On radio ON, turn on any LEDs that require to be on during start
761 * - On initialization, start unassociated blink
762 * - On association, disable unassociated blink
763 * - On disassociation, start unassociated blink
764 * - On radio OFF, turn off any LEDs started during radio on
765 *
766 */
Zhu Yiede61112006-01-24 16:37:10 +0800767#define LD_TIME_LINK_ON msecs_to_jiffies(300)
768#define LD_TIME_LINK_OFF msecs_to_jiffies(2700)
769#define LD_TIME_ACT_ON msecs_to_jiffies(250)
James Ketrenosa613bff2005-08-24 21:43:11 -0500770
Adrian Bunka73e22b2006-01-21 01:39:42 +0100771static void ipw_led_link_on(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -0500772{
773 unsigned long flags;
774 u32 led;
775
776 /* If configured to not use LEDs, or nic_type is 1,
777 * then we don't toggle a LINK led */
778 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
779 return;
780
781 spin_lock_irqsave(&priv->lock, flags);
782
783 if (!(priv->status & STATUS_RF_KILL_MASK) &&
784 !(priv->status & STATUS_LED_LINK_ON)) {
785 IPW_DEBUG_LED("Link LED On\n");
James Ketrenosb095c382005-08-24 22:04:42 -0500786 led = ipw_read_reg32(priv, IPW_EVENT_REG);
James Ketrenosa613bff2005-08-24 21:43:11 -0500787 led |= priv->led_association_on;
788
789 led = ipw_register_toggle(led);
790
791 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
James Ketrenosb095c382005-08-24 22:04:42 -0500792 ipw_write_reg32(priv, IPW_EVENT_REG, led);
James Ketrenosa613bff2005-08-24 21:43:11 -0500793
794 priv->status |= STATUS_LED_LINK_ON;
795
796 /* If we aren't associated, schedule turning the LED off */
797 if (!(priv->status & STATUS_ASSOCIATED))
798 queue_delayed_work(priv->workqueue,
799 &priv->led_link_off,
800 LD_TIME_LINK_ON);
801 }
802
803 spin_unlock_irqrestore(&priv->lock, flags);
804}
805
James Ketrenosc848d0a2005-08-24 21:56:24 -0500806static void ipw_bg_led_link_on(void *data)
807{
808 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +0800809 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -0500810 ipw_led_link_on(data);
Zhu Yi46441512006-01-24 16:37:59 +0800811 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -0500812}
813
Adrian Bunka73e22b2006-01-21 01:39:42 +0100814static void ipw_led_link_off(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -0500815{
816 unsigned long flags;
817 u32 led;
818
819 /* If configured not to use LEDs, or nic type is 1,
820 * then we don't goggle the LINK led. */
821 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
822 return;
823
824 spin_lock_irqsave(&priv->lock, flags);
825
826 if (priv->status & STATUS_LED_LINK_ON) {
James Ketrenosb095c382005-08-24 22:04:42 -0500827 led = ipw_read_reg32(priv, IPW_EVENT_REG);
James Ketrenosa613bff2005-08-24 21:43:11 -0500828 led &= priv->led_association_off;
829 led = ipw_register_toggle(led);
830
831 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
James Ketrenosb095c382005-08-24 22:04:42 -0500832 ipw_write_reg32(priv, IPW_EVENT_REG, led);
James Ketrenosa613bff2005-08-24 21:43:11 -0500833
834 IPW_DEBUG_LED("Link LED Off\n");
835
836 priv->status &= ~STATUS_LED_LINK_ON;
837
838 /* If we aren't associated and the radio is on, schedule
839 * turning the LED on (blink while unassociated) */
840 if (!(priv->status & STATUS_RF_KILL_MASK) &&
841 !(priv->status & STATUS_ASSOCIATED))
842 queue_delayed_work(priv->workqueue, &priv->led_link_on,
843 LD_TIME_LINK_OFF);
844
845 }
846
847 spin_unlock_irqrestore(&priv->lock, flags);
848}
849
James Ketrenosc848d0a2005-08-24 21:56:24 -0500850static void ipw_bg_led_link_off(void *data)
851{
852 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +0800853 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -0500854 ipw_led_link_off(data);
Zhu Yi46441512006-01-24 16:37:59 +0800855 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -0500856}
857
Arjan van de Ven858119e2006-01-14 13:20:43 -0800858static void __ipw_led_activity_on(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -0500859{
James Ketrenosa613bff2005-08-24 21:43:11 -0500860 u32 led;
861
862 if (priv->config & CFG_NO_LED)
863 return;
864
James Ketrenosb095c382005-08-24 22:04:42 -0500865 if (priv->status & STATUS_RF_KILL_MASK)
James Ketrenosa613bff2005-08-24 21:43:11 -0500866 return;
James Ketrenosa613bff2005-08-24 21:43:11 -0500867
868 if (!(priv->status & STATUS_LED_ACT_ON)) {
James Ketrenosb095c382005-08-24 22:04:42 -0500869 led = ipw_read_reg32(priv, IPW_EVENT_REG);
James Ketrenosa613bff2005-08-24 21:43:11 -0500870 led |= priv->led_activity_on;
871
872 led = ipw_register_toggle(led);
873
874 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
James Ketrenosb095c382005-08-24 22:04:42 -0500875 ipw_write_reg32(priv, IPW_EVENT_REG, led);
James Ketrenosa613bff2005-08-24 21:43:11 -0500876
877 IPW_DEBUG_LED("Activity LED On\n");
878
879 priv->status |= STATUS_LED_ACT_ON;
880
James Ketrenosc848d0a2005-08-24 21:56:24 -0500881 cancel_delayed_work(&priv->led_act_off);
James Ketrenosa613bff2005-08-24 21:43:11 -0500882 queue_delayed_work(priv->workqueue, &priv->led_act_off,
883 LD_TIME_ACT_ON);
884 } else {
885 /* Reschedule LED off for full time period */
886 cancel_delayed_work(&priv->led_act_off);
887 queue_delayed_work(priv->workqueue, &priv->led_act_off,
888 LD_TIME_ACT_ON);
889 }
James Ketrenosb095c382005-08-24 22:04:42 -0500890}
James Ketrenosa613bff2005-08-24 21:43:11 -0500891
Adrian Bunka73e22b2006-01-21 01:39:42 +0100892#if 0
James Ketrenosb095c382005-08-24 22:04:42 -0500893void ipw_led_activity_on(struct ipw_priv *priv)
894{
895 unsigned long flags;
896 spin_lock_irqsave(&priv->lock, flags);
897 __ipw_led_activity_on(priv);
James Ketrenosa613bff2005-08-24 21:43:11 -0500898 spin_unlock_irqrestore(&priv->lock, flags);
899}
Adrian Bunka73e22b2006-01-21 01:39:42 +0100900#endif /* 0 */
James Ketrenosa613bff2005-08-24 21:43:11 -0500901
Adrian Bunka73e22b2006-01-21 01:39:42 +0100902static void ipw_led_activity_off(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -0500903{
904 unsigned long flags;
905 u32 led;
906
907 if (priv->config & CFG_NO_LED)
908 return;
909
910 spin_lock_irqsave(&priv->lock, flags);
911
912 if (priv->status & STATUS_LED_ACT_ON) {
James Ketrenosb095c382005-08-24 22:04:42 -0500913 led = ipw_read_reg32(priv, IPW_EVENT_REG);
James Ketrenosa613bff2005-08-24 21:43:11 -0500914 led &= priv->led_activity_off;
915
916 led = ipw_register_toggle(led);
917
918 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
James Ketrenosb095c382005-08-24 22:04:42 -0500919 ipw_write_reg32(priv, IPW_EVENT_REG, led);
James Ketrenosa613bff2005-08-24 21:43:11 -0500920
921 IPW_DEBUG_LED("Activity LED Off\n");
922
923 priv->status &= ~STATUS_LED_ACT_ON;
924 }
925
926 spin_unlock_irqrestore(&priv->lock, flags);
927}
928
James Ketrenosc848d0a2005-08-24 21:56:24 -0500929static void ipw_bg_led_activity_off(void *data)
930{
931 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +0800932 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -0500933 ipw_led_activity_off(data);
Zhu Yi46441512006-01-24 16:37:59 +0800934 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -0500935}
936
Adrian Bunka73e22b2006-01-21 01:39:42 +0100937static void ipw_led_band_on(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -0500938{
939 unsigned long flags;
940 u32 led;
941
942 /* Only nic type 1 supports mode LEDs */
James Ketrenosc848d0a2005-08-24 21:56:24 -0500943 if (priv->config & CFG_NO_LED ||
944 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
James Ketrenosa613bff2005-08-24 21:43:11 -0500945 return;
946
947 spin_lock_irqsave(&priv->lock, flags);
948
James Ketrenosb095c382005-08-24 22:04:42 -0500949 led = ipw_read_reg32(priv, IPW_EVENT_REG);
James Ketrenosa613bff2005-08-24 21:43:11 -0500950 if (priv->assoc_network->mode == IEEE_A) {
951 led |= priv->led_ofdm_on;
952 led &= priv->led_association_off;
953 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
954 } else if (priv->assoc_network->mode == IEEE_G) {
955 led |= priv->led_ofdm_on;
956 led |= priv->led_association_on;
957 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
958 } else {
959 led &= priv->led_ofdm_off;
960 led |= priv->led_association_on;
961 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
962 }
963
964 led = ipw_register_toggle(led);
965
966 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
James Ketrenosb095c382005-08-24 22:04:42 -0500967 ipw_write_reg32(priv, IPW_EVENT_REG, led);
James Ketrenosa613bff2005-08-24 21:43:11 -0500968
969 spin_unlock_irqrestore(&priv->lock, flags);
970}
971
Adrian Bunka73e22b2006-01-21 01:39:42 +0100972static void ipw_led_band_off(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -0500973{
974 unsigned long flags;
975 u32 led;
976
977 /* Only nic type 1 supports mode LEDs */
978 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
979 return;
980
981 spin_lock_irqsave(&priv->lock, flags);
982
James Ketrenosb095c382005-08-24 22:04:42 -0500983 led = ipw_read_reg32(priv, IPW_EVENT_REG);
James Ketrenosa613bff2005-08-24 21:43:11 -0500984 led &= priv->led_ofdm_off;
985 led &= priv->led_association_off;
986
987 led = ipw_register_toggle(led);
988
989 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
James Ketrenosb095c382005-08-24 22:04:42 -0500990 ipw_write_reg32(priv, IPW_EVENT_REG, led);
James Ketrenosa613bff2005-08-24 21:43:11 -0500991
992 spin_unlock_irqrestore(&priv->lock, flags);
993}
994
Adrian Bunka73e22b2006-01-21 01:39:42 +0100995static void ipw_led_radio_on(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -0500996{
997 ipw_led_link_on(priv);
998}
999
Adrian Bunka73e22b2006-01-21 01:39:42 +01001000static void ipw_led_radio_off(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -05001001{
1002 ipw_led_activity_off(priv);
1003 ipw_led_link_off(priv);
1004}
1005
Adrian Bunka73e22b2006-01-21 01:39:42 +01001006static void ipw_led_link_up(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -05001007{
1008 /* Set the Link Led on for all nic types */
1009 ipw_led_link_on(priv);
1010}
1011
Adrian Bunka73e22b2006-01-21 01:39:42 +01001012static void ipw_led_link_down(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -05001013{
1014 ipw_led_activity_off(priv);
1015 ipw_led_link_off(priv);
1016
1017 if (priv->status & STATUS_RF_KILL_MASK)
1018 ipw_led_radio_off(priv);
1019}
1020
Adrian Bunka73e22b2006-01-21 01:39:42 +01001021static void ipw_led_init(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -05001022{
1023 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1024
1025 /* Set the default PINs for the link and activity leds */
James Ketrenosb095c382005-08-24 22:04:42 -05001026 priv->led_activity_on = IPW_ACTIVITY_LED;
1027 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
James Ketrenosa613bff2005-08-24 21:43:11 -05001028
James Ketrenosb095c382005-08-24 22:04:42 -05001029 priv->led_association_on = IPW_ASSOCIATED_LED;
1030 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
James Ketrenosa613bff2005-08-24 21:43:11 -05001031
1032 /* Set the default PINs for the OFDM leds */
James Ketrenosb095c382005-08-24 22:04:42 -05001033 priv->led_ofdm_on = IPW_OFDM_LED;
1034 priv->led_ofdm_off = ~(IPW_OFDM_LED);
James Ketrenosa613bff2005-08-24 21:43:11 -05001035
1036 switch (priv->nic_type) {
1037 case EEPROM_NIC_TYPE_1:
1038 /* In this NIC type, the LEDs are reversed.... */
James Ketrenosb095c382005-08-24 22:04:42 -05001039 priv->led_activity_on = IPW_ASSOCIATED_LED;
1040 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1041 priv->led_association_on = IPW_ACTIVITY_LED;
1042 priv->led_association_off = ~(IPW_ACTIVITY_LED);
James Ketrenosa613bff2005-08-24 21:43:11 -05001043
1044 if (!(priv->config & CFG_NO_LED))
1045 ipw_led_band_on(priv);
1046
1047 /* And we don't blink link LEDs for this nic, so
1048 * just return here */
1049 return;
1050
1051 case EEPROM_NIC_TYPE_3:
1052 case EEPROM_NIC_TYPE_2:
1053 case EEPROM_NIC_TYPE_4:
1054 case EEPROM_NIC_TYPE_0:
1055 break;
1056
1057 default:
1058 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1059 priv->nic_type);
1060 priv->nic_type = EEPROM_NIC_TYPE_0;
1061 break;
1062 }
1063
1064 if (!(priv->config & CFG_NO_LED)) {
1065 if (priv->status & STATUS_ASSOCIATED)
1066 ipw_led_link_on(priv);
1067 else
1068 ipw_led_link_off(priv);
1069 }
1070}
1071
Adrian Bunka73e22b2006-01-21 01:39:42 +01001072static void ipw_led_shutdown(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -05001073{
James Ketrenosa613bff2005-08-24 21:43:11 -05001074 ipw_led_activity_off(priv);
1075 ipw_led_link_off(priv);
1076 ipw_led_band_off(priv);
James Ketrenosafbf30a2005-08-25 00:05:33 -05001077 cancel_delayed_work(&priv->led_link_on);
1078 cancel_delayed_work(&priv->led_link_off);
1079 cancel_delayed_work(&priv->led_act_off);
James Ketrenosa613bff2005-08-24 21:43:11 -05001080}
1081
James Ketrenos43f66a62005-03-25 12:31:53 -06001082/*
1083 * The following adds a new attribute to the sysfs representation
1084 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1085 * used for controling the debug level.
Jeff Garzikbf794512005-07-31 13:07:26 -04001086 *
James Ketrenos43f66a62005-03-25 12:31:53 -06001087 * See the level definitions in ipw for details.
1088 */
1089static ssize_t show_debug_level(struct device_driver *d, char *buf)
1090{
1091 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1092}
James Ketrenosa613bff2005-08-24 21:43:11 -05001093
1094static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1095 size_t count)
James Ketrenos43f66a62005-03-25 12:31:53 -06001096{
1097 char *p = (char *)buf;
1098 u32 val;
1099
1100 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1101 p++;
1102 if (p[0] == 'x' || p[0] == 'X')
1103 p++;
1104 val = simple_strtoul(p, &p, 16);
1105 } else
1106 val = simple_strtoul(p, &p, 10);
Jeff Garzikbf794512005-07-31 13:07:26 -04001107 if (p == buf)
1108 printk(KERN_INFO DRV_NAME
James Ketrenos43f66a62005-03-25 12:31:53 -06001109 ": %s is not in hex or decimal form.\n", buf);
1110 else
1111 ipw_debug_level = val;
1112
1113 return strnlen(buf, count);
1114}
1115
Jeff Garzikbf794512005-07-31 13:07:26 -04001116static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
James Ketrenos43f66a62005-03-25 12:31:53 -06001117 show_debug_level, store_debug_level);
1118
James Ketrenosb39860c2005-08-12 09:36:32 -05001119static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
1120{
Zhu Yic8fe6672006-01-24 16:36:36 +08001121 /* length = 1st dword in log */
James Ketrenosb39860c2005-08-12 09:36:32 -05001122 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
1123}
1124
1125static void ipw_capture_event_log(struct ipw_priv *priv,
1126 u32 log_len, struct ipw_event *log)
1127{
1128 u32 base;
1129
1130 if (log_len) {
1131 base = ipw_read32(priv, IPW_EVENT_LOG);
1132 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1133 (u8 *) log, sizeof(*log) * log_len);
1134 }
1135}
1136
1137static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
1138{
1139 struct ipw_fw_error *error;
1140 u32 log_len = ipw_get_event_log_len(priv);
1141 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1142 u32 elem_len = ipw_read_reg32(priv, base);
1143
1144 error = kmalloc(sizeof(*error) +
1145 sizeof(*error->elem) * elem_len +
1146 sizeof(*error->log) * log_len, GFP_ATOMIC);
1147 if (!error) {
1148 IPW_ERROR("Memory allocation for firmware error log "
1149 "failed.\n");
1150 return NULL;
1151 }
James Ketrenosf6c5cb72005-08-25 00:39:09 -05001152 error->jiffies = jiffies;
James Ketrenosb39860c2005-08-12 09:36:32 -05001153 error->status = priv->status;
1154 error->config = priv->config;
1155 error->elem_len = elem_len;
1156 error->log_len = log_len;
1157 error->elem = (struct ipw_error_elem *)error->payload;
Zhu Yi3b26b112005-11-17 13:58:30 +08001158 error->log = (struct ipw_event *)(error->elem + elem_len);
James Ketrenosb39860c2005-08-12 09:36:32 -05001159
1160 ipw_capture_event_log(priv, log_len, error->log);
1161
1162 if (elem_len)
1163 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1164 sizeof(*error->elem) * elem_len);
1165
1166 return error;
1167}
1168
1169static void ipw_free_error_log(struct ipw_fw_error *error)
1170{
1171 if (error)
1172 kfree(error);
1173}
1174
1175static ssize_t show_event_log(struct device *d,
1176 struct device_attribute *attr, char *buf)
1177{
1178 struct ipw_priv *priv = dev_get_drvdata(d);
1179 u32 log_len = ipw_get_event_log_len(priv);
1180 struct ipw_event log[log_len];
1181 u32 len = 0, i;
1182
1183 ipw_capture_event_log(priv, log_len, log);
1184
1185 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1186 for (i = 0; i < log_len; i++)
1187 len += snprintf(buf + len, PAGE_SIZE - len,
1188 "\n%08X%08X%08X",
1189 log[i].time, log[i].event, log[i].data);
1190 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1191 return len;
1192}
1193
1194static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
1195
1196static ssize_t show_error(struct device *d,
1197 struct device_attribute *attr, char *buf)
1198{
1199 struct ipw_priv *priv = dev_get_drvdata(d);
1200 u32 len = 0, i;
1201 if (!priv->error)
1202 return 0;
1203 len += snprintf(buf + len, PAGE_SIZE - len,
James Ketrenosf6c5cb72005-08-25 00:39:09 -05001204 "%08lX%08X%08X%08X",
1205 priv->error->jiffies,
James Ketrenosb39860c2005-08-12 09:36:32 -05001206 priv->error->status,
1207 priv->error->config, priv->error->elem_len);
1208 for (i = 0; i < priv->error->elem_len; i++)
1209 len += snprintf(buf + len, PAGE_SIZE - len,
1210 "\n%08X%08X%08X%08X%08X%08X%08X",
1211 priv->error->elem[i].time,
1212 priv->error->elem[i].desc,
1213 priv->error->elem[i].blink1,
1214 priv->error->elem[i].blink2,
1215 priv->error->elem[i].link1,
1216 priv->error->elem[i].link2,
1217 priv->error->elem[i].data);
1218
1219 len += snprintf(buf + len, PAGE_SIZE - len,
1220 "\n%08X", priv->error->log_len);
1221 for (i = 0; i < priv->error->log_len; i++)
1222 len += snprintf(buf + len, PAGE_SIZE - len,
1223 "\n%08X%08X%08X",
1224 priv->error->log[i].time,
1225 priv->error->log[i].event,
1226 priv->error->log[i].data);
1227 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1228 return len;
1229}
1230
1231static ssize_t clear_error(struct device *d,
1232 struct device_attribute *attr,
1233 const char *buf, size_t count)
1234{
1235 struct ipw_priv *priv = dev_get_drvdata(d);
1236 if (priv->error) {
1237 ipw_free_error_log(priv->error);
1238 priv->error = NULL;
1239 }
1240 return count;
1241}
1242
1243static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
1244
James Ketrenosf6c5cb72005-08-25 00:39:09 -05001245static ssize_t show_cmd_log(struct device *d,
1246 struct device_attribute *attr, char *buf)
1247{
1248 struct ipw_priv *priv = dev_get_drvdata(d);
1249 u32 len = 0, i;
1250 if (!priv->cmdlog)
1251 return 0;
1252 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1253 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1254 i = (i + 1) % priv->cmdlog_len) {
1255 len +=
1256 snprintf(buf + len, PAGE_SIZE - len,
1257 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1258 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1259 priv->cmdlog[i].cmd.len);
1260 len +=
1261 snprintk_buf(buf + len, PAGE_SIZE - len,
1262 (u8 *) priv->cmdlog[i].cmd.param,
1263 priv->cmdlog[i].cmd.len);
1264 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1265 }
1266 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1267 return len;
1268}
1269
1270static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
1271
James Ketrenosa613bff2005-08-24 21:43:11 -05001272static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1273 char *buf)
1274{
1275 struct ipw_priv *priv = dev_get_drvdata(d);
1276 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1277}
1278
1279static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1280 const char *buf, size_t count)
1281{
1282 struct ipw_priv *priv = dev_get_drvdata(d);
Brice Goglin0f52bf92005-12-01 01:41:46 -08001283#ifdef CONFIG_IPW2200_DEBUG
James Ketrenosa613bff2005-08-24 21:43:11 -05001284 struct net_device *dev = priv->net_dev;
James Ketrenosc848d0a2005-08-24 21:56:24 -05001285#endif
James Ketrenosa613bff2005-08-24 21:43:11 -05001286 char buffer[] = "00000000";
1287 unsigned long len =
1288 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1289 unsigned long val;
1290 char *p = buffer;
1291
1292 IPW_DEBUG_INFO("enter\n");
1293
1294 strncpy(buffer, buf, len);
1295 buffer[len] = 0;
1296
1297 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1298 p++;
1299 if (p[0] == 'x' || p[0] == 'X')
1300 p++;
1301 val = simple_strtoul(p, &p, 16);
1302 } else
1303 val = simple_strtoul(p, &p, 10);
1304 if (p == buffer) {
1305 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1306 } else {
1307 priv->ieee->scan_age = val;
1308 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1309 }
1310
1311 IPW_DEBUG_INFO("exit\n");
1312 return len;
1313}
1314
1315static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1316
1317static ssize_t show_led(struct device *d, struct device_attribute *attr,
1318 char *buf)
1319{
1320 struct ipw_priv *priv = dev_get_drvdata(d);
1321 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1322}
1323
1324static ssize_t store_led(struct device *d, struct device_attribute *attr,
1325 const char *buf, size_t count)
1326{
1327 struct ipw_priv *priv = dev_get_drvdata(d);
1328
1329 IPW_DEBUG_INFO("enter\n");
1330
1331 if (count == 0)
1332 return 0;
1333
1334 if (*buf == 0) {
1335 IPW_DEBUG_LED("Disabling LED control.\n");
1336 priv->config |= CFG_NO_LED;
1337 ipw_led_shutdown(priv);
1338 } else {
1339 IPW_DEBUG_LED("Enabling LED control.\n");
1340 priv->config &= ~CFG_NO_LED;
1341 ipw_led_init(priv);
1342 }
1343
1344 IPW_DEBUG_INFO("exit\n");
1345 return count;
1346}
1347
1348static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1349
Andrew Mortonad3fee52005-06-20 14:30:36 -07001350static ssize_t show_status(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001351 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001352{
Andrew Mortonad3fee52005-06-20 14:30:36 -07001353 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001354 return sprintf(buf, "0x%08x\n", (int)p->status);
1355}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001356
James Ketrenos43f66a62005-03-25 12:31:53 -06001357static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1358
Andrew Mortonad3fee52005-06-20 14:30:36 -07001359static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1360 char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001361{
Andrew Mortonad3fee52005-06-20 14:30:36 -07001362 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001363 return sprintf(buf, "0x%08x\n", (int)p->config);
1364}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001365
James Ketrenos43f66a62005-03-25 12:31:53 -06001366static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1367
Andrew Mortonad3fee52005-06-20 14:30:36 -07001368static ssize_t show_nic_type(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001369 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001370{
James Ketrenosa613bff2005-08-24 21:43:11 -05001371 struct ipw_priv *priv = d->driver_data;
1372 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
James Ketrenos43f66a62005-03-25 12:31:53 -06001373}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001374
James Ketrenos43f66a62005-03-25 12:31:53 -06001375static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1376
Andrew Mortonad3fee52005-06-20 14:30:36 -07001377static ssize_t show_ucode_version(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001378 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001379{
1380 u32 len = sizeof(u32), tmp = 0;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001381 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001382
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001383 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
James Ketrenos43f66a62005-03-25 12:31:53 -06001384 return 0;
1385
1386 return sprintf(buf, "0x%08x\n", tmp);
1387}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001388
1389static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
James Ketrenos43f66a62005-03-25 12:31:53 -06001390
Andrew Mortonad3fee52005-06-20 14:30:36 -07001391static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1392 char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001393{
1394 u32 len = sizeof(u32), tmp = 0;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001395 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001396
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001397 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
James Ketrenos43f66a62005-03-25 12:31:53 -06001398 return 0;
1399
1400 return sprintf(buf, "0x%08x\n", tmp);
1401}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001402
1403static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
James Ketrenos43f66a62005-03-25 12:31:53 -06001404
1405/*
1406 * Add a device attribute to view/control the delay between eeprom
1407 * operations.
1408 */
Andrew Mortonad3fee52005-06-20 14:30:36 -07001409static ssize_t show_eeprom_delay(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001410 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001411{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001412 int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
James Ketrenos43f66a62005-03-25 12:31:53 -06001413 return sprintf(buf, "%i\n", n);
1414}
Andrew Mortonad3fee52005-06-20 14:30:36 -07001415static ssize_t store_eeprom_delay(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001416 struct device_attribute *attr,
1417 const char *buf, size_t count)
James Ketrenos43f66a62005-03-25 12:31:53 -06001418{
Andrew Mortonad3fee52005-06-20 14:30:36 -07001419 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001420 sscanf(buf, "%i", &p->eeprom_delay);
1421 return strnlen(buf, count);
1422}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001423
1424static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1425 show_eeprom_delay, store_eeprom_delay);
James Ketrenos43f66a62005-03-25 12:31:53 -06001426
Andrew Mortonad3fee52005-06-20 14:30:36 -07001427static ssize_t show_command_event_reg(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001428 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001429{
1430 u32 reg = 0;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001431 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001432
James Ketrenosb095c382005-08-24 22:04:42 -05001433 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
James Ketrenos43f66a62005-03-25 12:31:53 -06001434 return sprintf(buf, "0x%08x\n", reg);
1435}
Andrew Mortonad3fee52005-06-20 14:30:36 -07001436static ssize_t store_command_event_reg(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001437 struct device_attribute *attr,
1438 const char *buf, size_t count)
James Ketrenos43f66a62005-03-25 12:31:53 -06001439{
1440 u32 reg;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001441 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001442
1443 sscanf(buf, "%x", &reg);
James Ketrenosb095c382005-08-24 22:04:42 -05001444 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
James Ketrenos43f66a62005-03-25 12:31:53 -06001445 return strnlen(buf, count);
1446}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001447
1448static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1449 show_command_event_reg, store_command_event_reg);
James Ketrenos43f66a62005-03-25 12:31:53 -06001450
Andrew Mortonad3fee52005-06-20 14:30:36 -07001451static ssize_t show_mem_gpio_reg(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001452 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001453{
1454 u32 reg = 0;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001455 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001456
1457 reg = ipw_read_reg32(p, 0x301100);
1458 return sprintf(buf, "0x%08x\n", reg);
1459}
Andrew Mortonad3fee52005-06-20 14:30:36 -07001460static ssize_t store_mem_gpio_reg(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001461 struct device_attribute *attr,
1462 const char *buf, size_t count)
James Ketrenos43f66a62005-03-25 12:31:53 -06001463{
1464 u32 reg;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001465 struct ipw_priv *p = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001466
1467 sscanf(buf, "%x", &reg);
1468 ipw_write_reg32(p, 0x301100, reg);
1469 return strnlen(buf, count);
1470}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001471
1472static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1473 show_mem_gpio_reg, store_mem_gpio_reg);
James Ketrenos43f66a62005-03-25 12:31:53 -06001474
Andrew Mortonad3fee52005-06-20 14:30:36 -07001475static ssize_t show_indirect_dword(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001476 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001477{
1478 u32 reg = 0;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001479 struct ipw_priv *priv = d->driver_data;
James Ketrenosafbf30a2005-08-25 00:05:33 -05001480
Jeff Garzikbf794512005-07-31 13:07:26 -04001481 if (priv->status & STATUS_INDIRECT_DWORD)
James Ketrenos43f66a62005-03-25 12:31:53 -06001482 reg = ipw_read_reg32(priv, priv->indirect_dword);
Jeff Garzikbf794512005-07-31 13:07:26 -04001483 else
James Ketrenos43f66a62005-03-25 12:31:53 -06001484 reg = 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04001485
James Ketrenos43f66a62005-03-25 12:31:53 -06001486 return sprintf(buf, "0x%08x\n", reg);
1487}
Andrew Mortonad3fee52005-06-20 14:30:36 -07001488static ssize_t store_indirect_dword(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001489 struct device_attribute *attr,
1490 const char *buf, size_t count)
James Ketrenos43f66a62005-03-25 12:31:53 -06001491{
Andrew Mortonad3fee52005-06-20 14:30:36 -07001492 struct ipw_priv *priv = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001493
1494 sscanf(buf, "%x", &priv->indirect_dword);
1495 priv->status |= STATUS_INDIRECT_DWORD;
1496 return strnlen(buf, count);
1497}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001498
1499static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1500 show_indirect_dword, store_indirect_dword);
James Ketrenos43f66a62005-03-25 12:31:53 -06001501
Andrew Mortonad3fee52005-06-20 14:30:36 -07001502static ssize_t show_indirect_byte(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001503 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001504{
1505 u8 reg = 0;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001506 struct ipw_priv *priv = d->driver_data;
James Ketrenosafbf30a2005-08-25 00:05:33 -05001507
Jeff Garzikbf794512005-07-31 13:07:26 -04001508 if (priv->status & STATUS_INDIRECT_BYTE)
James Ketrenos43f66a62005-03-25 12:31:53 -06001509 reg = ipw_read_reg8(priv, priv->indirect_byte);
Jeff Garzikbf794512005-07-31 13:07:26 -04001510 else
James Ketrenos43f66a62005-03-25 12:31:53 -06001511 reg = 0;
1512
1513 return sprintf(buf, "0x%02x\n", reg);
1514}
Andrew Mortonad3fee52005-06-20 14:30:36 -07001515static ssize_t store_indirect_byte(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001516 struct device_attribute *attr,
1517 const char *buf, size_t count)
James Ketrenos43f66a62005-03-25 12:31:53 -06001518{
Andrew Mortonad3fee52005-06-20 14:30:36 -07001519 struct ipw_priv *priv = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001520
1521 sscanf(buf, "%x", &priv->indirect_byte);
1522 priv->status |= STATUS_INDIRECT_BYTE;
1523 return strnlen(buf, count);
1524}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001525
1526static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
James Ketrenos43f66a62005-03-25 12:31:53 -06001527 show_indirect_byte, store_indirect_byte);
1528
Andrew Mortonad3fee52005-06-20 14:30:36 -07001529static ssize_t show_direct_dword(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001530 struct device_attribute *attr, char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001531{
1532 u32 reg = 0;
Andrew Mortonad3fee52005-06-20 14:30:36 -07001533 struct ipw_priv *priv = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001534
Jeff Garzikbf794512005-07-31 13:07:26 -04001535 if (priv->status & STATUS_DIRECT_DWORD)
James Ketrenos43f66a62005-03-25 12:31:53 -06001536 reg = ipw_read32(priv, priv->direct_dword);
Jeff Garzikbf794512005-07-31 13:07:26 -04001537 else
James Ketrenos43f66a62005-03-25 12:31:53 -06001538 reg = 0;
1539
1540 return sprintf(buf, "0x%08x\n", reg);
1541}
Andrew Mortonad3fee52005-06-20 14:30:36 -07001542static ssize_t store_direct_dword(struct device *d,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001543 struct device_attribute *attr,
1544 const char *buf, size_t count)
James Ketrenos43f66a62005-03-25 12:31:53 -06001545{
Andrew Mortonad3fee52005-06-20 14:30:36 -07001546 struct ipw_priv *priv = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001547
1548 sscanf(buf, "%x", &priv->direct_dword);
1549 priv->status |= STATUS_DIRECT_DWORD;
1550 return strnlen(buf, count);
1551}
James Ketrenos43f66a62005-03-25 12:31:53 -06001552
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001553static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1554 show_direct_dword, store_direct_dword);
James Ketrenos43f66a62005-03-25 12:31:53 -06001555
Arjan van de Ven858119e2006-01-14 13:20:43 -08001556static int rf_kill_active(struct ipw_priv *priv)
James Ketrenos43f66a62005-03-25 12:31:53 -06001557{
1558 if (0 == (ipw_read32(priv, 0x30) & 0x10000))
1559 priv->status |= STATUS_RF_KILL_HW;
1560 else
1561 priv->status &= ~STATUS_RF_KILL_HW;
1562
1563 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1564}
1565
Andrew Mortonad3fee52005-06-20 14:30:36 -07001566static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001567 char *buf)
James Ketrenos43f66a62005-03-25 12:31:53 -06001568{
1569 /* 0 - RF kill not enabled
Jeff Garzikbf794512005-07-31 13:07:26 -04001570 1 - SW based RF kill active (sysfs)
James Ketrenos43f66a62005-03-25 12:31:53 -06001571 2 - HW based RF kill active
1572 3 - Both HW and SW baed RF kill active */
Andrew Mortonad3fee52005-06-20 14:30:36 -07001573 struct ipw_priv *priv = d->driver_data;
James Ketrenos43f66a62005-03-25 12:31:53 -06001574 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001575 (rf_kill_active(priv) ? 0x2 : 0x0);
James Ketrenos43f66a62005-03-25 12:31:53 -06001576 return sprintf(buf, "%i\n", val);
1577}
1578
1579static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1580{
Jeff Garzikbf794512005-07-31 13:07:26 -04001581 if ((disable_radio ? 1 : 0) ==
James Ketrenosea2b26e2005-08-24 21:25:16 -05001582 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001583 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06001584
1585 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1586 disable_radio ? "OFF" : "ON");
1587
1588 if (disable_radio) {
1589 priv->status |= STATUS_RF_KILL_SW;
1590
James Ketrenosa613bff2005-08-24 21:43:11 -05001591 if (priv->workqueue)
James Ketrenos43f66a62005-03-25 12:31:53 -06001592 cancel_delayed_work(&priv->request_scan);
James Ketrenos43f66a62005-03-25 12:31:53 -06001593 queue_work(priv->workqueue, &priv->down);
1594 } else {
1595 priv->status &= ~STATUS_RF_KILL_SW;
1596 if (rf_kill_active(priv)) {
1597 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1598 "disabled by HW switch\n");
1599 /* Make sure the RF_KILL check timer is running */
1600 cancel_delayed_work(&priv->rf_kill);
Jeff Garzikbf794512005-07-31 13:07:26 -04001601 queue_delayed_work(priv->workqueue, &priv->rf_kill,
James Ketrenos43f66a62005-03-25 12:31:53 -06001602 2 * HZ);
Jeff Garzikbf794512005-07-31 13:07:26 -04001603 } else
James Ketrenos43f66a62005-03-25 12:31:53 -06001604 queue_work(priv->workqueue, &priv->up);
1605 }
1606
1607 return 1;
1608}
1609
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001610static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1611 const char *buf, size_t count)
James Ketrenos43f66a62005-03-25 12:31:53 -06001612{
Andrew Mortonad3fee52005-06-20 14:30:36 -07001613 struct ipw_priv *priv = d->driver_data;
Jeff Garzikbf794512005-07-31 13:07:26 -04001614
James Ketrenos43f66a62005-03-25 12:31:53 -06001615 ipw_radio_kill_sw(priv, buf[0] == '1');
1616
1617 return count;
1618}
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001619
1620static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
James Ketrenos43f66a62005-03-25 12:31:53 -06001621
James Ketrenosb095c382005-08-24 22:04:42 -05001622static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1623 char *buf)
1624{
1625 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1626 int pos = 0, len = 0;
1627 if (priv->config & CFG_SPEED_SCAN) {
1628 while (priv->speed_scan[pos] != 0)
1629 len += sprintf(&buf[len], "%d ",
1630 priv->speed_scan[pos++]);
1631 return len + sprintf(&buf[len], "\n");
1632 }
1633
1634 return sprintf(buf, "0\n");
1635}
1636
1637static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1638 const char *buf, size_t count)
1639{
1640 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1641 int channel, pos = 0;
1642 const char *p = buf;
1643
1644 /* list of space separated channels to scan, optionally ending with 0 */
1645 while ((channel = simple_strtol(p, NULL, 0))) {
1646 if (pos == MAX_SPEED_SCAN - 1) {
1647 priv->speed_scan[pos] = 0;
1648 break;
1649 }
1650
Larry Finger1867b112006-02-28 09:48:28 -06001651 if (ieee80211_is_valid_channel(priv->ieee, channel))
James Ketrenosb095c382005-08-24 22:04:42 -05001652 priv->speed_scan[pos++] = channel;
1653 else
1654 IPW_WARNING("Skipping invalid channel request: %d\n",
1655 channel);
1656 p = strchr(p, ' ');
1657 if (!p)
1658 break;
1659 while (*p == ' ' || *p == '\t')
1660 p++;
1661 }
1662
1663 if (pos == 0)
1664 priv->config &= ~CFG_SPEED_SCAN;
1665 else {
1666 priv->speed_scan_pos = 0;
1667 priv->config |= CFG_SPEED_SCAN;
1668 }
1669
1670 return count;
1671}
1672
1673static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1674 store_speed_scan);
1675
1676static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1677 char *buf)
1678{
1679 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1680 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1681}
1682
1683static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1684 const char *buf, size_t count)
1685{
1686 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1687 if (buf[0] == '1')
1688 priv->config |= CFG_NET_STATS;
1689 else
1690 priv->config &= ~CFG_NET_STATS;
1691
1692 return count;
1693}
1694
James Ketrenosafbf30a2005-08-25 00:05:33 -05001695static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1696 show_net_stats, store_net_stats);
James Ketrenosb095c382005-08-24 22:04:42 -05001697
James Ketrenosea2b26e2005-08-24 21:25:16 -05001698static void notify_wx_assoc_event(struct ipw_priv *priv)
1699{
1700 union iwreq_data wrqu;
1701 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1702 if (priv->status & STATUS_ASSOCIATED)
1703 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1704 else
1705 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1706 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1707}
1708
James Ketrenos43f66a62005-03-25 12:31:53 -06001709static void ipw_irq_tasklet(struct ipw_priv *priv)
1710{
1711 u32 inta, inta_mask, handled = 0;
1712 unsigned long flags;
1713 int rc = 0;
1714
1715 spin_lock_irqsave(&priv->lock, flags);
1716
James Ketrenosb095c382005-08-24 22:04:42 -05001717 inta = ipw_read32(priv, IPW_INTA_RW);
1718 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1719 inta &= (IPW_INTA_MASK_ALL & inta_mask);
James Ketrenos43f66a62005-03-25 12:31:53 -06001720
1721 /* Add any cached INTA values that need to be handled */
1722 inta |= priv->isr_inta;
1723
1724 /* handle all the justifications for the interrupt */
James Ketrenosb095c382005-08-24 22:04:42 -05001725 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001726 ipw_rx(priv);
James Ketrenosb095c382005-08-24 22:04:42 -05001727 handled |= IPW_INTA_BIT_RX_TRANSFER;
James Ketrenos43f66a62005-03-25 12:31:53 -06001728 }
1729
James Ketrenosb095c382005-08-24 22:04:42 -05001730 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001731 IPW_DEBUG_HC("Command completed.\n");
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001732 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
James Ketrenos43f66a62005-03-25 12:31:53 -06001733 priv->status &= ~STATUS_HCMD_ACTIVE;
1734 wake_up_interruptible(&priv->wait_command_queue);
James Ketrenosb095c382005-08-24 22:04:42 -05001735 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
James Ketrenos43f66a62005-03-25 12:31:53 -06001736 }
1737
James Ketrenosb095c382005-08-24 22:04:42 -05001738 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001739 IPW_DEBUG_TX("TX_QUEUE_1\n");
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001740 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
James Ketrenosb095c382005-08-24 22:04:42 -05001741 handled |= IPW_INTA_BIT_TX_QUEUE_1;
James Ketrenos43f66a62005-03-25 12:31:53 -06001742 }
1743
James Ketrenosb095c382005-08-24 22:04:42 -05001744 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001745 IPW_DEBUG_TX("TX_QUEUE_2\n");
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001746 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
James Ketrenosb095c382005-08-24 22:04:42 -05001747 handled |= IPW_INTA_BIT_TX_QUEUE_2;
James Ketrenos43f66a62005-03-25 12:31:53 -06001748 }
1749
James Ketrenosb095c382005-08-24 22:04:42 -05001750 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001751 IPW_DEBUG_TX("TX_QUEUE_3\n");
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001752 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
James Ketrenosb095c382005-08-24 22:04:42 -05001753 handled |= IPW_INTA_BIT_TX_QUEUE_3;
James Ketrenos43f66a62005-03-25 12:31:53 -06001754 }
1755
James Ketrenosb095c382005-08-24 22:04:42 -05001756 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001757 IPW_DEBUG_TX("TX_QUEUE_4\n");
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001758 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
James Ketrenosb095c382005-08-24 22:04:42 -05001759 handled |= IPW_INTA_BIT_TX_QUEUE_4;
James Ketrenos43f66a62005-03-25 12:31:53 -06001760 }
1761
James Ketrenosb095c382005-08-24 22:04:42 -05001762 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001763 IPW_WARNING("STATUS_CHANGE\n");
James Ketrenosb095c382005-08-24 22:04:42 -05001764 handled |= IPW_INTA_BIT_STATUS_CHANGE;
James Ketrenos43f66a62005-03-25 12:31:53 -06001765 }
1766
James Ketrenosb095c382005-08-24 22:04:42 -05001767 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001768 IPW_WARNING("TX_PERIOD_EXPIRED\n");
James Ketrenosb095c382005-08-24 22:04:42 -05001769 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
James Ketrenos43f66a62005-03-25 12:31:53 -06001770 }
1771
James Ketrenosb095c382005-08-24 22:04:42 -05001772 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001773 IPW_WARNING("HOST_CMD_DONE\n");
James Ketrenosb095c382005-08-24 22:04:42 -05001774 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
James Ketrenos43f66a62005-03-25 12:31:53 -06001775 }
1776
James Ketrenosb095c382005-08-24 22:04:42 -05001777 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001778 IPW_WARNING("FW_INITIALIZATION_DONE\n");
James Ketrenosb095c382005-08-24 22:04:42 -05001779 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
James Ketrenos43f66a62005-03-25 12:31:53 -06001780 }
1781
James Ketrenosb095c382005-08-24 22:04:42 -05001782 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001783 IPW_WARNING("PHY_OFF_DONE\n");
James Ketrenosb095c382005-08-24 22:04:42 -05001784 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
James Ketrenos43f66a62005-03-25 12:31:53 -06001785 }
1786
James Ketrenosb095c382005-08-24 22:04:42 -05001787 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001788 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1789 priv->status |= STATUS_RF_KILL_HW;
1790 wake_up_interruptible(&priv->wait_command_queue);
James Ketrenosea2b26e2005-08-24 21:25:16 -05001791 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
James Ketrenos43f66a62005-03-25 12:31:53 -06001792 cancel_delayed_work(&priv->request_scan);
James Ketrenosa613bff2005-08-24 21:43:11 -05001793 schedule_work(&priv->link_down);
James Ketrenos43f66a62005-03-25 12:31:53 -06001794 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
James Ketrenosb095c382005-08-24 22:04:42 -05001795 handled |= IPW_INTA_BIT_RF_KILL_DONE;
James Ketrenos43f66a62005-03-25 12:31:53 -06001796 }
Jeff Garzikbf794512005-07-31 13:07:26 -04001797
James Ketrenosb095c382005-08-24 22:04:42 -05001798 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001799 IPW_ERROR("Firmware error detected. Restarting.\n");
James Ketrenosb39860c2005-08-12 09:36:32 -05001800 if (priv->error) {
1801 IPW_ERROR("Sysfs 'error' log already exists.\n");
Brice Goglin0f52bf92005-12-01 01:41:46 -08001802#ifdef CONFIG_IPW2200_DEBUG
James Ketrenosb39860c2005-08-12 09:36:32 -05001803 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1804 struct ipw_fw_error *error =
1805 ipw_alloc_error_log(priv);
1806 ipw_dump_error_log(priv, error);
1807 if (error)
1808 ipw_free_error_log(error);
1809 }
James Ketrenos43f66a62005-03-25 12:31:53 -06001810#endif
James Ketrenosb39860c2005-08-12 09:36:32 -05001811 } else {
1812 priv->error = ipw_alloc_error_log(priv);
1813 if (priv->error)
1814 IPW_ERROR("Sysfs 'error' log captured.\n");
1815 else
1816 IPW_ERROR("Error allocating sysfs 'error' "
1817 "log.\n");
Brice Goglin0f52bf92005-12-01 01:41:46 -08001818#ifdef CONFIG_IPW2200_DEBUG
James Ketrenosb39860c2005-08-12 09:36:32 -05001819 if (ipw_debug_level & IPW_DL_FW_ERRORS)
1820 ipw_dump_error_log(priv, priv->error);
1821#endif
1822 }
1823
James Ketrenosb095c382005-08-24 22:04:42 -05001824 /* XXX: If hardware encryption is for WPA/WPA2,
1825 * we have to notify the supplicant. */
1826 if (priv->ieee->sec.encrypt) {
1827 priv->status &= ~STATUS_ASSOCIATED;
1828 notify_wx_assoc_event(priv);
1829 }
1830
1831 /* Keep the restart process from trying to send host
1832 * commands by clearing the INIT status bit */
1833 priv->status &= ~STATUS_INIT;
James Ketrenosafbf30a2005-08-25 00:05:33 -05001834
1835 /* Cancel currently queued command. */
1836 priv->status &= ~STATUS_HCMD_ACTIVE;
1837 wake_up_interruptible(&priv->wait_command_queue);
1838
James Ketrenos43f66a62005-03-25 12:31:53 -06001839 queue_work(priv->workqueue, &priv->adapter_restart);
James Ketrenosb095c382005-08-24 22:04:42 -05001840 handled |= IPW_INTA_BIT_FATAL_ERROR;
James Ketrenos43f66a62005-03-25 12:31:53 -06001841 }
1842
James Ketrenosb095c382005-08-24 22:04:42 -05001843 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
James Ketrenos43f66a62005-03-25 12:31:53 -06001844 IPW_ERROR("Parity error\n");
James Ketrenosb095c382005-08-24 22:04:42 -05001845 handled |= IPW_INTA_BIT_PARITY_ERROR;
James Ketrenos43f66a62005-03-25 12:31:53 -06001846 }
1847
1848 if (handled != inta) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001849 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
James Ketrenos43f66a62005-03-25 12:31:53 -06001850 }
1851
1852 /* enable all interrupts */
1853 ipw_enable_interrupts(priv);
1854
1855 spin_unlock_irqrestore(&priv->lock, flags);
1856}
Jeff Garzikbf794512005-07-31 13:07:26 -04001857
James Ketrenos43f66a62005-03-25 12:31:53 -06001858#define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1859static char *get_cmd_string(u8 cmd)
1860{
1861 switch (cmd) {
1862 IPW_CMD(HOST_COMPLETE);
Jeff Garzikbf794512005-07-31 13:07:26 -04001863 IPW_CMD(POWER_DOWN);
1864 IPW_CMD(SYSTEM_CONFIG);
1865 IPW_CMD(MULTICAST_ADDRESS);
1866 IPW_CMD(SSID);
1867 IPW_CMD(ADAPTER_ADDRESS);
1868 IPW_CMD(PORT_TYPE);
1869 IPW_CMD(RTS_THRESHOLD);
1870 IPW_CMD(FRAG_THRESHOLD);
1871 IPW_CMD(POWER_MODE);
1872 IPW_CMD(WEP_KEY);
1873 IPW_CMD(TGI_TX_KEY);
1874 IPW_CMD(SCAN_REQUEST);
1875 IPW_CMD(SCAN_REQUEST_EXT);
1876 IPW_CMD(ASSOCIATE);
1877 IPW_CMD(SUPPORTED_RATES);
1878 IPW_CMD(SCAN_ABORT);
1879 IPW_CMD(TX_FLUSH);
1880 IPW_CMD(QOS_PARAMETERS);
1881 IPW_CMD(DINO_CONFIG);
1882 IPW_CMD(RSN_CAPABILITIES);
1883 IPW_CMD(RX_KEY);
1884 IPW_CMD(CARD_DISABLE);
1885 IPW_CMD(SEED_NUMBER);
1886 IPW_CMD(TX_POWER);
1887 IPW_CMD(COUNTRY_INFO);
1888 IPW_CMD(AIRONET_INFO);
1889 IPW_CMD(AP_TX_POWER);
1890 IPW_CMD(CCKM_INFO);
1891 IPW_CMD(CCX_VER_INFO);
1892 IPW_CMD(SET_CALIBRATION);
1893 IPW_CMD(SENSITIVITY_CALIB);
1894 IPW_CMD(RETRY_LIMIT);
1895 IPW_CMD(IPW_PRE_POWER_DOWN);
1896 IPW_CMD(VAP_BEACON_TEMPLATE);
1897 IPW_CMD(VAP_DTIM_PERIOD);
1898 IPW_CMD(EXT_SUPPORTED_RATES);
1899 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1900 IPW_CMD(VAP_QUIET_INTERVALS);
1901 IPW_CMD(VAP_CHANNEL_SWITCH);
1902 IPW_CMD(VAP_MANDATORY_CHANNELS);
1903 IPW_CMD(VAP_CELL_PWR_LIMIT);
1904 IPW_CMD(VAP_CF_PARAM_SET);
1905 IPW_CMD(VAP_SET_BEACONING_STATE);
1906 IPW_CMD(MEASUREMENT);
1907 IPW_CMD(POWER_CAPABILITY);
1908 IPW_CMD(SUPPORTED_CHANNELS);
1909 IPW_CMD(TPC_REPORT);
1910 IPW_CMD(WME_INFO);
1911 IPW_CMD(PRODUCTION_COMMAND);
1912 default:
James Ketrenos43f66a62005-03-25 12:31:53 -06001913 return "UNKNOWN";
1914 }
1915}
James Ketrenos43f66a62005-03-25 12:31:53 -06001916
1917#define HOST_COMPLETE_TIMEOUT HZ
Zhu Yi0a7bcf22006-01-24 16:37:28 +08001918
1919static int __ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
James Ketrenos43f66a62005-03-25 12:31:53 -06001920{
1921 int rc = 0;
James Ketrenosa613bff2005-08-24 21:43:11 -05001922 unsigned long flags;
James Ketrenos43f66a62005-03-25 12:31:53 -06001923
James Ketrenosa613bff2005-08-24 21:43:11 -05001924 spin_lock_irqsave(&priv->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06001925 if (priv->status & STATUS_HCMD_ACTIVE) {
James Ketrenos9ddf84f2005-08-16 17:07:11 -05001926 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1927 get_cmd_string(cmd->cmd));
James Ketrenosa613bff2005-08-24 21:43:11 -05001928 spin_unlock_irqrestore(&priv->lock, flags);
James Ketrenos9ddf84f2005-08-16 17:07:11 -05001929 return -EAGAIN;
James Ketrenos43f66a62005-03-25 12:31:53 -06001930 }
1931
1932 priv->status |= STATUS_HCMD_ACTIVE;
Jeff Garzikbf794512005-07-31 13:07:26 -04001933
James Ketrenosf6c5cb72005-08-25 00:39:09 -05001934 if (priv->cmdlog) {
1935 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1936 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1937 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1938 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1939 cmd->len);
1940 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1941 }
1942
James Ketrenosb095c382005-08-24 22:04:42 -05001943 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1944 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1945 priv->status);
Zhu Yif516dbc2006-01-24 16:36:44 +08001946
1947#ifndef DEBUG_CMD_WEP_KEY
1948 if (cmd->cmd == IPW_CMD_WEP_KEY)
1949 IPW_DEBUG_HC("WEP_KEY command masked out for secure.\n");
1950 else
1951#endif
1952 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1953
Zhu Yi0a7bcf22006-01-24 16:37:28 +08001954 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
James Ketrenosa613bff2005-08-24 21:43:11 -05001955 if (rc) {
1956 priv->status &= ~STATUS_HCMD_ACTIVE;
James Ketrenos9ddf84f2005-08-16 17:07:11 -05001957 IPW_ERROR("Failed to send %s: Reason %d\n",
1958 get_cmd_string(cmd->cmd), rc);
James Ketrenosa613bff2005-08-24 21:43:11 -05001959 spin_unlock_irqrestore(&priv->lock, flags);
James Ketrenosf6c5cb72005-08-25 00:39:09 -05001960 goto exit;
James Ketrenosa613bff2005-08-24 21:43:11 -05001961 }
1962 spin_unlock_irqrestore(&priv->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06001963
Jeff Garzik0edd5b42005-09-07 00:48:31 -04001964 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1965 !(priv->
1966 status & STATUS_HCMD_ACTIVE),
1967 HOST_COMPLETE_TIMEOUT);
James Ketrenos43f66a62005-03-25 12:31:53 -06001968 if (rc == 0) {
James Ketrenosa613bff2005-08-24 21:43:11 -05001969 spin_lock_irqsave(&priv->lock, flags);
1970 if (priv->status & STATUS_HCMD_ACTIVE) {
James Ketrenos9ddf84f2005-08-16 17:07:11 -05001971 IPW_ERROR("Failed to send %s: Command timed out.\n",
1972 get_cmd_string(cmd->cmd));
James Ketrenosa613bff2005-08-24 21:43:11 -05001973 priv->status &= ~STATUS_HCMD_ACTIVE;
1974 spin_unlock_irqrestore(&priv->lock, flags);
James Ketrenosf6c5cb72005-08-25 00:39:09 -05001975 rc = -EIO;
1976 goto exit;
James Ketrenosa613bff2005-08-24 21:43:11 -05001977 }
1978 spin_unlock_irqrestore(&priv->lock, flags);
James Ketrenos3b9990c2005-08-19 13:18:55 -05001979 } else
1980 rc = 0;
James Ketrenosa613bff2005-08-24 21:43:11 -05001981
James Ketrenosb095c382005-08-24 22:04:42 -05001982 if (priv->status & STATUS_RF_KILL_HW) {
James Ketrenos9ddf84f2005-08-16 17:07:11 -05001983 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1984 get_cmd_string(cmd->cmd));
James Ketrenosf6c5cb72005-08-25 00:39:09 -05001985 rc = -EIO;
1986 goto exit;
James Ketrenos43f66a62005-03-25 12:31:53 -06001987 }
1988
Zhu Yi2638bc32006-01-24 16:37:52 +08001989 exit:
James Ketrenosf6c5cb72005-08-25 00:39:09 -05001990 if (priv->cmdlog) {
1991 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1992 priv->cmdlog_pos %= priv->cmdlog_len;
1993 }
1994 return rc;
James Ketrenos43f66a62005-03-25 12:31:53 -06001995}
1996
Zhu Yi0a7bcf22006-01-24 16:37:28 +08001997static int ipw_send_cmd_simple(struct ipw_priv *priv, u8 command)
James Ketrenos43f66a62005-03-25 12:31:53 -06001998{
1999 struct host_cmd cmd = {
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002000 .cmd = command,
James Ketrenos43f66a62005-03-25 12:31:53 -06002001 };
2002
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002003 return __ipw_send_cmd(priv, &cmd);
2004}
2005
2006static int ipw_send_cmd_pdu(struct ipw_priv *priv, u8 command, u8 len,
2007 void *data)
2008{
2009 struct host_cmd cmd = {
2010 .cmd = command,
2011 .len = len,
2012 .param = data,
2013 };
2014
2015 return __ipw_send_cmd(priv, &cmd);
2016}
2017
2018static int ipw_send_host_complete(struct ipw_priv *priv)
2019{
James Ketrenos43f66a62005-03-25 12:31:53 -06002020 if (!priv) {
2021 IPW_ERROR("Invalid args\n");
2022 return -1;
2023 }
2024
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002025 return ipw_send_cmd_simple(priv, IPW_CMD_HOST_COMPLETE);
James Ketrenos43f66a62005-03-25 12:31:53 -06002026}
2027
Jeff Garzikbf794512005-07-31 13:07:26 -04002028static int ipw_send_system_config(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -06002029 struct ipw_sys_config *config)
2030{
James Ketrenos43f66a62005-03-25 12:31:53 -06002031 if (!priv || !config) {
2032 IPW_ERROR("Invalid args\n");
2033 return -1;
2034 }
2035
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002036 return ipw_send_cmd_pdu(priv, IPW_CMD_SYSTEM_CONFIG, sizeof(*config),
Zhu Yi2638bc32006-01-24 16:37:52 +08002037 config);
James Ketrenos43f66a62005-03-25 12:31:53 -06002038}
2039
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002040static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
James Ketrenos43f66a62005-03-25 12:31:53 -06002041{
James Ketrenos43f66a62005-03-25 12:31:53 -06002042 if (!priv || !ssid) {
2043 IPW_ERROR("Invalid args\n");
2044 return -1;
2045 }
2046
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002047 return ipw_send_cmd_pdu(priv, IPW_CMD_SSID, min(len, IW_ESSID_MAX_SIZE),
Zhu Yi2638bc32006-01-24 16:37:52 +08002048 ssid);
James Ketrenos43f66a62005-03-25 12:31:53 -06002049}
2050
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002051static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
James Ketrenos43f66a62005-03-25 12:31:53 -06002052{
James Ketrenos43f66a62005-03-25 12:31:53 -06002053 if (!priv || !mac) {
2054 IPW_ERROR("Invalid args\n");
2055 return -1;
2056 }
2057
2058 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2059 priv->net_dev->name, MAC_ARG(mac));
2060
Zhu Yi2638bc32006-01-24 16:37:52 +08002061 return ipw_send_cmd_pdu(priv, IPW_CMD_ADAPTER_ADDRESS, ETH_ALEN, mac);
James Ketrenos43f66a62005-03-25 12:31:53 -06002062}
2063
James Ketrenosa613bff2005-08-24 21:43:11 -05002064/*
2065 * NOTE: This must be executed from our workqueue as it results in udelay
2066 * being called which may corrupt the keyboard if executed on default
2067 * workqueue
2068 */
James Ketrenos43f66a62005-03-25 12:31:53 -06002069static void ipw_adapter_restart(void *adapter)
2070{
2071 struct ipw_priv *priv = adapter;
2072
2073 if (priv->status & STATUS_RF_KILL_MASK)
2074 return;
2075
2076 ipw_down(priv);
James Ketrenosb095c382005-08-24 22:04:42 -05002077
2078 if (priv->assoc_network &&
2079 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2080 ipw_remove_current_network(priv);
2081
James Ketrenos43f66a62005-03-25 12:31:53 -06002082 if (ipw_up(priv)) {
2083 IPW_ERROR("Failed to up device\n");
2084 return;
2085 }
2086}
2087
James Ketrenosc848d0a2005-08-24 21:56:24 -05002088static void ipw_bg_adapter_restart(void *data)
2089{
2090 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08002091 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05002092 ipw_adapter_restart(data);
Zhu Yi46441512006-01-24 16:37:59 +08002093 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05002094}
2095
James Ketrenos43f66a62005-03-25 12:31:53 -06002096#define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2097
2098static void ipw_scan_check(void *data)
2099{
2100 struct ipw_priv *priv = data;
2101 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2102 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
Zhu Yic7b6a672006-01-24 16:37:05 +08002103 "adapter after (%dms).\n",
2104 jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
James Ketrenosa613bff2005-08-24 21:43:11 -05002105 queue_work(priv->workqueue, &priv->adapter_restart);
James Ketrenos43f66a62005-03-25 12:31:53 -06002106 }
2107}
2108
James Ketrenosc848d0a2005-08-24 21:56:24 -05002109static void ipw_bg_scan_check(void *data)
2110{
2111 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08002112 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05002113 ipw_scan_check(data);
Zhu Yi46441512006-01-24 16:37:59 +08002114 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05002115}
2116
James Ketrenos43f66a62005-03-25 12:31:53 -06002117static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2118 struct ipw_scan_request_ext *request)
2119{
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002120 return ipw_send_cmd_pdu(priv, IPW_CMD_SCAN_REQUEST_EXT,
Zhu Yi2638bc32006-01-24 16:37:52 +08002121 sizeof(*request), request);
James Ketrenos43f66a62005-03-25 12:31:53 -06002122}
2123
2124static int ipw_send_scan_abort(struct ipw_priv *priv)
2125{
James Ketrenos43f66a62005-03-25 12:31:53 -06002126 if (!priv) {
2127 IPW_ERROR("Invalid args\n");
2128 return -1;
2129 }
2130
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002131 return ipw_send_cmd_simple(priv, IPW_CMD_SCAN_ABORT);
James Ketrenos43f66a62005-03-25 12:31:53 -06002132}
2133
2134static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2135{
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002136 struct ipw_sensitivity_calib calib = {
2137 .beacon_rssi_raw = sens,
James Ketrenos43f66a62005-03-25 12:31:53 -06002138 };
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002139
2140 return ipw_send_cmd_pdu(priv, IPW_CMD_SENSITIVITY_CALIB, sizeof(calib),
Zhu Yi2638bc32006-01-24 16:37:52 +08002141 &calib);
James Ketrenos43f66a62005-03-25 12:31:53 -06002142}
2143
2144static int ipw_send_associate(struct ipw_priv *priv,
2145 struct ipw_associate *associate)
2146{
James Ketrenosa613bff2005-08-24 21:43:11 -05002147 struct ipw_associate tmp_associate;
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002148
2149 if (!priv || !associate) {
2150 IPW_ERROR("Invalid args\n");
2151 return -1;
2152 }
2153
James Ketrenosa613bff2005-08-24 21:43:11 -05002154 memcpy(&tmp_associate, associate, sizeof(*associate));
2155 tmp_associate.policy_support =
2156 cpu_to_le16(tmp_associate.policy_support);
2157 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2158 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2159 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2160 tmp_associate.listen_interval =
2161 cpu_to_le16(tmp_associate.listen_interval);
2162 tmp_associate.beacon_interval =
2163 cpu_to_le16(tmp_associate.beacon_interval);
2164 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2165
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002166 return ipw_send_cmd_pdu(priv, IPW_CMD_ASSOCIATE, sizeof(tmp_associate),
Zhu Yi2638bc32006-01-24 16:37:52 +08002167 &tmp_associate);
James Ketrenos43f66a62005-03-25 12:31:53 -06002168}
2169
2170static int ipw_send_supported_rates(struct ipw_priv *priv,
2171 struct ipw_supported_rates *rates)
2172{
James Ketrenos43f66a62005-03-25 12:31:53 -06002173 if (!priv || !rates) {
2174 IPW_ERROR("Invalid args\n");
2175 return -1;
2176 }
2177
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002178 return ipw_send_cmd_pdu(priv, IPW_CMD_SUPPORTED_RATES, sizeof(*rates),
Zhu Yi2638bc32006-01-24 16:37:52 +08002179 rates);
James Ketrenos43f66a62005-03-25 12:31:53 -06002180}
2181
2182static int ipw_set_random_seed(struct ipw_priv *priv)
2183{
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002184 u32 val;
James Ketrenos43f66a62005-03-25 12:31:53 -06002185
2186 if (!priv) {
2187 IPW_ERROR("Invalid args\n");
2188 return -1;
2189 }
2190
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002191 get_random_bytes(&val, sizeof(val));
James Ketrenos43f66a62005-03-25 12:31:53 -06002192
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002193 return ipw_send_cmd_pdu(priv, IPW_CMD_SEED_NUMBER, sizeof(val), &val);
James Ketrenos43f66a62005-03-25 12:31:53 -06002194}
2195
James Ketrenos43f66a62005-03-25 12:31:53 -06002196static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2197{
James Ketrenos43f66a62005-03-25 12:31:53 -06002198 if (!priv) {
2199 IPW_ERROR("Invalid args\n");
2200 return -1;
2201 }
2202
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002203 return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(phy_off),
Zhu Yi2638bc32006-01-24 16:37:52 +08002204 &phy_off);
James Ketrenos43f66a62005-03-25 12:31:53 -06002205}
James Ketrenos43f66a62005-03-25 12:31:53 -06002206
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002207static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
James Ketrenos43f66a62005-03-25 12:31:53 -06002208{
James Ketrenos43f66a62005-03-25 12:31:53 -06002209 if (!priv || !power) {
2210 IPW_ERROR("Invalid args\n");
2211 return -1;
2212 }
2213
Zhu Yi2638bc32006-01-24 16:37:52 +08002214 return ipw_send_cmd_pdu(priv, IPW_CMD_TX_POWER, sizeof(*power), power);
James Ketrenos43f66a62005-03-25 12:31:53 -06002215}
James Ketrenos43f66a62005-03-25 12:31:53 -06002216
Zhu Yi6de9f7f2005-08-11 14:39:33 +08002217static int ipw_set_tx_power(struct ipw_priv *priv)
2218{
Larry Finger1867b112006-02-28 09:48:28 -06002219 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
Zhu Yi6de9f7f2005-08-11 14:39:33 +08002220 struct ipw_tx_power tx_power;
2221 s8 max_power;
2222 int i;
2223
2224 memset(&tx_power, 0, sizeof(tx_power));
2225
2226 /* configure device for 'G' band */
2227 tx_power.ieee_mode = IPW_G_MODE;
2228 tx_power.num_channels = geo->bg_channels;
2229 for (i = 0; i < geo->bg_channels; i++) {
2230 max_power = geo->bg[i].max_power;
2231 tx_power.channels_tx_power[i].channel_number =
2232 geo->bg[i].channel;
2233 tx_power.channels_tx_power[i].tx_power = max_power ?
2234 min(max_power, priv->tx_power) : priv->tx_power;
2235 }
2236 if (ipw_send_tx_power(priv, &tx_power))
2237 return -EIO;
2238
2239 /* configure device to also handle 'B' band */
2240 tx_power.ieee_mode = IPW_B_MODE;
2241 if (ipw_send_tx_power(priv, &tx_power))
2242 return -EIO;
2243
2244 /* configure device to also handle 'A' band */
2245 if (priv->ieee->abg_true) {
2246 tx_power.ieee_mode = IPW_A_MODE;
2247 tx_power.num_channels = geo->a_channels;
2248 for (i = 0; i < tx_power.num_channels; i++) {
2249 max_power = geo->a[i].max_power;
2250 tx_power.channels_tx_power[i].channel_number =
2251 geo->a[i].channel;
2252 tx_power.channels_tx_power[i].tx_power = max_power ?
2253 min(max_power, priv->tx_power) : priv->tx_power;
2254 }
2255 if (ipw_send_tx_power(priv, &tx_power))
2256 return -EIO;
2257 }
James Ketrenos43f66a62005-03-25 12:31:53 -06002258 return 0;
2259}
2260
2261static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2262{
2263 struct ipw_rts_threshold rts_threshold = {
2264 .rts_threshold = rts,
2265 };
James Ketrenos43f66a62005-03-25 12:31:53 -06002266
2267 if (!priv) {
2268 IPW_ERROR("Invalid args\n");
2269 return -1;
2270 }
2271
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002272 return ipw_send_cmd_pdu(priv, IPW_CMD_RTS_THRESHOLD,
2273 sizeof(rts_threshold), &rts_threshold);
James Ketrenos43f66a62005-03-25 12:31:53 -06002274}
2275
2276static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2277{
2278 struct ipw_frag_threshold frag_threshold = {
2279 .frag_threshold = frag,
2280 };
James Ketrenos43f66a62005-03-25 12:31:53 -06002281
2282 if (!priv) {
2283 IPW_ERROR("Invalid args\n");
2284 return -1;
2285 }
2286
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002287 return ipw_send_cmd_pdu(priv, IPW_CMD_FRAG_THRESHOLD,
2288 sizeof(frag_threshold), &frag_threshold);
James Ketrenos43f66a62005-03-25 12:31:53 -06002289}
2290
2291static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2292{
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002293 u32 param;
James Ketrenos43f66a62005-03-25 12:31:53 -06002294
2295 if (!priv) {
2296 IPW_ERROR("Invalid args\n");
2297 return -1;
2298 }
Jeff Garzikbf794512005-07-31 13:07:26 -04002299
James Ketrenos43f66a62005-03-25 12:31:53 -06002300 /* If on battery, set to 3, if AC set to CAM, else user
2301 * level */
2302 switch (mode) {
2303 case IPW_POWER_BATTERY:
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002304 param = IPW_POWER_INDEX_3;
James Ketrenos43f66a62005-03-25 12:31:53 -06002305 break;
2306 case IPW_POWER_AC:
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002307 param = IPW_POWER_MODE_CAM;
James Ketrenos43f66a62005-03-25 12:31:53 -06002308 break;
2309 default:
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002310 param = mode;
James Ketrenos43f66a62005-03-25 12:31:53 -06002311 break;
2312 }
2313
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002314 return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
Zhu Yi2638bc32006-01-24 16:37:52 +08002315 &param);
James Ketrenos43f66a62005-03-25 12:31:53 -06002316}
2317
James Ketrenosafbf30a2005-08-25 00:05:33 -05002318static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2319{
2320 struct ipw_retry_limit retry_limit = {
2321 .short_retry_limit = slimit,
2322 .long_retry_limit = llimit
2323 };
James Ketrenosafbf30a2005-08-25 00:05:33 -05002324
2325 if (!priv) {
2326 IPW_ERROR("Invalid args\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06002327 return -1;
2328 }
2329
Zhu Yi0a7bcf22006-01-24 16:37:28 +08002330 return ipw_send_cmd_pdu(priv, IPW_CMD_RETRY_LIMIT, sizeof(retry_limit),
Zhu Yi2638bc32006-01-24 16:37:52 +08002331 &retry_limit);
James Ketrenos43f66a62005-03-25 12:31:53 -06002332}
2333
2334/*
2335 * The IPW device contains a Microwire compatible EEPROM that stores
2336 * various data like the MAC address. Usually the firmware has exclusive
2337 * access to the eeprom, but during device initialization (before the
2338 * device driver has sent the HostComplete command to the firmware) the
2339 * device driver has read access to the EEPROM by way of indirect addressing
2340 * through a couple of memory mapped registers.
2341 *
2342 * The following is a simplified implementation for pulling data out of the
2343 * the eeprom, along with some helper functions to find information in
2344 * the per device private data's copy of the eeprom.
2345 *
2346 * NOTE: To better understand how these functions work (i.e what is a chip
2347 * select and why do have to keep driving the eeprom clock?), read
2348 * just about any data sheet for a Microwire compatible EEPROM.
2349 */
2350
2351/* write a 32 bit value into the indirect accessor register */
2352static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2353{
2354 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
Jeff Garzikbf794512005-07-31 13:07:26 -04002355
James Ketrenos43f66a62005-03-25 12:31:53 -06002356 /* the eeprom requires some time to complete the operation */
2357 udelay(p->eeprom_delay);
2358
2359 return;
2360}
2361
2362/* perform a chip select operation */
Arjan van de Ven858119e2006-01-14 13:20:43 -08002363static void eeprom_cs(struct ipw_priv *priv)
James Ketrenos43f66a62005-03-25 12:31:53 -06002364{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002365 eeprom_write_reg(priv, 0);
2366 eeprom_write_reg(priv, EEPROM_BIT_CS);
2367 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2368 eeprom_write_reg(priv, EEPROM_BIT_CS);
James Ketrenos43f66a62005-03-25 12:31:53 -06002369}
2370
2371/* perform a chip select operation */
Arjan van de Ven858119e2006-01-14 13:20:43 -08002372static void eeprom_disable_cs(struct ipw_priv *priv)
James Ketrenos43f66a62005-03-25 12:31:53 -06002373{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002374 eeprom_write_reg(priv, EEPROM_BIT_CS);
2375 eeprom_write_reg(priv, 0);
2376 eeprom_write_reg(priv, EEPROM_BIT_SK);
James Ketrenos43f66a62005-03-25 12:31:53 -06002377}
2378
2379/* push a single bit down to the eeprom */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002380static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
James Ketrenos43f66a62005-03-25 12:31:53 -06002381{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002382 int d = (bit ? EEPROM_BIT_DI : 0);
2383 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2384 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
James Ketrenos43f66a62005-03-25 12:31:53 -06002385}
2386
2387/* push an opcode followed by an address down to the eeprom */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002388static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
James Ketrenos43f66a62005-03-25 12:31:53 -06002389{
2390 int i;
2391
2392 eeprom_cs(priv);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002393 eeprom_write_bit(priv, 1);
2394 eeprom_write_bit(priv, op & 2);
2395 eeprom_write_bit(priv, op & 1);
2396 for (i = 7; i >= 0; i--) {
2397 eeprom_write_bit(priv, addr & (1 << i));
James Ketrenos43f66a62005-03-25 12:31:53 -06002398 }
2399}
2400
2401/* pull 16 bits off the eeprom, one bit at a time */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002402static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
James Ketrenos43f66a62005-03-25 12:31:53 -06002403{
2404 int i;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002405 u16 r = 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04002406
James Ketrenos43f66a62005-03-25 12:31:53 -06002407 /* Send READ Opcode */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002408 eeprom_op(priv, EEPROM_CMD_READ, addr);
James Ketrenos43f66a62005-03-25 12:31:53 -06002409
2410 /* Send dummy bit */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002411 eeprom_write_reg(priv, EEPROM_BIT_CS);
James Ketrenos43f66a62005-03-25 12:31:53 -06002412
2413 /* Read the byte off the eeprom one bit at a time */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002414 for (i = 0; i < 16; i++) {
James Ketrenos43f66a62005-03-25 12:31:53 -06002415 u32 data = 0;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002416 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2417 eeprom_write_reg(priv, EEPROM_BIT_CS);
2418 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2419 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
James Ketrenos43f66a62005-03-25 12:31:53 -06002420 }
Jeff Garzikbf794512005-07-31 13:07:26 -04002421
James Ketrenos43f66a62005-03-25 12:31:53 -06002422 /* Send another dummy bit */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002423 eeprom_write_reg(priv, 0);
James Ketrenos43f66a62005-03-25 12:31:53 -06002424 eeprom_disable_cs(priv);
Jeff Garzikbf794512005-07-31 13:07:26 -04002425
James Ketrenos43f66a62005-03-25 12:31:53 -06002426 return r;
2427}
2428
2429/* helper function for pulling the mac address out of the private */
2430/* data's copy of the eeprom data */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002431static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
James Ketrenos43f66a62005-03-25 12:31:53 -06002432{
James Ketrenosafbf30a2005-08-25 00:05:33 -05002433 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
James Ketrenos43f66a62005-03-25 12:31:53 -06002434}
2435
2436/*
2437 * Either the device driver (i.e. the host) or the firmware can
2438 * load eeprom data into the designated region in SRAM. If neither
2439 * happens then the FW will shutdown with a fatal error.
2440 *
2441 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2442 * bit needs region of shared SRAM needs to be non-zero.
2443 */
2444static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2445{
2446 int i;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002447 u16 *eeprom = (u16 *) priv->eeprom;
Jeff Garzikbf794512005-07-31 13:07:26 -04002448
James Ketrenos43f66a62005-03-25 12:31:53 -06002449 IPW_DEBUG_TRACE(">>\n");
2450
2451 /* read entire contents of eeprom into private buffer */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002452 for (i = 0; i < 128; i++)
James Ketrenosa613bff2005-08-24 21:43:11 -05002453 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
James Ketrenos43f66a62005-03-25 12:31:53 -06002454
Jeff Garzikbf794512005-07-31 13:07:26 -04002455 /*
2456 If the data looks correct, then copy it to our private
James Ketrenos43f66a62005-03-25 12:31:53 -06002457 copy. Otherwise let the firmware know to perform the operation
Zhu Yic7b6a672006-01-24 16:37:05 +08002458 on its own.
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002459 */
Alexey Dobriyan386093e2006-02-01 03:04:57 -08002460 if (priv->eeprom[EEPROM_VERSION] != 0) {
James Ketrenos43f66a62005-03-25 12:31:53 -06002461 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2462
2463 /* write the eeprom data to sram */
James Ketrenosb095c382005-08-24 22:04:42 -05002464 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002465 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
James Ketrenos43f66a62005-03-25 12:31:53 -06002466
2467 /* Do not load eeprom data on fatal error or suspend */
2468 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2469 } else {
2470 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2471
2472 /* Load eeprom data on fatal error or suspend */
2473 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2474 }
2475
2476 IPW_DEBUG_TRACE("<<\n");
2477}
2478
Arjan van de Ven858119e2006-01-14 13:20:43 -08002479static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
James Ketrenos43f66a62005-03-25 12:31:53 -06002480{
2481 count >>= 2;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002482 if (!count)
2483 return;
James Ketrenosb095c382005-08-24 22:04:42 -05002484 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
Jeff Garzikbf794512005-07-31 13:07:26 -04002485 while (count--)
James Ketrenosb095c382005-08-24 22:04:42 -05002486 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
James Ketrenos43f66a62005-03-25 12:31:53 -06002487}
2488
2489static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2490{
James Ketrenosb095c382005-08-24 22:04:42 -05002491 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
Jeff Garzikbf794512005-07-31 13:07:26 -04002492 CB_NUMBER_OF_ELEMENTS_SMALL *
James Ketrenos43f66a62005-03-25 12:31:53 -06002493 sizeof(struct command_block));
2494}
2495
2496static int ipw_fw_dma_enable(struct ipw_priv *priv)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002497{ /* start dma engine but no transfers yet */
James Ketrenos43f66a62005-03-25 12:31:53 -06002498
2499 IPW_DEBUG_FW(">> : \n");
Jeff Garzikbf794512005-07-31 13:07:26 -04002500
James Ketrenos43f66a62005-03-25 12:31:53 -06002501 /* Start the dma */
2502 ipw_fw_dma_reset_command_blocks(priv);
Jeff Garzikbf794512005-07-31 13:07:26 -04002503
James Ketrenos43f66a62005-03-25 12:31:53 -06002504 /* Write CB base address */
James Ketrenosb095c382005-08-24 22:04:42 -05002505 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
James Ketrenos43f66a62005-03-25 12:31:53 -06002506
2507 IPW_DEBUG_FW("<< : \n");
2508 return 0;
2509}
2510
2511static void ipw_fw_dma_abort(struct ipw_priv *priv)
2512{
2513 u32 control = 0;
2514
2515 IPW_DEBUG_FW(">> :\n");
Jeff Garzikbf794512005-07-31 13:07:26 -04002516
2517 //set the Stop and Abort bit
James Ketrenos43f66a62005-03-25 12:31:53 -06002518 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
James Ketrenosb095c382005-08-24 22:04:42 -05002519 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
James Ketrenos43f66a62005-03-25 12:31:53 -06002520 priv->sram_desc.last_cb_index = 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04002521
James Ketrenos43f66a62005-03-25 12:31:53 -06002522 IPW_DEBUG_FW("<< \n");
2523}
2524
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002525static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2526 struct command_block *cb)
James Ketrenos43f66a62005-03-25 12:31:53 -06002527{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002528 u32 address =
James Ketrenosb095c382005-08-24 22:04:42 -05002529 IPW_SHARED_SRAM_DMA_CONTROL +
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002530 (sizeof(struct command_block) * index);
James Ketrenos43f66a62005-03-25 12:31:53 -06002531 IPW_DEBUG_FW(">> :\n");
2532
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002533 ipw_write_indirect(priv, address, (u8 *) cb,
2534 (int)sizeof(struct command_block));
James Ketrenos43f66a62005-03-25 12:31:53 -06002535
2536 IPW_DEBUG_FW("<< :\n");
2537 return 0;
2538
2539}
2540
2541static int ipw_fw_dma_kick(struct ipw_priv *priv)
2542{
2543 u32 control = 0;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002544 u32 index = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06002545
2546 IPW_DEBUG_FW(">> :\n");
Jeff Garzikbf794512005-07-31 13:07:26 -04002547
James Ketrenos43f66a62005-03-25 12:31:53 -06002548 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002549 ipw_fw_dma_write_command_block(priv, index,
2550 &priv->sram_desc.cb_list[index]);
James Ketrenos43f66a62005-03-25 12:31:53 -06002551
2552 /* Enable the DMA in the CSR register */
James Ketrenosb095c382005-08-24 22:04:42 -05002553 ipw_clear_bit(priv, IPW_RESET_REG,
2554 IPW_RESET_REG_MASTER_DISABLED |
2555 IPW_RESET_REG_STOP_MASTER);
Jeff Garzikbf794512005-07-31 13:07:26 -04002556
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002557 /* Set the Start bit. */
James Ketrenos43f66a62005-03-25 12:31:53 -06002558 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
James Ketrenosb095c382005-08-24 22:04:42 -05002559 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
James Ketrenos43f66a62005-03-25 12:31:53 -06002560
2561 IPW_DEBUG_FW("<< :\n");
2562 return 0;
2563}
2564
2565static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2566{
2567 u32 address;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002568 u32 register_value = 0;
2569 u32 cb_fields_address = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06002570
2571 IPW_DEBUG_FW(">> :\n");
James Ketrenosb095c382005-08-24 22:04:42 -05002572 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002573 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
James Ketrenos43f66a62005-03-25 12:31:53 -06002574
2575 /* Read the DMA Controlor register */
James Ketrenosb095c382005-08-24 22:04:42 -05002576 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2577 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
James Ketrenos43f66a62005-03-25 12:31:53 -06002578
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002579 /* Print the CB values */
James Ketrenos43f66a62005-03-25 12:31:53 -06002580 cb_fields_address = address;
2581 register_value = ipw_read_reg32(priv, cb_fields_address);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002582 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
James Ketrenos43f66a62005-03-25 12:31:53 -06002583
2584 cb_fields_address += sizeof(u32);
2585 register_value = ipw_read_reg32(priv, cb_fields_address);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002586 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
James Ketrenos43f66a62005-03-25 12:31:53 -06002587
2588 cb_fields_address += sizeof(u32);
2589 register_value = ipw_read_reg32(priv, cb_fields_address);
2590 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2591 register_value);
2592
2593 cb_fields_address += sizeof(u32);
2594 register_value = ipw_read_reg32(priv, cb_fields_address);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002595 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
James Ketrenos43f66a62005-03-25 12:31:53 -06002596
2597 IPW_DEBUG_FW(">> :\n");
2598}
2599
2600static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2601{
2602 u32 current_cb_address = 0;
2603 u32 current_cb_index = 0;
2604
2605 IPW_DEBUG_FW("<< :\n");
James Ketrenosb095c382005-08-24 22:04:42 -05002606 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
Jeff Garzikbf794512005-07-31 13:07:26 -04002607
James Ketrenosb095c382005-08-24 22:04:42 -05002608 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002609 sizeof(struct command_block);
Jeff Garzikbf794512005-07-31 13:07:26 -04002610
James Ketrenos43f66a62005-03-25 12:31:53 -06002611 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002612 current_cb_index, current_cb_address);
James Ketrenos43f66a62005-03-25 12:31:53 -06002613
2614 IPW_DEBUG_FW(">> :\n");
2615 return current_cb_index;
2616
2617}
2618
2619static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2620 u32 src_address,
2621 u32 dest_address,
2622 u32 length,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002623 int interrupt_enabled, int is_last)
James Ketrenos43f66a62005-03-25 12:31:53 -06002624{
2625
Jeff Garzikbf794512005-07-31 13:07:26 -04002626 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002627 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2628 CB_DEST_SIZE_LONG;
James Ketrenos43f66a62005-03-25 12:31:53 -06002629 struct command_block *cb;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002630 u32 last_cb_element = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06002631
2632 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2633 src_address, dest_address, length);
2634
2635 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2636 return -1;
2637
2638 last_cb_element = priv->sram_desc.last_cb_index;
2639 cb = &priv->sram_desc.cb_list[last_cb_element];
2640 priv->sram_desc.last_cb_index++;
2641
2642 /* Calculate the new CB control word */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002643 if (interrupt_enabled)
James Ketrenos43f66a62005-03-25 12:31:53 -06002644 control |= CB_INT_ENABLED;
2645
2646 if (is_last)
2647 control |= CB_LAST_VALID;
Jeff Garzikbf794512005-07-31 13:07:26 -04002648
James Ketrenos43f66a62005-03-25 12:31:53 -06002649 control |= length;
2650
2651 /* Calculate the CB Element's checksum value */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002652 cb->status = control ^ src_address ^ dest_address;
James Ketrenos43f66a62005-03-25 12:31:53 -06002653
2654 /* Copy the Source and Destination addresses */
2655 cb->dest_addr = dest_address;
2656 cb->source_addr = src_address;
2657
2658 /* Copy the Control Word last */
2659 cb->control = control;
2660
2661 return 0;
2662}
2663
2664static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002665 u32 src_phys, u32 dest_address, u32 length)
James Ketrenos43f66a62005-03-25 12:31:53 -06002666{
2667 u32 bytes_left = length;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002668 u32 src_offset = 0;
2669 u32 dest_offset = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06002670 int status = 0;
2671 IPW_DEBUG_FW(">> \n");
2672 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2673 src_phys, dest_address, length);
2674 while (bytes_left > CB_MAX_LENGTH) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002675 status = ipw_fw_dma_add_command_block(priv,
2676 src_phys + src_offset,
2677 dest_address +
2678 dest_offset,
2679 CB_MAX_LENGTH, 0, 0);
James Ketrenos43f66a62005-03-25 12:31:53 -06002680 if (status) {
2681 IPW_DEBUG_FW_INFO(": Failed\n");
2682 return -1;
Jeff Garzikbf794512005-07-31 13:07:26 -04002683 } else
James Ketrenos43f66a62005-03-25 12:31:53 -06002684 IPW_DEBUG_FW_INFO(": Added new cb\n");
2685
2686 src_offset += CB_MAX_LENGTH;
2687 dest_offset += CB_MAX_LENGTH;
2688 bytes_left -= CB_MAX_LENGTH;
2689 }
2690
2691 /* add the buffer tail */
2692 if (bytes_left > 0) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002693 status =
2694 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2695 dest_address + dest_offset,
2696 bytes_left, 0, 0);
James Ketrenos43f66a62005-03-25 12:31:53 -06002697 if (status) {
2698 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2699 return -1;
Jeff Garzikbf794512005-07-31 13:07:26 -04002700 } else
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002701 IPW_DEBUG_FW_INFO
2702 (": Adding new cb - the buffer tail\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06002703 }
Jeff Garzikbf794512005-07-31 13:07:26 -04002704
James Ketrenos43f66a62005-03-25 12:31:53 -06002705 IPW_DEBUG_FW("<< \n");
2706 return 0;
2707}
2708
2709static int ipw_fw_dma_wait(struct ipw_priv *priv)
2710{
Zhu Yi397ae122006-01-24 16:37:22 +08002711 u32 current_index = 0, previous_index;
James Ketrenos43f66a62005-03-25 12:31:53 -06002712 u32 watchdog = 0;
2713
2714 IPW_DEBUG_FW(">> : \n");
2715
2716 current_index = ipw_fw_dma_command_block_index(priv);
Zhu Yi397ae122006-01-24 16:37:22 +08002717 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%08X\n",
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002718 (int)priv->sram_desc.last_cb_index);
James Ketrenos43f66a62005-03-25 12:31:53 -06002719
2720 while (current_index < priv->sram_desc.last_cb_index) {
2721 udelay(50);
Zhu Yi397ae122006-01-24 16:37:22 +08002722 previous_index = current_index;
James Ketrenos43f66a62005-03-25 12:31:53 -06002723 current_index = ipw_fw_dma_command_block_index(priv);
2724
Zhu Yi397ae122006-01-24 16:37:22 +08002725 if (previous_index < current_index) {
2726 watchdog = 0;
2727 continue;
2728 }
2729 if (++watchdog > 400) {
James Ketrenos43f66a62005-03-25 12:31:53 -06002730 IPW_DEBUG_FW_INFO("Timeout\n");
2731 ipw_fw_dma_dump_command_block(priv);
2732 ipw_fw_dma_abort(priv);
2733 return -1;
2734 }
2735 }
2736
2737 ipw_fw_dma_abort(priv);
2738
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002739 /*Disable the DMA in the CSR register */
James Ketrenosb095c382005-08-24 22:04:42 -05002740 ipw_set_bit(priv, IPW_RESET_REG,
2741 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
James Ketrenos43f66a62005-03-25 12:31:53 -06002742
2743 IPW_DEBUG_FW("<< dmaWaitSync \n");
2744 return 0;
2745}
2746
Jeff Garzikbf794512005-07-31 13:07:26 -04002747static void ipw_remove_current_network(struct ipw_priv *priv)
James Ketrenos43f66a62005-03-25 12:31:53 -06002748{
2749 struct list_head *element, *safe;
Jeff Garzikbf794512005-07-31 13:07:26 -04002750 struct ieee80211_network *network = NULL;
James Ketrenosa613bff2005-08-24 21:43:11 -05002751 unsigned long flags;
2752
2753 spin_lock_irqsave(&priv->ieee->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06002754 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2755 network = list_entry(element, struct ieee80211_network, list);
2756 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2757 list_del(element);
Jeff Garzikbf794512005-07-31 13:07:26 -04002758 list_add_tail(&network->list,
James Ketrenos43f66a62005-03-25 12:31:53 -06002759 &priv->ieee->network_free_list);
2760 }
2761 }
James Ketrenosa613bff2005-08-24 21:43:11 -05002762 spin_unlock_irqrestore(&priv->ieee->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06002763}
2764
2765/**
Jeff Garzikbf794512005-07-31 13:07:26 -04002766 * Check that card is still alive.
James Ketrenos43f66a62005-03-25 12:31:53 -06002767 * Reads debug register from domain0.
2768 * If card is present, pre-defined value should
2769 * be found there.
Jeff Garzikbf794512005-07-31 13:07:26 -04002770 *
James Ketrenos43f66a62005-03-25 12:31:53 -06002771 * @param priv
2772 * @return 1 if card is present, 0 otherwise
2773 */
2774static inline int ipw_alive(struct ipw_priv *priv)
2775{
2776 return ipw_read32(priv, 0x90) == 0xd55555d5;
2777}
2778
Zhu Yic7b6a672006-01-24 16:37:05 +08002779/* timeout in msec, attempted in 10-msec quanta */
Arjan van de Ven858119e2006-01-14 13:20:43 -08002780static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
James Ketrenos43f66a62005-03-25 12:31:53 -06002781 int timeout)
2782{
2783 int i = 0;
2784
2785 do {
Jeff Garzikbf794512005-07-31 13:07:26 -04002786 if ((ipw_read32(priv, addr) & mask) == mask)
James Ketrenos43f66a62005-03-25 12:31:53 -06002787 return i;
2788 mdelay(10);
2789 i += 10;
2790 } while (i < timeout);
Jeff Garzikbf794512005-07-31 13:07:26 -04002791
James Ketrenos43f66a62005-03-25 12:31:53 -06002792 return -ETIME;
2793}
2794
Jeff Garzikbf794512005-07-31 13:07:26 -04002795/* These functions load the firmware and micro code for the operation of
James Ketrenos43f66a62005-03-25 12:31:53 -06002796 * the ipw hardware. It assumes the buffer has all the bits for the
2797 * image and the caller is handling the memory allocation and clean up.
2798 */
2799
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002800static int ipw_stop_master(struct ipw_priv *priv)
James Ketrenos43f66a62005-03-25 12:31:53 -06002801{
2802 int rc;
Jeff Garzikbf794512005-07-31 13:07:26 -04002803
James Ketrenos43f66a62005-03-25 12:31:53 -06002804 IPW_DEBUG_TRACE(">> \n");
2805 /* stop master. typical delay - 0 */
James Ketrenosb095c382005-08-24 22:04:42 -05002806 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
James Ketrenos43f66a62005-03-25 12:31:53 -06002807
Zhu Yic7b6a672006-01-24 16:37:05 +08002808 /* timeout is in msec, polled in 10-msec quanta */
James Ketrenosb095c382005-08-24 22:04:42 -05002809 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2810 IPW_RESET_REG_MASTER_DISABLED, 100);
James Ketrenos43f66a62005-03-25 12:31:53 -06002811 if (rc < 0) {
Zhu Yic7b6a672006-01-24 16:37:05 +08002812 IPW_ERROR("wait for stop master failed after 100ms\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06002813 return -1;
2814 }
2815
2816 IPW_DEBUG_INFO("stop master %dms\n", rc);
2817
2818 return rc;
2819}
2820
2821static void ipw_arc_release(struct ipw_priv *priv)
2822{
2823 IPW_DEBUG_TRACE(">> \n");
2824 mdelay(5);
2825
James Ketrenosb095c382005-08-24 22:04:42 -05002826 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
James Ketrenos43f66a62005-03-25 12:31:53 -06002827
2828 /* no one knows timing, for safety add some delay */
2829 mdelay(5);
2830}
2831
2832struct fw_header {
2833 u32 version;
2834 u32 mode;
2835};
2836
2837struct fw_chunk {
2838 u32 address;
2839 u32 length;
2840};
2841
2842#define IPW_FW_MAJOR_VERSION 2
James Ketrenos817153762005-08-25 01:37:28 -05002843#define IPW_FW_MINOR_VERSION 4
James Ketrenos43f66a62005-03-25 12:31:53 -06002844
2845#define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2846#define IPW_FW_MAJOR(x) (x & 0xff)
2847
James Ketrenosafbf30a2005-08-25 00:05:33 -05002848#define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
James Ketrenos43f66a62005-03-25 12:31:53 -06002849
2850#define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2851"." __stringify(IPW_FW_MINOR_VERSION) "-"
2852
2853#if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2854#define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2855#else
2856#define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2857#endif
2858
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002859static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
James Ketrenos43f66a62005-03-25 12:31:53 -06002860{
2861 int rc = 0, i, addr;
2862 u8 cr = 0;
2863 u16 *image;
2864
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002865 image = (u16 *) data;
Jeff Garzikbf794512005-07-31 13:07:26 -04002866
James Ketrenos43f66a62005-03-25 12:31:53 -06002867 IPW_DEBUG_TRACE(">> \n");
2868
2869 rc = ipw_stop_master(priv);
2870
2871 if (rc < 0)
2872 return rc;
Jeff Garzikbf794512005-07-31 13:07:26 -04002873
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002874// spin_lock_irqsave(&priv->lock, flags);
Jeff Garzikbf794512005-07-31 13:07:26 -04002875
James Ketrenosb095c382005-08-24 22:04:42 -05002876 for (addr = IPW_SHARED_LOWER_BOUND;
2877 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
James Ketrenos43f66a62005-03-25 12:31:53 -06002878 ipw_write32(priv, addr, 0);
2879 }
2880
2881 /* no ucode (yet) */
2882 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2883 /* destroy DMA queues */
2884 /* reset sequence */
2885
James Ketrenosb095c382005-08-24 22:04:42 -05002886 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
James Ketrenos43f66a62005-03-25 12:31:53 -06002887 ipw_arc_release(priv);
James Ketrenosb095c382005-08-24 22:04:42 -05002888 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
James Ketrenos43f66a62005-03-25 12:31:53 -06002889 mdelay(1);
2890
2891 /* reset PHY */
James Ketrenosb095c382005-08-24 22:04:42 -05002892 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
James Ketrenos43f66a62005-03-25 12:31:53 -06002893 mdelay(1);
Jeff Garzikbf794512005-07-31 13:07:26 -04002894
James Ketrenosb095c382005-08-24 22:04:42 -05002895 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
James Ketrenos43f66a62005-03-25 12:31:53 -06002896 mdelay(1);
Jeff Garzikbf794512005-07-31 13:07:26 -04002897
James Ketrenos43f66a62005-03-25 12:31:53 -06002898 /* enable ucode store */
Zhu Yic8fe6672006-01-24 16:36:36 +08002899 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
2900 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
James Ketrenos43f66a62005-03-25 12:31:53 -06002901 mdelay(1);
2902
2903 /* write ucode */
2904 /**
2905 * @bug
2906 * Do NOT set indirect address register once and then
2907 * store data to indirect data register in the loop.
2908 * It seems very reasonable, but in this case DINO do not
2909 * accept ucode. It is essential to set address each time.
2910 */
2911 /* load new ipw uCode */
2912 for (i = 0; i < len / 2; i++)
James Ketrenosb095c382005-08-24 22:04:42 -05002913 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
James Ketrenosa613bff2005-08-24 21:43:11 -05002914 cpu_to_le16(image[i]));
James Ketrenos43f66a62005-03-25 12:31:53 -06002915
James Ketrenos43f66a62005-03-25 12:31:53 -06002916 /* enable DINO */
James Ketrenosb095c382005-08-24 22:04:42 -05002917 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2918 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
James Ketrenos43f66a62005-03-25 12:31:53 -06002919
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002920 /* this is where the igx / win driver deveates from the VAP driver. */
James Ketrenos43f66a62005-03-25 12:31:53 -06002921
2922 /* wait for alive response */
2923 for (i = 0; i < 100; i++) {
2924 /* poll for incoming data */
James Ketrenosb095c382005-08-24 22:04:42 -05002925 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
James Ketrenos43f66a62005-03-25 12:31:53 -06002926 if (cr & DINO_RXFIFO_DATA)
2927 break;
2928 mdelay(1);
2929 }
2930
2931 if (cr & DINO_RXFIFO_DATA) {
2932 /* alive_command_responce size is NOT multiple of 4 */
2933 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
Jeff Garzikbf794512005-07-31 13:07:26 -04002934
2935 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
James Ketrenos43f66a62005-03-25 12:31:53 -06002936 response_buffer[i] =
James Ketrenosa613bff2005-08-24 21:43:11 -05002937 le32_to_cpu(ipw_read_reg32(priv,
James Ketrenosb095c382005-08-24 22:04:42 -05002938 IPW_BASEBAND_RX_FIFO_READ));
James Ketrenos43f66a62005-03-25 12:31:53 -06002939 memcpy(&priv->dino_alive, response_buffer,
2940 sizeof(priv->dino_alive));
2941 if (priv->dino_alive.alive_command == 1
2942 && priv->dino_alive.ucode_valid == 1) {
2943 rc = 0;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002944 IPW_DEBUG_INFO
2945 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2946 "of %02d/%02d/%02d %02d:%02d\n",
2947 priv->dino_alive.software_revision,
2948 priv->dino_alive.software_revision,
2949 priv->dino_alive.device_identifier,
2950 priv->dino_alive.device_identifier,
2951 priv->dino_alive.time_stamp[0],
2952 priv->dino_alive.time_stamp[1],
2953 priv->dino_alive.time_stamp[2],
2954 priv->dino_alive.time_stamp[3],
2955 priv->dino_alive.time_stamp[4]);
James Ketrenos43f66a62005-03-25 12:31:53 -06002956 } else {
2957 IPW_DEBUG_INFO("Microcode is not alive\n");
2958 rc = -EINVAL;
2959 }
2960 } else {
2961 IPW_DEBUG_INFO("No alive response from DINO\n");
2962 rc = -ETIME;
2963 }
2964
2965 /* disable DINO, otherwise for some reason
2966 firmware have problem getting alive resp. */
James Ketrenosb095c382005-08-24 22:04:42 -05002967 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
James Ketrenos43f66a62005-03-25 12:31:53 -06002968
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002969// spin_unlock_irqrestore(&priv->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06002970
2971 return rc;
2972}
2973
Jeff Garzik0edd5b42005-09-07 00:48:31 -04002974static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
James Ketrenos43f66a62005-03-25 12:31:53 -06002975{
2976 int rc = -1;
2977 int offset = 0;
2978 struct fw_chunk *chunk;
2979 dma_addr_t shared_phys;
2980 u8 *shared_virt;
2981
2982 IPW_DEBUG_TRACE("<< : \n");
2983 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2984
2985 if (!shared_virt)
2986 return -ENOMEM;
2987
2988 memmove(shared_virt, data, len);
2989
2990 /* Start the Dma */
2991 rc = ipw_fw_dma_enable(priv);
2992
2993 if (priv->sram_desc.last_cb_index > 0) {
2994 /* the DMA is already ready this would be a bug. */
2995 BUG();
2996 goto out;
2997 }
2998
2999 do {
3000 chunk = (struct fw_chunk *)(data + offset);
3001 offset += sizeof(struct fw_chunk);
3002 /* build DMA packet and queue up for sending */
Jeff Garzikbf794512005-07-31 13:07:26 -04003003 /* dma to chunk->address, the chunk->length bytes from data +
James Ketrenos43f66a62005-03-25 12:31:53 -06003004 * offeset*/
3005 /* Dma loading */
3006 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
James Ketrenosa613bff2005-08-24 21:43:11 -05003007 le32_to_cpu(chunk->address),
3008 le32_to_cpu(chunk->length));
James Ketrenos43f66a62005-03-25 12:31:53 -06003009 if (rc) {
3010 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3011 goto out;
3012 }
Jeff Garzikbf794512005-07-31 13:07:26 -04003013
James Ketrenosa613bff2005-08-24 21:43:11 -05003014 offset += le32_to_cpu(chunk->length);
James Ketrenos43f66a62005-03-25 12:31:53 -06003015 } while (offset < len);
3016
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003017 /* Run the DMA and wait for the answer */
James Ketrenos43f66a62005-03-25 12:31:53 -06003018 rc = ipw_fw_dma_kick(priv);
3019 if (rc) {
3020 IPW_ERROR("dmaKick Failed\n");
3021 goto out;
3022 }
3023
3024 rc = ipw_fw_dma_wait(priv);
3025 if (rc) {
3026 IPW_ERROR("dmaWaitSync Failed\n");
3027 goto out;
3028 }
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003029 out:
3030 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
James Ketrenos43f66a62005-03-25 12:31:53 -06003031 return rc;
3032}
3033
3034/* stop nic */
3035static int ipw_stop_nic(struct ipw_priv *priv)
3036{
3037 int rc = 0;
3038
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003039 /* stop */
James Ketrenosb095c382005-08-24 22:04:42 -05003040 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
Jeff Garzikbf794512005-07-31 13:07:26 -04003041
James Ketrenosb095c382005-08-24 22:04:42 -05003042 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3043 IPW_RESET_REG_MASTER_DISABLED, 500);
James Ketrenos43f66a62005-03-25 12:31:53 -06003044 if (rc < 0) {
Zhu Yic7b6a672006-01-24 16:37:05 +08003045 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06003046 return rc;
Jeff Garzikbf794512005-07-31 13:07:26 -04003047 }
James Ketrenos43f66a62005-03-25 12:31:53 -06003048
James Ketrenosb095c382005-08-24 22:04:42 -05003049 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
Jeff Garzikbf794512005-07-31 13:07:26 -04003050
James Ketrenos43f66a62005-03-25 12:31:53 -06003051 return rc;
3052}
3053
3054static void ipw_start_nic(struct ipw_priv *priv)
3055{
3056 IPW_DEBUG_TRACE(">>\n");
3057
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003058 /* prvHwStartNic release ARC */
James Ketrenosb095c382005-08-24 22:04:42 -05003059 ipw_clear_bit(priv, IPW_RESET_REG,
3060 IPW_RESET_REG_MASTER_DISABLED |
3061 IPW_RESET_REG_STOP_MASTER |
James Ketrenos43f66a62005-03-25 12:31:53 -06003062 CBD_RESET_REG_PRINCETON_RESET);
Jeff Garzikbf794512005-07-31 13:07:26 -04003063
James Ketrenos43f66a62005-03-25 12:31:53 -06003064 /* enable power management */
James Ketrenosb095c382005-08-24 22:04:42 -05003065 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3066 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
James Ketrenos43f66a62005-03-25 12:31:53 -06003067
3068 IPW_DEBUG_TRACE("<<\n");
3069}
Jeff Garzikbf794512005-07-31 13:07:26 -04003070
James Ketrenos43f66a62005-03-25 12:31:53 -06003071static int ipw_init_nic(struct ipw_priv *priv)
3072{
3073 int rc;
3074
3075 IPW_DEBUG_TRACE(">>\n");
Jeff Garzikbf794512005-07-31 13:07:26 -04003076 /* reset */
James Ketrenos43f66a62005-03-25 12:31:53 -06003077 /*prvHwInitNic */
3078 /* set "initialization complete" bit to move adapter to D0 state */
James Ketrenosb095c382005-08-24 22:04:42 -05003079 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
James Ketrenos43f66a62005-03-25 12:31:53 -06003080
3081 /* low-level PLL activation */
James Ketrenosb095c382005-08-24 22:04:42 -05003082 ipw_write32(priv, IPW_READ_INT_REGISTER,
3083 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
James Ketrenos43f66a62005-03-25 12:31:53 -06003084
3085 /* wait for clock stabilization */
James Ketrenosb095c382005-08-24 22:04:42 -05003086 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3087 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003088 if (rc < 0)
James Ketrenos43f66a62005-03-25 12:31:53 -06003089 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3090
3091 /* assert SW reset */
James Ketrenosb095c382005-08-24 22:04:42 -05003092 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
James Ketrenos43f66a62005-03-25 12:31:53 -06003093
3094 udelay(10);
3095
3096 /* set "initialization complete" bit to move adapter to D0 state */
James Ketrenosb095c382005-08-24 22:04:42 -05003097 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
James Ketrenos43f66a62005-03-25 12:31:53 -06003098
3099 IPW_DEBUG_TRACE(">>\n");
3100 return 0;
3101}
3102
Jeff Garzikbf794512005-07-31 13:07:26 -04003103/* Call this function from process context, it will sleep in request_firmware.
James Ketrenos43f66a62005-03-25 12:31:53 -06003104 * Probe is an ok place to call this from.
3105 */
3106static int ipw_reset_nic(struct ipw_priv *priv)
3107{
3108 int rc = 0;
James Ketrenosa613bff2005-08-24 21:43:11 -05003109 unsigned long flags;
James Ketrenos43f66a62005-03-25 12:31:53 -06003110
3111 IPW_DEBUG_TRACE(">>\n");
Jeff Garzikbf794512005-07-31 13:07:26 -04003112
James Ketrenos43f66a62005-03-25 12:31:53 -06003113 rc = ipw_init_nic(priv);
Jeff Garzikbf794512005-07-31 13:07:26 -04003114
James Ketrenosa613bff2005-08-24 21:43:11 -05003115 spin_lock_irqsave(&priv->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06003116 /* Clear the 'host command active' bit... */
3117 priv->status &= ~STATUS_HCMD_ACTIVE;
3118 wake_up_interruptible(&priv->wait_command_queue);
James Ketrenosafbf30a2005-08-25 00:05:33 -05003119 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3120 wake_up_interruptible(&priv->wait_state);
James Ketrenosa613bff2005-08-24 21:43:11 -05003121 spin_unlock_irqrestore(&priv->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06003122
3123 IPW_DEBUG_TRACE("<<\n");
3124 return rc;
Jeff Garzikbf794512005-07-31 13:07:26 -04003125}
James Ketrenos43f66a62005-03-25 12:31:53 -06003126
Jeff Garzikbf794512005-07-31 13:07:26 -04003127static int ipw_get_fw(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -06003128 const struct firmware **fw, const char *name)
3129{
3130 struct fw_header *header;
3131 int rc;
3132
3133 /* ask firmware_class module to get the boot firmware off disk */
3134 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3135 if (rc < 0) {
3136 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3137 return rc;
Jeff Garzikbf794512005-07-31 13:07:26 -04003138 }
James Ketrenos43f66a62005-03-25 12:31:53 -06003139
3140 header = (struct fw_header *)(*fw)->data;
James Ketrenosa613bff2005-08-24 21:43:11 -05003141 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
James Ketrenos43f66a62005-03-25 12:31:53 -06003142 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3143 name,
James Ketrenosa613bff2005-08-24 21:43:11 -05003144 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3145 IPW_FW_MAJOR_VERSION);
James Ketrenos43f66a62005-03-25 12:31:53 -06003146 return -EINVAL;
3147 }
3148
Jiri Bencaaa4d302005-06-07 14:58:41 +02003149 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06003150 name,
James Ketrenosa613bff2005-08-24 21:43:11 -05003151 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3152 IPW_FW_MINOR(le32_to_cpu(header->version)),
James Ketrenos43f66a62005-03-25 12:31:53 -06003153 (*fw)->size - sizeof(struct fw_header));
3154 return 0;
3155}
3156
James Ketrenosb095c382005-08-24 22:04:42 -05003157#define IPW_RX_BUF_SIZE (3000)
James Ketrenos43f66a62005-03-25 12:31:53 -06003158
Arjan van de Ven858119e2006-01-14 13:20:43 -08003159static void ipw_rx_queue_reset(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -06003160 struct ipw_rx_queue *rxq)
3161{
3162 unsigned long flags;
3163 int i;
3164
3165 spin_lock_irqsave(&rxq->lock, flags);
3166
3167 INIT_LIST_HEAD(&rxq->rx_free);
3168 INIT_LIST_HEAD(&rxq->rx_used);
3169
3170 /* Fill the rx_used queue with _all_ of the Rx buffers */
3171 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3172 /* In the reset function, these buffers may have been allocated
3173 * to an SKB, so we need to unmap and free potential storage */
3174 if (rxq->pool[i].skb != NULL) {
3175 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
James Ketrenosb095c382005-08-24 22:04:42 -05003176 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
James Ketrenos43f66a62005-03-25 12:31:53 -06003177 dev_kfree_skb(rxq->pool[i].skb);
James Ketrenosa613bff2005-08-24 21:43:11 -05003178 rxq->pool[i].skb = NULL;
James Ketrenos43f66a62005-03-25 12:31:53 -06003179 }
3180 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3181 }
Jeff Garzikbf794512005-07-31 13:07:26 -04003182
James Ketrenos43f66a62005-03-25 12:31:53 -06003183 /* Set us so that we have processed and used all buffers, but have
3184 * not restocked the Rx queue with fresh buffers */
3185 rxq->read = rxq->write = 0;
3186 rxq->processed = RX_QUEUE_SIZE - 1;
3187 rxq->free_count = 0;
3188 spin_unlock_irqrestore(&rxq->lock, flags);
3189}
3190
3191#ifdef CONFIG_PM
3192static int fw_loaded = 0;
3193static const struct firmware *bootfw = NULL;
3194static const struct firmware *firmware = NULL;
3195static const struct firmware *ucode = NULL;
James Ketrenosafbf30a2005-08-25 00:05:33 -05003196
3197static void free_firmware(void)
3198{
3199 if (fw_loaded) {
3200 release_firmware(bootfw);
3201 release_firmware(ucode);
3202 release_firmware(firmware);
3203 bootfw = ucode = firmware = NULL;
3204 fw_loaded = 0;
3205 }
3206}
3207#else
3208#define free_firmware() do {} while (0)
James Ketrenos43f66a62005-03-25 12:31:53 -06003209#endif
3210
3211static int ipw_load(struct ipw_priv *priv)
3212{
3213#ifndef CONFIG_PM
3214 const struct firmware *bootfw = NULL;
3215 const struct firmware *firmware = NULL;
3216 const struct firmware *ucode = NULL;
3217#endif
Zhu Yi397ae122006-01-24 16:37:22 +08003218 char *ucode_name;
3219 char *fw_name;
James Ketrenos43f66a62005-03-25 12:31:53 -06003220 int rc = 0, retries = 3;
3221
Zhu Yi397ae122006-01-24 16:37:22 +08003222 switch (priv->ieee->iw_mode) {
3223 case IW_MODE_ADHOC:
3224 ucode_name = IPW_FW_NAME("ibss_ucode");
3225 fw_name = IPW_FW_NAME("ibss");
3226 break;
James Ketrenosb095c382005-08-24 22:04:42 -05003227#ifdef CONFIG_IPW2200_MONITOR
Zhu Yi397ae122006-01-24 16:37:22 +08003228 case IW_MODE_MONITOR:
3229 ucode_name = IPW_FW_NAME("sniffer_ucode");
3230 fw_name = IPW_FW_NAME("sniffer");
3231 break;
James Ketrenos43f66a62005-03-25 12:31:53 -06003232#endif
Zhu Yi397ae122006-01-24 16:37:22 +08003233 case IW_MODE_INFRA:
3234 ucode_name = IPW_FW_NAME("bss_ucode");
3235 fw_name = IPW_FW_NAME("bss");
3236 break;
3237 default:
3238 rc = -EINVAL;
James Ketrenos43f66a62005-03-25 12:31:53 -06003239 }
Zhu Yi397ae122006-01-24 16:37:22 +08003240
3241 if (rc < 0)
3242 goto error;
James Ketrenos43f66a62005-03-25 12:31:53 -06003243
3244 if (!priv->rxq)
3245 priv->rxq = ipw_rx_queue_alloc(priv);
3246 else
3247 ipw_rx_queue_reset(priv, priv->rxq);
3248 if (!priv->rxq) {
3249 IPW_ERROR("Unable to initialize Rx queue\n");
3250 goto error;
3251 }
3252
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003253 retry:
James Ketrenos43f66a62005-03-25 12:31:53 -06003254 /* Ensure interrupts are disabled */
James Ketrenosb095c382005-08-24 22:04:42 -05003255 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
James Ketrenos43f66a62005-03-25 12:31:53 -06003256 priv->status &= ~STATUS_INT_ENABLED;
3257
3258 /* ack pending interrupts */
James Ketrenosb095c382005-08-24 22:04:42 -05003259 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
Jeff Garzikbf794512005-07-31 13:07:26 -04003260
James Ketrenos43f66a62005-03-25 12:31:53 -06003261 ipw_stop_nic(priv);
3262
3263 rc = ipw_reset_nic(priv);
Zhu Yi397ae122006-01-24 16:37:22 +08003264 if (rc < 0) {
James Ketrenos43f66a62005-03-25 12:31:53 -06003265 IPW_ERROR("Unable to reset NIC\n");
3266 goto error;
3267 }
3268
James Ketrenosb095c382005-08-24 22:04:42 -05003269 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3270 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
James Ketrenos43f66a62005-03-25 12:31:53 -06003271
Zhu Yi397ae122006-01-24 16:37:22 +08003272#ifdef CONFIG_PM
3273 if (!fw_loaded) {
3274#endif
3275 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3276 if (rc < 0)
3277 goto error;
3278#ifdef CONFIG_PM
3279 }
3280#endif
James Ketrenos43f66a62005-03-25 12:31:53 -06003281 /* DMA the initial boot firmware into the device */
Jeff Garzikbf794512005-07-31 13:07:26 -04003282 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
James Ketrenos43f66a62005-03-25 12:31:53 -06003283 bootfw->size - sizeof(struct fw_header));
3284 if (rc < 0) {
Peter Jonesa4f6bbb2005-08-26 00:33:34 -05003285 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
James Ketrenos43f66a62005-03-25 12:31:53 -06003286 goto error;
3287 }
3288
3289 /* kick start the device */
3290 ipw_start_nic(priv);
3291
Zhu Yic7b6a672006-01-24 16:37:05 +08003292 /* wait for the device to finish its initial startup sequence */
James Ketrenosb095c382005-08-24 22:04:42 -05003293 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3294 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
James Ketrenos43f66a62005-03-25 12:31:53 -06003295 if (rc < 0) {
3296 IPW_ERROR("device failed to boot initial fw image\n");
3297 goto error;
3298 }
3299 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3300
Jeff Garzikbf794512005-07-31 13:07:26 -04003301 /* ack fw init done interrupt */
James Ketrenosb095c382005-08-24 22:04:42 -05003302 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
James Ketrenos43f66a62005-03-25 12:31:53 -06003303
Zhu Yi397ae122006-01-24 16:37:22 +08003304#ifdef CONFIG_PM
3305 if (!fw_loaded) {
3306#endif
3307 rc = ipw_get_fw(priv, &ucode, ucode_name);
3308 if (rc < 0)
3309 goto error;
3310#ifdef CONFIG_PM
3311 }
3312#endif
Zhu Yi2638bc32006-01-24 16:37:52 +08003313
James Ketrenos43f66a62005-03-25 12:31:53 -06003314 /* DMA the ucode into the device */
Jeff Garzikbf794512005-07-31 13:07:26 -04003315 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
James Ketrenos43f66a62005-03-25 12:31:53 -06003316 ucode->size - sizeof(struct fw_header));
3317 if (rc < 0) {
Peter Jonesa4f6bbb2005-08-26 00:33:34 -05003318 IPW_ERROR("Unable to load ucode: %d\n", rc);
James Ketrenos43f66a62005-03-25 12:31:53 -06003319 goto error;
3320 }
Jeff Garzikbf794512005-07-31 13:07:26 -04003321
James Ketrenos43f66a62005-03-25 12:31:53 -06003322 /* stop nic */
3323 ipw_stop_nic(priv);
3324
Zhu Yi397ae122006-01-24 16:37:22 +08003325#ifdef CONFIG_PM
3326 if (!fw_loaded) {
3327#endif
3328 rc = ipw_get_fw(priv, &firmware, fw_name);
3329 if (rc < 0)
3330 goto error;
3331#ifdef CONFIG_PM
3332 }
3333#endif
3334
James Ketrenos43f66a62005-03-25 12:31:53 -06003335 /* DMA bss firmware into the device */
Jeff Garzikbf794512005-07-31 13:07:26 -04003336 rc = ipw_load_firmware(priv, firmware->data +
3337 sizeof(struct fw_header),
James Ketrenos43f66a62005-03-25 12:31:53 -06003338 firmware->size - sizeof(struct fw_header));
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003339 if (rc < 0) {
Peter Jonesa4f6bbb2005-08-26 00:33:34 -05003340 IPW_ERROR("Unable to load firmware: %d\n", rc);
James Ketrenos43f66a62005-03-25 12:31:53 -06003341 goto error;
3342 }
Zhu Yi397ae122006-01-24 16:37:22 +08003343#ifdef CONFIG_PM
3344 fw_loaded = 1;
3345#endif
3346
James Ketrenos43f66a62005-03-25 12:31:53 -06003347 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3348
3349 rc = ipw_queue_reset(priv);
Zhu Yi397ae122006-01-24 16:37:22 +08003350 if (rc < 0) {
James Ketrenos43f66a62005-03-25 12:31:53 -06003351 IPW_ERROR("Unable to initialize queues\n");
3352 goto error;
3353 }
3354
3355 /* Ensure interrupts are disabled */
James Ketrenosb095c382005-08-24 22:04:42 -05003356 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
James Ketrenosc848d0a2005-08-24 21:56:24 -05003357 /* ack pending interrupts */
James Ketrenosb095c382005-08-24 22:04:42 -05003358 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
Jeff Garzikbf794512005-07-31 13:07:26 -04003359
James Ketrenos43f66a62005-03-25 12:31:53 -06003360 /* kick start the device */
3361 ipw_start_nic(priv);
3362
James Ketrenosb095c382005-08-24 22:04:42 -05003363 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
James Ketrenos43f66a62005-03-25 12:31:53 -06003364 if (retries > 0) {
3365 IPW_WARNING("Parity error. Retrying init.\n");
3366 retries--;
3367 goto retry;
3368 }
3369
3370 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3371 rc = -EIO;
3372 goto error;
3373 }
3374
3375 /* wait for the device */
James Ketrenosb095c382005-08-24 22:04:42 -05003376 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3377 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
James Ketrenos43f66a62005-03-25 12:31:53 -06003378 if (rc < 0) {
Zhu Yic7b6a672006-01-24 16:37:05 +08003379 IPW_ERROR("device failed to start within 500ms\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06003380 goto error;
3381 }
3382 IPW_DEBUG_INFO("device response after %dms\n", rc);
3383
3384 /* ack fw init done interrupt */
James Ketrenosb095c382005-08-24 22:04:42 -05003385 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
James Ketrenos43f66a62005-03-25 12:31:53 -06003386
3387 /* read eeprom data and initialize the eeprom region of sram */
3388 priv->eeprom_delay = 1;
Jeff Garzikbf794512005-07-31 13:07:26 -04003389 ipw_eeprom_init_sram(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -06003390
3391 /* enable interrupts */
3392 ipw_enable_interrupts(priv);
3393
3394 /* Ensure our queue has valid packets */
3395 ipw_rx_queue_replenish(priv);
3396
James Ketrenosb095c382005-08-24 22:04:42 -05003397 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
James Ketrenos43f66a62005-03-25 12:31:53 -06003398
3399 /* ack pending interrupts */
James Ketrenosb095c382005-08-24 22:04:42 -05003400 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
James Ketrenos43f66a62005-03-25 12:31:53 -06003401
3402#ifndef CONFIG_PM
3403 release_firmware(bootfw);
3404 release_firmware(ucode);
3405 release_firmware(firmware);
3406#endif
3407 return 0;
3408
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003409 error:
James Ketrenos43f66a62005-03-25 12:31:53 -06003410 if (priv->rxq) {
3411 ipw_rx_queue_free(priv, priv->rxq);
3412 priv->rxq = NULL;
3413 }
3414 ipw_tx_queue_free(priv);
3415 if (bootfw)
3416 release_firmware(bootfw);
3417 if (ucode)
3418 release_firmware(ucode);
3419 if (firmware)
3420 release_firmware(firmware);
3421#ifdef CONFIG_PM
3422 fw_loaded = 0;
3423 bootfw = ucode = firmware = NULL;
3424#endif
3425
3426 return rc;
3427}
3428
Jeff Garzikbf794512005-07-31 13:07:26 -04003429/**
James Ketrenos43f66a62005-03-25 12:31:53 -06003430 * DMA services
3431 *
3432 * Theory of operation
3433 *
3434 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3435 * 2 empty entries always kept in the buffer to protect from overflow.
3436 *
3437 * For Tx queue, there are low mark and high mark limits. If, after queuing
Jeff Garzikbf794512005-07-31 13:07:26 -04003438 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3439 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
James Ketrenos43f66a62005-03-25 12:31:53 -06003440 * Tx queue resumed.
3441 *
3442 * The IPW operates with six queues, one receive queue in the device's
3443 * sram, one transmit queue for sending commands to the device firmware,
Jeff Garzikbf794512005-07-31 13:07:26 -04003444 * and four transmit queues for data.
James Ketrenos43f66a62005-03-25 12:31:53 -06003445 *
Jeff Garzikbf794512005-07-31 13:07:26 -04003446 * The four transmit queues allow for performing quality of service (qos)
James Ketrenos43f66a62005-03-25 12:31:53 -06003447 * transmissions as per the 802.11 protocol. Currently Linux does not
Jeff Garzikbf794512005-07-31 13:07:26 -04003448 * provide a mechanism to the user for utilizing prioritized queues, so
James Ketrenos43f66a62005-03-25 12:31:53 -06003449 * we only utilize the first data transmit queue (queue1).
3450 */
3451
3452/**
3453 * Driver allocates buffers of this size for Rx
3454 */
3455
3456static inline int ipw_queue_space(const struct clx2_queue *q)
3457{
3458 int s = q->last_used - q->first_empty;
3459 if (s <= 0)
3460 s += q->n_bd;
3461 s -= 2; /* keep some reserve to not confuse empty and full situations */
3462 if (s < 0)
3463 s = 0;
3464 return s;
3465}
3466
3467static inline int ipw_queue_inc_wrap(int index, int n_bd)
3468{
3469 return (++index == n_bd) ? 0 : index;
3470}
3471
3472/**
3473 * Initialize common DMA queue structure
Jeff Garzikbf794512005-07-31 13:07:26 -04003474 *
James Ketrenos43f66a62005-03-25 12:31:53 -06003475 * @param q queue to init
3476 * @param count Number of BD's to allocate. Should be power of 2
3477 * @param read_register Address for 'read' register
3478 * (not offset within BAR, full address)
3479 * @param write_register Address for 'write' register
3480 * (not offset within BAR, full address)
3481 * @param base_register Address for 'base' register
3482 * (not offset within BAR, full address)
3483 * @param size Address for 'size' register
3484 * (not offset within BAR, full address)
3485 */
Jeff Garzikbf794512005-07-31 13:07:26 -04003486static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003487 int count, u32 read, u32 write, u32 base, u32 size)
James Ketrenos43f66a62005-03-25 12:31:53 -06003488{
3489 q->n_bd = count;
3490
3491 q->low_mark = q->n_bd / 4;
3492 if (q->low_mark < 4)
3493 q->low_mark = 4;
3494
3495 q->high_mark = q->n_bd / 8;
3496 if (q->high_mark < 2)
3497 q->high_mark = 2;
3498
3499 q->first_empty = q->last_used = 0;
3500 q->reg_r = read;
3501 q->reg_w = write;
3502
3503 ipw_write32(priv, base, q->dma_addr);
3504 ipw_write32(priv, size, count);
3505 ipw_write32(priv, read, 0);
3506 ipw_write32(priv, write, 0);
3507
3508 _ipw_read32(priv, 0x90);
3509}
3510
Jeff Garzikbf794512005-07-31 13:07:26 -04003511static int ipw_queue_tx_init(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -06003512 struct clx2_tx_queue *q,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003513 int count, u32 read, u32 write, u32 base, u32 size)
James Ketrenos43f66a62005-03-25 12:31:53 -06003514{
3515 struct pci_dev *dev = priv->pci_dev;
3516
3517 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3518 if (!q->txb) {
3519 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3520 return -ENOMEM;
3521 }
3522
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003523 q->bd =
3524 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
James Ketrenos43f66a62005-03-25 12:31:53 -06003525 if (!q->bd) {
Jiri Bencaaa4d302005-06-07 14:58:41 +02003526 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003527 sizeof(q->bd[0]) * count);
James Ketrenos43f66a62005-03-25 12:31:53 -06003528 kfree(q->txb);
3529 q->txb = NULL;
3530 return -ENOMEM;
3531 }
3532
3533 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3534 return 0;
3535}
3536
3537/**
3538 * Free one TFD, those at index [txq->q.last_used].
3539 * Do NOT advance any indexes
Jeff Garzikbf794512005-07-31 13:07:26 -04003540 *
James Ketrenos43f66a62005-03-25 12:31:53 -06003541 * @param dev
3542 * @param txq
3543 */
3544static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3545 struct clx2_tx_queue *txq)
3546{
3547 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3548 struct pci_dev *dev = priv->pci_dev;
3549 int i;
Jeff Garzikbf794512005-07-31 13:07:26 -04003550
James Ketrenos43f66a62005-03-25 12:31:53 -06003551 /* classify bd */
3552 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3553 /* nothing to cleanup after for host commands */
3554 return;
3555
3556 /* sanity check */
James Ketrenosa613bff2005-08-24 21:43:11 -05003557 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3558 IPW_ERROR("Too many chunks: %i\n",
3559 le32_to_cpu(bd->u.data.num_chunks));
James Ketrenos43f66a62005-03-25 12:31:53 -06003560 /** @todo issue fatal error, it is quite serious situation */
3561 return;
3562 }
3563
3564 /* unmap chunks if any */
James Ketrenosa613bff2005-08-24 21:43:11 -05003565 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3566 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3567 le16_to_cpu(bd->u.data.chunk_len[i]),
3568 PCI_DMA_TODEVICE);
James Ketrenos43f66a62005-03-25 12:31:53 -06003569 if (txq->txb[txq->q.last_used]) {
3570 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3571 txq->txb[txq->q.last_used] = NULL;
3572 }
3573 }
3574}
3575
3576/**
3577 * Deallocate DMA queue.
Jeff Garzikbf794512005-07-31 13:07:26 -04003578 *
James Ketrenos43f66a62005-03-25 12:31:53 -06003579 * Empty queue by removing and destroying all BD's.
3580 * Free all buffers.
Jeff Garzikbf794512005-07-31 13:07:26 -04003581 *
James Ketrenos43f66a62005-03-25 12:31:53 -06003582 * @param dev
3583 * @param q
3584 */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003585static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
James Ketrenos43f66a62005-03-25 12:31:53 -06003586{
3587 struct clx2_queue *q = &txq->q;
3588 struct pci_dev *dev = priv->pci_dev;
3589
Jeff Garzikbf794512005-07-31 13:07:26 -04003590 if (q->n_bd == 0)
3591 return;
James Ketrenos43f66a62005-03-25 12:31:53 -06003592
3593 /* first, empty all BD's */
3594 for (; q->first_empty != q->last_used;
3595 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3596 ipw_queue_tx_free_tfd(priv, txq);
3597 }
Jeff Garzikbf794512005-07-31 13:07:26 -04003598
James Ketrenos43f66a62005-03-25 12:31:53 -06003599 /* free buffers belonging to queue itself */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003600 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
James Ketrenos43f66a62005-03-25 12:31:53 -06003601 q->dma_addr);
3602 kfree(txq->txb);
3603
3604 /* 0 fill whole structure */
3605 memset(txq, 0, sizeof(*txq));
3606}
3607
James Ketrenos43f66a62005-03-25 12:31:53 -06003608/**
3609 * Destroy all DMA queues and structures
Jeff Garzikbf794512005-07-31 13:07:26 -04003610 *
James Ketrenos43f66a62005-03-25 12:31:53 -06003611 * @param priv
3612 */
3613static void ipw_tx_queue_free(struct ipw_priv *priv)
3614{
3615 /* Tx CMD queue */
3616 ipw_queue_tx_free(priv, &priv->txq_cmd);
3617
3618 /* Tx queues */
3619 ipw_queue_tx_free(priv, &priv->txq[0]);
3620 ipw_queue_tx_free(priv, &priv->txq[1]);
3621 ipw_queue_tx_free(priv, &priv->txq[2]);
3622 ipw_queue_tx_free(priv, &priv->txq[3]);
3623}
3624
Arjan van de Ven858119e2006-01-14 13:20:43 -08003625static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
James Ketrenos43f66a62005-03-25 12:31:53 -06003626{
3627 /* First 3 bytes are manufacturer */
3628 bssid[0] = priv->mac_addr[0];
3629 bssid[1] = priv->mac_addr[1];
3630 bssid[2] = priv->mac_addr[2];
3631
3632 /* Last bytes are random */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003633 get_random_bytes(&bssid[3], ETH_ALEN - 3);
James Ketrenos43f66a62005-03-25 12:31:53 -06003634
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003635 bssid[0] &= 0xfe; /* clear multicast bit */
3636 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
James Ketrenos43f66a62005-03-25 12:31:53 -06003637}
3638
Arjan van de Ven858119e2006-01-14 13:20:43 -08003639static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
James Ketrenos43f66a62005-03-25 12:31:53 -06003640{
3641 struct ipw_station_entry entry;
3642 int i;
3643
3644 for (i = 0; i < priv->num_stations; i++) {
3645 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3646 /* Another node is active in network */
3647 priv->missed_adhoc_beacons = 0;
3648 if (!(priv->config & CFG_STATIC_CHANNEL))
3649 /* when other nodes drop out, we drop out */
3650 priv->config &= ~CFG_ADHOC_PERSIST;
3651
3652 return i;
3653 }
3654 }
3655
3656 if (i == MAX_STATIONS)
3657 return IPW_INVALID_STATION;
3658
3659 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3660
3661 entry.reserved = 0;
3662 entry.support_mode = 0;
3663 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3664 memcpy(priv->stations[i], bssid, ETH_ALEN);
3665 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003666 &entry, sizeof(entry));
James Ketrenos43f66a62005-03-25 12:31:53 -06003667 priv->num_stations++;
3668
3669 return i;
3670}
3671
Arjan van de Ven858119e2006-01-14 13:20:43 -08003672static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
James Ketrenos43f66a62005-03-25 12:31:53 -06003673{
3674 int i;
3675
Jeff Garzikbf794512005-07-31 13:07:26 -04003676 for (i = 0; i < priv->num_stations; i++)
3677 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
James Ketrenos43f66a62005-03-25 12:31:53 -06003678 return i;
3679
3680 return IPW_INVALID_STATION;
3681}
3682
3683static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3684{
3685 int err;
3686
Hong Liu7b996592005-08-25 17:36:13 +08003687 if (priv->status & STATUS_ASSOCIATING) {
3688 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3689 queue_work(priv->workqueue, &priv->disassociate);
3690 return;
3691 }
3692
3693 if (!(priv->status & STATUS_ASSOCIATED)) {
James Ketrenos43f66a62005-03-25 12:31:53 -06003694 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3695 return;
3696 }
3697
3698 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3699 "on channel %d.\n",
Jeff Garzikbf794512005-07-31 13:07:26 -04003700 MAC_ARG(priv->assoc_request.bssid),
James Ketrenos43f66a62005-03-25 12:31:53 -06003701 priv->assoc_request.channel);
3702
3703 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3704 priv->status |= STATUS_DISASSOCIATING;
3705
3706 if (quiet)
3707 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3708 else
3709 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
Hong Liue6324722005-09-14 21:04:15 -05003710
James Ketrenos43f66a62005-03-25 12:31:53 -06003711 err = ipw_send_associate(priv, &priv->assoc_request);
3712 if (err) {
3713 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3714 "failed.\n");
3715 return;
3716 }
3717
3718}
3719
James Ketrenosc848d0a2005-08-24 21:56:24 -05003720static int ipw_disassociate(void *data)
James Ketrenos43f66a62005-03-25 12:31:53 -06003721{
James Ketrenosc848d0a2005-08-24 21:56:24 -05003722 struct ipw_priv *priv = data;
3723 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3724 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06003725 ipw_send_disassociate(data, 0);
James Ketrenosc848d0a2005-08-24 21:56:24 -05003726 return 1;
James Ketrenos43f66a62005-03-25 12:31:53 -06003727}
3728
James Ketrenosc848d0a2005-08-24 21:56:24 -05003729static void ipw_bg_disassociate(void *data)
James Ketrenos43f66a62005-03-25 12:31:53 -06003730{
James Ketrenosc848d0a2005-08-24 21:56:24 -05003731 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08003732 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05003733 ipw_disassociate(data);
Zhu Yi46441512006-01-24 16:37:59 +08003734 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06003735}
3736
Zhu Yid8bad6d2005-07-13 12:25:38 -05003737static void ipw_system_config(void *data)
3738{
3739 struct ipw_priv *priv = data;
3740 ipw_send_system_config(priv, &priv->sys_config);
James Ketrenos43f66a62005-03-25 12:31:53 -06003741}
3742
3743struct ipw_status_code {
3744 u16 status;
3745 const char *reason;
3746};
3747
3748static const struct ipw_status_code ipw_status_codes[] = {
3749 {0x00, "Successful"},
3750 {0x01, "Unspecified failure"},
3751 {0x0A, "Cannot support all requested capabilities in the "
3752 "Capability information field"},
3753 {0x0B, "Reassociation denied due to inability to confirm that "
3754 "association exists"},
3755 {0x0C, "Association denied due to reason outside the scope of this "
3756 "standard"},
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003757 {0x0D,
3758 "Responding station does not support the specified authentication "
James Ketrenos43f66a62005-03-25 12:31:53 -06003759 "algorithm"},
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003760 {0x0E,
3761 "Received an Authentication frame with authentication sequence "
James Ketrenos43f66a62005-03-25 12:31:53 -06003762 "transaction sequence number out of expected sequence"},
3763 {0x0F, "Authentication rejected because of challenge failure"},
3764 {0x10, "Authentication rejected due to timeout waiting for next "
3765 "frame in sequence"},
3766 {0x11, "Association denied because AP is unable to handle additional "
3767 "associated stations"},
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003768 {0x12,
3769 "Association denied due to requesting station not supporting all "
James Ketrenos43f66a62005-03-25 12:31:53 -06003770 "of the datarates in the BSSBasicServiceSet Parameter"},
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003771 {0x13,
3772 "Association denied due to requesting station not supporting "
James Ketrenos43f66a62005-03-25 12:31:53 -06003773 "short preamble operation"},
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003774 {0x14,
3775 "Association denied due to requesting station not supporting "
James Ketrenos43f66a62005-03-25 12:31:53 -06003776 "PBCC encoding"},
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003777 {0x15,
3778 "Association denied due to requesting station not supporting "
James Ketrenos43f66a62005-03-25 12:31:53 -06003779 "channel agility"},
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003780 {0x19,
3781 "Association denied due to requesting station not supporting "
James Ketrenos43f66a62005-03-25 12:31:53 -06003782 "short slot operation"},
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003783 {0x1A,
3784 "Association denied due to requesting station not supporting "
James Ketrenos43f66a62005-03-25 12:31:53 -06003785 "DSSS-OFDM operation"},
3786 {0x28, "Invalid Information Element"},
3787 {0x29, "Group Cipher is not valid"},
3788 {0x2A, "Pairwise Cipher is not valid"},
3789 {0x2B, "AKMP is not valid"},
3790 {0x2C, "Unsupported RSN IE version"},
3791 {0x2D, "Invalid RSN IE Capabilities"},
3792 {0x2E, "Cipher suite is rejected per security policy"},
3793};
3794
Brice Goglin0f52bf92005-12-01 01:41:46 -08003795#ifdef CONFIG_IPW2200_DEBUG
Jeff Garzikbf794512005-07-31 13:07:26 -04003796static const char *ipw_get_status_code(u16 status)
James Ketrenos43f66a62005-03-25 12:31:53 -06003797{
3798 int i;
Jeff Garzikbf794512005-07-31 13:07:26 -04003799 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
James Ketrenosea2b26e2005-08-24 21:25:16 -05003800 if (ipw_status_codes[i].status == (status & 0xff))
James Ketrenos43f66a62005-03-25 12:31:53 -06003801 return ipw_status_codes[i].reason;
3802 return "Unknown status value.";
3803}
3804#endif
3805
3806static void inline average_init(struct average *avg)
3807{
3808 memset(avg, 0, sizeof(*avg));
3809}
3810
Arjan van de Ven858119e2006-01-14 13:20:43 -08003811static void average_add(struct average *avg, s16 val)
James Ketrenos43f66a62005-03-25 12:31:53 -06003812{
3813 avg->sum -= avg->entries[avg->pos];
3814 avg->sum += val;
3815 avg->entries[avg->pos++] = val;
3816 if (unlikely(avg->pos == AVG_ENTRIES)) {
3817 avg->init = 1;
3818 avg->pos = 0;
3819 }
3820}
3821
Arjan van de Ven858119e2006-01-14 13:20:43 -08003822static s16 average_value(struct average *avg)
James Ketrenos43f66a62005-03-25 12:31:53 -06003823{
3824 if (!unlikely(avg->init)) {
3825 if (avg->pos)
3826 return avg->sum / avg->pos;
3827 return 0;
3828 }
3829
3830 return avg->sum / AVG_ENTRIES;
3831}
3832
3833static void ipw_reset_stats(struct ipw_priv *priv)
3834{
3835 u32 len = sizeof(u32);
3836
3837 priv->quality = 0;
3838
3839 average_init(&priv->average_missed_beacons);
3840 average_init(&priv->average_rssi);
3841 average_init(&priv->average_noise);
3842
3843 priv->last_rate = 0;
3844 priv->last_missed_beacons = 0;
3845 priv->last_rx_packets = 0;
3846 priv->last_tx_packets = 0;
3847 priv->last_tx_failures = 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04003848
James Ketrenos43f66a62005-03-25 12:31:53 -06003849 /* Firmware managed, reset only when NIC is restarted, so we have to
3850 * normalize on the current value */
Jeff Garzikbf794512005-07-31 13:07:26 -04003851 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
James Ketrenos43f66a62005-03-25 12:31:53 -06003852 &priv->last_rx_err, &len);
Jeff Garzikbf794512005-07-31 13:07:26 -04003853 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
James Ketrenos43f66a62005-03-25 12:31:53 -06003854 &priv->last_tx_failures, &len);
3855
3856 /* Driver managed, reset with each association */
3857 priv->missed_adhoc_beacons = 0;
3858 priv->missed_beacons = 0;
3859 priv->tx_packets = 0;
3860 priv->rx_packets = 0;
3861
3862}
3863
Arjan van de Ven858119e2006-01-14 13:20:43 -08003864static u32 ipw_get_max_rate(struct ipw_priv *priv)
James Ketrenos43f66a62005-03-25 12:31:53 -06003865{
3866 u32 i = 0x80000000;
3867 u32 mask = priv->rates_mask;
3868 /* If currently associated in B mode, restrict the maximum
3869 * rate match to B rates */
3870 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3871 mask &= IEEE80211_CCK_RATES_MASK;
3872
3873 /* TODO: Verify that the rate is supported by the current rates
3874 * list. */
3875
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003876 while (i && !(mask & i))
3877 i >>= 1;
James Ketrenos43f66a62005-03-25 12:31:53 -06003878 switch (i) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05003879 case IEEE80211_CCK_RATE_1MB_MASK:
3880 return 1000000;
3881 case IEEE80211_CCK_RATE_2MB_MASK:
3882 return 2000000;
3883 case IEEE80211_CCK_RATE_5MB_MASK:
3884 return 5500000;
3885 case IEEE80211_OFDM_RATE_6MB_MASK:
3886 return 6000000;
3887 case IEEE80211_OFDM_RATE_9MB_MASK:
3888 return 9000000;
3889 case IEEE80211_CCK_RATE_11MB_MASK:
3890 return 11000000;
3891 case IEEE80211_OFDM_RATE_12MB_MASK:
3892 return 12000000;
3893 case IEEE80211_OFDM_RATE_18MB_MASK:
3894 return 18000000;
3895 case IEEE80211_OFDM_RATE_24MB_MASK:
3896 return 24000000;
3897 case IEEE80211_OFDM_RATE_36MB_MASK:
3898 return 36000000;
3899 case IEEE80211_OFDM_RATE_48MB_MASK:
3900 return 48000000;
3901 case IEEE80211_OFDM_RATE_54MB_MASK:
3902 return 54000000;
James Ketrenos43f66a62005-03-25 12:31:53 -06003903 }
3904
Jeff Garzikbf794512005-07-31 13:07:26 -04003905 if (priv->ieee->mode == IEEE_B)
James Ketrenos43f66a62005-03-25 12:31:53 -06003906 return 11000000;
3907 else
3908 return 54000000;
3909}
3910
3911static u32 ipw_get_current_rate(struct ipw_priv *priv)
3912{
3913 u32 rate, len = sizeof(rate);
3914 int err;
3915
Jeff Garzikbf794512005-07-31 13:07:26 -04003916 if (!(priv->status & STATUS_ASSOCIATED))
James Ketrenos43f66a62005-03-25 12:31:53 -06003917 return 0;
3918
3919 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
Jeff Garzikbf794512005-07-31 13:07:26 -04003920 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
James Ketrenos43f66a62005-03-25 12:31:53 -06003921 &len);
3922 if (err) {
3923 IPW_DEBUG_INFO("failed querying ordinals.\n");
3924 return 0;
3925 }
Jeff Garzikbf794512005-07-31 13:07:26 -04003926 } else
James Ketrenos43f66a62005-03-25 12:31:53 -06003927 return ipw_get_max_rate(priv);
3928
3929 switch (rate) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05003930 case IPW_TX_RATE_1MB:
3931 return 1000000;
3932 case IPW_TX_RATE_2MB:
3933 return 2000000;
3934 case IPW_TX_RATE_5MB:
3935 return 5500000;
3936 case IPW_TX_RATE_6MB:
3937 return 6000000;
3938 case IPW_TX_RATE_9MB:
3939 return 9000000;
3940 case IPW_TX_RATE_11MB:
3941 return 11000000;
3942 case IPW_TX_RATE_12MB:
3943 return 12000000;
3944 case IPW_TX_RATE_18MB:
3945 return 18000000;
3946 case IPW_TX_RATE_24MB:
3947 return 24000000;
3948 case IPW_TX_RATE_36MB:
3949 return 36000000;
3950 case IPW_TX_RATE_48MB:
3951 return 48000000;
3952 case IPW_TX_RATE_54MB:
3953 return 54000000;
James Ketrenos43f66a62005-03-25 12:31:53 -06003954 }
3955
3956 return 0;
3957}
3958
James Ketrenos43f66a62005-03-25 12:31:53 -06003959#define IPW_STATS_INTERVAL (2 * HZ)
3960static void ipw_gather_stats(struct ipw_priv *priv)
3961{
3962 u32 rx_err, rx_err_delta, rx_packets_delta;
3963 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3964 u32 missed_beacons_percent, missed_beacons_delta;
3965 u32 quality = 0;
3966 u32 len = sizeof(u32);
3967 s16 rssi;
Jeff Garzikbf794512005-07-31 13:07:26 -04003968 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003969 rate_quality;
James Ketrenosea2b26e2005-08-24 21:25:16 -05003970 u32 max_rate;
James Ketrenos43f66a62005-03-25 12:31:53 -06003971
3972 if (!(priv->status & STATUS_ASSOCIATED)) {
3973 priv->quality = 0;
3974 return;
3975 }
3976
3977 /* Update the statistics */
Jeff Garzikbf794512005-07-31 13:07:26 -04003978 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
James Ketrenos43f66a62005-03-25 12:31:53 -06003979 &priv->missed_beacons, &len);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003980 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
James Ketrenos43f66a62005-03-25 12:31:53 -06003981 priv->last_missed_beacons = priv->missed_beacons;
3982 if (priv->assoc_request.beacon_interval) {
3983 missed_beacons_percent = missed_beacons_delta *
Jeff Garzik0edd5b42005-09-07 00:48:31 -04003984 (HZ * priv->assoc_request.beacon_interval) /
3985 (IPW_STATS_INTERVAL * 10);
James Ketrenos43f66a62005-03-25 12:31:53 -06003986 } else {
3987 missed_beacons_percent = 0;
3988 }
3989 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3990
3991 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3992 rx_err_delta = rx_err - priv->last_rx_err;
3993 priv->last_rx_err = rx_err;
3994
3995 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3996 tx_failures_delta = tx_failures - priv->last_tx_failures;
3997 priv->last_tx_failures = tx_failures;
3998
3999 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4000 priv->last_rx_packets = priv->rx_packets;
4001
4002 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4003 priv->last_tx_packets = priv->tx_packets;
4004
4005 /* Calculate quality based on the following:
Jeff Garzikbf794512005-07-31 13:07:26 -04004006 *
James Ketrenos43f66a62005-03-25 12:31:53 -06004007 * Missed beacon: 100% = 0, 0% = 70% missed
4008 * Rate: 60% = 1Mbs, 100% = Max
4009 * Rx and Tx errors represent a straight % of total Rx/Tx
4010 * RSSI: 100% = > -50, 0% = < -80
4011 * Rx errors: 100% = 0, 0% = 50% missed
Jeff Garzikbf794512005-07-31 13:07:26 -04004012 *
James Ketrenos43f66a62005-03-25 12:31:53 -06004013 * The lowest computed quality is used.
4014 *
4015 */
4016#define BEACON_THRESHOLD 5
4017 beacon_quality = 100 - missed_beacons_percent;
4018 if (beacon_quality < BEACON_THRESHOLD)
4019 beacon_quality = 0;
4020 else
Jeff Garzikbf794512005-07-31 13:07:26 -04004021 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004022 (100 - BEACON_THRESHOLD);
Jeff Garzikbf794512005-07-31 13:07:26 -04004023 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06004024 beacon_quality, missed_beacons_percent);
Jeff Garzikbf794512005-07-31 13:07:26 -04004025
James Ketrenos43f66a62005-03-25 12:31:53 -06004026 priv->last_rate = ipw_get_current_rate(priv);
James Ketrenosea2b26e2005-08-24 21:25:16 -05004027 max_rate = ipw_get_max_rate(priv);
4028 rate_quality = priv->last_rate * 40 / max_rate + 60;
James Ketrenos43f66a62005-03-25 12:31:53 -06004029 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4030 rate_quality, priv->last_rate / 1000000);
Jeff Garzikbf794512005-07-31 13:07:26 -04004031
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004032 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
Jeff Garzikbf794512005-07-31 13:07:26 -04004033 rx_quality = 100 - (rx_err_delta * 100) /
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004034 (rx_packets_delta + rx_err_delta);
James Ketrenos43f66a62005-03-25 12:31:53 -06004035 else
4036 rx_quality = 100;
4037 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4038 rx_quality, rx_err_delta, rx_packets_delta);
Jeff Garzikbf794512005-07-31 13:07:26 -04004039
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004040 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
Jeff Garzikbf794512005-07-31 13:07:26 -04004041 tx_quality = 100 - (tx_failures_delta * 100) /
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004042 (tx_packets_delta + tx_failures_delta);
James Ketrenos43f66a62005-03-25 12:31:53 -06004043 else
4044 tx_quality = 100;
4045 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4046 tx_quality, tx_failures_delta, tx_packets_delta);
Jeff Garzikbf794512005-07-31 13:07:26 -04004047
James Ketrenos43f66a62005-03-25 12:31:53 -06004048 rssi = average_value(&priv->average_rssi);
James Ketrenosc848d0a2005-08-24 21:56:24 -05004049 signal_quality =
4050 (100 *
4051 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4052 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4053 (priv->ieee->perfect_rssi - rssi) *
4054 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4055 62 * (priv->ieee->perfect_rssi - rssi))) /
4056 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4057 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4058 if (signal_quality > 100)
James Ketrenos43f66a62005-03-25 12:31:53 -06004059 signal_quality = 100;
James Ketrenosc848d0a2005-08-24 21:56:24 -05004060 else if (signal_quality < 1)
James Ketrenos43f66a62005-03-25 12:31:53 -06004061 signal_quality = 0;
James Ketrenosea2b26e2005-08-24 21:25:16 -05004062
James Ketrenos43f66a62005-03-25 12:31:53 -06004063 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4064 signal_quality, rssi);
Jeff Garzikbf794512005-07-31 13:07:26 -04004065
4066 quality = min(beacon_quality,
James Ketrenos43f66a62005-03-25 12:31:53 -06004067 min(rate_quality,
4068 min(tx_quality, min(rx_quality, signal_quality))));
4069 if (quality == beacon_quality)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004070 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4071 quality);
James Ketrenos43f66a62005-03-25 12:31:53 -06004072 if (quality == rate_quality)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004073 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4074 quality);
James Ketrenos43f66a62005-03-25 12:31:53 -06004075 if (quality == tx_quality)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004076 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4077 quality);
James Ketrenos43f66a62005-03-25 12:31:53 -06004078 if (quality == rx_quality)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004079 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4080 quality);
James Ketrenos43f66a62005-03-25 12:31:53 -06004081 if (quality == signal_quality)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004082 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4083 quality);
James Ketrenos43f66a62005-03-25 12:31:53 -06004084
4085 priv->quality = quality;
Jeff Garzikbf794512005-07-31 13:07:26 -04004086
4087 queue_delayed_work(priv->workqueue, &priv->gather_stats,
James Ketrenos43f66a62005-03-25 12:31:53 -06004088 IPW_STATS_INTERVAL);
4089}
4090
James Ketrenosc848d0a2005-08-24 21:56:24 -05004091static void ipw_bg_gather_stats(void *data)
4092{
4093 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08004094 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05004095 ipw_gather_stats(data);
Zhu Yi46441512006-01-24 16:37:59 +08004096 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05004097}
4098
Ben Cahille7582562005-10-06 15:34:41 -05004099/* Missed beacon behavior:
4100 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4101 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4102 * Above disassociate threshold, give up and stop scanning.
4103 * Roaming is disabled if disassociate_threshold <= roaming_threshold */
Arjan van de Ven858119e2006-01-14 13:20:43 -08004104static void ipw_handle_missed_beacon(struct ipw_priv *priv,
James Ketrenosea2b26e2005-08-24 21:25:16 -05004105 int missed_count)
4106{
4107 priv->notif_missed_beacons = missed_count;
4108
James Ketrenosafbf30a2005-08-25 00:05:33 -05004109 if (missed_count > priv->disassociate_threshold &&
James Ketrenosea2b26e2005-08-24 21:25:16 -05004110 priv->status & STATUS_ASSOCIATED) {
4111 /* If associated and we've hit the missed
4112 * beacon threshold, disassociate, turn
4113 * off roaming, and abort any active scans */
4114 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
James Ketrenosafbf30a2005-08-25 00:05:33 -05004115 IPW_DL_STATE | IPW_DL_ASSOC,
James Ketrenosea2b26e2005-08-24 21:25:16 -05004116 "Missed beacon: %d - disassociate\n", missed_count);
4117 priv->status &= ~STATUS_ROAMING;
James Ketrenosa613bff2005-08-24 21:43:11 -05004118 if (priv->status & STATUS_SCANNING) {
4119 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4120 IPW_DL_STATE,
4121 "Aborting scan with missed beacon.\n");
James Ketrenosea2b26e2005-08-24 21:25:16 -05004122 queue_work(priv->workqueue, &priv->abort_scan);
James Ketrenosa613bff2005-08-24 21:43:11 -05004123 }
4124
James Ketrenosea2b26e2005-08-24 21:25:16 -05004125 queue_work(priv->workqueue, &priv->disassociate);
4126 return;
4127 }
4128
4129 if (priv->status & STATUS_ROAMING) {
4130 /* If we are currently roaming, then just
4131 * print a debug statement... */
4132 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4133 "Missed beacon: %d - roam in progress\n",
4134 missed_count);
4135 return;
4136 }
4137
Zhu Yi4bfdb912006-01-24 16:37:16 +08004138 if (roaming &&
4139 (missed_count > priv->roaming_threshold &&
4140 missed_count <= priv->disassociate_threshold)) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05004141 /* If we are not already roaming, set the ROAM
Ben Cahille7582562005-10-06 15:34:41 -05004142 * bit in the status and kick off a scan.
4143 * This can happen several times before we reach
4144 * disassociate_threshold. */
James Ketrenosea2b26e2005-08-24 21:25:16 -05004145 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4146 "Missed beacon: %d - initiate "
4147 "roaming\n", missed_count);
4148 if (!(priv->status & STATUS_ROAMING)) {
4149 priv->status |= STATUS_ROAMING;
4150 if (!(priv->status & STATUS_SCANNING))
4151 queue_work(priv->workqueue,
4152 &priv->request_scan);
4153 }
4154 return;
4155 }
4156
4157 if (priv->status & STATUS_SCANNING) {
4158 /* Stop scan to keep fw from getting
4159 * stuck (only if we aren't roaming --
4160 * otherwise we'll never scan more than 2 or 3
4161 * channels..) */
James Ketrenosb095c382005-08-24 22:04:42 -05004162 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4163 "Aborting scan with missed beacon.\n");
James Ketrenosea2b26e2005-08-24 21:25:16 -05004164 queue_work(priv->workqueue, &priv->abort_scan);
4165 }
4166
4167 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
James Ketrenosea2b26e2005-08-24 21:25:16 -05004168}
4169
James Ketrenos43f66a62005-03-25 12:31:53 -06004170/**
4171 * Handle host notification packet.
4172 * Called from interrupt routine
4173 */
Arjan van de Ven858119e2006-01-14 13:20:43 -08004174static void ipw_rx_notification(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -06004175 struct ipw_rx_notification *notif)
4176{
James Ketrenosa613bff2005-08-24 21:43:11 -05004177 notif->size = le16_to_cpu(notif->size);
4178
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004179 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
Jeff Garzikbf794512005-07-31 13:07:26 -04004180
James Ketrenos43f66a62005-03-25 12:31:53 -06004181 switch (notif->subtype) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004182 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4183 struct notif_association *assoc = &notif->u.assoc;
Jeff Garzikbf794512005-07-31 13:07:26 -04004184
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004185 switch (assoc->state) {
4186 case CMAS_ASSOCIATED:{
4187 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4188 IPW_DL_ASSOC,
4189 "associated: '%s' " MAC_FMT
4190 " \n",
4191 escape_essid(priv->essid,
4192 priv->essid_len),
4193 MAC_ARG(priv->bssid));
Jeff Garzikbf794512005-07-31 13:07:26 -04004194
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004195 switch (priv->ieee->iw_mode) {
4196 case IW_MODE_INFRA:
4197 memcpy(priv->ieee->bssid,
4198 priv->bssid, ETH_ALEN);
4199 break;
James Ketrenos43f66a62005-03-25 12:31:53 -06004200
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004201 case IW_MODE_ADHOC:
4202 memcpy(priv->ieee->bssid,
4203 priv->bssid, ETH_ALEN);
Jeff Garzikbf794512005-07-31 13:07:26 -04004204
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004205 /* clear out the station table */
4206 priv->num_stations = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06004207
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004208 IPW_DEBUG_ASSOC
4209 ("queueing adhoc check\n");
4210 queue_delayed_work(priv->
4211 workqueue,
4212 &priv->
4213 adhoc_check,
4214 priv->
4215 assoc_request.
4216 beacon_interval);
4217 break;
4218 }
James Ketrenos43f66a62005-03-25 12:31:53 -06004219
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004220 priv->status &= ~STATUS_ASSOCIATING;
4221 priv->status |= STATUS_ASSOCIATED;
Zhu Yid8bad6d2005-07-13 12:25:38 -05004222 queue_work(priv->workqueue,
4223 &priv->system_config);
James Ketrenos43f66a62005-03-25 12:31:53 -06004224
James Ketrenosb095c382005-08-24 22:04:42 -05004225#ifdef CONFIG_IPW_QOS
James Ketrenosafbf30a2005-08-25 00:05:33 -05004226#define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4227 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4228 if ((priv->status & STATUS_AUTH) &&
4229 (IPW_GET_PACKET_STYPE(&notif->u.raw)
4230 == IEEE80211_STYPE_ASSOC_RESP)) {
James Ketrenosb095c382005-08-24 22:04:42 -05004231 if ((sizeof
4232 (struct
James Ketrenos2b184d52005-08-03 20:33:14 -05004233 ieee80211_assoc_response)
James Ketrenosb095c382005-08-24 22:04:42 -05004234 <= notif->size)
4235 && (notif->size <= 2314)) {
4236 struct
4237 ieee80211_rx_stats
4238 stats = {
4239 .len =
4240 notif->
4241 size - 1,
4242 };
4243
4244 IPW_DEBUG_QOS
4245 ("QoS Associate "
4246 "size %d\n",
4247 notif->size);
4248 ieee80211_rx_mgt(priv->
4249 ieee,
4250 (struct
James Ketrenos2b184d52005-08-03 20:33:14 -05004251 ieee80211_hdr_4addr
James Ketrenosb095c382005-08-24 22:04:42 -05004252 *)
4253 &notif->u.raw, &stats);
4254 }
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004255 }
James Ketrenosb095c382005-08-24 22:04:42 -05004256#endif
James Ketrenos43f66a62005-03-25 12:31:53 -06004257
James Ketrenosa613bff2005-08-24 21:43:11 -05004258 schedule_work(&priv->link_up);
James Ketrenos43f66a62005-03-25 12:31:53 -06004259
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004260 break;
4261 }
4262
4263 case CMAS_AUTHENTICATED:{
4264 if (priv->
4265 status & (STATUS_ASSOCIATED |
4266 STATUS_AUTH)) {
Brice Goglin0f52bf92005-12-01 01:41:46 -08004267#ifdef CONFIG_IPW2200_DEBUG
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004268 struct notif_authenticate *auth
4269 = &notif->u.auth;
4270 IPW_DEBUG(IPW_DL_NOTIF |
4271 IPW_DL_STATE |
4272 IPW_DL_ASSOC,
4273 "deauthenticated: '%s' "
4274 MAC_FMT
4275 ": (0x%04X) - %s \n",
4276 escape_essid(priv->
4277 essid,
4278 priv->
4279 essid_len),
4280 MAC_ARG(priv->bssid),
4281 ntohs(auth->status),
4282 ipw_get_status_code
4283 (ntohs
4284 (auth->status)));
4285#endif
4286
4287 priv->status &=
4288 ~(STATUS_ASSOCIATING |
4289 STATUS_AUTH |
4290 STATUS_ASSOCIATED);
4291
James Ketrenosa613bff2005-08-24 21:43:11 -05004292 schedule_work(&priv->link_down);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004293 break;
4294 }
4295
4296 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4297 IPW_DL_ASSOC,
4298 "authenticated: '%s' " MAC_FMT
4299 "\n",
4300 escape_essid(priv->essid,
4301 priv->essid_len),
4302 MAC_ARG(priv->bssid));
4303 break;
4304 }
4305
4306 case CMAS_INIT:{
James Ketrenosea2b26e2005-08-24 21:25:16 -05004307 if (priv->status & STATUS_AUTH) {
4308 struct
4309 ieee80211_assoc_response
4310 *resp;
4311 resp =
4312 (struct
4313 ieee80211_assoc_response
4314 *)&notif->u.raw;
4315 IPW_DEBUG(IPW_DL_NOTIF |
4316 IPW_DL_STATE |
4317 IPW_DL_ASSOC,
4318 "association failed (0x%04X): %s\n",
4319 ntohs(resp->status),
4320 ipw_get_status_code
4321 (ntohs
4322 (resp->status)));
4323 }
4324
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004325 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4326 IPW_DL_ASSOC,
4327 "disassociated: '%s' " MAC_FMT
4328 " \n",
4329 escape_essid(priv->essid,
4330 priv->essid_len),
4331 MAC_ARG(priv->bssid));
4332
4333 priv->status &=
4334 ~(STATUS_DISASSOCIATING |
4335 STATUS_ASSOCIATING |
4336 STATUS_ASSOCIATED | STATUS_AUTH);
James Ketrenosb095c382005-08-24 22:04:42 -05004337 if (priv->assoc_network
4338 && (priv->assoc_network->
4339 capability &
4340 WLAN_CAPABILITY_IBSS))
4341 ipw_remove_current_network
4342 (priv);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004343
James Ketrenosa613bff2005-08-24 21:43:11 -05004344 schedule_work(&priv->link_down);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004345
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004346 break;
4347 }
4348
James Ketrenosb095c382005-08-24 22:04:42 -05004349 case CMAS_RX_ASSOC_RESP:
4350 break;
4351
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004352 default:
4353 IPW_ERROR("assoc: unknown (%d)\n",
4354 assoc->state);
4355 break;
4356 }
4357
James Ketrenos43f66a62005-03-25 12:31:53 -06004358 break;
4359 }
Jeff Garzikbf794512005-07-31 13:07:26 -04004360
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004361 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4362 struct notif_authenticate *auth = &notif->u.auth;
4363 switch (auth->state) {
4364 case CMAS_AUTHENTICATED:
4365 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4366 "authenticated: '%s' " MAC_FMT " \n",
4367 escape_essid(priv->essid,
4368 priv->essid_len),
4369 MAC_ARG(priv->bssid));
4370 priv->status |= STATUS_AUTH;
4371 break;
4372
4373 case CMAS_INIT:
4374 if (priv->status & STATUS_AUTH) {
4375 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4376 IPW_DL_ASSOC,
4377 "authentication failed (0x%04X): %s\n",
4378 ntohs(auth->status),
4379 ipw_get_status_code(ntohs
4380 (auth->
4381 status)));
4382 }
4383 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4384 IPW_DL_ASSOC,
4385 "deauthenticated: '%s' " MAC_FMT "\n",
4386 escape_essid(priv->essid,
4387 priv->essid_len),
4388 MAC_ARG(priv->bssid));
James Ketrenos43f66a62005-03-25 12:31:53 -06004389
4390 priv->status &= ~(STATUS_ASSOCIATING |
4391 STATUS_AUTH |
4392 STATUS_ASSOCIATED);
4393
James Ketrenosa613bff2005-08-24 21:43:11 -05004394 schedule_work(&priv->link_down);
James Ketrenos43f66a62005-03-25 12:31:53 -06004395 break;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004396
4397 case CMAS_TX_AUTH_SEQ_1:
4398 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4399 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4400 break;
4401 case CMAS_RX_AUTH_SEQ_2:
4402 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4403 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4404 break;
4405 case CMAS_AUTH_SEQ_1_PASS:
4406 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4407 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4408 break;
4409 case CMAS_AUTH_SEQ_1_FAIL:
4410 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4411 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4412 break;
4413 case CMAS_TX_AUTH_SEQ_3:
4414 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4415 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4416 break;
4417 case CMAS_RX_AUTH_SEQ_4:
4418 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4419 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4420 break;
4421 case CMAS_AUTH_SEQ_2_PASS:
4422 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4423 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4424 break;
4425 case CMAS_AUTH_SEQ_2_FAIL:
4426 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4427 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4428 break;
4429 case CMAS_TX_ASSOC:
4430 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4431 IPW_DL_ASSOC, "TX_ASSOC\n");
4432 break;
4433 case CMAS_RX_ASSOC_RESP:
4434 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4435 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
James Ketrenosb095c382005-08-24 22:04:42 -05004436
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004437 break;
4438 case CMAS_ASSOCIATED:
4439 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4440 IPW_DL_ASSOC, "ASSOCIATED\n");
4441 break;
4442 default:
4443 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4444 auth->state);
4445 break;
4446 }
4447 break;
4448 }
4449
4450 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4451 struct notif_channel_result *x =
4452 &notif->u.channel_result;
4453
4454 if (notif->size == sizeof(*x)) {
4455 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4456 x->channel_num);
4457 } else {
4458 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4459 "(should be %zd)\n",
4460 notif->size, sizeof(*x));
4461 }
4462 break;
4463 }
4464
4465 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4466 struct notif_scan_complete *x = &notif->u.scan_complete;
4467 if (notif->size == sizeof(*x)) {
4468 IPW_DEBUG_SCAN
4469 ("Scan completed: type %d, %d channels, "
4470 "%d status\n", x->scan_type,
4471 x->num_channels, x->status);
4472 } else {
4473 IPW_ERROR("Scan completed of wrong size %d "
4474 "(should be %zd)\n",
4475 notif->size, sizeof(*x));
4476 }
4477
4478 priv->status &=
4479 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4480
James Ketrenosa0e04ab2005-08-25 00:49:43 -05004481 wake_up_interruptible(&priv->wait_state);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004482 cancel_delayed_work(&priv->scan_check);
4483
James Ketrenosb095c382005-08-24 22:04:42 -05004484 if (priv->status & STATUS_EXIT_PENDING)
4485 break;
4486
4487 priv->ieee->scans++;
4488
4489#ifdef CONFIG_IPW2200_MONITOR
4490 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05004491 priv->status |= STATUS_SCAN_FORCED;
James Ketrenosb095c382005-08-24 22:04:42 -05004492 queue_work(priv->workqueue,
4493 &priv->request_scan);
4494 break;
4495 }
James Ketrenosafbf30a2005-08-25 00:05:33 -05004496 priv->status &= ~STATUS_SCAN_FORCED;
James Ketrenosb095c382005-08-24 22:04:42 -05004497#endif /* CONFIG_IPW2200_MONITOR */
4498
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004499 if (!(priv->status & (STATUS_ASSOCIATED |
4500 STATUS_ASSOCIATING |
4501 STATUS_ROAMING |
4502 STATUS_DISASSOCIATING)))
4503 queue_work(priv->workqueue, &priv->associate);
4504 else if (priv->status & STATUS_ROAMING) {
Ben Cahille7582562005-10-06 15:34:41 -05004505 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4506 /* If a scan completed and we are in roam mode, then
4507 * the scan that completed was the one requested as a
4508 * result of entering roam... so, schedule the
4509 * roam work */
4510 queue_work(priv->workqueue,
4511 &priv->roam);
4512 else
4513 /* Don't schedule if we aborted the scan */
4514 priv->status &= ~STATUS_ROAMING;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004515 } else if (priv->status & STATUS_SCAN_PENDING)
4516 queue_work(priv->workqueue,
4517 &priv->request_scan);
James Ketrenosa613bff2005-08-24 21:43:11 -05004518 else if (priv->config & CFG_BACKGROUND_SCAN
4519 && priv->status & STATUS_ASSOCIATED)
4520 queue_delayed_work(priv->workqueue,
4521 &priv->request_scan, HZ);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004522 break;
4523 }
4524
4525 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4526 struct notif_frag_length *x = &notif->u.frag_len;
4527
James Ketrenosa613bff2005-08-24 21:43:11 -05004528 if (notif->size == sizeof(*x))
4529 IPW_ERROR("Frag length: %d\n",
4530 le16_to_cpu(x->frag_length));
4531 else
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004532 IPW_ERROR("Frag length of wrong size %d "
4533 "(should be %zd)\n",
4534 notif->size, sizeof(*x));
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004535 break;
4536 }
4537
4538 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4539 struct notif_link_deterioration *x =
4540 &notif->u.link_deterioration;
James Ketrenosafbf30a2005-08-25 00:05:33 -05004541
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004542 if (notif->size == sizeof(*x)) {
4543 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4544 "link deterioration: '%s' " MAC_FMT
4545 " \n", escape_essid(priv->essid,
4546 priv->essid_len),
4547 MAC_ARG(priv->bssid));
4548 memcpy(&priv->last_link_deterioration, x,
4549 sizeof(*x));
4550 } else {
4551 IPW_ERROR("Link Deterioration of wrong size %d "
4552 "(should be %zd)\n",
4553 notif->size, sizeof(*x));
4554 }
4555 break;
4556 }
4557
4558 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4559 IPW_ERROR("Dino config\n");
4560 if (priv->hcmd
James Ketrenosa613bff2005-08-24 21:43:11 -05004561 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004562 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
James Ketrenosa613bff2005-08-24 21:43:11 -05004563
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004564 break;
4565 }
4566
4567 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4568 struct notif_beacon_state *x = &notif->u.beacon_state;
4569 if (notif->size != sizeof(*x)) {
4570 IPW_ERROR
4571 ("Beacon state of wrong size %d (should "
4572 "be %zd)\n", notif->size, sizeof(*x));
4573 break;
Jeff Garzikbf794512005-07-31 13:07:26 -04004574 }
James Ketrenos43f66a62005-03-25 12:31:53 -06004575
James Ketrenosa613bff2005-08-24 21:43:11 -05004576 if (le32_to_cpu(x->state) ==
4577 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4578 ipw_handle_missed_beacon(priv,
4579 le32_to_cpu(x->
4580 number));
Jeff Garzikbf794512005-07-31 13:07:26 -04004581
James Ketrenos43f66a62005-03-25 12:31:53 -06004582 break;
4583 }
Jeff Garzikbf794512005-07-31 13:07:26 -04004584
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004585 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4586 struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
4587 if (notif->size == sizeof(*x)) {
4588 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4589 "0x%02x station %d\n",
4590 x->key_state, x->security_type,
4591 x->station_index);
4592 break;
James Ketrenos43f66a62005-03-25 12:31:53 -06004593 }
4594
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004595 IPW_ERROR
4596 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4597 notif->size, sizeof(*x));
4598 break;
4599 }
4600
4601 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4602 struct notif_calibration *x = &notif->u.calibration;
4603
4604 if (notif->size == sizeof(*x)) {
4605 memcpy(&priv->calib, x, sizeof(*x));
4606 IPW_DEBUG_INFO("TODO: Calibration\n");
4607 break;
James Ketrenos43f66a62005-03-25 12:31:53 -06004608 }
4609
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004610 IPW_ERROR
4611 ("Calibration of wrong size %d (should be %zd)\n",
4612 notif->size, sizeof(*x));
James Ketrenos43f66a62005-03-25 12:31:53 -06004613 break;
Jeff Garzikbf794512005-07-31 13:07:26 -04004614 }
James Ketrenos43f66a62005-03-25 12:31:53 -06004615
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004616 case HOST_NOTIFICATION_NOISE_STATS:{
4617 if (notif->size == sizeof(u32)) {
4618 priv->last_noise =
James Ketrenosa613bff2005-08-24 21:43:11 -05004619 (u8) (le32_to_cpu(notif->u.noise.value) &
4620 0xff);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004621 average_add(&priv->average_noise,
4622 priv->last_noise);
4623 break;
4624 }
James Ketrenos43f66a62005-03-25 12:31:53 -06004625
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004626 IPW_ERROR
4627 ("Noise stat is wrong size %d (should be %zd)\n",
4628 notif->size, sizeof(u32));
James Ketrenos43f66a62005-03-25 12:31:53 -06004629 break;
Jeff Garzikbf794512005-07-31 13:07:26 -04004630 }
4631
James Ketrenos43f66a62005-03-25 12:31:53 -06004632 default:
Zhu Yi1dd31b62006-02-20 18:28:09 -08004633 IPW_DEBUG_NOTIF("Unknown notification: "
4634 "subtype=%d,flags=0x%2x,size=%d\n",
4635 notif->subtype, notif->flags, notif->size);
James Ketrenos43f66a62005-03-25 12:31:53 -06004636 }
4637}
4638
4639/**
4640 * Destroys all DMA structures and initialise them again
Jeff Garzikbf794512005-07-31 13:07:26 -04004641 *
James Ketrenos43f66a62005-03-25 12:31:53 -06004642 * @param priv
4643 * @return error code
4644 */
4645static int ipw_queue_reset(struct ipw_priv *priv)
4646{
4647 int rc = 0;
4648 /** @todo customize queue sizes */
4649 int nTx = 64, nTxCmd = 8;
4650 ipw_tx_queue_free(priv);
4651 /* Tx CMD queue */
4652 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
James Ketrenosb095c382005-08-24 22:04:42 -05004653 IPW_TX_CMD_QUEUE_READ_INDEX,
4654 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4655 IPW_TX_CMD_QUEUE_BD_BASE,
4656 IPW_TX_CMD_QUEUE_BD_SIZE);
James Ketrenos43f66a62005-03-25 12:31:53 -06004657 if (rc) {
4658 IPW_ERROR("Tx Cmd queue init failed\n");
4659 goto error;
4660 }
4661 /* Tx queue(s) */
4662 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
James Ketrenosb095c382005-08-24 22:04:42 -05004663 IPW_TX_QUEUE_0_READ_INDEX,
4664 IPW_TX_QUEUE_0_WRITE_INDEX,
4665 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
James Ketrenos43f66a62005-03-25 12:31:53 -06004666 if (rc) {
4667 IPW_ERROR("Tx 0 queue init failed\n");
4668 goto error;
4669 }
4670 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
James Ketrenosb095c382005-08-24 22:04:42 -05004671 IPW_TX_QUEUE_1_READ_INDEX,
4672 IPW_TX_QUEUE_1_WRITE_INDEX,
4673 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
James Ketrenos43f66a62005-03-25 12:31:53 -06004674 if (rc) {
4675 IPW_ERROR("Tx 1 queue init failed\n");
4676 goto error;
4677 }
4678 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
James Ketrenosb095c382005-08-24 22:04:42 -05004679 IPW_TX_QUEUE_2_READ_INDEX,
4680 IPW_TX_QUEUE_2_WRITE_INDEX,
4681 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
James Ketrenos43f66a62005-03-25 12:31:53 -06004682 if (rc) {
4683 IPW_ERROR("Tx 2 queue init failed\n");
4684 goto error;
4685 }
4686 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
James Ketrenosb095c382005-08-24 22:04:42 -05004687 IPW_TX_QUEUE_3_READ_INDEX,
4688 IPW_TX_QUEUE_3_WRITE_INDEX,
4689 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
James Ketrenos43f66a62005-03-25 12:31:53 -06004690 if (rc) {
4691 IPW_ERROR("Tx 3 queue init failed\n");
4692 goto error;
4693 }
4694 /* statistics */
4695 priv->rx_bufs_min = 0;
4696 priv->rx_pend_max = 0;
4697 return rc;
4698
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004699 error:
James Ketrenos43f66a62005-03-25 12:31:53 -06004700 ipw_tx_queue_free(priv);
4701 return rc;
4702}
4703
4704/**
4705 * Reclaim Tx queue entries no more used by NIC.
Jeff Garzikbf794512005-07-31 13:07:26 -04004706 *
James Ketrenos43f66a62005-03-25 12:31:53 -06004707 * When FW adwances 'R' index, all entries between old and
4708 * new 'R' index need to be reclaimed. As result, some free space
4709 * forms. If there is enough free space (> low mark), wake Tx queue.
Jeff Garzikbf794512005-07-31 13:07:26 -04004710 *
James Ketrenos43f66a62005-03-25 12:31:53 -06004711 * @note Need to protect against garbage in 'R' index
4712 * @param priv
4713 * @param txq
4714 * @param qindex
4715 * @return Number of used entries remains in the queue
4716 */
Jeff Garzikbf794512005-07-31 13:07:26 -04004717static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -06004718 struct clx2_tx_queue *txq, int qindex)
4719{
4720 u32 hw_tail;
4721 int used;
4722 struct clx2_queue *q = &txq->q;
4723
4724 hw_tail = ipw_read32(priv, q->reg_r);
4725 if (hw_tail >= q->n_bd) {
4726 IPW_ERROR
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004727 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4728 hw_tail, q->n_bd);
James Ketrenos43f66a62005-03-25 12:31:53 -06004729 goto done;
4730 }
4731 for (; q->last_used != hw_tail;
4732 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4733 ipw_queue_tx_free_tfd(priv, txq);
4734 priv->tx_packets++;
4735 }
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004736 done:
James Ketrenos9ddf84f2005-08-16 17:07:11 -05004737 if ((ipw_queue_space(q) > q->low_mark) &&
4738 (qindex >= 0) &&
4739 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4740 netif_wake_queue(priv->net_dev);
James Ketrenos43f66a62005-03-25 12:31:53 -06004741 used = q->first_empty - q->last_used;
4742 if (used < 0)
4743 used += q->n_bd;
4744
4745 return used;
4746}
4747
4748static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4749 int len, int sync)
4750{
4751 struct clx2_tx_queue *txq = &priv->txq_cmd;
4752 struct clx2_queue *q = &txq->q;
4753 struct tfd_frame *tfd;
4754
4755 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4756 IPW_ERROR("No space for Tx\n");
4757 return -EBUSY;
4758 }
4759
4760 tfd = &txq->bd[q->first_empty];
4761 txq->txb[q->first_empty] = NULL;
4762
4763 memset(tfd, 0, sizeof(*tfd));
4764 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4765 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4766 priv->hcmd_seq++;
4767 tfd->u.cmd.index = hcmd;
4768 tfd->u.cmd.length = len;
4769 memcpy(tfd->u.cmd.payload, buf, len);
4770 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4771 ipw_write32(priv, q->reg_w, q->first_empty);
4772 _ipw_read32(priv, 0x90);
4773
4774 return 0;
4775}
4776
Jeff Garzikbf794512005-07-31 13:07:26 -04004777/*
James Ketrenos43f66a62005-03-25 12:31:53 -06004778 * Rx theory of operation
4779 *
4780 * The host allocates 32 DMA target addresses and passes the host address
James Ketrenosb095c382005-08-24 22:04:42 -05004781 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
James Ketrenos43f66a62005-03-25 12:31:53 -06004782 * 0 to 31
4783 *
4784 * Rx Queue Indexes
4785 * The host/firmware share two index registers for managing the Rx buffers.
4786 *
Jeff Garzikbf794512005-07-31 13:07:26 -04004787 * The READ index maps to the first position that the firmware may be writing
4788 * to -- the driver can read up to (but not including) this position and get
4789 * good data.
James Ketrenos43f66a62005-03-25 12:31:53 -06004790 * The READ index is managed by the firmware once the card is enabled.
4791 *
4792 * The WRITE index maps to the last position the driver has read from -- the
4793 * position preceding WRITE is the last slot the firmware can place a packet.
4794 *
4795 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
Jeff Garzikbf794512005-07-31 13:07:26 -04004796 * WRITE = READ.
James Ketrenos43f66a62005-03-25 12:31:53 -06004797 *
Jeff Garzikbf794512005-07-31 13:07:26 -04004798 * During initialization the host sets up the READ queue position to the first
James Ketrenos43f66a62005-03-25 12:31:53 -06004799 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4800 *
4801 * When the firmware places a packet in a buffer it will advance the READ index
4802 * and fire the RX interrupt. The driver can then query the READ index and
4803 * process as many packets as possible, moving the WRITE index forward as it
4804 * resets the Rx queue buffers with new memory.
Jeff Garzikbf794512005-07-31 13:07:26 -04004805 *
James Ketrenos43f66a62005-03-25 12:31:53 -06004806 * The management in the driver is as follows:
Jeff Garzikbf794512005-07-31 13:07:26 -04004807 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
James Ketrenos43f66a62005-03-25 12:31:53 -06004808 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
Jeff Garzikbf794512005-07-31 13:07:26 -04004809 * to replensish the ipw->rxq->rx_free.
James Ketrenos43f66a62005-03-25 12:31:53 -06004810 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4811 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4812 * 'processed' and 'read' driver indexes as well)
4813 * + A received packet is processed and handed to the kernel network stack,
4814 * detached from the ipw->rxq. The driver 'processed' index is updated.
4815 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
Jeff Garzikbf794512005-07-31 13:07:26 -04004816 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4817 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
James Ketrenos43f66a62005-03-25 12:31:53 -06004818 * were enough free buffers and RX_STALLED is set it is cleared.
4819 *
4820 *
4821 * Driver sequence:
4822 *
Jeff Garzikbf794512005-07-31 13:07:26 -04004823 * ipw_rx_queue_alloc() Allocates rx_free
James Ketrenos43f66a62005-03-25 12:31:53 -06004824 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4825 * ipw_rx_queue_restock
4826 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4827 * queue, updates firmware pointers, and updates
4828 * the WRITE index. If insufficient rx_free buffers
4829 * are available, schedules ipw_rx_queue_replenish
4830 *
4831 * -- enable interrupts --
4832 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
Jeff Garzikbf794512005-07-31 13:07:26 -04004833 * READ INDEX, detaching the SKB from the pool.
James Ketrenos43f66a62005-03-25 12:31:53 -06004834 * Moves the packet buffer from queue to rx_used.
4835 * Calls ipw_rx_queue_restock to refill any empty
4836 * slots.
4837 * ...
4838 *
4839 */
4840
Jeff Garzikbf794512005-07-31 13:07:26 -04004841/*
James Ketrenos43f66a62005-03-25 12:31:53 -06004842 * If there are slots in the RX queue that need to be restocked,
4843 * and we have free pre-allocated buffers, fill the ranks as much
4844 * as we can pulling from rx_free.
4845 *
4846 * This moves the 'write' index forward to catch up with 'processed', and
4847 * also updates the memory address in the firmware to reference the new
4848 * target buffer.
4849 */
4850static void ipw_rx_queue_restock(struct ipw_priv *priv)
4851{
4852 struct ipw_rx_queue *rxq = priv->rxq;
4853 struct list_head *element;
4854 struct ipw_rx_mem_buffer *rxb;
4855 unsigned long flags;
4856 int write;
4857
4858 spin_lock_irqsave(&rxq->lock, flags);
4859 write = rxq->write;
4860 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4861 element = rxq->rx_free.next;
4862 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4863 list_del(element);
4864
James Ketrenosb095c382005-08-24 22:04:42 -05004865 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
James Ketrenos43f66a62005-03-25 12:31:53 -06004866 rxb->dma_addr);
4867 rxq->queue[rxq->write] = rxb;
4868 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4869 rxq->free_count--;
4870 }
4871 spin_unlock_irqrestore(&rxq->lock, flags);
4872
Jeff Garzikbf794512005-07-31 13:07:26 -04004873 /* If the pre-allocated buffer pool is dropping low, schedule to
James Ketrenos43f66a62005-03-25 12:31:53 -06004874 * refill it */
4875 if (rxq->free_count <= RX_LOW_WATERMARK)
4876 queue_work(priv->workqueue, &priv->rx_replenish);
4877
4878 /* If we've added more space for the firmware to place data, tell it */
Jeff Garzikbf794512005-07-31 13:07:26 -04004879 if (write != rxq->write)
James Ketrenosb095c382005-08-24 22:04:42 -05004880 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
James Ketrenos43f66a62005-03-25 12:31:53 -06004881}
4882
4883/*
4884 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
Jeff Garzikbf794512005-07-31 13:07:26 -04004885 * Also restock the Rx queue via ipw_rx_queue_restock.
4886 *
James Ketrenos43f66a62005-03-25 12:31:53 -06004887 * This is called as a scheduled work item (except for during intialization)
4888 */
4889static void ipw_rx_queue_replenish(void *data)
4890{
4891 struct ipw_priv *priv = data;
4892 struct ipw_rx_queue *rxq = priv->rxq;
4893 struct list_head *element;
4894 struct ipw_rx_mem_buffer *rxb;
4895 unsigned long flags;
4896
4897 spin_lock_irqsave(&rxq->lock, flags);
4898 while (!list_empty(&rxq->rx_used)) {
4899 element = rxq->rx_used.next;
4900 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
James Ketrenosb095c382005-08-24 22:04:42 -05004901 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
James Ketrenos43f66a62005-03-25 12:31:53 -06004902 if (!rxb->skb) {
4903 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4904 priv->net_dev->name);
4905 /* We don't reschedule replenish work here -- we will
4906 * call the restock method and if it still needs
4907 * more buffers it will schedule replenish */
4908 break;
4909 }
4910 list_del(element);
Jeff Garzikbf794512005-07-31 13:07:26 -04004911
James Ketrenos43f66a62005-03-25 12:31:53 -06004912 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004913 rxb->dma_addr =
4914 pci_map_single(priv->pci_dev, rxb->skb->data,
James Ketrenosb095c382005-08-24 22:04:42 -05004915 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
Jeff Garzikbf794512005-07-31 13:07:26 -04004916
James Ketrenos43f66a62005-03-25 12:31:53 -06004917 list_add_tail(&rxb->list, &rxq->rx_free);
4918 rxq->free_count++;
4919 }
4920 spin_unlock_irqrestore(&rxq->lock, flags);
4921
4922 ipw_rx_queue_restock(priv);
4923}
4924
James Ketrenosc848d0a2005-08-24 21:56:24 -05004925static void ipw_bg_rx_queue_replenish(void *data)
4926{
4927 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08004928 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05004929 ipw_rx_queue_replenish(data);
Zhu Yi46441512006-01-24 16:37:59 +08004930 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05004931}
4932
James Ketrenos43f66a62005-03-25 12:31:53 -06004933/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
Zhu Yic7b6a672006-01-24 16:37:05 +08004934 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
Jeff Garzikbf794512005-07-31 13:07:26 -04004935 * This free routine walks the list of POOL entries and if SKB is set to
James Ketrenos43f66a62005-03-25 12:31:53 -06004936 * non NULL it is unmapped and freed
4937 */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004938static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
James Ketrenos43f66a62005-03-25 12:31:53 -06004939{
4940 int i;
4941
4942 if (!rxq)
4943 return;
Jeff Garzikbf794512005-07-31 13:07:26 -04004944
James Ketrenos43f66a62005-03-25 12:31:53 -06004945 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4946 if (rxq->pool[i].skb != NULL) {
4947 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
James Ketrenosb095c382005-08-24 22:04:42 -05004948 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
James Ketrenos43f66a62005-03-25 12:31:53 -06004949 dev_kfree_skb(rxq->pool[i].skb);
4950 }
4951 }
4952
4953 kfree(rxq);
4954}
4955
4956static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4957{
4958 struct ipw_rx_queue *rxq;
4959 int i;
4960
Takisc75f4742005-12-01 01:41:45 -08004961 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
Panagiotis Issarisad18b0e2005-09-05 04:14:10 +02004962 if (unlikely(!rxq)) {
4963 IPW_ERROR("memory allocation failed\n");
4964 return NULL;
4965 }
James Ketrenos43f66a62005-03-25 12:31:53 -06004966 spin_lock_init(&rxq->lock);
4967 INIT_LIST_HEAD(&rxq->rx_free);
4968 INIT_LIST_HEAD(&rxq->rx_used);
4969
4970 /* Fill the rx_used queue with _all_ of the Rx buffers */
Jeff Garzikbf794512005-07-31 13:07:26 -04004971 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
James Ketrenos43f66a62005-03-25 12:31:53 -06004972 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4973
4974 /* Set us so that we have processed and used all buffers, but have
4975 * not restocked the Rx queue with fresh buffers */
4976 rxq->read = rxq->write = 0;
4977 rxq->processed = RX_QUEUE_SIZE - 1;
4978 rxq->free_count = 0;
4979
4980 return rxq;
4981}
4982
4983static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4984{
4985 rate &= ~IEEE80211_BASIC_RATE_MASK;
4986 if (ieee_mode == IEEE_A) {
4987 switch (rate) {
Jeff Garzikbf794512005-07-31 13:07:26 -04004988 case IEEE80211_OFDM_RATE_6MB:
4989 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004990 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04004991 case IEEE80211_OFDM_RATE_9MB:
4992 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004993 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04004994 case IEEE80211_OFDM_RATE_12MB:
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004995 return priv->
4996 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04004997 case IEEE80211_OFDM_RATE_18MB:
Jeff Garzik0edd5b42005-09-07 00:48:31 -04004998 return priv->
4999 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005000 case IEEE80211_OFDM_RATE_24MB:
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005001 return priv->
5002 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005003 case IEEE80211_OFDM_RATE_36MB:
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005004 return priv->
5005 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005006 case IEEE80211_OFDM_RATE_48MB:
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005007 return priv->
5008 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005009 case IEEE80211_OFDM_RATE_54MB:
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005010 return priv->
5011 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06005012 default:
5013 return 0;
5014 }
5015 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005016
James Ketrenos43f66a62005-03-25 12:31:53 -06005017 /* B and G mixed */
5018 switch (rate) {
Jeff Garzikbf794512005-07-31 13:07:26 -04005019 case IEEE80211_CCK_RATE_1MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005020 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005021 case IEEE80211_CCK_RATE_2MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005022 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005023 case IEEE80211_CCK_RATE_5MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005024 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005025 case IEEE80211_CCK_RATE_11MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005026 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5027 }
5028
5029 /* If we are limited to B modulations, bail at this point */
5030 if (ieee_mode == IEEE_B)
5031 return 0;
5032
5033 /* G */
5034 switch (rate) {
Jeff Garzikbf794512005-07-31 13:07:26 -04005035 case IEEE80211_OFDM_RATE_6MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005036 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005037 case IEEE80211_OFDM_RATE_9MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005038 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005039 case IEEE80211_OFDM_RATE_12MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005040 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005041 case IEEE80211_OFDM_RATE_18MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005042 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005043 case IEEE80211_OFDM_RATE_24MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005044 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005045 case IEEE80211_OFDM_RATE_36MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005046 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005047 case IEEE80211_OFDM_RATE_48MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005048 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005049 case IEEE80211_OFDM_RATE_54MB:
James Ketrenos43f66a62005-03-25 12:31:53 -06005050 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5051 }
5052
5053 return 0;
5054}
5055
Jeff Garzikbf794512005-07-31 13:07:26 -04005056static int ipw_compatible_rates(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -06005057 const struct ieee80211_network *network,
5058 struct ipw_supported_rates *rates)
5059{
5060 int num_rates, i;
5061
5062 memset(rates, 0, sizeof(*rates));
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005063 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
James Ketrenos43f66a62005-03-25 12:31:53 -06005064 rates->num_rates = 0;
5065 for (i = 0; i < num_rates; i++) {
James Ketrenosa613bff2005-08-24 21:43:11 -05005066 if (!ipw_is_rate_in_mask(priv, network->mode,
5067 network->rates[i])) {
5068
James Ketrenosea2b26e2005-08-24 21:25:16 -05005069 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
James Ketrenosa613bff2005-08-24 21:43:11 -05005070 IPW_DEBUG_SCAN("Adding masked mandatory "
5071 "rate %02X\n",
5072 network->rates[i]);
5073 rates->supported_rates[rates->num_rates++] =
5074 network->rates[i];
5075 continue;
James Ketrenosea2b26e2005-08-24 21:25:16 -05005076 }
5077
James Ketrenos43f66a62005-03-25 12:31:53 -06005078 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5079 network->rates[i], priv->rates_mask);
5080 continue;
5081 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005082
James Ketrenos43f66a62005-03-25 12:31:53 -06005083 rates->supported_rates[rates->num_rates++] = network->rates[i];
5084 }
5085
James Ketrenosa613bff2005-08-24 21:43:11 -05005086 num_rates = min(network->rates_ex_len,
5087 (u8) (IPW_MAX_RATES - num_rates));
James Ketrenos43f66a62005-03-25 12:31:53 -06005088 for (i = 0; i < num_rates; i++) {
James Ketrenosa613bff2005-08-24 21:43:11 -05005089 if (!ipw_is_rate_in_mask(priv, network->mode,
5090 network->rates_ex[i])) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05005091 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
James Ketrenosa613bff2005-08-24 21:43:11 -05005092 IPW_DEBUG_SCAN("Adding masked mandatory "
5093 "rate %02X\n",
5094 network->rates_ex[i]);
5095 rates->supported_rates[rates->num_rates++] =
5096 network->rates[i];
5097 continue;
James Ketrenosea2b26e2005-08-24 21:25:16 -05005098 }
5099
James Ketrenos43f66a62005-03-25 12:31:53 -06005100 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5101 network->rates_ex[i], priv->rates_mask);
5102 continue;
5103 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005104
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005105 rates->supported_rates[rates->num_rates++] =
5106 network->rates_ex[i];
James Ketrenos43f66a62005-03-25 12:31:53 -06005107 }
5108
James Ketrenosea2b26e2005-08-24 21:25:16 -05005109 return 1;
James Ketrenos43f66a62005-03-25 12:31:53 -06005110}
5111
Arjan van de Ven858119e2006-01-14 13:20:43 -08005112static void ipw_copy_rates(struct ipw_supported_rates *dest,
James Ketrenos43f66a62005-03-25 12:31:53 -06005113 const struct ipw_supported_rates *src)
5114{
5115 u8 i;
5116 for (i = 0; i < src->num_rates; i++)
5117 dest->supported_rates[i] = src->supported_rates[i];
5118 dest->num_rates = src->num_rates;
5119}
5120
5121/* TODO: Look at sniffed packets in the air to determine if the basic rate
5122 * mask should ever be used -- right now all callers to add the scan rates are
5123 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5124static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005125 u8 modulation, u32 rate_mask)
James Ketrenos43f66a62005-03-25 12:31:53 -06005126{
Jeff Garzikbf794512005-07-31 13:07:26 -04005127 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005128 IEEE80211_BASIC_RATE_MASK : 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005129
James Ketrenos43f66a62005-03-25 12:31:53 -06005130 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005131 rates->supported_rates[rates->num_rates++] =
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005132 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005133
5134 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005135 rates->supported_rates[rates->num_rates++] =
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005136 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005137
5138 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005139 rates->supported_rates[rates->num_rates++] = basic_mask |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005140 IEEE80211_CCK_RATE_5MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005141
5142 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005143 rates->supported_rates[rates->num_rates++] = basic_mask |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005144 IEEE80211_CCK_RATE_11MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005145}
5146
5147static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005148 u8 modulation, u32 rate_mask)
James Ketrenos43f66a62005-03-25 12:31:53 -06005149{
Jeff Garzikbf794512005-07-31 13:07:26 -04005150 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005151 IEEE80211_BASIC_RATE_MASK : 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06005152
5153 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005154 rates->supported_rates[rates->num_rates++] = basic_mask |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005155 IEEE80211_OFDM_RATE_6MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005156
5157 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005158 rates->supported_rates[rates->num_rates++] =
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005159 IEEE80211_OFDM_RATE_9MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005160
5161 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005162 rates->supported_rates[rates->num_rates++] = basic_mask |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005163 IEEE80211_OFDM_RATE_12MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005164
5165 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005166 rates->supported_rates[rates->num_rates++] =
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005167 IEEE80211_OFDM_RATE_18MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005168
5169 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005170 rates->supported_rates[rates->num_rates++] = basic_mask |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005171 IEEE80211_OFDM_RATE_24MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005172
5173 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005174 rates->supported_rates[rates->num_rates++] =
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005175 IEEE80211_OFDM_RATE_36MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005176
5177 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005178 rates->supported_rates[rates->num_rates++] =
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005179 IEEE80211_OFDM_RATE_48MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005180
5181 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
Jeff Garzikbf794512005-07-31 13:07:26 -04005182 rates->supported_rates[rates->num_rates++] =
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005183 IEEE80211_OFDM_RATE_54MB;
James Ketrenos43f66a62005-03-25 12:31:53 -06005184}
5185
5186struct ipw_network_match {
5187 struct ieee80211_network *network;
5188 struct ipw_supported_rates rates;
5189};
5190
James Ketrenosc848d0a2005-08-24 21:56:24 -05005191static int ipw_find_adhoc_network(struct ipw_priv *priv,
5192 struct ipw_network_match *match,
5193 struct ieee80211_network *network,
5194 int roaming)
5195{
5196 struct ipw_supported_rates rates;
5197
5198 /* Verify that this network's capability is compatible with the
5199 * current mode (AdHoc or Infrastructure) */
5200 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5201 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5202 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5203 "capability mismatch.\n",
5204 escape_essid(network->ssid, network->ssid_len),
5205 MAC_ARG(network->bssid));
5206 return 0;
5207 }
5208
5209 /* If we do not have an ESSID for this AP, we can not associate with
5210 * it */
5211 if (network->flags & NETWORK_EMPTY_ESSID) {
5212 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5213 "because of hidden ESSID.\n",
5214 escape_essid(network->ssid, network->ssid_len),
5215 MAC_ARG(network->bssid));
5216 return 0;
5217 }
5218
5219 if (unlikely(roaming)) {
5220 /* If we are roaming, then ensure check if this is a valid
5221 * network to try and roam to */
5222 if ((network->ssid_len != match->network->ssid_len) ||
5223 memcmp(network->ssid, match->network->ssid,
5224 network->ssid_len)) {
5225 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5226 "because of non-network ESSID.\n",
5227 escape_essid(network->ssid,
5228 network->ssid_len),
5229 MAC_ARG(network->bssid));
5230 return 0;
5231 }
5232 } else {
5233 /* If an ESSID has been configured then compare the broadcast
5234 * ESSID to ours */
5235 if ((priv->config & CFG_STATIC_ESSID) &&
5236 ((network->ssid_len != priv->essid_len) ||
5237 memcmp(network->ssid, priv->essid,
5238 min(network->ssid_len, priv->essid_len)))) {
5239 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
James Ketrenosafbf30a2005-08-25 00:05:33 -05005240
James Ketrenosc848d0a2005-08-24 21:56:24 -05005241 strncpy(escaped,
5242 escape_essid(network->ssid, network->ssid_len),
5243 sizeof(escaped));
5244 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5245 "because of ESSID mismatch: '%s'.\n",
5246 escaped, MAC_ARG(network->bssid),
5247 escape_essid(priv->essid,
5248 priv->essid_len));
5249 return 0;
5250 }
5251 }
5252
5253 /* If the old network rate is better than this one, don't bother
5254 * testing everything else. */
5255
5256 if (network->time_stamp[0] < match->network->time_stamp[0]) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05005257 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5258 "current network.\n",
5259 escape_essid(match->network->ssid,
5260 match->network->ssid_len));
James Ketrenosc848d0a2005-08-24 21:56:24 -05005261 return 0;
5262 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05005263 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5264 "current network.\n",
5265 escape_essid(match->network->ssid,
5266 match->network->ssid_len));
James Ketrenosc848d0a2005-08-24 21:56:24 -05005267 return 0;
5268 }
5269
5270 /* Now go through and see if the requested network is valid... */
5271 if (priv->ieee->scan_age != 0 &&
5272 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5273 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
Zhu Yic7b6a672006-01-24 16:37:05 +08005274 "because of age: %ums.\n",
James Ketrenosc848d0a2005-08-24 21:56:24 -05005275 escape_essid(network->ssid, network->ssid_len),
5276 MAC_ARG(network->bssid),
Zhu Yi2638bc32006-01-24 16:37:52 +08005277 jiffies_to_msecs(jiffies -
5278 network->last_scanned));
James Ketrenosc848d0a2005-08-24 21:56:24 -05005279 return 0;
5280 }
5281
5282 if ((priv->config & CFG_STATIC_CHANNEL) &&
5283 (network->channel != priv->channel)) {
5284 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5285 "because of channel mismatch: %d != %d.\n",
5286 escape_essid(network->ssid, network->ssid_len),
5287 MAC_ARG(network->bssid),
5288 network->channel, priv->channel);
5289 return 0;
5290 }
5291
5292 /* Verify privacy compatability */
5293 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5294 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5295 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5296 "because of privacy mismatch: %s != %s.\n",
5297 escape_essid(network->ssid, network->ssid_len),
5298 MAC_ARG(network->bssid),
James Ketrenosafbf30a2005-08-25 00:05:33 -05005299 priv->
5300 capability & CAP_PRIVACY_ON ? "on" : "off",
5301 network->
5302 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5303 "off");
James Ketrenosc848d0a2005-08-24 21:56:24 -05005304 return 0;
5305 }
5306
5307 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5308 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5309 "because of the same BSSID match: " MAC_FMT
5310 ".\n", escape_essid(network->ssid,
5311 network->ssid_len),
5312 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5313 return 0;
5314 }
5315
5316 /* Filter out any incompatible freq / mode combinations */
5317 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5318 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5319 "because of invalid frequency/mode "
5320 "combination.\n",
5321 escape_essid(network->ssid, network->ssid_len),
5322 MAC_ARG(network->bssid));
5323 return 0;
5324 }
5325
5326 /* Ensure that the rates supported by the driver are compatible with
5327 * this AP, including verification of basic rates (mandatory) */
5328 if (!ipw_compatible_rates(priv, network, &rates)) {
5329 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5330 "because configured rate mask excludes "
5331 "AP mandatory rate.\n",
5332 escape_essid(network->ssid, network->ssid_len),
5333 MAC_ARG(network->bssid));
5334 return 0;
5335 }
5336
5337 if (rates.num_rates == 0) {
5338 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5339 "because of no compatible rates.\n",
5340 escape_essid(network->ssid, network->ssid_len),
5341 MAC_ARG(network->bssid));
5342 return 0;
5343 }
5344
5345 /* TODO: Perform any further minimal comparititive tests. We do not
5346 * want to put too much policy logic here; intelligent scan selection
5347 * should occur within a generic IEEE 802.11 user space tool. */
5348
5349 /* Set up 'new' AP to this network */
5350 ipw_copy_rates(&match->rates, &rates);
5351 match->network = network;
5352 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5353 escape_essid(network->ssid, network->ssid_len),
5354 MAC_ARG(network->bssid));
5355
5356 return 1;
5357}
5358
5359static void ipw_merge_adhoc_network(void *data)
5360{
5361 struct ipw_priv *priv = data;
5362 struct ieee80211_network *network = NULL;
5363 struct ipw_network_match match = {
5364 .network = priv->assoc_network
5365 };
5366
James Ketrenosafbf30a2005-08-25 00:05:33 -05005367 if ((priv->status & STATUS_ASSOCIATED) &&
5368 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
James Ketrenosc848d0a2005-08-24 21:56:24 -05005369 /* First pass through ROAM process -- look for a better
5370 * network */
5371 unsigned long flags;
5372
5373 spin_lock_irqsave(&priv->ieee->lock, flags);
5374 list_for_each_entry(network, &priv->ieee->network_list, list) {
5375 if (network != priv->assoc_network)
5376 ipw_find_adhoc_network(priv, &match, network,
5377 1);
5378 }
5379 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5380
5381 if (match.network == priv->assoc_network) {
5382 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5383 "merge to.\n");
5384 return;
5385 }
5386
Zhu Yi46441512006-01-24 16:37:59 +08005387 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05005388 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5389 IPW_DEBUG_MERGE("remove network %s\n",
5390 escape_essid(priv->essid,
5391 priv->essid_len));
5392 ipw_remove_current_network(priv);
5393 }
5394
5395 ipw_disassociate(priv);
5396 priv->assoc_network = match.network;
Zhu Yi46441512006-01-24 16:37:59 +08005397 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05005398 return;
5399 }
James Ketrenosc848d0a2005-08-24 21:56:24 -05005400}
5401
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005402static int ipw_best_network(struct ipw_priv *priv,
5403 struct ipw_network_match *match,
5404 struct ieee80211_network *network, int roaming)
James Ketrenos43f66a62005-03-25 12:31:53 -06005405{
5406 struct ipw_supported_rates rates;
5407
5408 /* Verify that this network's capability is compatible with the
5409 * current mode (AdHoc or Infrastructure) */
5410 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
Jouni Malinen24743852005-08-14 20:59:59 -07005411 !(network->capability & WLAN_CAPABILITY_ESS)) ||
James Ketrenos43f66a62005-03-25 12:31:53 -06005412 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5413 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5414 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
Jeff Garzikbf794512005-07-31 13:07:26 -04005415 "capability mismatch.\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06005416 escape_essid(network->ssid, network->ssid_len),
5417 MAC_ARG(network->bssid));
5418 return 0;
5419 }
5420
5421 /* If we do not have an ESSID for this AP, we can not associate with
5422 * it */
5423 if (network->flags & NETWORK_EMPTY_ESSID) {
5424 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5425 "because of hidden ESSID.\n",
5426 escape_essid(network->ssid, network->ssid_len),
5427 MAC_ARG(network->bssid));
5428 return 0;
5429 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005430
James Ketrenos43f66a62005-03-25 12:31:53 -06005431 if (unlikely(roaming)) {
5432 /* If we are roaming, then ensure check if this is a valid
5433 * network to try and roam to */
5434 if ((network->ssid_len != match->network->ssid_len) ||
Jeff Garzikbf794512005-07-31 13:07:26 -04005435 memcmp(network->ssid, match->network->ssid,
James Ketrenos43f66a62005-03-25 12:31:53 -06005436 network->ssid_len)) {
5437 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5438 "because of non-network ESSID.\n",
Jeff Garzikbf794512005-07-31 13:07:26 -04005439 escape_essid(network->ssid,
James Ketrenos43f66a62005-03-25 12:31:53 -06005440 network->ssid_len),
5441 MAC_ARG(network->bssid));
5442 return 0;
5443 }
5444 } else {
Jeff Garzikbf794512005-07-31 13:07:26 -04005445 /* If an ESSID has been configured then compare the broadcast
5446 * ESSID to ours */
5447 if ((priv->config & CFG_STATIC_ESSID) &&
James Ketrenos43f66a62005-03-25 12:31:53 -06005448 ((network->ssid_len != priv->essid_len) ||
Jeff Garzikbf794512005-07-31 13:07:26 -04005449 memcmp(network->ssid, priv->essid,
James Ketrenos43f66a62005-03-25 12:31:53 -06005450 min(network->ssid_len, priv->essid_len)))) {
5451 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005452 strncpy(escaped,
5453 escape_essid(network->ssid, network->ssid_len),
James Ketrenos43f66a62005-03-25 12:31:53 -06005454 sizeof(escaped));
5455 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
Jeff Garzikbf794512005-07-31 13:07:26 -04005456 "because of ESSID mismatch: '%s'.\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06005457 escaped, MAC_ARG(network->bssid),
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005458 escape_essid(priv->essid,
5459 priv->essid_len));
James Ketrenos43f66a62005-03-25 12:31:53 -06005460 return 0;
5461 }
5462 }
5463
5464 /* If the old network rate is better than this one, don't bother
5465 * testing everything else. */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005466 if (match->network && match->network->stats.rssi > network->stats.rssi) {
James Ketrenos43f66a62005-03-25 12:31:53 -06005467 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
Jeff Garzikbf794512005-07-31 13:07:26 -04005468 strncpy(escaped,
5469 escape_essid(network->ssid, network->ssid_len),
James Ketrenos43f66a62005-03-25 12:31:53 -06005470 sizeof(escaped));
5471 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5472 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5473 escaped, MAC_ARG(network->bssid),
5474 escape_essid(match->network->ssid,
5475 match->network->ssid_len),
5476 MAC_ARG(match->network->bssid));
5477 return 0;
5478 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005479
James Ketrenos43f66a62005-03-25 12:31:53 -06005480 /* If this network has already had an association attempt within the
5481 * last 3 seconds, do not try and associate again... */
5482 if (network->last_associate &&
James Ketrenosea2b26e2005-08-24 21:25:16 -05005483 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
James Ketrenos43f66a62005-03-25 12:31:53 -06005484 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
Zhu Yic7b6a672006-01-24 16:37:05 +08005485 "because of storming (%ums since last "
James Ketrenos43f66a62005-03-25 12:31:53 -06005486 "assoc attempt).\n",
5487 escape_essid(network->ssid, network->ssid_len),
5488 MAC_ARG(network->bssid),
Zhu Yi2638bc32006-01-24 16:37:52 +08005489 jiffies_to_msecs(jiffies -
5490 network->last_associate));
James Ketrenos43f66a62005-03-25 12:31:53 -06005491 return 0;
5492 }
5493
5494 /* Now go through and see if the requested network is valid... */
Jeff Garzikbf794512005-07-31 13:07:26 -04005495 if (priv->ieee->scan_age != 0 &&
James Ketrenosea2b26e2005-08-24 21:25:16 -05005496 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
James Ketrenos43f66a62005-03-25 12:31:53 -06005497 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
Zhu Yic7b6a672006-01-24 16:37:05 +08005498 "because of age: %ums.\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06005499 escape_essid(network->ssid, network->ssid_len),
5500 MAC_ARG(network->bssid),
Zhu Yi2638bc32006-01-24 16:37:52 +08005501 jiffies_to_msecs(jiffies -
5502 network->last_scanned));
James Ketrenos43f66a62005-03-25 12:31:53 -06005503 return 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04005504 }
James Ketrenos43f66a62005-03-25 12:31:53 -06005505
Jeff Garzikbf794512005-07-31 13:07:26 -04005506 if ((priv->config & CFG_STATIC_CHANNEL) &&
James Ketrenos43f66a62005-03-25 12:31:53 -06005507 (network->channel != priv->channel)) {
5508 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5509 "because of channel mismatch: %d != %d.\n",
5510 escape_essid(network->ssid, network->ssid_len),
5511 MAC_ARG(network->bssid),
5512 network->channel, priv->channel);
5513 return 0;
5514 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005515
James Ketrenos43f66a62005-03-25 12:31:53 -06005516 /* Verify privacy compatability */
Jeff Garzikbf794512005-07-31 13:07:26 -04005517 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
James Ketrenos43f66a62005-03-25 12:31:53 -06005518 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5519 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5520 "because of privacy mismatch: %s != %s.\n",
5521 escape_essid(network->ssid, network->ssid_len),
5522 MAC_ARG(network->bssid),
Jeff Garzikbf794512005-07-31 13:07:26 -04005523 priv->capability & CAP_PRIVACY_ON ? "on" :
James Ketrenos43f66a62005-03-25 12:31:53 -06005524 "off",
Jeff Garzikbf794512005-07-31 13:07:26 -04005525 network->capability &
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005526 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
James Ketrenos43f66a62005-03-25 12:31:53 -06005527 return 0;
5528 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005529
5530 if ((priv->config & CFG_STATIC_BSSID) &&
James Ketrenos43f66a62005-03-25 12:31:53 -06005531 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5532 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5533 "because of BSSID mismatch: " MAC_FMT ".\n",
5534 escape_essid(network->ssid, network->ssid_len),
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005535 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
James Ketrenos43f66a62005-03-25 12:31:53 -06005536 return 0;
5537 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005538
James Ketrenos43f66a62005-03-25 12:31:53 -06005539 /* Filter out any incompatible freq / mode combinations */
5540 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5541 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5542 "because of invalid frequency/mode "
5543 "combination.\n",
5544 escape_essid(network->ssid, network->ssid_len),
5545 MAC_ARG(network->bssid));
5546 return 0;
5547 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005548
Liu Hong1fe0adb2005-08-19 09:33:10 -05005549 /* Filter out invalid channel in current GEO */
Larry Finger1867b112006-02-28 09:48:28 -06005550 if (!ieee80211_is_valid_channel(priv->ieee, network->channel)) {
Liu Hong1fe0adb2005-08-19 09:33:10 -05005551 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5552 "because of invalid channel in current GEO\n",
5553 escape_essid(network->ssid, network->ssid_len),
5554 MAC_ARG(network->bssid));
5555 return 0;
5556 }
5557
James Ketrenosea2b26e2005-08-24 21:25:16 -05005558 /* Ensure that the rates supported by the driver are compatible with
5559 * this AP, including verification of basic rates (mandatory) */
5560 if (!ipw_compatible_rates(priv, network, &rates)) {
5561 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5562 "because configured rate mask excludes "
5563 "AP mandatory rate.\n",
5564 escape_essid(network->ssid, network->ssid_len),
5565 MAC_ARG(network->bssid));
5566 return 0;
5567 }
5568
James Ketrenos43f66a62005-03-25 12:31:53 -06005569 if (rates.num_rates == 0) {
5570 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5571 "because of no compatible rates.\n",
5572 escape_essid(network->ssid, network->ssid_len),
5573 MAC_ARG(network->bssid));
5574 return 0;
5575 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005576
James Ketrenos43f66a62005-03-25 12:31:53 -06005577 /* TODO: Perform any further minimal comparititive tests. We do not
5578 * want to put too much policy logic here; intelligent scan selection
5579 * should occur within a generic IEEE 802.11 user space tool. */
5580
5581 /* Set up 'new' AP to this network */
5582 ipw_copy_rates(&match->rates, &rates);
5583 match->network = network;
5584
5585 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5586 escape_essid(network->ssid, network->ssid_len),
5587 MAC_ARG(network->bssid));
5588
5589 return 1;
5590}
5591
Jeff Garzikbf794512005-07-31 13:07:26 -04005592static void ipw_adhoc_create(struct ipw_priv *priv,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005593 struct ieee80211_network *network)
James Ketrenos43f66a62005-03-25 12:31:53 -06005594{
Larry Finger1867b112006-02-28 09:48:28 -06005595 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
James Ketrenosafbf30a2005-08-25 00:05:33 -05005596 int i;
5597
James Ketrenos43f66a62005-03-25 12:31:53 -06005598 /*
5599 * For the purposes of scanning, we can set our wireless mode
5600 * to trigger scans across combinations of bands, but when it
5601 * comes to creating a new ad-hoc network, we have tell the FW
5602 * exactly which band to use.
5603 *
Jeff Garzikbf794512005-07-31 13:07:26 -04005604 * We also have the possibility of an invalid channel for the
James Ketrenos43f66a62005-03-25 12:31:53 -06005605 * chossen band. Attempting to create a new ad-hoc network
5606 * with an invalid channel for wireless mode will trigger a
5607 * FW fatal error.
James Ketrenosafbf30a2005-08-25 00:05:33 -05005608 *
James Ketrenos43f66a62005-03-25 12:31:53 -06005609 */
Larry Finger1867b112006-02-28 09:48:28 -06005610 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05005611 case IEEE80211_52GHZ_BAND:
5612 network->mode = IEEE_A;
Larry Finger1867b112006-02-28 09:48:28 -06005613 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
James Ketrenosafbf30a2005-08-25 00:05:33 -05005614 if (i == -1)
5615 BUG();
5616 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5617 IPW_WARNING("Overriding invalid channel\n");
5618 priv->channel = geo->a[0].channel;
5619 }
5620 break;
5621
5622 case IEEE80211_24GHZ_BAND:
5623 if (priv->ieee->mode & IEEE_G)
5624 network->mode = IEEE_G;
5625 else
5626 network->mode = IEEE_B;
Larry Finger1867b112006-02-28 09:48:28 -06005627 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
Liu Hong1fe0adb2005-08-19 09:33:10 -05005628 if (i == -1)
5629 BUG();
5630 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5631 IPW_WARNING("Overriding invalid channel\n");
5632 priv->channel = geo->bg[0].channel;
5633 }
James Ketrenosafbf30a2005-08-25 00:05:33 -05005634 break;
5635
5636 default:
James Ketrenos43f66a62005-03-25 12:31:53 -06005637 IPW_WARNING("Overriding invalid channel\n");
5638 if (priv->ieee->mode & IEEE_A) {
5639 network->mode = IEEE_A;
James Ketrenosb095c382005-08-24 22:04:42 -05005640 priv->channel = geo->a[0].channel;
James Ketrenos43f66a62005-03-25 12:31:53 -06005641 } else if (priv->ieee->mode & IEEE_G) {
5642 network->mode = IEEE_G;
James Ketrenosb095c382005-08-24 22:04:42 -05005643 priv->channel = geo->bg[0].channel;
James Ketrenos43f66a62005-03-25 12:31:53 -06005644 } else {
5645 network->mode = IEEE_B;
James Ketrenosb095c382005-08-24 22:04:42 -05005646 priv->channel = geo->bg[0].channel;
James Ketrenos43f66a62005-03-25 12:31:53 -06005647 }
James Ketrenosafbf30a2005-08-25 00:05:33 -05005648 break;
James Ketrenos43f66a62005-03-25 12:31:53 -06005649 }
5650
5651 network->channel = priv->channel;
5652 priv->config |= CFG_ADHOC_PERSIST;
5653 ipw_create_bssid(priv, network->bssid);
5654 network->ssid_len = priv->essid_len;
5655 memcpy(network->ssid, priv->essid, priv->essid_len);
5656 memset(&network->stats, 0, sizeof(network->stats));
5657 network->capability = WLAN_CAPABILITY_IBSS;
James Ketrenosea2b26e2005-08-24 21:25:16 -05005658 if (!(priv->config & CFG_PREAMBLE_LONG))
5659 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
James Ketrenos43f66a62005-03-25 12:31:53 -06005660 if (priv->capability & CAP_PRIVACY_ON)
5661 network->capability |= WLAN_CAPABILITY_PRIVACY;
5662 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005663 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
James Ketrenos43f66a62005-03-25 12:31:53 -06005664 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
Jeff Garzikbf794512005-07-31 13:07:26 -04005665 memcpy(network->rates_ex,
James Ketrenos43f66a62005-03-25 12:31:53 -06005666 &priv->rates.supported_rates[network->rates_len],
5667 network->rates_ex_len);
5668 network->last_scanned = 0;
5669 network->flags = 0;
5670 network->last_associate = 0;
5671 network->time_stamp[0] = 0;
5672 network->time_stamp[1] = 0;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005673 network->beacon_interval = 100; /* Default */
5674 network->listen_interval = 10; /* Default */
5675 network->atim_window = 0; /* Default */
James Ketrenos43f66a62005-03-25 12:31:53 -06005676 network->wpa_ie_len = 0;
5677 network->rsn_ie_len = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06005678}
5679
James Ketrenosb095c382005-08-24 22:04:42 -05005680static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5681{
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005682 struct ipw_tgi_tx_key key;
James Ketrenosb095c382005-08-24 22:04:42 -05005683
5684 if (!(priv->ieee->sec.flags & (1 << index)))
5685 return;
5686
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005687 key.key_id = index;
5688 memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5689 key.security_type = type;
5690 key.station_index = 0; /* always 0 for BSS */
5691 key.flags = 0;
James Ketrenosb095c382005-08-24 22:04:42 -05005692 /* 0 for new key; previous value of counter (after fatal error) */
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005693 key.tx_counter[0] = 0;
5694 key.tx_counter[1] = 0;
James Ketrenosb095c382005-08-24 22:04:42 -05005695
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005696 ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
James Ketrenosb095c382005-08-24 22:04:42 -05005697}
5698
5699static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
James Ketrenos43f66a62005-03-25 12:31:53 -06005700{
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005701 struct ipw_wep_key key;
James Ketrenos43f66a62005-03-25 12:31:53 -06005702 int i;
James Ketrenos43f66a62005-03-25 12:31:53 -06005703
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005704 key.cmd_id = DINO_CMD_WEP_KEY;
5705 key.seq_num = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06005706
James Ketrenosb095c382005-08-24 22:04:42 -05005707 /* Note: AES keys cannot be set for multiple times.
5708 * Only set it at the first time. */
Jeff Garzikbf794512005-07-31 13:07:26 -04005709 for (i = 0; i < 4; i++) {
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005710 key.key_index = i | type;
James Ketrenosb095c382005-08-24 22:04:42 -05005711 if (!(priv->ieee->sec.flags & (1 << i))) {
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005712 key.key_size = 0;
James Ketrenosb095c382005-08-24 22:04:42 -05005713 continue;
James Ketrenos43f66a62005-03-25 12:31:53 -06005714 }
5715
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005716 key.key_size = priv->ieee->sec.key_sizes[i];
5717 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
James Ketrenosb095c382005-08-24 22:04:42 -05005718
Zhu Yi0a7bcf22006-01-24 16:37:28 +08005719 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
Jeff Garzikbf794512005-07-31 13:07:26 -04005720 }
James Ketrenos43f66a62005-03-25 12:31:53 -06005721}
5722
Zhu Yi1fbfea52005-08-05 17:22:56 +08005723static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5724{
5725 if (priv->ieee->host_encrypt)
5726 return;
5727
5728 switch (level) {
5729 case SEC_LEVEL_3:
5730 priv->sys_config.disable_unicast_decryption = 0;
5731 priv->ieee->host_decrypt = 0;
5732 break;
5733 case SEC_LEVEL_2:
5734 priv->sys_config.disable_unicast_decryption = 1;
5735 priv->ieee->host_decrypt = 1;
5736 break;
5737 case SEC_LEVEL_1:
5738 priv->sys_config.disable_unicast_decryption = 0;
5739 priv->ieee->host_decrypt = 0;
5740 break;
5741 case SEC_LEVEL_0:
5742 priv->sys_config.disable_unicast_decryption = 1;
5743 break;
5744 default:
5745 break;
5746 }
5747}
5748
5749static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5750{
5751 if (priv->ieee->host_encrypt)
5752 return;
5753
5754 switch (level) {
5755 case SEC_LEVEL_3:
5756 priv->sys_config.disable_multicast_decryption = 0;
5757 break;
5758 case SEC_LEVEL_2:
5759 priv->sys_config.disable_multicast_decryption = 1;
5760 break;
5761 case SEC_LEVEL_1:
5762 priv->sys_config.disable_multicast_decryption = 0;
5763 break;
5764 case SEC_LEVEL_0:
5765 priv->sys_config.disable_multicast_decryption = 1;
5766 break;
5767 default:
5768 break;
5769 }
5770}
5771
James Ketrenosb095c382005-08-24 22:04:42 -05005772static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5773{
5774 switch (priv->ieee->sec.level) {
5775 case SEC_LEVEL_3:
Zhu Yid8bad6d2005-07-13 12:25:38 -05005776 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5777 ipw_send_tgi_tx_key(priv,
5778 DCT_FLAG_EXT_SECURITY_CCM,
5779 priv->ieee->sec.active_key);
James Ketrenosafbf30a2005-08-25 00:05:33 -05005780
Hong Liu567deaf2005-08-31 18:07:22 +08005781 if (!priv->ieee->host_mc_decrypt)
5782 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
James Ketrenosb095c382005-08-24 22:04:42 -05005783 break;
5784 case SEC_LEVEL_2:
Zhu Yid8bad6d2005-07-13 12:25:38 -05005785 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5786 ipw_send_tgi_tx_key(priv,
5787 DCT_FLAG_EXT_SECURITY_TKIP,
5788 priv->ieee->sec.active_key);
James Ketrenosb095c382005-08-24 22:04:42 -05005789 break;
5790 case SEC_LEVEL_1:
5791 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
Hong Liu29cb8432005-09-12 10:43:33 -05005792 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5793 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
James Ketrenosb095c382005-08-24 22:04:42 -05005794 break;
5795 case SEC_LEVEL_0:
5796 default:
5797 break;
James Ketrenos43f66a62005-03-25 12:31:53 -06005798 }
5799}
5800
5801static void ipw_adhoc_check(void *data)
5802{
5803 struct ipw_priv *priv = data;
Jeff Garzikbf794512005-07-31 13:07:26 -04005804
James Ketrenosafbf30a2005-08-25 00:05:33 -05005805 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
James Ketrenos43f66a62005-03-25 12:31:53 -06005806 !(priv->config & CFG_ADHOC_PERSIST)) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05005807 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5808 IPW_DL_STATE | IPW_DL_ASSOC,
5809 "Missed beacon: %d - disassociate\n",
5810 priv->missed_adhoc_beacons);
James Ketrenos43f66a62005-03-25 12:31:53 -06005811 ipw_remove_current_network(priv);
5812 ipw_disassociate(priv);
5813 return;
5814 }
5815
Jeff Garzikbf794512005-07-31 13:07:26 -04005816 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
James Ketrenos43f66a62005-03-25 12:31:53 -06005817 priv->assoc_request.beacon_interval);
5818}
5819
James Ketrenosc848d0a2005-08-24 21:56:24 -05005820static void ipw_bg_adhoc_check(void *data)
5821{
5822 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08005823 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05005824 ipw_adhoc_check(data);
Zhu Yi46441512006-01-24 16:37:59 +08005825 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05005826}
5827
Brice Goglin0f52bf92005-12-01 01:41:46 -08005828#ifdef CONFIG_IPW2200_DEBUG
James Ketrenos43f66a62005-03-25 12:31:53 -06005829static void ipw_debug_config(struct ipw_priv *priv)
5830{
5831 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5832 "[CFG 0x%08X]\n", priv->config);
5833 if (priv->config & CFG_STATIC_CHANNEL)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005834 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
James Ketrenos43f66a62005-03-25 12:31:53 -06005835 else
5836 IPW_DEBUG_INFO("Channel unlocked.\n");
5837 if (priv->config & CFG_STATIC_ESSID)
Jeff Garzikbf794512005-07-31 13:07:26 -04005838 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005839 escape_essid(priv->essid, priv->essid_len));
James Ketrenos43f66a62005-03-25 12:31:53 -06005840 else
5841 IPW_DEBUG_INFO("ESSID unlocked.\n");
5842 if (priv->config & CFG_STATIC_BSSID)
James Ketrenosea2b26e2005-08-24 21:25:16 -05005843 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5844 MAC_ARG(priv->bssid));
James Ketrenos43f66a62005-03-25 12:31:53 -06005845 else
5846 IPW_DEBUG_INFO("BSSID unlocked.\n");
5847 if (priv->capability & CAP_PRIVACY_ON)
5848 IPW_DEBUG_INFO("PRIVACY on\n");
5849 else
5850 IPW_DEBUG_INFO("PRIVACY off\n");
5851 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5852}
5853#else
Jiri Benc8d45ff72005-08-25 20:09:39 -04005854#define ipw_debug_config(x) do {} while (0)
James Ketrenos43f66a62005-03-25 12:31:53 -06005855#endif
5856
Arjan van de Ven858119e2006-01-14 13:20:43 -08005857static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
James Ketrenos43f66a62005-03-25 12:31:53 -06005858{
5859 /* TODO: Verify that this works... */
5860 struct ipw_fixed_rate fr = {
5861 .tx_rates = priv->rates_mask
5862 };
5863 u32 reg;
5864 u16 mask = 0;
5865
Jeff Garzikbf794512005-07-31 13:07:26 -04005866 /* Identify 'current FW band' and match it with the fixed
James Ketrenos43f66a62005-03-25 12:31:53 -06005867 * Tx rates */
Jeff Garzikbf794512005-07-31 13:07:26 -04005868
James Ketrenos43f66a62005-03-25 12:31:53 -06005869 switch (priv->ieee->freq_band) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005870 case IEEE80211_52GHZ_BAND: /* A only */
James Ketrenos43f66a62005-03-25 12:31:53 -06005871 /* IEEE_A */
5872 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5873 /* Invalid fixed rate mask */
James Ketrenosea2b26e2005-08-24 21:25:16 -05005874 IPW_DEBUG_WX
5875 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06005876 fr.tx_rates = 0;
5877 break;
5878 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005879
James Ketrenos43f66a62005-03-25 12:31:53 -06005880 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5881 break;
5882
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005883 default: /* 2.4Ghz or Mixed */
James Ketrenos43f66a62005-03-25 12:31:53 -06005884 /* IEEE_B */
James Ketrenosb095c382005-08-24 22:04:42 -05005885 if (mode == IEEE_B) {
James Ketrenos43f66a62005-03-25 12:31:53 -06005886 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5887 /* Invalid fixed rate mask */
James Ketrenosea2b26e2005-08-24 21:25:16 -05005888 IPW_DEBUG_WX
5889 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06005890 fr.tx_rates = 0;
5891 }
5892 break;
Jeff Garzikbf794512005-07-31 13:07:26 -04005893 }
James Ketrenos43f66a62005-03-25 12:31:53 -06005894
5895 /* IEEE_G */
5896 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5897 IEEE80211_OFDM_RATES_MASK)) {
5898 /* Invalid fixed rate mask */
James Ketrenosea2b26e2005-08-24 21:25:16 -05005899 IPW_DEBUG_WX
5900 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06005901 fr.tx_rates = 0;
5902 break;
5903 }
5904
5905 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5906 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5907 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5908 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005909
James Ketrenos43f66a62005-03-25 12:31:53 -06005910 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5911 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5912 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5913 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005914
James Ketrenos43f66a62005-03-25 12:31:53 -06005915 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5916 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5917 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5918 }
Jeff Garzikbf794512005-07-31 13:07:26 -04005919
James Ketrenos43f66a62005-03-25 12:31:53 -06005920 fr.tx_rates |= mask;
5921 break;
5922 }
5923
5924 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04005925 ipw_write_reg32(priv, reg, *(u32 *) & fr);
James Ketrenos43f66a62005-03-25 12:31:53 -06005926}
5927
James Ketrenosea2b26e2005-08-24 21:25:16 -05005928static void ipw_abort_scan(struct ipw_priv *priv)
5929{
5930 int err;
5931
5932 if (priv->status & STATUS_SCAN_ABORTING) {
5933 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5934 return;
5935 }
5936 priv->status |= STATUS_SCAN_ABORTING;
5937
5938 err = ipw_send_scan_abort(priv);
5939 if (err)
5940 IPW_DEBUG_HC("Request to abort scan failed.\n");
5941}
5942
James Ketrenosafbf30a2005-08-25 00:05:33 -05005943static void ipw_add_scan_channels(struct ipw_priv *priv,
5944 struct ipw_scan_request_ext *scan,
5945 int scan_type)
5946{
5947 int channel_index = 0;
5948 const struct ieee80211_geo *geo;
5949 int i;
5950
Larry Finger1867b112006-02-28 09:48:28 -06005951 geo = ieee80211_get_geo(priv->ieee);
James Ketrenosafbf30a2005-08-25 00:05:33 -05005952
5953 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5954 int start = channel_index;
5955 for (i = 0; i < geo->a_channels; i++) {
5956 if ((priv->status & STATUS_ASSOCIATED) &&
5957 geo->a[i].channel == priv->channel)
5958 continue;
5959 channel_index++;
5960 scan->channels_list[channel_index] = geo->a[i].channel;
Liu Hong1fe0adb2005-08-19 09:33:10 -05005961 ipw_set_scan_type(scan, channel_index,
5962 geo->a[i].
5963 flags & IEEE80211_CH_PASSIVE_ONLY ?
5964 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5965 scan_type);
James Ketrenosafbf30a2005-08-25 00:05:33 -05005966 }
5967
5968 if (start != channel_index) {
5969 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5970 (channel_index - start);
5971 channel_index++;
5972 }
5973 }
5974
5975 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5976 int start = channel_index;
5977 if (priv->config & CFG_SPEED_SCAN) {
Liu Hong1fe0adb2005-08-19 09:33:10 -05005978 int index;
James Ketrenosafbf30a2005-08-25 00:05:33 -05005979 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5980 /* nop out the list */
5981 [0] = 0
5982 };
5983
5984 u8 channel;
5985 while (channel_index < IPW_SCAN_CHANNELS) {
5986 channel =
5987 priv->speed_scan[priv->speed_scan_pos];
5988 if (channel == 0) {
5989 priv->speed_scan_pos = 0;
5990 channel = priv->speed_scan[0];
5991 }
5992 if ((priv->status & STATUS_ASSOCIATED) &&
5993 channel == priv->channel) {
5994 priv->speed_scan_pos++;
5995 continue;
5996 }
5997
5998 /* If this channel has already been
5999 * added in scan, break from loop
6000 * and this will be the first channel
6001 * in the next scan.
6002 */
6003 if (channels[channel - 1] != 0)
6004 break;
6005
6006 channels[channel - 1] = 1;
6007 priv->speed_scan_pos++;
6008 channel_index++;
6009 scan->channels_list[channel_index] = channel;
Liu Hong1fe0adb2005-08-19 09:33:10 -05006010 index =
Larry Finger1867b112006-02-28 09:48:28 -06006011 ieee80211_channel_to_index(priv->ieee, channel);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006012 ipw_set_scan_type(scan, channel_index,
Liu Hong1fe0adb2005-08-19 09:33:10 -05006013 geo->bg[index].
6014 flags &
6015 IEEE80211_CH_PASSIVE_ONLY ?
6016 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6017 : scan_type);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006018 }
6019 } else {
6020 for (i = 0; i < geo->bg_channels; i++) {
6021 if ((priv->status & STATUS_ASSOCIATED) &&
6022 geo->bg[i].channel == priv->channel)
6023 continue;
6024 channel_index++;
6025 scan->channels_list[channel_index] =
6026 geo->bg[i].channel;
6027 ipw_set_scan_type(scan, channel_index,
Liu Hong1fe0adb2005-08-19 09:33:10 -05006028 geo->bg[i].
6029 flags &
6030 IEEE80211_CH_PASSIVE_ONLY ?
6031 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6032 : scan_type);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006033 }
6034 }
6035
6036 if (start != channel_index) {
6037 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6038 (channel_index - start);
6039 }
6040 }
6041}
6042
James Ketrenosea2b26e2005-08-24 21:25:16 -05006043static int ipw_request_scan(struct ipw_priv *priv)
6044{
6045 struct ipw_scan_request_ext scan;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006046 int err = 0, scan_type;
6047
6048 if (!(priv->status & STATUS_INIT) ||
6049 (priv->status & STATUS_EXIT_PENDING))
6050 return 0;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006051
Zhu Yi46441512006-01-24 16:37:59 +08006052 mutex_lock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05006053
James Ketrenosea2b26e2005-08-24 21:25:16 -05006054 if (priv->status & STATUS_SCANNING) {
James Ketrenosa613bff2005-08-24 21:43:11 -05006055 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
James Ketrenosea2b26e2005-08-24 21:25:16 -05006056 priv->status |= STATUS_SCAN_PENDING;
James Ketrenosb095c382005-08-24 22:04:42 -05006057 goto done;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006058 }
6059
James Ketrenosafbf30a2005-08-25 00:05:33 -05006060 if (!(priv->status & STATUS_SCAN_FORCED) &&
6061 priv->status & STATUS_SCAN_ABORTING) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05006062 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6063 priv->status |= STATUS_SCAN_PENDING;
James Ketrenosb095c382005-08-24 22:04:42 -05006064 goto done;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006065 }
6066
6067 if (priv->status & STATUS_RF_KILL_MASK) {
6068 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6069 priv->status |= STATUS_SCAN_PENDING;
James Ketrenosb095c382005-08-24 22:04:42 -05006070 goto done;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006071 }
6072
6073 memset(&scan, 0, sizeof(scan));
6074
James Ketrenosb095c382005-08-24 22:04:42 -05006075 if (priv->config & CFG_SPEED_SCAN)
6076 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6077 cpu_to_le16(30);
6078 else
6079 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6080 cpu_to_le16(20);
6081
James Ketrenosa613bff2005-08-24 21:43:11 -05006082 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6083 cpu_to_le16(20);
Liu Hong1fe0adb2005-08-19 09:33:10 -05006084 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
James Ketrenosea2b26e2005-08-24 21:25:16 -05006085
James Ketrenosa613bff2005-08-24 21:43:11 -05006086 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
James Ketrenosea2b26e2005-08-24 21:25:16 -05006087
James Ketrenosb095c382005-08-24 22:04:42 -05006088#ifdef CONFIG_IPW2200_MONITOR
James Ketrenosea2b26e2005-08-24 21:25:16 -05006089 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05006090 u8 channel;
James Ketrenosb095c382005-08-24 22:04:42 -05006091 u8 band = 0;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006092
Larry Finger1867b112006-02-28 09:48:28 -06006093 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
James Ketrenosb095c382005-08-24 22:04:42 -05006094 case IEEE80211_52GHZ_BAND:
James Ketrenosea2b26e2005-08-24 21:25:16 -05006095 band = (u8) (IPW_A_MODE << 6) | 1;
James Ketrenosb095c382005-08-24 22:04:42 -05006096 channel = priv->channel;
6097 break;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006098
James Ketrenosb095c382005-08-24 22:04:42 -05006099 case IEEE80211_24GHZ_BAND:
James Ketrenosea2b26e2005-08-24 21:25:16 -05006100 band = (u8) (IPW_B_MODE << 6) | 1;
James Ketrenosb095c382005-08-24 22:04:42 -05006101 channel = priv->channel;
6102 break;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006103
James Ketrenosb095c382005-08-24 22:04:42 -05006104 default:
James Ketrenosea2b26e2005-08-24 21:25:16 -05006105 band = (u8) (IPW_B_MODE << 6) | 1;
6106 channel = 9;
James Ketrenosb095c382005-08-24 22:04:42 -05006107 break;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006108 }
6109
James Ketrenosb095c382005-08-24 22:04:42 -05006110 scan.channels_list[0] = band;
6111 scan.channels_list[1] = channel;
6112 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
James Ketrenosea2b26e2005-08-24 21:25:16 -05006113
James Ketrenosb095c382005-08-24 22:04:42 -05006114 /* NOTE: The card will sit on this channel for this time
6115 * period. Scan aborts are timing sensitive and frequently
6116 * result in firmware restarts. As such, it is best to
6117 * set a small dwell_time here and just keep re-issuing
6118 * scans. Otherwise fast channel hopping will not actually
6119 * hop channels.
6120 *
6121 * TODO: Move SPEED SCAN support to all modes and bands */
James Ketrenosa613bff2005-08-24 21:43:11 -05006122 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6123 cpu_to_le16(2000);
James Ketrenosea2b26e2005-08-24 21:25:16 -05006124 } else {
James Ketrenosb095c382005-08-24 22:04:42 -05006125#endif /* CONFIG_IPW2200_MONITOR */
6126 /* If we are roaming, then make this a directed scan for the
6127 * current network. Otherwise, ensure that every other scan
6128 * is a fast channel hop scan */
6129 if ((priv->status & STATUS_ROAMING)
6130 || (!(priv->status & STATUS_ASSOCIATED)
6131 && (priv->config & CFG_STATIC_ESSID)
6132 && (le32_to_cpu(scan.full_scan_index) % 2))) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05006133 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6134 if (err) {
James Ketrenosb095c382005-08-24 22:04:42 -05006135 IPW_DEBUG_HC("Attempt to send SSID command "
6136 "failed.\n");
6137 goto done;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006138 }
6139
6140 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006141 } else
James Ketrenosea2b26e2005-08-24 21:25:16 -05006142 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006143
James Ketrenosafbf30a2005-08-25 00:05:33 -05006144 ipw_add_scan_channels(priv, &scan, scan_type);
James Ketrenosb095c382005-08-24 22:04:42 -05006145#ifdef CONFIG_IPW2200_MONITOR
James Ketrenosea2b26e2005-08-24 21:25:16 -05006146 }
6147#endif
6148
6149 err = ipw_send_scan_request_ext(priv, &scan);
6150 if (err) {
6151 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
James Ketrenosb095c382005-08-24 22:04:42 -05006152 goto done;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006153 }
6154
6155 priv->status |= STATUS_SCANNING;
6156 priv->status &= ~STATUS_SCAN_PENDING;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006157 queue_delayed_work(priv->workqueue, &priv->scan_check,
6158 IPW_SCAN_CHECK_WATCHDOG);
James Ketrenosb095c382005-08-24 22:04:42 -05006159 done:
Zhu Yi46441512006-01-24 16:37:59 +08006160 mutex_unlock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05006161 return err;
James Ketrenosc848d0a2005-08-24 21:56:24 -05006162}
6163
6164static void ipw_bg_abort_scan(void *data)
6165{
6166 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08006167 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05006168 ipw_abort_scan(data);
Zhu Yi46441512006-01-24 16:37:59 +08006169 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05006170}
6171
James Ketrenosea2b26e2005-08-24 21:25:16 -05006172static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6173{
James Ketrenosb095c382005-08-24 22:04:42 -05006174 /* This is called when wpa_supplicant loads and closes the driver
6175 * interface. */
Hong Liucdd1fa12005-08-31 18:14:27 +08006176 priv->ieee->wpa_enabled = value;
James Ketrenosb095c382005-08-24 22:04:42 -05006177 return 0;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006178}
6179
James Ketrenosea2b26e2005-08-24 21:25:16 -05006180static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6181{
6182 struct ieee80211_device *ieee = priv->ieee;
6183 struct ieee80211_security sec = {
6184 .flags = SEC_AUTH_MODE,
6185 };
6186 int ret = 0;
6187
James Ketrenosafbf30a2005-08-25 00:05:33 -05006188 if (value & IW_AUTH_ALG_SHARED_KEY) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05006189 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6190 ieee->open_wep = 0;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006191 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05006192 sec.auth_mode = WLAN_AUTH_OPEN;
6193 ieee->open_wep = 1;
Zhu Yi3e234b42006-01-24 16:36:52 +08006194 } else if (value & IW_AUTH_ALG_LEAP) {
6195 sec.auth_mode = WLAN_AUTH_LEAP;
6196 ieee->open_wep = 1;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006197 } else
6198 return -EINVAL;
James Ketrenosea2b26e2005-08-24 21:25:16 -05006199
6200 if (ieee->set_security)
6201 ieee->set_security(ieee->dev, &sec);
6202 else
6203 ret = -EOPNOTSUPP;
6204
6205 return ret;
6206}
6207
Adrian Bunka73e22b2006-01-21 01:39:42 +01006208static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6209 int wpa_ie_len)
James Ketrenosafbf30a2005-08-25 00:05:33 -05006210{
6211 /* make sure WPA is enabled */
6212 ipw_wpa_enable(priv, 1);
6213
6214 ipw_disassociate(priv);
6215}
6216
6217static int ipw_set_rsn_capa(struct ipw_priv *priv,
6218 char *capabilities, int length)
6219{
James Ketrenosafbf30a2005-08-25 00:05:33 -05006220 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6221
Zhu Yi0a7bcf22006-01-24 16:37:28 +08006222 return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
Zhu Yi2638bc32006-01-24 16:37:52 +08006223 capabilities);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006224}
6225
James Ketrenosafbf30a2005-08-25 00:05:33 -05006226/*
6227 * WE-18 support
6228 */
6229
6230/* SIOCSIWGENIE */
6231static int ipw_wx_set_genie(struct net_device *dev,
6232 struct iw_request_info *info,
6233 union iwreq_data *wrqu, char *extra)
6234{
6235 struct ipw_priv *priv = ieee80211_priv(dev);
6236 struct ieee80211_device *ieee = priv->ieee;
6237 u8 *buf;
6238 int err = 0;
6239
6240 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6241 (wrqu->data.length && extra == NULL))
6242 return -EINVAL;
6243
Zhu Yi46441512006-01-24 16:37:59 +08006244 //mutex_lock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006245
6246 //if (!ieee->wpa_enabled) {
6247 // err = -EOPNOTSUPP;
6248 // goto out;
6249 //}
6250
6251 if (wrqu->data.length) {
6252 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6253 if (buf == NULL) {
6254 err = -ENOMEM;
6255 goto out;
6256 }
6257
6258 memcpy(buf, extra, wrqu->data.length);
6259 kfree(ieee->wpa_ie);
6260 ieee->wpa_ie = buf;
6261 ieee->wpa_ie_len = wrqu->data.length;
6262 } else {
6263 kfree(ieee->wpa_ie);
6264 ieee->wpa_ie = NULL;
6265 ieee->wpa_ie_len = 0;
6266 }
6267
6268 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6269 out:
Zhu Yi46441512006-01-24 16:37:59 +08006270 //mutex_unlock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006271 return err;
6272}
6273
6274/* SIOCGIWGENIE */
6275static int ipw_wx_get_genie(struct net_device *dev,
6276 struct iw_request_info *info,
6277 union iwreq_data *wrqu, char *extra)
6278{
6279 struct ipw_priv *priv = ieee80211_priv(dev);
6280 struct ieee80211_device *ieee = priv->ieee;
6281 int err = 0;
6282
Zhu Yi46441512006-01-24 16:37:59 +08006283 //mutex_lock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006284
6285 //if (!ieee->wpa_enabled) {
6286 // err = -EOPNOTSUPP;
6287 // goto out;
6288 //}
6289
6290 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6291 wrqu->data.length = 0;
6292 goto out;
6293 }
6294
6295 if (wrqu->data.length < ieee->wpa_ie_len) {
6296 err = -E2BIG;
6297 goto out;
6298 }
6299
6300 wrqu->data.length = ieee->wpa_ie_len;
6301 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6302
6303 out:
Zhu Yi46441512006-01-24 16:37:59 +08006304 //mutex_unlock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006305 return err;
6306}
6307
Zhu Yi1fbfea52005-08-05 17:22:56 +08006308static int wext_cipher2level(int cipher)
6309{
6310 switch (cipher) {
6311 case IW_AUTH_CIPHER_NONE:
6312 return SEC_LEVEL_0;
6313 case IW_AUTH_CIPHER_WEP40:
6314 case IW_AUTH_CIPHER_WEP104:
6315 return SEC_LEVEL_1;
6316 case IW_AUTH_CIPHER_TKIP:
6317 return SEC_LEVEL_2;
6318 case IW_AUTH_CIPHER_CCMP:
6319 return SEC_LEVEL_3;
6320 default:
6321 return -1;
6322 }
6323}
6324
James Ketrenosafbf30a2005-08-25 00:05:33 -05006325/* SIOCSIWAUTH */
6326static int ipw_wx_set_auth(struct net_device *dev,
6327 struct iw_request_info *info,
6328 union iwreq_data *wrqu, char *extra)
6329{
6330 struct ipw_priv *priv = ieee80211_priv(dev);
6331 struct ieee80211_device *ieee = priv->ieee;
6332 struct iw_param *param = &wrqu->param;
6333 struct ieee80211_crypt_data *crypt;
6334 unsigned long flags;
6335 int ret = 0;
6336
6337 switch (param->flags & IW_AUTH_INDEX) {
6338 case IW_AUTH_WPA_VERSION:
Zhu Yi1fbfea52005-08-05 17:22:56 +08006339 break;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006340 case IW_AUTH_CIPHER_PAIRWISE:
Zhu Yi1fbfea52005-08-05 17:22:56 +08006341 ipw_set_hw_decrypt_unicast(priv,
6342 wext_cipher2level(param->value));
6343 break;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006344 case IW_AUTH_CIPHER_GROUP:
Zhu Yi1fbfea52005-08-05 17:22:56 +08006345 ipw_set_hw_decrypt_multicast(priv,
6346 wext_cipher2level(param->value));
6347 break;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006348 case IW_AUTH_KEY_MGMT:
6349 /*
6350 * ipw2200 does not use these parameters
6351 */
6352 break;
6353
6354 case IW_AUTH_TKIP_COUNTERMEASURES:
6355 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
James Ketrenos991d1cc2005-10-13 09:26:48 +00006356 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
James Ketrenosafbf30a2005-08-25 00:05:33 -05006357 break;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006358
6359 flags = crypt->ops->get_flags(crypt->priv);
6360
6361 if (param->value)
6362 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6363 else
6364 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6365
6366 crypt->ops->set_flags(flags, crypt->priv);
6367
6368 break;
6369
6370 case IW_AUTH_DROP_UNENCRYPTED:{
6371 /* HACK:
6372 *
6373 * wpa_supplicant calls set_wpa_enabled when the driver
6374 * is loaded and unloaded, regardless of if WPA is being
6375 * used. No other calls are made which can be used to
6376 * determine if encryption will be used or not prior to
6377 * association being expected. If encryption is not being
6378 * used, drop_unencrypted is set to false, else true -- we
6379 * can use this to determine if the CAP_PRIVACY_ON bit should
6380 * be set.
6381 */
6382 struct ieee80211_security sec = {
6383 .flags = SEC_ENABLED,
6384 .enabled = param->value,
6385 };
6386 priv->ieee->drop_unencrypted = param->value;
6387 /* We only change SEC_LEVEL for open mode. Others
6388 * are set by ipw_wpa_set_encryption.
6389 */
6390 if (!param->value) {
6391 sec.flags |= SEC_LEVEL;
6392 sec.level = SEC_LEVEL_0;
6393 } else {
6394 sec.flags |= SEC_LEVEL;
6395 sec.level = SEC_LEVEL_1;
6396 }
6397 if (priv->ieee->set_security)
6398 priv->ieee->set_security(priv->ieee->dev, &sec);
6399 break;
6400 }
6401
6402 case IW_AUTH_80211_AUTH_ALG:
6403 ret = ipw_wpa_set_auth_algs(priv, param->value);
6404 break;
6405
6406 case IW_AUTH_WPA_ENABLED:
6407 ret = ipw_wpa_enable(priv, param->value);
6408 break;
6409
6410 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6411 ieee->ieee802_1x = param->value;
6412 break;
6413
6414 //case IW_AUTH_ROAMING_CONTROL:
6415 case IW_AUTH_PRIVACY_INVOKED:
6416 ieee->privacy_invoked = param->value;
6417 break;
6418
6419 default:
6420 return -EOPNOTSUPP;
6421 }
6422 return ret;
6423}
6424
6425/* SIOCGIWAUTH */
6426static int ipw_wx_get_auth(struct net_device *dev,
6427 struct iw_request_info *info,
6428 union iwreq_data *wrqu, char *extra)
6429{
6430 struct ipw_priv *priv = ieee80211_priv(dev);
6431 struct ieee80211_device *ieee = priv->ieee;
6432 struct ieee80211_crypt_data *crypt;
6433 struct iw_param *param = &wrqu->param;
6434 int ret = 0;
6435
6436 switch (param->flags & IW_AUTH_INDEX) {
6437 case IW_AUTH_WPA_VERSION:
6438 case IW_AUTH_CIPHER_PAIRWISE:
6439 case IW_AUTH_CIPHER_GROUP:
6440 case IW_AUTH_KEY_MGMT:
6441 /*
6442 * wpa_supplicant will control these internally
6443 */
6444 ret = -EOPNOTSUPP;
6445 break;
6446
6447 case IW_AUTH_TKIP_COUNTERMEASURES:
6448 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
James Ketrenos991d1cc2005-10-13 09:26:48 +00006449 if (!crypt || !crypt->ops->get_flags)
James Ketrenosafbf30a2005-08-25 00:05:33 -05006450 break;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006451
6452 param->value = (crypt->ops->get_flags(crypt->priv) &
6453 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6454
6455 break;
6456
6457 case IW_AUTH_DROP_UNENCRYPTED:
6458 param->value = ieee->drop_unencrypted;
6459 break;
6460
6461 case IW_AUTH_80211_AUTH_ALG:
6462 param->value = ieee->sec.auth_mode;
6463 break;
6464
6465 case IW_AUTH_WPA_ENABLED:
6466 param->value = ieee->wpa_enabled;
6467 break;
6468
6469 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6470 param->value = ieee->ieee802_1x;
6471 break;
6472
6473 case IW_AUTH_ROAMING_CONTROL:
6474 case IW_AUTH_PRIVACY_INVOKED:
6475 param->value = ieee->privacy_invoked;
6476 break;
6477
6478 default:
6479 return -EOPNOTSUPP;
6480 }
6481 return 0;
6482}
6483
6484/* SIOCSIWENCODEEXT */
6485static int ipw_wx_set_encodeext(struct net_device *dev,
6486 struct iw_request_info *info,
6487 union iwreq_data *wrqu, char *extra)
6488{
6489 struct ipw_priv *priv = ieee80211_priv(dev);
6490 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6491
6492 if (hwcrypto) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05006493 if (ext->alg == IW_ENCODE_ALG_TKIP) {
Hong Liu567deaf2005-08-31 18:07:22 +08006494 /* IPW HW can't build TKIP MIC,
6495 host decryption still needed */
6496 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6497 priv->ieee->host_mc_decrypt = 1;
6498 else {
6499 priv->ieee->host_encrypt = 0;
6500 priv->ieee->host_encrypt_msdu = 1;
6501 priv->ieee->host_decrypt = 1;
6502 }
James Ketrenosafbf30a2005-08-25 00:05:33 -05006503 } else {
6504 priv->ieee->host_encrypt = 0;
6505 priv->ieee->host_encrypt_msdu = 0;
6506 priv->ieee->host_decrypt = 0;
Hong Liu567deaf2005-08-31 18:07:22 +08006507 priv->ieee->host_mc_decrypt = 0;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006508 }
6509 }
6510
6511 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6512}
6513
6514/* SIOCGIWENCODEEXT */
6515static int ipw_wx_get_encodeext(struct net_device *dev,
6516 struct iw_request_info *info,
6517 union iwreq_data *wrqu, char *extra)
6518{
6519 struct ipw_priv *priv = ieee80211_priv(dev);
6520 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6521}
6522
6523/* SIOCSIWMLME */
6524static int ipw_wx_set_mlme(struct net_device *dev,
6525 struct iw_request_info *info,
6526 union iwreq_data *wrqu, char *extra)
6527{
6528 struct ipw_priv *priv = ieee80211_priv(dev);
6529 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6530 u16 reason;
6531
6532 reason = cpu_to_le16(mlme->reason_code);
6533
6534 switch (mlme->cmd) {
6535 case IW_MLME_DEAUTH:
6536 // silently ignore
6537 break;
6538
6539 case IW_MLME_DISASSOC:
6540 ipw_disassociate(priv);
6541 break;
6542
6543 default:
6544 return -EOPNOTSUPP;
6545 }
6546 return 0;
6547}
James Ketrenosea2b26e2005-08-24 21:25:16 -05006548
James Ketrenosb095c382005-08-24 22:04:42 -05006549#ifdef CONFIG_IPW_QOS
6550
6551/* QoS */
6552/*
6553* get the modulation type of the current network or
6554* the card current mode
6555*/
Adrian Bunk53d0bcf2006-03-04 13:14:31 +01006556static u8 ipw_qos_current_mode(struct ipw_priv * priv)
James Ketrenosb095c382005-08-24 22:04:42 -05006557{
6558 u8 mode = 0;
6559
6560 if (priv->status & STATUS_ASSOCIATED) {
6561 unsigned long flags;
6562
6563 spin_lock_irqsave(&priv->ieee->lock, flags);
6564 mode = priv->assoc_network->mode;
6565 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6566 } else {
6567 mode = priv->ieee->mode;
6568 }
6569 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6570 return mode;
6571}
6572
6573/*
6574* Handle management frame beacon and probe response
6575*/
James Ketrenos3b9990c2005-08-19 13:18:55 -05006576static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6577 int active_network,
6578 struct ieee80211_network *network)
James Ketrenosb095c382005-08-24 22:04:42 -05006579{
6580 u32 size = sizeof(struct ieee80211_qos_parameters);
6581
James Ketrenosafbf30a2005-08-25 00:05:33 -05006582 if (network->capability & WLAN_CAPABILITY_IBSS)
James Ketrenosb095c382005-08-24 22:04:42 -05006583 network->qos_data.active = network->qos_data.supported;
6584
6585 if (network->flags & NETWORK_HAS_QOS_MASK) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05006586 if (active_network &&
6587 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
James Ketrenosb095c382005-08-24 22:04:42 -05006588 network->qos_data.active = network->qos_data.supported;
6589
6590 if ((network->qos_data.active == 1) && (active_network == 1) &&
6591 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6592 (network->qos_data.old_param_count !=
6593 network->qos_data.param_count)) {
6594 network->qos_data.old_param_count =
6595 network->qos_data.param_count;
6596 schedule_work(&priv->qos_activate);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006597 IPW_DEBUG_QOS("QoS parameters change call "
6598 "qos_activate\n");
James Ketrenosb095c382005-08-24 22:04:42 -05006599 }
6600 } else {
James Ketrenosafbf30a2005-08-25 00:05:33 -05006601 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6602 memcpy(&network->qos_data.parameters,
James Ketrenosb095c382005-08-24 22:04:42 -05006603 &def_parameters_CCK, size);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006604 else
6605 memcpy(&network->qos_data.parameters,
James Ketrenosb095c382005-08-24 22:04:42 -05006606 &def_parameters_OFDM, size);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006607
James Ketrenosb095c382005-08-24 22:04:42 -05006608 if ((network->qos_data.active == 1) && (active_network == 1)) {
6609 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6610 schedule_work(&priv->qos_activate);
6611 }
6612
6613 network->qos_data.active = 0;
6614 network->qos_data.supported = 0;
6615 }
James Ketrenosafbf30a2005-08-25 00:05:33 -05006616 if ((priv->status & STATUS_ASSOCIATED) &&
6617 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6618 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6619 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6620 !(network->flags & NETWORK_EMPTY_ESSID))
James Ketrenosb095c382005-08-24 22:04:42 -05006621 if ((network->ssid_len ==
James Ketrenosafbf30a2005-08-25 00:05:33 -05006622 priv->assoc_network->ssid_len) &&
6623 !memcmp(network->ssid,
6624 priv->assoc_network->ssid,
6625 network->ssid_len)) {
James Ketrenosb095c382005-08-24 22:04:42 -05006626 queue_work(priv->workqueue,
6627 &priv->merge_networks);
6628 }
James Ketrenosb095c382005-08-24 22:04:42 -05006629 }
6630
6631 return 0;
6632}
6633
6634/*
6635* This function set up the firmware to support QoS. It sends
6636* IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6637*/
6638static int ipw_qos_activate(struct ipw_priv *priv,
6639 struct ieee80211_qos_data *qos_network_data)
6640{
6641 int err;
6642 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6643 struct ieee80211_qos_parameters *active_one = NULL;
6644 u32 size = sizeof(struct ieee80211_qos_parameters);
6645 u32 burst_duration;
6646 int i;
6647 u8 type;
6648
6649 type = ipw_qos_current_mode(priv);
6650
6651 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6652 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6653 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6654 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6655
6656 if (qos_network_data == NULL) {
6657 if (type == IEEE_B) {
6658 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6659 active_one = &def_parameters_CCK;
6660 } else
6661 active_one = &def_parameters_OFDM;
6662
James Ketrenosafbf30a2005-08-25 00:05:33 -05006663 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
James Ketrenosb095c382005-08-24 22:04:42 -05006664 burst_duration = ipw_qos_get_burst_duration(priv);
6665 for (i = 0; i < QOS_QUEUE_NUM; i++)
James Ketrenosafbf30a2005-08-25 00:05:33 -05006666 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6667 (u16) burst_duration;
6668 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
James Ketrenosb095c382005-08-24 22:04:42 -05006669 if (type == IEEE_B) {
6670 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6671 type);
6672 if (priv->qos_data.qos_enable == 0)
6673 active_one = &def_parameters_CCK;
6674 else
6675 active_one = priv->qos_data.def_qos_parm_CCK;
6676 } else {
6677 if (priv->qos_data.qos_enable == 0)
6678 active_one = &def_parameters_OFDM;
6679 else
6680 active_one = priv->qos_data.def_qos_parm_OFDM;
6681 }
James Ketrenosafbf30a2005-08-25 00:05:33 -05006682 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
James Ketrenosb095c382005-08-24 22:04:42 -05006683 } else {
6684 unsigned long flags;
6685 int active;
6686
6687 spin_lock_irqsave(&priv->ieee->lock, flags);
6688 active_one = &(qos_network_data->parameters);
6689 qos_network_data->old_param_count =
6690 qos_network_data->param_count;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006691 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
James Ketrenosb095c382005-08-24 22:04:42 -05006692 active = qos_network_data->supported;
6693 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6694
6695 if (active == 0) {
6696 burst_duration = ipw_qos_get_burst_duration(priv);
6697 for (i = 0; i < QOS_QUEUE_NUM; i++)
6698 qos_parameters[QOS_PARAM_SET_ACTIVE].
6699 tx_op_limit[i] = (u16) burst_duration;
6700 }
6701 }
6702
6703 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
James Ketrenosafbf30a2005-08-25 00:05:33 -05006704 err = ipw_send_qos_params_command(priv,
6705 (struct ieee80211_qos_parameters *)
6706 &(qos_parameters[0]));
James Ketrenosb095c382005-08-24 22:04:42 -05006707 if (err)
6708 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6709
6710 return err;
6711}
6712
6713/*
6714* send IPW_CMD_WME_INFO to the firmware
6715*/
6716static int ipw_qos_set_info_element(struct ipw_priv *priv)
6717{
6718 int ret = 0;
6719 struct ieee80211_qos_information_element qos_info;
6720
6721 if (priv == NULL)
6722 return -1;
6723
6724 qos_info.elementID = QOS_ELEMENT_ID;
6725 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6726
6727 qos_info.version = QOS_VERSION_1;
6728 qos_info.ac_info = 0;
6729
6730 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6731 qos_info.qui_type = QOS_OUI_TYPE;
6732 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6733
6734 ret = ipw_send_qos_info_command(priv, &qos_info);
6735 if (ret != 0) {
6736 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6737 }
6738 return ret;
6739}
6740
6741/*
6742* Set the QoS parameter with the association request structure
6743*/
6744static int ipw_qos_association(struct ipw_priv *priv,
6745 struct ieee80211_network *network)
6746{
6747 int err = 0;
6748 struct ieee80211_qos_data *qos_data = NULL;
6749 struct ieee80211_qos_data ibss_data = {
6750 .supported = 1,
6751 .active = 1,
6752 };
6753
6754 switch (priv->ieee->iw_mode) {
6755 case IW_MODE_ADHOC:
6756 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6757 BUG();
6758
6759 qos_data = &ibss_data;
6760 break;
6761
6762 case IW_MODE_INFRA:
6763 qos_data = &network->qos_data;
6764 break;
6765
6766 default:
6767 BUG();
6768 break;
6769 }
6770
6771 err = ipw_qos_activate(priv, qos_data);
6772 if (err) {
6773 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6774 return err;
6775 }
6776
6777 if (priv->qos_data.qos_enable && qos_data->supported) {
6778 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6779 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6780 return ipw_qos_set_info_element(priv);
6781 }
6782
6783 return 0;
6784}
6785
6786/*
6787* handling the beaconing responces. if we get different QoS setting
6788* of the network from the the associated setting adjust the QoS
6789* setting
6790*/
6791static int ipw_qos_association_resp(struct ipw_priv *priv,
6792 struct ieee80211_network *network)
6793{
6794 int ret = 0;
6795 unsigned long flags;
6796 u32 size = sizeof(struct ieee80211_qos_parameters);
6797 int set_qos_param = 0;
6798
James Ketrenosafbf30a2005-08-25 00:05:33 -05006799 if ((priv == NULL) || (network == NULL) ||
6800 (priv->assoc_network == NULL))
James Ketrenosb095c382005-08-24 22:04:42 -05006801 return ret;
6802
6803 if (!(priv->status & STATUS_ASSOCIATED))
6804 return ret;
6805
James Ketrenosafbf30a2005-08-25 00:05:33 -05006806 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
James Ketrenosb095c382005-08-24 22:04:42 -05006807 return ret;
James Ketrenosb095c382005-08-24 22:04:42 -05006808
6809 spin_lock_irqsave(&priv->ieee->lock, flags);
6810 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05006811 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
James Ketrenosb095c382005-08-24 22:04:42 -05006812 sizeof(struct ieee80211_qos_data));
6813 priv->assoc_network->qos_data.active = 1;
6814 if ((network->qos_data.old_param_count !=
6815 network->qos_data.param_count)) {
6816 set_qos_param = 1;
6817 network->qos_data.old_param_count =
6818 network->qos_data.param_count;
6819 }
6820
6821 } else {
James Ketrenosafbf30a2005-08-25 00:05:33 -05006822 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6823 memcpy(&priv->assoc_network->qos_data.parameters,
James Ketrenosb095c382005-08-24 22:04:42 -05006824 &def_parameters_CCK, size);
James Ketrenosafbf30a2005-08-25 00:05:33 -05006825 else
6826 memcpy(&priv->assoc_network->qos_data.parameters,
James Ketrenosb095c382005-08-24 22:04:42 -05006827 &def_parameters_OFDM, size);
James Ketrenosb095c382005-08-24 22:04:42 -05006828 priv->assoc_network->qos_data.active = 0;
6829 priv->assoc_network->qos_data.supported = 0;
6830 set_qos_param = 1;
6831 }
6832
6833 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6834
6835 if (set_qos_param == 1)
6836 schedule_work(&priv->qos_activate);
6837
6838 return ret;
6839}
6840
6841static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6842{
6843 u32 ret = 0;
6844
6845 if ((priv == NULL))
6846 return 0;
6847
James Ketrenosafbf30a2005-08-25 00:05:33 -05006848 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
James Ketrenosb095c382005-08-24 22:04:42 -05006849 ret = priv->qos_data.burst_duration_CCK;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006850 else
James Ketrenosb095c382005-08-24 22:04:42 -05006851 ret = priv->qos_data.burst_duration_OFDM;
James Ketrenosafbf30a2005-08-25 00:05:33 -05006852
James Ketrenosb095c382005-08-24 22:04:42 -05006853 return ret;
6854}
6855
6856/*
6857* Initialize the setting of QoS global
6858*/
6859static void ipw_qos_init(struct ipw_priv *priv, int enable,
6860 int burst_enable, u32 burst_duration_CCK,
6861 u32 burst_duration_OFDM)
6862{
6863 priv->qos_data.qos_enable = enable;
6864
6865 if (priv->qos_data.qos_enable) {
6866 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6867 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6868 IPW_DEBUG_QOS("QoS is enabled\n");
6869 } else {
6870 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6871 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6872 IPW_DEBUG_QOS("QoS is not enabled\n");
6873 }
6874
6875 priv->qos_data.burst_enable = burst_enable;
6876
6877 if (burst_enable) {
6878 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6879 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6880 } else {
6881 priv->qos_data.burst_duration_CCK = 0;
6882 priv->qos_data.burst_duration_OFDM = 0;
6883 }
6884}
6885
6886/*
6887* map the packet priority to the right TX Queue
6888*/
6889static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6890{
6891 if (priority > 7 || !priv->qos_data.qos_enable)
6892 priority = 0;
6893
6894 return from_priority_to_tx_queue[priority] - 1;
6895}
6896
6897/*
6898* add QoS parameter to the TX command
6899*/
6900static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6901 u16 priority,
6902 struct tfd_data *tfd, u8 unicast)
6903{
6904 int ret = 0;
6905 int tx_queue_id = 0;
6906 struct ieee80211_qos_data *qos_data = NULL;
6907 int active, supported;
6908 unsigned long flags;
6909
6910 if (!(priv->status & STATUS_ASSOCIATED))
6911 return 0;
6912
6913 qos_data = &priv->assoc_network->qos_data;
6914
6915 spin_lock_irqsave(&priv->ieee->lock, flags);
6916
6917 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6918 if (unicast == 0)
6919 qos_data->active = 0;
6920 else
6921 qos_data->active = qos_data->supported;
6922 }
6923
6924 active = qos_data->active;
6925 supported = qos_data->supported;
6926
6927 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6928
James Ketrenosafbf30a2005-08-25 00:05:33 -05006929 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
6930 "unicast %d\n",
6931 priv->qos_data.qos_enable, active, supported, unicast);
James Ketrenosb095c382005-08-24 22:04:42 -05006932 if (active && priv->qos_data.qos_enable) {
6933 ret = from_priority_to_tx_queue[priority];
6934 tx_queue_id = ret - 1;
6935 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6936 if (priority <= 7) {
6937 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6938 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6939 tfd->tfd.tfd_26.mchdr.frame_ctl |=
6940 IEEE80211_STYPE_QOS_DATA;
6941
6942 if (priv->qos_data.qos_no_ack_mask &
6943 (1UL << tx_queue_id)) {
6944 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6945 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6946 CTRL_QOS_NO_ACK;
6947 }
6948 }
6949 }
6950
6951 return ret;
6952}
6953
6954/*
6955* background support to run QoS activate functionality
6956*/
6957static void ipw_bg_qos_activate(void *data)
6958{
6959 struct ipw_priv *priv = data;
6960
6961 if (priv == NULL)
6962 return;
6963
Zhu Yi46441512006-01-24 16:37:59 +08006964 mutex_lock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05006965
6966 if (priv->status & STATUS_ASSOCIATED)
6967 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6968
Zhu Yi46441512006-01-24 16:37:59 +08006969 mutex_unlock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05006970}
6971
James Ketrenos3b9990c2005-08-19 13:18:55 -05006972static int ipw_handle_probe_response(struct net_device *dev,
6973 struct ieee80211_probe_response *resp,
6974 struct ieee80211_network *network)
James Ketrenosb095c382005-08-24 22:04:42 -05006975{
6976 struct ipw_priv *priv = ieee80211_priv(dev);
James Ketrenos3b9990c2005-08-19 13:18:55 -05006977 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6978 (network == priv->assoc_network));
James Ketrenosb095c382005-08-24 22:04:42 -05006979
James Ketrenos3b9990c2005-08-19 13:18:55 -05006980 ipw_qos_handle_probe_response(priv, active_network, network);
James Ketrenosb095c382005-08-24 22:04:42 -05006981
James Ketrenos3b9990c2005-08-19 13:18:55 -05006982 return 0;
6983}
James Ketrenosb095c382005-08-24 22:04:42 -05006984
James Ketrenos3b9990c2005-08-19 13:18:55 -05006985static int ipw_handle_beacon(struct net_device *dev,
6986 struct ieee80211_beacon *resp,
6987 struct ieee80211_network *network)
6988{
6989 struct ipw_priv *priv = ieee80211_priv(dev);
6990 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6991 (network == priv->assoc_network));
6992
6993 ipw_qos_handle_probe_response(priv, active_network, network);
6994
6995 return 0;
6996}
6997
6998static int ipw_handle_assoc_response(struct net_device *dev,
6999 struct ieee80211_assoc_response *resp,
7000 struct ieee80211_network *network)
7001{
7002 struct ipw_priv *priv = ieee80211_priv(dev);
7003 ipw_qos_association_resp(priv, network);
James Ketrenosb095c382005-08-24 22:04:42 -05007004 return 0;
7005}
7006
7007static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7008 *qos_param)
7009{
Zhu Yi4e226992006-01-24 16:37:36 +08007010 return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7011 sizeof(*qos_param) * 3, qos_param);
James Ketrenosb095c382005-08-24 22:04:42 -05007012}
7013
7014static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7015 *qos_param)
7016{
Zhu Yi4e226992006-01-24 16:37:36 +08007017 return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7018 qos_param);
James Ketrenosb095c382005-08-24 22:04:42 -05007019}
7020
7021#endif /* CONFIG_IPW_QOS */
7022
James Ketrenos43f66a62005-03-25 12:31:53 -06007023static int ipw_associate_network(struct ipw_priv *priv,
7024 struct ieee80211_network *network,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007025 struct ipw_supported_rates *rates, int roaming)
James Ketrenos43f66a62005-03-25 12:31:53 -06007026{
7027 int err;
7028
7029 if (priv->config & CFG_FIXED_RATE)
James Ketrenosb095c382005-08-24 22:04:42 -05007030 ipw_set_fixed_rate(priv, network->mode);
James Ketrenos43f66a62005-03-25 12:31:53 -06007031
7032 if (!(priv->config & CFG_STATIC_ESSID)) {
Jeff Garzikbf794512005-07-31 13:07:26 -04007033 priv->essid_len = min(network->ssid_len,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007034 (u8) IW_ESSID_MAX_SIZE);
James Ketrenos43f66a62005-03-25 12:31:53 -06007035 memcpy(priv->essid, network->ssid, priv->essid_len);
7036 }
7037
7038 network->last_associate = jiffies;
7039
7040 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7041 priv->assoc_request.channel = network->channel;
Zhu Yi3e234b42006-01-24 16:36:52 +08007042 priv->assoc_request.auth_key = 0;
7043
James Ketrenos43f66a62005-03-25 12:31:53 -06007044 if ((priv->capability & CAP_PRIVACY_ON) &&
Zhu Yi3e234b42006-01-24 16:36:52 +08007045 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
James Ketrenos43f66a62005-03-25 12:31:53 -06007046 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
James Ketrenosb095c382005-08-24 22:04:42 -05007047 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7048
Zhu Yi1ba61e02006-02-15 13:00:55 +08007049 if (priv->ieee->sec.level == SEC_LEVEL_1)
James Ketrenosb095c382005-08-24 22:04:42 -05007050 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
Zhu Yi3e234b42006-01-24 16:36:52 +08007051
7052 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7053 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7054 priv->assoc_request.auth_type = AUTH_LEAP;
7055 else
James Ketrenos43f66a62005-03-25 12:31:53 -06007056 priv->assoc_request.auth_type = AUTH_OPEN;
James Ketrenos43f66a62005-03-25 12:31:53 -06007057
James Ketrenosa613bff2005-08-24 21:43:11 -05007058 if (priv->ieee->wpa_ie_len) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05007059 priv->assoc_request.policy_support = 0x02; /* RSN active */
7060 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7061 priv->ieee->wpa_ie_len);
7062 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007063
Jeff Garzikbf794512005-07-31 13:07:26 -04007064 /*
7065 * It is valid for our ieee device to support multiple modes, but
7066 * when it comes to associating to a given network we have to choose
James Ketrenos43f66a62005-03-25 12:31:53 -06007067 * just one mode.
7068 */
7069 if (network->mode & priv->ieee->mode & IEEE_A)
7070 priv->assoc_request.ieee_mode = IPW_A_MODE;
7071 else if (network->mode & priv->ieee->mode & IEEE_G)
7072 priv->assoc_request.ieee_mode = IPW_G_MODE;
7073 else if (network->mode & priv->ieee->mode & IEEE_B)
7074 priv->assoc_request.ieee_mode = IPW_B_MODE;
7075
James Ketrenosea2b26e2005-08-24 21:25:16 -05007076 priv->assoc_request.capability = network->capability;
7077 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7078 && !(priv->config & CFG_PREAMBLE_LONG)) {
7079 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7080 } else {
7081 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7082
7083 /* Clear the short preamble if we won't be supporting it */
7084 priv->assoc_request.capability &=
7085 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7086 }
7087
James Ketrenosafbf30a2005-08-25 00:05:33 -05007088 /* Clear capability bits that aren't used in Ad Hoc */
7089 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7090 priv->assoc_request.capability &=
7091 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7092
James Ketrenos43f66a62005-03-25 12:31:53 -06007093 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
James Ketrenosea2b26e2005-08-24 21:25:16 -05007094 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06007095 roaming ? "Rea" : "A",
Jeff Garzikbf794512005-07-31 13:07:26 -04007096 escape_essid(priv->essid, priv->essid_len),
7097 network->channel,
7098 ipw_modes[priv->assoc_request.ieee_mode],
7099 rates->num_rates,
James Ketrenosea2b26e2005-08-24 21:25:16 -05007100 (priv->assoc_request.preamble_length ==
7101 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7102 network->capability &
7103 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
James Ketrenos43f66a62005-03-25 12:31:53 -06007104 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
Jeff Garzikbf794512005-07-31 13:07:26 -04007105 priv->capability & CAP_PRIVACY_ON ?
7106 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
James Ketrenos43f66a62005-03-25 12:31:53 -06007107 "(open)") : "",
7108 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
Jeff Garzikbf794512005-07-31 13:07:26 -04007109 priv->capability & CAP_PRIVACY_ON ?
James Ketrenosb095c382005-08-24 22:04:42 -05007110 '1' + priv->ieee->sec.active_key : '.',
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007111 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
James Ketrenos43f66a62005-03-25 12:31:53 -06007112
7113 priv->assoc_request.beacon_interval = network->beacon_interval;
7114 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007115 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
James Ketrenos43f66a62005-03-25 12:31:53 -06007116 priv->assoc_request.assoc_type = HC_IBSS_START;
7117 priv->assoc_request.assoc_tsf_msw = 0;
7118 priv->assoc_request.assoc_tsf_lsw = 0;
7119 } else {
7120 if (unlikely(roaming))
7121 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7122 else
7123 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7124 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7125 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7126 }
7127
James Ketrenosafbf30a2005-08-25 00:05:33 -05007128 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
James Ketrenos43f66a62005-03-25 12:31:53 -06007129
7130 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7131 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7132 priv->assoc_request.atim_window = network->atim_window;
7133 } else {
James Ketrenosafbf30a2005-08-25 00:05:33 -05007134 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
James Ketrenos43f66a62005-03-25 12:31:53 -06007135 priv->assoc_request.atim_window = 0;
7136 }
7137
James Ketrenos43f66a62005-03-25 12:31:53 -06007138 priv->assoc_request.listen_interval = network->listen_interval;
Jeff Garzikbf794512005-07-31 13:07:26 -04007139
James Ketrenos43f66a62005-03-25 12:31:53 -06007140 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7141 if (err) {
7142 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7143 return err;
7144 }
7145
7146 rates->ieee_mode = priv->assoc_request.ieee_mode;
7147 rates->purpose = IPW_RATE_CONNECT;
7148 ipw_send_supported_rates(priv, rates);
Jeff Garzikbf794512005-07-31 13:07:26 -04007149
James Ketrenos43f66a62005-03-25 12:31:53 -06007150 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7151 priv->sys_config.dot11g_auto_detection = 1;
7152 else
7153 priv->sys_config.dot11g_auto_detection = 0;
James Ketrenosc848d0a2005-08-24 21:56:24 -05007154
7155 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7156 priv->sys_config.answer_broadcast_ssid_probe = 1;
7157 else
7158 priv->sys_config.answer_broadcast_ssid_probe = 0;
7159
James Ketrenos43f66a62005-03-25 12:31:53 -06007160 err = ipw_send_system_config(priv, &priv->sys_config);
7161 if (err) {
7162 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7163 return err;
7164 }
Jeff Garzikbf794512005-07-31 13:07:26 -04007165
James Ketrenos43f66a62005-03-25 12:31:53 -06007166 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
James Ketrenosea2b26e2005-08-24 21:25:16 -05007167 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
James Ketrenos43f66a62005-03-25 12:31:53 -06007168 if (err) {
7169 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7170 return err;
7171 }
7172
7173 /*
7174 * If preemption is enabled, it is possible for the association
7175 * to complete before we return from ipw_send_associate. Therefore
7176 * we have to be sure and update our priviate data first.
7177 */
7178 priv->channel = network->channel;
7179 memcpy(priv->bssid, network->bssid, ETH_ALEN);
Jeff Garzikbf794512005-07-31 13:07:26 -04007180 priv->status |= STATUS_ASSOCIATING;
James Ketrenos43f66a62005-03-25 12:31:53 -06007181 priv->status &= ~STATUS_SECURITY_UPDATED;
7182
7183 priv->assoc_network = network;
7184
James Ketrenosb095c382005-08-24 22:04:42 -05007185#ifdef CONFIG_IPW_QOS
7186 ipw_qos_association(priv, network);
7187#endif
7188
James Ketrenos43f66a62005-03-25 12:31:53 -06007189 err = ipw_send_associate(priv, &priv->assoc_request);
7190 if (err) {
7191 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7192 return err;
7193 }
Jeff Garzikbf794512005-07-31 13:07:26 -04007194
7195 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
James Ketrenos43f66a62005-03-25 12:31:53 -06007196 escape_essid(priv->essid, priv->essid_len),
7197 MAC_ARG(priv->bssid));
7198
7199 return 0;
7200}
7201
7202static void ipw_roam(void *data)
7203{
7204 struct ipw_priv *priv = data;
7205 struct ieee80211_network *network = NULL;
7206 struct ipw_network_match match = {
7207 .network = priv->assoc_network
7208 };
7209
7210 /* The roaming process is as follows:
Jeff Garzikbf794512005-07-31 13:07:26 -04007211 *
7212 * 1. Missed beacon threshold triggers the roaming process by
James Ketrenos43f66a62005-03-25 12:31:53 -06007213 * setting the status ROAM bit and requesting a scan.
7214 * 2. When the scan completes, it schedules the ROAM work
7215 * 3. The ROAM work looks at all of the known networks for one that
7216 * is a better network than the currently associated. If none
7217 * found, the ROAM process is over (ROAM bit cleared)
7218 * 4. If a better network is found, a disassociation request is
7219 * sent.
7220 * 5. When the disassociation completes, the roam work is again
7221 * scheduled. The second time through, the driver is no longer
7222 * associated, and the newly selected network is sent an
Jeff Garzikbf794512005-07-31 13:07:26 -04007223 * association request.
James Ketrenos43f66a62005-03-25 12:31:53 -06007224 * 6. At this point ,the roaming process is complete and the ROAM
7225 * status bit is cleared.
7226 */
7227
7228 /* If we are no longer associated, and the roaming bit is no longer
7229 * set, then we are not actively roaming, so just return */
7230 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7231 return;
Jeff Garzikbf794512005-07-31 13:07:26 -04007232
James Ketrenos43f66a62005-03-25 12:31:53 -06007233 if (priv->status & STATUS_ASSOCIATED) {
Jeff Garzikbf794512005-07-31 13:07:26 -04007234 /* First pass through ROAM process -- look for a better
James Ketrenos43f66a62005-03-25 12:31:53 -06007235 * network */
James Ketrenosa613bff2005-08-24 21:43:11 -05007236 unsigned long flags;
James Ketrenos43f66a62005-03-25 12:31:53 -06007237 u8 rssi = priv->assoc_network->stats.rssi;
7238 priv->assoc_network->stats.rssi = -128;
James Ketrenosa613bff2005-08-24 21:43:11 -05007239 spin_lock_irqsave(&priv->ieee->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06007240 list_for_each_entry(network, &priv->ieee->network_list, list) {
7241 if (network != priv->assoc_network)
7242 ipw_best_network(priv, &match, network, 1);
7243 }
James Ketrenosa613bff2005-08-24 21:43:11 -05007244 spin_unlock_irqrestore(&priv->ieee->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06007245 priv->assoc_network->stats.rssi = rssi;
Jeff Garzikbf794512005-07-31 13:07:26 -04007246
James Ketrenos43f66a62005-03-25 12:31:53 -06007247 if (match.network == priv->assoc_network) {
7248 IPW_DEBUG_ASSOC("No better APs in this network to "
7249 "roam to.\n");
7250 priv->status &= ~STATUS_ROAMING;
7251 ipw_debug_config(priv);
7252 return;
7253 }
Jeff Garzikbf794512005-07-31 13:07:26 -04007254
James Ketrenos43f66a62005-03-25 12:31:53 -06007255 ipw_send_disassociate(priv, 1);
7256 priv->assoc_network = match.network;
7257
7258 return;
Jeff Garzikbf794512005-07-31 13:07:26 -04007259 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007260
7261 /* Second pass through ROAM process -- request association */
7262 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7263 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7264 priv->status &= ~STATUS_ROAMING;
7265}
7266
James Ketrenosc848d0a2005-08-24 21:56:24 -05007267static void ipw_bg_roam(void *data)
7268{
7269 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08007270 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05007271 ipw_roam(data);
Zhu Yi46441512006-01-24 16:37:59 +08007272 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05007273}
7274
7275static int ipw_associate(void *data)
James Ketrenos43f66a62005-03-25 12:31:53 -06007276{
7277 struct ipw_priv *priv = data;
7278
7279 struct ieee80211_network *network = NULL;
7280 struct ipw_network_match match = {
7281 .network = NULL
7282 };
7283 struct ipw_supported_rates *rates;
7284 struct list_head *element;
James Ketrenosa613bff2005-08-24 21:43:11 -05007285 unsigned long flags;
James Ketrenos43f66a62005-03-25 12:31:53 -06007286
James Ketrenosb095c382005-08-24 22:04:42 -05007287 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7288 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7289 return 0;
7290 }
7291
James Ketrenosc848d0a2005-08-24 21:56:24 -05007292 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05007293 IPW_DEBUG_ASSOC("Not attempting association (already in "
7294 "progress)\n");
James Ketrenosc848d0a2005-08-24 21:56:24 -05007295 return 0;
7296 }
7297
Hong Liue6324722005-09-14 21:04:15 -05007298 if (priv->status & STATUS_DISASSOCIATING) {
7299 IPW_DEBUG_ASSOC("Not attempting association (in "
7300 "disassociating)\n ");
7301 queue_work(priv->workqueue, &priv->associate);
7302 return 0;
7303 }
7304
James Ketrenosc848d0a2005-08-24 21:56:24 -05007305 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05007306 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7307 "initialized)\n");
James Ketrenosc848d0a2005-08-24 21:56:24 -05007308 return 0;
7309 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007310
7311 if (!(priv->config & CFG_ASSOCIATE) &&
7312 !(priv->config & (CFG_STATIC_ESSID |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007313 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
James Ketrenos43f66a62005-03-25 12:31:53 -06007314 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
James Ketrenosc848d0a2005-08-24 21:56:24 -05007315 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06007316 }
7317
James Ketrenosa613bff2005-08-24 21:43:11 -05007318 /* Protect our use of the network_list */
7319 spin_lock_irqsave(&priv->ieee->lock, flags);
Jeff Garzikbf794512005-07-31 13:07:26 -04007320 list_for_each_entry(network, &priv->ieee->network_list, list)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007321 ipw_best_network(priv, &match, network, 0);
James Ketrenos43f66a62005-03-25 12:31:53 -06007322
7323 network = match.network;
7324 rates = &match.rates;
7325
7326 if (network == NULL &&
7327 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7328 priv->config & CFG_ADHOC_CREATE &&
7329 priv->config & CFG_STATIC_ESSID &&
James Ketrenosa613bff2005-08-24 21:43:11 -05007330 priv->config & CFG_STATIC_CHANNEL &&
James Ketrenos43f66a62005-03-25 12:31:53 -06007331 !list_empty(&priv->ieee->network_free_list)) {
7332 element = priv->ieee->network_free_list.next;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007333 network = list_entry(element, struct ieee80211_network, list);
James Ketrenos43f66a62005-03-25 12:31:53 -06007334 ipw_adhoc_create(priv, network);
7335 rates = &priv->rates;
7336 list_del(element);
7337 list_add_tail(&network->list, &priv->ieee->network_list);
7338 }
James Ketrenosa613bff2005-08-24 21:43:11 -05007339 spin_unlock_irqrestore(&priv->ieee->lock, flags);
Jeff Garzikbf794512005-07-31 13:07:26 -04007340
James Ketrenos43f66a62005-03-25 12:31:53 -06007341 /* If we reached the end of the list, then we don't have any valid
7342 * matching APs */
7343 if (!network) {
7344 ipw_debug_config(priv);
7345
James Ketrenosb095c382005-08-24 22:04:42 -05007346 if (!(priv->status & STATUS_SCANNING)) {
7347 if (!(priv->config & CFG_SPEED_SCAN))
7348 queue_delayed_work(priv->workqueue,
7349 &priv->request_scan,
7350 SCAN_INTERVAL);
7351 else
7352 queue_work(priv->workqueue,
7353 &priv->request_scan);
7354 }
Jeff Garzikbf794512005-07-31 13:07:26 -04007355
James Ketrenosc848d0a2005-08-24 21:56:24 -05007356 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06007357 }
7358
7359 ipw_associate_network(priv, network, rates, 0);
James Ketrenosc848d0a2005-08-24 21:56:24 -05007360
7361 return 1;
James Ketrenos43f66a62005-03-25 12:31:53 -06007362}
Jeff Garzikbf794512005-07-31 13:07:26 -04007363
James Ketrenosc848d0a2005-08-24 21:56:24 -05007364static void ipw_bg_associate(void *data)
James Ketrenos43f66a62005-03-25 12:31:53 -06007365{
James Ketrenosc848d0a2005-08-24 21:56:24 -05007366 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +08007367 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05007368 ipw_associate(data);
Zhu Yi46441512006-01-24 16:37:59 +08007369 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06007370}
7371
James Ketrenosb095c382005-08-24 22:04:42 -05007372static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7373 struct sk_buff *skb)
7374{
7375 struct ieee80211_hdr *hdr;
7376 u16 fc;
7377
7378 hdr = (struct ieee80211_hdr *)skb->data;
7379 fc = le16_to_cpu(hdr->frame_ctl);
7380 if (!(fc & IEEE80211_FCTL_PROTECTED))
7381 return;
7382
7383 fc &= ~IEEE80211_FCTL_PROTECTED;
7384 hdr->frame_ctl = cpu_to_le16(fc);
7385 switch (priv->ieee->sec.level) {
7386 case SEC_LEVEL_3:
7387 /* Remove CCMP HDR */
7388 memmove(skb->data + IEEE80211_3ADDR_LEN,
7389 skb->data + IEEE80211_3ADDR_LEN + 8,
7390 skb->len - IEEE80211_3ADDR_LEN - 8);
Zhu Yif4ff4972005-09-12 10:48:48 -05007391 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
James Ketrenosb095c382005-08-24 22:04:42 -05007392 break;
7393 case SEC_LEVEL_2:
7394 break;
7395 case SEC_LEVEL_1:
7396 /* Remove IV */
7397 memmove(skb->data + IEEE80211_3ADDR_LEN,
7398 skb->data + IEEE80211_3ADDR_LEN + 4,
7399 skb->len - IEEE80211_3ADDR_LEN - 4);
Zhu Yif4ff4972005-09-12 10:48:48 -05007400 skb_trim(skb, skb->len - 8); /* IV + ICV */
James Ketrenosb095c382005-08-24 22:04:42 -05007401 break;
7402 case SEC_LEVEL_0:
7403 break;
7404 default:
7405 printk(KERN_ERR "Unknow security level %d\n",
7406 priv->ieee->sec.level);
7407 break;
7408 }
7409}
7410
7411static void ipw_handle_data_packet(struct ipw_priv *priv,
7412 struct ipw_rx_mem_buffer *rxb,
7413 struct ieee80211_rx_stats *stats)
James Ketrenos43f66a62005-03-25 12:31:53 -06007414{
Hong Liu567deaf2005-08-31 18:07:22 +08007415 struct ieee80211_hdr_4addr *hdr;
James Ketrenos43f66a62005-03-25 12:31:53 -06007416 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7417
7418 /* We received data from the HW, so stop the watchdog */
7419 priv->net_dev->trans_start = jiffies;
7420
Jeff Garzikbf794512005-07-31 13:07:26 -04007421 /* We only process data packets if the
James Ketrenos43f66a62005-03-25 12:31:53 -06007422 * interface is open */
James Ketrenosa613bff2005-08-24 21:43:11 -05007423 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
James Ketrenos43f66a62005-03-25 12:31:53 -06007424 skb_tailroom(rxb->skb))) {
7425 priv->ieee->stats.rx_errors++;
7426 priv->wstats.discard.misc++;
7427 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7428 return;
7429 } else if (unlikely(!netif_running(priv->net_dev))) {
7430 priv->ieee->stats.rx_dropped++;
7431 priv->wstats.discard.misc++;
7432 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7433 return;
7434 }
7435
7436 /* Advance skb->data to the start of the actual payload */
Jiri Bencaaa4d302005-06-07 14:58:41 +02007437 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
James Ketrenos43f66a62005-03-25 12:31:53 -06007438
7439 /* Set the size of the skb to the size of the frame */
James Ketrenosa613bff2005-08-24 21:43:11 -05007440 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
James Ketrenos43f66a62005-03-25 12:31:53 -06007441
7442 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7443
James Ketrenosb095c382005-08-24 22:04:42 -05007444 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
Hong Liu567deaf2005-08-31 18:07:22 +08007445 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7446 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
Stephen Hemminger3c190652006-01-03 15:27:38 -08007447 (is_multicast_ether_addr(hdr->addr1) ?
Hong Liu567deaf2005-08-31 18:07:22 +08007448 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
James Ketrenosb095c382005-08-24 22:04:42 -05007449 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7450
Jeff Garzikbf794512005-07-31 13:07:26 -04007451 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
James Ketrenos43f66a62005-03-25 12:31:53 -06007452 priv->ieee->stats.rx_errors++;
James Ketrenosa613bff2005-08-24 21:43:11 -05007453 else { /* ieee80211_rx succeeded, so it now owns the SKB */
James Ketrenos43f66a62005-03-25 12:31:53 -06007454 rxb->skb = NULL;
James Ketrenosb095c382005-08-24 22:04:42 -05007455 __ipw_led_activity_on(priv);
James Ketrenosa613bff2005-08-24 21:43:11 -05007456 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007457}
7458
Mike Kershaw24a47db2005-08-26 00:41:54 -05007459#ifdef CONFIG_IEEE80211_RADIOTAP
7460static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7461 struct ipw_rx_mem_buffer *rxb,
7462 struct ieee80211_rx_stats *stats)
7463{
7464 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7465 struct ipw_rx_frame *frame = &pkt->u.frame;
7466
7467 /* initial pull of some data */
7468 u16 received_channel = frame->received_channel;
7469 u8 antennaAndPhy = frame->antennaAndPhy;
7470 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7471 u16 pktrate = frame->rate;
7472
7473 /* Magic struct that slots into the radiotap header -- no reason
7474 * to build this manually element by element, we can write it much
7475 * more efficiently than we can parse it. ORDER MATTERS HERE */
7476 struct ipw_rt_hdr {
7477 struct ieee80211_radiotap_header rt_hdr;
7478 u8 rt_flags; /* radiotap packet flags */
7479 u8 rt_rate; /* rate in 500kb/s */
7480 u16 rt_channel; /* channel in mhz */
7481 u16 rt_chbitmask; /* channel bitfield */
7482 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7483 u8 rt_antenna; /* antenna number */
7484 } *ipw_rt;
7485
7486 short len = le16_to_cpu(pkt->u.frame.length);
7487
7488 /* We received data from the HW, so stop the watchdog */
7489 priv->net_dev->trans_start = jiffies;
7490
7491 /* We only process data packets if the
7492 * interface is open */
7493 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7494 skb_tailroom(rxb->skb))) {
7495 priv->ieee->stats.rx_errors++;
7496 priv->wstats.discard.misc++;
7497 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7498 return;
7499 } else if (unlikely(!netif_running(priv->net_dev))) {
7500 priv->ieee->stats.rx_dropped++;
7501 priv->wstats.discard.misc++;
7502 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7503 return;
7504 }
7505
7506 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7507 * that now */
7508 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7509 /* FIXME: Should alloc bigger skb instead */
7510 priv->ieee->stats.rx_dropped++;
7511 priv->wstats.discard.misc++;
7512 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7513 return;
7514 }
7515
7516 /* copy the frame itself */
7517 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7518 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7519
7520 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7521 * part of our real header, saves a little time.
7522 *
7523 * No longer necessary since we fill in all our data. Purge before merging
7524 * patch officially.
7525 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7526 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7527 */
7528
7529 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7530
7531 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7532 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7533 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7534
7535 /* Big bitfield of all the fields we provide in radiotap */
7536 ipw_rt->rt_hdr.it_present =
7537 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7538 (1 << IEEE80211_RADIOTAP_RATE) |
7539 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7540 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7541 (1 << IEEE80211_RADIOTAP_ANTENNA));
7542
7543 /* Zero the flags, we'll add to them as we go */
7544 ipw_rt->rt_flags = 0;
7545
7546 /* Convert signal to DBM */
7547 ipw_rt->rt_dbmsignal = antsignal;
7548
7549 /* Convert the channel data and set the flags */
7550 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7551 if (received_channel > 14) { /* 802.11a */
7552 ipw_rt->rt_chbitmask =
7553 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7554 } else if (antennaAndPhy & 32) { /* 802.11b */
7555 ipw_rt->rt_chbitmask =
7556 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7557 } else { /* 802.11g */
7558 ipw_rt->rt_chbitmask =
7559 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7560 }
7561
7562 /* set the rate in multiples of 500k/s */
7563 switch (pktrate) {
7564 case IPW_TX_RATE_1MB:
7565 ipw_rt->rt_rate = 2;
7566 break;
7567 case IPW_TX_RATE_2MB:
7568 ipw_rt->rt_rate = 4;
7569 break;
7570 case IPW_TX_RATE_5MB:
7571 ipw_rt->rt_rate = 10;
7572 break;
7573 case IPW_TX_RATE_6MB:
7574 ipw_rt->rt_rate = 12;
7575 break;
7576 case IPW_TX_RATE_9MB:
7577 ipw_rt->rt_rate = 18;
7578 break;
7579 case IPW_TX_RATE_11MB:
7580 ipw_rt->rt_rate = 22;
7581 break;
7582 case IPW_TX_RATE_12MB:
7583 ipw_rt->rt_rate = 24;
7584 break;
7585 case IPW_TX_RATE_18MB:
7586 ipw_rt->rt_rate = 36;
7587 break;
7588 case IPW_TX_RATE_24MB:
7589 ipw_rt->rt_rate = 48;
7590 break;
7591 case IPW_TX_RATE_36MB:
7592 ipw_rt->rt_rate = 72;
7593 break;
7594 case IPW_TX_RATE_48MB:
7595 ipw_rt->rt_rate = 96;
7596 break;
7597 case IPW_TX_RATE_54MB:
7598 ipw_rt->rt_rate = 108;
7599 break;
7600 default:
7601 ipw_rt->rt_rate = 0;
7602 break;
7603 }
7604
7605 /* antenna number */
7606 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7607
7608 /* set the preamble flag if we have it */
7609 if ((antennaAndPhy & 64))
7610 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7611
7612 /* Set the size of the skb to the size of the frame */
7613 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
James Ketrenos43f66a62005-03-25 12:31:53 -06007614
7615 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7616
7617 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7618 priv->ieee->stats.rx_errors++;
Mike Kershaw24a47db2005-08-26 00:41:54 -05007619 else { /* ieee80211_rx succeeded, so it now owns the SKB */
James Ketrenos43f66a62005-03-25 12:31:53 -06007620 rxb->skb = NULL;
Mike Kershaw24a47db2005-08-26 00:41:54 -05007621 /* no LED during capture */
7622 }
7623}
7624#endif
7625
Arjan van de Ven858119e2006-01-14 13:20:43 -08007626static int is_network_packet(struct ipw_priv *priv,
James Ketrenosea2b26e2005-08-24 21:25:16 -05007627 struct ieee80211_hdr_4addr *header)
7628{
7629 /* Filter incoming packets to determine if they are targetted toward
7630 * this network, discarding packets coming from ourselves */
7631 switch (priv->ieee->iw_mode) {
James Ketrenosa613bff2005-08-24 21:43:11 -05007632 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
James Ketrenosc848d0a2005-08-24 21:56:24 -05007633 /* packets from our adapter are dropped (echo) */
7634 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7635 return 0;
7636
Peter Jones90700fd2005-08-26 16:51:06 -05007637 /* {broad,multi}cast packets to our BSSID go through */
Stephen Hemminger3c190652006-01-03 15:27:38 -08007638 if (is_multicast_ether_addr(header->addr1))
James Ketrenosea2b26e2005-08-24 21:25:16 -05007639 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
James Ketrenosa613bff2005-08-24 21:43:11 -05007640
7641 /* packets to our adapter go through */
7642 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7643 ETH_ALEN);
James Ketrenosa613bff2005-08-24 21:43:11 -05007644
Peter Jones90700fd2005-08-26 16:51:06 -05007645 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
James Ketrenosc848d0a2005-08-24 21:56:24 -05007646 /* packets from our adapter are dropped (echo) */
7647 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7648 return 0;
7649
Peter Jones90700fd2005-08-26 16:51:06 -05007650 /* {broad,multi}cast packets to our BSS go through */
Stephen Hemminger3c190652006-01-03 15:27:38 -08007651 if (is_multicast_ether_addr(header->addr1))
James Ketrenosa613bff2005-08-24 21:43:11 -05007652 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7653
7654 /* packets to our adapter go through */
7655 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7656 ETH_ALEN);
James Ketrenosea2b26e2005-08-24 21:25:16 -05007657 }
James Ketrenosa613bff2005-08-24 21:43:11 -05007658
James Ketrenosea2b26e2005-08-24 21:25:16 -05007659 return 1;
7660}
7661
James Ketrenosafbf30a2005-08-25 00:05:33 -05007662#define IPW_PACKET_RETRY_TIME HZ
7663
Arjan van de Ven858119e2006-01-14 13:20:43 -08007664static int is_duplicate_packet(struct ipw_priv *priv,
James Ketrenosafbf30a2005-08-25 00:05:33 -05007665 struct ieee80211_hdr_4addr *header)
7666{
James Ketrenosafbf30a2005-08-25 00:05:33 -05007667 u16 sc = le16_to_cpu(header->seq_ctl);
7668 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7669 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7670 u16 *last_seq, *last_frag;
7671 unsigned long *last_time;
7672
7673 switch (priv->ieee->iw_mode) {
7674 case IW_MODE_ADHOC:
7675 {
7676 struct list_head *p;
7677 struct ipw_ibss_seq *entry = NULL;
7678 u8 *mac = header->addr2;
7679 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7680
7681 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7682 entry =
7683 list_entry(p, struct ipw_ibss_seq, list);
7684 if (!memcmp(entry->mac, mac, ETH_ALEN))
7685 break;
7686 }
7687 if (p == &priv->ibss_mac_hash[index]) {
7688 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7689 if (!entry) {
7690 IPW_ERROR
7691 ("Cannot malloc new mac entry\n");
7692 return 0;
7693 }
7694 memcpy(entry->mac, mac, ETH_ALEN);
7695 entry->seq_num = seq;
7696 entry->frag_num = frag;
7697 entry->packet_time = jiffies;
7698 list_add(&entry->list,
7699 &priv->ibss_mac_hash[index]);
7700 return 0;
7701 }
7702 last_seq = &entry->seq_num;
7703 last_frag = &entry->frag_num;
7704 last_time = &entry->packet_time;
7705 break;
7706 }
7707 case IW_MODE_INFRA:
7708 last_seq = &priv->last_seq_num;
7709 last_frag = &priv->last_frag_num;
7710 last_time = &priv->last_packet_time;
7711 break;
7712 default:
7713 return 0;
7714 }
7715 if ((*last_seq == seq) &&
7716 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7717 if (*last_frag == frag)
7718 goto drop;
7719 if (*last_frag + 1 != frag)
7720 /* out-of-order fragment */
7721 goto drop;
James Ketrenosafbf30a2005-08-25 00:05:33 -05007722 } else
7723 *last_seq = seq;
7724
Zhu Yif57ce7c2005-07-13 12:22:15 -05007725 *last_frag = frag;
James Ketrenosafbf30a2005-08-25 00:05:33 -05007726 *last_time = jiffies;
7727 return 0;
7728
7729 drop:
Zhu Yi87b016c2005-08-05 17:17:35 +08007730 /* Comment this line now since we observed the card receives
7731 * duplicate packets but the FCTL_RETRY bit is not set in the
7732 * IBSS mode with fragmentation enabled.
7733 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
James Ketrenosafbf30a2005-08-25 00:05:33 -05007734 return 1;
7735}
7736
James Ketrenosb095c382005-08-24 22:04:42 -05007737static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7738 struct ipw_rx_mem_buffer *rxb,
7739 struct ieee80211_rx_stats *stats)
7740{
7741 struct sk_buff *skb = rxb->skb;
7742 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7743 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7744 (skb->data + IPW_RX_FRAME_SIZE);
7745
7746 ieee80211_rx_mgt(priv->ieee, header, stats);
7747
7748 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7749 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7750 IEEE80211_STYPE_PROBE_RESP) ||
7751 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7752 IEEE80211_STYPE_BEACON))) {
7753 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7754 ipw_add_station(priv, header->addr2);
7755 }
7756
7757 if (priv->config & CFG_NET_STATS) {
7758 IPW_DEBUG_HC("sending stat packet\n");
7759
7760 /* Set the size of the skb to the size of the full
7761 * ipw header and 802.11 frame */
7762 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7763 IPW_RX_FRAME_SIZE);
7764
7765 /* Advance past the ipw packet header to the 802.11 frame */
7766 skb_pull(skb, IPW_RX_FRAME_SIZE);
7767
7768 /* Push the ieee80211_rx_stats before the 802.11 frame */
7769 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7770
7771 skb->dev = priv->ieee->dev;
7772
7773 /* Point raw at the ieee80211_stats */
7774 skb->mac.raw = skb->data;
7775
7776 skb->pkt_type = PACKET_OTHERHOST;
7777 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7778 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7779 netif_rx(skb);
7780 rxb->skb = NULL;
7781 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007782}
7783
James Ketrenos43f66a62005-03-25 12:31:53 -06007784/*
7785 * Main entry function for recieving a packet with 80211 headers. This
7786 * should be called when ever the FW has notified us that there is a new
7787 * skb in the recieve queue.
7788 */
7789static void ipw_rx(struct ipw_priv *priv)
7790{
7791 struct ipw_rx_mem_buffer *rxb;
7792 struct ipw_rx_packet *pkt;
James Ketrenos0dacca12005-09-21 12:23:41 -05007793 struct ieee80211_hdr_4addr *header;
James Ketrenos43f66a62005-03-25 12:31:53 -06007794 u32 r, w, i;
7795 u8 network_packet;
7796
James Ketrenosb095c382005-08-24 22:04:42 -05007797 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7798 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
James Ketrenos43f66a62005-03-25 12:31:53 -06007799 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7800
7801 while (i != r) {
7802 rxb = priv->rxq->queue[i];
James Ketrenos43f66a62005-03-25 12:31:53 -06007803 if (unlikely(rxb == NULL)) {
7804 printk(KERN_CRIT "Queue not allocated!\n");
7805 break;
7806 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007807 priv->rxq->queue[i] = NULL;
7808
7809 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
James Ketrenosb095c382005-08-24 22:04:42 -05007810 IPW_RX_BUF_SIZE,
James Ketrenos43f66a62005-03-25 12:31:53 -06007811 PCI_DMA_FROMDEVICE);
7812
7813 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7814 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7815 pkt->header.message_type,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007816 pkt->header.rx_seq_num, pkt->header.control_bits);
James Ketrenos43f66a62005-03-25 12:31:53 -06007817
7818 switch (pkt->header.message_type) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007819 case RX_FRAME_TYPE: /* 802.11 frame */ {
7820 struct ieee80211_rx_stats stats = {
James Ketrenosc848d0a2005-08-24 21:56:24 -05007821 .rssi =
7822 le16_to_cpu(pkt->u.frame.rssi_dbm) -
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007823 IPW_RSSI_TO_DBM,
James Ketrenosc848d0a2005-08-24 21:56:24 -05007824 .signal =
Bill Mossb1916082006-02-15 08:50:18 +08007825 le16_to_cpu(pkt->u.frame.rssi_dbm) -
7826 IPW_RSSI_TO_DBM + 0x100,
James Ketrenosc848d0a2005-08-24 21:56:24 -05007827 .noise =
7828 le16_to_cpu(pkt->u.frame.noise),
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007829 .rate = pkt->u.frame.rate,
7830 .mac_time = jiffies,
7831 .received_channel =
7832 pkt->u.frame.received_channel,
7833 .freq =
7834 (pkt->u.frame.
7835 control & (1 << 0)) ?
7836 IEEE80211_24GHZ_BAND :
7837 IEEE80211_52GHZ_BAND,
James Ketrenosa613bff2005-08-24 21:43:11 -05007838 .len = le16_to_cpu(pkt->u.frame.length),
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007839 };
James Ketrenos43f66a62005-03-25 12:31:53 -06007840
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007841 if (stats.rssi != 0)
7842 stats.mask |= IEEE80211_STATMASK_RSSI;
7843 if (stats.signal != 0)
7844 stats.mask |= IEEE80211_STATMASK_SIGNAL;
James Ketrenosc848d0a2005-08-24 21:56:24 -05007845 if (stats.noise != 0)
7846 stats.mask |= IEEE80211_STATMASK_NOISE;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007847 if (stats.rate != 0)
7848 stats.mask |= IEEE80211_STATMASK_RATE;
James Ketrenos43f66a62005-03-25 12:31:53 -06007849
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007850 priv->rx_packets++;
James Ketrenos43f66a62005-03-25 12:31:53 -06007851
James Ketrenosb095c382005-08-24 22:04:42 -05007852#ifdef CONFIG_IPW2200_MONITOR
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007853 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
Mike Kershaw24a47db2005-08-26 00:41:54 -05007854#ifdef CONFIG_IEEE80211_RADIOTAP
7855 ipw_handle_data_packet_monitor(priv,
7856 rxb,
7857 &stats);
7858#else
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007859 ipw_handle_data_packet(priv, rxb,
7860 &stats);
Mike Kershaw24a47db2005-08-26 00:41:54 -05007861#endif
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007862 break;
7863 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007864#endif
Jeff Garzikbf794512005-07-31 13:07:26 -04007865
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007866 header =
James Ketrenos0dacca12005-09-21 12:23:41 -05007867 (struct ieee80211_hdr_4addr *)(rxb->skb->
7868 data +
7869 IPW_RX_FRAME_SIZE);
James Ketrenos43f66a62005-03-25 12:31:53 -06007870 /* TODO: Check Ad-Hoc dest/source and make sure
7871 * that we are actually parsing these packets
Jeff Garzikbf794512005-07-31 13:07:26 -04007872 * correctly -- we should probably use the
James Ketrenos43f66a62005-03-25 12:31:53 -06007873 * frame control of the packet and disregard
7874 * the current iw_mode */
James Ketrenos43f66a62005-03-25 12:31:53 -06007875
James Ketrenosea2b26e2005-08-24 21:25:16 -05007876 network_packet =
7877 is_network_packet(priv, header);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007878 if (network_packet && priv->assoc_network) {
7879 priv->assoc_network->stats.rssi =
7880 stats.rssi;
7881 average_add(&priv->average_rssi,
7882 stats.rssi);
7883 priv->last_rx_rssi = stats.rssi;
7884 }
7885
7886 IPW_DEBUG_RX("Frame: len=%u\n",
James Ketrenosa613bff2005-08-24 21:43:11 -05007887 le16_to_cpu(pkt->u.frame.length));
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007888
James Ketrenosa613bff2005-08-24 21:43:11 -05007889 if (le16_to_cpu(pkt->u.frame.length) <
Zhu Yi9d0be032006-02-15 06:18:19 +08007890 ieee80211_get_hdrlen(le16_to_cpu(
7891 header->frame_ctl))) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007892 IPW_DEBUG_DROP
7893 ("Received packet is too small. "
7894 "Dropping.\n");
7895 priv->ieee->stats.rx_errors++;
7896 priv->wstats.discard.misc++;
7897 break;
7898 }
7899
James Ketrenosa613bff2005-08-24 21:43:11 -05007900 switch (WLAN_FC_GET_TYPE
7901 (le16_to_cpu(header->frame_ctl))) {
James Ketrenosb095c382005-08-24 22:04:42 -05007902
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007903 case IEEE80211_FTYPE_MGMT:
James Ketrenosb095c382005-08-24 22:04:42 -05007904 ipw_handle_mgmt_packet(priv, rxb,
7905 &stats);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007906 break;
7907
7908 case IEEE80211_FTYPE_CTL:
7909 break;
7910
7911 case IEEE80211_FTYPE_DATA:
James Ketrenosafbf30a2005-08-25 00:05:33 -05007912 if (unlikely(!network_packet ||
7913 is_duplicate_packet(priv,
7914 header)))
7915 {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007916 IPW_DEBUG_DROP("Dropping: "
7917 MAC_FMT ", "
7918 MAC_FMT ", "
7919 MAC_FMT "\n",
7920 MAC_ARG(header->
7921 addr1),
7922 MAC_ARG(header->
7923 addr2),
7924 MAC_ARG(header->
7925 addr3));
James Ketrenosb095c382005-08-24 22:04:42 -05007926 break;
7927 }
7928
7929 ipw_handle_data_packet(priv, rxb,
7930 &stats);
7931
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007932 break;
7933 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007934 break;
7935 }
Jeff Garzikbf794512005-07-31 13:07:26 -04007936
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007937 case RX_HOST_NOTIFICATION_TYPE:{
7938 IPW_DEBUG_RX
7939 ("Notification: subtype=%02X flags=%02X size=%d\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06007940 pkt->u.notification.subtype,
7941 pkt->u.notification.flags,
7942 pkt->u.notification.size);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04007943 ipw_rx_notification(priv, &pkt->u.notification);
7944 break;
7945 }
James Ketrenos43f66a62005-03-25 12:31:53 -06007946
7947 default:
7948 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7949 pkt->header.message_type);
7950 break;
7951 }
Jeff Garzikbf794512005-07-31 13:07:26 -04007952
7953 /* For now we just don't re-use anything. We can tweak this
7954 * later to try and re-use notification packets and SKBs that
James Ketrenos43f66a62005-03-25 12:31:53 -06007955 * fail to Rx correctly */
7956 if (rxb->skb != NULL) {
7957 dev_kfree_skb_any(rxb->skb);
7958 rxb->skb = NULL;
7959 }
Jeff Garzikbf794512005-07-31 13:07:26 -04007960
James Ketrenos43f66a62005-03-25 12:31:53 -06007961 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
James Ketrenosb095c382005-08-24 22:04:42 -05007962 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
James Ketrenos43f66a62005-03-25 12:31:53 -06007963 list_add_tail(&rxb->list, &priv->rxq->rx_used);
Jeff Garzikbf794512005-07-31 13:07:26 -04007964
James Ketrenos43f66a62005-03-25 12:31:53 -06007965 i = (i + 1) % RX_QUEUE_SIZE;
7966 }
7967
7968 /* Backtrack one entry */
7969 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7970
7971 ipw_rx_queue_restock(priv);
7972}
7973
James Ketrenosafbf30a2005-08-25 00:05:33 -05007974#define DEFAULT_RTS_THRESHOLD 2304U
7975#define MIN_RTS_THRESHOLD 1U
7976#define MAX_RTS_THRESHOLD 2304U
7977#define DEFAULT_BEACON_INTERVAL 100U
7978#define DEFAULT_SHORT_RETRY_LIMIT 7U
7979#define DEFAULT_LONG_RETRY_LIMIT 4U
7980
Zhu Yid6d5b5c2006-02-16 16:21:09 +08007981/**
7982 * ipw_sw_reset
7983 * @option: options to control different reset behaviour
7984 * 0 = reset everything except the 'disable' module_param
7985 * 1 = reset everything and print out driver info (for probe only)
7986 * 2 = reset everything
7987 */
7988static int ipw_sw_reset(struct ipw_priv *priv, int option)
James Ketrenos43f66a62005-03-25 12:31:53 -06007989{
James Ketrenosafbf30a2005-08-25 00:05:33 -05007990 int band, modulation;
7991 int old_mode = priv->ieee->iw_mode;
James Ketrenos43f66a62005-03-25 12:31:53 -06007992
James Ketrenosafbf30a2005-08-25 00:05:33 -05007993 /* Initialize module parameter values here */
7994 priv->config = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06007995
James Ketrenosafbf30a2005-08-25 00:05:33 -05007996 /* We default to disabling the LED code as right now it causes
7997 * too many systems to lock up... */
7998 if (!led)
7999 priv->config |= CFG_NO_LED;
James Ketrenos43f66a62005-03-25 12:31:53 -06008000
James Ketrenosafbf30a2005-08-25 00:05:33 -05008001 if (associate)
8002 priv->config |= CFG_ASSOCIATE;
8003 else
8004 IPW_DEBUG_INFO("Auto associate disabled.\n");
Jeff Garzikbf794512005-07-31 13:07:26 -04008005
James Ketrenosafbf30a2005-08-25 00:05:33 -05008006 if (auto_create)
8007 priv->config |= CFG_ADHOC_CREATE;
8008 else
8009 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8010
Zhu Yi17ed0812006-01-24 16:36:31 +08008011 priv->config &= ~CFG_STATIC_ESSID;
8012 priv->essid_len = 0;
8013 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8014
Zhu Yid6d5b5c2006-02-16 16:21:09 +08008015 if (disable && option) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05008016 priv->status |= STATUS_RF_KILL_SW;
8017 IPW_DEBUG_INFO("Radio disabled.\n");
James Ketrenos43f66a62005-03-25 12:31:53 -06008018 }
8019
James Ketrenosafbf30a2005-08-25 00:05:33 -05008020 if (channel != 0) {
8021 priv->config |= CFG_STATIC_CHANNEL;
8022 priv->channel = channel;
8023 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8024 /* TODO: Validate that provided channel is in range */
8025 }
8026#ifdef CONFIG_IPW_QOS
8027 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8028 burst_duration_CCK, burst_duration_OFDM);
8029#endif /* CONFIG_IPW_QOS */
8030
8031 switch (mode) {
8032 case 1:
8033 priv->ieee->iw_mode = IW_MODE_ADHOC;
8034 priv->net_dev->type = ARPHRD_ETHER;
8035
8036 break;
8037#ifdef CONFIG_IPW2200_MONITOR
8038 case 2:
8039 priv->ieee->iw_mode = IW_MODE_MONITOR;
Mike Kershaw24a47db2005-08-26 00:41:54 -05008040#ifdef CONFIG_IEEE80211_RADIOTAP
8041 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8042#else
James Ketrenosafbf30a2005-08-25 00:05:33 -05008043 priv->net_dev->type = ARPHRD_IEEE80211;
Mike Kershaw24a47db2005-08-26 00:41:54 -05008044#endif
James Ketrenosafbf30a2005-08-25 00:05:33 -05008045 break;
8046#endif
8047 default:
8048 case 0:
8049 priv->net_dev->type = ARPHRD_ETHER;
8050 priv->ieee->iw_mode = IW_MODE_INFRA;
8051 break;
James Ketrenos43f66a62005-03-25 12:31:53 -06008052 }
Jeff Garzikbf794512005-07-31 13:07:26 -04008053
James Ketrenosafbf30a2005-08-25 00:05:33 -05008054 if (hwcrypto) {
8055 priv->ieee->host_encrypt = 0;
8056 priv->ieee->host_encrypt_msdu = 0;
8057 priv->ieee->host_decrypt = 0;
Hong Liu567deaf2005-08-31 18:07:22 +08008058 priv->ieee->host_mc_decrypt = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06008059 }
James Ketrenosafbf30a2005-08-25 00:05:33 -05008060 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
James Ketrenos43f66a62005-03-25 12:31:53 -06008061
Zhu Yie402c932005-08-05 17:20:40 +08008062 /* IPW2200/2915 is abled to do hardware fragmentation. */
8063 priv->ieee->host_open_frag = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06008064
James Ketrenosafbf30a2005-08-25 00:05:33 -05008065 if ((priv->pci_dev->device == 0x4223) ||
8066 (priv->pci_dev->device == 0x4224)) {
Zhu Yid6d5b5c2006-02-16 16:21:09 +08008067 if (option == 2)
James Ketrenosafbf30a2005-08-25 00:05:33 -05008068 printk(KERN_INFO DRV_NAME
8069 ": Detected Intel PRO/Wireless 2915ABG Network "
8070 "Connection\n");
8071 priv->ieee->abg_true = 1;
8072 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8073 modulation = IEEE80211_OFDM_MODULATION |
8074 IEEE80211_CCK_MODULATION;
8075 priv->adapter = IPW_2915ABG;
8076 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
James Ketrenos43f66a62005-03-25 12:31:53 -06008077 } else {
Zhu Yid6d5b5c2006-02-16 16:21:09 +08008078 if (option == 2)
James Ketrenosafbf30a2005-08-25 00:05:33 -05008079 printk(KERN_INFO DRV_NAME
8080 ": Detected Intel PRO/Wireless 2200BG Network "
8081 "Connection\n");
8082
8083 priv->ieee->abg_true = 0;
8084 band = IEEE80211_24GHZ_BAND;
8085 modulation = IEEE80211_OFDM_MODULATION |
8086 IEEE80211_CCK_MODULATION;
8087 priv->adapter = IPW_2200BG;
8088 priv->ieee->mode = IEEE_G | IEEE_B;
James Ketrenos43f66a62005-03-25 12:31:53 -06008089 }
Jeff Garzikbf794512005-07-31 13:07:26 -04008090
James Ketrenosafbf30a2005-08-25 00:05:33 -05008091 priv->ieee->freq_band = band;
8092 priv->ieee->modulation = modulation;
Jeff Garzikbf794512005-07-31 13:07:26 -04008093
James Ketrenosafbf30a2005-08-25 00:05:33 -05008094 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
James Ketrenos43f66a62005-03-25 12:31:53 -06008095
James Ketrenosafbf30a2005-08-25 00:05:33 -05008096 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8097 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
James Ketrenos43f66a62005-03-25 12:31:53 -06008098
James Ketrenosafbf30a2005-08-25 00:05:33 -05008099 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8100 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8101 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
Jeff Garzikbf794512005-07-31 13:07:26 -04008102
James Ketrenosafbf30a2005-08-25 00:05:33 -05008103 /* If power management is turned on, default to AC mode */
8104 priv->power_mode = IPW_POWER_AC;
8105 priv->tx_power = IPW_TX_POWER_DEFAULT;
James Ketrenos43f66a62005-03-25 12:31:53 -06008106
Zhu Yi0ece35b2005-08-05 17:26:51 +08008107 return old_mode == priv->ieee->iw_mode;
James Ketrenos43f66a62005-03-25 12:31:53 -06008108}
8109
8110/*
8111 * This file defines the Wireless Extension handlers. It does not
8112 * define any methods of hardware manipulation and relies on the
8113 * functions defined in ipw_main to provide the HW interaction.
Jeff Garzikbf794512005-07-31 13:07:26 -04008114 *
8115 * The exception to this is the use of the ipw_get_ordinal()
James Ketrenos43f66a62005-03-25 12:31:53 -06008116 * function used to poll the hardware vs. making unecessary calls.
8117 *
8118 */
8119
Jeff Garzikbf794512005-07-31 13:07:26 -04008120static int ipw_wx_get_name(struct net_device *dev,
8121 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008122 union iwreq_data *wrqu, char *extra)
8123{
8124 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08008125 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05008126 if (priv->status & STATUS_RF_KILL_MASK)
James Ketrenosa613bff2005-08-24 21:43:11 -05008127 strcpy(wrqu->name, "radio off");
James Ketrenosc848d0a2005-08-24 21:56:24 -05008128 else if (!(priv->status & STATUS_ASSOCIATED))
James Ketrenos43f66a62005-03-25 12:31:53 -06008129 strcpy(wrqu->name, "unassociated");
Jeff Garzikbf794512005-07-31 13:07:26 -04008130 else
James Ketrenos43f66a62005-03-25 12:31:53 -06008131 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8132 ipw_modes[priv->assoc_request.ieee_mode]);
8133 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
Zhu Yi46441512006-01-24 16:37:59 +08008134 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008135 return 0;
8136}
8137
8138static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8139{
8140 if (channel == 0) {
8141 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8142 priv->config &= ~CFG_STATIC_CHANNEL;
James Ketrenosc848d0a2005-08-24 21:56:24 -05008143 IPW_DEBUG_ASSOC("Attempting to associate with new "
8144 "parameters.\n");
8145 ipw_associate(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -06008146 return 0;
8147 }
8148
8149 priv->config |= CFG_STATIC_CHANNEL;
8150
8151 if (priv->channel == channel) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008152 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8153 channel);
James Ketrenos43f66a62005-03-25 12:31:53 -06008154 return 0;
8155 }
8156
8157 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8158 priv->channel = channel;
8159
James Ketrenosb095c382005-08-24 22:04:42 -05008160#ifdef CONFIG_IPW2200_MONITOR
8161 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05008162 int i;
James Ketrenosb095c382005-08-24 22:04:42 -05008163 if (priv->status & STATUS_SCANNING) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05008164 IPW_DEBUG_SCAN("Scan abort triggered due to "
James Ketrenosb095c382005-08-24 22:04:42 -05008165 "channel change.\n");
James Ketrenosafbf30a2005-08-25 00:05:33 -05008166 ipw_abort_scan(priv);
James Ketrenosb095c382005-08-24 22:04:42 -05008167 }
8168
8169 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8170 udelay(10);
8171
8172 if (priv->status & STATUS_SCANNING)
8173 IPW_DEBUG_SCAN("Still scanning...\n");
8174 else
8175 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8176 1000 - i);
8177
8178 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06008179 }
James Ketrenosb095c382005-08-24 22:04:42 -05008180#endif /* CONFIG_IPW2200_MONITOR */
8181
James Ketrenosc848d0a2005-08-24 21:56:24 -05008182 /* Network configuration changed -- force [re]association */
8183 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8184 if (!ipw_disassociate(priv))
James Ketrenos43f66a62005-03-25 12:31:53 -06008185 ipw_associate(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -06008186
8187 return 0;
8188}
8189
Jeff Garzikbf794512005-07-31 13:07:26 -04008190static int ipw_wx_set_freq(struct net_device *dev,
8191 struct iw_request_info *info,
8192 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06008193{
8194 struct ipw_priv *priv = ieee80211_priv(dev);
Larry Finger1867b112006-02-28 09:48:28 -06008195 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
James Ketrenos43f66a62005-03-25 12:31:53 -06008196 struct iw_freq *fwrq = &wrqu->freq;
James Ketrenosafbf30a2005-08-25 00:05:33 -05008197 int ret = 0, i;
Liu Hong1fe0adb2005-08-19 09:33:10 -05008198 u8 channel, flags;
8199 int band;
Jeff Garzikbf794512005-07-31 13:07:26 -04008200
James Ketrenosb095c382005-08-24 22:04:42 -05008201 if (fwrq->m == 0) {
8202 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
Zhu Yi46441512006-01-24 16:37:59 +08008203 mutex_lock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05008204 ret = ipw_set_channel(priv, 0);
Zhu Yi46441512006-01-24 16:37:59 +08008205 mutex_unlock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05008206 return ret;
8207 }
James Ketrenos43f66a62005-03-25 12:31:53 -06008208 /* if setting by freq convert to channel */
8209 if (fwrq->e == 1) {
Larry Finger1867b112006-02-28 09:48:28 -06008210 channel = ieee80211_freq_to_channel(priv->ieee, fwrq->m);
James Ketrenosb095c382005-08-24 22:04:42 -05008211 if (channel == 0)
8212 return -EINVAL;
8213 } else
8214 channel = fwrq->m;
Jeff Garzikbf794512005-07-31 13:07:26 -04008215
Larry Finger1867b112006-02-28 09:48:28 -06008216 if (!(band = ieee80211_is_valid_channel(priv->ieee, channel)))
James Ketrenosb095c382005-08-24 22:04:42 -05008217 return -EINVAL;
Jeff Garzikbf794512005-07-31 13:07:26 -04008218
Liu Hong1fe0adb2005-08-19 09:33:10 -05008219 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
Larry Finger1867b112006-02-28 09:48:28 -06008220 i = ieee80211_channel_to_index(priv->ieee, channel);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008221 if (i == -1)
8222 return -EINVAL;
Liu Hong1fe0adb2005-08-19 09:33:10 -05008223
8224 flags = (band == IEEE80211_24GHZ_BAND) ?
8225 geo->bg[i].flags : geo->a[i].flags;
8226 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
James Ketrenosafbf30a2005-08-25 00:05:33 -05008227 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8228 return -EINVAL;
James Ketrenos43f66a62005-03-25 12:31:53 -06008229 }
8230 }
Jeff Garzikbf794512005-07-31 13:07:26 -04008231
James Ketrenos43f66a62005-03-25 12:31:53 -06008232 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
Zhu Yi46441512006-01-24 16:37:59 +08008233 mutex_lock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05008234 ret = ipw_set_channel(priv, channel);
Zhu Yi46441512006-01-24 16:37:59 +08008235 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05008236 return ret;
James Ketrenos43f66a62005-03-25 12:31:53 -06008237}
8238
Jeff Garzikbf794512005-07-31 13:07:26 -04008239static int ipw_wx_get_freq(struct net_device *dev,
8240 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008241 union iwreq_data *wrqu, char *extra)
8242{
8243 struct ipw_priv *priv = ieee80211_priv(dev);
8244
8245 wrqu->freq.e = 0;
8246
8247 /* If we are associated, trying to associate, or have a statically
8248 * configured CHANNEL then return that; otherwise return ANY */
Zhu Yi46441512006-01-24 16:37:59 +08008249 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008250 if (priv->config & CFG_STATIC_CHANNEL ||
8251 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8252 wrqu->freq.m = priv->channel;
Jeff Garzikbf794512005-07-31 13:07:26 -04008253 else
James Ketrenos43f66a62005-03-25 12:31:53 -06008254 wrqu->freq.m = 0;
8255
Zhu Yi46441512006-01-24 16:37:59 +08008256 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008257 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8258 return 0;
8259}
8260
Jeff Garzikbf794512005-07-31 13:07:26 -04008261static int ipw_wx_set_mode(struct net_device *dev,
8262 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008263 union iwreq_data *wrqu, char *extra)
8264{
8265 struct ipw_priv *priv = ieee80211_priv(dev);
8266 int err = 0;
8267
8268 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8269
James Ketrenos43f66a62005-03-25 12:31:53 -06008270 switch (wrqu->mode) {
James Ketrenosb095c382005-08-24 22:04:42 -05008271#ifdef CONFIG_IPW2200_MONITOR
James Ketrenos43f66a62005-03-25 12:31:53 -06008272 case IW_MODE_MONITOR:
8273#endif
8274 case IW_MODE_ADHOC:
8275 case IW_MODE_INFRA:
8276 break;
8277 case IW_MODE_AUTO:
8278 wrqu->mode = IW_MODE_INFRA;
8279 break;
8280 default:
8281 return -EINVAL;
8282 }
James Ketrenosb095c382005-08-24 22:04:42 -05008283 if (wrqu->mode == priv->ieee->iw_mode)
8284 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06008285
Zhu Yi46441512006-01-24 16:37:59 +08008286 mutex_lock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008287
8288 ipw_sw_reset(priv, 0);
8289
James Ketrenosb095c382005-08-24 22:04:42 -05008290#ifdef CONFIG_IPW2200_MONITOR
Jeff Garzikbf794512005-07-31 13:07:26 -04008291 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
James Ketrenos43f66a62005-03-25 12:31:53 -06008292 priv->net_dev->type = ARPHRD_ETHER;
Jeff Garzikbf794512005-07-31 13:07:26 -04008293
8294 if (wrqu->mode == IW_MODE_MONITOR)
Mike Kershaw24a47db2005-08-26 00:41:54 -05008295#ifdef CONFIG_IEEE80211_RADIOTAP
8296 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8297#else
James Ketrenos43f66a62005-03-25 12:31:53 -06008298 priv->net_dev->type = ARPHRD_IEEE80211;
Mike Kershaw24a47db2005-08-26 00:41:54 -05008299#endif
James Ketrenosb095c382005-08-24 22:04:42 -05008300#endif /* CONFIG_IPW2200_MONITOR */
Jeff Garzikbf794512005-07-31 13:07:26 -04008301
Jeff Garzikbf794512005-07-31 13:07:26 -04008302 /* Free the existing firmware and reset the fw_loaded
James Ketrenos43f66a62005-03-25 12:31:53 -06008303 * flag so ipw_load() will bring in the new firmawre */
James Ketrenosafbf30a2005-08-25 00:05:33 -05008304 free_firmware();
James Ketrenos43f66a62005-03-25 12:31:53 -06008305
8306 priv->ieee->iw_mode = wrqu->mode;
Jeff Garzikbf794512005-07-31 13:07:26 -04008307
James Ketrenosc848d0a2005-08-24 21:56:24 -05008308 queue_work(priv->workqueue, &priv->adapter_restart);
Zhu Yi46441512006-01-24 16:37:59 +08008309 mutex_unlock(&priv->mutex);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008310 return err;
James Ketrenos43f66a62005-03-25 12:31:53 -06008311}
8312
Jeff Garzikbf794512005-07-31 13:07:26 -04008313static int ipw_wx_get_mode(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008314 struct iw_request_info *info,
8315 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06008316{
8317 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08008318 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008319 wrqu->mode = priv->ieee->iw_mode;
8320 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
Zhu Yi46441512006-01-24 16:37:59 +08008321 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008322 return 0;
8323}
8324
James Ketrenos43f66a62005-03-25 12:31:53 -06008325/* Values are in microsecond */
8326static const s32 timeout_duration[] = {
8327 350000,
8328 250000,
8329 75000,
8330 37000,
8331 25000,
8332};
8333
8334static const s32 period_duration[] = {
8335 400000,
8336 700000,
8337 1000000,
8338 1000000,
8339 1000000
8340};
8341
Jeff Garzikbf794512005-07-31 13:07:26 -04008342static int ipw_wx_get_range(struct net_device *dev,
8343 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008344 union iwreq_data *wrqu, char *extra)
8345{
8346 struct ipw_priv *priv = ieee80211_priv(dev);
8347 struct iw_range *range = (struct iw_range *)extra;
Larry Finger1867b112006-02-28 09:48:28 -06008348 const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
James Ketrenosb095c382005-08-24 22:04:42 -05008349 int i = 0, j;
James Ketrenos43f66a62005-03-25 12:31:53 -06008350
8351 wrqu->data.length = sizeof(*range);
8352 memset(range, 0, sizeof(*range));
8353
8354 /* 54Mbs == ~27 Mb/s real (802.11g) */
Jeff Garzikbf794512005-07-31 13:07:26 -04008355 range->throughput = 27 * 1000 * 1000;
James Ketrenos43f66a62005-03-25 12:31:53 -06008356
8357 range->max_qual.qual = 100;
8358 /* TODO: Find real max RSSI and stick here */
8359 range->max_qual.level = 0;
Bill Mossb1916082006-02-15 08:50:18 +08008360 range->max_qual.noise = 0;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008361 range->max_qual.updated = 7; /* Updated all three */
James Ketrenos43f66a62005-03-25 12:31:53 -06008362
8363 range->avg_qual.qual = 70;
8364 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008365 range->avg_qual.level = 0; /* FIXME to real average level */
James Ketrenos43f66a62005-03-25 12:31:53 -06008366 range->avg_qual.noise = 0;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008367 range->avg_qual.updated = 7; /* Updated all three */
Zhu Yi46441512006-01-24 16:37:59 +08008368 mutex_lock(&priv->mutex);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008369 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
James Ketrenos43f66a62005-03-25 12:31:53 -06008370
Jeff Garzikbf794512005-07-31 13:07:26 -04008371 for (i = 0; i < range->num_bitrates; i++)
8372 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008373 500000;
Jeff Garzikbf794512005-07-31 13:07:26 -04008374
James Ketrenos43f66a62005-03-25 12:31:53 -06008375 range->max_rts = DEFAULT_RTS_THRESHOLD;
8376 range->min_frag = MIN_FRAG_THRESHOLD;
8377 range->max_frag = MAX_FRAG_THRESHOLD;
8378
8379 range->encoding_size[0] = 5;
Jeff Garzikbf794512005-07-31 13:07:26 -04008380 range->encoding_size[1] = 13;
James Ketrenos43f66a62005-03-25 12:31:53 -06008381 range->num_encoding_sizes = 2;
8382 range->max_encoding_tokens = WEP_KEYS;
8383
8384 /* Set the Wireless Extension versions */
8385 range->we_version_compiled = WIRELESS_EXT;
Dan Williamsf1b50862006-01-30 13:58:56 -05008386 range->we_version_source = 18;
James Ketrenos43f66a62005-03-25 12:31:53 -06008387
James Ketrenosb095c382005-08-24 22:04:42 -05008388 i = 0;
8389 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8390 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8391 i++, j++) {
8392 range->freq[i].i = geo->bg[j].channel;
8393 range->freq[i].m = geo->bg[j].freq * 100000;
8394 range->freq[i].e = 1;
8395 }
James Ketrenos43f66a62005-03-25 12:31:53 -06008396 }
James Ketrenosb095c382005-08-24 22:04:42 -05008397
8398 if (priv->ieee->mode & IEEE_A) {
8399 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8400 i++, j++) {
8401 range->freq[i].i = geo->a[j].channel;
8402 range->freq[i].m = geo->a[j].freq * 100000;
8403 range->freq[i].e = 1;
8404 }
8405 }
8406
8407 range->num_channels = i;
8408 range->num_frequency = i;
8409
Zhu Yi46441512006-01-24 16:37:59 +08008410 mutex_unlock(&priv->mutex);
Benoit Boissinot97a78ca2005-09-15 17:30:28 +00008411
8412 /* Event capability (kernel + driver) */
8413 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8414 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8415 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8416 range->event_capa[1] = IW_EVENT_CAPA_K_1;
James Ketrenos43f66a62005-03-25 12:31:53 -06008417
Dan Williamsf1b50862006-01-30 13:58:56 -05008418 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8419 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8420
James Ketrenos43f66a62005-03-25 12:31:53 -06008421 IPW_DEBUG_WX("GET Range\n");
8422 return 0;
8423}
8424
Jeff Garzikbf794512005-07-31 13:07:26 -04008425static int ipw_wx_set_wap(struct net_device *dev,
8426 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008427 union iwreq_data *wrqu, char *extra)
8428{
8429 struct ipw_priv *priv = ieee80211_priv(dev);
8430
8431 static const unsigned char any[] = {
8432 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8433 };
8434 static const unsigned char off[] = {
8435 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8436 };
8437
Jeff Garzikbf794512005-07-31 13:07:26 -04008438 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
James Ketrenos43f66a62005-03-25 12:31:53 -06008439 return -EINVAL;
Zhu Yi46441512006-01-24 16:37:59 +08008440 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008441 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8442 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8443 /* we disable mandatory BSSID association */
8444 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8445 priv->config &= ~CFG_STATIC_BSSID;
James Ketrenosc848d0a2005-08-24 21:56:24 -05008446 IPW_DEBUG_ASSOC("Attempting to associate with new "
8447 "parameters.\n");
8448 ipw_associate(priv);
Zhu Yi46441512006-01-24 16:37:59 +08008449 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008450 return 0;
8451 }
8452
8453 priv->config |= CFG_STATIC_BSSID;
8454 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8455 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
Zhu Yi46441512006-01-24 16:37:59 +08008456 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008457 return 0;
8458 }
8459
8460 IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8461 MAC_ARG(wrqu->ap_addr.sa_data));
8462
8463 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8464
James Ketrenosc848d0a2005-08-24 21:56:24 -05008465 /* Network configuration changed -- force [re]association */
8466 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8467 if (!ipw_disassociate(priv))
James Ketrenos43f66a62005-03-25 12:31:53 -06008468 ipw_associate(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -06008469
Zhu Yi46441512006-01-24 16:37:59 +08008470 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008471 return 0;
8472}
8473
Jeff Garzikbf794512005-07-31 13:07:26 -04008474static int ipw_wx_get_wap(struct net_device *dev,
8475 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008476 union iwreq_data *wrqu, char *extra)
8477{
8478 struct ipw_priv *priv = ieee80211_priv(dev);
8479 /* If we are associated, trying to associate, or have a statically
8480 * configured BSSID then return that; otherwise return ANY */
Zhu Yi46441512006-01-24 16:37:59 +08008481 mutex_lock(&priv->mutex);
Jeff Garzikbf794512005-07-31 13:07:26 -04008482 if (priv->config & CFG_STATIC_BSSID ||
James Ketrenos43f66a62005-03-25 12:31:53 -06008483 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8484 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
James Ketrenosafbf30a2005-08-25 00:05:33 -05008485 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
James Ketrenos43f66a62005-03-25 12:31:53 -06008486 } else
8487 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8488
8489 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8490 MAC_ARG(wrqu->ap_addr.sa_data));
Zhu Yi46441512006-01-24 16:37:59 +08008491 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008492 return 0;
8493}
8494
Jeff Garzikbf794512005-07-31 13:07:26 -04008495static int ipw_wx_set_essid(struct net_device *dev,
8496 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008497 union iwreq_data *wrqu, char *extra)
8498{
8499 struct ipw_priv *priv = ieee80211_priv(dev);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008500 char *essid = ""; /* ANY */
James Ketrenos43f66a62005-03-25 12:31:53 -06008501 int length = 0;
Zhu Yi46441512006-01-24 16:37:59 +08008502 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008503 if (wrqu->essid.flags && wrqu->essid.length) {
8504 length = wrqu->essid.length - 1;
8505 essid = extra;
8506 }
8507 if (length == 0) {
8508 IPW_DEBUG_WX("Setting ESSID to ANY\n");
James Ketrenosafbf30a2005-08-25 00:05:33 -05008509 if ((priv->config & CFG_STATIC_ESSID) &&
8510 !(priv->status & (STATUS_ASSOCIATED |
James Ketrenos43f66a62005-03-25 12:31:53 -06008511 STATUS_ASSOCIATING))) {
8512 IPW_DEBUG_ASSOC("Attempting to associate with new "
8513 "parameters.\n");
James Ketrenosafbf30a2005-08-25 00:05:33 -05008514 priv->config &= ~CFG_STATIC_ESSID;
James Ketrenos43f66a62005-03-25 12:31:53 -06008515 ipw_associate(priv);
8516 }
Zhu Yi46441512006-01-24 16:37:59 +08008517 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008518 return 0;
8519 }
8520
8521 length = min(length, IW_ESSID_MAX_SIZE);
8522
8523 priv->config |= CFG_STATIC_ESSID;
8524
8525 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8526 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
Zhu Yi46441512006-01-24 16:37:59 +08008527 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008528 return 0;
8529 }
8530
8531 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8532 length);
8533
8534 priv->essid_len = length;
8535 memcpy(priv->essid, essid, priv->essid_len);
Jeff Garzikbf794512005-07-31 13:07:26 -04008536
James Ketrenosc848d0a2005-08-24 21:56:24 -05008537 /* Network configuration changed -- force [re]association */
8538 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8539 if (!ipw_disassociate(priv))
James Ketrenos43f66a62005-03-25 12:31:53 -06008540 ipw_associate(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -06008541
Zhu Yi46441512006-01-24 16:37:59 +08008542 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008543 return 0;
8544}
8545
Jeff Garzikbf794512005-07-31 13:07:26 -04008546static int ipw_wx_get_essid(struct net_device *dev,
8547 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008548 union iwreq_data *wrqu, char *extra)
8549{
8550 struct ipw_priv *priv = ieee80211_priv(dev);
8551
8552 /* If we are associated, trying to associate, or have a statically
8553 * configured ESSID then return that; otherwise return ANY */
Zhu Yi46441512006-01-24 16:37:59 +08008554 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008555 if (priv->config & CFG_STATIC_ESSID ||
Jeff Garzikbf794512005-07-31 13:07:26 -04008556 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8557 IPW_DEBUG_WX("Getting essid: '%s'\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06008558 escape_essid(priv->essid, priv->essid_len));
Jeff Garzikbf794512005-07-31 13:07:26 -04008559 memcpy(extra, priv->essid, priv->essid_len);
James Ketrenos43f66a62005-03-25 12:31:53 -06008560 wrqu->essid.length = priv->essid_len;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008561 wrqu->essid.flags = 1; /* active */
James Ketrenos43f66a62005-03-25 12:31:53 -06008562 } else {
8563 IPW_DEBUG_WX("Getting essid: ANY\n");
8564 wrqu->essid.length = 0;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008565 wrqu->essid.flags = 0; /* active */
James Ketrenos43f66a62005-03-25 12:31:53 -06008566 }
Zhu Yi46441512006-01-24 16:37:59 +08008567 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008568 return 0;
8569}
8570
Jeff Garzikbf794512005-07-31 13:07:26 -04008571static int ipw_wx_set_nick(struct net_device *dev,
8572 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008573 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008574{
James Ketrenos43f66a62005-03-25 12:31:53 -06008575 struct ipw_priv *priv = ieee80211_priv(dev);
8576
8577 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8578 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8579 return -E2BIG;
Zhu Yi46441512006-01-24 16:37:59 +08008580 mutex_lock(&priv->mutex);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008581 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
James Ketrenos43f66a62005-03-25 12:31:53 -06008582 memset(priv->nick, 0, sizeof(priv->nick));
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008583 memcpy(priv->nick, extra, wrqu->data.length);
James Ketrenos43f66a62005-03-25 12:31:53 -06008584 IPW_DEBUG_TRACE("<<\n");
Zhu Yi46441512006-01-24 16:37:59 +08008585 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008586 return 0;
8587
8588}
8589
Jeff Garzikbf794512005-07-31 13:07:26 -04008590static int ipw_wx_get_nick(struct net_device *dev,
8591 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008592 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008593{
James Ketrenos43f66a62005-03-25 12:31:53 -06008594 struct ipw_priv *priv = ieee80211_priv(dev);
8595 IPW_DEBUG_WX("Getting nick\n");
Zhu Yi46441512006-01-24 16:37:59 +08008596 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008597 wrqu->data.length = strlen(priv->nick) + 1;
8598 memcpy(extra, priv->nick, wrqu->data.length);
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008599 wrqu->data.flags = 1; /* active */
Zhu Yi46441512006-01-24 16:37:59 +08008600 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008601 return 0;
8602}
8603
James Ketrenos43f66a62005-03-25 12:31:53 -06008604static int ipw_wx_set_rate(struct net_device *dev,
8605 struct iw_request_info *info,
8606 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008607{
James Ketrenosea2b26e2005-08-24 21:25:16 -05008608 /* TODO: We should use semaphores or locks for access to priv */
8609 struct ipw_priv *priv = ieee80211_priv(dev);
8610 u32 target_rate = wrqu->bitrate.value;
8611 u32 fixed, mask;
8612
8613 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8614 /* value = X, fixed = 1 means only rate X */
8615 /* value = X, fixed = 0 means all rates lower equal X */
8616
8617 if (target_rate == -1) {
8618 fixed = 0;
8619 mask = IEEE80211_DEFAULT_RATES_MASK;
8620 /* Now we should reassociate */
8621 goto apply;
8622 }
8623
8624 mask = 0;
8625 fixed = wrqu->bitrate.fixed;
8626
8627 if (target_rate == 1000000 || !fixed)
8628 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8629 if (target_rate == 1000000)
8630 goto apply;
8631
8632 if (target_rate == 2000000 || !fixed)
8633 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8634 if (target_rate == 2000000)
8635 goto apply;
8636
8637 if (target_rate == 5500000 || !fixed)
8638 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8639 if (target_rate == 5500000)
8640 goto apply;
8641
8642 if (target_rate == 6000000 || !fixed)
8643 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8644 if (target_rate == 6000000)
8645 goto apply;
8646
8647 if (target_rate == 9000000 || !fixed)
8648 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8649 if (target_rate == 9000000)
8650 goto apply;
8651
8652 if (target_rate == 11000000 || !fixed)
8653 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8654 if (target_rate == 11000000)
8655 goto apply;
8656
8657 if (target_rate == 12000000 || !fixed)
8658 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8659 if (target_rate == 12000000)
8660 goto apply;
8661
8662 if (target_rate == 18000000 || !fixed)
8663 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8664 if (target_rate == 18000000)
8665 goto apply;
8666
8667 if (target_rate == 24000000 || !fixed)
8668 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8669 if (target_rate == 24000000)
8670 goto apply;
8671
8672 if (target_rate == 36000000 || !fixed)
8673 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8674 if (target_rate == 36000000)
8675 goto apply;
8676
8677 if (target_rate == 48000000 || !fixed)
8678 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8679 if (target_rate == 48000000)
8680 goto apply;
8681
8682 if (target_rate == 54000000 || !fixed)
8683 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8684 if (target_rate == 54000000)
8685 goto apply;
8686
8687 IPW_DEBUG_WX("invalid rate specified, returning error\n");
8688 return -EINVAL;
8689
8690 apply:
8691 IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8692 mask, fixed ? "fixed" : "sub-rates");
Zhu Yi46441512006-01-24 16:37:59 +08008693 mutex_lock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05008694 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
James Ketrenosea2b26e2005-08-24 21:25:16 -05008695 priv->config &= ~CFG_FIXED_RATE;
James Ketrenosb095c382005-08-24 22:04:42 -05008696 ipw_set_fixed_rate(priv, priv->ieee->mode);
8697 } else
James Ketrenosea2b26e2005-08-24 21:25:16 -05008698 priv->config |= CFG_FIXED_RATE;
8699
James Ketrenosc848d0a2005-08-24 21:56:24 -05008700 if (priv->rates_mask == mask) {
8701 IPW_DEBUG_WX("Mask set to current mask.\n");
Zhu Yi46441512006-01-24 16:37:59 +08008702 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05008703 return 0;
James Ketrenosea2b26e2005-08-24 21:25:16 -05008704 }
8705
James Ketrenosc848d0a2005-08-24 21:56:24 -05008706 priv->rates_mask = mask;
8707
8708 /* Network configuration changed -- force [re]association */
8709 IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8710 if (!ipw_disassociate(priv))
8711 ipw_associate(priv);
8712
Zhu Yi46441512006-01-24 16:37:59 +08008713 mutex_unlock(&priv->mutex);
James Ketrenosea2b26e2005-08-24 21:25:16 -05008714 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06008715}
8716
Jeff Garzikbf794512005-07-31 13:07:26 -04008717static int ipw_wx_get_rate(struct net_device *dev,
8718 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008719 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008720{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008721 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08008722 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008723 wrqu->bitrate.value = priv->last_rate;
Zhu Yi46441512006-01-24 16:37:59 +08008724 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008725 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8726 return 0;
8727}
8728
Jeff Garzikbf794512005-07-31 13:07:26 -04008729static int ipw_wx_set_rts(struct net_device *dev,
8730 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008731 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008732{
James Ketrenos43f66a62005-03-25 12:31:53 -06008733 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08008734 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008735 if (wrqu->rts.disabled)
8736 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8737 else {
8738 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
James Ketrenosc848d0a2005-08-24 21:56:24 -05008739 wrqu->rts.value > MAX_RTS_THRESHOLD) {
Zhu Yi46441512006-01-24 16:37:59 +08008740 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008741 return -EINVAL;
James Ketrenosc848d0a2005-08-24 21:56:24 -05008742 }
James Ketrenos43f66a62005-03-25 12:31:53 -06008743 priv->rts_threshold = wrqu->rts.value;
8744 }
8745
8746 ipw_send_rts_threshold(priv, priv->rts_threshold);
Zhu Yi46441512006-01-24 16:37:59 +08008747 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008748 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8749 return 0;
8750}
8751
Jeff Garzikbf794512005-07-31 13:07:26 -04008752static int ipw_wx_get_rts(struct net_device *dev,
8753 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008754 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008755{
James Ketrenos43f66a62005-03-25 12:31:53 -06008756 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08008757 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008758 wrqu->rts.value = priv->rts_threshold;
8759 wrqu->rts.fixed = 0; /* no auto select */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008760 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
Zhu Yi46441512006-01-24 16:37:59 +08008761 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008762 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8763 return 0;
8764}
8765
Jeff Garzikbf794512005-07-31 13:07:26 -04008766static int ipw_wx_set_txpow(struct net_device *dev,
8767 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008768 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008769{
James Ketrenos43f66a62005-03-25 12:31:53 -06008770 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi6de9f7f2005-08-11 14:39:33 +08008771 int err = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06008772
Zhu Yi46441512006-01-24 16:37:59 +08008773 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -05008774 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
Zhu Yi6de9f7f2005-08-11 14:39:33 +08008775 err = -EINPROGRESS;
8776 goto out;
James Ketrenosc848d0a2005-08-24 21:56:24 -05008777 }
James Ketrenos43f66a62005-03-25 12:31:53 -06008778
James Ketrenosb095c382005-08-24 22:04:42 -05008779 if (!wrqu->power.fixed)
8780 wrqu->power.value = IPW_TX_POWER_DEFAULT;
James Ketrenos43f66a62005-03-25 12:31:53 -06008781
James Ketrenosc848d0a2005-08-24 21:56:24 -05008782 if (wrqu->power.flags != IW_TXPOW_DBM) {
Zhu Yi6de9f7f2005-08-11 14:39:33 +08008783 err = -EINVAL;
8784 goto out;
James Ketrenosc848d0a2005-08-24 21:56:24 -05008785 }
James Ketrenos43f66a62005-03-25 12:31:53 -06008786
James Ketrenosb095c382005-08-24 22:04:42 -05008787 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
James Ketrenosafbf30a2005-08-25 00:05:33 -05008788 (wrqu->power.value < IPW_TX_POWER_MIN)) {
Zhu Yi6de9f7f2005-08-11 14:39:33 +08008789 err = -EINVAL;
8790 goto out;
James Ketrenosc848d0a2005-08-24 21:56:24 -05008791 }
James Ketrenos43f66a62005-03-25 12:31:53 -06008792
8793 priv->tx_power = wrqu->power.value;
Zhu Yi6de9f7f2005-08-11 14:39:33 +08008794 err = ipw_set_tx_power(priv);
8795 out:
Zhu Yi46441512006-01-24 16:37:59 +08008796 mutex_unlock(&priv->mutex);
Zhu Yi6de9f7f2005-08-11 14:39:33 +08008797 return err;
James Ketrenos43f66a62005-03-25 12:31:53 -06008798}
8799
Jeff Garzikbf794512005-07-31 13:07:26 -04008800static int ipw_wx_get_txpow(struct net_device *dev,
8801 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008802 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008803{
James Ketrenos43f66a62005-03-25 12:31:53 -06008804 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08008805 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008806 wrqu->power.value = priv->tx_power;
8807 wrqu->power.fixed = 1;
8808 wrqu->power.flags = IW_TXPOW_DBM;
8809 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
Zhu Yi46441512006-01-24 16:37:59 +08008810 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008811
Jeff Garzikbf794512005-07-31 13:07:26 -04008812 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
Zhu Yi22501c82005-08-11 10:49:17 +08008813 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
James Ketrenos43f66a62005-03-25 12:31:53 -06008814
8815 return 0;
8816}
8817
Jeff Garzikbf794512005-07-31 13:07:26 -04008818static int ipw_wx_set_frag(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008819 struct iw_request_info *info,
8820 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06008821{
8822 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08008823 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008824 if (wrqu->frag.disabled)
8825 priv->ieee->fts = DEFAULT_FTS;
8826 else {
8827 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
James Ketrenosb095c382005-08-24 22:04:42 -05008828 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
Zhu Yi46441512006-01-24 16:37:59 +08008829 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008830 return -EINVAL;
James Ketrenosb095c382005-08-24 22:04:42 -05008831 }
Jeff Garzikbf794512005-07-31 13:07:26 -04008832
James Ketrenos43f66a62005-03-25 12:31:53 -06008833 priv->ieee->fts = wrqu->frag.value & ~0x1;
8834 }
8835
8836 ipw_send_frag_threshold(priv, wrqu->frag.value);
Zhu Yi46441512006-01-24 16:37:59 +08008837 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008838 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8839 return 0;
8840}
8841
Jeff Garzikbf794512005-07-31 13:07:26 -04008842static int ipw_wx_get_frag(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008843 struct iw_request_info *info,
8844 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06008845{
8846 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08008847 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008848 wrqu->frag.value = priv->ieee->fts;
8849 wrqu->frag.fixed = 0; /* no auto select */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04008850 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
Zhu Yi46441512006-01-24 16:37:59 +08008851 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06008852 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8853
8854 return 0;
8855}
8856
Jeff Garzikbf794512005-07-31 13:07:26 -04008857static int ipw_wx_set_retry(struct net_device *dev,
8858 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008859 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008860{
James Ketrenosafbf30a2005-08-25 00:05:33 -05008861 struct ipw_priv *priv = ieee80211_priv(dev);
8862
8863 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8864 return -EINVAL;
8865
8866 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8867 return 0;
8868
8869 if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8870 return -EINVAL;
8871
Zhu Yi46441512006-01-24 16:37:59 +08008872 mutex_lock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008873 if (wrqu->retry.flags & IW_RETRY_MIN)
8874 priv->short_retry_limit = (u8) wrqu->retry.value;
8875 else if (wrqu->retry.flags & IW_RETRY_MAX)
8876 priv->long_retry_limit = (u8) wrqu->retry.value;
8877 else {
8878 priv->short_retry_limit = (u8) wrqu->retry.value;
8879 priv->long_retry_limit = (u8) wrqu->retry.value;
8880 }
8881
8882 ipw_send_retry_limit(priv, priv->short_retry_limit,
8883 priv->long_retry_limit);
Zhu Yi46441512006-01-24 16:37:59 +08008884 mutex_unlock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008885 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8886 priv->short_retry_limit, priv->long_retry_limit);
8887 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06008888}
8889
Jeff Garzikbf794512005-07-31 13:07:26 -04008890static int ipw_wx_get_retry(struct net_device *dev,
8891 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008892 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04008893{
James Ketrenosafbf30a2005-08-25 00:05:33 -05008894 struct ipw_priv *priv = ieee80211_priv(dev);
8895
Zhu Yi46441512006-01-24 16:37:59 +08008896 mutex_lock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008897 wrqu->retry.disabled = 0;
8898
8899 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
Zhu Yi46441512006-01-24 16:37:59 +08008900 mutex_unlock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008901 return -EINVAL;
8902 }
8903
8904 if (wrqu->retry.flags & IW_RETRY_MAX) {
8905 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8906 wrqu->retry.value = priv->long_retry_limit;
8907 } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8908 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8909 wrqu->retry.value = priv->short_retry_limit;
8910 } else {
8911 wrqu->retry.flags = IW_RETRY_LIMIT;
8912 wrqu->retry.value = priv->short_retry_limit;
8913 }
Zhu Yi46441512006-01-24 16:37:59 +08008914 mutex_unlock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008915
8916 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8917
8918 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06008919}
8920
James Ketrenosafbf30a2005-08-25 00:05:33 -05008921static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8922 int essid_len)
8923{
8924 struct ipw_scan_request_ext scan;
8925 int err = 0, scan_type;
8926
Pekka Enbergefb34422005-11-16 21:55:05 +02008927 if (!(priv->status & STATUS_INIT) ||
8928 (priv->status & STATUS_EXIT_PENDING))
8929 return 0;
8930
Zhu Yi46441512006-01-24 16:37:59 +08008931 mutex_lock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008932
8933 if (priv->status & STATUS_RF_KILL_MASK) {
8934 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8935 priv->status |= STATUS_SCAN_PENDING;
8936 goto done;
8937 }
8938
8939 IPW_DEBUG_HC("starting request direct scan!\n");
8940
8941 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
Olaf Kirchd834a412006-01-09 17:00:37 +01008942 /* We should not sleep here; otherwise we will block most
8943 * of the system (for instance, we hold rtnl_lock when we
8944 * get here).
8945 */
8946 err = -EAGAIN;
8947 goto done;
James Ketrenosafbf30a2005-08-25 00:05:33 -05008948 }
8949 memset(&scan, 0, sizeof(scan));
8950
8951 if (priv->config & CFG_SPEED_SCAN)
8952 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8953 cpu_to_le16(30);
8954 else
8955 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8956 cpu_to_le16(20);
8957
8958 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8959 cpu_to_le16(20);
Liu Hong1fe0adb2005-08-19 09:33:10 -05008960 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008961 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8962
8963 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8964
8965 err = ipw_send_ssid(priv, essid, essid_len);
8966 if (err) {
8967 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8968 goto done;
8969 }
8970 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8971
8972 ipw_add_scan_channels(priv, &scan, scan_type);
8973
8974 err = ipw_send_scan_request_ext(priv, &scan);
8975 if (err) {
8976 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8977 goto done;
8978 }
8979
8980 priv->status |= STATUS_SCANNING;
8981
8982 done:
Zhu Yi46441512006-01-24 16:37:59 +08008983 mutex_unlock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008984 return err;
James Ketrenos43f66a62005-03-25 12:31:53 -06008985}
8986
Jeff Garzikbf794512005-07-31 13:07:26 -04008987static int ipw_wx_set_scan(struct net_device *dev,
8988 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06008989 union iwreq_data *wrqu, char *extra)
8990{
8991 struct ipw_priv *priv = ieee80211_priv(dev);
James Ketrenosafbf30a2005-08-25 00:05:33 -05008992 struct iw_scan_req *req = NULL;
8993 if (wrqu->data.length
8994 && wrqu->data.length == sizeof(struct iw_scan_req)) {
8995 req = (struct iw_scan_req *)extra;
8996 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
8997 ipw_request_direct_scan(priv, req->essid,
8998 req->essid_len);
8999 return 0;
9000 }
9001 }
James Ketrenos8935f392005-10-05 15:59:08 -05009002
James Ketrenos43f66a62005-03-25 12:31:53 -06009003 IPW_DEBUG_WX("Start scan\n");
James Ketrenosb095c382005-08-24 22:04:42 -05009004
9005 queue_work(priv->workqueue, &priv->request_scan);
9006
James Ketrenos43f66a62005-03-25 12:31:53 -06009007 return 0;
9008}
9009
Jeff Garzikbf794512005-07-31 13:07:26 -04009010static int ipw_wx_get_scan(struct net_device *dev,
9011 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06009012 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04009013{
James Ketrenos43f66a62005-03-25 12:31:53 -06009014 struct ipw_priv *priv = ieee80211_priv(dev);
9015 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9016}
9017
Jeff Garzikbf794512005-07-31 13:07:26 -04009018static int ipw_wx_set_encode(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009019 struct iw_request_info *info,
9020 union iwreq_data *wrqu, char *key)
James Ketrenos43f66a62005-03-25 12:31:53 -06009021{
9022 struct ipw_priv *priv = ieee80211_priv(dev);
James Ketrenosafbf30a2005-08-25 00:05:33 -05009023 int ret;
Hong Liucaeff812005-08-05 17:25:50 +08009024 u32 cap = priv->capability;
James Ketrenosafbf30a2005-08-25 00:05:33 -05009025
Zhu Yi46441512006-01-24 16:37:59 +08009026 mutex_lock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05009027 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
James Ketrenosafbf30a2005-08-25 00:05:33 -05009028
Hong Liucaeff812005-08-05 17:25:50 +08009029 /* In IBSS mode, we need to notify the firmware to update
9030 * the beacon info after we changed the capability. */
9031 if (cap != priv->capability &&
9032 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9033 priv->status & STATUS_ASSOCIATED)
9034 ipw_disassociate(priv);
9035
Zhu Yi46441512006-01-24 16:37:59 +08009036 mutex_unlock(&priv->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05009037 return ret;
James Ketrenos43f66a62005-03-25 12:31:53 -06009038}
9039
Jeff Garzikbf794512005-07-31 13:07:26 -04009040static int ipw_wx_get_encode(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009041 struct iw_request_info *info,
9042 union iwreq_data *wrqu, char *key)
James Ketrenos43f66a62005-03-25 12:31:53 -06009043{
9044 struct ipw_priv *priv = ieee80211_priv(dev);
9045 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9046}
9047
Jeff Garzikbf794512005-07-31 13:07:26 -04009048static int ipw_wx_set_power(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009049 struct iw_request_info *info,
9050 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06009051{
9052 struct ipw_priv *priv = ieee80211_priv(dev);
9053 int err;
Zhu Yi46441512006-01-24 16:37:59 +08009054 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009055 if (wrqu->power.disabled) {
9056 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9057 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9058 if (err) {
9059 IPW_DEBUG_WX("failed setting power mode.\n");
Zhu Yi46441512006-01-24 16:37:59 +08009060 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009061 return err;
9062 }
James Ketrenos43f66a62005-03-25 12:31:53 -06009063 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
Zhu Yi46441512006-01-24 16:37:59 +08009064 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009065 return 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04009066 }
James Ketrenos43f66a62005-03-25 12:31:53 -06009067
9068 switch (wrqu->power.flags & IW_POWER_MODE) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009069 case IW_POWER_ON: /* If not specified */
9070 case IW_POWER_MODE: /* If set all mask */
9071 case IW_POWER_ALL_R: /* If explicitely state all */
James Ketrenos43f66a62005-03-25 12:31:53 -06009072 break;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009073 default: /* Otherwise we don't support it */
James Ketrenos43f66a62005-03-25 12:31:53 -06009074 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9075 wrqu->power.flags);
Zhu Yi46441512006-01-24 16:37:59 +08009076 mutex_unlock(&priv->mutex);
Jeff Garzikbf794512005-07-31 13:07:26 -04009077 return -EOPNOTSUPP;
James Ketrenos43f66a62005-03-25 12:31:53 -06009078 }
Jeff Garzikbf794512005-07-31 13:07:26 -04009079
James Ketrenos43f66a62005-03-25 12:31:53 -06009080 /* If the user hasn't specified a power management mode yet, default
9081 * to BATTERY */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009082 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
James Ketrenos43f66a62005-03-25 12:31:53 -06009083 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
Jeff Garzikbf794512005-07-31 13:07:26 -04009084 else
James Ketrenos43f66a62005-03-25 12:31:53 -06009085 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9086 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9087 if (err) {
9088 IPW_DEBUG_WX("failed setting power mode.\n");
Zhu Yi46441512006-01-24 16:37:59 +08009089 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009090 return err;
9091 }
9092
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009093 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
Zhu Yi46441512006-01-24 16:37:59 +08009094 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009095 return 0;
9096}
9097
Jeff Garzikbf794512005-07-31 13:07:26 -04009098static int ipw_wx_get_power(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009099 struct iw_request_info *info,
9100 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06009101{
9102 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08009103 mutex_lock(&priv->mutex);
James Ketrenosa613bff2005-08-24 21:43:11 -05009104 if (!(priv->power_mode & IPW_POWER_ENABLED))
James Ketrenos43f66a62005-03-25 12:31:53 -06009105 wrqu->power.disabled = 1;
James Ketrenosa613bff2005-08-24 21:43:11 -05009106 else
James Ketrenos43f66a62005-03-25 12:31:53 -06009107 wrqu->power.disabled = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06009108
Zhu Yi46441512006-01-24 16:37:59 +08009109 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009110 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
Jeff Garzikbf794512005-07-31 13:07:26 -04009111
James Ketrenos43f66a62005-03-25 12:31:53 -06009112 return 0;
9113}
9114
Jeff Garzikbf794512005-07-31 13:07:26 -04009115static int ipw_wx_set_powermode(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009116 struct iw_request_info *info,
9117 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06009118{
9119 struct ipw_priv *priv = ieee80211_priv(dev);
9120 int mode = *(int *)extra;
9121 int err;
Zhu Yi46441512006-01-24 16:37:59 +08009122 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009123 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9124 mode = IPW_POWER_AC;
9125 priv->power_mode = mode;
9126 } else {
9127 priv->power_mode = IPW_POWER_ENABLED | mode;
9128 }
Jeff Garzikbf794512005-07-31 13:07:26 -04009129
James Ketrenos43f66a62005-03-25 12:31:53 -06009130 if (priv->power_mode != mode) {
9131 err = ipw_send_power_mode(priv, mode);
Jeff Garzikbf794512005-07-31 13:07:26 -04009132
James Ketrenos43f66a62005-03-25 12:31:53 -06009133 if (err) {
9134 IPW_DEBUG_WX("failed setting power mode.\n");
Zhu Yi46441512006-01-24 16:37:59 +08009135 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009136 return err;
9137 }
9138 }
Zhu Yi46441512006-01-24 16:37:59 +08009139 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009140 return 0;
9141}
9142
9143#define MAX_WX_STRING 80
Jeff Garzikbf794512005-07-31 13:07:26 -04009144static int ipw_wx_get_powermode(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009145 struct iw_request_info *info,
9146 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06009147{
9148 struct ipw_priv *priv = ieee80211_priv(dev);
9149 int level = IPW_POWER_LEVEL(priv->power_mode);
9150 char *p = extra;
9151
9152 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9153
9154 switch (level) {
9155 case IPW_POWER_AC:
9156 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9157 break;
9158 case IPW_POWER_BATTERY:
9159 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9160 break;
9161 default:
9162 p += snprintf(p, MAX_WX_STRING - (p - extra),
Jeff Garzikbf794512005-07-31 13:07:26 -04009163 "(Timeout %dms, Period %dms)",
James Ketrenos43f66a62005-03-25 12:31:53 -06009164 timeout_duration[level - 1] / 1000,
9165 period_duration[level - 1] / 1000);
9166 }
9167
9168 if (!(priv->power_mode & IPW_POWER_ENABLED))
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009169 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
James Ketrenos43f66a62005-03-25 12:31:53 -06009170
9171 wrqu->data.length = p - extra + 1;
9172
9173 return 0;
9174}
9175
9176static int ipw_wx_set_wireless_mode(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009177 struct iw_request_info *info,
9178 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06009179{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009180 struct ipw_priv *priv = ieee80211_priv(dev);
James Ketrenos43f66a62005-03-25 12:31:53 -06009181 int mode = *(int *)extra;
9182 u8 band = 0, modulation = 0;
9183
9184 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009185 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
James Ketrenos43f66a62005-03-25 12:31:53 -06009186 return -EINVAL;
9187 }
Zhu Yi46441512006-01-24 16:37:59 +08009188 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009189 if (priv->adapter == IPW_2915ABG) {
James Ketrenosa33a1982005-09-14 14:28:59 -05009190 priv->ieee->abg_true = 1;
James Ketrenos43f66a62005-03-25 12:31:53 -06009191 if (mode & IEEE_A) {
9192 band |= IEEE80211_52GHZ_BAND;
9193 modulation |= IEEE80211_OFDM_MODULATION;
9194 } else
James Ketrenosa33a1982005-09-14 14:28:59 -05009195 priv->ieee->abg_true = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06009196 } else {
9197 if (mode & IEEE_A) {
9198 IPW_WARNING("Attempt to set 2200BG into "
9199 "802.11a mode\n");
Zhu Yi46441512006-01-24 16:37:59 +08009200 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009201 return -EINVAL;
9202 }
9203
James Ketrenosa33a1982005-09-14 14:28:59 -05009204 priv->ieee->abg_true = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06009205 }
9206
9207 if (mode & IEEE_B) {
9208 band |= IEEE80211_24GHZ_BAND;
9209 modulation |= IEEE80211_CCK_MODULATION;
9210 } else
James Ketrenosa33a1982005-09-14 14:28:59 -05009211 priv->ieee->abg_true = 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04009212
James Ketrenos43f66a62005-03-25 12:31:53 -06009213 if (mode & IEEE_G) {
9214 band |= IEEE80211_24GHZ_BAND;
9215 modulation |= IEEE80211_OFDM_MODULATION;
9216 } else
James Ketrenosa33a1982005-09-14 14:28:59 -05009217 priv->ieee->abg_true = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06009218
9219 priv->ieee->mode = mode;
9220 priv->ieee->freq_band = band;
9221 priv->ieee->modulation = modulation;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009222 init_supported_rates(priv, &priv->rates);
James Ketrenos43f66a62005-03-25 12:31:53 -06009223
James Ketrenosc848d0a2005-08-24 21:56:24 -05009224 /* Network configuration changed -- force [re]association */
9225 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9226 if (!ipw_disassociate(priv)) {
James Ketrenos43f66a62005-03-25 12:31:53 -06009227 ipw_send_supported_rates(priv, &priv->rates);
James Ketrenosc848d0a2005-08-24 21:56:24 -05009228 ipw_associate(priv);
9229 }
James Ketrenos43f66a62005-03-25 12:31:53 -06009230
James Ketrenosa613bff2005-08-24 21:43:11 -05009231 /* Update the band LEDs */
9232 ipw_led_band_on(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -06009233
Jeff Garzikbf794512005-07-31 13:07:26 -04009234 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06009235 mode & IEEE_A ? 'a' : '.',
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009236 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
Zhu Yi46441512006-01-24 16:37:59 +08009237 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009238 return 0;
9239}
9240
9241static int ipw_wx_get_wireless_mode(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009242 struct iw_request_info *info,
9243 union iwreq_data *wrqu, char *extra)
James Ketrenos43f66a62005-03-25 12:31:53 -06009244{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009245 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08009246 mutex_lock(&priv->mutex);
James Ketrenosea2b26e2005-08-24 21:25:16 -05009247 switch (priv->ieee->mode) {
9248 case IEEE_A:
James Ketrenos43f66a62005-03-25 12:31:53 -06009249 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9250 break;
James Ketrenosea2b26e2005-08-24 21:25:16 -05009251 case IEEE_B:
9252 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9253 break;
9254 case IEEE_A | IEEE_B:
9255 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9256 break;
9257 case IEEE_G:
9258 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9259 break;
9260 case IEEE_A | IEEE_G:
9261 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9262 break;
9263 case IEEE_B | IEEE_G:
9264 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9265 break;
9266 case IEEE_A | IEEE_B | IEEE_G:
9267 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9268 break;
9269 default:
9270 strncpy(extra, "unknown", MAX_WX_STRING);
James Ketrenos43f66a62005-03-25 12:31:53 -06009271 break;
Jeff Garzikbf794512005-07-31 13:07:26 -04009272 }
9273
James Ketrenos43f66a62005-03-25 12:31:53 -06009274 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9275
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009276 wrqu->data.length = strlen(extra) + 1;
Zhu Yi46441512006-01-24 16:37:59 +08009277 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009278
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009279 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06009280}
9281
James Ketrenosea2b26e2005-08-24 21:25:16 -05009282static int ipw_wx_set_preamble(struct net_device *dev,
9283 struct iw_request_info *info,
9284 union iwreq_data *wrqu, char *extra)
9285{
9286 struct ipw_priv *priv = ieee80211_priv(dev);
9287 int mode = *(int *)extra;
Zhu Yi46441512006-01-24 16:37:59 +08009288 mutex_lock(&priv->mutex);
James Ketrenosea2b26e2005-08-24 21:25:16 -05009289 /* Switching from SHORT -> LONG requires a disassociation */
9290 if (mode == 1) {
9291 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9292 priv->config |= CFG_PREAMBLE_LONG;
James Ketrenosc848d0a2005-08-24 21:56:24 -05009293
9294 /* Network configuration changed -- force [re]association */
9295 IPW_DEBUG_ASSOC
9296 ("[re]association triggered due to preamble change.\n");
9297 if (!ipw_disassociate(priv))
9298 ipw_associate(priv);
James Ketrenosea2b26e2005-08-24 21:25:16 -05009299 }
9300 goto done;
9301 }
9302
9303 if (mode == 0) {
9304 priv->config &= ~CFG_PREAMBLE_LONG;
9305 goto done;
9306 }
Zhu Yi46441512006-01-24 16:37:59 +08009307 mutex_unlock(&priv->mutex);
James Ketrenosea2b26e2005-08-24 21:25:16 -05009308 return -EINVAL;
9309
9310 done:
Zhu Yi46441512006-01-24 16:37:59 +08009311 mutex_unlock(&priv->mutex);
James Ketrenosea2b26e2005-08-24 21:25:16 -05009312 return 0;
9313}
9314
9315static int ipw_wx_get_preamble(struct net_device *dev,
9316 struct iw_request_info *info,
9317 union iwreq_data *wrqu, char *extra)
9318{
9319 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +08009320 mutex_lock(&priv->mutex);
James Ketrenosea2b26e2005-08-24 21:25:16 -05009321 if (priv->config & CFG_PREAMBLE_LONG)
9322 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9323 else
9324 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
Zhu Yi46441512006-01-24 16:37:59 +08009325 mutex_unlock(&priv->mutex);
James Ketrenosea2b26e2005-08-24 21:25:16 -05009326 return 0;
9327}
9328
James Ketrenosb095c382005-08-24 22:04:42 -05009329#ifdef CONFIG_IPW2200_MONITOR
James Ketrenosea2b26e2005-08-24 21:25:16 -05009330static int ipw_wx_set_monitor(struct net_device *dev,
Jeff Garzikbf794512005-07-31 13:07:26 -04009331 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06009332 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04009333{
James Ketrenos43f66a62005-03-25 12:31:53 -06009334 struct ipw_priv *priv = ieee80211_priv(dev);
9335 int *parms = (int *)extra;
9336 int enable = (parms[0] > 0);
Zhu Yi46441512006-01-24 16:37:59 +08009337 mutex_lock(&priv->mutex);
James Ketrenosea2b26e2005-08-24 21:25:16 -05009338 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
James Ketrenos43f66a62005-03-25 12:31:53 -06009339 if (enable) {
9340 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
Mike Kershaw24a47db2005-08-26 00:41:54 -05009341#ifdef CONFIG_IEEE80211_RADIOTAP
9342 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9343#else
James Ketrenos43f66a62005-03-25 12:31:53 -06009344 priv->net_dev->type = ARPHRD_IEEE80211;
Mike Kershaw24a47db2005-08-26 00:41:54 -05009345#endif
James Ketrenosa613bff2005-08-24 21:43:11 -05009346 queue_work(priv->workqueue, &priv->adapter_restart);
James Ketrenos43f66a62005-03-25 12:31:53 -06009347 }
Jeff Garzikbf794512005-07-31 13:07:26 -04009348
James Ketrenos43f66a62005-03-25 12:31:53 -06009349 ipw_set_channel(priv, parms[1]);
9350 } else {
James Ketrenosc848d0a2005-08-24 21:56:24 -05009351 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
Zhu Yi46441512006-01-24 16:37:59 +08009352 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009353 return 0;
James Ketrenosc848d0a2005-08-24 21:56:24 -05009354 }
James Ketrenos43f66a62005-03-25 12:31:53 -06009355 priv->net_dev->type = ARPHRD_ETHER;
James Ketrenosa613bff2005-08-24 21:43:11 -05009356 queue_work(priv->workqueue, &priv->adapter_restart);
James Ketrenos43f66a62005-03-25 12:31:53 -06009357 }
Zhu Yi46441512006-01-24 16:37:59 +08009358 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009359 return 0;
9360}
9361
James Ketrenosb095c382005-08-24 22:04:42 -05009362#endif // CONFIG_IPW2200_MONITOR
9363
Jeff Garzikbf794512005-07-31 13:07:26 -04009364static int ipw_wx_reset(struct net_device *dev,
9365 struct iw_request_info *info,
James Ketrenos43f66a62005-03-25 12:31:53 -06009366 union iwreq_data *wrqu, char *extra)
Jeff Garzikbf794512005-07-31 13:07:26 -04009367{
James Ketrenos43f66a62005-03-25 12:31:53 -06009368 struct ipw_priv *priv = ieee80211_priv(dev);
9369 IPW_DEBUG_WX("RESET\n");
James Ketrenosa613bff2005-08-24 21:43:11 -05009370 queue_work(priv->workqueue, &priv->adapter_restart);
James Ketrenos43f66a62005-03-25 12:31:53 -06009371 return 0;
9372}
James Ketrenosb095c382005-08-24 22:04:42 -05009373
James Ketrenosb095c382005-08-24 22:04:42 -05009374static int ipw_wx_sw_reset(struct net_device *dev,
9375 struct iw_request_info *info,
9376 union iwreq_data *wrqu, char *extra)
9377{
9378 struct ipw_priv *priv = ieee80211_priv(dev);
9379 union iwreq_data wrqu_sec = {
9380 .encoding = {
9381 .flags = IW_ENCODE_DISABLED,
9382 },
9383 };
James Ketrenosafbf30a2005-08-25 00:05:33 -05009384 int ret;
James Ketrenosb095c382005-08-24 22:04:42 -05009385
9386 IPW_DEBUG_WX("SW_RESET\n");
9387
Zhu Yi46441512006-01-24 16:37:59 +08009388 mutex_lock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05009389
Zhu Yid6d5b5c2006-02-16 16:21:09 +08009390 ret = ipw_sw_reset(priv, 2);
James Ketrenosafbf30a2005-08-25 00:05:33 -05009391 if (!ret) {
9392 free_firmware();
9393 ipw_adapter_restart(priv);
9394 }
James Ketrenosb095c382005-08-24 22:04:42 -05009395
9396 /* The SW reset bit might have been toggled on by the 'disable'
9397 * module parameter, so take appropriate action */
9398 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9399
Zhu Yi46441512006-01-24 16:37:59 +08009400 mutex_unlock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05009401 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
Zhu Yi46441512006-01-24 16:37:59 +08009402 mutex_lock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05009403
9404 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9405 /* Configuration likely changed -- force [re]association */
9406 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9407 "reset.\n");
9408 if (!ipw_disassociate(priv))
9409 ipw_associate(priv);
9410 }
9411
Zhu Yi46441512006-01-24 16:37:59 +08009412 mutex_unlock(&priv->mutex);
James Ketrenosb095c382005-08-24 22:04:42 -05009413
9414 return 0;
9415}
James Ketrenos43f66a62005-03-25 12:31:53 -06009416
9417/* Rebase the WE IOCTLs to zero for the handler array */
9418#define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009419static iw_handler ipw_wx_handlers[] = {
James Ketrenosea2b26e2005-08-24 21:25:16 -05009420 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9421 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9422 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9423 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9424 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9425 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9426 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9427 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9428 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9429 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9430 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9431 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9432 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9433 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9434 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9435 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9436 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9437 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9438 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9439 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9440 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9441 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9442 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9443 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9444 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9445 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9446 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9447 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
James Ketrenosa613bff2005-08-24 21:43:11 -05009448 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9449 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9450 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9451 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
James Ketrenosafbf30a2005-08-25 00:05:33 -05009452 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9453 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9454 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9455 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9456 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9457 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9458 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
James Ketrenos43f66a62005-03-25 12:31:53 -06009459};
9460
James Ketrenosb095c382005-08-24 22:04:42 -05009461enum {
9462 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9463 IPW_PRIV_GET_POWER,
9464 IPW_PRIV_SET_MODE,
9465 IPW_PRIV_GET_MODE,
9466 IPW_PRIV_SET_PREAMBLE,
9467 IPW_PRIV_GET_PREAMBLE,
9468 IPW_PRIV_RESET,
9469 IPW_PRIV_SW_RESET,
9470#ifdef CONFIG_IPW2200_MONITOR
9471 IPW_PRIV_SET_MONITOR,
9472#endif
9473};
James Ketrenos43f66a62005-03-25 12:31:53 -06009474
Jeff Garzikbf794512005-07-31 13:07:26 -04009475static struct iw_priv_args ipw_priv_args[] = {
James Ketrenos43f66a62005-03-25 12:31:53 -06009476 {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009477 .cmd = IPW_PRIV_SET_POWER,
9478 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9479 .name = "set_power"},
James Ketrenos43f66a62005-03-25 12:31:53 -06009480 {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009481 .cmd = IPW_PRIV_GET_POWER,
9482 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9483 .name = "get_power"},
James Ketrenos43f66a62005-03-25 12:31:53 -06009484 {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009485 .cmd = IPW_PRIV_SET_MODE,
9486 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9487 .name = "set_mode"},
James Ketrenos43f66a62005-03-25 12:31:53 -06009488 {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009489 .cmd = IPW_PRIV_GET_MODE,
9490 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9491 .name = "get_mode"},
James Ketrenos43f66a62005-03-25 12:31:53 -06009492 {
James Ketrenosea2b26e2005-08-24 21:25:16 -05009493 .cmd = IPW_PRIV_SET_PREAMBLE,
9494 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9495 .name = "set_preamble"},
9496 {
9497 .cmd = IPW_PRIV_GET_PREAMBLE,
9498 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9499 .name = "get_preamble"},
James Ketrenos43f66a62005-03-25 12:31:53 -06009500 {
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009501 IPW_PRIV_RESET,
9502 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
James Ketrenosb095c382005-08-24 22:04:42 -05009503 {
9504 IPW_PRIV_SW_RESET,
9505 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9506#ifdef CONFIG_IPW2200_MONITOR
9507 {
9508 IPW_PRIV_SET_MONITOR,
9509 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9510#endif /* CONFIG_IPW2200_MONITOR */
James Ketrenos43f66a62005-03-25 12:31:53 -06009511};
9512
9513static iw_handler ipw_priv_handler[] = {
9514 ipw_wx_set_powermode,
9515 ipw_wx_get_powermode,
9516 ipw_wx_set_wireless_mode,
9517 ipw_wx_get_wireless_mode,
James Ketrenosea2b26e2005-08-24 21:25:16 -05009518 ipw_wx_set_preamble,
9519 ipw_wx_get_preamble,
Jeff Garzikbf794512005-07-31 13:07:26 -04009520 ipw_wx_reset,
James Ketrenosb095c382005-08-24 22:04:42 -05009521 ipw_wx_sw_reset,
9522#ifdef CONFIG_IPW2200_MONITOR
9523 ipw_wx_set_monitor,
James Ketrenos43f66a62005-03-25 12:31:53 -06009524#endif
9525};
9526
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009527static struct iw_handler_def ipw_wx_handler_def = {
James Ketrenosea2b26e2005-08-24 21:25:16 -05009528 .standard = ipw_wx_handlers,
9529 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9530 .num_private = ARRAY_SIZE(ipw_priv_handler),
9531 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9532 .private = ipw_priv_handler,
9533 .private_args = ipw_priv_args,
Benoit Boissinot97a78ca2005-09-15 17:30:28 +00009534 .get_wireless_stats = ipw_get_wireless_stats,
James Ketrenos43f66a62005-03-25 12:31:53 -06009535};
9536
James Ketrenos43f66a62005-03-25 12:31:53 -06009537/*
9538 * Get wireless statistics.
9539 * Called by /proc/net/wireless
9540 * Also called by SIOCGIWSTATS
9541 */
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009542static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
James Ketrenos43f66a62005-03-25 12:31:53 -06009543{
9544 struct ipw_priv *priv = ieee80211_priv(dev);
9545 struct iw_statistics *wstats;
Jeff Garzikbf794512005-07-31 13:07:26 -04009546
James Ketrenos43f66a62005-03-25 12:31:53 -06009547 wstats = &priv->wstats;
9548
James Ketrenosea2b26e2005-08-24 21:25:16 -05009549 /* if hw is disabled, then ipw_get_ordinal() can't be called.
James Ketrenosafbf30a2005-08-25 00:05:33 -05009550 * netdev->get_wireless_stats seems to be called before fw is
James Ketrenos43f66a62005-03-25 12:31:53 -06009551 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9552 * and associated; if not associcated, the values are all meaningless
9553 * anyway, so set them all to NULL and INVALID */
9554 if (!(priv->status & STATUS_ASSOCIATED)) {
9555 wstats->miss.beacon = 0;
9556 wstats->discard.retries = 0;
9557 wstats->qual.qual = 0;
9558 wstats->qual.level = 0;
9559 wstats->qual.noise = 0;
9560 wstats->qual.updated = 7;
9561 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009562 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
James Ketrenos43f66a62005-03-25 12:31:53 -06009563 return wstats;
Jeff Garzikbf794512005-07-31 13:07:26 -04009564 }
James Ketrenos43f66a62005-03-25 12:31:53 -06009565
9566 wstats->qual.qual = priv->quality;
9567 wstats->qual.level = average_value(&priv->average_rssi);
9568 wstats->qual.noise = average_value(&priv->average_noise);
9569 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
Bill Mossb1916082006-02-15 08:50:18 +08009570 IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
James Ketrenos43f66a62005-03-25 12:31:53 -06009571
9572 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9573 wstats->discard.retries = priv->last_tx_failures;
9574 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
Jeff Garzikbf794512005-07-31 13:07:26 -04009575
James Ketrenos43f66a62005-03-25 12:31:53 -06009576/* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9577 goto fail_get_ordinal;
9578 wstats->discard.retries += tx_retry; */
Jeff Garzikbf794512005-07-31 13:07:26 -04009579
James Ketrenos43f66a62005-03-25 12:31:53 -06009580 return wstats;
9581}
9582
James Ketrenos43f66a62005-03-25 12:31:53 -06009583/* net device stuff */
9584
Arjan van de Ven858119e2006-01-14 13:20:43 -08009585static void init_sys_config(struct ipw_sys_config *sys_config)
James Ketrenos43f66a62005-03-25 12:31:53 -06009586{
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009587 memset(sys_config, 0, sizeof(struct ipw_sys_config));
Zhu Yi810dabd2006-01-24 16:36:59 +08009588 sys_config->bt_coexistence = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06009589 sys_config->answer_broadcast_ssid_probe = 0;
9590 sys_config->accept_all_data_frames = 0;
9591 sys_config->accept_non_directed_frames = 1;
9592 sys_config->exclude_unicast_unencrypted = 0;
9593 sys_config->disable_unicast_decryption = 1;
9594 sys_config->exclude_multicast_unencrypted = 0;
9595 sys_config->disable_multicast_decryption = 1;
9596 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009597 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
James Ketrenos43f66a62005-03-25 12:31:53 -06009598 sys_config->dot11g_auto_detection = 0;
Jeff Garzikbf794512005-07-31 13:07:26 -04009599 sys_config->enable_cts_to_self = 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06009600 sys_config->bt_coexist_collision_thr = 0;
James Ketrenosc848d0a2005-08-24 21:56:24 -05009601 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
James Ketrenos43f66a62005-03-25 12:31:53 -06009602}
9603
9604static int ipw_net_open(struct net_device *dev)
9605{
9606 struct ipw_priv *priv = ieee80211_priv(dev);
9607 IPW_DEBUG_INFO("dev->open\n");
9608 /* we should be verifying the device is ready to be opened */
Zhu Yi46441512006-01-24 16:37:59 +08009609 mutex_lock(&priv->mutex);
Jeff Garzikbf794512005-07-31 13:07:26 -04009610 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9611 (priv->status & STATUS_ASSOCIATED))
James Ketrenos43f66a62005-03-25 12:31:53 -06009612 netif_start_queue(dev);
Zhu Yi46441512006-01-24 16:37:59 +08009613 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009614 return 0;
9615}
9616
9617static int ipw_net_stop(struct net_device *dev)
9618{
9619 IPW_DEBUG_INFO("dev->close\n");
9620 netif_stop_queue(dev);
9621 return 0;
9622}
9623
9624/*
9625todo:
9626
9627modify to send one tfd per fragment instead of using chunking. otherwise
9628we need to heavily modify the ieee80211_skb_to_txb.
9629*/
9630
Arjan van de Ven858119e2006-01-14 13:20:43 -08009631static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
James Ketrenos227d2dc2005-07-28 16:25:55 -05009632 int pri)
James Ketrenos43f66a62005-03-25 12:31:53 -06009633{
James Ketrenos0dacca12005-09-21 12:23:41 -05009634 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009635 txb->fragments[0]->data;
James Ketrenos43f66a62005-03-25 12:31:53 -06009636 int i = 0;
9637 struct tfd_frame *tfd;
James Ketrenosb095c382005-08-24 22:04:42 -05009638#ifdef CONFIG_IPW_QOS
9639 int tx_id = ipw_get_tx_queue_number(priv, pri);
9640 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9641#else
James Ketrenos43f66a62005-03-25 12:31:53 -06009642 struct clx2_tx_queue *txq = &priv->txq[0];
James Ketrenosb095c382005-08-24 22:04:42 -05009643#endif
James Ketrenos43f66a62005-03-25 12:31:53 -06009644 struct clx2_queue *q = &txq->q;
9645 u8 id, hdr_len, unicast;
9646 u16 remaining_bytes;
James Ketrenosc848d0a2005-08-24 21:56:24 -05009647 int fc;
James Ketrenos43f66a62005-03-25 12:31:53 -06009648
9649 switch (priv->ieee->iw_mode) {
9650 case IW_MODE_ADHOC:
9651 hdr_len = IEEE80211_3ADDR_LEN;
Stephen Hemminger3c190652006-01-03 15:27:38 -08009652 unicast = !is_multicast_ether_addr(hdr->addr1);
James Ketrenos43f66a62005-03-25 12:31:53 -06009653 id = ipw_find_station(priv, hdr->addr1);
9654 if (id == IPW_INVALID_STATION) {
9655 id = ipw_add_station(priv, hdr->addr1);
9656 if (id == IPW_INVALID_STATION) {
9657 IPW_WARNING("Attempt to send data to "
Jeff Garzikbf794512005-07-31 13:07:26 -04009658 "invalid cell: " MAC_FMT "\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06009659 MAC_ARG(hdr->addr1));
9660 goto drop;
9661 }
9662 }
9663 break;
9664
9665 case IW_MODE_INFRA:
9666 default:
Stephen Hemminger3c190652006-01-03 15:27:38 -08009667 unicast = !is_multicast_ether_addr(hdr->addr3);
James Ketrenos43f66a62005-03-25 12:31:53 -06009668 hdr_len = IEEE80211_3ADDR_LEN;
9669 id = 0;
9670 break;
9671 }
9672
9673 tfd = &txq->bd[q->first_empty];
9674 txq->txb[q->first_empty] = txb;
9675 memset(tfd, 0, sizeof(*tfd));
9676 tfd->u.data.station_number = id;
9677
9678 tfd->control_flags.message_type = TX_FRAME_TYPE;
9679 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9680
9681 tfd->u.data.cmd_id = DINO_CMD_TX;
James Ketrenosa613bff2005-08-24 21:43:11 -05009682 tfd->u.data.len = cpu_to_le16(txb->payload_size);
James Ketrenos43f66a62005-03-25 12:31:53 -06009683 remaining_bytes = txb->payload_size;
Jeff Garzikbf794512005-07-31 13:07:26 -04009684
James Ketrenos43f66a62005-03-25 12:31:53 -06009685 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
James Ketrenosb095c382005-08-24 22:04:42 -05009686 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
James Ketrenos43f66a62005-03-25 12:31:53 -06009687 else
James Ketrenosb095c382005-08-24 22:04:42 -05009688 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
James Ketrenos43f66a62005-03-25 12:31:53 -06009689
James Ketrenosea2b26e2005-08-24 21:25:16 -05009690 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9691 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
James Ketrenos43f66a62005-03-25 12:31:53 -06009692
James Ketrenosc848d0a2005-08-24 21:56:24 -05009693 fc = le16_to_cpu(hdr->frame_ctl);
9694 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
James Ketrenos43f66a62005-03-25 12:31:53 -06009695
9696 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9697
James Ketrenosb095c382005-08-24 22:04:42 -05009698 if (likely(unicast))
9699 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9700
9701 if (txb->encrypted && !priv->ieee->host_encrypt) {
9702 switch (priv->ieee->sec.level) {
9703 case SEC_LEVEL_3:
9704 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9705 IEEE80211_FCTL_PROTECTED;
9706 /* XXX: ACK flag must be set for CCMP even if it
9707 * is a multicast/broadcast packet, because CCMP
9708 * group communication encrypted by GTK is
9709 * actually done by the AP. */
9710 if (!unicast)
9711 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9712
9713 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9714 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9715 tfd->u.data.key_index = 0;
9716 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9717 break;
9718 case SEC_LEVEL_2:
9719 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9720 IEEE80211_FCTL_PROTECTED;
9721 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9722 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9723 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9724 break;
9725 case SEC_LEVEL_1:
9726 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9727 IEEE80211_FCTL_PROTECTED;
9728 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9729 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9730 40)
9731 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9732 else
9733 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9734 break;
9735 case SEC_LEVEL_0:
9736 break;
9737 default:
9738 printk(KERN_ERR "Unknow security level %d\n",
9739 priv->ieee->sec.level);
9740 break;
9741 }
9742 } else
9743 /* No hardware encryption */
9744 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9745
9746#ifdef CONFIG_IPW_QOS
9747 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9748#endif /* CONFIG_IPW_QOS */
9749
James Ketrenos43f66a62005-03-25 12:31:53 -06009750 /* payload */
James Ketrenosa613bff2005-08-24 21:43:11 -05009751 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9752 txb->nr_frags));
9753 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9754 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9755 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9756 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9757 i, le32_to_cpu(tfd->u.data.num_chunks),
9758 txb->fragments[i]->len - hdr_len);
Jeff Garzikbf794512005-07-31 13:07:26 -04009759 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
James Ketrenos43f66a62005-03-25 12:31:53 -06009760 i, tfd->u.data.num_chunks,
9761 txb->fragments[i]->len - hdr_len);
Jeff Garzikbf794512005-07-31 13:07:26 -04009762 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
James Ketrenos43f66a62005-03-25 12:31:53 -06009763 txb->fragments[i]->len - hdr_len);
9764
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009765 tfd->u.data.chunk_ptr[i] =
James Ketrenosa613bff2005-08-24 21:43:11 -05009766 cpu_to_le32(pci_map_single
9767 (priv->pci_dev,
9768 txb->fragments[i]->data + hdr_len,
9769 txb->fragments[i]->len - hdr_len,
9770 PCI_DMA_TODEVICE));
9771 tfd->u.data.chunk_len[i] =
9772 cpu_to_le16(txb->fragments[i]->len - hdr_len);
James Ketrenos43f66a62005-03-25 12:31:53 -06009773 }
9774
9775 if (i != txb->nr_frags) {
9776 struct sk_buff *skb;
9777 u16 remaining_bytes = 0;
9778 int j;
9779
9780 for (j = i; j < txb->nr_frags; j++)
9781 remaining_bytes += txb->fragments[j]->len - hdr_len;
9782
9783 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9784 remaining_bytes);
9785 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9786 if (skb != NULL) {
James Ketrenosa613bff2005-08-24 21:43:11 -05009787 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
James Ketrenos43f66a62005-03-25 12:31:53 -06009788 for (j = i; j < txb->nr_frags; j++) {
9789 int size = txb->fragments[j]->len - hdr_len;
James Ketrenosafbf30a2005-08-25 00:05:33 -05009790
James Ketrenos43f66a62005-03-25 12:31:53 -06009791 printk(KERN_INFO "Adding frag %d %d...\n",
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009792 j, size);
James Ketrenos43f66a62005-03-25 12:31:53 -06009793 memcpy(skb_put(skb, size),
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009794 txb->fragments[j]->data + hdr_len, size);
James Ketrenos43f66a62005-03-25 12:31:53 -06009795 }
9796 dev_kfree_skb_any(txb->fragments[i]);
9797 txb->fragments[i] = skb;
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009798 tfd->u.data.chunk_ptr[i] =
James Ketrenosa613bff2005-08-24 21:43:11 -05009799 cpu_to_le32(pci_map_single
9800 (priv->pci_dev, skb->data,
9801 tfd->u.data.chunk_len[i],
9802 PCI_DMA_TODEVICE));
9803
9804 tfd->u.data.num_chunks =
9805 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9806 1);
Jeff Garzikbf794512005-07-31 13:07:26 -04009807 }
James Ketrenos43f66a62005-03-25 12:31:53 -06009808 }
9809
9810 /* kick DMA */
9811 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9812 ipw_write32(priv, q->reg_w, q->first_empty);
9813
James Ketrenosf6970142006-02-14 09:10:51 +08009814 if (ipw_queue_space(q) < q->high_mark)
9815 netif_stop_queue(priv->net_dev);
9816
James Ketrenos227d2dc2005-07-28 16:25:55 -05009817 return NETDEV_TX_OK;
James Ketrenos43f66a62005-03-25 12:31:53 -06009818
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009819 drop:
James Ketrenos43f66a62005-03-25 12:31:53 -06009820 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9821 ieee80211_txb_free(txb);
James Ketrenos227d2dc2005-07-28 16:25:55 -05009822 return NETDEV_TX_OK;
9823}
9824
9825static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9826{
9827 struct ipw_priv *priv = ieee80211_priv(dev);
9828#ifdef CONFIG_IPW_QOS
9829 int tx_id = ipw_get_tx_queue_number(priv, pri);
9830 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9831#else
9832 struct clx2_tx_queue *txq = &priv->txq[0];
9833#endif /* CONFIG_IPW_QOS */
9834
9835 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9836 return 1;
9837
9838 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -06009839}
9840
9841static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
James Ketrenosc8d42d12005-09-21 12:23:43 -05009842 struct net_device *dev, int pri)
James Ketrenos43f66a62005-03-25 12:31:53 -06009843{
9844 struct ipw_priv *priv = ieee80211_priv(dev);
9845 unsigned long flags;
James Ketrenos227d2dc2005-07-28 16:25:55 -05009846 int ret;
James Ketrenos43f66a62005-03-25 12:31:53 -06009847
9848 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
James Ketrenos43f66a62005-03-25 12:31:53 -06009849 spin_lock_irqsave(&priv->lock, flags);
9850
9851 if (!(priv->status & STATUS_ASSOCIATED)) {
9852 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9853 priv->ieee->stats.tx_carrier_errors++;
9854 netif_stop_queue(dev);
9855 goto fail_unlock;
9856 }
9857
James Ketrenos227d2dc2005-07-28 16:25:55 -05009858 ret = ipw_tx_skb(priv, txb, pri);
9859 if (ret == NETDEV_TX_OK)
9860 __ipw_led_activity_on(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -06009861 spin_unlock_irqrestore(&priv->lock, flags);
James Ketrenos43f66a62005-03-25 12:31:53 -06009862
James Ketrenos227d2dc2005-07-28 16:25:55 -05009863 return ret;
James Ketrenos43f66a62005-03-25 12:31:53 -06009864
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009865 fail_unlock:
James Ketrenos43f66a62005-03-25 12:31:53 -06009866 spin_unlock_irqrestore(&priv->lock, flags);
9867 return 1;
9868}
9869
9870static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9871{
9872 struct ipw_priv *priv = ieee80211_priv(dev);
Jeff Garzikbf794512005-07-31 13:07:26 -04009873
James Ketrenos43f66a62005-03-25 12:31:53 -06009874 priv->ieee->stats.tx_packets = priv->tx_packets;
9875 priv->ieee->stats.rx_packets = priv->rx_packets;
9876 return &priv->ieee->stats;
9877}
9878
9879static void ipw_net_set_multicast_list(struct net_device *dev)
9880{
9881
9882}
9883
9884static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9885{
9886 struct ipw_priv *priv = ieee80211_priv(dev);
9887 struct sockaddr *addr = p;
9888 if (!is_valid_ether_addr(addr->sa_data))
9889 return -EADDRNOTAVAIL;
Zhu Yi46441512006-01-24 16:37:59 +08009890 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009891 priv->config |= CFG_CUSTOM_MAC;
9892 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9893 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9894 priv->net_dev->name, MAC_ARG(priv->mac_addr));
James Ketrenosa613bff2005-08-24 21:43:11 -05009895 queue_work(priv->workqueue, &priv->adapter_restart);
Zhu Yi46441512006-01-24 16:37:59 +08009896 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009897 return 0;
9898}
9899
Jeff Garzikbf794512005-07-31 13:07:26 -04009900static void ipw_ethtool_get_drvinfo(struct net_device *dev,
James Ketrenos43f66a62005-03-25 12:31:53 -06009901 struct ethtool_drvinfo *info)
9902{
9903 struct ipw_priv *p = ieee80211_priv(dev);
9904 char vers[64];
9905 char date[32];
9906 u32 len;
9907
9908 strcpy(info->driver, DRV_NAME);
9909 strcpy(info->version, DRV_VERSION);
9910
9911 len = sizeof(vers);
9912 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9913 len = sizeof(date);
9914 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9915
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009916 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
James Ketrenos43f66a62005-03-25 12:31:53 -06009917 vers, date);
9918 strcpy(info->bus_info, pci_name(p->pci_dev));
James Ketrenosb095c382005-08-24 22:04:42 -05009919 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
James Ketrenos43f66a62005-03-25 12:31:53 -06009920}
9921
9922static u32 ipw_ethtool_get_link(struct net_device *dev)
9923{
9924 struct ipw_priv *priv = ieee80211_priv(dev);
9925 return (priv->status & STATUS_ASSOCIATED) != 0;
9926}
9927
9928static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9929{
James Ketrenosb095c382005-08-24 22:04:42 -05009930 return IPW_EEPROM_IMAGE_SIZE;
James Ketrenos43f66a62005-03-25 12:31:53 -06009931}
9932
9933static int ipw_ethtool_get_eeprom(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009934 struct ethtool_eeprom *eeprom, u8 * bytes)
James Ketrenos43f66a62005-03-25 12:31:53 -06009935{
9936 struct ipw_priv *p = ieee80211_priv(dev);
9937
James Ketrenosb095c382005-08-24 22:04:42 -05009938 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
James Ketrenos43f66a62005-03-25 12:31:53 -06009939 return -EINVAL;
Zhu Yi46441512006-01-24 16:37:59 +08009940 mutex_lock(&p->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05009941 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
Zhu Yi46441512006-01-24 16:37:59 +08009942 mutex_unlock(&p->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009943 return 0;
9944}
9945
9946static int ipw_ethtool_set_eeprom(struct net_device *dev,
Jeff Garzik0edd5b42005-09-07 00:48:31 -04009947 struct ethtool_eeprom *eeprom, u8 * bytes)
James Ketrenos43f66a62005-03-25 12:31:53 -06009948{
9949 struct ipw_priv *p = ieee80211_priv(dev);
9950 int i;
9951
James Ketrenosb095c382005-08-24 22:04:42 -05009952 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
James Ketrenos43f66a62005-03-25 12:31:53 -06009953 return -EINVAL;
Zhu Yi46441512006-01-24 16:37:59 +08009954 mutex_lock(&p->mutex);
James Ketrenosafbf30a2005-08-25 00:05:33 -05009955 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
Jeff Garzikbf794512005-07-31 13:07:26 -04009956 for (i = IPW_EEPROM_DATA;
James Ketrenosb095c382005-08-24 22:04:42 -05009957 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
James Ketrenos43f66a62005-03-25 12:31:53 -06009958 ipw_write8(p, i, p->eeprom[i]);
Zhu Yi46441512006-01-24 16:37:59 +08009959 mutex_unlock(&p->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -06009960 return 0;
9961}
9962
9963static struct ethtool_ops ipw_ethtool_ops = {
James Ketrenosea2b26e2005-08-24 21:25:16 -05009964 .get_link = ipw_ethtool_get_link,
9965 .get_drvinfo = ipw_ethtool_get_drvinfo,
9966 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9967 .get_eeprom = ipw_ethtool_get_eeprom,
9968 .set_eeprom = ipw_ethtool_set_eeprom,
James Ketrenos43f66a62005-03-25 12:31:53 -06009969};
9970
9971static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9972{
9973 struct ipw_priv *priv = data;
9974 u32 inta, inta_mask;
Jeff Garzikbf794512005-07-31 13:07:26 -04009975
James Ketrenos43f66a62005-03-25 12:31:53 -06009976 if (!priv)
9977 return IRQ_NONE;
9978
9979 spin_lock(&priv->lock);
9980
9981 if (!(priv->status & STATUS_INT_ENABLED)) {
9982 /* Shared IRQ */
9983 goto none;
9984 }
9985
James Ketrenosb095c382005-08-24 22:04:42 -05009986 inta = ipw_read32(priv, IPW_INTA_RW);
9987 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
Jeff Garzikbf794512005-07-31 13:07:26 -04009988
James Ketrenos43f66a62005-03-25 12:31:53 -06009989 if (inta == 0xFFFFFFFF) {
9990 /* Hardware disappeared */
9991 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
9992 goto none;
9993 }
9994
James Ketrenosb095c382005-08-24 22:04:42 -05009995 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
James Ketrenos43f66a62005-03-25 12:31:53 -06009996 /* Shared interrupt */
9997 goto none;
9998 }
9999
10000 /* tell the device to stop sending interrupts */
10001 ipw_disable_interrupts(priv);
Jeff Garzikbf794512005-07-31 13:07:26 -040010002
James Ketrenos43f66a62005-03-25 12:31:53 -060010003 /* ack current interrupts */
James Ketrenosb095c382005-08-24 22:04:42 -050010004 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10005 ipw_write32(priv, IPW_INTA_RW, inta);
Jeff Garzikbf794512005-07-31 13:07:26 -040010006
James Ketrenos43f66a62005-03-25 12:31:53 -060010007 /* Cache INTA value for our tasklet */
10008 priv->isr_inta = inta;
10009
10010 tasklet_schedule(&priv->irq_tasklet);
10011
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010012 spin_unlock(&priv->lock);
James Ketrenos43f66a62005-03-25 12:31:53 -060010013
10014 return IRQ_HANDLED;
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010015 none:
James Ketrenos43f66a62005-03-25 12:31:53 -060010016 spin_unlock(&priv->lock);
10017 return IRQ_NONE;
10018}
10019
10020static void ipw_rf_kill(void *adapter)
10021{
10022 struct ipw_priv *priv = adapter;
10023 unsigned long flags;
Jeff Garzikbf794512005-07-31 13:07:26 -040010024
James Ketrenos43f66a62005-03-25 12:31:53 -060010025 spin_lock_irqsave(&priv->lock, flags);
10026
10027 if (rf_kill_active(priv)) {
10028 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10029 if (priv->workqueue)
10030 queue_delayed_work(priv->workqueue,
10031 &priv->rf_kill, 2 * HZ);
10032 goto exit_unlock;
10033 }
10034
10035 /* RF Kill is now disabled, so bring the device back up */
10036
10037 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10038 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10039 "device\n");
10040
10041 /* we can not do an adapter restart while inside an irq lock */
10042 queue_work(priv->workqueue, &priv->adapter_restart);
Jeff Garzikbf794512005-07-31 13:07:26 -040010043 } else
James Ketrenos43f66a62005-03-25 12:31:53 -060010044 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10045 "enabled\n");
10046
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010047 exit_unlock:
James Ketrenos43f66a62005-03-25 12:31:53 -060010048 spin_unlock_irqrestore(&priv->lock, flags);
10049}
10050
James Ketrenosc848d0a2005-08-24 21:56:24 -050010051static void ipw_bg_rf_kill(void *data)
10052{
10053 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +080010054 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010055 ipw_rf_kill(data);
Zhu Yi46441512006-01-24 16:37:59 +080010056 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010057}
10058
Adrian Bunka73e22b2006-01-21 01:39:42 +010010059static void ipw_link_up(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -050010060{
James Ketrenosafbf30a2005-08-25 00:05:33 -050010061 priv->last_seq_num = -1;
10062 priv->last_frag_num = -1;
10063 priv->last_packet_time = 0;
10064
James Ketrenosa613bff2005-08-24 21:43:11 -050010065 netif_carrier_on(priv->net_dev);
10066 if (netif_queue_stopped(priv->net_dev)) {
10067 IPW_DEBUG_NOTIF("waking queue\n");
10068 netif_wake_queue(priv->net_dev);
10069 } else {
10070 IPW_DEBUG_NOTIF("starting queue\n");
10071 netif_start_queue(priv->net_dev);
10072 }
10073
James Ketrenosc848d0a2005-08-24 21:56:24 -050010074 cancel_delayed_work(&priv->request_scan);
James Ketrenosa613bff2005-08-24 21:43:11 -050010075 ipw_reset_stats(priv);
10076 /* Ensure the rate is updated immediately */
10077 priv->last_rate = ipw_get_current_rate(priv);
10078 ipw_gather_stats(priv);
10079 ipw_led_link_up(priv);
10080 notify_wx_assoc_event(priv);
10081
10082 if (priv->config & CFG_BACKGROUND_SCAN)
10083 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10084}
10085
James Ketrenosc848d0a2005-08-24 21:56:24 -050010086static void ipw_bg_link_up(void *data)
10087{
10088 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +080010089 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010090 ipw_link_up(data);
Zhu Yi46441512006-01-24 16:37:59 +080010091 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010092}
10093
Adrian Bunka73e22b2006-01-21 01:39:42 +010010094static void ipw_link_down(struct ipw_priv *priv)
James Ketrenosa613bff2005-08-24 21:43:11 -050010095{
10096 ipw_led_link_down(priv);
10097 netif_carrier_off(priv->net_dev);
10098 netif_stop_queue(priv->net_dev);
10099 notify_wx_assoc_event(priv);
10100
10101 /* Cancel any queued work ... */
10102 cancel_delayed_work(&priv->request_scan);
10103 cancel_delayed_work(&priv->adhoc_check);
10104 cancel_delayed_work(&priv->gather_stats);
10105
10106 ipw_reset_stats(priv);
10107
James Ketrenosafbf30a2005-08-25 00:05:33 -050010108 if (!(priv->status & STATUS_EXIT_PENDING)) {
10109 /* Queue up another scan... */
10110 queue_work(priv->workqueue, &priv->request_scan);
10111 }
James Ketrenosa613bff2005-08-24 21:43:11 -050010112}
10113
James Ketrenosc848d0a2005-08-24 21:56:24 -050010114static void ipw_bg_link_down(void *data)
10115{
10116 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +080010117 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010118 ipw_link_down(data);
Zhu Yi46441512006-01-24 16:37:59 +080010119 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010120}
10121
James Ketrenos43f66a62005-03-25 12:31:53 -060010122static int ipw_setup_deferred_work(struct ipw_priv *priv)
10123{
10124 int ret = 0;
10125
James Ketrenos43f66a62005-03-25 12:31:53 -060010126 priv->workqueue = create_workqueue(DRV_NAME);
James Ketrenos43f66a62005-03-25 12:31:53 -060010127 init_waitqueue_head(&priv->wait_command_queue);
James Ketrenosafbf30a2005-08-25 00:05:33 -050010128 init_waitqueue_head(&priv->wait_state);
James Ketrenos43f66a62005-03-25 12:31:53 -060010129
James Ketrenosc848d0a2005-08-24 21:56:24 -050010130 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10131 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10132 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
Zhu Yid8bad6d2005-07-13 12:25:38 -050010133 INIT_WORK(&priv->system_config, ipw_system_config, priv);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010134 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10135 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10136 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10137 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10138 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
Jeff Garzikbf794512005-07-31 13:07:26 -040010139 INIT_WORK(&priv->request_scan,
James Ketrenos43f66a62005-03-25 12:31:53 -060010140 (void (*)(void *))ipw_request_scan, priv);
Jeff Garzikbf794512005-07-31 13:07:26 -040010141 INIT_WORK(&priv->gather_stats,
James Ketrenosc848d0a2005-08-24 21:56:24 -050010142 (void (*)(void *))ipw_bg_gather_stats, priv);
10143 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10144 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10145 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10146 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10147 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10148 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
James Ketrenosa613bff2005-08-24 21:43:11 -050010149 priv);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010150 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
James Ketrenosa613bff2005-08-24 21:43:11 -050010151 priv);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010152 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10153 priv);
10154 INIT_WORK(&priv->merge_networks,
10155 (void (*)(void *))ipw_merge_adhoc_network, priv);
James Ketrenos43f66a62005-03-25 12:31:53 -060010156
James Ketrenosb095c382005-08-24 22:04:42 -050010157#ifdef CONFIG_IPW_QOS
10158 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10159 priv);
10160#endif /* CONFIG_IPW_QOS */
James Ketrenos43f66a62005-03-25 12:31:53 -060010161
10162 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10163 ipw_irq_tasklet, (unsigned long)priv);
10164
10165 return ret;
10166}
10167
James Ketrenos43f66a62005-03-25 12:31:53 -060010168static void shim__set_security(struct net_device *dev,
10169 struct ieee80211_security *sec)
10170{
10171 struct ipw_priv *priv = ieee80211_priv(dev);
10172 int i;
Jeff Garzikbf794512005-07-31 13:07:26 -040010173 for (i = 0; i < 4; i++) {
James Ketrenos43f66a62005-03-25 12:31:53 -060010174 if (sec->flags & (1 << i)) {
James Ketrenosafbf30a2005-08-25 00:05:33 -050010175 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
James Ketrenosb095c382005-08-24 22:04:42 -050010176 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
James Ketrenos43f66a62005-03-25 12:31:53 -060010177 if (sec->key_sizes[i] == 0)
James Ketrenosb095c382005-08-24 22:04:42 -050010178 priv->ieee->sec.flags &= ~(1 << i);
10179 else {
10180 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
James Ketrenos43f66a62005-03-25 12:31:53 -060010181 sec->key_sizes[i]);
James Ketrenosb095c382005-08-24 22:04:42 -050010182 priv->ieee->sec.flags |= (1 << i);
10183 }
James Ketrenos43f66a62005-03-25 12:31:53 -060010184 priv->status |= STATUS_SECURITY_UPDATED;
James Ketrenosb095c382005-08-24 22:04:42 -050010185 } else if (sec->level != SEC_LEVEL_1)
10186 priv->ieee->sec.flags &= ~(1 << i);
James Ketrenos43f66a62005-03-25 12:31:53 -060010187 }
10188
James Ketrenosb095c382005-08-24 22:04:42 -050010189 if (sec->flags & SEC_ACTIVE_KEY) {
James Ketrenos43f66a62005-03-25 12:31:53 -060010190 if (sec->active_key <= 3) {
James Ketrenosb095c382005-08-24 22:04:42 -050010191 priv->ieee->sec.active_key = sec->active_key;
10192 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
Jeff Garzikbf794512005-07-31 13:07:26 -040010193 } else
James Ketrenosb095c382005-08-24 22:04:42 -050010194 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
James Ketrenos43f66a62005-03-25 12:31:53 -060010195 priv->status |= STATUS_SECURITY_UPDATED;
James Ketrenosb095c382005-08-24 22:04:42 -050010196 } else
10197 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
James Ketrenos43f66a62005-03-25 12:31:53 -060010198
10199 if ((sec->flags & SEC_AUTH_MODE) &&
James Ketrenosb095c382005-08-24 22:04:42 -050010200 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10201 priv->ieee->sec.auth_mode = sec->auth_mode;
10202 priv->ieee->sec.flags |= SEC_AUTH_MODE;
James Ketrenos43f66a62005-03-25 12:31:53 -060010203 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10204 priv->capability |= CAP_SHARED_KEY;
10205 else
10206 priv->capability &= ~CAP_SHARED_KEY;
10207 priv->status |= STATUS_SECURITY_UPDATED;
10208 }
Jeff Garzikbf794512005-07-31 13:07:26 -040010209
James Ketrenosb095c382005-08-24 22:04:42 -050010210 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10211 priv->ieee->sec.flags |= SEC_ENABLED;
10212 priv->ieee->sec.enabled = sec->enabled;
James Ketrenos43f66a62005-03-25 12:31:53 -060010213 priv->status |= STATUS_SECURITY_UPDATED;
Jeff Garzikbf794512005-07-31 13:07:26 -040010214 if (sec->enabled)
James Ketrenos43f66a62005-03-25 12:31:53 -060010215 priv->capability |= CAP_PRIVACY_ON;
10216 else
10217 priv->capability &= ~CAP_PRIVACY_ON;
10218 }
Jeff Garzikbf794512005-07-31 13:07:26 -040010219
James Ketrenosafbf30a2005-08-25 00:05:33 -050010220 if (sec->flags & SEC_ENCRYPT)
10221 priv->ieee->sec.encrypt = sec->encrypt;
James Ketrenos43f66a62005-03-25 12:31:53 -060010222
James Ketrenosb095c382005-08-24 22:04:42 -050010223 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10224 priv->ieee->sec.level = sec->level;
10225 priv->ieee->sec.flags |= SEC_LEVEL;
James Ketrenos43f66a62005-03-25 12:31:53 -060010226 priv->status |= STATUS_SECURITY_UPDATED;
10227 }
10228
Zhu Yi1fbfea52005-08-05 17:22:56 +080010229 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10230 ipw_set_hwcrypto_keys(priv);
10231
Jeff Garzikbf794512005-07-31 13:07:26 -040010232 /* To match current functionality of ipw2100 (which works well w/
10233 * various supplicants, we don't force a disassociate if the
James Ketrenos43f66a62005-03-25 12:31:53 -060010234 * privacy capability changes ... */
10235#if 0
10236 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
Jeff Garzikbf794512005-07-31 13:07:26 -040010237 (((priv->assoc_request.capability &
James Ketrenos43f66a62005-03-25 12:31:53 -060010238 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
Jeff Garzikbf794512005-07-31 13:07:26 -040010239 (!(priv->assoc_request.capability &
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010240 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
James Ketrenos43f66a62005-03-25 12:31:53 -060010241 IPW_DEBUG_ASSOC("Disassociating due to capability "
10242 "change.\n");
10243 ipw_disassociate(priv);
10244 }
10245#endif
10246}
10247
Jeff Garzikbf794512005-07-31 13:07:26 -040010248static int init_supported_rates(struct ipw_priv *priv,
James Ketrenos43f66a62005-03-25 12:31:53 -060010249 struct ipw_supported_rates *rates)
10250{
10251 /* TODO: Mask out rates based on priv->rates_mask */
10252
10253 memset(rates, 0, sizeof(*rates));
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010254 /* configure supported rates */
James Ketrenos43f66a62005-03-25 12:31:53 -060010255 switch (priv->ieee->freq_band) {
10256 case IEEE80211_52GHZ_BAND:
10257 rates->ieee_mode = IPW_A_MODE;
10258 rates->purpose = IPW_RATE_CAPABILITIES;
10259 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10260 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10261 break;
10262
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010263 default: /* Mixed or 2.4Ghz */
James Ketrenos43f66a62005-03-25 12:31:53 -060010264 rates->ieee_mode = IPW_G_MODE;
10265 rates->purpose = IPW_RATE_CAPABILITIES;
10266 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10267 IEEE80211_CCK_DEFAULT_RATES_MASK);
10268 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10269 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10270 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10271 }
10272 break;
10273 }
10274
10275 return 0;
10276}
10277
Jeff Garzikbf794512005-07-31 13:07:26 -040010278static int ipw_config(struct ipw_priv *priv)
James Ketrenos43f66a62005-03-25 12:31:53 -060010279{
James Ketrenos43f66a62005-03-25 12:31:53 -060010280 /* This is only called from ipw_up, which resets/reloads the firmware
10281 so, we don't need to first disable the card before we configure
10282 it */
Zhu Yi6de9f7f2005-08-11 14:39:33 +080010283 if (ipw_set_tx_power(priv))
James Ketrenos43f66a62005-03-25 12:31:53 -060010284 goto error;
10285
10286 /* initialize adapter address */
10287 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10288 goto error;
10289
10290 /* set basic system config settings */
10291 init_sys_config(&priv->sys_config);
Zhu Yi810dabd2006-01-24 16:36:59 +080010292
10293 /* Support Bluetooth if we have BT h/w on board, and user wants to.
10294 * Does not support BT priority yet (don't abort or defer our Tx) */
10295 if (bt_coexist) {
Zhu Yi2638bc32006-01-24 16:37:52 +080010296 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
Zhu Yi810dabd2006-01-24 16:36:59 +080010297
10298 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10299 priv->sys_config.bt_coexistence
Zhu Yi2638bc32006-01-24 16:37:52 +080010300 |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
Zhu Yi810dabd2006-01-24 16:36:59 +080010301 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10302 priv->sys_config.bt_coexistence
Zhu Yi2638bc32006-01-24 16:37:52 +080010303 |= CFG_BT_COEXISTENCE_OOB;
Zhu Yi810dabd2006-01-24 16:36:59 +080010304 }
10305
James Ketrenosc848d0a2005-08-24 21:56:24 -050010306 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10307 priv->sys_config.answer_broadcast_ssid_probe = 1;
10308 else
10309 priv->sys_config.answer_broadcast_ssid_probe = 0;
10310
James Ketrenos43f66a62005-03-25 12:31:53 -060010311 if (ipw_send_system_config(priv, &priv->sys_config))
10312 goto error;
10313
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010314 init_supported_rates(priv, &priv->rates);
10315 if (ipw_send_supported_rates(priv, &priv->rates))
James Ketrenos43f66a62005-03-25 12:31:53 -060010316 goto error;
10317
10318 /* Set request-to-send threshold */
10319 if (priv->rts_threshold) {
10320 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10321 goto error;
10322 }
James Ketrenosb095c382005-08-24 22:04:42 -050010323#ifdef CONFIG_IPW_QOS
10324 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10325 ipw_qos_activate(priv, NULL);
10326#endif /* CONFIG_IPW_QOS */
James Ketrenos43f66a62005-03-25 12:31:53 -060010327
10328 if (ipw_set_random_seed(priv))
10329 goto error;
Jeff Garzikbf794512005-07-31 13:07:26 -040010330
James Ketrenos43f66a62005-03-25 12:31:53 -060010331 /* final state transition to the RUN state */
10332 if (ipw_send_host_complete(priv))
10333 goto error;
10334
James Ketrenose6666192005-08-12 09:17:04 -050010335 priv->status |= STATUS_INIT;
10336
10337 ipw_led_init(priv);
10338 ipw_led_radio_on(priv);
10339 priv->notif_missed_beacons = 0;
10340
10341 /* Set hardware WEP key if it is configured. */
10342 if ((priv->capability & CAP_PRIVACY_ON) &&
10343 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10344 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10345 ipw_set_hwcrypto_keys(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -060010346
10347 return 0;
Jeff Garzikbf794512005-07-31 13:07:26 -040010348
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010349 error:
James Ketrenos43f66a62005-03-25 12:31:53 -060010350 return -EIO;
10351}
10352
James Ketrenos4f36f802005-08-03 20:36:56 -050010353/*
10354 * NOTE:
10355 *
10356 * These tables have been tested in conjunction with the
10357 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10358 *
10359 * Altering this values, using it on other hardware, or in geographies
10360 * not intended for resale of the above mentioned Intel adapters has
10361 * not been tested.
10362 *
Henrik Brix Andersen48a84772006-02-14 09:09:52 +080010363 * Remember to update the table in README.ipw2200 when changing this
10364 * table.
10365 *
James Ketrenos4f36f802005-08-03 20:36:56 -050010366 */
10367static const struct ieee80211_geo ipw_geos[] = {
10368 { /* Restricted */
10369 "---",
10370 .bg_channels = 11,
10371 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10372 {2427, 4}, {2432, 5}, {2437, 6},
10373 {2442, 7}, {2447, 8}, {2452, 9},
10374 {2457, 10}, {2462, 11}},
10375 },
10376
10377 { /* Custom US/Canada */
10378 "ZZF",
10379 .bg_channels = 11,
10380 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10381 {2427, 4}, {2432, 5}, {2437, 6},
10382 {2442, 7}, {2447, 8}, {2452, 9},
10383 {2457, 10}, {2462, 11}},
10384 .a_channels = 8,
10385 .a = {{5180, 36},
10386 {5200, 40},
10387 {5220, 44},
10388 {5240, 48},
10389 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10390 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10391 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10392 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10393 },
10394
10395 { /* Rest of World */
10396 "ZZD",
10397 .bg_channels = 13,
10398 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10399 {2427, 4}, {2432, 5}, {2437, 6},
10400 {2442, 7}, {2447, 8}, {2452, 9},
10401 {2457, 10}, {2462, 11}, {2467, 12},
10402 {2472, 13}},
10403 },
10404
10405 { /* Custom USA & Europe & High */
10406 "ZZA",
10407 .bg_channels = 11,
10408 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10409 {2427, 4}, {2432, 5}, {2437, 6},
10410 {2442, 7}, {2447, 8}, {2452, 9},
10411 {2457, 10}, {2462, 11}},
10412 .a_channels = 13,
10413 .a = {{5180, 36},
10414 {5200, 40},
10415 {5220, 44},
10416 {5240, 48},
10417 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10418 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10419 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10420 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10421 {5745, 149},
10422 {5765, 153},
10423 {5785, 157},
10424 {5805, 161},
10425 {5825, 165}},
10426 },
10427
10428 { /* Custom NA & Europe */
10429 "ZZB",
10430 .bg_channels = 11,
10431 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10432 {2427, 4}, {2432, 5}, {2437, 6},
10433 {2442, 7}, {2447, 8}, {2452, 9},
10434 {2457, 10}, {2462, 11}},
10435 .a_channels = 13,
10436 .a = {{5180, 36},
10437 {5200, 40},
10438 {5220, 44},
10439 {5240, 48},
10440 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10441 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10442 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10443 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10444 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10445 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10446 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10447 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10448 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10449 },
10450
10451 { /* Custom Japan */
10452 "ZZC",
10453 .bg_channels = 11,
10454 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10455 {2427, 4}, {2432, 5}, {2437, 6},
10456 {2442, 7}, {2447, 8}, {2452, 9},
10457 {2457, 10}, {2462, 11}},
10458 .a_channels = 4,
10459 .a = {{5170, 34}, {5190, 38},
10460 {5210, 42}, {5230, 46}},
10461 },
10462
10463 { /* Custom */
10464 "ZZM",
10465 .bg_channels = 11,
10466 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10467 {2427, 4}, {2432, 5}, {2437, 6},
10468 {2442, 7}, {2447, 8}, {2452, 9},
10469 {2457, 10}, {2462, 11}},
10470 },
10471
10472 { /* Europe */
10473 "ZZE",
10474 .bg_channels = 13,
10475 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10476 {2427, 4}, {2432, 5}, {2437, 6},
10477 {2442, 7}, {2447, 8}, {2452, 9},
10478 {2457, 10}, {2462, 11}, {2467, 12},
10479 {2472, 13}},
10480 .a_channels = 19,
10481 .a = {{5180, 36},
10482 {5200, 40},
10483 {5220, 44},
10484 {5240, 48},
10485 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10486 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10487 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10488 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10489 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10490 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10491 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10492 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10493 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10494 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10495 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10496 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10497 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10498 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10499 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10500 },
10501
10502 { /* Custom Japan */
10503 "ZZJ",
10504 .bg_channels = 14,
10505 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10506 {2427, 4}, {2432, 5}, {2437, 6},
10507 {2442, 7}, {2447, 8}, {2452, 9},
10508 {2457, 10}, {2462, 11}, {2467, 12},
10509 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10510 .a_channels = 4,
10511 .a = {{5170, 34}, {5190, 38},
10512 {5210, 42}, {5230, 46}},
10513 },
10514
James Ketrenos03520572005-10-19 16:12:31 -050010515 { /* Rest of World */
10516 "ZZR",
10517 .bg_channels = 14,
10518 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10519 {2427, 4}, {2432, 5}, {2437, 6},
10520 {2442, 7}, {2447, 8}, {2452, 9},
10521 {2457, 10}, {2462, 11}, {2467, 12},
10522 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10523 IEEE80211_CH_PASSIVE_ONLY}},
10524 },
10525
James Ketrenos4f36f802005-08-03 20:36:56 -050010526 { /* High Band */
10527 "ZZH",
10528 .bg_channels = 13,
10529 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10530 {2427, 4}, {2432, 5}, {2437, 6},
10531 {2442, 7}, {2447, 8}, {2452, 9},
10532 {2457, 10}, {2462, 11},
10533 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10534 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10535 .a_channels = 4,
10536 .a = {{5745, 149}, {5765, 153},
10537 {5785, 157}, {5805, 161}},
10538 },
10539
10540 { /* Custom Europe */
10541 "ZZG",
10542 .bg_channels = 13,
10543 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10544 {2427, 4}, {2432, 5}, {2437, 6},
10545 {2442, 7}, {2447, 8}, {2452, 9},
10546 {2457, 10}, {2462, 11},
10547 {2467, 12}, {2472, 13}},
10548 .a_channels = 4,
10549 .a = {{5180, 36}, {5200, 40},
10550 {5220, 44}, {5240, 48}},
10551 },
10552
10553 { /* Europe */
10554 "ZZK",
10555 .bg_channels = 13,
10556 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10557 {2427, 4}, {2432, 5}, {2437, 6},
10558 {2442, 7}, {2447, 8}, {2452, 9},
10559 {2457, 10}, {2462, 11},
10560 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10561 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10562 .a_channels = 24,
10563 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10564 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10565 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10566 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10567 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10568 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10569 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10570 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10571 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10572 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10573 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10574 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10575 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10576 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10577 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10578 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10579 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10580 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10581 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10582 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10583 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10584 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10585 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10586 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10587 },
10588
10589 { /* Europe */
10590 "ZZL",
10591 .bg_channels = 11,
10592 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10593 {2427, 4}, {2432, 5}, {2437, 6},
10594 {2442, 7}, {2447, 8}, {2452, 9},
10595 {2457, 10}, {2462, 11}},
10596 .a_channels = 13,
10597 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10598 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10599 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10600 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10601 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10602 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10603 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10604 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10605 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10606 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10607 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10608 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10609 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10610 }
James Ketrenosafbf30a2005-08-25 00:05:33 -050010611};
10612
James Ketrenos43f66a62005-03-25 12:31:53 -060010613#define MAX_HW_RESTARTS 5
10614static int ipw_up(struct ipw_priv *priv)
10615{
James Ketrenos4f36f802005-08-03 20:36:56 -050010616 int rc, i, j;
James Ketrenos43f66a62005-03-25 12:31:53 -060010617
10618 if (priv->status & STATUS_EXIT_PENDING)
10619 return -EIO;
10620
James Ketrenosf6c5cb72005-08-25 00:39:09 -050010621 if (cmdlog && !priv->cmdlog) {
10622 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10623 GFP_KERNEL);
10624 if (priv->cmdlog == NULL) {
10625 IPW_ERROR("Error allocating %d command log entries.\n",
10626 cmdlog);
10627 } else {
10628 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10629 priv->cmdlog_len = cmdlog;
10630 }
10631 }
10632
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010633 for (i = 0; i < MAX_HW_RESTARTS; i++) {
Jeff Garzikbf794512005-07-31 13:07:26 -040010634 /* Load the microcode, firmware, and eeprom.
James Ketrenos43f66a62005-03-25 12:31:53 -060010635 * Also start the clocks. */
10636 rc = ipw_load(priv);
10637 if (rc) {
Peter Jonesa4f6bbb2005-08-26 00:33:34 -050010638 IPW_ERROR("Unable to load firmware: %d\n", rc);
James Ketrenos43f66a62005-03-25 12:31:53 -060010639 return rc;
10640 }
10641
10642 ipw_init_ordinals(priv);
10643 if (!(priv->config & CFG_CUSTOM_MAC))
10644 eeprom_parse_mac(priv, priv->mac_addr);
10645 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10646
James Ketrenos4f36f802005-08-03 20:36:56 -050010647 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10648 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10649 ipw_geos[j].name, 3))
10650 break;
10651 }
James Ketrenos03520572005-10-19 16:12:31 -050010652 if (j == ARRAY_SIZE(ipw_geos)) {
10653 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10654 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10655 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10656 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
James Ketrenos4f36f802005-08-03 20:36:56 -050010657 j = 0;
James Ketrenos03520572005-10-19 16:12:31 -050010658 }
Larry Finger1867b112006-02-28 09:48:28 -060010659 if (ieee80211_set_geo(priv->ieee, &ipw_geos[j])) {
James Ketrenos4f36f802005-08-03 20:36:56 -050010660 IPW_WARNING("Could not set geography.");
James Ketrenos43f66a62005-03-25 12:31:53 -060010661 return 0;
James Ketrenos4f36f802005-08-03 20:36:56 -050010662 }
10663
James Ketrenosb095c382005-08-24 22:04:42 -050010664 if (priv->status & STATUS_RF_KILL_SW) {
10665 IPW_WARNING("Radio disabled by module parameter.\n");
10666 return 0;
10667 } else if (rf_kill_active(priv)) {
10668 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10669 "Kill switch must be turned off for "
10670 "wireless networking to work.\n");
10671 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10672 2 * HZ);
James Ketrenos43f66a62005-03-25 12:31:53 -060010673 return 0;
James Ketrenosc848d0a2005-08-24 21:56:24 -050010674 }
James Ketrenos43f66a62005-03-25 12:31:53 -060010675
10676 rc = ipw_config(priv);
10677 if (!rc) {
10678 IPW_DEBUG_INFO("Configured device on count %i\n", i);
James Ketrenosafbf30a2005-08-25 00:05:33 -050010679
James Ketrenose6666192005-08-12 09:17:04 -050010680 /* If configure to try and auto-associate, kick
10681 * off a scan. */
10682 queue_work(priv->workqueue, &priv->request_scan);
James Ketrenosafbf30a2005-08-25 00:05:33 -050010683
James Ketrenos43f66a62005-03-25 12:31:53 -060010684 return 0;
James Ketrenos43f66a62005-03-25 12:31:53 -060010685 }
Jeff Garzikbf794512005-07-31 13:07:26 -040010686
James Ketrenosc848d0a2005-08-24 21:56:24 -050010687 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
James Ketrenos43f66a62005-03-25 12:31:53 -060010688 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10689 i, MAX_HW_RESTARTS);
10690
10691 /* We had an error bringing up the hardware, so take it
10692 * all the way back down so we can try again */
10693 ipw_down(priv);
10694 }
10695
Jeff Garzikbf794512005-07-31 13:07:26 -040010696 /* tried to restart and config the device for as long as our
James Ketrenos43f66a62005-03-25 12:31:53 -060010697 * patience could withstand */
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010698 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010699
James Ketrenos43f66a62005-03-25 12:31:53 -060010700 return -EIO;
10701}
10702
James Ketrenosc848d0a2005-08-24 21:56:24 -050010703static void ipw_bg_up(void *data)
10704{
10705 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +080010706 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010707 ipw_up(data);
Zhu Yi46441512006-01-24 16:37:59 +080010708 mutex_unlock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010709}
10710
James Ketrenosb095c382005-08-24 22:04:42 -050010711static void ipw_deinit(struct ipw_priv *priv)
James Ketrenos43f66a62005-03-25 12:31:53 -060010712{
James Ketrenosb095c382005-08-24 22:04:42 -050010713 int i;
10714
10715 if (priv->status & STATUS_SCANNING) {
10716 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10717 ipw_abort_scan(priv);
10718 }
10719
10720 if (priv->status & STATUS_ASSOCIATED) {
10721 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10722 ipw_disassociate(priv);
10723 }
10724
10725 ipw_led_shutdown(priv);
10726
10727 /* Wait up to 1s for status to change to not scanning and not
10728 * associated (disassociation can take a while for a ful 802.11
10729 * exchange */
10730 for (i = 1000; i && (priv->status &
10731 (STATUS_DISASSOCIATING |
10732 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10733 udelay(10);
10734
10735 if (priv->status & (STATUS_DISASSOCIATING |
10736 STATUS_ASSOCIATED | STATUS_SCANNING))
10737 IPW_DEBUG_INFO("Still associated or scanning...\n");
10738 else
10739 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10740
James Ketrenosc848d0a2005-08-24 21:56:24 -050010741 /* Attempt to disable the card */
James Ketrenos43f66a62005-03-25 12:31:53 -060010742 ipw_send_card_disable(priv, 0);
James Ketrenosb095c382005-08-24 22:04:42 -050010743
10744 priv->status &= ~STATUS_INIT;
10745}
10746
James Ketrenos43f66a62005-03-25 12:31:53 -060010747static void ipw_down(struct ipw_priv *priv)
10748{
James Ketrenosb095c382005-08-24 22:04:42 -050010749 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10750
10751 priv->status |= STATUS_EXIT_PENDING;
10752
10753 if (ipw_is_init(priv))
10754 ipw_deinit(priv);
10755
10756 /* Wipe out the EXIT_PENDING status bit if we are not actually
10757 * exiting the module */
10758 if (!exit_pending)
10759 priv->status &= ~STATUS_EXIT_PENDING;
James Ketrenos43f66a62005-03-25 12:31:53 -060010760
10761 /* tell the device to stop sending interrupts */
10762 ipw_disable_interrupts(priv);
10763
10764 /* Clear all bits but the RF Kill */
James Ketrenosb095c382005-08-24 22:04:42 -050010765 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
James Ketrenos43f66a62005-03-25 12:31:53 -060010766 netif_carrier_off(priv->net_dev);
10767 netif_stop_queue(priv->net_dev);
10768
10769 ipw_stop_nic(priv);
James Ketrenosa613bff2005-08-24 21:43:11 -050010770
10771 ipw_led_radio_off(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -060010772}
10773
James Ketrenosc848d0a2005-08-24 21:56:24 -050010774static void ipw_bg_down(void *data)
10775{
10776 struct ipw_priv *priv = data;
Zhu Yi46441512006-01-24 16:37:59 +080010777 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010778 ipw_down(data);
Zhu Yi46441512006-01-24 16:37:59 +080010779 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060010780}
10781
10782/* Called by register_netdev() */
10783static int ipw_net_init(struct net_device *dev)
10784{
10785 struct ipw_priv *priv = ieee80211_priv(dev);
Zhu Yi46441512006-01-24 16:37:59 +080010786 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060010787
James Ketrenosc848d0a2005-08-24 21:56:24 -050010788 if (ipw_up(priv)) {
Zhu Yi46441512006-01-24 16:37:59 +080010789 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060010790 return -EIO;
James Ketrenos43f66a62005-03-25 12:31:53 -060010791 }
10792
Zhu Yi46441512006-01-24 16:37:59 +080010793 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060010794 return 0;
10795}
10796
10797/* PCI driver stuff */
10798static struct pci_device_id card_ids[] = {
10799 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10800 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10801 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10802 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10803 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10804 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10805 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10806 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10807 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10808 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10809 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10810 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10811 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10812 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10813 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10814 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10815 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10816 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010817 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
James Ketrenosa613bff2005-08-24 21:43:11 -050010818 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010819 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10820 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
Jeff Garzikbf794512005-07-31 13:07:26 -040010821
James Ketrenos43f66a62005-03-25 12:31:53 -060010822 /* required last entry */
10823 {0,}
10824};
10825
10826MODULE_DEVICE_TABLE(pci, card_ids);
10827
10828static struct attribute *ipw_sysfs_entries[] = {
10829 &dev_attr_rf_kill.attr,
10830 &dev_attr_direct_dword.attr,
10831 &dev_attr_indirect_byte.attr,
10832 &dev_attr_indirect_dword.attr,
10833 &dev_attr_mem_gpio_reg.attr,
10834 &dev_attr_command_event_reg.attr,
10835 &dev_attr_nic_type.attr,
10836 &dev_attr_status.attr,
10837 &dev_attr_cfg.attr,
James Ketrenosb39860c2005-08-12 09:36:32 -050010838 &dev_attr_error.attr,
10839 &dev_attr_event_log.attr,
James Ketrenosf6c5cb72005-08-25 00:39:09 -050010840 &dev_attr_cmd_log.attr,
James Ketrenos43f66a62005-03-25 12:31:53 -060010841 &dev_attr_eeprom_delay.attr,
10842 &dev_attr_ucode_version.attr,
10843 &dev_attr_rtc.attr,
James Ketrenosa613bff2005-08-24 21:43:11 -050010844 &dev_attr_scan_age.attr,
10845 &dev_attr_led.attr,
James Ketrenosb095c382005-08-24 22:04:42 -050010846 &dev_attr_speed_scan.attr,
10847 &dev_attr_net_stats.attr,
James Ketrenos43f66a62005-03-25 12:31:53 -060010848 NULL
10849};
10850
10851static struct attribute_group ipw_attribute_group = {
10852 .name = NULL, /* put in device directory */
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010853 .attrs = ipw_sysfs_entries,
James Ketrenos43f66a62005-03-25 12:31:53 -060010854};
10855
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010856static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
James Ketrenos43f66a62005-03-25 12:31:53 -060010857{
10858 int err = 0;
10859 struct net_device *net_dev;
10860 void __iomem *base;
10861 u32 length, val;
10862 struct ipw_priv *priv;
James Ketrenosafbf30a2005-08-25 00:05:33 -050010863 int i;
James Ketrenos43f66a62005-03-25 12:31:53 -060010864
10865 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10866 if (net_dev == NULL) {
10867 err = -ENOMEM;
10868 goto out;
10869 }
10870
10871 priv = ieee80211_priv(net_dev);
10872 priv->ieee = netdev_priv(net_dev);
James Ketrenosa613bff2005-08-24 21:43:11 -050010873
James Ketrenos43f66a62005-03-25 12:31:53 -060010874 priv->net_dev = net_dev;
10875 priv->pci_dev = pdev;
Brice Goglin0f52bf92005-12-01 01:41:46 -080010876#ifdef CONFIG_IPW2200_DEBUG
James Ketrenos43f66a62005-03-25 12:31:53 -060010877 ipw_debug_level = debug;
10878#endif
10879 spin_lock_init(&priv->lock);
James Ketrenosafbf30a2005-08-25 00:05:33 -050010880 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10881 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
James Ketrenos43f66a62005-03-25 12:31:53 -060010882
Zhu Yi46441512006-01-24 16:37:59 +080010883 mutex_init(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060010884 if (pci_enable_device(pdev)) {
10885 err = -ENODEV;
10886 goto out_free_ieee80211;
10887 }
10888
10889 pci_set_master(pdev);
10890
Tobias Klauser0e08b442005-06-20 14:28:41 -070010891 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
Jeff Garzikbf794512005-07-31 13:07:26 -040010892 if (!err)
Tobias Klauser0e08b442005-06-20 14:28:41 -070010893 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
James Ketrenos43f66a62005-03-25 12:31:53 -060010894 if (err) {
10895 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10896 goto out_pci_disable_device;
10897 }
10898
10899 pci_set_drvdata(pdev, priv);
10900
10901 err = pci_request_regions(pdev, DRV_NAME);
Jeff Garzikbf794512005-07-31 13:07:26 -040010902 if (err)
James Ketrenos43f66a62005-03-25 12:31:53 -060010903 goto out_pci_disable_device;
10904
Jeff Garzikbf794512005-07-31 13:07:26 -040010905 /* We disable the RETRY_TIMEOUT register (0x41) to keep
James Ketrenos43f66a62005-03-25 12:31:53 -060010906 * PCI Tx retries from interfering with C3 CPU state */
Jeff Garzikbf794512005-07-31 13:07:26 -040010907 pci_read_config_dword(pdev, 0x40, &val);
10908 if ((val & 0x0000ff00) != 0)
James Ketrenos43f66a62005-03-25 12:31:53 -060010909 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
Jeff Garzikbf794512005-07-31 13:07:26 -040010910
James Ketrenos43f66a62005-03-25 12:31:53 -060010911 length = pci_resource_len(pdev, 0);
10912 priv->hw_len = length;
Jeff Garzikbf794512005-07-31 13:07:26 -040010913
James Ketrenos43f66a62005-03-25 12:31:53 -060010914 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10915 if (!base) {
10916 err = -ENODEV;
10917 goto out_pci_release_regions;
10918 }
10919
10920 priv->hw_base = base;
10921 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
10922 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
10923
10924 err = ipw_setup_deferred_work(priv);
10925 if (err) {
10926 IPW_ERROR("Unable to setup deferred work\n");
10927 goto out_iounmap;
10928 }
10929
James Ketrenosb095c382005-08-24 22:04:42 -050010930 ipw_sw_reset(priv, 1);
James Ketrenos43f66a62005-03-25 12:31:53 -060010931
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010932 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
James Ketrenos43f66a62005-03-25 12:31:53 -060010933 if (err) {
10934 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
10935 goto out_destroy_workqueue;
10936 }
10937
10938 SET_MODULE_OWNER(net_dev);
10939 SET_NETDEV_DEV(net_dev, &pdev->dev);
10940
Zhu Yi46441512006-01-24 16:37:59 +080010941 mutex_lock(&priv->mutex);
James Ketrenosc848d0a2005-08-24 21:56:24 -050010942
James Ketrenos43f66a62005-03-25 12:31:53 -060010943 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
10944 priv->ieee->set_security = shim__set_security;
James Ketrenos227d2dc2005-07-28 16:25:55 -050010945 priv->ieee->is_queue_full = ipw_net_is_queue_full;
James Ketrenos43f66a62005-03-25 12:31:53 -060010946
James Ketrenosb095c382005-08-24 22:04:42 -050010947#ifdef CONFIG_IPW_QOS
James Ketrenos3b9990c2005-08-19 13:18:55 -050010948 priv->ieee->handle_probe_response = ipw_handle_beacon;
10949 priv->ieee->handle_beacon = ipw_handle_probe_response;
10950 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
James Ketrenosb095c382005-08-24 22:04:42 -050010951#endif /* CONFIG_IPW_QOS */
10952
James Ketrenosc848d0a2005-08-24 21:56:24 -050010953 priv->ieee->perfect_rssi = -20;
10954 priv->ieee->worst_rssi = -85;
James Ketrenos43f66a62005-03-25 12:31:53 -060010955
10956 net_dev->open = ipw_net_open;
10957 net_dev->stop = ipw_net_stop;
10958 net_dev->init = ipw_net_init;
10959 net_dev->get_stats = ipw_net_get_stats;
10960 net_dev->set_multicast_list = ipw_net_set_multicast_list;
10961 net_dev->set_mac_address = ipw_net_set_mac_address;
Benoit Boissinot97a78ca2005-09-15 17:30:28 +000010962 priv->wireless_data.spy_data = &priv->ieee->spy_data;
Benoit Boissinot97a78ca2005-09-15 17:30:28 +000010963 net_dev->wireless_data = &priv->wireless_data;
James Ketrenos43f66a62005-03-25 12:31:53 -060010964 net_dev->wireless_handlers = &ipw_wx_handler_def;
10965 net_dev->ethtool_ops = &ipw_ethtool_ops;
10966 net_dev->irq = pdev->irq;
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010967 net_dev->base_addr = (unsigned long)priv->hw_base;
James Ketrenos43f66a62005-03-25 12:31:53 -060010968 net_dev->mem_start = pci_resource_start(pdev, 0);
10969 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
10970
10971 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
10972 if (err) {
10973 IPW_ERROR("failed to create sysfs device attributes\n");
Zhu Yi46441512006-01-24 16:37:59 +080010974 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060010975 goto out_release_irq;
10976 }
10977
Zhu Yi46441512006-01-24 16:37:59 +080010978 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060010979 err = register_netdev(net_dev);
10980 if (err) {
10981 IPW_ERROR("failed to register network device\n");
James Ketrenosa613bff2005-08-24 21:43:11 -050010982 goto out_remove_sysfs;
James Ketrenos43f66a62005-03-25 12:31:53 -060010983 }
Henrik Brix Andersen48a84772006-02-14 09:09:52 +080010984
10985 printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
10986 "channels, %d 802.11a channels)\n",
10987 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
10988 priv->ieee->geo.a_channels);
10989
James Ketrenos43f66a62005-03-25 12:31:53 -060010990 return 0;
10991
James Ketrenosa613bff2005-08-24 21:43:11 -050010992 out_remove_sysfs:
James Ketrenos43f66a62005-03-25 12:31:53 -060010993 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010994 out_release_irq:
James Ketrenos43f66a62005-03-25 12:31:53 -060010995 free_irq(pdev->irq, priv);
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010996 out_destroy_workqueue:
James Ketrenos43f66a62005-03-25 12:31:53 -060010997 destroy_workqueue(priv->workqueue);
10998 priv->workqueue = NULL;
Jeff Garzik0edd5b42005-09-07 00:48:31 -040010999 out_iounmap:
James Ketrenos43f66a62005-03-25 12:31:53 -060011000 iounmap(priv->hw_base);
Jeff Garzik0edd5b42005-09-07 00:48:31 -040011001 out_pci_release_regions:
James Ketrenos43f66a62005-03-25 12:31:53 -060011002 pci_release_regions(pdev);
Jeff Garzik0edd5b42005-09-07 00:48:31 -040011003 out_pci_disable_device:
James Ketrenos43f66a62005-03-25 12:31:53 -060011004 pci_disable_device(pdev);
11005 pci_set_drvdata(pdev, NULL);
Jeff Garzik0edd5b42005-09-07 00:48:31 -040011006 out_free_ieee80211:
James Ketrenos43f66a62005-03-25 12:31:53 -060011007 free_ieee80211(priv->net_dev);
Jeff Garzik0edd5b42005-09-07 00:48:31 -040011008 out:
James Ketrenos43f66a62005-03-25 12:31:53 -060011009 return err;
11010}
11011
11012static void ipw_pci_remove(struct pci_dev *pdev)
11013{
11014 struct ipw_priv *priv = pci_get_drvdata(pdev);
James Ketrenosafbf30a2005-08-25 00:05:33 -050011015 struct list_head *p, *q;
11016 int i;
James Ketrenosb095c382005-08-24 22:04:42 -050011017
James Ketrenos43f66a62005-03-25 12:31:53 -060011018 if (!priv)
11019 return;
11020
Zhu Yi46441512006-01-24 16:37:59 +080011021 mutex_lock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060011022
James Ketrenosafbf30a2005-08-25 00:05:33 -050011023 priv->status |= STATUS_EXIT_PENDING;
James Ketrenos43f66a62005-03-25 12:31:53 -060011024 ipw_down(priv);
James Ketrenos43f66a62005-03-25 12:31:53 -060011025 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11026
Zhu Yi46441512006-01-24 16:37:59 +080011027 mutex_unlock(&priv->mutex);
James Ketrenos43f66a62005-03-25 12:31:53 -060011028
11029 unregister_netdev(priv->net_dev);
11030
11031 if (priv->rxq) {
11032 ipw_rx_queue_free(priv, priv->rxq);
11033 priv->rxq = NULL;
11034 }
11035 ipw_tx_queue_free(priv);
11036
James Ketrenosf6c5cb72005-08-25 00:39:09 -050011037 if (priv->cmdlog) {
11038 kfree(priv->cmdlog);
11039 priv->cmdlog = NULL;
11040 }
James Ketrenos43f66a62005-03-25 12:31:53 -060011041 /* ipw_down will ensure that there is no more pending work
11042 * in the workqueue's, so we can safely remove them now. */
James Ketrenosa613bff2005-08-24 21:43:11 -050011043 cancel_delayed_work(&priv->adhoc_check);
11044 cancel_delayed_work(&priv->gather_stats);
11045 cancel_delayed_work(&priv->request_scan);
11046 cancel_delayed_work(&priv->rf_kill);
11047 cancel_delayed_work(&priv->scan_check);
11048 destroy_workqueue(priv->workqueue);
11049 priv->workqueue = NULL;
James Ketrenos43f66a62005-03-25 12:31:53 -060011050
James Ketrenosafbf30a2005-08-25 00:05:33 -050011051 /* Free MAC hash list for ADHOC */
11052 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11053 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
James Ketrenosafbf30a2005-08-25 00:05:33 -050011054 list_del(p);
Zhu Yi489f4452006-01-24 16:37:41 +080011055 kfree(list_entry(p, struct ipw_ibss_seq, list));
James Ketrenosafbf30a2005-08-25 00:05:33 -050011056 }
11057 }
11058
James Ketrenosb39860c2005-08-12 09:36:32 -050011059 if (priv->error) {
11060 ipw_free_error_log(priv->error);
11061 priv->error = NULL;
James Ketrenos43f66a62005-03-25 12:31:53 -060011062 }
11063
11064 free_irq(pdev->irq, priv);
11065 iounmap(priv->hw_base);
11066 pci_release_regions(pdev);
11067 pci_disable_device(pdev);
11068 pci_set_drvdata(pdev, NULL);
11069 free_ieee80211(priv->net_dev);
James Ketrenosafbf30a2005-08-25 00:05:33 -050011070 free_firmware();
James Ketrenos43f66a62005-03-25 12:31:53 -060011071}
11072
James Ketrenos43f66a62005-03-25 12:31:53 -060011073#ifdef CONFIG_PM
Pavel Machek583a4e82005-09-03 15:56:58 -070011074static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
James Ketrenos43f66a62005-03-25 12:31:53 -060011075{
11076 struct ipw_priv *priv = pci_get_drvdata(pdev);
11077 struct net_device *dev = priv->net_dev;
11078
11079 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11080
Jeff Garzik0edd5b42005-09-07 00:48:31 -040011081 /* Take down the device; powers it off, etc. */
James Ketrenos43f66a62005-03-25 12:31:53 -060011082 ipw_down(priv);
11083
11084 /* Remove the PRESENT state of the device */
11085 netif_device_detach(dev);
11086
James Ketrenos43f66a62005-03-25 12:31:53 -060011087 pci_save_state(pdev);
James Ketrenos43f66a62005-03-25 12:31:53 -060011088 pci_disable_device(pdev);
Pavel Machek583a4e82005-09-03 15:56:58 -070011089 pci_set_power_state(pdev, pci_choose_state(pdev, state));
Jeff Garzikbf794512005-07-31 13:07:26 -040011090
James Ketrenos43f66a62005-03-25 12:31:53 -060011091 return 0;
11092}
11093
11094static int ipw_pci_resume(struct pci_dev *pdev)
11095{
11096 struct ipw_priv *priv = pci_get_drvdata(pdev);
11097 struct net_device *dev = priv->net_dev;
11098 u32 val;
Jeff Garzikbf794512005-07-31 13:07:26 -040011099
James Ketrenos43f66a62005-03-25 12:31:53 -060011100 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11101
James Ketrenosea2b26e2005-08-24 21:25:16 -050011102 pci_set_power_state(pdev, PCI_D0);
James Ketrenos43f66a62005-03-25 12:31:53 -060011103 pci_enable_device(pdev);
James Ketrenos43f66a62005-03-25 12:31:53 -060011104 pci_restore_state(pdev);
James Ketrenosea2b26e2005-08-24 21:25:16 -050011105
James Ketrenos43f66a62005-03-25 12:31:53 -060011106 /*
11107 * Suspend/Resume resets the PCI configuration space, so we have to
11108 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11109 * from interfering with C3 CPU state. pci_restore_state won't help
11110 * here since it only restores the first 64 bytes pci config header.
11111 */
Jeff Garzikbf794512005-07-31 13:07:26 -040011112 pci_read_config_dword(pdev, 0x40, &val);
11113 if ((val & 0x0000ff00) != 0)
James Ketrenos43f66a62005-03-25 12:31:53 -060011114 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11115
11116 /* Set the device back into the PRESENT state; this will also wake
11117 * the queue of needed */
11118 netif_device_attach(dev);
11119
11120 /* Bring the device back up */
11121 queue_work(priv->workqueue, &priv->up);
Jeff Garzikbf794512005-07-31 13:07:26 -040011122
James Ketrenos43f66a62005-03-25 12:31:53 -060011123 return 0;
11124}
11125#endif
11126
11127/* driver initialization stuff */
11128static struct pci_driver ipw_driver = {
11129 .name = DRV_NAME,
11130 .id_table = card_ids,
11131 .probe = ipw_pci_probe,
11132 .remove = __devexit_p(ipw_pci_remove),
11133#ifdef CONFIG_PM
11134 .suspend = ipw_pci_suspend,
11135 .resume = ipw_pci_resume,
11136#endif
11137};
11138
11139static int __init ipw_init(void)
11140{
11141 int ret;
11142
11143 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11144 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11145
11146 ret = pci_module_init(&ipw_driver);
11147 if (ret) {
11148 IPW_ERROR("Unable to initialize PCI module\n");
11149 return ret;
11150 }
11151
Jeff Garzik0edd5b42005-09-07 00:48:31 -040011152 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
James Ketrenos43f66a62005-03-25 12:31:53 -060011153 if (ret) {
11154 IPW_ERROR("Unable to create driver sysfs file\n");
11155 pci_unregister_driver(&ipw_driver);
11156 return ret;
11157 }
11158
11159 return ret;
11160}
11161
11162static void __exit ipw_exit(void)
11163{
11164 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11165 pci_unregister_driver(&ipw_driver);
11166}
11167
11168module_param(disable, int, 0444);
11169MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11170
11171module_param(associate, int, 0444);
11172MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11173
11174module_param(auto_create, int, 0444);
11175MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11176
James Ketrenosa613bff2005-08-24 21:43:11 -050011177module_param(led, int, 0444);
James Ketrenosc848d0a2005-08-24 21:56:24 -050011178MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
James Ketrenosa613bff2005-08-24 21:43:11 -050011179
James Ketrenos43f66a62005-03-25 12:31:53 -060011180module_param(debug, int, 0444);
11181MODULE_PARM_DESC(debug, "debug output mask");
11182
11183module_param(channel, int, 0444);
Jeff Garzikbf794512005-07-31 13:07:26 -040011184MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
James Ketrenos43f66a62005-03-25 12:31:53 -060011185
James Ketrenosb095c382005-08-24 22:04:42 -050011186#ifdef CONFIG_IPW_QOS
11187module_param(qos_enable, int, 0444);
11188MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
James Ketrenos43f66a62005-03-25 12:31:53 -060011189
James Ketrenosb095c382005-08-24 22:04:42 -050011190module_param(qos_burst_enable, int, 0444);
11191MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11192
11193module_param(qos_no_ack_mask, int, 0444);
11194MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11195
11196module_param(burst_duration_CCK, int, 0444);
11197MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11198
11199module_param(burst_duration_OFDM, int, 0444);
11200MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11201#endif /* CONFIG_IPW_QOS */
11202
11203#ifdef CONFIG_IPW2200_MONITOR
James Ketrenos43f66a62005-03-25 12:31:53 -060011204module_param(mode, int, 0444);
11205MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11206#else
11207module_param(mode, int, 0444);
11208MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11209#endif
11210
Zhu Yi810dabd2006-01-24 16:36:59 +080011211module_param(bt_coexist, int, 0444);
11212MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
11213
James Ketrenosb095c382005-08-24 22:04:42 -050011214module_param(hwcrypto, int, 0444);
Zhu Yibde37d02006-01-24 16:38:08 +080011215MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
James Ketrenosb095c382005-08-24 22:04:42 -050011216
James Ketrenosf6c5cb72005-08-25 00:39:09 -050011217module_param(cmdlog, int, 0444);
11218MODULE_PARM_DESC(cmdlog,
11219 "allocate a ring buffer for logging firmware commands");
11220
Zhu Yi4bfdb912006-01-24 16:37:16 +080011221module_param(roaming, int, 0444);
11222MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
11223
James Ketrenos43f66a62005-03-25 12:31:53 -060011224module_exit(ipw_exit);
11225module_init(ipw_init);