]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blame - drivers/net/wireless/ipw2200.c
projects / mirror_ubuntu-eoan-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] Duplicate IPW_DEBUG option for ipw2100 and 2200
[mirror_ubuntu-eoan-kernel.git] / drivers / net / wireless / ipw2200.c
CommitLineData
43f66a6c 1/******************************************************************************
bf79451e 2
afbf30a2 3 Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
43f66a6c
JK		 4
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
bf79451e
JG		 11 This program is free software; you can redistribute it and/or modify it
12 under the terms of version 2 of the GNU General Public License as
43f66a6c 13 published by the Free Software Foundation.
bf79451e
JG		 14
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
43f66a6c 18 more details.
bf79451e 19
43f66a6c 20 You should have received a copy of the GNU General Public License along with
bf79451e 21 this program; if not, write to the Free Software Foundation, Inc., 59
43f66a6c 22 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
bf79451e 23
43f66a6c
JK		 24 The full GNU General Public License is included in this distribution in the
25 file called LICENSE.
bf79451e 26
43f66a6c
JK		 27 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"
733482e4 34#include <linux/version.h>
43f66a6c 35
cf1b479b 36#define IPW2200_VERSION "git-1.0.8"
43f66a6c 37#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
2b184d5b 38#define DRV_COPYRIGHT "Copyright(c) 2003-2005 Intel Corporation"
43f66a6c
JK		 39#define DRV_VERSION IPW2200_VERSION
40
b095c381
JK		 41#define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
42
43f66a6c
JK		 43MODULE_DESCRIPTION(DRV_DESCRIPTION);
44MODULE_VERSION(DRV_VERSION);
45MODULE_AUTHOR(DRV_COPYRIGHT);
46MODULE_LICENSE("GPL");
47
f6c5cb7c 48static int cmdlog = 0;
43f66a6c
JK		 49static int debug = 0;
50static int channel = 0;
43f66a6c
JK		 51static int mode = 0;
52
53static u32 ipw_debug_level;
54static int associate = 1;
55static int auto_create = 1;
a613bffd 56static int led = 0;
43f66a6c 57static int disable = 0;
b095c381 58static int hwcrypto = 1;
43f66a6c
JK		 59static const char ipw_modes[] = {
60 'a', 'b', 'g', '?'
61};
62
b095c381
JK		 63#ifdef CONFIG_IPW_QOS
64static int qos_enable = 0;
65static int qos_burst_enable = 0;
66static int qos_no_ack_mask = 0;
67static int burst_duration_CCK = 0;
68static int burst_duration_OFDM = 0;
69
70static struct ieee80211_qos_parameters def_qos_parameters_OFDM = {
71 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
72 QOS_TX3_CW_MIN_OFDM},
73 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
74 QOS_TX3_CW_MAX_OFDM},
75 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
76 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
77 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
78 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
79};
80
81static struct ieee80211_qos_parameters def_qos_parameters_CCK = {
82 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
83 QOS_TX3_CW_MIN_CCK},
84 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
85 QOS_TX3_CW_MAX_CCK},
86 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
87 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
88 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
89 QOS_TX3_TXOP_LIMIT_CCK}
90};
91
92static struct ieee80211_qos_parameters def_parameters_OFDM = {
93 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
94 DEF_TX3_CW_MIN_OFDM},
95 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
96 DEF_TX3_CW_MAX_OFDM},
97 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
98 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
99 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
100 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
101};
102
103static struct ieee80211_qos_parameters def_parameters_CCK = {
104 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
105 DEF_TX3_CW_MIN_CCK},
106 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
107 DEF_TX3_CW_MAX_CCK},
108 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
109 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
110 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
111 DEF_TX3_TXOP_LIMIT_CCK}
112};
113
114static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
115
116static int from_priority_to_tx_queue[] = {
117 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
118 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
119};
120
121static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
122
123static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
124 *qos_param);
125static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
126 *qos_param);
127#endif /* CONFIG_IPW_QOS */
128
97a78ca9 129static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
b095c381 130static void ipw_remove_current_network(struct ipw_priv *priv);
43f66a6c 131static void ipw_rx(struct ipw_priv *priv);
bf79451e 132static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
43f66a6c
JK		 133 struct clx2_tx_queue *txq, int qindex);
134static int ipw_queue_reset(struct ipw_priv *priv);
135
136static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
137 int len, int sync);
138
139static void ipw_tx_queue_free(struct ipw_priv *);
140
141static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
142static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
143static void ipw_rx_queue_replenish(void *);
43f66a6c 144static int ipw_up(struct ipw_priv *);
c848d0af 145static void ipw_bg_up(void *);
43f66a6c 146static void ipw_down(struct ipw_priv *);
c848d0af 147static void ipw_bg_down(void *);
43f66a6c 148static int ipw_config(struct ipw_priv *);
0edd5b44
JG		 149static int init_supported_rates(struct ipw_priv *priv,
150 struct ipw_supported_rates *prates);
b095c381
JK		 151static void ipw_set_hwcrypto_keys(struct ipw_priv *);
152static void ipw_send_wep_keys(struct ipw_priv *, int);
43f66a6c 153
1fe0adb4
LH		 154static int ipw_is_valid_channel(struct ieee80211_device *, u8);
155static int ipw_channel_to_index(struct ieee80211_device *, u8);
156static u8 ipw_freq_to_channel(struct ieee80211_device *, u32);
157static int ipw_set_geo(struct ieee80211_device *, const struct ieee80211_geo *);
158static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *);
43f66a6c 159
f6c5cb7c
JK		 160static int snprint_line(char *buf, size_t count,
161 const u8 * data, u32 len, u32 ofs)
43f66a6c
JK		 162{
163 int out, i, j, l;
164 char c;
bf79451e 165
43f66a6c
JK		 166 out = snprintf(buf, count, "%08X", ofs);
167
168 for (l = 0, i = 0; i < 2; i++) {
169 out += snprintf(buf + out, count - out, " ");
bf79451e
JG		 170 for (j = 0; j < 8 && l < len; j++, l++)
171 out += snprintf(buf + out, count - out, "%02X ",
43f66a6c
JK		 172 data[(i * 8 + j)]);
173 for (; j < 8; j++)
174 out += snprintf(buf + out, count - out, " ");
175 }
bf79451e 176
43f66a6c
JK		 177 out += snprintf(buf + out, count - out, " ");
178 for (l = 0, i = 0; i < 2; i++) {
179 out += snprintf(buf + out, count - out, " ");
180 for (j = 0; j < 8 && l < len; j++, l++) {
181 c = data[(i * 8 + j)];
182 if (!isascii(c) || !isprint(c))
183 c = '.';
bf79451e 184
43f66a6c
JK		 185 out += snprintf(buf + out, count - out, "%c", c);
186 }
187
188 for (; j < 8; j++)
189 out += snprintf(buf + out, count - out, " ");
190 }
bf79451e 191
f6c5cb7c 192 return out;
43f66a6c
JK		 193}
194
0edd5b44 195static void printk_buf(int level, const u8 * data, u32 len)
43f66a6c
JK		 196{
197 char line[81];
198 u32 ofs = 0;
199 if (!(ipw_debug_level & level))
200 return;
201
202 while (len) {
f6c5cb7c
JK		 203 snprint_line(line, sizeof(line), &data[ofs],
204 min(len, 16U), ofs);
205 printk(KERN_DEBUG "%s\n", line);
43f66a6c
JK		 206 ofs += 16;
207 len -= min(len, 16U);
208 }
209}
210
f6c5cb7c
JK		 211static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
212{
213 size_t out = size;
214 u32 ofs = 0;
215 int total = 0;
216
217 while (size && len) {
218 out = snprint_line(output, size, &data[ofs],
219 min_t(size_t, len, 16U), ofs);
220
221 ofs += 16;
222 output += out;
223 size -= out;
224 len -= min_t(size_t, len, 16U);
225 total += out;
226 }
227 return total;
228}
229
43f66a6c
JK		 230static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
231#define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
232
233static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
234#define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
235
236static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
237static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
238{
0edd5b44
JG		 239 IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
240 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 241 _ipw_write_reg8(a, b, c);
242}
243
244static 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{
0edd5b44
JG		 247 IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
248 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 249 _ipw_write_reg16(a, b, c);
250}
251
252static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
253static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
254{
0edd5b44
JG		 255 IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
256 __LINE__, (u32) (b), (u32) (c));
43f66a6c
JK		 257 _ipw_write_reg32(a, b, c);
258}
259
260#define _ipw_write8(ipw, ofs, val) writeb((val), (ipw)->hw_base + (ofs))
261#define ipw_write8(ipw, ofs, val) \
262 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
263 _ipw_write8(ipw, ofs, val)
264
265#define _ipw_write16(ipw, ofs, val) writew((val), (ipw)->hw_base + (ofs))
266#define ipw_write16(ipw, ofs, val) \
267 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
268 _ipw_write16(ipw, ofs, val)
269
270#define _ipw_write32(ipw, ofs, val) writel((val), (ipw)->hw_base + (ofs))
271#define ipw_write32(ipw, ofs, val) \
272 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
273 _ipw_write32(ipw, ofs, val)
274
275#define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
0edd5b44
JG		 276static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
277{
278 IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
43f66a6c
JK		 279 return _ipw_read8(ipw, ofs);
280}
0edd5b44 281
43f66a6c
JK		 282#define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)
283
284#define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
0edd5b44
JG		 285static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
286{
287 IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
43f66a6c
JK		 288 return _ipw_read16(ipw, ofs);
289}
0edd5b44 290
43f66a6c
JK		 291#define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)
292
293#define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
0edd5b44
JG		 294static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
295{
296 IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
43f66a6c
JK		 297 return _ipw_read32(ipw, ofs);
298}
0edd5b44 299
43f66a6c
JK		 300#define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
301
302static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
f6c5cb7c
JK		 303static inline void __ipw_read_indirect(const char *f, int l,
304 struct ipw_priv *a, u32 b, u8 * c, int d)
305{
306 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
307 d);
308 _ipw_read_indirect(a, b, c, d);
309}
310
311#define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
43f66a6c 312
0edd5b44
JG		 313static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
314 int num);
43f66a6c
JK		 315#define ipw_write_indirect(a, b, c, d) \
316 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
afbf30a2 317 _ipw_write_indirect(a, b, c, d)
43f66a6c
JK		 318
319/* indirect write s */
0edd5b44 320static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
43f66a6c 321{
0edd5b44 322 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
b095c381
JK		 323 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
324 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
43f66a6c
JK		 325}
326
43f66a6c
JK		 327static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
328{
329 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
b095c381
JK		 330 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
331 _ipw_write8(priv, IPW_INDIRECT_DATA, value);
43f66a6c
JK		 332}
333
0edd5b44 334static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
43f66a6c
JK		 335{
336 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
b095c381
JK		 337 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
338 _ipw_write16(priv, IPW_INDIRECT_DATA, value);
43f66a6c
JK		 339}
340
341/* indirect read s */
342
343static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
344{
345 u32 word;
b095c381 346 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
43f66a6c 347 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
b095c381 348 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
0edd5b44 349 return (word >> ((reg & 0x3) * 8)) & 0xff;
43f66a6c
JK		 350}
351
352static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
353{
354 u32 value;
355
356 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
357
b095c381
JK		 358 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
359 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
43f66a6c
JK		 360 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
361 return value;
362}
363
364/* iterative/auto-increment 32 bit reads and writes */
365static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
366 int num)
367{
b095c381 368 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
43f66a6c 369 u32 dif_len = addr - aligned_addr;
43f66a6c 370 u32 i;
bf79451e 371
43f66a6c
JK		 372 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
373
ea2b26e0
JK		 374 if (num <= 0) {
375 return;
376 }
377
43f66a6c
JK		 378 /* Read the first nibble byte by byte */
379 if (unlikely(dif_len)) {
b095c381 380 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
43f66a6c 381 /* Start reading at aligned_addr + dif_len */
ea2b26e0 382 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
b095c381 383 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
43f66a6c
JK		 384 aligned_addr += 4;
385 }
386
b095c381 387 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
ea2b26e0 388 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
b095c381 389 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
bf79451e 390
43f66a6c 391 /* Copy the last nibble */
ea2b26e0 392 if (unlikely(num)) {
b095c381 393 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0 394 for (i = 0; num > 0; i++, num--)
b095c381 395 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
ea2b26e0 396 }
43f66a6c
JK		 397}
398
0edd5b44 399static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
43f66a6c
JK		 400 int num)
401{
b095c381 402 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
43f66a6c 403 u32 dif_len = addr - aligned_addr;
43f66a6c 404 u32 i;
bf79451e 405
43f66a6c 406 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
bf79451e 407
ea2b26e0
JK		 408 if (num <= 0) {
409 return;
410 }
411
43f66a6c
JK		 412 /* Write the first nibble byte by byte */
413 if (unlikely(dif_len)) {
b095c381 414 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0
JK		 415 /* Start reading at aligned_addr + dif_len */
416 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
b095c381 417 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
43f66a6c
JK		 418 aligned_addr += 4;
419 }
bf79451e 420
b095c381 421 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
ea2b26e0 422 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
b095c381 423 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
bf79451e 424
43f66a6c 425 /* Copy the last nibble */
ea2b26e0 426 if (unlikely(num)) {
b095c381 427 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
ea2b26e0 428 for (i = 0; num > 0; i++, num--, buf++)
b095c381 429 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
ea2b26e0 430 }
43f66a6c
JK		 431}
432
bf79451e 433static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
43f66a6c
JK		 434 int num)
435{
436 memcpy_toio((priv->hw_base + addr), buf, num);
437}
438
439static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
440{
441 ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
442}
443
444static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
445{
446 ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
447}
448
449static inline void ipw_enable_interrupts(struct ipw_priv *priv)
450{
451 if (priv->status & STATUS_INT_ENABLED)
452 return;
453 priv->status |= STATUS_INT_ENABLED;
b095c381 454 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
43f66a6c
JK		 455}
456
457static inline void ipw_disable_interrupts(struct ipw_priv *priv)
458{
459 if (!(priv->status & STATUS_INT_ENABLED))
460 return;
461 priv->status &= ~STATUS_INT_ENABLED;
b095c381 462 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
43f66a6c
JK		 463}
464
0f52bf90 465#ifdef CONFIG_IPW2200_DEBUG
43f66a6c
JK		 466static char *ipw_error_desc(u32 val)
467{
468 switch (val) {
bf79451e 469 case IPW_FW_ERROR_OK:
43f66a6c 470 return "ERROR_OK";
bf79451e 471 case IPW_FW_ERROR_FAIL:
43f66a6c 472 return "ERROR_FAIL";
bf79451e 473 case IPW_FW_ERROR_MEMORY_UNDERFLOW:
43f66a6c 474 return "MEMORY_UNDERFLOW";
bf79451e 475 case IPW_FW_ERROR_MEMORY_OVERFLOW:
43f66a6c 476 return "MEMORY_OVERFLOW";
bf79451e 477 case IPW_FW_ERROR_BAD_PARAM:
b095c381 478 return "BAD_PARAM";
bf79451e 479 case IPW_FW_ERROR_BAD_CHECKSUM:
b095c381 480 return "BAD_CHECKSUM";
bf79451e 481 case IPW_FW_ERROR_NMI_INTERRUPT:
b095c381 482 return "NMI_INTERRUPT";
bf79451e 483 case IPW_FW_ERROR_BAD_DATABASE:
b095c381 484 return "BAD_DATABASE";
bf79451e 485 case IPW_FW_ERROR_ALLOC_FAIL:
b095c381 486 return "ALLOC_FAIL";
bf79451e 487 case IPW_FW_ERROR_DMA_UNDERRUN:
b095c381 488 return "DMA_UNDERRUN";
bf79451e 489 case IPW_FW_ERROR_DMA_STATUS:
b095c381
JK		 490 return "DMA_STATUS";
491 case IPW_FW_ERROR_DINO_ERROR:
492 return "DINO_ERROR";
493 case IPW_FW_ERROR_EEPROM_ERROR:
494 return "EEPROM_ERROR";
bf79451e 495 case IPW_FW_ERROR_SYSASSERT:
b095c381 496 return "SYSASSERT";
bf79451e 497 case IPW_FW_ERROR_FATAL_ERROR:
b095c381 498 return "FATAL_ERROR";
bf79451e 499 default:
b095c381 500 return "UNKNOWN_ERROR";
43f66a6c
JK		 501 }
502}
503
b39860c6
JK		 504static void ipw_dump_error_log(struct ipw_priv *priv,
505 struct ipw_fw_error *error)
43f66a6c 506{
b39860c6 507 u32 i;
bf79451e 508
b39860c6
JK		 509 if (!error) {
510 IPW_ERROR("Error allocating and capturing error log. "
511 "Nothing to dump.\n");
512 return;
43f66a6c
JK		 513 }
514
b39860c6
JK		 515 IPW_ERROR("Start IPW Error Log Dump:\n");
516 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
517 error->status, error->config);
43f66a6c 518
b39860c6 519 for (i = 0; i < error->elem_len; i++)
0edd5b44 520 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
b39860c6
JK		 521 ipw_error_desc(error->elem[i].desc),
522 error->elem[i].time,
523 error->elem[i].blink1,
524 error->elem[i].blink2,
525 error->elem[i].link1,
526 error->elem[i].link2, error->elem[i].data);
527 for (i = 0; i < error->log_len; i++)
528 IPW_ERROR("%i\t0x%08x\t%i\n",
529 error->log[i].time,
286568ab 530 error->log[i].data, error->log[i].event);
43f66a6c 531}
43f66a6c 532#endif
43f66a6c 533
c848d0af 534static inline int ipw_is_init(struct ipw_priv *priv)
43f66a6c 535{
c848d0af 536 return (priv->status & STATUS_INIT) ? 1 : 0;
43f66a6c
JK		 537}
538
0edd5b44 539static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
43f66a6c
JK		 540{
541 u32 addr, field_info, field_len, field_count, total_len;
542
543 IPW_DEBUG_ORD("ordinal = %i\n", ord);
544
545 if (!priv || !val || !len) {
546 IPW_DEBUG_ORD("Invalid argument\n");
547 return -EINVAL;
548 }
bf79451e 549
43f66a6c
JK		 550 /* verify device ordinal tables have been initialized */
551 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
552 IPW_DEBUG_ORD("Access ordinals before initialization\n");
553 return -EINVAL;
554 }
555
556 switch (IPW_ORD_TABLE_ID_MASK & ord) {
557 case IPW_ORD_TABLE_0_MASK:
558 /*
559 * TABLE 0: Direct access to a table of 32 bit values
560 *
bf79451e 561 * This is a very simple table with the data directly
43f66a6c
JK		 562 * read from the table
563 */
564
565 /* remove the table id from the ordinal */
566 ord &= IPW_ORD_TABLE_VALUE_MASK;
567
568 /* boundary check */
569 if (ord > priv->table0_len) {
570 IPW_DEBUG_ORD("ordinal value (%i) longer then "
571 "max (%i)\n", ord, priv->table0_len);
572 return -EINVAL;
573 }
574
575 /* verify we have enough room to store the value */
576 if (*len < sizeof(u32)) {
577 IPW_DEBUG_ORD("ordinal buffer length too small, "
aaa4d308 578 "need %zd\n", sizeof(u32));
43f66a6c
JK		 579 return -EINVAL;
580 }
581
582 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
0edd5b44 583 ord, priv->table0_addr + (ord << 2));
43f66a6c
JK		 584
585 *len = sizeof(u32);
586 ord <<= 2;
0edd5b44 587 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
43f66a6c
JK		 588 break;
589
590 case IPW_ORD_TABLE_1_MASK:
591 /*
592 * TABLE 1: Indirect access to a table of 32 bit values
bf79451e
JG		 593 *
594 * This is a fairly large table of u32 values each
43f66a6c
JK		 595 * representing starting addr for the data (which is
596 * also a u32)
597 */
598
599 /* remove the table id from the ordinal */
600 ord &= IPW_ORD_TABLE_VALUE_MASK;
bf79451e 601
43f66a6c
JK		 602 /* boundary check */
603 if (ord > priv->table1_len) {
604 IPW_DEBUG_ORD("ordinal value too long\n");
605 return -EINVAL;
606 }
607
608 /* verify we have enough room to store the value */
609 if (*len < sizeof(u32)) {
610 IPW_DEBUG_ORD("ordinal buffer length too small, "
aaa4d308 611 "need %zd\n", sizeof(u32));
43f66a6c
JK		 612 return -EINVAL;
613 }
614
0edd5b44
JG		 615 *((u32 *) val) =
616 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
43f66a6c
JK		 617 *len = sizeof(u32);
618 break;
619
620 case IPW_ORD_TABLE_2_MASK:
621 /*
622 * TABLE 2: Indirect access to a table of variable sized values
623 *
624 * This table consist of six values, each containing
625 * - dword containing the starting offset of the data
626 * - dword containing the lengh in the first 16bits
627 * and the count in the second 16bits
628 */
629
630 /* remove the table id from the ordinal */
631 ord &= IPW_ORD_TABLE_VALUE_MASK;
632
633 /* boundary check */
634 if (ord > priv->table2_len) {
635 IPW_DEBUG_ORD("ordinal value too long\n");
636 return -EINVAL;
637 }
638
639 /* get the address of statistic */
640 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
bf79451e
JG		 641
642 /* get the second DW of statistics ;
43f66a6c 643 * two 16-bit words - first is length, second is count */
0edd5b44
JG		 644 field_info =
645 ipw_read_reg32(priv,
646 priv->table2_addr + (ord << 3) +
647 sizeof(u32));
bf79451e 648
43f66a6c 649 /* get each entry length */
0edd5b44 650 field_len = *((u16 *) & field_info);
bf79451e 651
43f66a6c 652 /* get number of entries */
0edd5b44 653 field_count = *(((u16 *) & field_info) + 1);
bf79451e 654
43f66a6c
JK		 655 /* abort if not enought memory */
656 total_len = field_len * field_count;
657 if (total_len > *len) {
658 *len = total_len;
659 return -EINVAL;
660 }
bf79451e 661
43f66a6c
JK		 662 *len = total_len;
663 if (!total_len)
664 return 0;
665
666 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
bf79451e 667 "field_info = 0x%08x\n",
43f66a6c
JK		 668 addr, total_len, field_info);
669 ipw_read_indirect(priv, addr, val, total_len);
670 break;
671
672 default:
673 IPW_DEBUG_ORD("Invalid ordinal!\n");
674 return -EINVAL;
675
676 }
677
43f66a6c
JK		 678 return 0;
679}
680
681static void ipw_init_ordinals(struct ipw_priv *priv)
682{
683 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
bf79451e 684 priv->table0_len = ipw_read32(priv, priv->table0_addr);
43f66a6c
JK		 685
686 IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
687 priv->table0_addr, priv->table0_len);
688
689 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
690 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
691
692 IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
693 priv->table1_addr, priv->table1_len);
694
695 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
696 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
0edd5b44 697 priv->table2_len &= 0x0000ffff; /* use first two bytes */
43f66a6c
JK		 698
699 IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
700 priv->table2_addr, priv->table2_len);
701
702}
703
a613bffd
JK		 704u32 ipw_register_toggle(u32 reg)
705{
b095c381
JK		 706 reg &= ~IPW_START_STANDBY;
707 if (reg & IPW_GATE_ODMA)
708 reg &= ~IPW_GATE_ODMA;
709 if (reg & IPW_GATE_IDMA)
710 reg &= ~IPW_GATE_IDMA;
711 if (reg & IPW_GATE_ADMA)
712 reg &= ~IPW_GATE_ADMA;
a613bffd
JK		 713 return reg;
714}
715
716/*
717 * LED behavior:
718 * - On radio ON, turn on any LEDs that require to be on during start
719 * - On initialization, start unassociated blink
720 * - On association, disable unassociated blink
721 * - On disassociation, start unassociated blink
722 * - On radio OFF, turn off any LEDs started during radio on
723 *
724 */
725#define LD_TIME_LINK_ON 300
726#define LD_TIME_LINK_OFF 2700
727#define LD_TIME_ACT_ON 250
728
729void ipw_led_link_on(struct ipw_priv *priv)
730{
731 unsigned long flags;
732 u32 led;
733
734 /* If configured to not use LEDs, or nic_type is 1,
735 * then we don't toggle a LINK led */
736 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
737 return;
738
739 spin_lock_irqsave(&priv->lock, flags);
740
741 if (!(priv->status & STATUS_RF_KILL_MASK) &&
742 !(priv->status & STATUS_LED_LINK_ON)) {
743 IPW_DEBUG_LED("Link LED On\n");
b095c381 744 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 745 led |= priv->led_association_on;
746
747 led = ipw_register_toggle(led);
748
749 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 750 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 751
752 priv->status |= STATUS_LED_LINK_ON;
753
754 /* If we aren't associated, schedule turning the LED off */
755 if (!(priv->status & STATUS_ASSOCIATED))
756 queue_delayed_work(priv->workqueue,
757 &priv->led_link_off,
758 LD_TIME_LINK_ON);
759 }
760
761 spin_unlock_irqrestore(&priv->lock, flags);
762}
763
c848d0af
JK		 764static void ipw_bg_led_link_on(void *data)
765{
766 struct ipw_priv *priv = data;
767 down(&priv->sem);
768 ipw_led_link_on(data);
769 up(&priv->sem);
770}
771
a613bffd
JK		 772void ipw_led_link_off(struct ipw_priv *priv)
773{
774 unsigned long flags;
775 u32 led;
776
777 /* If configured not to use LEDs, or nic type is 1,
778 * then we don't goggle the LINK led. */
779 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
780 return;
781
782 spin_lock_irqsave(&priv->lock, flags);
783
784 if (priv->status & STATUS_LED_LINK_ON) {
b095c381 785 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 786 led &= priv->led_association_off;
787 led = ipw_register_toggle(led);
788
789 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 790 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 791
792 IPW_DEBUG_LED("Link LED Off\n");
793
794 priv->status &= ~STATUS_LED_LINK_ON;
795
796 /* If we aren't associated and the radio is on, schedule
797 * turning the LED on (blink while unassociated) */
798 if (!(priv->status & STATUS_RF_KILL_MASK) &&
799 !(priv->status & STATUS_ASSOCIATED))
800 queue_delayed_work(priv->workqueue, &priv->led_link_on,
801 LD_TIME_LINK_OFF);
802
803 }
804
805 spin_unlock_irqrestore(&priv->lock, flags);
806}
807
c848d0af
JK		 808static void ipw_bg_led_link_off(void *data)
809{
810 struct ipw_priv *priv = data;
811 down(&priv->sem);
812 ipw_led_link_off(data);
813 up(&priv->sem);
814}
815
b095c381 816static inline void __ipw_led_activity_on(struct ipw_priv *priv)
a613bffd 817{
a613bffd
JK		 818 u32 led;
819
820 if (priv->config & CFG_NO_LED)
821 return;
822
b095c381 823 if (priv->status & STATUS_RF_KILL_MASK)
a613bffd 824 return;
a613bffd
JK		 825
826 if (!(priv->status & STATUS_LED_ACT_ON)) {
b095c381 827 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 828 led |= priv->led_activity_on;
829
830 led = ipw_register_toggle(led);
831
832 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 833 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 834
835 IPW_DEBUG_LED("Activity LED On\n");
836
837 priv->status |= STATUS_LED_ACT_ON;
838
c848d0af 839 cancel_delayed_work(&priv->led_act_off);
a613bffd
JK		 840 queue_delayed_work(priv->workqueue, &priv->led_act_off,
841 LD_TIME_ACT_ON);
842 } else {
843 /* Reschedule LED off for full time period */
844 cancel_delayed_work(&priv->led_act_off);
845 queue_delayed_work(priv->workqueue, &priv->led_act_off,
846 LD_TIME_ACT_ON);
847 }
b095c381 848}
a613bffd 849
b095c381
JK		 850void ipw_led_activity_on(struct ipw_priv *priv)
851{
852 unsigned long flags;
853 spin_lock_irqsave(&priv->lock, flags);
854 __ipw_led_activity_on(priv);
a613bffd
JK		 855 spin_unlock_irqrestore(&priv->lock, flags);
856}
857
858void ipw_led_activity_off(struct ipw_priv *priv)
859{
860 unsigned long flags;
861 u32 led;
862
863 if (priv->config & CFG_NO_LED)
864 return;
865
866 spin_lock_irqsave(&priv->lock, flags);
867
868 if (priv->status & STATUS_LED_ACT_ON) {
b095c381 869 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 870 led &= priv->led_activity_off;
871
872 led = ipw_register_toggle(led);
873
874 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 875 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 876
877 IPW_DEBUG_LED("Activity LED Off\n");
878
879 priv->status &= ~STATUS_LED_ACT_ON;
880 }
881
882 spin_unlock_irqrestore(&priv->lock, flags);
883}
884
c848d0af
JK		 885static void ipw_bg_led_activity_off(void *data)
886{
887 struct ipw_priv *priv = data;
888 down(&priv->sem);
889 ipw_led_activity_off(data);
890 up(&priv->sem);
891}
892
a613bffd
JK		 893void ipw_led_band_on(struct ipw_priv *priv)
894{
895 unsigned long flags;
896 u32 led;
897
898 /* Only nic type 1 supports mode LEDs */
c848d0af
JK		 899 if (priv->config & CFG_NO_LED ||
900 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
a613bffd
JK		 901 return;
902
903 spin_lock_irqsave(&priv->lock, flags);
904
b095c381 905 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 906 if (priv->assoc_network->mode == IEEE_A) {
907 led |= priv->led_ofdm_on;
908 led &= priv->led_association_off;
909 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
910 } else if (priv->assoc_network->mode == IEEE_G) {
911 led |= priv->led_ofdm_on;
912 led |= priv->led_association_on;
913 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
914 } else {
915 led &= priv->led_ofdm_off;
916 led |= priv->led_association_on;
917 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
918 }
919
920 led = ipw_register_toggle(led);
921
922 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 923 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 924
925 spin_unlock_irqrestore(&priv->lock, flags);
926}
927
928void ipw_led_band_off(struct ipw_priv *priv)
929{
930 unsigned long flags;
931 u32 led;
932
933 /* Only nic type 1 supports mode LEDs */
934 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
935 return;
936
937 spin_lock_irqsave(&priv->lock, flags);
938
b095c381 939 led = ipw_read_reg32(priv, IPW_EVENT_REG);
a613bffd
JK		 940 led &= priv->led_ofdm_off;
941 led &= priv->led_association_off;
942
943 led = ipw_register_toggle(led);
944
945 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
b095c381 946 ipw_write_reg32(priv, IPW_EVENT_REG, led);
a613bffd
JK		 947
948 spin_unlock_irqrestore(&priv->lock, flags);
949}
950
951void ipw_led_radio_on(struct ipw_priv *priv)
952{
953 ipw_led_link_on(priv);
954}
955
956void ipw_led_radio_off(struct ipw_priv *priv)
957{
958 ipw_led_activity_off(priv);
959 ipw_led_link_off(priv);
960}
961
962void ipw_led_link_up(struct ipw_priv *priv)
963{
964 /* Set the Link Led on for all nic types */
965 ipw_led_link_on(priv);
966}
967
968void ipw_led_link_down(struct ipw_priv *priv)
969{
970 ipw_led_activity_off(priv);
971 ipw_led_link_off(priv);
972
973 if (priv->status & STATUS_RF_KILL_MASK)
974 ipw_led_radio_off(priv);
975}
976
977void ipw_led_init(struct ipw_priv *priv)
978{
979 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
980
981 /* Set the default PINs for the link and activity leds */
b095c381
JK		 982 priv->led_activity_on = IPW_ACTIVITY_LED;
983 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
a613bffd 984
b095c381
JK		 985 priv->led_association_on = IPW_ASSOCIATED_LED;
986 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
a613bffd
JK		 987
988 /* Set the default PINs for the OFDM leds */
b095c381
JK		 989 priv->led_ofdm_on = IPW_OFDM_LED;
990 priv->led_ofdm_off = ~(IPW_OFDM_LED);
a613bffd
JK		 991
992 switch (priv->nic_type) {
993 case EEPROM_NIC_TYPE_1:
994 /* In this NIC type, the LEDs are reversed.... */
b095c381
JK		 995 priv->led_activity_on = IPW_ASSOCIATED_LED;
996 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
997 priv->led_association_on = IPW_ACTIVITY_LED;
998 priv->led_association_off = ~(IPW_ACTIVITY_LED);
a613bffd
JK		 999
1000 if (!(priv->config & CFG_NO_LED))
1001 ipw_led_band_on(priv);
1002
1003 /* And we don't blink link LEDs for this nic, so
1004 * just return here */
1005 return;
1006
1007 case EEPROM_NIC_TYPE_3:
1008 case EEPROM_NIC_TYPE_2:
1009 case EEPROM_NIC_TYPE_4:
1010 case EEPROM_NIC_TYPE_0:
1011 break;
1012
1013 default:
1014 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1015 priv->nic_type);
1016 priv->nic_type = EEPROM_NIC_TYPE_0;
1017 break;
1018 }
1019
1020 if (!(priv->config & CFG_NO_LED)) {
1021 if (priv->status & STATUS_ASSOCIATED)
1022 ipw_led_link_on(priv);
1023 else
1024 ipw_led_link_off(priv);
1025 }
1026}
1027
1028void ipw_led_shutdown(struct ipw_priv *priv)
1029{
a613bffd
JK		 1030 ipw_led_activity_off(priv);
1031 ipw_led_link_off(priv);
1032 ipw_led_band_off(priv);
afbf30a2
JK		 1033 cancel_delayed_work(&priv->led_link_on);
1034 cancel_delayed_work(&priv->led_link_off);
1035 cancel_delayed_work(&priv->led_act_off);
a613bffd
JK		 1036}
1037
43f66a6c
JK		 1038/*
1039 * The following adds a new attribute to the sysfs representation
1040 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1041 * used for controling the debug level.
bf79451e 1042 *
43f66a6c
JK		 1043 * See the level definitions in ipw for details.
1044 */
1045static ssize_t show_debug_level(struct device_driver *d, char *buf)
1046{
1047 return sprintf(buf, "0x%08X\n", ipw_debug_level);
1048}
a613bffd
JK		 1049
1050static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1051 size_t count)
43f66a6c
JK		 1052{
1053 char *p = (char *)buf;
1054 u32 val;
1055
1056 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1057 p++;
1058 if (p[0] == 'x' || p[0] == 'X')
1059 p++;
1060 val = simple_strtoul(p, &p, 16);
1061 } else
1062 val = simple_strtoul(p, &p, 10);
bf79451e
JG		 1063 if (p == buf)
1064 printk(KERN_INFO DRV_NAME
43f66a6c
JK		 1065 ": %s is not in hex or decimal form.\n", buf);
1066 else
1067 ipw_debug_level = val;
1068
1069 return strnlen(buf, count);
1070}
1071
bf79451e 1072static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
43f66a6c
JK		 1073 show_debug_level, store_debug_level);
1074
b39860c6 1075static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
43f66a6c 1076{
b39860c6 1077 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
43f66a6c 1078}
0edd5b44 1079
b39860c6
JK		 1080static void ipw_capture_event_log(struct ipw_priv *priv,
1081 u32 log_len, struct ipw_event *log)
43f66a6c 1082{
b39860c6 1083 u32 base;
0edd5b44 1084
b39860c6
JK		 1085 if (log_len) {
1086 base = ipw_read32(priv, IPW_EVENT_LOG);
1087 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1088 (u8 *) log, sizeof(*log) * log_len);
1089 }
1090}
43f66a6c 1091
b39860c6 1092static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
43f66a6c 1093{
b39860c6
JK		 1094 struct ipw_fw_error *error;
1095 u32 log_len = ipw_get_event_log_len(priv);
1096 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1097 u32 elem_len = ipw_read_reg32(priv, base);
43f66a6c 1098
b39860c6
JK		 1099 error = kmalloc(sizeof(*error) +
1100 sizeof(*error->elem) * elem_len +
1101 sizeof(*error->log) * log_len, GFP_ATOMIC);
1102 if (!error) {
1103 IPW_ERROR("Memory allocation for firmware error log "
1104 "failed.\n");
1105 return NULL;
43f66a6c 1106 }
f6c5cb7c 1107 error->jiffies = jiffies;
b39860c6
JK		 1108 error->status = priv->status;
1109 error->config = priv->config;
1110 error->elem_len = elem_len;
1111 error->log_len = log_len;
1112 error->elem = (struct ipw_error_elem *)error->payload;
3b26b110 1113 error->log = (struct ipw_event *)(error->elem + elem_len);
b39860c6
JK		 1114
1115 ipw_capture_event_log(priv, log_len, error->log);
bf79451e 1116
b39860c6
JK		 1117 if (elem_len)
1118 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1119 sizeof(*error->elem) * elem_len);
1120
1121 return error;
43f66a6c 1122}
0edd5b44 1123
b39860c6
JK		 1124static void ipw_free_error_log(struct ipw_fw_error *error)
1125{
1126 if (error)
1127 kfree(error);
1128}
43f66a6c 1129
b39860c6
JK		 1130static ssize_t show_event_log(struct device *d,
1131 struct device_attribute *attr, char *buf)
43f66a6c 1132{
b39860c6
JK		 1133 struct ipw_priv *priv = dev_get_drvdata(d);
1134 u32 log_len = ipw_get_event_log_len(priv);
1135 struct ipw_event log[log_len];
1136 u32 len = 0, i;
43f66a6c 1137
b39860c6 1138 ipw_capture_event_log(priv, log_len, log);
43f66a6c 1139
b39860c6
JK		 1140 len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1141 for (i = 0; i < log_len; i++)
1142 len += snprintf(buf + len, PAGE_SIZE - len,
1143 "\n%08X%08X%08X",
1144 log[i].time, log[i].event, log[i].data);
1145 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1146 return len;
43f66a6c 1147}
0edd5b44 1148
b39860c6 1149static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
43f66a6c 1150
b39860c6
JK		 1151static ssize_t show_error(struct device *d,
1152 struct device_attribute *attr, char *buf)
43f66a6c 1153{
b39860c6
JK		 1154 struct ipw_priv *priv = dev_get_drvdata(d);
1155 u32 len = 0, i;
1156 if (!priv->error)
1157 return 0;
1158 len += snprintf(buf + len, PAGE_SIZE - len,
f6c5cb7c
JK		 1159 "%08lX%08X%08X%08X",
1160 priv->error->jiffies,
b39860c6
JK		 1161 priv->error->status,
1162 priv->error->config, priv->error->elem_len);
1163 for (i = 0; i < priv->error->elem_len; i++)
1164 len += snprintf(buf + len, PAGE_SIZE - len,
1165 "\n%08X%08X%08X%08X%08X%08X%08X",
1166 priv->error->elem[i].time,
1167 priv->error->elem[i].desc,
1168 priv->error->elem[i].blink1,
1169 priv->error->elem[i].blink2,
1170 priv->error->elem[i].link1,
1171 priv->error->elem[i].link2,
1172 priv->error->elem[i].data);
1173
1174 len += snprintf(buf + len, PAGE_SIZE - len,
1175 "\n%08X", priv->error->log_len);
1176 for (i = 0; i < priv->error->log_len; i++)
1177 len += snprintf(buf + len, PAGE_SIZE - len,
1178 "\n%08X%08X%08X",
1179 priv->error->log[i].time,
1180 priv->error->log[i].event,
1181 priv->error->log[i].data);
1182 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1183 return len;
1184}
1185
1186static ssize_t clear_error(struct device *d,
1187 struct device_attribute *attr,
1188 const char *buf, size_t count)
1189{
1190 struct ipw_priv *priv = dev_get_drvdata(d);
1191 if (priv->error) {
1192 ipw_free_error_log(priv->error);
1193 priv->error = NULL;
1194 }
1195 return count;
1196}
43f66a6c 1197
b39860c6 1198static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
43f66a6c 1199
f6c5cb7c
JK		 1200static ssize_t show_cmd_log(struct device *d,
1201 struct device_attribute *attr, char *buf)
1202{
1203 struct ipw_priv *priv = dev_get_drvdata(d);
1204 u32 len = 0, i;
1205 if (!priv->cmdlog)
1206 return 0;
1207 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1208 (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
1209 i = (i + 1) % priv->cmdlog_len) {
1210 len +=
1211 snprintf(buf + len, PAGE_SIZE - len,
1212 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1213 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1214 priv->cmdlog[i].cmd.len);
1215 len +=
1216 snprintk_buf(buf + len, PAGE_SIZE - len,
1217 (u8 *) priv->cmdlog[i].cmd.param,
1218 priv->cmdlog[i].cmd.len);
1219 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1220 }
1221 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
1222 return len;
43f66a6c 1223}
0edd5b44 1224
f6c5cb7c 1225static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
43f66a6c 1226
a613bffd
JK		 1227static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
1228 char *buf)
43f66a6c 1229{
a613bffd
JK		 1230 struct ipw_priv *priv = dev_get_drvdata(d);
1231 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1232}
1233
1234static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
1235 const char *buf, size_t count)
1236{
1237 struct ipw_priv *priv = dev_get_drvdata(d);
0f52bf90 1238#ifdef CONFIG_IPW2200_DEBUG
a613bffd 1239 struct net_device *dev = priv->net_dev;
c848d0af 1240#endif
a613bffd
JK		 1241 char buffer[] = "00000000";
1242 unsigned long len =
1243 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
1244 unsigned long val;
1245 char *p = buffer;
1246
1247 IPW_DEBUG_INFO("enter\n");
1248
1249 strncpy(buffer, buf, len);
1250 buffer[len] = 0;
1251
1252 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
1253 p++;
1254 if (p[0] == 'x' || p[0] == 'X')
1255 p++;
1256 val = simple_strtoul(p, &p, 16);
1257 } else
1258 val = simple_strtoul(p, &p, 10);
1259 if (p == buffer) {
1260 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1261 } else {
1262 priv->ieee->scan_age = val;
1263 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1264 }
1265
1266 IPW_DEBUG_INFO("exit\n");
1267 return len;
1268}
1269
1270static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
1271
1272static ssize_t show_led(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->config & CFG_NO_LED) ? 0 : 1);
1277}
1278
1279static ssize_t store_led(struct device *d, struct device_attribute *attr,
1280 const char *buf, size_t count)
1281{
1282 struct ipw_priv *priv = dev_get_drvdata(d);
1283
1284 IPW_DEBUG_INFO("enter\n");
1285
1286 if (count == 0)
1287 return 0;
1288
1289 if (*buf == 0) {
1290 IPW_DEBUG_LED("Disabling LED control.\n");
1291 priv->config |= CFG_NO_LED;
1292 ipw_led_shutdown(priv);
1293 } else {
1294 IPW_DEBUG_LED("Enabling LED control.\n");
1295 priv->config &= ~CFG_NO_LED;
1296 ipw_led_init(priv);
1297 }
1298
1299 IPW_DEBUG_INFO("exit\n");
1300 return count;
1301}
1302
1303static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);
1304
ad3fee56 1305static ssize_t show_status(struct device *d,
0edd5b44 1306 struct device_attribute *attr, char *buf)
43f66a6c 1307{
ad3fee56 1308 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1309 return sprintf(buf, "0x%08x\n", (int)p->status);
1310}
0edd5b44 1311
43f66a6c
JK		 1312static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
1313
ad3fee56
AM		 1314static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
1315 char *buf)
43f66a6c 1316{
ad3fee56 1317 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1318 return sprintf(buf, "0x%08x\n", (int)p->config);
1319}
0edd5b44 1320
43f66a6c
JK		 1321static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
1322
ad3fee56 1323static ssize_t show_nic_type(struct device *d,
0edd5b44 1324 struct device_attribute *attr, char *buf)
43f66a6c 1325{
a613bffd
JK		 1326 struct ipw_priv *priv = d->driver_data;
1327 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
43f66a6c 1328}
0edd5b44 1329
43f66a6c
JK		 1330static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);
1331
ad3fee56 1332static ssize_t show_ucode_version(struct device *d,
0edd5b44 1333 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1334{
1335 u32 len = sizeof(u32), tmp = 0;
ad3fee56 1336 struct ipw_priv *p = d->driver_data;
43f66a6c 1337
0edd5b44 1338 if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
43f66a6c
JK		 1339 return 0;
1340
1341 return sprintf(buf, "0x%08x\n", tmp);
1342}
0edd5b44
JG		 1343
1344static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
43f66a6c 1345
ad3fee56
AM		 1346static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
1347 char *buf)
43f66a6c
JK		 1348{
1349 u32 len = sizeof(u32), tmp = 0;
ad3fee56 1350 struct ipw_priv *p = d->driver_data;
43f66a6c 1351
0edd5b44 1352 if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
43f66a6c
JK		 1353 return 0;
1354
1355 return sprintf(buf, "0x%08x\n", tmp);
1356}
0edd5b44
JG		 1357
1358static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
43f66a6c
JK		 1359
1360/*
1361 * Add a device attribute to view/control the delay between eeprom
1362 * operations.
1363 */
ad3fee56 1364static ssize_t show_eeprom_delay(struct device *d,
0edd5b44 1365 struct device_attribute *attr, char *buf)
43f66a6c 1366{
0edd5b44 1367 int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
43f66a6c
JK		 1368 return sprintf(buf, "%i\n", n);
1369}
ad3fee56 1370static ssize_t store_eeprom_delay(struct device *d,
0edd5b44
JG		 1371 struct device_attribute *attr,
1372 const char *buf, size_t count)
43f66a6c 1373{
ad3fee56 1374 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1375 sscanf(buf, "%i", &p->eeprom_delay);
1376 return strnlen(buf, count);
1377}
0edd5b44
JG		 1378
1379static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
1380 show_eeprom_delay, store_eeprom_delay);
43f66a6c 1381
ad3fee56 1382static ssize_t show_command_event_reg(struct device *d,
0edd5b44 1383 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1384{
1385 u32 reg = 0;
ad3fee56 1386 struct ipw_priv *p = d->driver_data;
43f66a6c 1387
b095c381 1388 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
43f66a6c
JK		 1389 return sprintf(buf, "0x%08x\n", reg);
1390}
ad3fee56 1391static ssize_t store_command_event_reg(struct device *d,
0edd5b44
JG		 1392 struct device_attribute *attr,
1393 const char *buf, size_t count)
43f66a6c
JK		 1394{
1395 u32 reg;
ad3fee56 1396 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1397
1398 sscanf(buf, "%x", &reg);
b095c381 1399 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
43f66a6c
JK		 1400 return strnlen(buf, count);
1401}
0edd5b44
JG		 1402
1403static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
1404 show_command_event_reg, store_command_event_reg);
43f66a6c 1405
ad3fee56 1406static ssize_t show_mem_gpio_reg(struct device *d,
0edd5b44 1407 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1408{
1409 u32 reg = 0;
ad3fee56 1410 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1411
1412 reg = ipw_read_reg32(p, 0x301100);
1413 return sprintf(buf, "0x%08x\n", reg);
1414}
ad3fee56 1415static ssize_t store_mem_gpio_reg(struct device *d,
0edd5b44
JG		 1416 struct device_attribute *attr,
1417 const char *buf, size_t count)
43f66a6c
JK		 1418{
1419 u32 reg;
ad3fee56 1420 struct ipw_priv *p = d->driver_data;
43f66a6c
JK		 1421
1422 sscanf(buf, "%x", &reg);
1423 ipw_write_reg32(p, 0x301100, reg);
1424 return strnlen(buf, count);
1425}
0edd5b44
JG		 1426
1427static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
1428 show_mem_gpio_reg, store_mem_gpio_reg);
43f66a6c 1429
ad3fee56 1430static ssize_t show_indirect_dword(struct device *d,
0edd5b44 1431 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1432{
1433 u32 reg = 0;
ad3fee56 1434 struct ipw_priv *priv = d->driver_data;
afbf30a2 1435
bf79451e 1436 if (priv->status & STATUS_INDIRECT_DWORD)
43f66a6c 1437 reg = ipw_read_reg32(priv, priv->indirect_dword);
bf79451e 1438 else
43f66a6c 1439 reg = 0;
bf79451e 1440
43f66a6c
JK		 1441 return sprintf(buf, "0x%08x\n", reg);
1442}
ad3fee56 1443static ssize_t store_indirect_dword(struct device *d,
0edd5b44
JG		 1444 struct device_attribute *attr,
1445 const char *buf, size_t count)
43f66a6c 1446{
ad3fee56 1447 struct ipw_priv *priv = d->driver_data;
43f66a6c
JK		 1448
1449 sscanf(buf, "%x", &priv->indirect_dword);
1450 priv->status |= STATUS_INDIRECT_DWORD;
1451 return strnlen(buf, count);
1452}
0edd5b44
JG		 1453
1454static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
1455 show_indirect_dword, store_indirect_dword);
43f66a6c 1456
ad3fee56 1457static ssize_t show_indirect_byte(struct device *d,
0edd5b44 1458 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1459{
1460 u8 reg = 0;
ad3fee56 1461 struct ipw_priv *priv = d->driver_data;
afbf30a2 1462
bf79451e 1463 if (priv->status & STATUS_INDIRECT_BYTE)
43f66a6c 1464 reg = ipw_read_reg8(priv, priv->indirect_byte);
bf79451e 1465 else
43f66a6c
JK		 1466 reg = 0;
1467
1468 return sprintf(buf, "0x%02x\n", reg);
1469}
ad3fee56 1470static ssize_t store_indirect_byte(struct device *d,
0edd5b44
JG		 1471 struct device_attribute *attr,
1472 const char *buf, size_t count)
43f66a6c 1473{
ad3fee56 1474 struct ipw_priv *priv = d->driver_data;
43f66a6c
JK		 1475
1476 sscanf(buf, "%x", &priv->indirect_byte);
1477 priv->status |= STATUS_INDIRECT_BYTE;
1478 return strnlen(buf, count);
1479}
0edd5b44
JG		 1480
1481static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
43f66a6c
JK		 1482 show_indirect_byte, store_indirect_byte);
1483
ad3fee56 1484static ssize_t show_direct_dword(struct device *d,
0edd5b44 1485 struct device_attribute *attr, char *buf)
43f66a6c
JK		 1486{
1487 u32 reg = 0;
ad3fee56 1488 struct ipw_priv *priv = d->driver_data;
43f66a6c 1489
bf79451e 1490 if (priv->status & STATUS_DIRECT_DWORD)
43f66a6c 1491 reg = ipw_read32(priv, priv->direct_dword);
bf79451e 1492 else
43f66a6c
JK		 1493 reg = 0;
1494
1495 return sprintf(buf, "0x%08x\n", reg);
1496}
ad3fee56 1497static ssize_t store_direct_dword(struct device *d,
0edd5b44
JG		 1498 struct device_attribute *attr,
1499 const char *buf, size_t count)
43f66a6c 1500{
ad3fee56 1501 struct ipw_priv *priv = d->driver_data;
43f66a6c
JK		 1502
1503 sscanf(buf, "%x", &priv->direct_dword);
1504 priv->status |= STATUS_DIRECT_DWORD;
1505 return strnlen(buf, count);
1506}
43f66a6c 1507
0edd5b44
JG		 1508static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
1509 show_direct_dword, store_direct_dword);
43f66a6c
JK		 1510
1511static inline int rf_kill_active(struct ipw_priv *priv)
1512{
1513 if (0 == (ipw_read32(priv, 0x30) & 0x10000))
1514 priv->status |= STATUS_RF_KILL_HW;
1515 else
1516 priv->status &= ~STATUS_RF_KILL_HW;
1517
1518 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1519}
1520
ad3fee56 1521static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
0edd5b44 1522 char *buf)
43f66a6c
JK		 1523{
1524 /* 0 - RF kill not enabled
bf79451e 1525 1 - SW based RF kill active (sysfs)
43f66a6c
JK		 1526 2 - HW based RF kill active
1527 3 - Both HW and SW baed RF kill active */
ad3fee56 1528 struct ipw_priv *priv = d->driver_data;
43f66a6c 1529 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
0edd5b44 1530 (rf_kill_active(priv) ? 0x2 : 0x0);
43f66a6c
JK		 1531 return sprintf(buf, "%i\n", val);
1532}
1533
1534static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1535{
bf79451e 1536 if ((disable_radio ? 1 : 0) ==
ea2b26e0 1537 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
0edd5b44 1538 return 0;
43f66a6c
JK		 1539
1540 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
1541 disable_radio ? "OFF" : "ON");
1542
1543 if (disable_radio) {
1544 priv->status |= STATUS_RF_KILL_SW;
1545
a613bffd 1546 if (priv->workqueue)
43f66a6c 1547 cancel_delayed_work(&priv->request_scan);
43f66a6c
JK		 1548 queue_work(priv->workqueue, &priv->down);
1549 } else {
1550 priv->status &= ~STATUS_RF_KILL_SW;
1551 if (rf_kill_active(priv)) {
1552 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1553 "disabled by HW switch\n");
1554 /* Make sure the RF_KILL check timer is running */
1555 cancel_delayed_work(&priv->rf_kill);
bf79451e 1556 queue_delayed_work(priv->workqueue, &priv->rf_kill,
43f66a6c 1557 2 * HZ);
bf79451e 1558 } else
43f66a6c
JK		 1559 queue_work(priv->workqueue, &priv->up);
1560 }
1561
1562 return 1;
1563}
1564
0edd5b44
JG		 1565static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
1566 const char *buf, size_t count)
43f66a6c 1567{
ad3fee56 1568 struct ipw_priv *priv = d->driver_data;
bf79451e 1569
43f66a6c
JK		 1570 ipw_radio_kill_sw(priv, buf[0] == '1');
1571
1572 return count;
1573}
0edd5b44
JG		 1574
1575static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
43f66a6c 1576
b095c381
JK		 1577static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
1578 char *buf)
1579{
1580 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1581 int pos = 0, len = 0;
1582 if (priv->config & CFG_SPEED_SCAN) {
1583 while (priv->speed_scan[pos] != 0)
1584 len += sprintf(&buf[len], "%d ",
1585 priv->speed_scan[pos++]);
1586 return len + sprintf(&buf[len], "\n");
1587 }
1588
1589 return sprintf(buf, "0\n");
1590}
1591
1592static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
1593 const char *buf, size_t count)
1594{
1595 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1596 int channel, pos = 0;
1597 const char *p = buf;
1598
1599 /* list of space separated channels to scan, optionally ending with 0 */
1600 while ((channel = simple_strtol(p, NULL, 0))) {
1601 if (pos == MAX_SPEED_SCAN - 1) {
1602 priv->speed_scan[pos] = 0;
1603 break;
1604 }
1605
1fe0adb4 1606 if (ipw_is_valid_channel(priv->ieee, channel))
b095c381
JK		 1607 priv->speed_scan[pos++] = channel;
1608 else
1609 IPW_WARNING("Skipping invalid channel request: %d\n",
1610 channel);
1611 p = strchr(p, ' ');
1612 if (!p)
1613 break;
1614 while (*p == ' ' || *p == '\t')
1615 p++;
1616 }
1617
1618 if (pos == 0)
1619 priv->config &= ~CFG_SPEED_SCAN;
1620 else {
1621 priv->speed_scan_pos = 0;
1622 priv->config |= CFG_SPEED_SCAN;
1623 }
1624
1625 return count;
1626}
1627
1628static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
1629 store_speed_scan);
1630
1631static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
1632 char *buf)
1633{
1634 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1635 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1636}
1637
1638static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
1639 const char *buf, size_t count)
1640{
1641 struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
1642 if (buf[0] == '1')
1643 priv->config |= CFG_NET_STATS;
1644 else
1645 priv->config &= ~CFG_NET_STATS;
1646
1647 return count;
1648}
1649
afbf30a2
JK		 1650static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
1651 show_net_stats, store_net_stats);
b095c381 1652
ea2b26e0
JK		 1653static void notify_wx_assoc_event(struct ipw_priv *priv)
1654{
1655 union iwreq_data wrqu;
1656 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1657 if (priv->status & STATUS_ASSOCIATED)
1658 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1659 else
1660 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1661 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1662}
1663
43f66a6c
JK		 1664static void ipw_irq_tasklet(struct ipw_priv *priv)
1665{
1666 u32 inta, inta_mask, handled = 0;
1667 unsigned long flags;
1668 int rc = 0;
1669
1670 spin_lock_irqsave(&priv->lock, flags);
1671
b095c381
JK		 1672 inta = ipw_read32(priv, IPW_INTA_RW);
1673 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1674 inta &= (IPW_INTA_MASK_ALL & inta_mask);
43f66a6c
JK		 1675
1676 /* Add any cached INTA values that need to be handled */
1677 inta |= priv->isr_inta;
1678
1679 /* handle all the justifications for the interrupt */
b095c381 1680 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
43f66a6c 1681 ipw_rx(priv);
b095c381 1682 handled |= IPW_INTA_BIT_RX_TRANSFER;
43f66a6c
JK		 1683 }
1684
b095c381 1685 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
43f66a6c 1686 IPW_DEBUG_HC("Command completed.\n");
0edd5b44 1687 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
43f66a6c
JK		 1688 priv->status &= ~STATUS_HCMD_ACTIVE;
1689 wake_up_interruptible(&priv->wait_command_queue);
b095c381 1690 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
43f66a6c
JK		 1691 }
1692
b095c381 1693 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
43f66a6c 1694 IPW_DEBUG_TX("TX_QUEUE_1\n");
0edd5b44 1695 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
b095c381 1696 handled |= IPW_INTA_BIT_TX_QUEUE_1;
43f66a6c
JK		 1697 }
1698
b095c381 1699 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
43f66a6c 1700 IPW_DEBUG_TX("TX_QUEUE_2\n");
0edd5b44 1701 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
b095c381 1702 handled |= IPW_INTA_BIT_TX_QUEUE_2;
43f66a6c
JK		 1703 }
1704
b095c381 1705 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
43f66a6c 1706 IPW_DEBUG_TX("TX_QUEUE_3\n");
0edd5b44 1707 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
b095c381 1708 handled |= IPW_INTA_BIT_TX_QUEUE_3;
43f66a6c
JK		 1709 }
1710
b095c381 1711 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
43f66a6c 1712 IPW_DEBUG_TX("TX_QUEUE_4\n");
0edd5b44 1713 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
b095c381 1714 handled |= IPW_INTA_BIT_TX_QUEUE_4;
43f66a6c
JK		 1715 }
1716
b095c381 1717 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
43f66a6c 1718 IPW_WARNING("STATUS_CHANGE\n");
b095c381 1719 handled |= IPW_INTA_BIT_STATUS_CHANGE;
43f66a6c
JK		 1720 }
1721
b095c381 1722 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
43f66a6c 1723 IPW_WARNING("TX_PERIOD_EXPIRED\n");
b095c381 1724 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
43f66a6c
JK		 1725 }
1726
b095c381 1727 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
43f66a6c 1728 IPW_WARNING("HOST_CMD_DONE\n");
b095c381 1729 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
43f66a6c
JK		 1730 }
1731
b095c381 1732 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
43f66a6c 1733 IPW_WARNING("FW_INITIALIZATION_DONE\n");
b095c381 1734 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
43f66a6c
JK		 1735 }
1736
b095c381 1737 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
43f66a6c 1738 IPW_WARNING("PHY_OFF_DONE\n");
b095c381 1739 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
43f66a6c
JK		 1740 }
1741
b095c381 1742 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
43f66a6c
JK		 1743 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1744 priv->status |= STATUS_RF_KILL_HW;
1745 wake_up_interruptible(&priv->wait_command_queue);
ea2b26e0 1746 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
43f66a6c 1747 cancel_delayed_work(&priv->request_scan);
a613bffd 1748 schedule_work(&priv->link_down);
43f66a6c 1749 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
b095c381 1750 handled |= IPW_INTA_BIT_RF_KILL_DONE;
43f66a6c 1751 }
bf79451e 1752
b095c381 1753 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
43f66a6c 1754 IPW_ERROR("Firmware error detected. Restarting.\n");
b39860c6
JK		 1755 if (priv->error) {
1756 IPW_ERROR("Sysfs 'error' log already exists.\n");
0f52bf90 1757#ifdef CONFIG_IPW2200_DEBUG
b39860c6
JK		 1758 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1759 struct ipw_fw_error *error =
1760 ipw_alloc_error_log(priv);
1761 ipw_dump_error_log(priv, error);
1762 if (error)
1763 ipw_free_error_log(error);
1764 }
1765#endif
1766 } else {
1767 priv->error = ipw_alloc_error_log(priv);
1768 if (priv->error)
1769 IPW_ERROR("Sysfs 'error' log captured.\n");
1770 else
1771 IPW_ERROR("Error allocating sysfs 'error' "
1772 "log.\n");
0f52bf90 1773#ifdef CONFIG_IPW2200_DEBUG
b39860c6
JK		 1774 if (ipw_debug_level & IPW_DL_FW_ERRORS)
1775 ipw_dump_error_log(priv, priv->error);
43f66a6c 1776#endif
b39860c6
JK		 1777 }
1778
b095c381
JK		 1779 /* XXX: If hardware encryption is for WPA/WPA2,
1780 * we have to notify the supplicant. */
1781 if (priv->ieee->sec.encrypt) {
1782 priv->status &= ~STATUS_ASSOCIATED;
1783 notify_wx_assoc_event(priv);
1784 }
1785
1786 /* Keep the restart process from trying to send host
1787 * commands by clearing the INIT status bit */
1788 priv->status &= ~STATUS_INIT;
afbf30a2
JK		 1789
1790 /* Cancel currently queued command. */
1791 priv->status &= ~STATUS_HCMD_ACTIVE;
1792 wake_up_interruptible(&priv->wait_command_queue);
1793
43f66a6c 1794 queue_work(priv->workqueue, &priv->adapter_restart);
b095c381 1795 handled |= IPW_INTA_BIT_FATAL_ERROR;
43f66a6c
JK		 1796 }
1797
b095c381 1798 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
43f66a6c 1799 IPW_ERROR("Parity error\n");
b095c381 1800 handled |= IPW_INTA_BIT_PARITY_ERROR;
43f66a6c
JK		 1801 }
1802
1803 if (handled != inta) {
0edd5b44 1804 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
43f66a6c
JK		 1805 }
1806
1807 /* enable all interrupts */
1808 ipw_enable_interrupts(priv);
1809
1810 spin_unlock_irqrestore(&priv->lock, flags);
1811}
bf79451e 1812
43f66a6c
JK		 1813#define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1814static char *get_cmd_string(u8 cmd)
1815{
1816 switch (cmd) {
1817 IPW_CMD(HOST_COMPLETE);
bf79451e
JG		 1818 IPW_CMD(POWER_DOWN);
1819 IPW_CMD(SYSTEM_CONFIG);
1820 IPW_CMD(MULTICAST_ADDRESS);
1821 IPW_CMD(SSID);
1822 IPW_CMD(ADAPTER_ADDRESS);
1823 IPW_CMD(PORT_TYPE);
1824 IPW_CMD(RTS_THRESHOLD);
1825 IPW_CMD(FRAG_THRESHOLD);
1826 IPW_CMD(POWER_MODE);
1827 IPW_CMD(WEP_KEY);
1828 IPW_CMD(TGI_TX_KEY);
1829 IPW_CMD(SCAN_REQUEST);
1830 IPW_CMD(SCAN_REQUEST_EXT);
1831 IPW_CMD(ASSOCIATE);
1832 IPW_CMD(SUPPORTED_RATES);
1833 IPW_CMD(SCAN_ABORT);
1834 IPW_CMD(TX_FLUSH);
1835 IPW_CMD(QOS_PARAMETERS);
1836 IPW_CMD(DINO_CONFIG);
1837 IPW_CMD(RSN_CAPABILITIES);
1838 IPW_CMD(RX_KEY);
1839 IPW_CMD(CARD_DISABLE);
1840 IPW_CMD(SEED_NUMBER);
1841 IPW_CMD(TX_POWER);
1842 IPW_CMD(COUNTRY_INFO);
1843 IPW_CMD(AIRONET_INFO);
1844 IPW_CMD(AP_TX_POWER);
1845 IPW_CMD(CCKM_INFO);
1846 IPW_CMD(CCX_VER_INFO);
1847 IPW_CMD(SET_CALIBRATION);
1848 IPW_CMD(SENSITIVITY_CALIB);
1849 IPW_CMD(RETRY_LIMIT);
1850 IPW_CMD(IPW_PRE_POWER_DOWN);
1851 IPW_CMD(VAP_BEACON_TEMPLATE);
1852 IPW_CMD(VAP_DTIM_PERIOD);
1853 IPW_CMD(EXT_SUPPORTED_RATES);
1854 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
1855 IPW_CMD(VAP_QUIET_INTERVALS);
1856 IPW_CMD(VAP_CHANNEL_SWITCH);
1857 IPW_CMD(VAP_MANDATORY_CHANNELS);
1858 IPW_CMD(VAP_CELL_PWR_LIMIT);
1859 IPW_CMD(VAP_CF_PARAM_SET);
1860 IPW_CMD(VAP_SET_BEACONING_STATE);
1861 IPW_CMD(MEASUREMENT);
1862 IPW_CMD(POWER_CAPABILITY);
1863 IPW_CMD(SUPPORTED_CHANNELS);
1864 IPW_CMD(TPC_REPORT);
1865 IPW_CMD(WME_INFO);
1866 IPW_CMD(PRODUCTION_COMMAND);
1867 default:
43f66a6c
JK		 1868 return "UNKNOWN";
1869 }
1870}
43f66a6c
JK		 1871
1872#define HOST_COMPLETE_TIMEOUT HZ
1873static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
1874{
1875 int rc = 0;
a613bffd 1876 unsigned long flags;
43f66a6c 1877
a613bffd 1878 spin_lock_irqsave(&priv->lock, flags);
43f66a6c 1879 if (priv->status & STATUS_HCMD_ACTIVE) {
9ddf84f6
JK		 1880 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1881 get_cmd_string(cmd->cmd));
a613bffd 1882 spin_unlock_irqrestore(&priv->lock, flags);
9ddf84f6 1883 return -EAGAIN;
43f66a6c
JK		 1884 }
1885
1886 priv->status |= STATUS_HCMD_ACTIVE;
bf79451e 1887
f6c5cb7c
JK		 1888 if (priv->cmdlog) {
1889 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
1890 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
1891 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
1892 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
1893 cmd->len);
1894 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
1895 }
1896
b095c381
JK		 1897 IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
1898 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
1899 priv->status);
0edd5b44 1900 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
43f66a6c
JK		 1901
1902 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
a613bffd
JK		 1903 if (rc) {
1904 priv->status &= ~STATUS_HCMD_ACTIVE;
9ddf84f6
JK		 1905 IPW_ERROR("Failed to send %s: Reason %d\n",
1906 get_cmd_string(cmd->cmd), rc);
a613bffd 1907 spin_unlock_irqrestore(&priv->lock, flags);
f6c5cb7c 1908 goto exit;
a613bffd
JK		 1909 }
1910 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 1911
0edd5b44
JG		 1912 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1913 !(priv->
1914 status & STATUS_HCMD_ACTIVE),
1915 HOST_COMPLETE_TIMEOUT);
43f66a6c 1916 if (rc == 0) {
a613bffd
JK		 1917 spin_lock_irqsave(&priv->lock, flags);
1918 if (priv->status & STATUS_HCMD_ACTIVE) {
9ddf84f6
JK		 1919 IPW_ERROR("Failed to send %s: Command timed out.\n",
1920 get_cmd_string(cmd->cmd));
a613bffd
JK		 1921 priv->status &= ~STATUS_HCMD_ACTIVE;
1922 spin_unlock_irqrestore(&priv->lock, flags);
f6c5cb7c
JK		 1923 rc = -EIO;
1924 goto exit;
a613bffd
JK		 1925 }
1926 spin_unlock_irqrestore(&priv->lock, flags);
3b9990cb
JK		 1927 } else
1928 rc = 0;
a613bffd 1929
b095c381 1930 if (priv->status & STATUS_RF_KILL_HW) {
9ddf84f6
JK		 1931 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
1932 get_cmd_string(cmd->cmd));
f6c5cb7c
JK		 1933 rc = -EIO;
1934 goto exit;
43f66a6c
JK		 1935 }
1936
f6c5cb7c
JK		 1937 exit:
1938 if (priv->cmdlog) {
1939 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
1940 priv->cmdlog_pos %= priv->cmdlog_len;
1941 }
1942 return rc;
43f66a6c
JK		 1943}
1944
1945static int ipw_send_host_complete(struct ipw_priv *priv)
1946{
1947 struct host_cmd cmd = {
1948 .cmd = IPW_CMD_HOST_COMPLETE,
1949 .len = 0
1950 };
1951
1952 if (!priv) {
1953 IPW_ERROR("Invalid args\n");
1954 return -1;
1955 }
1956
9ddf84f6 1957 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 1958}
1959
bf79451e 1960static int ipw_send_system_config(struct ipw_priv *priv,
43f66a6c
JK		 1961 struct ipw_sys_config *config)
1962{
1963 struct host_cmd cmd = {
1964 .cmd = IPW_CMD_SYSTEM_CONFIG,
1965 .len = sizeof(*config)
1966 };
1967
1968 if (!priv || !config) {
1969 IPW_ERROR("Invalid args\n");
1970 return -1;
1971 }
1972
afbf30a2 1973 memcpy(cmd.param, config, sizeof(*config));
9ddf84f6 1974 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 1975}
1976
0edd5b44 1977static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
43f66a6c
JK		 1978{
1979 struct host_cmd cmd = {
1980 .cmd = IPW_CMD_SSID,
1981 .len = min(len, IW_ESSID_MAX_SIZE)
1982 };
1983
1984 if (!priv || !ssid) {
1985 IPW_ERROR("Invalid args\n");
1986 return -1;
1987 }
1988
afbf30a2 1989 memcpy(cmd.param, ssid, cmd.len);
9ddf84f6 1990 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 1991}
1992
0edd5b44 1993static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
43f66a6c
JK		 1994{
1995 struct host_cmd cmd = {
1996 .cmd = IPW_CMD_ADAPTER_ADDRESS,
1997 .len = ETH_ALEN
1998 };
1999
2000 if (!priv || !mac) {
2001 IPW_ERROR("Invalid args\n");
2002 return -1;
2003 }
2004
2005 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
2006 priv->net_dev->name, MAC_ARG(mac));
2007
afbf30a2 2008 memcpy(cmd.param, mac, ETH_ALEN);
9ddf84f6 2009 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2010}
2011
a613bffd
JK		 2012/*
2013 * NOTE: This must be executed from our workqueue as it results in udelay
2014 * being called which may corrupt the keyboard if executed on default
2015 * workqueue
2016 */
43f66a6c
JK		 2017static void ipw_adapter_restart(void *adapter)
2018{
2019 struct ipw_priv *priv = adapter;
2020
2021 if (priv->status & STATUS_RF_KILL_MASK)
2022 return;
2023
2024 ipw_down(priv);
b095c381
JK		 2025
2026 if (priv->assoc_network &&
2027 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2028 ipw_remove_current_network(priv);
2029
43f66a6c
JK		 2030 if (ipw_up(priv)) {
2031 IPW_ERROR("Failed to up device\n");
2032 return;
2033 }
2034}
2035
c848d0af
JK		 2036static void ipw_bg_adapter_restart(void *data)
2037{
2038 struct ipw_priv *priv = data;
2039 down(&priv->sem);
2040 ipw_adapter_restart(data);
2041 up(&priv->sem);
2042}
2043
43f66a6c
JK		 2044#define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2045
2046static void ipw_scan_check(void *data)
2047{
2048 struct ipw_priv *priv = data;
2049 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
2050 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
bf79451e 2051 "adapter (%dms).\n",
43f66a6c 2052 IPW_SCAN_CHECK_WATCHDOG / 100);
a613bffd 2053 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c
JK		 2054 }
2055}
2056
c848d0af
JK		 2057static void ipw_bg_scan_check(void *data)
2058{
2059 struct ipw_priv *priv = data;
2060 down(&priv->sem);
2061 ipw_scan_check(data);
2062 up(&priv->sem);
2063}
2064
43f66a6c
JK		 2065static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2066 struct ipw_scan_request_ext *request)
2067{
2068 struct host_cmd cmd = {
2069 .cmd = IPW_CMD_SCAN_REQUEST_EXT,
2070 .len = sizeof(*request)
2071 };
2072
afbf30a2 2073 memcpy(cmd.param, request, sizeof(*request));
9ddf84f6 2074 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2075}
2076
2077static int ipw_send_scan_abort(struct ipw_priv *priv)
2078{
2079 struct host_cmd cmd = {
2080 .cmd = IPW_CMD_SCAN_ABORT,
2081 .len = 0
2082 };
2083
2084 if (!priv) {
2085 IPW_ERROR("Invalid args\n");
2086 return -1;
2087 }
2088
9ddf84f6 2089 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2090}
2091
2092static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2093{
2094 struct host_cmd cmd = {
2095 .cmd = IPW_CMD_SENSITIVITY_CALIB,
2096 .len = sizeof(struct ipw_sensitivity_calib)
2097 };
2098 struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
0edd5b44 2099 &cmd.param;
43f66a6c 2100 calib->beacon_rssi_raw = sens;
9ddf84f6 2101 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2102}
2103
2104static int ipw_send_associate(struct ipw_priv *priv,
2105 struct ipw_associate *associate)
2106{
2107 struct host_cmd cmd = {
2108 .cmd = IPW_CMD_ASSOCIATE,
2109 .len = sizeof(*associate)
2110 };
2111
a613bffd
JK		 2112 struct ipw_associate tmp_associate;
2113 memcpy(&tmp_associate, associate, sizeof(*associate));
2114 tmp_associate.policy_support =
2115 cpu_to_le16(tmp_associate.policy_support);
2116 tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
2117 tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
2118 tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
2119 tmp_associate.listen_interval =
2120 cpu_to_le16(tmp_associate.listen_interval);
2121 tmp_associate.beacon_interval =
2122 cpu_to_le16(tmp_associate.beacon_interval);
2123 tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);
2124
43f66a6c
JK		 2125 if (!priv || !associate) {
2126 IPW_ERROR("Invalid args\n");
2127 return -1;
2128 }
2129
afbf30a2 2130 memcpy(cmd.param, &tmp_associate, sizeof(*associate));
9ddf84f6 2131 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2132}
2133
2134static int ipw_send_supported_rates(struct ipw_priv *priv,
2135 struct ipw_supported_rates *rates)
2136{
2137 struct host_cmd cmd = {
2138 .cmd = IPW_CMD_SUPPORTED_RATES,
2139 .len = sizeof(*rates)
2140 };
2141
2142 if (!priv || !rates) {
2143 IPW_ERROR("Invalid args\n");
2144 return -1;
2145 }
2146
afbf30a2 2147 memcpy(cmd.param, rates, sizeof(*rates));
9ddf84f6 2148 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2149}
2150
2151static int ipw_set_random_seed(struct ipw_priv *priv)
2152{
2153 struct host_cmd cmd = {
2154 .cmd = IPW_CMD_SEED_NUMBER,
2155 .len = sizeof(u32)
2156 };
2157
2158 if (!priv) {
2159 IPW_ERROR("Invalid args\n");
2160 return -1;
2161 }
2162
2163 get_random_bytes(&cmd.param, sizeof(u32));
2164
9ddf84f6 2165 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2166}
2167
43f66a6c
JK		 2168static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2169{
2170 struct host_cmd cmd = {
2171 .cmd = IPW_CMD_CARD_DISABLE,
2172 .len = sizeof(u32)
2173 };
2174
2175 if (!priv) {
2176 IPW_ERROR("Invalid args\n");
2177 return -1;
2178 }
2179
0edd5b44 2180 *((u32 *) & cmd.param) = phy_off;
43f66a6c 2181
9ddf84f6 2182 return ipw_send_cmd(priv, &cmd);
43f66a6c 2183}
43f66a6c 2184
0edd5b44 2185static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
43f66a6c
JK		 2186{
2187 struct host_cmd cmd = {
2188 .cmd = IPW_CMD_TX_POWER,
2189 .len = sizeof(*power)
2190 };
2191
2192 if (!priv || !power) {
2193 IPW_ERROR("Invalid args\n");
2194 return -1;
2195 }
2196
afbf30a2 2197 memcpy(cmd.param, power, sizeof(*power));
9ddf84f6 2198 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2199}
2200
6de9f7f2
ZY		 2201static int ipw_set_tx_power(struct ipw_priv *priv)
2202{
1fe0adb4 2203 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
6de9f7f2
ZY		 2204 struct ipw_tx_power tx_power;
2205 s8 max_power;
2206 int i;
2207
2208 memset(&tx_power, 0, sizeof(tx_power));
2209
2210 /* configure device for 'G' band */
2211 tx_power.ieee_mode = IPW_G_MODE;
2212 tx_power.num_channels = geo->bg_channels;
2213 for (i = 0; i < geo->bg_channels; i++) {
2214 max_power = geo->bg[i].max_power;
2215 tx_power.channels_tx_power[i].channel_number =
2216 geo->bg[i].channel;
2217 tx_power.channels_tx_power[i].tx_power = max_power ?
2218 min(max_power, priv->tx_power) : priv->tx_power;
43f66a6c 2219 }
6de9f7f2
ZY		 2220 if (ipw_send_tx_power(priv, &tx_power))
2221 return -EIO;
2222
2223 /* configure device to also handle 'B' band */
2224 tx_power.ieee_mode = IPW_B_MODE;
2225 if (ipw_send_tx_power(priv, &tx_power))
2226 return -EIO;
bf79451e 2227
6de9f7f2
ZY		 2228 /* configure device to also handle 'A' band */
2229 if (priv->ieee->abg_true) {
2230 tx_power.ieee_mode = IPW_A_MODE;
2231 tx_power.num_channels = geo->a_channels;
2232 for (i = 0; i < tx_power.num_channels; i++) {
2233 max_power = geo->a[i].max_power;
2234 tx_power.channels_tx_power[i].channel_number =
2235 geo->a[i].channel;
2236 tx_power.channels_tx_power[i].tx_power = max_power ?
2237 min(max_power, priv->tx_power) : priv->tx_power;
2238 }
2239 if (ipw_send_tx_power(priv, &tx_power))
2240 return -EIO;
2241 }
43f66a6c
JK		 2242 return 0;
2243}
2244
2245static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2246{
2247 struct ipw_rts_threshold rts_threshold = {
2248 .rts_threshold = rts,
2249 };
2250 struct host_cmd cmd = {
2251 .cmd = IPW_CMD_RTS_THRESHOLD,
2252 .len = sizeof(rts_threshold)
2253 };
2254
2255 if (!priv) {
2256 IPW_ERROR("Invalid args\n");
2257 return -1;
2258 }
2259
afbf30a2 2260 memcpy(cmd.param, &rts_threshold, sizeof(rts_threshold));
9ddf84f6 2261 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2262}
2263
2264static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2265{
2266 struct ipw_frag_threshold frag_threshold = {
2267 .frag_threshold = frag,
2268 };
2269 struct host_cmd cmd = {
2270 .cmd = IPW_CMD_FRAG_THRESHOLD,
2271 .len = sizeof(frag_threshold)
2272 };
2273
2274 if (!priv) {
2275 IPW_ERROR("Invalid args\n");
2276 return -1;
2277 }
2278
afbf30a2 2279 memcpy(cmd.param, &frag_threshold, sizeof(frag_threshold));
9ddf84f6 2280 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2281}
2282
2283static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2284{
2285 struct host_cmd cmd = {
2286 .cmd = IPW_CMD_POWER_MODE,
2287 .len = sizeof(u32)
2288 };
0edd5b44 2289 u32 *param = (u32 *) (&cmd.param);
43f66a6c
JK		 2290
2291 if (!priv) {
2292 IPW_ERROR("Invalid args\n");
2293 return -1;
2294 }
bf79451e 2295
43f66a6c
JK		 2296 /* If on battery, set to 3, if AC set to CAM, else user
2297 * level */
2298 switch (mode) {
2299 case IPW_POWER_BATTERY:
2300 *param = IPW_POWER_INDEX_3;
2301 break;
2302 case IPW_POWER_AC:
2303 *param = IPW_POWER_MODE_CAM;
2304 break;
2305 default:
2306 *param = mode;
2307 break;
2308 }
2309
9ddf84f6 2310 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 2311}
2312
afbf30a2
JK		 2313static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2314{
2315 struct ipw_retry_limit retry_limit = {
2316 .short_retry_limit = slimit,
2317 .long_retry_limit = llimit
2318 };
2319 struct host_cmd cmd = {
2320 .cmd = IPW_CMD_RETRY_LIMIT,
2321 .len = sizeof(retry_limit)
2322 };
2323
2324 if (!priv) {
2325 IPW_ERROR("Invalid args\n");
2326 return -1;
2327 }
2328
2329 memcpy(cmd.param, &retry_limit, sizeof(retry_limit));
9ddf84f6 2330 return ipw_send_cmd(priv, &cmd);
afbf30a2
JK		 2331}
2332
43f66a6c
JK		 2333/*
2334 * The IPW device contains a Microwire compatible EEPROM that stores
2335 * various data like the MAC address. Usually the firmware has exclusive
2336 * access to the eeprom, but during device initialization (before the
2337 * device driver has sent the HostComplete command to the firmware) the
2338 * device driver has read access to the EEPROM by way of indirect addressing
2339 * through a couple of memory mapped registers.
2340 *
2341 * The following is a simplified implementation for pulling data out of the
2342 * the eeprom, along with some helper functions to find information in
2343 * the per device private data's copy of the eeprom.
2344 *
2345 * NOTE: To better understand how these functions work (i.e what is a chip
2346 * select and why do have to keep driving the eeprom clock?), read
2347 * just about any data sheet for a Microwire compatible EEPROM.
2348 */
2349
2350/* write a 32 bit value into the indirect accessor register */
2351static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2352{
2353 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
bf79451e 2354
43f66a6c
JK		 2355 /* the eeprom requires some time to complete the operation */
2356 udelay(p->eeprom_delay);
2357
2358 return;
2359}
2360
2361/* perform a chip select operation */
0edd5b44 2362static inline void eeprom_cs(struct ipw_priv *priv)
43f66a6c 2363{
0edd5b44
JG		 2364 eeprom_write_reg(priv, 0);
2365 eeprom_write_reg(priv, EEPROM_BIT_CS);
2366 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2367 eeprom_write_reg(priv, EEPROM_BIT_CS);
43f66a6c
JK		 2368}
2369
2370/* perform a chip select operation */
0edd5b44 2371static inline void eeprom_disable_cs(struct ipw_priv *priv)
43f66a6c 2372{
0edd5b44
JG		 2373 eeprom_write_reg(priv, EEPROM_BIT_CS);
2374 eeprom_write_reg(priv, 0);
2375 eeprom_write_reg(priv, EEPROM_BIT_SK);
43f66a6c
JK		 2376}
2377
2378/* push a single bit down to the eeprom */
0edd5b44 2379static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
43f66a6c 2380{
0edd5b44
JG		 2381 int d = (bit ? EEPROM_BIT_DI : 0);
2382 eeprom_write_reg(p, EEPROM_BIT_CS | d);
2383 eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
43f66a6c
JK		 2384}
2385
2386/* push an opcode followed by an address down to the eeprom */
0edd5b44 2387static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
43f66a6c
JK		 2388{
2389 int i;
2390
2391 eeprom_cs(priv);
0edd5b44
JG		 2392 eeprom_write_bit(priv, 1);
2393 eeprom_write_bit(priv, op & 2);
2394 eeprom_write_bit(priv, op & 1);
2395 for (i = 7; i >= 0; i--) {
2396 eeprom_write_bit(priv, addr & (1 << i));
43f66a6c
JK		 2397 }
2398}
2399
2400/* pull 16 bits off the eeprom, one bit at a time */
0edd5b44 2401static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
43f66a6c
JK		 2402{
2403 int i;
0edd5b44 2404 u16 r = 0;
bf79451e 2405
43f66a6c 2406 /* Send READ Opcode */
0edd5b44 2407 eeprom_op(priv, EEPROM_CMD_READ, addr);
43f66a6c
JK		 2408
2409 /* Send dummy bit */
0edd5b44 2410 eeprom_write_reg(priv, EEPROM_BIT_CS);
43f66a6c
JK		 2411
2412 /* Read the byte off the eeprom one bit at a time */
0edd5b44 2413 for (i = 0; i < 16; i++) {
43f66a6c 2414 u32 data = 0;
0edd5b44
JG		 2415 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2416 eeprom_write_reg(priv, EEPROM_BIT_CS);
2417 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2418 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
43f66a6c 2419 }
bf79451e 2420
43f66a6c 2421 /* Send another dummy bit */
0edd5b44 2422 eeprom_write_reg(priv, 0);
43f66a6c 2423 eeprom_disable_cs(priv);
bf79451e 2424
43f66a6c
JK		 2425 return r;
2426}
2427
2428/* helper function for pulling the mac address out of the private */
2429/* data's copy of the eeprom data */
0edd5b44 2430static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
43f66a6c 2431{
afbf30a2 2432 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
43f66a6c
JK		 2433}
2434
2435/*
2436 * Either the device driver (i.e. the host) or the firmware can
2437 * load eeprom data into the designated region in SRAM. If neither
2438 * happens then the FW will shutdown with a fatal error.
2439 *
2440 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2441 * bit needs region of shared SRAM needs to be non-zero.
2442 */
2443static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2444{
2445 int i;
0edd5b44 2446 u16 *eeprom = (u16 *) priv->eeprom;
bf79451e 2447
43f66a6c
JK		 2448 IPW_DEBUG_TRACE(">>\n");
2449
2450 /* read entire contents of eeprom into private buffer */
0edd5b44 2451 for (i = 0; i < 128; i++)
a613bffd 2452 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
43f66a6c 2453
bf79451e
JG		 2454 /*
2455 If the data looks correct, then copy it to our private
43f66a6c
JK		 2456 copy. Otherwise let the firmware know to perform the operation
2457 on it's own
0edd5b44 2458 */
43f66a6c
JK		 2459 if ((priv->eeprom + EEPROM_VERSION) != 0) {
2460 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2461
2462 /* write the eeprom data to sram */
b095c381 2463 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
0edd5b44 2464 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
43f66a6c
JK		 2465
2466 /* Do not load eeprom data on fatal error or suspend */
2467 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2468 } else {
2469 IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");
2470
2471 /* Load eeprom data on fatal error or suspend */
2472 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2473 }
2474
2475 IPW_DEBUG_TRACE("<<\n");
2476}
2477
43f66a6c
JK		 2478static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2479{
2480 count >>= 2;
0edd5b44
JG		 2481 if (!count)
2482 return;
b095c381 2483 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
bf79451e 2484 while (count--)
b095c381 2485 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
43f66a6c
JK		 2486}
2487
2488static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2489{
b095c381 2490 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
bf79451e 2491 CB_NUMBER_OF_ELEMENTS_SMALL *
43f66a6c
JK		 2492 sizeof(struct command_block));
2493}
2494
2495static int ipw_fw_dma_enable(struct ipw_priv *priv)
0edd5b44 2496{ /* start dma engine but no transfers yet */
43f66a6c
JK		 2497
2498 IPW_DEBUG_FW(">> : \n");
bf79451e 2499
43f66a6c
JK		 2500 /* Start the dma */
2501 ipw_fw_dma_reset_command_blocks(priv);
bf79451e 2502
43f66a6c 2503 /* Write CB base address */
b095c381 2504 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
43f66a6c
JK		 2505
2506 IPW_DEBUG_FW("<< : \n");
2507 return 0;
2508}
2509
2510static void ipw_fw_dma_abort(struct ipw_priv *priv)
2511{
2512 u32 control = 0;
2513
2514 IPW_DEBUG_FW(">> :\n");
bf79451e
JG		 2515
2516 //set the Stop and Abort bit
43f66a6c 2517 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
b095c381 2518 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
43f66a6c 2519 priv->sram_desc.last_cb_index = 0;
bf79451e 2520
43f66a6c
JK		 2521 IPW_DEBUG_FW("<< \n");
2522}
2523
0edd5b44
JG		 2524static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2525 struct command_block *cb)
43f66a6c 2526{
0edd5b44 2527 u32 address =
b095c381 2528 IPW_SHARED_SRAM_DMA_CONTROL +
0edd5b44 2529 (sizeof(struct command_block) * index);
43f66a6c
JK		 2530 IPW_DEBUG_FW(">> :\n");
2531
0edd5b44
JG		 2532 ipw_write_indirect(priv, address, (u8 *) cb,
2533 (int)sizeof(struct command_block));
43f66a6c
JK		 2534
2535 IPW_DEBUG_FW("<< :\n");
2536 return 0;
2537
2538}
2539
2540static int ipw_fw_dma_kick(struct ipw_priv *priv)
2541{
2542 u32 control = 0;
0edd5b44 2543 u32 index = 0;
43f66a6c
JK		 2544
2545 IPW_DEBUG_FW(">> :\n");
bf79451e 2546
43f66a6c 2547 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
0edd5b44
JG		 2548 ipw_fw_dma_write_command_block(priv, index,
2549 &priv->sram_desc.cb_list[index]);
43f66a6c
JK		 2550
2551 /* Enable the DMA in the CSR register */
b095c381
JK		 2552 ipw_clear_bit(priv, IPW_RESET_REG,
2553 IPW_RESET_REG_MASTER_DISABLED |
2554 IPW_RESET_REG_STOP_MASTER);
bf79451e 2555
0edd5b44 2556 /* Set the Start bit. */
43f66a6c 2557 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
b095c381 2558 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
43f66a6c
JK		 2559
2560 IPW_DEBUG_FW("<< :\n");
2561 return 0;
2562}
2563
2564static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2565{
2566 u32 address;
0edd5b44
JG		 2567 u32 register_value = 0;
2568 u32 cb_fields_address = 0;
43f66a6c
JK		 2569
2570 IPW_DEBUG_FW(">> :\n");
b095c381 2571 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
0edd5b44 2572 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
43f66a6c
JK		 2573
2574 /* Read the DMA Controlor register */
b095c381
JK		 2575 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2576 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
43f66a6c 2577
0edd5b44 2578 /* Print the CB values */
43f66a6c
JK		 2579 cb_fields_address = address;
2580 register_value = ipw_read_reg32(priv, cb_fields_address);
0edd5b44 2581 IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
43f66a6c
JK		 2582
2583 cb_fields_address += sizeof(u32);
2584 register_value = ipw_read_reg32(priv, cb_fields_address);
0edd5b44 2585 IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
43f66a6c
JK		 2586
2587 cb_fields_address += sizeof(u32);
2588 register_value = ipw_read_reg32(priv, cb_fields_address);
2589 IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
2590 register_value);
2591
2592 cb_fields_address += sizeof(u32);
2593 register_value = ipw_read_reg32(priv, cb_fields_address);
0edd5b44 2594 IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
43f66a6c
JK		 2595
2596 IPW_DEBUG_FW(">> :\n");
2597}
2598
2599static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2600{
2601 u32 current_cb_address = 0;
2602 u32 current_cb_index = 0;
2603
2604 IPW_DEBUG_FW("<< :\n");
b095c381 2605 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
bf79451e 2606
b095c381 2607 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
0edd5b44 2608 sizeof(struct command_block);
bf79451e 2609
43f66a6c 2610 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
0edd5b44 2611 current_cb_index, current_cb_address);
43f66a6c
JK		 2612
2613 IPW_DEBUG_FW(">> :\n");
2614 return current_cb_index;
2615
2616}
2617
2618static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2619 u32 src_address,
2620 u32 dest_address,
2621 u32 length,
0edd5b44 2622 int interrupt_enabled, int is_last)
43f66a6c
JK		 2623{
2624
bf79451e 2625 u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
0edd5b44
JG		 2626 CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2627 CB_DEST_SIZE_LONG;
43f66a6c 2628 struct command_block *cb;
0edd5b44 2629 u32 last_cb_element = 0;
43f66a6c
JK		 2630
2631 IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2632 src_address, dest_address, length);
2633
2634 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2635 return -1;
2636
2637 last_cb_element = priv->sram_desc.last_cb_index;
2638 cb = &priv->sram_desc.cb_list[last_cb_element];
2639 priv->sram_desc.last_cb_index++;
2640
2641 /* Calculate the new CB control word */
0edd5b44 2642 if (interrupt_enabled)
43f66a6c
JK		 2643 control |= CB_INT_ENABLED;
2644
2645 if (is_last)
2646 control |= CB_LAST_VALID;
bf79451e 2647
43f66a6c
JK		 2648 control |= length;
2649
2650 /* Calculate the CB Element's checksum value */
0edd5b44 2651 cb->status = control ^ src_address ^ dest_address;
43f66a6c
JK		 2652
2653 /* Copy the Source and Destination addresses */
2654 cb->dest_addr = dest_address;
2655 cb->source_addr = src_address;
2656
2657 /* Copy the Control Word last */
2658 cb->control = control;
2659
2660 return 0;
2661}
2662
2663static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
0edd5b44 2664 u32 src_phys, u32 dest_address, u32 length)
43f66a6c
JK		 2665{
2666 u32 bytes_left = length;
0edd5b44
JG		 2667 u32 src_offset = 0;
2668 u32 dest_offset = 0;
43f66a6c
JK		 2669 int status = 0;
2670 IPW_DEBUG_FW(">> \n");
2671 IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
2672 src_phys, dest_address, length);
2673 while (bytes_left > CB_MAX_LENGTH) {
0edd5b44
JG		 2674 status = ipw_fw_dma_add_command_block(priv,
2675 src_phys + src_offset,
2676 dest_address +
2677 dest_offset,
2678 CB_MAX_LENGTH, 0, 0);
43f66a6c
JK		 2679 if (status) {
2680 IPW_DEBUG_FW_INFO(": Failed\n");
2681 return -1;
bf79451e 2682 } else
43f66a6c
JK		 2683 IPW_DEBUG_FW_INFO(": Added new cb\n");
2684
2685 src_offset += CB_MAX_LENGTH;
2686 dest_offset += CB_MAX_LENGTH;
2687 bytes_left -= CB_MAX_LENGTH;
2688 }
2689
2690 /* add the buffer tail */
2691 if (bytes_left > 0) {
0edd5b44
JG		 2692 status =
2693 ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
2694 dest_address + dest_offset,
2695 bytes_left, 0, 0);
43f66a6c
JK		 2696 if (status) {
2697 IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
2698 return -1;
bf79451e 2699 } else
0edd5b44
JG		 2700 IPW_DEBUG_FW_INFO
2701 (": Adding new cb - the buffer tail\n");
43f66a6c 2702 }
bf79451e 2703
43f66a6c
JK		 2704 IPW_DEBUG_FW("<< \n");
2705 return 0;
2706}
2707
2708static int ipw_fw_dma_wait(struct ipw_priv *priv)
2709{
2710 u32 current_index = 0;
2711 u32 watchdog = 0;
2712
2713 IPW_DEBUG_FW(">> : \n");
2714
2715 current_index = ipw_fw_dma_command_block_index(priv);
bf79451e 2716 IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%8X\n",
0edd5b44 2717 (int)priv->sram_desc.last_cb_index);
43f66a6c
JK		 2718
2719 while (current_index < priv->sram_desc.last_cb_index) {
2720 udelay(50);
2721 current_index = ipw_fw_dma_command_block_index(priv);
2722
2723 watchdog++;
2724
2725 if (watchdog > 400) {
2726 IPW_DEBUG_FW_INFO("Timeout\n");
2727 ipw_fw_dma_dump_command_block(priv);
2728 ipw_fw_dma_abort(priv);
2729 return -1;
2730 }
2731 }
2732
2733 ipw_fw_dma_abort(priv);
2734
0edd5b44 2735 /*Disable the DMA in the CSR register */
b095c381
JK		 2736 ipw_set_bit(priv, IPW_RESET_REG,
2737 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
43f66a6c
JK		 2738
2739 IPW_DEBUG_FW("<< dmaWaitSync \n");
2740 return 0;
2741}
2742
bf79451e 2743static void ipw_remove_current_network(struct ipw_priv *priv)
43f66a6c
JK		 2744{
2745 struct list_head *element, *safe;
bf79451e 2746 struct ieee80211_network *network = NULL;
a613bffd
JK		 2747 unsigned long flags;
2748
2749 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c
JK		 2750 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2751 network = list_entry(element, struct ieee80211_network, list);
2752 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
2753 list_del(element);
bf79451e 2754 list_add_tail(&network->list,
43f66a6c
JK		 2755 &priv->ieee->network_free_list);
2756 }
2757 }
a613bffd 2758 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c
JK		 2759}
2760
2761/**
bf79451e 2762 * Check that card is still alive.
43f66a6c
JK		 2763 * Reads debug register from domain0.
2764 * If card is present, pre-defined value should
2765 * be found there.
bf79451e 2766 *
43f66a6c
JK		 2767 * @param priv
2768 * @return 1 if card is present, 0 otherwise
2769 */
2770static inline int ipw_alive(struct ipw_priv *priv)
2771{
2772 return ipw_read32(priv, 0x90) == 0xd55555d5;
2773}
2774
2775static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2776 int timeout)
2777{
2778 int i = 0;
2779
2780 do {
bf79451e 2781 if ((ipw_read32(priv, addr) & mask) == mask)
43f66a6c
JK		 2782 return i;
2783 mdelay(10);
2784 i += 10;
2785 } while (i < timeout);
bf79451e 2786
43f66a6c
JK		 2787 return -ETIME;
2788}
2789
bf79451e 2790/* These functions load the firmware and micro code for the operation of
43f66a6c
JK		 2791 * the ipw hardware. It assumes the buffer has all the bits for the
2792 * image and the caller is handling the memory allocation and clean up.
2793 */
2794
0edd5b44 2795static int ipw_stop_master(struct ipw_priv *priv)
43f66a6c
JK		 2796{
2797 int rc;
bf79451e 2798
43f66a6c
JK		 2799 IPW_DEBUG_TRACE(">> \n");
2800 /* stop master. typical delay - 0 */
b095c381 2801 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
43f66a6c 2802
b095c381
JK		 2803 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2804 IPW_RESET_REG_MASTER_DISABLED, 100);
43f66a6c
JK		 2805 if (rc < 0) {
2806 IPW_ERROR("stop master failed in 10ms\n");
2807 return -1;
2808 }
2809
2810 IPW_DEBUG_INFO("stop master %dms\n", rc);
2811
2812 return rc;
2813}
2814
2815static void ipw_arc_release(struct ipw_priv *priv)
2816{
2817 IPW_DEBUG_TRACE(">> \n");
2818 mdelay(5);
2819
b095c381 2820 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
43f66a6c
JK		 2821
2822 /* no one knows timing, for safety add some delay */
2823 mdelay(5);
2824}
2825
2826struct fw_header {
2827 u32 version;
2828 u32 mode;
2829};
2830
2831struct fw_chunk {
2832 u32 address;
2833 u32 length;
2834};
2835
2836#define IPW_FW_MAJOR_VERSION 2
81715376 2837#define IPW_FW_MINOR_VERSION 4
43f66a6c
JK		 2838
2839#define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2840#define IPW_FW_MAJOR(x) (x & 0xff)
2841
afbf30a2 2842#define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
43f66a6c
JK		 2843
2844#define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2845"." __stringify(IPW_FW_MINOR_VERSION) "-"
2846
2847#if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2848#define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2849#else
2850#define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2851#endif
2852
0edd5b44 2853static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
43f66a6c
JK		 2854{
2855 int rc = 0, i, addr;
2856 u8 cr = 0;
2857 u16 *image;
2858
0edd5b44 2859 image = (u16 *) data;
bf79451e 2860
43f66a6c
JK		 2861 IPW_DEBUG_TRACE(">> \n");
2862
2863 rc = ipw_stop_master(priv);
2864
2865 if (rc < 0)
2866 return rc;
bf79451e 2867
0edd5b44 2868// spin_lock_irqsave(&priv->lock, flags);
bf79451e 2869
b095c381
JK		 2870 for (addr = IPW_SHARED_LOWER_BOUND;
2871 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
43f66a6c
JK		 2872 ipw_write32(priv, addr, 0);
2873 }
2874
2875 /* no ucode (yet) */
2876 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2877 /* destroy DMA queues */
2878 /* reset sequence */
2879
b095c381 2880 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
43f66a6c 2881 ipw_arc_release(priv);
b095c381 2882 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
43f66a6c
JK		 2883 mdelay(1);
2884
2885 /* reset PHY */
b095c381 2886 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
43f66a6c 2887 mdelay(1);
bf79451e 2888
b095c381 2889 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
43f66a6c 2890 mdelay(1);
bf79451e 2891
43f66a6c
JK		 2892 /* enable ucode store */
2893 ipw_write_reg8(priv, DINO_CONTROL_REG, 0x0);
2894 ipw_write_reg8(priv, DINO_CONTROL_REG, DINO_ENABLE_CS);
2895 mdelay(1);
2896
2897 /* write ucode */
2898 /**
2899 * @bug
2900 * Do NOT set indirect address register once and then
2901 * store data to indirect data register in the loop.
2902 * It seems very reasonable, but in this case DINO do not
2903 * accept ucode. It is essential to set address each time.
2904 */
2905 /* load new ipw uCode */
2906 for (i = 0; i < len / 2; i++)
b095c381 2907 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
a613bffd 2908 cpu_to_le16(image[i]));
43f66a6c 2909
43f66a6c 2910 /* enable DINO */
b095c381
JK		 2911 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2912 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
43f66a6c 2913
0edd5b44 2914 /* this is where the igx / win driver deveates from the VAP driver. */
43f66a6c
JK		 2915
2916 /* wait for alive response */
2917 for (i = 0; i < 100; i++) {
2918 /* poll for incoming data */
b095c381 2919 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
43f66a6c
JK		 2920 if (cr & DINO_RXFIFO_DATA)
2921 break;
2922 mdelay(1);
2923 }
2924
2925 if (cr & DINO_RXFIFO_DATA) {
2926 /* alive_command_responce size is NOT multiple of 4 */
2927 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
bf79451e
JG		 2928
2929 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
43f66a6c 2930 response_buffer[i] =
a613bffd 2931 le32_to_cpu(ipw_read_reg32(priv,
b095c381 2932 IPW_BASEBAND_RX_FIFO_READ));
43f66a6c
JK		 2933 memcpy(&priv->dino_alive, response_buffer,
2934 sizeof(priv->dino_alive));
2935 if (priv->dino_alive.alive_command == 1
2936 && priv->dino_alive.ucode_valid == 1) {
2937 rc = 0;
0edd5b44
JG		 2938 IPW_DEBUG_INFO
2939 ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2940 "of %02d/%02d/%02d %02d:%02d\n",
2941 priv->dino_alive.software_revision,
2942 priv->dino_alive.software_revision,
2943 priv->dino_alive.device_identifier,
2944 priv->dino_alive.device_identifier,
2945 priv->dino_alive.time_stamp[0],
2946 priv->dino_alive.time_stamp[1],
2947 priv->dino_alive.time_stamp[2],
2948 priv->dino_alive.time_stamp[3],
2949 priv->dino_alive.time_stamp[4]);
43f66a6c
JK		 2950 } else {
2951 IPW_DEBUG_INFO("Microcode is not alive\n");
2952 rc = -EINVAL;
2953 }
2954 } else {
2955 IPW_DEBUG_INFO("No alive response from DINO\n");
2956 rc = -ETIME;
2957 }
2958
2959 /* disable DINO, otherwise for some reason
2960 firmware have problem getting alive resp. */
b095c381 2961 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
43f66a6c 2962
0edd5b44 2963// spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c
JK		 2964
2965 return rc;
2966}
2967
0edd5b44 2968static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
43f66a6c
JK		 2969{
2970 int rc = -1;
2971 int offset = 0;
2972 struct fw_chunk *chunk;
2973 dma_addr_t shared_phys;
2974 u8 *shared_virt;
2975
2976 IPW_DEBUG_TRACE("<< : \n");
2977 shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2978
2979 if (!shared_virt)
2980 return -ENOMEM;
2981
2982 memmove(shared_virt, data, len);
2983
2984 /* Start the Dma */
2985 rc = ipw_fw_dma_enable(priv);
2986
2987 if (priv->sram_desc.last_cb_index > 0) {
2988 /* the DMA is already ready this would be a bug. */
2989 BUG();
2990 goto out;
2991 }
2992
2993 do {
2994 chunk = (struct fw_chunk *)(data + offset);
2995 offset += sizeof(struct fw_chunk);
2996 /* build DMA packet and queue up for sending */
bf79451e 2997 /* dma to chunk->address, the chunk->length bytes from data +
43f66a6c
JK		 2998 * offeset*/
2999 /* Dma loading */
3000 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
a613bffd
JK		 3001 le32_to_cpu(chunk->address),
3002 le32_to_cpu(chunk->length));
43f66a6c
JK		 3003 if (rc) {
3004 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3005 goto out;
3006 }
bf79451e 3007
a613bffd 3008 offset += le32_to_cpu(chunk->length);
43f66a6c
JK		 3009 } while (offset < len);
3010
0edd5b44 3011 /* Run the DMA and wait for the answer */
43f66a6c
JK		 3012 rc = ipw_fw_dma_kick(priv);
3013 if (rc) {
3014 IPW_ERROR("dmaKick Failed\n");
3015 goto out;
3016 }
3017
3018 rc = ipw_fw_dma_wait(priv);
3019 if (rc) {
3020 IPW_ERROR("dmaWaitSync Failed\n");
3021 goto out;
3022 }
0edd5b44
JG		 3023 out:
3024 pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
43f66a6c
JK		 3025 return rc;
3026}
3027
3028/* stop nic */
3029static int ipw_stop_nic(struct ipw_priv *priv)
3030{
3031 int rc = 0;
3032
0edd5b44 3033 /* stop */
b095c381 3034 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
bf79451e 3035
b095c381
JK		 3036 rc = ipw_poll_bit(priv, IPW_RESET_REG,
3037 IPW_RESET_REG_MASTER_DISABLED, 500);
43f66a6c
JK		 3038 if (rc < 0) {
3039 IPW_ERROR("wait for reg master disabled failed\n");
3040 return rc;
bf79451e 3041 }
43f66a6c 3042
b095c381 3043 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
bf79451e 3044
43f66a6c
JK		 3045 return rc;
3046}
3047
3048static void ipw_start_nic(struct ipw_priv *priv)
3049{
3050 IPW_DEBUG_TRACE(">>\n");
3051
0edd5b44 3052 /* prvHwStartNic release ARC */
b095c381
JK		 3053 ipw_clear_bit(priv, IPW_RESET_REG,
3054 IPW_RESET_REG_MASTER_DISABLED |
3055 IPW_RESET_REG_STOP_MASTER |
43f66a6c 3056 CBD_RESET_REG_PRINCETON_RESET);
bf79451e 3057
43f66a6c 3058 /* enable power management */
b095c381
JK		 3059 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3060 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
43f66a6c
JK		 3061
3062 IPW_DEBUG_TRACE("<<\n");
3063}
bf79451e 3064
43f66a6c
JK		 3065static int ipw_init_nic(struct ipw_priv *priv)
3066{
3067 int rc;
3068
3069 IPW_DEBUG_TRACE(">>\n");
bf79451e 3070 /* reset */
43f66a6c
JK		 3071 /*prvHwInitNic */
3072 /* set "initialization complete" bit to move adapter to D0 state */
b095c381 3073 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
43f66a6c
JK		 3074
3075 /* low-level PLL activation */
b095c381
JK		 3076 ipw_write32(priv, IPW_READ_INT_REGISTER,
3077 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
43f66a6c
JK		 3078
3079 /* wait for clock stabilization */
b095c381
JK		 3080 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3081 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
0edd5b44 3082 if (rc < 0)
43f66a6c
JK		 3083 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3084
3085 /* assert SW reset */
b095c381 3086 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
43f66a6c
JK		 3087
3088 udelay(10);
3089
3090 /* set "initialization complete" bit to move adapter to D0 state */
b095c381 3091 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
43f66a6c
JK		 3092
3093 IPW_DEBUG_TRACE(">>\n");
3094 return 0;
3095}
3096
bf79451e 3097/* Call this function from process context, it will sleep in request_firmware.
43f66a6c
JK		 3098 * Probe is an ok place to call this from.
3099 */
3100static int ipw_reset_nic(struct ipw_priv *priv)
3101{
3102 int rc = 0;
a613bffd 3103 unsigned long flags;
43f66a6c
JK		 3104
3105 IPW_DEBUG_TRACE(">>\n");
bf79451e 3106
43f66a6c 3107 rc = ipw_init_nic(priv);
bf79451e 3108
a613bffd 3109 spin_lock_irqsave(&priv->lock, flags);
43f66a6c
JK		 3110 /* Clear the 'host command active' bit... */
3111 priv->status &= ~STATUS_HCMD_ACTIVE;
3112 wake_up_interruptible(&priv->wait_command_queue);
afbf30a2
JK		 3113 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3114 wake_up_interruptible(&priv->wait_state);
a613bffd 3115 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c
JK		 3116
3117 IPW_DEBUG_TRACE("<<\n");
3118 return rc;
bf79451e 3119}
43f66a6c 3120
bf79451e 3121static int ipw_get_fw(struct ipw_priv *priv,
43f66a6c
JK		 3122 const struct firmware **fw, const char *name)
3123{
3124 struct fw_header *header;
3125 int rc;
3126
3127 /* ask firmware_class module to get the boot firmware off disk */
3128 rc = request_firmware(fw, name, &priv->pci_dev->dev);
3129 if (rc < 0) {
3130 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3131 return rc;
bf79451e 3132 }
43f66a6c
JK		 3133
3134 header = (struct fw_header *)(*fw)->data;
a613bffd 3135 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
43f66a6c
JK		 3136 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3137 name,
a613bffd
JK		 3138 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3139 IPW_FW_MAJOR_VERSION);
43f66a6c
JK		 3140 return -EINVAL;
3141 }
3142
aaa4d308 3143 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
43f66a6c 3144 name,
a613bffd
JK		 3145 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3146 IPW_FW_MINOR(le32_to_cpu(header->version)),
43f66a6c
JK		 3147 (*fw)->size - sizeof(struct fw_header));
3148 return 0;
3149}
3150
b095c381 3151#define IPW_RX_BUF_SIZE (3000)
43f66a6c
JK		 3152
3153static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
3154 struct ipw_rx_queue *rxq)
3155{
3156 unsigned long flags;
3157 int i;
3158
3159 spin_lock_irqsave(&rxq->lock, flags);
3160
3161 INIT_LIST_HEAD(&rxq->rx_free);
3162 INIT_LIST_HEAD(&rxq->rx_used);
3163
3164 /* Fill the rx_used queue with _all_ of the Rx buffers */
3165 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3166 /* In the reset function, these buffers may have been allocated
3167 * to an SKB, so we need to unmap and free potential storage */
3168 if (rxq->pool[i].skb != NULL) {
3169 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
b095c381 3170 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 3171 dev_kfree_skb(rxq->pool[i].skb);
a613bffd 3172 rxq->pool[i].skb = NULL;
43f66a6c
JK		 3173 }
3174 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3175 }
bf79451e 3176
43f66a6c
JK		 3177 /* Set us so that we have processed and used all buffers, but have
3178 * not restocked the Rx queue with fresh buffers */
3179 rxq->read = rxq->write = 0;
3180 rxq->processed = RX_QUEUE_SIZE - 1;
3181 rxq->free_count = 0;
3182 spin_unlock_irqrestore(&rxq->lock, flags);
3183}
3184
3185#ifdef CONFIG_PM
3186static int fw_loaded = 0;
3187static const struct firmware *bootfw = NULL;
3188static const struct firmware *firmware = NULL;
3189static const struct firmware *ucode = NULL;
afbf30a2
JK		 3190
3191static void free_firmware(void)
3192{
3193 if (fw_loaded) {
3194 release_firmware(bootfw);
3195 release_firmware(ucode);
3196 release_firmware(firmware);
3197 bootfw = ucode = firmware = NULL;
3198 fw_loaded = 0;
3199 }
3200}
3201#else
3202#define free_firmware() do {} while (0)
43f66a6c
JK		 3203#endif
3204
3205static int ipw_load(struct ipw_priv *priv)
3206{
3207#ifndef CONFIG_PM
3208 const struct firmware *bootfw = NULL;
3209 const struct firmware *firmware = NULL;
3210 const struct firmware *ucode = NULL;
3211#endif
3212 int rc = 0, retries = 3;
3213
3214#ifdef CONFIG_PM
3215 if (!fw_loaded) {
3216#endif
3217 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
bf79451e 3218 if (rc)
43f66a6c 3219 goto error;
bf79451e 3220
43f66a6c
JK		 3221 switch (priv->ieee->iw_mode) {
3222 case IW_MODE_ADHOC:
bf79451e 3223 rc = ipw_get_fw(priv, &ucode,
43f66a6c 3224 IPW_FW_NAME("ibss_ucode"));
bf79451e 3225 if (rc)
43f66a6c 3226 goto error;
bf79451e 3227
43f66a6c
JK		 3228 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
3229 break;
bf79451e 3230
b095c381 3231#ifdef CONFIG_IPW2200_MONITOR
43f66a6c 3232 case IW_MODE_MONITOR:
bf79451e 3233 rc = ipw_get_fw(priv, &ucode,
ea2b26e0 3234 IPW_FW_NAME("sniffer_ucode"));
bf79451e 3235 if (rc)
43f66a6c 3236 goto error;
bf79451e 3237
0edd5b44
JG		 3238 rc = ipw_get_fw(priv, &firmware,
3239 IPW_FW_NAME("sniffer"));
43f66a6c
JK		 3240 break;
3241#endif
3242 case IW_MODE_INFRA:
0edd5b44 3243 rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
bf79451e 3244 if (rc)
43f66a6c 3245 goto error;
bf79451e 3246
43f66a6c
JK		 3247 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("bss"));
3248 break;
bf79451e 3249
43f66a6c
JK		 3250 default:
3251 rc = -EINVAL;
3252 }
3253
bf79451e 3254 if (rc)
43f66a6c
JK		 3255 goto error;
3256
3257#ifdef CONFIG_PM
3258 fw_loaded = 1;
3259 }
3260#endif
3261
3262 if (!priv->rxq)
3263 priv->rxq = ipw_rx_queue_alloc(priv);
3264 else
3265 ipw_rx_queue_reset(priv, priv->rxq);
3266 if (!priv->rxq) {
3267 IPW_ERROR("Unable to initialize Rx queue\n");
3268 goto error;
3269 }
3270
0edd5b44 3271 retry:
43f66a6c 3272 /* Ensure interrupts are disabled */
b095c381 3273 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
43f66a6c
JK		 3274 priv->status &= ~STATUS_INT_ENABLED;
3275
3276 /* ack pending interrupts */
b095c381 3277 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
bf79451e 3278
43f66a6c
JK		 3279 ipw_stop_nic(priv);
3280
3281 rc = ipw_reset_nic(priv);
3282 if (rc) {
3283 IPW_ERROR("Unable to reset NIC\n");
3284 goto error;
3285 }
3286
b095c381
JK		 3287 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3288 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
43f66a6c
JK		 3289
3290 /* DMA the initial boot firmware into the device */
bf79451e 3291 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
43f66a6c
JK		 3292 bootfw->size - sizeof(struct fw_header));
3293 if (rc < 0) {
a4f6bbb3 3294 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
43f66a6c
JK		 3295 goto error;
3296 }
3297
3298 /* kick start the device */
3299 ipw_start_nic(priv);
3300
3301 /* wait for the device to finish it's initial startup sequence */
b095c381
JK		 3302 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3303 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
43f66a6c
JK		 3304 if (rc < 0) {
3305 IPW_ERROR("device failed to boot initial fw image\n");
3306 goto error;
3307 }
3308 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3309
bf79451e 3310 /* ack fw init done interrupt */
b095c381 3311 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
43f66a6c
JK		 3312
3313 /* DMA the ucode into the device */
bf79451e 3314 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
43f66a6c
JK		 3315 ucode->size - sizeof(struct fw_header));
3316 if (rc < 0) {
a4f6bbb3 3317 IPW_ERROR("Unable to load ucode: %d\n", rc);
43f66a6c
JK		 3318 goto error;
3319 }
bf79451e 3320
43f66a6c
JK		 3321 /* stop nic */
3322 ipw_stop_nic(priv);
3323
3324 /* DMA bss firmware into the device */
bf79451e
JG		 3325 rc = ipw_load_firmware(priv, firmware->data +
3326 sizeof(struct fw_header),
43f66a6c 3327 firmware->size - sizeof(struct fw_header));
0edd5b44 3328 if (rc < 0) {
a4f6bbb3 3329 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 3330 goto error;
3331 }
3332
3333 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3334
3335 rc = ipw_queue_reset(priv);
3336 if (rc) {
3337 IPW_ERROR("Unable to initialize queues\n");
3338 goto error;
3339 }
3340
3341 /* Ensure interrupts are disabled */
b095c381 3342 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
c848d0af 3343 /* ack pending interrupts */
b095c381 3344 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
bf79451e 3345
43f66a6c
JK		 3346 /* kick start the device */
3347 ipw_start_nic(priv);
3348
b095c381 3349 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
43f66a6c
JK		 3350 if (retries > 0) {
3351 IPW_WARNING("Parity error. Retrying init.\n");
3352 retries--;
3353 goto retry;
3354 }
3355
3356 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3357 rc = -EIO;
3358 goto error;
3359 }
3360
3361 /* wait for the device */
b095c381
JK		 3362 rc = ipw_poll_bit(priv, IPW_INTA_RW,
3363 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
43f66a6c
JK		 3364 if (rc < 0) {
3365 IPW_ERROR("device failed to start after 500ms\n");
3366 goto error;
3367 }
3368 IPW_DEBUG_INFO("device response after %dms\n", rc);
3369
3370 /* ack fw init done interrupt */
b095c381 3371 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
43f66a6c
JK		 3372
3373 /* read eeprom data and initialize the eeprom region of sram */
3374 priv->eeprom_delay = 1;
bf79451e 3375 ipw_eeprom_init_sram(priv);
43f66a6c
JK		 3376
3377 /* enable interrupts */
3378 ipw_enable_interrupts(priv);
3379
3380 /* Ensure our queue has valid packets */
3381 ipw_rx_queue_replenish(priv);
3382
b095c381 3383 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
43f66a6c
JK		 3384
3385 /* ack pending interrupts */
b095c381 3386 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
43f66a6c
JK		 3387
3388#ifndef CONFIG_PM
3389 release_firmware(bootfw);
3390 release_firmware(ucode);
3391 release_firmware(firmware);
3392#endif
3393 return 0;
3394
0edd5b44 3395 error:
43f66a6c
JK		 3396 if (priv->rxq) {
3397 ipw_rx_queue_free(priv, priv->rxq);
3398 priv->rxq = NULL;
3399 }
3400 ipw_tx_queue_free(priv);
3401 if (bootfw)
3402 release_firmware(bootfw);
3403 if (ucode)
3404 release_firmware(ucode);
3405 if (firmware)
3406 release_firmware(firmware);
3407#ifdef CONFIG_PM
3408 fw_loaded = 0;
3409 bootfw = ucode = firmware = NULL;
3410#endif
3411
3412 return rc;
3413}
3414
bf79451e 3415/**
43f66a6c
JK		 3416 * DMA services
3417 *
3418 * Theory of operation
3419 *
3420 * A queue is a circular buffers with 'Read' and 'Write' pointers.
3421 * 2 empty entries always kept in the buffer to protect from overflow.
3422 *
3423 * For Tx queue, there are low mark and high mark limits. If, after queuing
bf79451e
JG		 3424 * the packet for Tx, free space become < low mark, Tx queue stopped. When
3425 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
43f66a6c
JK		 3426 * Tx queue resumed.
3427 *
3428 * The IPW operates with six queues, one receive queue in the device's
3429 * sram, one transmit queue for sending commands to the device firmware,
bf79451e 3430 * and four transmit queues for data.
43f66a6c 3431 *
bf79451e 3432 * The four transmit queues allow for performing quality of service (qos)
43f66a6c 3433 * transmissions as per the 802.11 protocol. Currently Linux does not
bf79451e 3434 * provide a mechanism to the user for utilizing prioritized queues, so
43f66a6c
JK		 3435 * we only utilize the first data transmit queue (queue1).
3436 */
3437
3438/**
3439 * Driver allocates buffers of this size for Rx
3440 */
3441
3442static inline int ipw_queue_space(const struct clx2_queue *q)
3443{
3444 int s = q->last_used - q->first_empty;
3445 if (s <= 0)
3446 s += q->n_bd;
3447 s -= 2; /* keep some reserve to not confuse empty and full situations */
3448 if (s < 0)
3449 s = 0;
3450 return s;
3451}
3452
3453static inline int ipw_queue_inc_wrap(int index, int n_bd)
3454{
3455 return (++index == n_bd) ? 0 : index;
3456}
3457
3458/**
3459 * Initialize common DMA queue structure
bf79451e 3460 *
43f66a6c
JK		 3461 * @param q queue to init
3462 * @param count Number of BD's to allocate. Should be power of 2
3463 * @param read_register Address for 'read' register
3464 * (not offset within BAR, full address)
3465 * @param write_register Address for 'write' register
3466 * (not offset within BAR, full address)
3467 * @param base_register Address for 'base' register
3468 * (not offset within BAR, full address)
3469 * @param size Address for 'size' register
3470 * (not offset within BAR, full address)
3471 */
bf79451e 3472static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
0edd5b44 3473 int count, u32 read, u32 write, u32 base, u32 size)
43f66a6c
JK		 3474{
3475 q->n_bd = count;
3476
3477 q->low_mark = q->n_bd / 4;
3478 if (q->low_mark < 4)
3479 q->low_mark = 4;
3480
3481 q->high_mark = q->n_bd / 8;
3482 if (q->high_mark < 2)
3483 q->high_mark = 2;
3484
3485 q->first_empty = q->last_used = 0;
3486 q->reg_r = read;
3487 q->reg_w = write;
3488
3489 ipw_write32(priv, base, q->dma_addr);
3490 ipw_write32(priv, size, count);
3491 ipw_write32(priv, read, 0);
3492 ipw_write32(priv, write, 0);
3493
3494 _ipw_read32(priv, 0x90);
3495}
3496
bf79451e 3497static int ipw_queue_tx_init(struct ipw_priv *priv,
43f66a6c 3498 struct clx2_tx_queue *q,
0edd5b44 3499 int count, u32 read, u32 write, u32 base, u32 size)
43f66a6c
JK		 3500{
3501 struct pci_dev *dev = priv->pci_dev;
3502
3503 q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3504 if (!q->txb) {
3505 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3506 return -ENOMEM;
3507 }
3508
0edd5b44
JG		 3509 q->bd =
3510 pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
43f66a6c 3511 if (!q->bd) {
aaa4d308 3512 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
0edd5b44 3513 sizeof(q->bd[0]) * count);
43f66a6c
JK		 3514 kfree(q->txb);
3515 q->txb = NULL;
3516 return -ENOMEM;
3517 }
3518
3519 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3520 return 0;
3521}
3522
3523/**
3524 * Free one TFD, those at index [txq->q.last_used].
3525 * Do NOT advance any indexes
bf79451e 3526 *
43f66a6c
JK		 3527 * @param dev
3528 * @param txq
3529 */
3530static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3531 struct clx2_tx_queue *txq)
3532{
3533 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3534 struct pci_dev *dev = priv->pci_dev;
3535 int i;
bf79451e 3536
43f66a6c
JK		 3537 /* classify bd */
3538 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3539 /* nothing to cleanup after for host commands */
3540 return;
3541
3542 /* sanity check */
a613bffd
JK		 3543 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3544 IPW_ERROR("Too many chunks: %i\n",
3545 le32_to_cpu(bd->u.data.num_chunks));
43f66a6c
JK		 3546 /** @todo issue fatal error, it is quite serious situation */
3547 return;
3548 }
3549
3550 /* unmap chunks if any */
a613bffd
JK		 3551 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3552 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3553 le16_to_cpu(bd->u.data.chunk_len[i]),
3554 PCI_DMA_TODEVICE);
43f66a6c
JK		 3555 if (txq->txb[txq->q.last_used]) {
3556 ieee80211_txb_free(txq->txb[txq->q.last_used]);
3557 txq->txb[txq->q.last_used] = NULL;
3558 }
3559 }
3560}
3561
3562/**
3563 * Deallocate DMA queue.
bf79451e 3564 *
43f66a6c
JK		 3565 * Empty queue by removing and destroying all BD's.
3566 * Free all buffers.
bf79451e 3567 *
43f66a6c
JK		 3568 * @param dev
3569 * @param q
3570 */
0edd5b44 3571static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
43f66a6c
JK		 3572{
3573 struct clx2_queue *q = &txq->q;
3574 struct pci_dev *dev = priv->pci_dev;
3575
bf79451e
JG		 3576 if (q->n_bd == 0)
3577 return;
43f66a6c
JK		 3578
3579 /* first, empty all BD's */
3580 for (; q->first_empty != q->last_used;
3581 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3582 ipw_queue_tx_free_tfd(priv, txq);
3583 }
bf79451e 3584
43f66a6c 3585 /* free buffers belonging to queue itself */
0edd5b44 3586 pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
43f66a6c
JK		 3587 q->dma_addr);
3588 kfree(txq->txb);
3589
3590 /* 0 fill whole structure */
3591 memset(txq, 0, sizeof(*txq));
3592}
3593
43f66a6c
JK		 3594/**
3595 * Destroy all DMA queues and structures
bf79451e 3596 *
43f66a6c
JK		 3597 * @param priv
3598 */
3599static void ipw_tx_queue_free(struct ipw_priv *priv)
3600{
3601 /* Tx CMD queue */
3602 ipw_queue_tx_free(priv, &priv->txq_cmd);
3603
3604 /* Tx queues */
3605 ipw_queue_tx_free(priv, &priv->txq[0]);
3606 ipw_queue_tx_free(priv, &priv->txq[1]);
3607 ipw_queue_tx_free(priv, &priv->txq[2]);
3608 ipw_queue_tx_free(priv, &priv->txq[3]);
3609}
3610
0edd5b44 3611static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3612{
3613 /* First 3 bytes are manufacturer */
3614 bssid[0] = priv->mac_addr[0];
3615 bssid[1] = priv->mac_addr[1];
3616 bssid[2] = priv->mac_addr[2];
3617
3618 /* Last bytes are random */
0edd5b44 3619 get_random_bytes(&bssid[3], ETH_ALEN - 3);
43f66a6c 3620
0edd5b44
JG		 3621 bssid[0] &= 0xfe; /* clear multicast bit */
3622 bssid[0] |= 0x02; /* set local assignment bit (IEEE802) */
43f66a6c
JK		 3623}
3624
0edd5b44 3625static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3626{
3627 struct ipw_station_entry entry;
3628 int i;
3629
3630 for (i = 0; i < priv->num_stations; i++) {
3631 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3632 /* Another node is active in network */
3633 priv->missed_adhoc_beacons = 0;
3634 if (!(priv->config & CFG_STATIC_CHANNEL))
3635 /* when other nodes drop out, we drop out */
3636 priv->config &= ~CFG_ADHOC_PERSIST;
3637
3638 return i;
3639 }
3640 }
3641
3642 if (i == MAX_STATIONS)
3643 return IPW_INVALID_STATION;
3644
3645 IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3646
3647 entry.reserved = 0;
3648 entry.support_mode = 0;
3649 memcpy(entry.mac_addr, bssid, ETH_ALEN);
3650 memcpy(priv->stations[i], bssid, ETH_ALEN);
3651 ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
0edd5b44 3652 &entry, sizeof(entry));
43f66a6c
JK		 3653 priv->num_stations++;
3654
3655 return i;
3656}
3657
0edd5b44 3658static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
43f66a6c
JK		 3659{
3660 int i;
3661
bf79451e
JG		 3662 for (i = 0; i < priv->num_stations; i++)
3663 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
43f66a6c
JK		 3664 return i;
3665
3666 return IPW_INVALID_STATION;
3667}
3668
3669static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3670{
3671 int err;
3672
7b99659f
HL		 3673 if (priv->status & STATUS_ASSOCIATING) {
3674 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3675 queue_work(priv->workqueue, &priv->disassociate);
3676 return;
3677 }
3678
3679 if (!(priv->status & STATUS_ASSOCIATED)) {
43f66a6c
JK		 3680 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3681 return;
3682 }
3683
3684 IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3685 "on channel %d.\n",
bf79451e 3686 MAC_ARG(priv->assoc_request.bssid),
43f66a6c
JK		 3687 priv->assoc_request.channel);
3688
3689 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3690 priv->status |= STATUS_DISASSOCIATING;
3691
3692 if (quiet)
3693 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3694 else
3695 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
e6324726 3696
43f66a6c
JK		 3697 err = ipw_send_associate(priv, &priv->assoc_request);
3698 if (err) {
3699 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3700 "failed.\n");
3701 return;
3702 }
3703
3704}
3705
c848d0af 3706static int ipw_disassociate(void *data)
43f66a6c 3707{
c848d0af
JK		 3708 struct ipw_priv *priv = data;
3709 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3710 return 0;
43f66a6c 3711 ipw_send_disassociate(data, 0);
c848d0af 3712 return 1;
43f66a6c
JK		 3713}
3714
c848d0af 3715static void ipw_bg_disassociate(void *data)
43f66a6c 3716{
c848d0af
JK		 3717 struct ipw_priv *priv = data;
3718 down(&priv->sem);
3719 ipw_disassociate(data);
3720 up(&priv->sem);
43f66a6c
JK		 3721}
3722
d8bad6df
ZY		 3723static void ipw_system_config(void *data)
3724{
3725 struct ipw_priv *priv = data;
3726 ipw_send_system_config(priv, &priv->sys_config);
43f66a6c
JK		 3727}
3728
3729struct ipw_status_code {
3730 u16 status;
3731 const char *reason;
3732};
3733
3734static const struct ipw_status_code ipw_status_codes[] = {
3735 {0x00, "Successful"},
3736 {0x01, "Unspecified failure"},
3737 {0x0A, "Cannot support all requested capabilities in the "
3738 "Capability information field"},
3739 {0x0B, "Reassociation denied due to inability to confirm that "
3740 "association exists"},
3741 {0x0C, "Association denied due to reason outside the scope of this "
3742 "standard"},
0edd5b44
JG		 3743 {0x0D,
3744 "Responding station does not support the specified authentication "
43f66a6c 3745 "algorithm"},
0edd5b44
JG		 3746 {0x0E,
3747 "Received an Authentication frame with authentication sequence "
43f66a6c
JK		 3748 "transaction sequence number out of expected sequence"},
3749 {0x0F, "Authentication rejected because of challenge failure"},
3750 {0x10, "Authentication rejected due to timeout waiting for next "
3751 "frame in sequence"},
3752 {0x11, "Association denied because AP is unable to handle additional "
3753 "associated stations"},
0edd5b44
JG		 3754 {0x12,
3755 "Association denied due to requesting station not supporting all "
43f66a6c 3756 "of the datarates in the BSSBasicServiceSet Parameter"},
0edd5b44
JG		 3757 {0x13,
3758 "Association denied due to requesting station not supporting "
43f66a6c 3759 "short preamble operation"},
0edd5b44
JG		 3760 {0x14,
3761 "Association denied due to requesting station not supporting "
43f66a6c 3762 "PBCC encoding"},
0edd5b44
JG		 3763 {0x15,
3764 "Association denied due to requesting station not supporting "
43f66a6c 3765 "channel agility"},
0edd5b44
JG		 3766 {0x19,
3767 "Association denied due to requesting station not supporting "
43f66a6c 3768 "short slot operation"},
0edd5b44
JG		 3769 {0x1A,
3770 "Association denied due to requesting station not supporting "
43f66a6c
JK		 3771 "DSSS-OFDM operation"},
3772 {0x28, "Invalid Information Element"},
3773 {0x29, "Group Cipher is not valid"},
3774 {0x2A, "Pairwise Cipher is not valid"},
3775 {0x2B, "AKMP is not valid"},
3776 {0x2C, "Unsupported RSN IE version"},
3777 {0x2D, "Invalid RSN IE Capabilities"},
3778 {0x2E, "Cipher suite is rejected per security policy"},
3779};
3780
0f52bf90 3781#ifdef CONFIG_IPW2200_DEBUG
bf79451e 3782static const char *ipw_get_status_code(u16 status)
43f66a6c
JK		 3783{
3784 int i;
bf79451e 3785 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
ea2b26e0 3786 if (ipw_status_codes[i].status == (status & 0xff))
43f66a6c
JK		 3787 return ipw_status_codes[i].reason;
3788 return "Unknown status value.";
3789}
3790#endif
3791
3792static void inline average_init(struct average *avg)
3793{
3794 memset(avg, 0, sizeof(*avg));
3795}
3796
3797static void inline average_add(struct average *avg, s16 val)
3798{
3799 avg->sum -= avg->entries[avg->pos];
3800 avg->sum += val;
3801 avg->entries[avg->pos++] = val;
3802 if (unlikely(avg->pos == AVG_ENTRIES)) {
3803 avg->init = 1;
3804 avg->pos = 0;
3805 }
3806}
3807
3808static s16 inline average_value(struct average *avg)
3809{
3810 if (!unlikely(avg->init)) {
3811 if (avg->pos)
3812 return avg->sum / avg->pos;
3813 return 0;
3814 }
3815
3816 return avg->sum / AVG_ENTRIES;
3817}
3818
3819static void ipw_reset_stats(struct ipw_priv *priv)
3820{
3821 u32 len = sizeof(u32);
3822
3823 priv->quality = 0;
3824
3825 average_init(&priv->average_missed_beacons);
3826 average_init(&priv->average_rssi);
3827 average_init(&priv->average_noise);
3828
3829 priv->last_rate = 0;
3830 priv->last_missed_beacons = 0;
3831 priv->last_rx_packets = 0;
3832 priv->last_tx_packets = 0;
3833 priv->last_tx_failures = 0;
bf79451e 3834
43f66a6c
JK		 3835 /* Firmware managed, reset only when NIC is restarted, so we have to
3836 * normalize on the current value */
bf79451e 3837 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
43f66a6c 3838 &priv->last_rx_err, &len);
bf79451e 3839 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
43f66a6c
JK		 3840 &priv->last_tx_failures, &len);
3841
3842 /* Driver managed, reset with each association */
3843 priv->missed_adhoc_beacons = 0;
3844 priv->missed_beacons = 0;
3845 priv->tx_packets = 0;
3846 priv->rx_packets = 0;
3847
3848}
3849
43f66a6c
JK		 3850static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
3851{
3852 u32 i = 0x80000000;
3853 u32 mask = priv->rates_mask;
3854 /* If currently associated in B mode, restrict the maximum
3855 * rate match to B rates */
3856 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3857 mask &= IEEE80211_CCK_RATES_MASK;
3858
3859 /* TODO: Verify that the rate is supported by the current rates
3860 * list. */
3861
0edd5b44
JG		 3862 while (i && !(mask & i))
3863 i >>= 1;
43f66a6c 3864 switch (i) {
ea2b26e0
JK		 3865 case IEEE80211_CCK_RATE_1MB_MASK:
3866 return 1000000;
3867 case IEEE80211_CCK_RATE_2MB_MASK:
3868 return 2000000;
3869 case IEEE80211_CCK_RATE_5MB_MASK:
3870 return 5500000;
3871 case IEEE80211_OFDM_RATE_6MB_MASK:
3872 return 6000000;
3873 case IEEE80211_OFDM_RATE_9MB_MASK:
3874 return 9000000;
3875 case IEEE80211_CCK_RATE_11MB_MASK:
3876 return 11000000;
3877 case IEEE80211_OFDM_RATE_12MB_MASK:
3878 return 12000000;
3879 case IEEE80211_OFDM_RATE_18MB_MASK:
3880 return 18000000;
3881 case IEEE80211_OFDM_RATE_24MB_MASK:
3882 return 24000000;
3883 case IEEE80211_OFDM_RATE_36MB_MASK:
3884 return 36000000;
3885 case IEEE80211_OFDM_RATE_48MB_MASK:
3886 return 48000000;
3887 case IEEE80211_OFDM_RATE_54MB_MASK:
3888 return 54000000;
43f66a6c
JK		 3889 }
3890
bf79451e 3891 if (priv->ieee->mode == IEEE_B)
43f66a6c
JK		 3892 return 11000000;
3893 else
3894 return 54000000;
3895}
3896
3897static u32 ipw_get_current_rate(struct ipw_priv *priv)
3898{
3899 u32 rate, len = sizeof(rate);
3900 int err;
3901
bf79451e 3902 if (!(priv->status & STATUS_ASSOCIATED))
43f66a6c
JK		 3903 return 0;
3904
3905 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
bf79451e 3906 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
43f66a6c
JK		 3907 &len);
3908 if (err) {
3909 IPW_DEBUG_INFO("failed querying ordinals.\n");
3910 return 0;
3911 }
bf79451e 3912 } else
43f66a6c
JK		 3913 return ipw_get_max_rate(priv);
3914
3915 switch (rate) {
ea2b26e0
JK		 3916 case IPW_TX_RATE_1MB:
3917 return 1000000;
3918 case IPW_TX_RATE_2MB:
3919 return 2000000;
3920 case IPW_TX_RATE_5MB:
3921 return 5500000;
3922 case IPW_TX_RATE_6MB:
3923 return 6000000;
3924 case IPW_TX_RATE_9MB:
3925 return 9000000;
3926 case IPW_TX_RATE_11MB:
3927 return 11000000;
3928 case IPW_TX_RATE_12MB:
3929 return 12000000;
3930 case IPW_TX_RATE_18MB:
3931 return 18000000;
3932 case IPW_TX_RATE_24MB:
3933 return 24000000;
3934 case IPW_TX_RATE_36MB:
3935 return 36000000;
3936 case IPW_TX_RATE_48MB:
3937 return 48000000;
3938 case IPW_TX_RATE_54MB:
3939 return 54000000;
43f66a6c
JK		 3940 }
3941
3942 return 0;
3943}
3944
43f66a6c
JK		 3945#define IPW_STATS_INTERVAL (2 * HZ)
3946static void ipw_gather_stats(struct ipw_priv *priv)
3947{
3948 u32 rx_err, rx_err_delta, rx_packets_delta;
3949 u32 tx_failures, tx_failures_delta, tx_packets_delta;
3950 u32 missed_beacons_percent, missed_beacons_delta;
3951 u32 quality = 0;
3952 u32 len = sizeof(u32);
3953 s16 rssi;
bf79451e 3954 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
0edd5b44 3955 rate_quality;
ea2b26e0 3956 u32 max_rate;
43f66a6c
JK		 3957
3958 if (!(priv->status & STATUS_ASSOCIATED)) {
3959 priv->quality = 0;
3960 return;
3961 }
3962
3963 /* Update the statistics */
bf79451e 3964 ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
43f66a6c 3965 &priv->missed_beacons, &len);
0edd5b44 3966 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
43f66a6c
JK		 3967 priv->last_missed_beacons = priv->missed_beacons;
3968 if (priv->assoc_request.beacon_interval) {
3969 missed_beacons_percent = missed_beacons_delta *
0edd5b44
JG		 3970 (HZ * priv->assoc_request.beacon_interval) /
3971 (IPW_STATS_INTERVAL * 10);
43f66a6c
JK		 3972 } else {
3973 missed_beacons_percent = 0;
3974 }
3975 average_add(&priv->average_missed_beacons, missed_beacons_percent);
3976
3977 ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3978 rx_err_delta = rx_err - priv->last_rx_err;
3979 priv->last_rx_err = rx_err;
3980
3981 ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3982 tx_failures_delta = tx_failures - priv->last_tx_failures;
3983 priv->last_tx_failures = tx_failures;
3984
3985 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
3986 priv->last_rx_packets = priv->rx_packets;
3987
3988 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
3989 priv->last_tx_packets = priv->tx_packets;
3990
3991 /* Calculate quality based on the following:
bf79451e 3992 *
43f66a6c
JK		 3993 * Missed beacon: 100% = 0, 0% = 70% missed
3994 * Rate: 60% = 1Mbs, 100% = Max
3995 * Rx and Tx errors represent a straight % of total Rx/Tx
3996 * RSSI: 100% = > -50, 0% = < -80
3997 * Rx errors: 100% = 0, 0% = 50% missed
bf79451e 3998 *
43f66a6c
JK		 3999 * The lowest computed quality is used.
4000 *
4001 */
4002#define BEACON_THRESHOLD 5
4003 beacon_quality = 100 - missed_beacons_percent;
4004 if (beacon_quality < BEACON_THRESHOLD)
4005 beacon_quality = 0;
4006 else
bf79451e 4007 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
0edd5b44 4008 (100 - BEACON_THRESHOLD);
bf79451e 4009 IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
43f66a6c 4010 beacon_quality, missed_beacons_percent);
bf79451e 4011
43f66a6c 4012 priv->last_rate = ipw_get_current_rate(priv);
ea2b26e0
JK		 4013 max_rate = ipw_get_max_rate(priv);
4014 rate_quality = priv->last_rate * 40 / max_rate + 60;
43f66a6c
JK		 4015 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4016 rate_quality, priv->last_rate / 1000000);
bf79451e 4017
0edd5b44 4018 if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
bf79451e 4019 rx_quality = 100 - (rx_err_delta * 100) /
0edd5b44 4020 (rx_packets_delta + rx_err_delta);
43f66a6c
JK		 4021 else
4022 rx_quality = 100;
4023 IPW_DEBUG_STATS("Rx quality : %3d%% (%u errors, %u packets)\n",
4024 rx_quality, rx_err_delta, rx_packets_delta);
bf79451e 4025
0edd5b44 4026 if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
bf79451e 4027 tx_quality = 100 - (tx_failures_delta * 100) /
0edd5b44 4028 (tx_packets_delta + tx_failures_delta);
43f66a6c
JK		 4029 else
4030 tx_quality = 100;
4031 IPW_DEBUG_STATS("Tx quality : %3d%% (%u errors, %u packets)\n",
4032 tx_quality, tx_failures_delta, tx_packets_delta);
bf79451e 4033
43f66a6c 4034 rssi = average_value(&priv->average_rssi);
c848d0af
JK		 4035 signal_quality =
4036 (100 *
4037 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4038 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4039 (priv->ieee->perfect_rssi - rssi) *
4040 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4041 62 * (priv->ieee->perfect_rssi - rssi))) /
4042 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4043 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4044 if (signal_quality > 100)
43f66a6c 4045 signal_quality = 100;
c848d0af 4046 else if (signal_quality < 1)
43f66a6c 4047 signal_quality = 0;
ea2b26e0 4048
43f66a6c
JK		 4049 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4050 signal_quality, rssi);
bf79451e
JG		 4051
4052 quality = min(beacon_quality,
43f66a6c
JK		 4053 min(rate_quality,
4054 min(tx_quality, min(rx_quality, signal_quality))));
4055 if (quality == beacon_quality)
0edd5b44
JG		 4056 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4057 quality);
43f66a6c 4058 if (quality == rate_quality)
0edd5b44
JG		 4059 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4060 quality);
43f66a6c 4061 if (quality == tx_quality)
0edd5b44
JG		 4062 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4063 quality);
43f66a6c 4064 if (quality == rx_quality)
0edd5b44
JG		 4065 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4066 quality);
43f66a6c 4067 if (quality == signal_quality)
0edd5b44
JG		 4068 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4069 quality);
43f66a6c
JK		 4070
4071 priv->quality = quality;
bf79451e
JG		 4072
4073 queue_delayed_work(priv->workqueue, &priv->gather_stats,
43f66a6c
JK		 4074 IPW_STATS_INTERVAL);
4075}
4076
c848d0af
JK		 4077static void ipw_bg_gather_stats(void *data)
4078{
4079 struct ipw_priv *priv = data;
4080 down(&priv->sem);
4081 ipw_gather_stats(data);
4082 up(&priv->sem);
4083}
4084
e7582561
BC		 4085/* Missed beacon behavior:
4086 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4087 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4088 * Above disassociate threshold, give up and stop scanning.
4089 * Roaming is disabled if disassociate_threshold <= roaming_threshold */
ea2b26e0
JK		 4090static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
4091 int missed_count)
4092{
4093 priv->notif_missed_beacons = missed_count;
4094
afbf30a2 4095 if (missed_count > priv->disassociate_threshold &&
ea2b26e0
JK		 4096 priv->status & STATUS_ASSOCIATED) {
4097 /* If associated and we've hit the missed
4098 * beacon threshold, disassociate, turn
4099 * off roaming, and abort any active scans */
4100 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
afbf30a2 4101 IPW_DL_STATE | IPW_DL_ASSOC,
ea2b26e0
JK		 4102 "Missed beacon: %d - disassociate\n", missed_count);
4103 priv->status &= ~STATUS_ROAMING;
a613bffd
JK		 4104 if (priv->status & STATUS_SCANNING) {
4105 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4106 IPW_DL_STATE,
4107 "Aborting scan with missed beacon.\n");
ea2b26e0 4108 queue_work(priv->workqueue, &priv->abort_scan);
a613bffd
JK		 4109 }
4110
ea2b26e0
JK		 4111 queue_work(priv->workqueue, &priv->disassociate);
4112 return;
4113 }
4114
4115 if (priv->status & STATUS_ROAMING) {
4116 /* If we are currently roaming, then just
4117 * print a debug statement... */
4118 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4119 "Missed beacon: %d - roam in progress\n",
4120 missed_count);
4121 return;
4122 }
4123
e7582561
BC		 4124 if (missed_count > priv->roaming_threshold &&
4125 missed_count <= priv->disassociate_threshold) {
ea2b26e0 4126 /* If we are not already roaming, set the ROAM
e7582561
BC		 4127 * bit in the status and kick off a scan.
4128 * This can happen several times before we reach
4129 * disassociate_threshold. */
ea2b26e0
JK		 4130 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4131 "Missed beacon: %d - initiate "
4132 "roaming\n", missed_count);
4133 if (!(priv->status & STATUS_ROAMING)) {
4134 priv->status |= STATUS_ROAMING;
4135 if (!(priv->status & STATUS_SCANNING))
4136 queue_work(priv->workqueue,
4137 &priv->request_scan);
4138 }
4139 return;
4140 }
4141
4142 if (priv->status & STATUS_SCANNING) {
4143 /* Stop scan to keep fw from getting
4144 * stuck (only if we aren't roaming --
4145 * otherwise we'll never scan more than 2 or 3
4146 * channels..) */
b095c381
JK		 4147 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4148 "Aborting scan with missed beacon.\n");
ea2b26e0
JK		 4149 queue_work(priv->workqueue, &priv->abort_scan);
4150 }
4151
4152 IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4153
4154}
4155
43f66a6c
JK		 4156/**
4157 * Handle host notification packet.
4158 * Called from interrupt routine
4159 */
0edd5b44 4160static inline void ipw_rx_notification(struct ipw_priv *priv,
43f66a6c
JK		 4161 struct ipw_rx_notification *notif)
4162{
a613bffd
JK		 4163 notif->size = le16_to_cpu(notif->size);
4164
0edd5b44 4165 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
bf79451e 4166
43f66a6c 4167 switch (notif->subtype) {
0edd5b44
JG		 4168 case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4169 struct notif_association *assoc = &notif->u.assoc;
4170
4171 switch (assoc->state) {
4172 case CMAS_ASSOCIATED:{
4173 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4174 IPW_DL_ASSOC,
4175 "associated: '%s' " MAC_FMT
4176 " \n",
4177 escape_essid(priv->essid,
4178 priv->essid_len),
4179 MAC_ARG(priv->bssid));
4180
4181 switch (priv->ieee->iw_mode) {
4182 case IW_MODE_INFRA:
4183 memcpy(priv->ieee->bssid,
4184 priv->bssid, ETH_ALEN);
4185 break;
4186
4187 case IW_MODE_ADHOC:
4188 memcpy(priv->ieee->bssid,
4189 priv->bssid, ETH_ALEN);
4190
4191 /* clear out the station table */
4192 priv->num_stations = 0;
4193
4194 IPW_DEBUG_ASSOC
4195 ("queueing adhoc check\n");
4196 queue_delayed_work(priv->
4197 workqueue,
4198 &priv->
4199 adhoc_check,
4200 priv->
4201 assoc_request.
4202 beacon_interval);
4203 break;
4204 }
4205
4206 priv->status &= ~STATUS_ASSOCIATING;
4207 priv->status |= STATUS_ASSOCIATED;
d8bad6df
ZY		 4208 queue_work(priv->workqueue,
4209 &priv->system_config);
0edd5b44 4210
b095c381 4211#ifdef CONFIG_IPW_QOS
afbf30a2
JK		 4212#define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4213 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4214 if ((priv->status & STATUS_AUTH) &&
4215 (IPW_GET_PACKET_STYPE(&notif->u.raw)
4216 == IEEE80211_STYPE_ASSOC_RESP)) {
b095c381
JK		 4217 if ((sizeof
4218 (struct
2b184d5b 4219 ieee80211_assoc_response)
b095c381
JK		 4220 <= notif->size)
4221 && (notif->size <= 2314)) {
4222 struct
4223 ieee80211_rx_stats
4224 stats = {
4225 .len =
4226 notif->
4227 size - 1,
4228 };
4229
4230 IPW_DEBUG_QOS
4231 ("QoS Associate "
4232 "size %d\n",
4233 notif->size);
4234 ieee80211_rx_mgt(priv->
4235 ieee,
4236 (struct
2b184d5b 4237 ieee80211_hdr_4addr
b095c381
JK		 4238 *)
4239 &notif->u.raw, &stats);
4240 }
0edd5b44 4241 }
b095c381 4242#endif
0edd5b44 4243
a613bffd 4244 schedule_work(&priv->link_up);
43f66a6c 4245
0edd5b44
JG		 4246 break;
4247 }
bf79451e 4248
0edd5b44
JG		 4249 case CMAS_AUTHENTICATED:{
4250 if (priv->
4251 status & (STATUS_ASSOCIATED |
4252 STATUS_AUTH)) {
0f52bf90 4253#ifdef CONFIG_IPW2200_DEBUG
0edd5b44
JG		 4254 struct notif_authenticate *auth
4255 = &notif->u.auth;
4256 IPW_DEBUG(IPW_DL_NOTIF |
4257 IPW_DL_STATE |
4258 IPW_DL_ASSOC,
4259 "deauthenticated: '%s' "
4260 MAC_FMT
4261 ": (0x%04X) - %s \n",
4262 escape_essid(priv->
4263 essid,
4264 priv->
4265 essid_len),
4266 MAC_ARG(priv->bssid),
4267 ntohs(auth->status),
4268 ipw_get_status_code
4269 (ntohs
4270 (auth->status)));
43f66a6c
JK		 4271#endif
4272
0edd5b44
JG		 4273 priv->status &=
4274 ~(STATUS_ASSOCIATING |
4275 STATUS_AUTH |
4276 STATUS_ASSOCIATED);
4277
a613bffd 4278 schedule_work(&priv->link_down);
0edd5b44
JG		 4279 break;
4280 }
4281
4282 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4283 IPW_DL_ASSOC,
4284 "authenticated: '%s' " MAC_FMT
4285 "\n",
4286 escape_essid(priv->essid,
4287 priv->essid_len),
4288 MAC_ARG(priv->bssid));
4289 break;
4290 }
4291
4292 case CMAS_INIT:{
ea2b26e0
JK		 4293 if (priv->status & STATUS_AUTH) {
4294 struct
4295 ieee80211_assoc_response
4296 *resp;
4297 resp =
4298 (struct
4299 ieee80211_assoc_response
4300 *)&notif->u.raw;
4301 IPW_DEBUG(IPW_DL_NOTIF |
4302 IPW_DL_STATE |
4303 IPW_DL_ASSOC,
4304 "association failed (0x%04X): %s\n",
4305 ntohs(resp->status),
4306 ipw_get_status_code
4307 (ntohs
4308 (resp->status)));
4309 }
4310
0edd5b44
JG		 4311 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4312 IPW_DL_ASSOC,
4313 "disassociated: '%s' " MAC_FMT
4314 " \n",
4315 escape_essid(priv->essid,
4316 priv->essid_len),
4317 MAC_ARG(priv->bssid));
4318
4319 priv->status &=
4320 ~(STATUS_DISASSOCIATING |
4321 STATUS_ASSOCIATING |
4322 STATUS_ASSOCIATED | STATUS_AUTH);
b095c381
JK		 4323 if (priv->assoc_network
4324 && (priv->assoc_network->
4325 capability &
4326 WLAN_CAPABILITY_IBSS))
4327 ipw_remove_current_network
4328 (priv);
0edd5b44 4329
a613bffd 4330 schedule_work(&priv->link_down);
0edd5b44 4331
0edd5b44
JG		 4332 break;
4333 }
43f66a6c 4334
b095c381
JK		 4335 case CMAS_RX_ASSOC_RESP:
4336 break;
4337
0edd5b44
JG		 4338 default:
4339 IPW_ERROR("assoc: unknown (%d)\n",
4340 assoc->state);
43f66a6c 4341 break;
bf79451e 4342 }
43f66a6c 4343
43f66a6c
JK		 4344 break;
4345 }
bf79451e 4346
0edd5b44
JG		 4347 case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4348 struct notif_authenticate *auth = &notif->u.auth;
4349 switch (auth->state) {
4350 case CMAS_AUTHENTICATED:
4351 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4352 "authenticated: '%s' " MAC_FMT " \n",
4353 escape_essid(priv->essid,
4354 priv->essid_len),
4355 MAC_ARG(priv->bssid));
4356 priv->status |= STATUS_AUTH;
4357 break;
43f66a6c 4358
0edd5b44
JG		 4359 case CMAS_INIT:
4360 if (priv->status & STATUS_AUTH) {
4361 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4362 IPW_DL_ASSOC,
4363 "authentication failed (0x%04X): %s\n",
4364 ntohs(auth->status),
4365 ipw_get_status_code(ntohs
4366 (auth->
4367 status)));
4368 }
4369 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4370 IPW_DL_ASSOC,
4371 "deauthenticated: '%s' " MAC_FMT "\n",
4372 escape_essid(priv->essid,
4373 priv->essid_len),
4374 MAC_ARG(priv->bssid));
bf79451e 4375
0edd5b44
JG		 4376 priv->status &= ~(STATUS_ASSOCIATING |
4377 STATUS_AUTH |
4378 STATUS_ASSOCIATED);
43f66a6c 4379
a613bffd 4380 schedule_work(&priv->link_down);
0edd5b44 4381 break;
43f66a6c 4382
0edd5b44
JG		 4383 case CMAS_TX_AUTH_SEQ_1:
4384 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4385 IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4386 break;
4387 case CMAS_RX_AUTH_SEQ_2:
4388 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4389 IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4390 break;
4391 case CMAS_AUTH_SEQ_1_PASS:
4392 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4393 IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4394 break;
4395 case CMAS_AUTH_SEQ_1_FAIL:
4396 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4397 IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4398 break;
4399 case CMAS_TX_AUTH_SEQ_3:
4400 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4401 IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4402 break;
4403 case CMAS_RX_AUTH_SEQ_4:
4404 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4405 IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4406 break;
4407 case CMAS_AUTH_SEQ_2_PASS:
4408 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4409 IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4410 break;
4411 case CMAS_AUTH_SEQ_2_FAIL:
4412 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4413 IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4414 break;
4415 case CMAS_TX_ASSOC:
4416 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4417 IPW_DL_ASSOC, "TX_ASSOC\n");
4418 break;
4419 case CMAS_RX_ASSOC_RESP:
4420 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4421 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
b095c381 4422
0edd5b44
JG		 4423 break;
4424 case CMAS_ASSOCIATED:
4425 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4426 IPW_DL_ASSOC, "ASSOCIATED\n");
4427 break;
4428 default:
4429 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4430 auth->state);
4431 break;
43f66a6c 4432 }
43f66a6c
JK		 4433 break;
4434 }
4435
0edd5b44
JG		 4436 case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4437 struct notif_channel_result *x =
4438 &notif->u.channel_result;
43f66a6c 4439
0edd5b44
JG		 4440 if (notif->size == sizeof(*x)) {
4441 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4442 x->channel_num);
4443 } else {
4444 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4445 "(should be %zd)\n",
4446 notif->size, sizeof(*x));
bf79451e 4447 }
43f66a6c
JK		 4448 break;
4449 }
43f66a6c 4450
0edd5b44
JG		 4451 case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4452 struct notif_scan_complete *x = &notif->u.scan_complete;
4453 if (notif->size == sizeof(*x)) {
4454 IPW_DEBUG_SCAN
4455 ("Scan completed: type %d, %d channels, "
4456 "%d status\n", x->scan_type,
4457 x->num_channels, x->status);
4458 } else {
4459 IPW_ERROR("Scan completed of wrong size %d "
4460 "(should be %zd)\n",
4461 notif->size, sizeof(*x));
4462 }
43f66a6c 4463
0edd5b44
JG		 4464 priv->status &=
4465 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4466
a0e04ab3 4467 wake_up_interruptible(&priv->wait_state);
0edd5b44
JG		 4468 cancel_delayed_work(&priv->scan_check);
4469
b095c381
JK		 4470 if (priv->status & STATUS_EXIT_PENDING)
4471 break;
4472
4473 priv->ieee->scans++;
4474
4475#ifdef CONFIG_IPW2200_MONITOR
4476 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 4477 priv->status |= STATUS_SCAN_FORCED;
b095c381
JK		 4478 queue_work(priv->workqueue,
4479 &priv->request_scan);
4480 break;
4481 }
afbf30a2 4482 priv->status &= ~STATUS_SCAN_FORCED;
b095c381
JK		 4483#endif /* CONFIG_IPW2200_MONITOR */
4484
0edd5b44
JG		 4485 if (!(priv->status & (STATUS_ASSOCIATED |
4486 STATUS_ASSOCIATING |
4487 STATUS_ROAMING |
4488 STATUS_DISASSOCIATING)))
4489 queue_work(priv->workqueue, &priv->associate);
4490 else if (priv->status & STATUS_ROAMING) {
e7582561
BC		 4491 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4492 /* If a scan completed and we are in roam mode, then
4493 * the scan that completed was the one requested as a
4494 * result of entering roam... so, schedule the
4495 * roam work */
4496 queue_work(priv->workqueue,
4497 &priv->roam);
4498 else
4499 /* Don't schedule if we aborted the scan */
4500 priv->status &= ~STATUS_ROAMING;
0edd5b44
JG		 4501 } else if (priv->status & STATUS_SCAN_PENDING)
4502 queue_work(priv->workqueue,
4503 &priv->request_scan);
a613bffd
JK		 4504 else if (priv->config & CFG_BACKGROUND_SCAN
4505 && priv->status & STATUS_ASSOCIATED)
4506 queue_delayed_work(priv->workqueue,
4507 &priv->request_scan, HZ);
0edd5b44 4508 break;
43f66a6c 4509 }
43f66a6c 4510
0edd5b44
JG		 4511 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4512 struct notif_frag_length *x = &notif->u.frag_len;
43f66a6c 4513
a613bffd
JK		 4514 if (notif->size == sizeof(*x))
4515 IPW_ERROR("Frag length: %d\n",
4516 le16_to_cpu(x->frag_length));
4517 else
0edd5b44
JG		 4518 IPW_ERROR("Frag length of wrong size %d "
4519 "(should be %zd)\n",
4520 notif->size, sizeof(*x));
0edd5b44 4521 break;
43f66a6c 4522 }
43f66a6c 4523
0edd5b44
JG		 4524 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4525 struct notif_link_deterioration *x =
4526 &notif->u.link_deterioration;
afbf30a2 4527
0edd5b44
JG		 4528 if (notif->size == sizeof(*x)) {
4529 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4530 "link deterioration: '%s' " MAC_FMT
4531 " \n", escape_essid(priv->essid,
4532 priv->essid_len),
4533 MAC_ARG(priv->bssid));
4534 memcpy(&priv->last_link_deterioration, x,
4535 sizeof(*x));
4536 } else {
4537 IPW_ERROR("Link Deterioration of wrong size %d "
4538 "(should be %zd)\n",
4539 notif->size, sizeof(*x));
4540 }
43f66a6c
JK		 4541 break;
4542 }
4543
0edd5b44
JG		 4544 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4545 IPW_ERROR("Dino config\n");
4546 if (priv->hcmd
a613bffd 4547 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
0edd5b44 4548 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
a613bffd 4549
0edd5b44
JG		 4550 break;
4551 }
43f66a6c 4552
0edd5b44
JG		 4553 case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4554 struct notif_beacon_state *x = &notif->u.beacon_state;
4555 if (notif->size != sizeof(*x)) {
4556 IPW_ERROR
4557 ("Beacon state of wrong size %d (should "
4558 "be %zd)\n", notif->size, sizeof(*x));
4559 break;
43f66a6c
JK		 4560 }
4561
a613bffd
JK		 4562 if (le32_to_cpu(x->state) ==
4563 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4564 ipw_handle_missed_beacon(priv,
4565 le32_to_cpu(x->
4566 number));
43f66a6c 4567
0edd5b44
JG		 4568 break;
4569 }
43f66a6c 4570
0edd5b44
JG		 4571 case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4572 struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
4573 if (notif->size == sizeof(*x)) {
4574 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4575 "0x%02x station %d\n",
4576 x->key_state, x->security_type,
4577 x->station_index);
4578 break;
4579 }
43f66a6c 4580
0edd5b44
JG		 4581 IPW_ERROR
4582 ("TGi Tx Key of wrong size %d (should be %zd)\n",
4583 notif->size, sizeof(*x));
43f66a6c 4584 break;
bf79451e 4585 }
43f66a6c 4586
0edd5b44
JG		 4587 case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4588 struct notif_calibration *x = &notif->u.calibration;
43f66a6c 4589
0edd5b44
JG		 4590 if (notif->size == sizeof(*x)) {
4591 memcpy(&priv->calib, x, sizeof(*x));
4592 IPW_DEBUG_INFO("TODO: Calibration\n");
4593 break;
4594 }
43f66a6c 4595
0edd5b44
JG		 4596 IPW_ERROR
4597 ("Calibration of wrong size %d (should be %zd)\n",
4598 notif->size, sizeof(*x));
43f66a6c 4599 break;
bf79451e
JG		 4600 }
4601
0edd5b44
JG		 4602 case HOST_NOTIFICATION_NOISE_STATS:{
4603 if (notif->size == sizeof(u32)) {
4604 priv->last_noise =
a613bffd
JK		 4605 (u8) (le32_to_cpu(notif->u.noise.value) &
4606 0xff);
0edd5b44
JG		 4607 average_add(&priv->average_noise,
4608 priv->last_noise);
4609 break;
4610 }
43f66a6c 4611
0edd5b44
JG		 4612 IPW_ERROR
4613 ("Noise stat is wrong size %d (should be %zd)\n",
4614 notif->size, sizeof(u32));
43f66a6c
JK		 4615 break;
4616 }
4617
43f66a6c
JK		 4618 default:
4619 IPW_ERROR("Unknown notification: "
4620 "subtype=%d,flags=0x%2x,size=%d\n",
4621 notif->subtype, notif->flags, notif->size);
4622 }
4623}
4624
4625/**
4626 * Destroys all DMA structures and initialise them again
bf79451e 4627 *
43f66a6c
JK		 4628 * @param priv
4629 * @return error code
4630 */
4631static int ipw_queue_reset(struct ipw_priv *priv)
4632{
4633 int rc = 0;
4634 /** @todo customize queue sizes */
4635 int nTx = 64, nTxCmd = 8;
4636 ipw_tx_queue_free(priv);
4637 /* Tx CMD queue */
4638 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
b095c381
JK		 4639 IPW_TX_CMD_QUEUE_READ_INDEX,
4640 IPW_TX_CMD_QUEUE_WRITE_INDEX,
4641 IPW_TX_CMD_QUEUE_BD_BASE,
4642 IPW_TX_CMD_QUEUE_BD_SIZE);
43f66a6c
JK		 4643 if (rc) {
4644 IPW_ERROR("Tx Cmd queue init failed\n");
4645 goto error;
4646 }
4647 /* Tx queue(s) */
4648 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
b095c381
JK		 4649 IPW_TX_QUEUE_0_READ_INDEX,
4650 IPW_TX_QUEUE_0_WRITE_INDEX,
4651 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
43f66a6c
JK		 4652 if (rc) {
4653 IPW_ERROR("Tx 0 queue init failed\n");
4654 goto error;
4655 }
4656 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
b095c381
JK		 4657 IPW_TX_QUEUE_1_READ_INDEX,
4658 IPW_TX_QUEUE_1_WRITE_INDEX,
4659 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
43f66a6c
JK		 4660 if (rc) {
4661 IPW_ERROR("Tx 1 queue init failed\n");
4662 goto error;
4663 }
4664 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
b095c381
JK		 4665 IPW_TX_QUEUE_2_READ_INDEX,
4666 IPW_TX_QUEUE_2_WRITE_INDEX,
4667 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
43f66a6c
JK		 4668 if (rc) {
4669 IPW_ERROR("Tx 2 queue init failed\n");
4670 goto error;
4671 }
4672 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
b095c381
JK		 4673 IPW_TX_QUEUE_3_READ_INDEX,
4674 IPW_TX_QUEUE_3_WRITE_INDEX,
4675 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
43f66a6c
JK		 4676 if (rc) {
4677 IPW_ERROR("Tx 3 queue init failed\n");
4678 goto error;
4679 }
4680 /* statistics */
4681 priv->rx_bufs_min = 0;
4682 priv->rx_pend_max = 0;
4683 return rc;
4684
0edd5b44 4685 error:
43f66a6c
JK		 4686 ipw_tx_queue_free(priv);
4687 return rc;
4688}
4689
4690/**
4691 * Reclaim Tx queue entries no more used by NIC.
bf79451e 4692 *
43f66a6c
JK		 4693 * When FW adwances 'R' index, all entries between old and
4694 * new 'R' index need to be reclaimed. As result, some free space
4695 * forms. If there is enough free space (> low mark), wake Tx queue.
bf79451e 4696 *
43f66a6c
JK		 4697 * @note Need to protect against garbage in 'R' index
4698 * @param priv
4699 * @param txq
4700 * @param qindex
4701 * @return Number of used entries remains in the queue
4702 */
bf79451e 4703static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
43f66a6c
JK		 4704 struct clx2_tx_queue *txq, int qindex)
4705{
4706 u32 hw_tail;
4707 int used;
4708 struct clx2_queue *q = &txq->q;
4709
4710 hw_tail = ipw_read32(priv, q->reg_r);
4711 if (hw_tail >= q->n_bd) {
4712 IPW_ERROR
0edd5b44
JG		 4713 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4714 hw_tail, q->n_bd);
43f66a6c
JK		 4715 goto done;
4716 }
4717 for (; q->last_used != hw_tail;
4718 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4719 ipw_queue_tx_free_tfd(priv, txq);
4720 priv->tx_packets++;
4721 }
0edd5b44 4722 done:
9ddf84f6
JK		 4723 if ((ipw_queue_space(q) > q->low_mark) &&
4724 (qindex >= 0) &&
4725 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4726 netif_wake_queue(priv->net_dev);
43f66a6c
JK		 4727 used = q->first_empty - q->last_used;
4728 if (used < 0)
4729 used += q->n_bd;
4730
4731 return used;
4732}
4733
4734static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4735 int len, int sync)
4736{
4737 struct clx2_tx_queue *txq = &priv->txq_cmd;
4738 struct clx2_queue *q = &txq->q;
4739 struct tfd_frame *tfd;
4740
4741 if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4742 IPW_ERROR("No space for Tx\n");
4743 return -EBUSY;
4744 }
4745
4746 tfd = &txq->bd[q->first_empty];
4747 txq->txb[q->first_empty] = NULL;
4748
4749 memset(tfd, 0, sizeof(*tfd));
4750 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4751 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4752 priv->hcmd_seq++;
4753 tfd->u.cmd.index = hcmd;
4754 tfd->u.cmd.length = len;
4755 memcpy(tfd->u.cmd.payload, buf, len);
4756 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4757 ipw_write32(priv, q->reg_w, q->first_empty);
4758 _ipw_read32(priv, 0x90);
4759
4760 return 0;
4761}
4762
bf79451e 4763/*
43f66a6c
JK		 4764 * Rx theory of operation
4765 *
4766 * The host allocates 32 DMA target addresses and passes the host address
b095c381 4767 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
43f66a6c
JK		 4768 * 0 to 31
4769 *
4770 * Rx Queue Indexes
4771 * The host/firmware share two index registers for managing the Rx buffers.
4772 *
bf79451e
JG		 4773 * The READ index maps to the first position that the firmware may be writing
4774 * to -- the driver can read up to (but not including) this position and get
4775 * good data.
43f66a6c
JK		 4776 * The READ index is managed by the firmware once the card is enabled.
4777 *
4778 * The WRITE index maps to the last position the driver has read from -- the
4779 * position preceding WRITE is the last slot the firmware can place a packet.
4780 *
4781 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
bf79451e 4782 * WRITE = READ.
43f66a6c 4783 *
bf79451e 4784 * During initialization the host sets up the READ queue position to the first
43f66a6c
JK		 4785 * INDEX position, and WRITE to the last (READ - 1 wrapped)
4786 *
4787 * When the firmware places a packet in a buffer it will advance the READ index
4788 * and fire the RX interrupt. The driver can then query the READ index and
4789 * process as many packets as possible, moving the WRITE index forward as it
4790 * resets the Rx queue buffers with new memory.
bf79451e 4791 *
43f66a6c 4792 * The management in the driver is as follows:
bf79451e 4793 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
43f66a6c 4794 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
bf79451e 4795 * to replensish the ipw->rxq->rx_free.
43f66a6c
JK		 4796 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4797 * ipw->rxq is replenished and the READ INDEX is updated (updating the
4798 * 'processed' and 'read' driver indexes as well)
4799 * + A received packet is processed and handed to the kernel network stack,
4800 * detached from the ipw->rxq. The driver 'processed' index is updated.
4801 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
bf79451e
JG		 4802 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4803 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
43f66a6c
JK		 4804 * were enough free buffers and RX_STALLED is set it is cleared.
4805 *
4806 *
4807 * Driver sequence:
4808 *
bf79451e 4809 * ipw_rx_queue_alloc() Allocates rx_free
43f66a6c
JK		 4810 * ipw_rx_queue_replenish() Replenishes rx_free list from rx_used, and calls
4811 * ipw_rx_queue_restock
4812 * ipw_rx_queue_restock() Moves available buffers from rx_free into Rx
4813 * queue, updates firmware pointers, and updates
4814 * the WRITE index. If insufficient rx_free buffers
4815 * are available, schedules ipw_rx_queue_replenish
4816 *
4817 * -- enable interrupts --
4818 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
bf79451e 4819 * READ INDEX, detaching the SKB from the pool.
43f66a6c
JK		 4820 * Moves the packet buffer from queue to rx_used.
4821 * Calls ipw_rx_queue_restock to refill any empty
4822 * slots.
4823 * ...
4824 *
4825 */
4826
bf79451e 4827/*
43f66a6c
JK		 4828 * If there are slots in the RX queue that need to be restocked,
4829 * and we have free pre-allocated buffers, fill the ranks as much
4830 * as we can pulling from rx_free.
4831 *
4832 * This moves the 'write' index forward to catch up with 'processed', and
4833 * also updates the memory address in the firmware to reference the new
4834 * target buffer.
4835 */
4836static void ipw_rx_queue_restock(struct ipw_priv *priv)
4837{
4838 struct ipw_rx_queue *rxq = priv->rxq;
4839 struct list_head *element;
4840 struct ipw_rx_mem_buffer *rxb;
4841 unsigned long flags;
4842 int write;
4843
4844 spin_lock_irqsave(&rxq->lock, flags);
4845 write = rxq->write;
4846 while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4847 element = rxq->rx_free.next;
4848 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4849 list_del(element);
4850
b095c381 4851 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
43f66a6c
JK		 4852 rxb->dma_addr);
4853 rxq->queue[rxq->write] = rxb;
4854 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4855 rxq->free_count--;
4856 }
4857 spin_unlock_irqrestore(&rxq->lock, flags);
4858
bf79451e 4859 /* If the pre-allocated buffer pool is dropping low, schedule to
43f66a6c
JK		 4860 * refill it */
4861 if (rxq->free_count <= RX_LOW_WATERMARK)
4862 queue_work(priv->workqueue, &priv->rx_replenish);
4863
4864 /* If we've added more space for the firmware to place data, tell it */
bf79451e 4865 if (write != rxq->write)
b095c381 4866 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
43f66a6c
JK		 4867}
4868
4869/*
4870 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
bf79451e
JG		 4871 * Also restock the Rx queue via ipw_rx_queue_restock.
4872 *
43f66a6c
JK		 4873 * This is called as a scheduled work item (except for during intialization)
4874 */
4875static void ipw_rx_queue_replenish(void *data)
4876{
4877 struct ipw_priv *priv = data;
4878 struct ipw_rx_queue *rxq = priv->rxq;
4879 struct list_head *element;
4880 struct ipw_rx_mem_buffer *rxb;
4881 unsigned long flags;
4882
4883 spin_lock_irqsave(&rxq->lock, flags);
4884 while (!list_empty(&rxq->rx_used)) {
4885 element = rxq->rx_used.next;
4886 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
b095c381 4887 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
43f66a6c
JK		 4888 if (!rxb->skb) {
4889 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4890 priv->net_dev->name);
4891 /* We don't reschedule replenish work here -- we will
4892 * call the restock method and if it still needs
4893 * more buffers it will schedule replenish */
4894 break;
4895 }
4896 list_del(element);
bf79451e 4897
43f66a6c 4898 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
0edd5b44
JG		 4899 rxb->dma_addr =
4900 pci_map_single(priv->pci_dev, rxb->skb->data,
b095c381 4901 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
bf79451e 4902
43f66a6c
JK		 4903 list_add_tail(&rxb->list, &rxq->rx_free);
4904 rxq->free_count++;
4905 }
4906 spin_unlock_irqrestore(&rxq->lock, flags);
4907
4908 ipw_rx_queue_restock(priv);
4909}
4910
c848d0af
JK		 4911static void ipw_bg_rx_queue_replenish(void *data)
4912{
4913 struct ipw_priv *priv = data;
4914 down(&priv->sem);
4915 ipw_rx_queue_replenish(data);
4916 up(&priv->sem);
4917}
4918
43f66a6c
JK		 4919/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4920 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL
bf79451e 4921 * This free routine walks the list of POOL entries and if SKB is set to
43f66a6c
JK		 4922 * non NULL it is unmapped and freed
4923 */
0edd5b44 4924static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
43f66a6c
JK		 4925{
4926 int i;
4927
4928 if (!rxq)
4929 return;
bf79451e 4930
43f66a6c
JK		 4931 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4932 if (rxq->pool[i].skb != NULL) {
4933 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
b095c381 4934 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c
JK		 4935 dev_kfree_skb(rxq->pool[i].skb);
4936 }
4937 }
4938
4939 kfree(rxq);
4940}
4941
4942static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4943{
4944 struct ipw_rx_queue *rxq;
4945 int i;
4946
c75f4742 4947 rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
ad18b0ea
PI		 4948 if (unlikely(!rxq)) {
4949 IPW_ERROR("memory allocation failed\n");
4950 return NULL;
4951 }
43f66a6c
JK		 4952 spin_lock_init(&rxq->lock);
4953 INIT_LIST_HEAD(&rxq->rx_free);
4954 INIT_LIST_HEAD(&rxq->rx_used);
4955
4956 /* Fill the rx_used queue with _all_ of the Rx buffers */
bf79451e 4957 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
43f66a6c
JK		 4958 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4959
4960 /* Set us so that we have processed and used all buffers, but have
4961 * not restocked the Rx queue with fresh buffers */
4962 rxq->read = rxq->write = 0;
4963 rxq->processed = RX_QUEUE_SIZE - 1;
4964 rxq->free_count = 0;
4965
4966 return rxq;
4967}
4968
4969static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4970{
4971 rate &= ~IEEE80211_BASIC_RATE_MASK;
4972 if (ieee_mode == IEEE_A) {
4973 switch (rate) {
bf79451e
JG		 4974 case IEEE80211_OFDM_RATE_6MB:
4975 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
0edd5b44 4976 1 : 0;
bf79451e
JG		 4977 case IEEE80211_OFDM_RATE_9MB:
4978 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
0edd5b44 4979 1 : 0;
bf79451e 4980 case IEEE80211_OFDM_RATE_12MB:
0edd5b44
JG		 4981 return priv->
4982 rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
bf79451e 4983 case IEEE80211_OFDM_RATE_18MB:
0edd5b44
JG		 4984 return priv->
4985 rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
bf79451e 4986 case IEEE80211_OFDM_RATE_24MB:
0edd5b44
JG		 4987 return priv->
4988 rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
bf79451e 4989 case IEEE80211_OFDM_RATE_36MB:
0edd5b44
JG		 4990 return priv->
4991 rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
bf79451e 4992 case IEEE80211_OFDM_RATE_48MB:
0edd5b44
JG		 4993 return priv->
4994 rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
bf79451e 4995 case IEEE80211_OFDM_RATE_54MB:
0edd5b44
JG		 4996 return priv->
4997 rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
43f66a6c
JK		 4998 default:
4999 return 0;
5000 }
5001 }
bf79451e 5002
43f66a6c
JK		 5003 /* B and G mixed */
5004 switch (rate) {
bf79451e 5005 case IEEE80211_CCK_RATE_1MB:
43f66a6c 5006 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
bf79451e 5007 case IEEE80211_CCK_RATE_2MB:
43f66a6c 5008 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
bf79451e 5009 case IEEE80211_CCK_RATE_5MB:
43f66a6c 5010 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
bf79451e 5011 case IEEE80211_CCK_RATE_11MB:
43f66a6c
JK		 5012 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5013 }
5014
5015 /* If we are limited to B modulations, bail at this point */
5016 if (ieee_mode == IEEE_B)
5017 return 0;
5018
5019 /* G */
5020 switch (rate) {
bf79451e 5021 case IEEE80211_OFDM_RATE_6MB:
43f66a6c 5022 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
bf79451e 5023 case IEEE80211_OFDM_RATE_9MB:
43f66a6c 5024 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
bf79451e 5025 case IEEE80211_OFDM_RATE_12MB:
43f66a6c 5026 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
bf79451e 5027 case IEEE80211_OFDM_RATE_18MB:
43f66a6c 5028 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
bf79451e 5029 case IEEE80211_OFDM_RATE_24MB:
43f66a6c 5030 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
bf79451e 5031 case IEEE80211_OFDM_RATE_36MB:
43f66a6c 5032 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
bf79451e 5033 case IEEE80211_OFDM_RATE_48MB:
43f66a6c 5034 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
bf79451e 5035 case IEEE80211_OFDM_RATE_54MB:
43f66a6c
JK		 5036 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5037 }
5038
5039 return 0;
5040}
5041
bf79451e 5042static int ipw_compatible_rates(struct ipw_priv *priv,
43f66a6c
JK		 5043 const struct ieee80211_network *network,
5044 struct ipw_supported_rates *rates)
5045{
5046 int num_rates, i;
5047
5048 memset(rates, 0, sizeof(*rates));
0edd5b44 5049 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
43f66a6c
JK		 5050 rates->num_rates = 0;
5051 for (i = 0; i < num_rates; i++) {
a613bffd
JK		 5052 if (!ipw_is_rate_in_mask(priv, network->mode,
5053 network->rates[i])) {
5054
ea2b26e0 5055 if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
a613bffd
JK		 5056 IPW_DEBUG_SCAN("Adding masked mandatory "
5057 "rate %02X\n",
5058 network->rates[i]);
5059 rates->supported_rates[rates->num_rates++] =
5060 network->rates[i];
5061 continue;
ea2b26e0
JK		 5062 }
5063
43f66a6c
JK		 5064 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5065 network->rates[i], priv->rates_mask);
5066 continue;
5067 }
bf79451e 5068
43f66a6c
JK		 5069 rates->supported_rates[rates->num_rates++] = network->rates[i];
5070 }
5071
a613bffd
JK		 5072 num_rates = min(network->rates_ex_len,
5073 (u8) (IPW_MAX_RATES - num_rates));
43f66a6c 5074 for (i = 0; i < num_rates; i++) {
a613bffd
JK		 5075 if (!ipw_is_rate_in_mask(priv, network->mode,
5076 network->rates_ex[i])) {
ea2b26e0 5077 if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
a613bffd
JK		 5078 IPW_DEBUG_SCAN("Adding masked mandatory "
5079 "rate %02X\n",
5080 network->rates_ex[i]);
5081 rates->supported_rates[rates->num_rates++] =
5082 network->rates[i];
5083 continue;
ea2b26e0
JK		 5084 }
5085
43f66a6c
JK		 5086 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5087 network->rates_ex[i], priv->rates_mask);
5088 continue;
5089 }
bf79451e 5090
0edd5b44
JG		 5091 rates->supported_rates[rates->num_rates++] =
5092 network->rates_ex[i];
43f66a6c
JK		 5093 }
5094
ea2b26e0 5095 return 1;
43f66a6c
JK		 5096}
5097
5098static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
5099 const struct ipw_supported_rates *src)
5100{
5101 u8 i;
5102 for (i = 0; i < src->num_rates; i++)
5103 dest->supported_rates[i] = src->supported_rates[i];
5104 dest->num_rates = src->num_rates;
5105}
5106
5107/* TODO: Look at sniffed packets in the air to determine if the basic rate
5108 * mask should ever be used -- right now all callers to add the scan rates are
5109 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5110static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
0edd5b44 5111 u8 modulation, u32 rate_mask)
43f66a6c 5112{
bf79451e 5113 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
0edd5b44 5114 IEEE80211_BASIC_RATE_MASK : 0;
bf79451e 5115
43f66a6c 5116 if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
bf79451e 5117 rates->supported_rates[rates->num_rates++] =
0edd5b44 5118 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
43f66a6c
JK		 5119
5120 if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
bf79451e 5121 rates->supported_rates[rates->num_rates++] =
0edd5b44 5122 IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
43f66a6c
JK		 5123
5124 if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
bf79451e 5125 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5126 IEEE80211_CCK_RATE_5MB;
43f66a6c
JK		 5127
5128 if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
bf79451e 5129 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5130 IEEE80211_CCK_RATE_11MB;
43f66a6c
JK		 5131}
5132
5133static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
0edd5b44 5134 u8 modulation, u32 rate_mask)
43f66a6c 5135{
bf79451e 5136 u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
0edd5b44 5137 IEEE80211_BASIC_RATE_MASK : 0;
43f66a6c
JK		 5138
5139 if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
bf79451e 5140 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5141 IEEE80211_OFDM_RATE_6MB;
43f66a6c
JK		 5142
5143 if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
bf79451e 5144 rates->supported_rates[rates->num_rates++] =
0edd5b44 5145 IEEE80211_OFDM_RATE_9MB;
43f66a6c
JK		 5146
5147 if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
bf79451e 5148 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5149 IEEE80211_OFDM_RATE_12MB;
43f66a6c
JK		 5150
5151 if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
bf79451e 5152 rates->supported_rates[rates->num_rates++] =
0edd5b44 5153 IEEE80211_OFDM_RATE_18MB;
43f66a6c
JK		 5154
5155 if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
bf79451e 5156 rates->supported_rates[rates->num_rates++] = basic_mask |
0edd5b44 5157 IEEE80211_OFDM_RATE_24MB;
43f66a6c
JK		 5158
5159 if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
bf79451e 5160 rates->supported_rates[rates->num_rates++] =
0edd5b44 5161 IEEE80211_OFDM_RATE_36MB;
43f66a6c
JK		 5162
5163 if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
bf79451e 5164 rates->supported_rates[rates->num_rates++] =
0edd5b44 5165 IEEE80211_OFDM_RATE_48MB;
43f66a6c
JK		 5166
5167 if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
bf79451e 5168 rates->supported_rates[rates->num_rates++] =
0edd5b44 5169 IEEE80211_OFDM_RATE_54MB;
43f66a6c
JK		 5170}
5171
5172struct ipw_network_match {
5173 struct ieee80211_network *network;
5174 struct ipw_supported_rates rates;
5175};
5176
c848d0af
JK		 5177static int ipw_find_adhoc_network(struct ipw_priv *priv,
5178 struct ipw_network_match *match,
5179 struct ieee80211_network *network,
5180 int roaming)
43f66a6c
JK		 5181{
5182 struct ipw_supported_rates rates;
5183
5184 /* Verify that this network's capability is compatible with the
5185 * current mode (AdHoc or Infrastructure) */
c848d0af 5186 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
43f66a6c 5187 !(network->capability & WLAN_CAPABILITY_IBSS))) {
c848d0af 5188 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
bf79451e 5189 "capability mismatch.\n",
43f66a6c
JK		 5190 escape_essid(network->ssid, network->ssid_len),
5191 MAC_ARG(network->bssid));
5192 return 0;
5193 }
5194
5195 /* If we do not have an ESSID for this AP, we can not associate with
5196 * it */
5197 if (network->flags & NETWORK_EMPTY_ESSID) {
c848d0af 5198 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5199 "because of hidden ESSID.\n",
5200 escape_essid(network->ssid, network->ssid_len),
5201 MAC_ARG(network->bssid));
5202 return 0;
5203 }
bf79451e 5204
43f66a6c
JK		 5205 if (unlikely(roaming)) {
5206 /* If we are roaming, then ensure check if this is a valid
5207 * network to try and roam to */
5208 if ((network->ssid_len != match->network->ssid_len) ||
bf79451e 5209 memcmp(network->ssid, match->network->ssid,
43f66a6c 5210 network->ssid_len)) {
c848d0af 5211 IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
43f66a6c 5212 "because of non-network ESSID.\n",
bf79451e 5213 escape_essid(network->ssid,
43f66a6c
JK		 5214 network->ssid_len),
5215 MAC_ARG(network->bssid));
5216 return 0;
5217 }
5218 } else {
bf79451e
JG		 5219 /* If an ESSID has been configured then compare the broadcast
5220 * ESSID to ours */
5221 if ((priv->config & CFG_STATIC_ESSID) &&
43f66a6c 5222 ((network->ssid_len != priv->essid_len) ||
bf79451e 5223 memcmp(network->ssid, priv->essid,
43f66a6c
JK		 5224 min(network->ssid_len, priv->essid_len)))) {
5225 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
afbf30a2 5226
0edd5b44
JG		 5227 strncpy(escaped,
5228 escape_essid(network->ssid, network->ssid_len),
43f66a6c 5229 sizeof(escaped));
c848d0af 5230 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
bf79451e 5231 "because of ESSID mismatch: '%s'.\n",
43f66a6c 5232 escaped, MAC_ARG(network->bssid),
0edd5b44
JG		 5233 escape_essid(priv->essid,
5234 priv->essid_len));
43f66a6c
JK		 5235 return 0;
5236 }
5237 }
5238
5239 /* If the old network rate is better than this one, don't bother
5240 * testing everything else. */
c848d0af
JK		 5241
5242 if (network->time_stamp[0] < match->network->time_stamp[0]) {
afbf30a2
JK		 5243 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5244 "current network.\n",
43f66a6c 5245 escape_essid(match->network->ssid,
afbf30a2 5246 match->network->ssid_len));
43f66a6c 5247 return 0;
c848d0af 5248 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
afbf30a2
JK		 5249 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5250 "current network.\n",
5251 escape_essid(match->network->ssid,
5252 match->network->ssid_len));
43f66a6c
JK		 5253 return 0;
5254 }
5255
5256 /* Now go through and see if the requested network is valid... */
bf79451e 5257 if (priv->ieee->scan_age != 0 &&
c848d0af
JK		 5258 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5259 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5260 "because of age: %lums.\n",
5261 escape_essid(network->ssid, network->ssid_len),
5262 MAC_ARG(network->bssid),
afbf30a2 5263 1000 * (jiffies - network->last_scanned) / HZ);
43f66a6c 5264 return 0;
bf79451e 5265 }
43f66a6c 5266
bf79451e 5267 if ((priv->config & CFG_STATIC_CHANNEL) &&
43f66a6c 5268 (network->channel != priv->channel)) {
c848d0af 5269 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5270 "because of channel mismatch: %d != %d.\n",
5271 escape_essid(network->ssid, network->ssid_len),
5272 MAC_ARG(network->bssid),
5273 network->channel, priv->channel);
5274 return 0;
5275 }
bf79451e 5276
43f66a6c 5277 /* Verify privacy compatability */
bf79451e 5278 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
43f66a6c 5279 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
c848d0af 5280 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5281 "because of privacy mismatch: %s != %s.\n",
5282 escape_essid(network->ssid, network->ssid_len),
5283 MAC_ARG(network->bssid),
afbf30a2
JK		 5284 priv->
5285 capability & CAP_PRIVACY_ON ? "on" : "off",
5286 network->
5287 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5288 "off");
43f66a6c
JK		 5289 return 0;
5290 }
bf79451e 5291
c848d0af
JK		 5292 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5293 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5294 "because of the same BSSID match: " MAC_FMT
5295 ".\n", escape_essid(network->ssid,
5296 network->ssid_len),
0edd5b44 5297 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
43f66a6c
JK		 5298 return 0;
5299 }
bf79451e 5300
43f66a6c
JK		 5301 /* Filter out any incompatible freq / mode combinations */
5302 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
c848d0af 5303 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5304 "because of invalid frequency/mode "
5305 "combination.\n",
5306 escape_essid(network->ssid, network->ssid_len),
5307 MAC_ARG(network->bssid));
5308 return 0;
5309 }
bf79451e 5310
c848d0af
JK		 5311 /* Ensure that the rates supported by the driver are compatible with
5312 * this AP, including verification of basic rates (mandatory) */
5313 if (!ipw_compatible_rates(priv, network, &rates)) {
5314 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5315 "because configured rate mask excludes "
5316 "AP mandatory rate.\n",
5317 escape_essid(network->ssid, network->ssid_len),
5318 MAC_ARG(network->bssid));
5319 return 0;
5320 }
5321
43f66a6c 5322 if (rates.num_rates == 0) {
c848d0af 5323 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
43f66a6c
JK		 5324 "because of no compatible rates.\n",
5325 escape_essid(network->ssid, network->ssid_len),
5326 MAC_ARG(network->bssid));
5327 return 0;
5328 }
bf79451e 5329
43f66a6c
JK		 5330 /* TODO: Perform any further minimal comparititive tests. We do not
5331 * want to put too much policy logic here; intelligent scan selection
5332 * should occur within a generic IEEE 802.11 user space tool. */
5333
5334 /* Set up 'new' AP to this network */
5335 ipw_copy_rates(&match->rates, &rates);
5336 match->network = network;
c848d0af 5337 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
43f66a6c
JK		 5338 escape_essid(network->ssid, network->ssid_len),
5339 MAC_ARG(network->bssid));
5340
5341 return 1;
5342}
5343
c848d0af 5344static void ipw_merge_adhoc_network(void *data)
43f66a6c 5345{
c848d0af
JK		 5346 struct ipw_priv *priv = data;
5347 struct ieee80211_network *network = NULL;
5348 struct ipw_network_match match = {
5349 .network = priv->assoc_network
5350 };
5351
afbf30a2
JK		 5352 if ((priv->status & STATUS_ASSOCIATED) &&
5353 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
c848d0af
JK		 5354 /* First pass through ROAM process -- look for a better
5355 * network */
5356 unsigned long flags;
5357
5358 spin_lock_irqsave(&priv->ieee->lock, flags);
5359 list_for_each_entry(network, &priv->ieee->network_list, list) {
5360 if (network != priv->assoc_network)
5361 ipw_find_adhoc_network(priv, &match, network,
5362 1);
5363 }
5364 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5365
5366 if (match.network == priv->assoc_network) {
5367 IPW_DEBUG_MERGE("No better ADHOC in this network to "
5368 "merge to.\n");
5369 return;
5370 }
5371
5372 down(&priv->sem);
5373 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5374 IPW_DEBUG_MERGE("remove network %s\n",
5375 escape_essid(priv->essid,
5376 priv->essid_len));
5377 ipw_remove_current_network(priv);
43f66a6c 5378 }
c848d0af
JK		 5379
5380 ipw_disassociate(priv);
5381 priv->assoc_network = match.network;
5382 up(&priv->sem);
5383 return;
43f66a6c 5384 }
c848d0af 5385}
43f66a6c 5386
0edd5b44
JG		 5387static int ipw_best_network(struct ipw_priv *priv,
5388 struct ipw_network_match *match,
5389 struct ieee80211_network *network, int roaming)
43f66a6c
JK		 5390{
5391 struct ipw_supported_rates rates;
5392
5393 /* Verify that this network's capability is compatible with the
5394 * current mode (AdHoc or Infrastructure) */
5395 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
2474385e 5396 !(network->capability & WLAN_CAPABILITY_ESS)) ||
43f66a6c
JK		 5397 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5398 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5399 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
bf79451e 5400 "capability mismatch.\n",
43f66a6c
JK		 5401 escape_essid(network->ssid, network->ssid_len),
5402 MAC_ARG(network->bssid));
5403 return 0;
5404 }
5405
5406 /* If we do not have an ESSID for this AP, we can not associate with
5407 * it */
5408 if (network->flags & NETWORK_EMPTY_ESSID) {
5409 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5410 "because of hidden ESSID.\n",
5411 escape_essid(network->ssid, network->ssid_len),
5412 MAC_ARG(network->bssid));
5413 return 0;
5414 }
bf79451e 5415
43f66a6c
JK		 5416 if (unlikely(roaming)) {
5417 /* If we are roaming, then ensure check if this is a valid
5418 * network to try and roam to */
5419 if ((network->ssid_len != match->network->ssid_len) ||
bf79451e 5420 memcmp(network->ssid, match->network->ssid,
43f66a6c
JK		 5421 network->ssid_len)) {
5422 IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5423 "because of non-network ESSID.\n",
bf79451e 5424 escape_essid(network->ssid,
43f66a6c
JK		 5425 network->ssid_len),
5426 MAC_ARG(network->bssid));
5427 return 0;
5428 }
5429 } else {
bf79451e
JG		 5430 /* If an ESSID has been configured then compare the broadcast
5431 * ESSID to ours */
5432 if ((priv->config & CFG_STATIC_ESSID) &&
43f66a6c 5433 ((network->ssid_len != priv->essid_len) ||
bf79451e 5434 memcmp(network->ssid, priv->essid,
43f66a6c
JK		 5435 min(network->ssid_len, priv->essid_len)))) {
5436 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
0edd5b44
JG		 5437 strncpy(escaped,
5438 escape_essid(network->ssid, network->ssid_len),
43f66a6c
JK		 5439 sizeof(escaped));
5440 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
bf79451e 5441 "because of ESSID mismatch: '%s'.\n",
43f66a6c 5442 escaped, MAC_ARG(network->bssid),
0edd5b44
JG		 5443 escape_essid(priv->essid,
5444 priv->essid_len));
43f66a6c
JK		 5445 return 0;
5446 }
5447 }
5448
5449 /* If the old network rate is better than this one, don't bother
5450 * testing everything else. */
0edd5b44 5451 if (match->network && match->network->stats.rssi > network->stats.rssi) {
43f66a6c 5452 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
bf79451e
JG		 5453 strncpy(escaped,
5454 escape_essid(network->ssid, network->ssid_len),
43f66a6c
JK		 5455 sizeof(escaped));
5456 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5457 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5458 escaped, MAC_ARG(network->bssid),
5459 escape_essid(match->network->ssid,
5460 match->network->ssid_len),
5461 MAC_ARG(match->network->bssid));
5462 return 0;
5463 }
bf79451e 5464
43f66a6c
JK		 5465 /* If this network has already had an association attempt within the
5466 * last 3 seconds, do not try and associate again... */
5467 if (network->last_associate &&
ea2b26e0 5468 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
43f66a6c 5469 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
afbf30a2 5470 "because of storming (%lus since last "
43f66a6c
JK		 5471 "assoc attempt).\n",
5472 escape_essid(network->ssid, network->ssid_len),
5473 MAC_ARG(network->bssid),
5474 (jiffies - network->last_associate) / HZ);
5475 return 0;
5476 }
5477
5478 /* Now go through and see if the requested network is valid... */
bf79451e 5479 if (priv->ieee->scan_age != 0 &&
ea2b26e0 5480 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
43f66a6c
JK		 5481 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5482 "because of age: %lums.\n",
5483 escape_essid(network->ssid, network->ssid_len),
5484 MAC_ARG(network->bssid),
afbf30a2 5485 1000 * (jiffies - network->last_scanned) / HZ);
43f66a6c 5486 return 0;
bf79451e 5487 }
43f66a6c 5488
bf79451e 5489 if ((priv->config & CFG_STATIC_CHANNEL) &&
43f66a6c
JK		 5490 (network->channel != priv->channel)) {
5491 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5492 "because of channel mismatch: %d != %d.\n",
5493 escape_essid(network->ssid, network->ssid_len),
5494 MAC_ARG(network->bssid),
5495 network->channel, priv->channel);
5496 return 0;
5497 }
bf79451e 5498
43f66a6c 5499 /* Verify privacy compatability */
bf79451e 5500 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
43f66a6c
JK		 5501 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5502 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5503 "because of privacy mismatch: %s != %s.\n",
5504 escape_essid(network->ssid, network->ssid_len),
5505 MAC_ARG(network->bssid),
bf79451e 5506 priv->capability & CAP_PRIVACY_ON ? "on" :
43f66a6c 5507 "off",
bf79451e 5508 network->capability &
0edd5b44 5509 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
43f66a6c
JK		 5510 return 0;
5511 }
bf79451e 5512
cdd1fa1e
HL		 5513 if (!priv->ieee->wpa_enabled && (network->wpa_ie_len > 0 ||
5514 network->rsn_ie_len > 0)) {
5515 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5516 "because of WPA capability mismatch.\n",
5517 escape_essid(network->ssid, network->ssid_len),
5518 MAC_ARG(network->bssid));
5519 return 0;
5520 }
5521
bf79451e 5522 if ((priv->config & CFG_STATIC_BSSID) &&
43f66a6c
JK		 5523 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5524 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5525 "because of BSSID mismatch: " MAC_FMT ".\n",
5526 escape_essid(network->ssid, network->ssid_len),
0edd5b44 5527 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
43f66a6c
JK		 5528 return 0;
5529 }
bf79451e 5530
43f66a6c
JK		 5531 /* Filter out any incompatible freq / mode combinations */
5532 if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5533 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5534 "because of invalid frequency/mode "
5535 "combination.\n",
5536 escape_essid(network->ssid, network->ssid_len),
5537 MAC_ARG(network->bssid));
5538 return 0;
5539 }
bf79451e 5540
1fe0adb4
LH		 5541 /* Filter out invalid channel in current GEO */
5542 if (!ipw_is_valid_channel(priv->ieee, network->channel)) {
5543 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5544 "because of invalid channel in current GEO\n",
5545 escape_essid(network->ssid, network->ssid_len),
5546 MAC_ARG(network->bssid));
5547 return 0;
5548 }
5549
ea2b26e0
JK		 5550 /* Ensure that the rates supported by the driver are compatible with
5551 * this AP, including verification of basic rates (mandatory) */
5552 if (!ipw_compatible_rates(priv, network, &rates)) {
5553 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5554 "because configured rate mask excludes "
5555 "AP mandatory rate.\n",
5556 escape_essid(network->ssid, network->ssid_len),
5557 MAC_ARG(network->bssid));
5558 return 0;
5559 }
5560
43f66a6c
JK		 5561 if (rates.num_rates == 0) {
5562 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5563 "because of no compatible rates.\n",
5564 escape_essid(network->ssid, network->ssid_len),
5565 MAC_ARG(network->bssid));
5566 return 0;
5567 }
bf79451e 5568
43f66a6c
JK		 5569 /* TODO: Perform any further minimal comparititive tests. We do not
5570 * want to put too much policy logic here; intelligent scan selection
5571 * should occur within a generic IEEE 802.11 user space tool. */
5572
5573 /* Set up 'new' AP to this network */
5574 ipw_copy_rates(&match->rates, &rates);
5575 match->network = network;
5576
5577 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5578 escape_essid(network->ssid, network->ssid_len),
5579 MAC_ARG(network->bssid));
5580
5581 return 1;
5582}
5583
bf79451e 5584static void ipw_adhoc_create(struct ipw_priv *priv,
0edd5b44 5585 struct ieee80211_network *network)
43f66a6c 5586{
1fe0adb4 5587 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
afbf30a2
JK		 5588 int i;
5589
43f66a6c
JK		 5590 /*
5591 * For the purposes of scanning, we can set our wireless mode
5592 * to trigger scans across combinations of bands, but when it
5593 * comes to creating a new ad-hoc network, we have tell the FW
5594 * exactly which band to use.
5595 *
bf79451e 5596 * We also have the possibility of an invalid channel for the
43f66a6c
JK		 5597 * chossen band. Attempting to create a new ad-hoc network
5598 * with an invalid channel for wireless mode will trigger a
5599 * FW fatal error.
afbf30a2 5600 *
43f66a6c 5601 */
1fe0adb4 5602 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
afbf30a2
JK		 5603 case IEEE80211_52GHZ_BAND:
5604 network->mode = IEEE_A;
1fe0adb4 5605 i = ipw_channel_to_index(priv->ieee, priv->channel);
afbf30a2
JK		 5606 if (i == -1)
5607 BUG();
5608 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5609 IPW_WARNING("Overriding invalid channel\n");
5610 priv->channel = geo->a[0].channel;
5611 }
5612 break;
5613
5614 case IEEE80211_24GHZ_BAND:
5615 if (priv->ieee->mode & IEEE_G)
5616 network->mode = IEEE_G;
5617 else
5618 network->mode = IEEE_B;
1fe0adb4
LH		 5619 i = ipw_channel_to_index(priv->ieee, priv->channel);
5620 if (i == -1)
5621 BUG();
5622 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5623 IPW_WARNING("Overriding invalid channel\n");
5624 priv->channel = geo->bg[0].channel;
5625 }
afbf30a2
JK		 5626 break;
5627
5628 default:
43f66a6c
JK		 5629 IPW_WARNING("Overriding invalid channel\n");
5630 if (priv->ieee->mode & IEEE_A) {
5631 network->mode = IEEE_A;
b095c381 5632 priv->channel = geo->a[0].channel;
43f66a6c
JK		 5633 } else if (priv->ieee->mode & IEEE_G) {
5634 network->mode = IEEE_G;
b095c381 5635 priv->channel = geo->bg[0].channel;
43f66a6c
JK		 5636 } else {
5637 network->mode = IEEE_B;
b095c381 5638 priv->channel = geo->bg[0].channel;
43f66a6c 5639 }
afbf30a2
JK		 5640 break;
5641 }
43f66a6c
JK		 5642
5643 network->channel = priv->channel;
5644 priv->config |= CFG_ADHOC_PERSIST;
5645 ipw_create_bssid(priv, network->bssid);
5646 network->ssid_len = priv->essid_len;
5647 memcpy(network->ssid, priv->essid, priv->essid_len);
5648 memset(&network->stats, 0, sizeof(network->stats));
5649 network->capability = WLAN_CAPABILITY_IBSS;
ea2b26e0
JK		 5650 if (!(priv->config & CFG_PREAMBLE_LONG))
5651 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
43f66a6c
JK		 5652 if (priv->capability & CAP_PRIVACY_ON)
5653 network->capability |= WLAN_CAPABILITY_PRIVACY;
5654 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
0edd5b44 5655 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
43f66a6c 5656 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
bf79451e 5657 memcpy(network->rates_ex,
43f66a6c
JK		 5658 &priv->rates.supported_rates[network->rates_len],
5659 network->rates_ex_len);
5660 network->last_scanned = 0;
5661 network->flags = 0;
5662 network->last_associate = 0;
5663 network->time_stamp[0] = 0;
5664 network->time_stamp[1] = 0;
0edd5b44
JG		 5665 network->beacon_interval = 100; /* Default */
5666 network->listen_interval = 10; /* Default */
5667 network->atim_window = 0; /* Default */
43f66a6c
JK		 5668 network->wpa_ie_len = 0;
5669 network->rsn_ie_len = 0;
43f66a6c
JK		 5670}
5671
b095c381
JK		 5672static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5673{
5674 struct ipw_tgi_tx_key *key;
5675 struct host_cmd cmd = {
5676 .cmd = IPW_CMD_TGI_TX_KEY,
5677 .len = sizeof(*key)
5678 };
5679
5680 if (!(priv->ieee->sec.flags & (1 << index)))
5681 return;
5682
5683 key = (struct ipw_tgi_tx_key *)&cmd.param;
5684 key->key_id = index;
5685 memcpy(key->key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5686 key->security_type = type;
5687 key->station_index = 0; /* always 0 for BSS */
5688 key->flags = 0;
5689 /* 0 for new key; previous value of counter (after fatal error) */
5690 key->tx_counter[0] = 0;
5691 key->tx_counter[1] = 0;
5692
9ddf84f6 5693 ipw_send_cmd(priv, &cmd);
b095c381
JK		 5694}
5695
5696static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
43f66a6c
JK		 5697{
5698 struct ipw_wep_key *key;
5699 int i;
5700 struct host_cmd cmd = {
5701 .cmd = IPW_CMD_WEP_KEY,
5702 .len = sizeof(*key)
5703 };
5704
5705 key = (struct ipw_wep_key *)&cmd.param;
5706 key->cmd_id = DINO_CMD_WEP_KEY;
5707 key->seq_num = 0;
5708
b095c381
JK		 5709 /* Note: AES keys cannot be set for multiple times.
5710 * Only set it at the first time. */
bf79451e 5711 for (i = 0; i < 4; i++) {
b095c381
JK		 5712 key->key_index = i | type;
5713 if (!(priv->ieee->sec.flags & (1 << i))) {
43f66a6c 5714 key->key_size = 0;
b095c381 5715 continue;
43f66a6c
JK		 5716 }
5717
b095c381
JK		 5718 key->key_size = priv->ieee->sec.key_sizes[i];
5719 memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);
5720
9ddf84f6 5721 ipw_send_cmd(priv, &cmd);
bf79451e 5722 }
43f66a6c
JK		 5723}
5724
1fbfea54 5725static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
43f66a6c 5726{
1fbfea54 5727 if (priv->ieee->host_encrypt)
43f66a6c 5728 return;
43f66a6c 5729
1fbfea54
ZY		 5730 switch (level) {
5731 case SEC_LEVEL_3:
5732 priv->sys_config.disable_unicast_decryption = 0;
5733 priv->ieee->host_decrypt = 0;
5734 break;
5735 case SEC_LEVEL_2:
5736 priv->sys_config.disable_unicast_decryption = 1;
5737 priv->ieee->host_decrypt = 1;
5738 break;
5739 case SEC_LEVEL_1:
5740 priv->sys_config.disable_unicast_decryption = 0;
5741 priv->ieee->host_decrypt = 0;
5742 break;
5743 case SEC_LEVEL_0:
5744 priv->sys_config.disable_unicast_decryption = 1;
5745 break;
5746 default:
5747 break;
5748 }
5749}
5750
5751static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5752{
5753 if (priv->ieee->host_encrypt)
5754 return;
5755
5756 switch (level) {
5757 case SEC_LEVEL_3:
5758 priv->sys_config.disable_multicast_decryption = 0;
5759 break;
5760 case SEC_LEVEL_2:
5761 priv->sys_config.disable_multicast_decryption = 1;
5762 break;
5763 case SEC_LEVEL_1:
5764 priv->sys_config.disable_multicast_decryption = 0;
5765 break;
5766 case SEC_LEVEL_0:
5767 priv->sys_config.disable_multicast_decryption = 1;
5768 break;
5769 default:
5770 break;
5771 }
5772}
5773
b095c381
JK		 5774static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5775{
5776 switch (priv->ieee->sec.level) {
5777 case SEC_LEVEL_3:
d8bad6df
ZY		 5778 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5779 ipw_send_tgi_tx_key(priv,
5780 DCT_FLAG_EXT_SECURITY_CCM,
5781 priv->ieee->sec.active_key);
afbf30a2 5782
567deaf6
HL		 5783 if (!priv->ieee->host_mc_decrypt)
5784 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
b095c381
JK		 5785 break;
5786 case SEC_LEVEL_2:
d8bad6df
ZY		 5787 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5788 ipw_send_tgi_tx_key(priv,
5789 DCT_FLAG_EXT_SECURITY_TKIP,
5790 priv->ieee->sec.active_key);
b095c381
JK		 5791 break;
5792 case SEC_LEVEL_1:
5793 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
29cb843e
HL		 5794 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5795 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
b095c381
JK		 5796 break;
5797 case SEC_LEVEL_0:
5798 default:
5799 break;
5800 }
5801}
5802
43f66a6c
JK		 5803static void ipw_adhoc_check(void *data)
5804{
5805 struct ipw_priv *priv = data;
bf79451e 5806
afbf30a2 5807 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
43f66a6c 5808 !(priv->config & CFG_ADHOC_PERSIST)) {
afbf30a2
JK		 5809 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5810 IPW_DL_STATE | IPW_DL_ASSOC,
5811 "Missed beacon: %d - disassociate\n",
5812 priv->missed_adhoc_beacons);
43f66a6c
JK		 5813 ipw_remove_current_network(priv);
5814 ipw_disassociate(priv);
5815 return;
5816 }
5817
bf79451e 5818 queue_delayed_work(priv->workqueue, &priv->adhoc_check,
43f66a6c
JK		 5819 priv->assoc_request.beacon_interval);
5820}
5821
c848d0af
JK		 5822static void ipw_bg_adhoc_check(void *data)
5823{
5824 struct ipw_priv *priv = data;
5825 down(&priv->sem);
5826 ipw_adhoc_check(data);
5827 up(&priv->sem);
5828}
5829
0f52bf90 5830#ifdef CONFIG_IPW2200_DEBUG
43f66a6c
JK		 5831static void ipw_debug_config(struct ipw_priv *priv)
5832{
5833 IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5834 "[CFG 0x%08X]\n", priv->config);
5835 if (priv->config & CFG_STATIC_CHANNEL)
0edd5b44 5836 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
43f66a6c
JK		 5837 else
5838 IPW_DEBUG_INFO("Channel unlocked.\n");
5839 if (priv->config & CFG_STATIC_ESSID)
bf79451e 5840 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
0edd5b44 5841 escape_essid(priv->essid, priv->essid_len));
43f66a6c
JK		 5842 else
5843 IPW_DEBUG_INFO("ESSID unlocked.\n");
5844 if (priv->config & CFG_STATIC_BSSID)
ea2b26e0
JK		 5845 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5846 MAC_ARG(priv->bssid));
43f66a6c
JK		 5847 else
5848 IPW_DEBUG_INFO("BSSID unlocked.\n");
5849 if (priv->capability & CAP_PRIVACY_ON)
5850 IPW_DEBUG_INFO("PRIVACY on\n");
5851 else
5852 IPW_DEBUG_INFO("PRIVACY off\n");
5853 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5854}
5855#else
8d45ff7d 5856#define ipw_debug_config(x) do {} while (0)
43f66a6c
JK		 5857#endif
5858
b095c381 5859static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
43f66a6c
JK		 5860{
5861 /* TODO: Verify that this works... */
5862 struct ipw_fixed_rate fr = {
5863 .tx_rates = priv->rates_mask
5864 };
5865 u32 reg;
5866 u16 mask = 0;
5867
bf79451e 5868 /* Identify 'current FW band' and match it with the fixed
43f66a6c 5869 * Tx rates */
bf79451e 5870
43f66a6c 5871 switch (priv->ieee->freq_band) {
0edd5b44 5872 case IEEE80211_52GHZ_BAND: /* A only */
43f66a6c
JK		 5873 /* IEEE_A */
5874 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5875 /* Invalid fixed rate mask */
ea2b26e0
JK		 5876 IPW_DEBUG_WX
5877 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
43f66a6c
JK		 5878 fr.tx_rates = 0;
5879 break;
5880 }
bf79451e 5881
43f66a6c
JK		 5882 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5883 break;
5884
0edd5b44 5885 default: /* 2.4Ghz or Mixed */
43f66a6c 5886 /* IEEE_B */
b095c381 5887 if (mode == IEEE_B) {
43f66a6c
JK		 5888 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5889 /* Invalid fixed rate mask */
ea2b26e0
JK		 5890 IPW_DEBUG_WX
5891 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
43f66a6c
JK		 5892 fr.tx_rates = 0;
5893 }
5894 break;
bf79451e 5895 }
43f66a6c
JK		 5896
5897 /* IEEE_G */
5898 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5899 IEEE80211_OFDM_RATES_MASK)) {
5900 /* Invalid fixed rate mask */
ea2b26e0
JK		 5901 IPW_DEBUG_WX
5902 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
43f66a6c
JK		 5903 fr.tx_rates = 0;
5904 break;
5905 }
bf79451e 5906
43f66a6c
JK		 5907 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5908 mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5909 fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5910 }
bf79451e 5911
43f66a6c
JK		 5912 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5913 mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5914 fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5915 }
bf79451e 5916
43f66a6c
JK		 5917 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5918 mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5919 fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5920 }
bf79451e 5921
43f66a6c
JK		 5922 fr.tx_rates |= mask;
5923 break;
5924 }
5925
5926 reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
0edd5b44 5927 ipw_write_reg32(priv, reg, *(u32 *) & fr);
43f66a6c
JK		 5928}
5929
ea2b26e0 5930static void ipw_abort_scan(struct ipw_priv *priv)
43f66a6c
JK		 5931{
5932 int err;
5933
ea2b26e0
JK		 5934 if (priv->status & STATUS_SCAN_ABORTING) {
5935 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5936 return;
5937 }
5938 priv->status |= STATUS_SCAN_ABORTING;
43f66a6c 5939
ea2b26e0
JK		 5940 err = ipw_send_scan_abort(priv);
5941 if (err)
5942 IPW_DEBUG_HC("Request to abort scan failed.\n");
5943}
5944
afbf30a2
JK		 5945static void ipw_add_scan_channels(struct ipw_priv *priv,
5946 struct ipw_scan_request_ext *scan,
5947 int scan_type)
ea2b26e0 5948{
ea2b26e0 5949 int channel_index = 0;
b095c381 5950 const struct ieee80211_geo *geo;
afbf30a2 5951 int i;
b095c381 5952
1fe0adb4 5953 geo = ipw_get_geo(priv->ieee);
43f66a6c 5954
afbf30a2
JK		 5955 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5956 int start = channel_index;
5957 for (i = 0; i < geo->a_channels; i++) {
5958 if ((priv->status & STATUS_ASSOCIATED) &&
5959 geo->a[i].channel == priv->channel)
5960 continue;
5961 channel_index++;
5962 scan->channels_list[channel_index] = geo->a[i].channel;
1fe0adb4
LH		 5963 ipw_set_scan_type(scan, channel_index,
5964 geo->a[i].
5965 flags & IEEE80211_CH_PASSIVE_ONLY ?
5966 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5967 scan_type);
afbf30a2
JK		 5968 }
5969
5970 if (start != channel_index) {
5971 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5972 (channel_index - start);
5973 channel_index++;
5974 }
5975 }
5976
5977 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5978 int start = channel_index;
5979 if (priv->config & CFG_SPEED_SCAN) {
1fe0adb4 5980 int index;
afbf30a2
JK		 5981 u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5982 /* nop out the list */
5983 [0] = 0
5984 };
5985
5986 u8 channel;
5987 while (channel_index < IPW_SCAN_CHANNELS) {
5988 channel =
5989 priv->speed_scan[priv->speed_scan_pos];
5990 if (channel == 0) {
5991 priv->speed_scan_pos = 0;
5992 channel = priv->speed_scan[0];
5993 }
5994 if ((priv->status & STATUS_ASSOCIATED) &&
5995 channel == priv->channel) {
5996 priv->speed_scan_pos++;
5997 continue;
5998 }
5999
6000 /* If this channel has already been
6001 * added in scan, break from loop
6002 * and this will be the first channel
6003 * in the next scan.
6004 */
6005 if (channels[channel - 1] != 0)
6006 break;
6007
6008 channels[channel - 1] = 1;
6009 priv->speed_scan_pos++;
6010 channel_index++;
6011 scan->channels_list[channel_index] = channel;
1fe0adb4
LH		 6012 index =
6013 ipw_channel_to_index(priv->ieee, channel);
afbf30a2 6014 ipw_set_scan_type(scan, channel_index,
1fe0adb4
LH		 6015 geo->bg[index].
6016 flags &
6017 IEEE80211_CH_PASSIVE_ONLY ?
6018 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6019 : scan_type);
afbf30a2
JK		 6020 }
6021 } else {
6022 for (i = 0; i < geo->bg_channels; i++) {
6023 if ((priv->status & STATUS_ASSOCIATED) &&
6024 geo->bg[i].channel == priv->channel)
6025 continue;
6026 channel_index++;
6027 scan->channels_list[channel_index] =
6028 geo->bg[i].channel;
6029 ipw_set_scan_type(scan, channel_index,
1fe0adb4
LH		 6030 geo->bg[i].
6031 flags &
6032 IEEE80211_CH_PASSIVE_ONLY ?
6033 IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6034 : scan_type);
afbf30a2
JK		 6035 }
6036 }
6037
6038 if (start != channel_index) {
6039 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6040 (channel_index - start);
6041 }
6042 }
6043}
6044
6045static int ipw_request_scan(struct ipw_priv *priv)
6046{
6047 struct ipw_scan_request_ext scan;
6048 int err = 0, scan_type;
6049
6050 if (!(priv->status & STATUS_INIT) ||
6051 (priv->status & STATUS_EXIT_PENDING))
6052 return 0;
6053
6054 down(&priv->sem);
6055
ea2b26e0 6056 if (priv->status & STATUS_SCANNING) {
a613bffd 6057 IPW_DEBUG_HC("Concurrent scan requested. Ignoring.\n");
ea2b26e0 6058 priv->status |= STATUS_SCAN_PENDING;
b095c381 6059 goto done;
ea2b26e0 6060 }
43f66a6c 6061
afbf30a2
JK		 6062 if (!(priv->status & STATUS_SCAN_FORCED) &&
6063 priv->status & STATUS_SCAN_ABORTING) {
ea2b26e0
JK		 6064 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
6065 priv->status |= STATUS_SCAN_PENDING;
b095c381 6066 goto done;
43f66a6c
JK		 6067 }
6068
ea2b26e0
JK		 6069 if (priv->status & STATUS_RF_KILL_MASK) {
6070 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6071 priv->status |= STATUS_SCAN_PENDING;
b095c381 6072 goto done;
ea2b26e0 6073 }
43f66a6c 6074
ea2b26e0 6075 memset(&scan, 0, sizeof(scan));
43f66a6c 6076
b095c381
JK		 6077 if (priv->config & CFG_SPEED_SCAN)
6078 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6079 cpu_to_le16(30);
6080 else
6081 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6082 cpu_to_le16(20);
6083
a613bffd
JK		 6084 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6085 cpu_to_le16(20);
1fe0adb4 6086 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
43f66a6c 6087
a613bffd 6088 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
43f66a6c 6089
b095c381 6090#ifdef CONFIG_IPW2200_MONITOR
ea2b26e0 6091 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 6092 u8 channel;
b095c381 6093 u8 band = 0;
43f66a6c 6094
1fe0adb4 6095 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
b095c381 6096 case IEEE80211_52GHZ_BAND:
ea2b26e0 6097 band = (u8) (IPW_A_MODE << 6) | 1;
b095c381
JK		 6098 channel = priv->channel;
6099 break;
ea2b26e0 6100
b095c381 6101 case IEEE80211_24GHZ_BAND:
ea2b26e0 6102 band = (u8) (IPW_B_MODE << 6) | 1;
b095c381
JK		 6103 channel = priv->channel;
6104 break;
ea2b26e0 6105
b095c381 6106 default:
ea2b26e0
JK		 6107 band = (u8) (IPW_B_MODE << 6) | 1;
6108 channel = 9;
b095c381 6109 break;
ea2b26e0
JK		 6110 }
6111
b095c381
JK		 6112 scan.channels_list[0] = band;
6113 scan.channels_list[1] = channel;
6114 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
ea2b26e0 6115
b095c381
JK		 6116 /* NOTE: The card will sit on this channel for this time
6117 * period. Scan aborts are timing sensitive and frequently
6118 * result in firmware restarts. As such, it is best to
6119 * set a small dwell_time here and just keep re-issuing
6120 * scans. Otherwise fast channel hopping will not actually
6121 * hop channels.
6122 *
6123 * TODO: Move SPEED SCAN support to all modes and bands */
a613bffd
JK		 6124 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6125 cpu_to_le16(2000);
43f66a6c 6126 } else {
b095c381
JK		 6127#endif /* CONFIG_IPW2200_MONITOR */
6128 /* If we are roaming, then make this a directed scan for the
6129 * current network. Otherwise, ensure that every other scan
6130 * is a fast channel hop scan */
6131 if ((priv->status & STATUS_ROAMING)
6132 || (!(priv->status & STATUS_ASSOCIATED)
6133 && (priv->config & CFG_STATIC_ESSID)
6134 && (le32_to_cpu(scan.full_scan_index) % 2))) {
ea2b26e0
JK		 6135 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6136 if (err) {
b095c381
JK		 6137 IPW_DEBUG_HC("Attempt to send SSID command "
6138 "failed.\n");
6139 goto done;
ea2b26e0 6140 }
43f66a6c 6141
ea2b26e0 6142 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
afbf30a2 6143 } else
ea2b26e0 6144 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
ea2b26e0 6145
afbf30a2 6146 ipw_add_scan_channels(priv, &scan, scan_type);
b095c381 6147#ifdef CONFIG_IPW2200_MONITOR
43f66a6c 6148 }
ea2b26e0 6149#endif
bf79451e 6150
ea2b26e0 6151 err = ipw_send_scan_request_ext(priv, &scan);
43f66a6c 6152 if (err) {
ea2b26e0 6153 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
b095c381 6154 goto done;
43f66a6c
JK		 6155 }
6156
ea2b26e0
JK		 6157 priv->status |= STATUS_SCANNING;
6158 priv->status &= ~STATUS_SCAN_PENDING;
afbf30a2
JK		 6159 queue_delayed_work(priv->workqueue, &priv->scan_check,
6160 IPW_SCAN_CHECK_WATCHDOG);
b095c381 6161 done:
c848d0af 6162 up(&priv->sem);
b095c381 6163 return err;
c848d0af
JK		 6164}
6165
6166static void ipw_bg_abort_scan(void *data)
6167{
6168 struct ipw_priv *priv = data;
6169 down(&priv->sem);
6170 ipw_abort_scan(data);
6171 up(&priv->sem);
6172}
6173
ea2b26e0
JK		 6174static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6175{
b095c381
JK		 6176 /* This is called when wpa_supplicant loads and closes the driver
6177 * interface. */
cdd1fa1e 6178 priv->ieee->wpa_enabled = value;
b095c381 6179 return 0;
ea2b26e0
JK		 6180}
6181
ea2b26e0
JK		 6182static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6183{
6184 struct ieee80211_device *ieee = priv->ieee;
6185 struct ieee80211_security sec = {
6186 .flags = SEC_AUTH_MODE,
6187 };
6188 int ret = 0;
6189
afbf30a2 6190 if (value & IW_AUTH_ALG_SHARED_KEY) {
ea2b26e0
JK		 6191 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6192 ieee->open_wep = 0;
afbf30a2 6193 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
ea2b26e0
JK		 6194 sec.auth_mode = WLAN_AUTH_OPEN;
6195 ieee->open_wep = 1;
afbf30a2
JK		 6196 } else
6197 return -EINVAL;
ea2b26e0
JK		 6198
6199 if (ieee->set_security)
6200 ieee->set_security(ieee->dev, &sec);
6201 else
6202 ret = -EOPNOTSUPP;
6203
6204 return ret;
6205}
6206
afbf30a2
JK		 6207void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie, int wpa_ie_len)
6208{
6209 /* make sure WPA is enabled */
6210 ipw_wpa_enable(priv, 1);
6211
6212 ipw_disassociate(priv);
6213}
6214
6215static int ipw_set_rsn_capa(struct ipw_priv *priv,
6216 char *capabilities, int length)
6217{
6218 struct host_cmd cmd = {
6219 .cmd = IPW_CMD_RSN_CAPABILITIES,
6220 .len = length,
6221 };
6222
6223 IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6224
6225 memcpy(cmd.param, capabilities, length);
9ddf84f6 6226 return ipw_send_cmd(priv, &cmd);
afbf30a2
JK		 6227}
6228
b095c381 6229/*
afbf30a2
JK		 6230 * WE-18 support
6231 */
6232
6233/* SIOCSIWGENIE */
6234static int ipw_wx_set_genie(struct net_device *dev,
6235 struct iw_request_info *info,
6236 union iwreq_data *wrqu, char *extra)
ea2b26e0 6237{
afbf30a2
JK		 6238 struct ipw_priv *priv = ieee80211_priv(dev);
6239 struct ieee80211_device *ieee = priv->ieee;
6240 u8 *buf;
6241 int err = 0;
ea2b26e0 6242
afbf30a2
JK		 6243 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6244 (wrqu->data.length && extra == NULL))
6245 return -EINVAL;
ea2b26e0 6246
afbf30a2
JK		 6247 //down(&priv->sem);
6248
6249 //if (!ieee->wpa_enabled) {
6250 // err = -EOPNOTSUPP;
6251 // goto out;
6252 //}
6253
6254 if (wrqu->data.length) {
6255 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6256 if (buf == NULL) {
6257 err = -ENOMEM;
6258 goto out;
6259 }
6260
6261 memcpy(buf, extra, wrqu->data.length);
6262 kfree(ieee->wpa_ie);
6263 ieee->wpa_ie = buf;
6264 ieee->wpa_ie_len = wrqu->data.length;
b095c381 6265 } else {
afbf30a2
JK		 6266 kfree(ieee->wpa_ie);
6267 ieee->wpa_ie = NULL;
6268 ieee->wpa_ie_len = 0;
ea2b26e0 6269 }
afbf30a2
JK		 6270
6271 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6272 out:
6273 //up(&priv->sem);
6274 return err;
6275}
6276
6277/* SIOCGIWGENIE */
6278static int ipw_wx_get_genie(struct net_device *dev,
6279 struct iw_request_info *info,
6280 union iwreq_data *wrqu, char *extra)
6281{
6282 struct ipw_priv *priv = ieee80211_priv(dev);
6283 struct ieee80211_device *ieee = priv->ieee;
6284 int err = 0;
6285
6286 //down(&priv->sem);
6287
6288 //if (!ieee->wpa_enabled) {
6289 // err = -EOPNOTSUPP;
6290 // goto out;
6291 //}
6292
6293 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6294 wrqu->data.length = 0;
6295 goto out;
6296 }
6297
6298 if (wrqu->data.length < ieee->wpa_ie_len) {
6299 err = -E2BIG;
6300 goto out;
6301 }
6302
6303 wrqu->data.length = ieee->wpa_ie_len;
6304 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6305
6306 out:
6307 //up(&priv->sem);
6308 return err;
6309}
6310
1fbfea54
ZY		 6311static int wext_cipher2level(int cipher)
6312{
6313 switch (cipher) {
6314 case IW_AUTH_CIPHER_NONE:
6315 return SEC_LEVEL_0;
6316 case IW_AUTH_CIPHER_WEP40:
6317 case IW_AUTH_CIPHER_WEP104:
6318 return SEC_LEVEL_1;
6319 case IW_AUTH_CIPHER_TKIP:
6320 return SEC_LEVEL_2;
6321 case IW_AUTH_CIPHER_CCMP:
6322 return SEC_LEVEL_3;
6323 default:
6324 return -1;
6325 }
6326}
6327
afbf30a2
JK		 6328/* SIOCSIWAUTH */
6329static int ipw_wx_set_auth(struct net_device *dev,
6330 struct iw_request_info *info,
6331 union iwreq_data *wrqu, char *extra)
6332{
6333 struct ipw_priv *priv = ieee80211_priv(dev);
6334 struct ieee80211_device *ieee = priv->ieee;
6335 struct iw_param *param = &wrqu->param;
6336 struct ieee80211_crypt_data *crypt;
6337 unsigned long flags;
6338 int ret = 0;
6339
6340 switch (param->flags & IW_AUTH_INDEX) {
6341 case IW_AUTH_WPA_VERSION:
1fbfea54 6342 break;
afbf30a2 6343 case IW_AUTH_CIPHER_PAIRWISE:
1fbfea54
ZY		 6344 ipw_set_hw_decrypt_unicast(priv,
6345 wext_cipher2level(param->value));
6346 break;
afbf30a2 6347 case IW_AUTH_CIPHER_GROUP:
1fbfea54
ZY		 6348 ipw_set_hw_decrypt_multicast(priv,
6349 wext_cipher2level(param->value));
6350 break;
afbf30a2
JK		 6351 case IW_AUTH_KEY_MGMT:
6352 /*
6353 * ipw2200 does not use these parameters
6354 */
6355 break;
6356
6357 case IW_AUTH_TKIP_COUNTERMEASURES:
6358 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
991d1cc5 6359 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
afbf30a2 6360 break;
afbf30a2
JK		 6361
6362 flags = crypt->ops->get_flags(crypt->priv);
6363
6364 if (param->value)
6365 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6366 else
6367 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6368
6369 crypt->ops->set_flags(flags, crypt->priv);
6370
6371 break;
6372
6373 case IW_AUTH_DROP_UNENCRYPTED:{
6374 /* HACK:
6375 *
6376 * wpa_supplicant calls set_wpa_enabled when the driver
6377 * is loaded and unloaded, regardless of if WPA is being
6378 * used. No other calls are made which can be used to
6379 * determine if encryption will be used or not prior to
6380 * association being expected. If encryption is not being
6381 * used, drop_unencrypted is set to false, else true -- we
6382 * can use this to determine if the CAP_PRIVACY_ON bit should
6383 * be set.
6384 */
6385 struct ieee80211_security sec = {
6386 .flags = SEC_ENABLED,
6387 .enabled = param->value,
6388 };
6389 priv->ieee->drop_unencrypted = param->value;
6390 /* We only change SEC_LEVEL for open mode. Others
6391 * are set by ipw_wpa_set_encryption.
6392 */
6393 if (!param->value) {
6394 sec.flags |= SEC_LEVEL;
6395 sec.level = SEC_LEVEL_0;
6396 } else {
6397 sec.flags |= SEC_LEVEL;
6398 sec.level = SEC_LEVEL_1;
6399 }
6400 if (priv->ieee->set_security)
6401 priv->ieee->set_security(priv->ieee->dev, &sec);
6402 break;
6403 }
6404
6405 case IW_AUTH_80211_AUTH_ALG:
6406 ret = ipw_wpa_set_auth_algs(priv, param->value);
6407 break;
6408
6409 case IW_AUTH_WPA_ENABLED:
6410 ret = ipw_wpa_enable(priv, param->value);
6411 break;
6412
6413 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6414 ieee->ieee802_1x = param->value;
6415 break;
6416
6417 //case IW_AUTH_ROAMING_CONTROL:
6418 case IW_AUTH_PRIVACY_INVOKED:
6419 ieee->privacy_invoked = param->value;
6420 break;
6421
6422 default:
6423 return -EOPNOTSUPP;
6424 }
6425 return ret;
6426}
6427
6428/* SIOCGIWAUTH */
6429static int ipw_wx_get_auth(struct net_device *dev,
6430 struct iw_request_info *info,
6431 union iwreq_data *wrqu, char *extra)
6432{
6433 struct ipw_priv *priv = ieee80211_priv(dev);
6434 struct ieee80211_device *ieee = priv->ieee;
6435 struct ieee80211_crypt_data *crypt;
6436 struct iw_param *param = &wrqu->param;
6437 int ret = 0;
6438
6439 switch (param->flags & IW_AUTH_INDEX) {
6440 case IW_AUTH_WPA_VERSION:
6441 case IW_AUTH_CIPHER_PAIRWISE:
6442 case IW_AUTH_CIPHER_GROUP:
6443 case IW_AUTH_KEY_MGMT:
6444 /*
6445 * wpa_supplicant will control these internally
6446 */
6447 ret = -EOPNOTSUPP;
6448 break;
6449
6450 case IW_AUTH_TKIP_COUNTERMEASURES:
6451 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
991d1cc5 6452 if (!crypt || !crypt->ops->get_flags)
afbf30a2 6453 break;
afbf30a2
JK		 6454
6455 param->value = (crypt->ops->get_flags(crypt->priv) &
6456 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6457
6458 break;
6459
6460 case IW_AUTH_DROP_UNENCRYPTED:
6461 param->value = ieee->drop_unencrypted;
6462 break;
6463
6464 case IW_AUTH_80211_AUTH_ALG:
6465 param->value = ieee->sec.auth_mode;
6466 break;
6467
6468 case IW_AUTH_WPA_ENABLED:
6469 param->value = ieee->wpa_enabled;
6470 break;
6471
6472 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6473 param->value = ieee->ieee802_1x;
6474 break;
6475
6476 case IW_AUTH_ROAMING_CONTROL:
6477 case IW_AUTH_PRIVACY_INVOKED:
6478 param->value = ieee->privacy_invoked;
6479 break;
6480
6481 default:
6482 return -EOPNOTSUPP;
6483 }
6484 return 0;
6485}
6486
6487/* SIOCSIWENCODEEXT */
6488static int ipw_wx_set_encodeext(struct net_device *dev,
6489 struct iw_request_info *info,
6490 union iwreq_data *wrqu, char *extra)
6491{
6492 struct ipw_priv *priv = ieee80211_priv(dev);
6493 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6494
6495 if (hwcrypto) {
afbf30a2 6496 if (ext->alg == IW_ENCODE_ALG_TKIP) {
567deaf6
HL		 6497 /* IPW HW can't build TKIP MIC,
6498 host decryption still needed */
6499 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6500 priv->ieee->host_mc_decrypt = 1;
6501 else {
6502 priv->ieee->host_encrypt = 0;
6503 priv->ieee->host_encrypt_msdu = 1;
6504 priv->ieee->host_decrypt = 1;
6505 }
afbf30a2
JK		 6506 } else {
6507 priv->ieee->host_encrypt = 0;
6508 priv->ieee->host_encrypt_msdu = 0;
6509 priv->ieee->host_decrypt = 0;
567deaf6 6510 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 6511 }
6512 }
6513
6514 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6515}
6516
6517/* SIOCGIWENCODEEXT */
6518static int ipw_wx_get_encodeext(struct net_device *dev,
6519 struct iw_request_info *info,
6520 union iwreq_data *wrqu, char *extra)
6521{
6522 struct ipw_priv *priv = ieee80211_priv(dev);
6523 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6524}
6525
6526/* SIOCSIWMLME */
6527static int ipw_wx_set_mlme(struct net_device *dev,
6528 struct iw_request_info *info,
6529 union iwreq_data *wrqu, char *extra)
6530{
6531 struct ipw_priv *priv = ieee80211_priv(dev);
6532 struct iw_mlme *mlme = (struct iw_mlme *)extra;
6533 u16 reason;
6534
6535 reason = cpu_to_le16(mlme->reason_code);
6536
6537 switch (mlme->cmd) {
6538 case IW_MLME_DEAUTH:
6539 // silently ignore
6540 break;
6541
6542 case IW_MLME_DISASSOC:
6543 ipw_disassociate(priv);
6544 break;
6545
6546 default:
6547 return -EOPNOTSUPP;
6548 }
6549 return 0;
6550}
afbf30a2
JK		 6551
6552#ifdef CONFIG_IPW_QOS
6553
6554/* QoS */
6555/*
6556* get the modulation type of the current network or
6557* the card current mode
6558*/
6559u8 ipw_qos_current_mode(struct ipw_priv * priv)
6560{
6561 u8 mode = 0;
6562
6563 if (priv->status & STATUS_ASSOCIATED) {
6564 unsigned long flags;
6565
6566 spin_lock_irqsave(&priv->ieee->lock, flags);
6567 mode = priv->assoc_network->mode;
6568 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6569 } else {
6570 mode = priv->ieee->mode;
6571 }
6572 IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6573 return mode;
b095c381 6574}
ea2b26e0 6575
b095c381
JK		 6576/*
6577* Handle management frame beacon and probe response
6578*/
3b9990cb
JK		 6579static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6580 int active_network,
6581 struct ieee80211_network *network)
b095c381
JK		 6582{
6583 u32 size = sizeof(struct ieee80211_qos_parameters);
6584
afbf30a2 6585 if (network->capability & WLAN_CAPABILITY_IBSS)
b095c381
JK		 6586 network->qos_data.active = network->qos_data.supported;
6587
6588 if (network->flags & NETWORK_HAS_QOS_MASK) {
afbf30a2
JK		 6589 if (active_network &&
6590 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
b095c381
JK		 6591 network->qos_data.active = network->qos_data.supported;
6592
6593 if ((network->qos_data.active == 1) && (active_network == 1) &&
6594 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6595 (network->qos_data.old_param_count !=
6596 network->qos_data.param_count)) {
6597 network->qos_data.old_param_count =
6598 network->qos_data.param_count;
6599 schedule_work(&priv->qos_activate);
afbf30a2
JK		 6600 IPW_DEBUG_QOS("QoS parameters change call "
6601 "qos_activate\n");
b095c381 6602 }
ea2b26e0 6603 } else {
afbf30a2
JK		 6604 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6605 memcpy(&network->qos_data.parameters,
b095c381 6606 &def_parameters_CCK, size);
afbf30a2
JK		 6607 else
6608 memcpy(&network->qos_data.parameters,
b095c381 6609 &def_parameters_OFDM, size);
afbf30a2 6610
b095c381
JK		 6611 if ((network->qos_data.active == 1) && (active_network == 1)) {
6612 IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6613 schedule_work(&priv->qos_activate);
6614 }
6615
6616 network->qos_data.active = 0;
6617 network->qos_data.supported = 0;
ea2b26e0 6618 }
afbf30a2
JK		 6619 if ((priv->status & STATUS_ASSOCIATED) &&
6620 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6621 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6622 if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6623 !(network->flags & NETWORK_EMPTY_ESSID))
b095c381 6624 if ((network->ssid_len ==
afbf30a2
JK		 6625 priv->assoc_network->ssid_len) &&
6626 !memcmp(network->ssid,
6627 priv->assoc_network->ssid,
6628 network->ssid_len)) {
b095c381
JK		 6629 queue_work(priv->workqueue,
6630 &priv->merge_networks);
6631 }
b095c381 6632 }
ea2b26e0 6633
b095c381
JK		 6634 return 0;
6635}
6636
6637/*
6638* This function set up the firmware to support QoS. It sends
6639* IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6640*/
6641static int ipw_qos_activate(struct ipw_priv *priv,
6642 struct ieee80211_qos_data *qos_network_data)
6643{
6644 int err;
6645 struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6646 struct ieee80211_qos_parameters *active_one = NULL;
6647 u32 size = sizeof(struct ieee80211_qos_parameters);
6648 u32 burst_duration;
6649 int i;
6650 u8 type;
6651
6652 type = ipw_qos_current_mode(priv);
6653
6654 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6655 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6656 active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6657 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6658
6659 if (qos_network_data == NULL) {
6660 if (type == IEEE_B) {
6661 IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6662 active_one = &def_parameters_CCK;
6663 } else
6664 active_one = &def_parameters_OFDM;
6665
afbf30a2 6666 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 6667 burst_duration = ipw_qos_get_burst_duration(priv);
6668 for (i = 0; i < QOS_QUEUE_NUM; i++)
afbf30a2
JK		 6669 qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6670 (u16) burst_duration;
6671 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
b095c381
JK		 6672 if (type == IEEE_B) {
6673 IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6674 type);
6675 if (priv->qos_data.qos_enable == 0)
6676 active_one = &def_parameters_CCK;
6677 else
6678 active_one = priv->qos_data.def_qos_parm_CCK;
6679 } else {
6680 if (priv->qos_data.qos_enable == 0)
6681 active_one = &def_parameters_OFDM;
6682 else
6683 active_one = priv->qos_data.def_qos_parm_OFDM;
6684 }
afbf30a2 6685 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 6686 } else {
6687 unsigned long flags;
6688 int active;
6689
6690 spin_lock_irqsave(&priv->ieee->lock, flags);
6691 active_one = &(qos_network_data->parameters);
6692 qos_network_data->old_param_count =
6693 qos_network_data->param_count;
afbf30a2 6694 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
b095c381
JK		 6695 active = qos_network_data->supported;
6696 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6697
6698 if (active == 0) {
6699 burst_duration = ipw_qos_get_burst_duration(priv);
6700 for (i = 0; i < QOS_QUEUE_NUM; i++)
6701 qos_parameters[QOS_PARAM_SET_ACTIVE].
6702 tx_op_limit[i] = (u16) burst_duration;
6703 }
6704 }
6705
6706 IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
afbf30a2
JK		 6707 err = ipw_send_qos_params_command(priv,
6708 (struct ieee80211_qos_parameters *)
6709 &(qos_parameters[0]));
b095c381
JK		 6710 if (err)
6711 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6712
6713 return err;
6714}
6715
6716/*
6717* send IPW_CMD_WME_INFO to the firmware
6718*/
6719static int ipw_qos_set_info_element(struct ipw_priv *priv)
6720{
6721 int ret = 0;
6722 struct ieee80211_qos_information_element qos_info;
6723
6724 if (priv == NULL)
6725 return -1;
6726
6727 qos_info.elementID = QOS_ELEMENT_ID;
6728 qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6729
6730 qos_info.version = QOS_VERSION_1;
6731 qos_info.ac_info = 0;
6732
6733 memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6734 qos_info.qui_type = QOS_OUI_TYPE;
6735 qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6736
6737 ret = ipw_send_qos_info_command(priv, &qos_info);
6738 if (ret != 0) {
6739 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6740 }
6741 return ret;
6742}
6743
6744/*
6745* Set the QoS parameter with the association request structure
6746*/
6747static int ipw_qos_association(struct ipw_priv *priv,
6748 struct ieee80211_network *network)
6749{
6750 int err = 0;
6751 struct ieee80211_qos_data *qos_data = NULL;
6752 struct ieee80211_qos_data ibss_data = {
6753 .supported = 1,
6754 .active = 1,
6755 };
6756
6757 switch (priv->ieee->iw_mode) {
6758 case IW_MODE_ADHOC:
6759 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6760 BUG();
6761
6762 qos_data = &ibss_data;
6763 break;
6764
6765 case IW_MODE_INFRA:
6766 qos_data = &network->qos_data;
6767 break;
6768
6769 default:
6770 BUG();
6771 break;
6772 }
6773
6774 err = ipw_qos_activate(priv, qos_data);
6775 if (err) {
6776 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6777 return err;
6778 }
6779
6780 if (priv->qos_data.qos_enable && qos_data->supported) {
6781 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6782 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6783 return ipw_qos_set_info_element(priv);
6784 }
6785
6786 return 0;
6787}
6788
6789/*
6790* handling the beaconing responces. if we get different QoS setting
6791* of the network from the the associated setting adjust the QoS
6792* setting
6793*/
6794static int ipw_qos_association_resp(struct ipw_priv *priv,
6795 struct ieee80211_network *network)
6796{
6797 int ret = 0;
6798 unsigned long flags;
6799 u32 size = sizeof(struct ieee80211_qos_parameters);
6800 int set_qos_param = 0;
6801
afbf30a2
JK		 6802 if ((priv == NULL) || (network == NULL) ||
6803 (priv->assoc_network == NULL))
b095c381
JK		 6804 return ret;
6805
6806 if (!(priv->status & STATUS_ASSOCIATED))
6807 return ret;
6808
afbf30a2 6809 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
b095c381 6810 return ret;
b095c381
JK		 6811
6812 spin_lock_irqsave(&priv->ieee->lock, flags);
6813 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
afbf30a2 6814 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
b095c381
JK		 6815 sizeof(struct ieee80211_qos_data));
6816 priv->assoc_network->qos_data.active = 1;
6817 if ((network->qos_data.old_param_count !=
6818 network->qos_data.param_count)) {
6819 set_qos_param = 1;
6820 network->qos_data.old_param_count =
6821 network->qos_data.param_count;
6822 }
6823
6824 } else {
afbf30a2
JK		 6825 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6826 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 6827 &def_parameters_CCK, size);
afbf30a2
JK		 6828 else
6829 memcpy(&priv->assoc_network->qos_data.parameters,
b095c381 6830 &def_parameters_OFDM, size);
b095c381
JK		 6831 priv->assoc_network->qos_data.active = 0;
6832 priv->assoc_network->qos_data.supported = 0;
6833 set_qos_param = 1;
6834 }
6835
6836 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6837
6838 if (set_qos_param == 1)
6839 schedule_work(&priv->qos_activate);
6840
6841 return ret;
6842}
6843
6844static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6845{
6846 u32 ret = 0;
6847
6848 if ((priv == NULL))
6849 return 0;
6850
afbf30a2 6851 if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
b095c381 6852 ret = priv->qos_data.burst_duration_CCK;
afbf30a2 6853 else
b095c381 6854 ret = priv->qos_data.burst_duration_OFDM;
afbf30a2 6855
b095c381
JK		 6856 return ret;
6857}
6858
6859/*
6860* Initialize the setting of QoS global
6861*/
6862static void ipw_qos_init(struct ipw_priv *priv, int enable,
6863 int burst_enable, u32 burst_duration_CCK,
6864 u32 burst_duration_OFDM)
6865{
6866 priv->qos_data.qos_enable = enable;
6867
6868 if (priv->qos_data.qos_enable) {
6869 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6870 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6871 IPW_DEBUG_QOS("QoS is enabled\n");
6872 } else {
6873 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6874 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6875 IPW_DEBUG_QOS("QoS is not enabled\n");
6876 }
6877
6878 priv->qos_data.burst_enable = burst_enable;
6879
6880 if (burst_enable) {
6881 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6882 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6883 } else {
6884 priv->qos_data.burst_duration_CCK = 0;
6885 priv->qos_data.burst_duration_OFDM = 0;
6886 }
6887}
6888
6889/*
6890* map the packet priority to the right TX Queue
6891*/
6892static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6893{
6894 if (priority > 7 || !priv->qos_data.qos_enable)
6895 priority = 0;
6896
6897 return from_priority_to_tx_queue[priority] - 1;
6898}
6899
6900/*
6901* add QoS parameter to the TX command
6902*/
6903static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6904 u16 priority,
6905 struct tfd_data *tfd, u8 unicast)
6906{
6907 int ret = 0;
6908 int tx_queue_id = 0;
6909 struct ieee80211_qos_data *qos_data = NULL;
6910 int active, supported;
6911 unsigned long flags;
6912
6913 if (!(priv->status & STATUS_ASSOCIATED))
6914 return 0;
6915
6916 qos_data = &priv->assoc_network->qos_data;
6917
6918 spin_lock_irqsave(&priv->ieee->lock, flags);
6919
6920 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6921 if (unicast == 0)
6922 qos_data->active = 0;
6923 else
6924 qos_data->active = qos_data->supported;
6925 }
6926
6927 active = qos_data->active;
6928 supported = qos_data->supported;
6929
6930 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6931
afbf30a2
JK		 6932 IPW_DEBUG_QOS("QoS %d network is QoS active %d supported %d "
6933 "unicast %d\n",
6934 priv->qos_data.qos_enable, active, supported, unicast);
b095c381
JK		 6935 if (active && priv->qos_data.qos_enable) {
6936 ret = from_priority_to_tx_queue[priority];
6937 tx_queue_id = ret - 1;
6938 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6939 if (priority <= 7) {
6940 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6941 tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6942 tfd->tfd.tfd_26.mchdr.frame_ctl |=
6943 IEEE80211_STYPE_QOS_DATA;
6944
6945 if (priv->qos_data.qos_no_ack_mask &
6946 (1UL << tx_queue_id)) {
6947 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6948 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6949 CTRL_QOS_NO_ACK;
6950 }
6951 }
6952 }
6953
6954 return ret;
6955}
6956
6957/*
6958* background support to run QoS activate functionality
6959*/
6960static void ipw_bg_qos_activate(void *data)
6961{
6962 struct ipw_priv *priv = data;
6963
6964 if (priv == NULL)
6965 return;
6966
6967 down(&priv->sem);
6968
6969 if (priv->status & STATUS_ASSOCIATED)
6970 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6971
6972 up(&priv->sem);
6973}
6974
3b9990cb
JK		 6975static int ipw_handle_probe_response(struct net_device *dev,
6976 struct ieee80211_probe_response *resp,
6977 struct ieee80211_network *network)
b095c381
JK		 6978{
6979 struct ipw_priv *priv = ieee80211_priv(dev);
3b9990cb
JK		 6980 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6981 (network == priv->assoc_network));
43f66a6c 6982
3b9990cb 6983 ipw_qos_handle_probe_response(priv, active_network, network);
43f66a6c 6984
3b9990cb
JK		 6985 return 0;
6986}
43f66a6c 6987
3b9990cb
JK		 6988static int ipw_handle_beacon(struct net_device *dev,
6989 struct ieee80211_beacon *resp,
6990 struct ieee80211_network *network)
6991{
6992 struct ipw_priv *priv = ieee80211_priv(dev);
6993 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6994 (network == priv->assoc_network));
bf79451e 6995
3b9990cb 6996 ipw_qos_handle_probe_response(priv, active_network, network);
bf79451e 6997
b095c381
JK		 6998 return 0;
6999}
bf79451e 7000
3b9990cb
JK		 7001static int ipw_handle_assoc_response(struct net_device *dev,
7002 struct ieee80211_assoc_response *resp,
7003 struct ieee80211_network *network)
7004{
7005 struct ipw_priv *priv = ieee80211_priv(dev);
7006 ipw_qos_association_resp(priv, network);
7007 return 0;
7008}
43f66a6c 7009
b095c381
JK		 7010static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7011 *qos_param)
7012{
7013 struct host_cmd cmd = {
7014 .cmd = IPW_CMD_QOS_PARAMETERS,
7015 .len = (sizeof(struct ieee80211_qos_parameters) * 3)
7016 };
7017
afbf30a2 7018 memcpy(cmd.param, qos_param, sizeof(*qos_param) * 3);
9ddf84f6 7019 return ipw_send_cmd(priv, &cmd);
b095c381
JK		 7020}
7021
7022static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7023 *qos_param)
7024{
7025 struct host_cmd cmd = {
7026 .cmd = IPW_CMD_WME_INFO,
7027 .len = sizeof(*qos_param)
7028 };
7029
afbf30a2 7030 memcpy(cmd.param, qos_param, sizeof(*qos_param));
9ddf84f6 7031 return ipw_send_cmd(priv, &cmd);
43f66a6c
JK		 7032}
7033
b095c381
JK		 7034#endif /* CONFIG_IPW_QOS */
7035
43f66a6c
JK		 7036static int ipw_associate_network(struct ipw_priv *priv,
7037 struct ieee80211_network *network,
0edd5b44 7038 struct ipw_supported_rates *rates, int roaming)
43f66a6c
JK		 7039{
7040 int err;
7041
7042 if (priv->config & CFG_FIXED_RATE)
b095c381 7043 ipw_set_fixed_rate(priv, network->mode);
43f66a6c
JK		 7044
7045 if (!(priv->config & CFG_STATIC_ESSID)) {
bf79451e 7046 priv->essid_len = min(network->ssid_len,
0edd5b44 7047 (u8) IW_ESSID_MAX_SIZE);
43f66a6c
JK		 7048 memcpy(priv->essid, network->ssid, priv->essid_len);
7049 }
7050
7051 network->last_associate = jiffies;
7052
7053 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7054 priv->assoc_request.channel = network->channel;
7055 if ((priv->capability & CAP_PRIVACY_ON) &&
7056 (priv->capability & CAP_SHARED_KEY)) {
7057 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
b095c381
JK		 7058 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7059
7060 if ((priv->capability & CAP_PRIVACY_ON) &&
7061 (priv->ieee->sec.level == SEC_LEVEL_1) &&
7062 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
7063 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
43f66a6c
JK		 7064 } else {
7065 priv->assoc_request.auth_type = AUTH_OPEN;
7066 priv->assoc_request.auth_key = 0;
7067 }
7068
b095c381 7069 if (priv->ieee->wpa_ie_len) {
ea2b26e0
JK		 7070 priv->assoc_request.policy_support = 0x02; /* RSN active */
7071 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7072 priv->ieee->wpa_ie_len);
7073 }
43f66a6c 7074
bf79451e
JG		 7075 /*
7076 * It is valid for our ieee device to support multiple modes, but
7077 * when it comes to associating to a given network we have to choose
43f66a6c
JK		 7078 * just one mode.
7079 */
7080 if (network->mode & priv->ieee->mode & IEEE_A)
7081 priv->assoc_request.ieee_mode = IPW_A_MODE;
7082 else if (network->mode & priv->ieee->mode & IEEE_G)
7083 priv->assoc_request.ieee_mode = IPW_G_MODE;
7084 else if (network->mode & priv->ieee->mode & IEEE_B)
7085 priv->assoc_request.ieee_mode = IPW_B_MODE;
7086
ea2b26e0
JK		 7087 priv->assoc_request.capability = network->capability;
7088 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7089 && !(priv->config & CFG_PREAMBLE_LONG)) {
7090 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7091 } else {
7092 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7093
7094 /* Clear the short preamble if we won't be supporting it */
7095 priv->assoc_request.capability &=
7096 ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7097 }
7098
afbf30a2
JK		 7099 /* Clear capability bits that aren't used in Ad Hoc */
7100 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7101 priv->assoc_request.capability &=
7102 ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7103
43f66a6c 7104 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
ea2b26e0 7105 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
43f66a6c 7106 roaming ? "Rea" : "A",
bf79451e
JG		 7107 escape_essid(priv->essid, priv->essid_len),
7108 network->channel,
7109 ipw_modes[priv->assoc_request.ieee_mode],
7110 rates->num_rates,
ea2b26e0
JK		 7111 (priv->assoc_request.preamble_length ==
7112 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7113 network->capability &
7114 WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
43f66a6c 7115 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
bf79451e
JG		 7116 priv->capability & CAP_PRIVACY_ON ?
7117 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
43f66a6c
JK		 7118 "(open)") : "",
7119 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
bf79451e 7120 priv->capability & CAP_PRIVACY_ON ?
b095c381 7121 '1' + priv->ieee->sec.active_key : '.',
0edd5b44 7122 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
43f66a6c
JK		 7123
7124 priv->assoc_request.beacon_interval = network->beacon_interval;
7125 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
0edd5b44 7126 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
43f66a6c
JK		 7127 priv->assoc_request.assoc_type = HC_IBSS_START;
7128 priv->assoc_request.assoc_tsf_msw = 0;
7129 priv->assoc_request.assoc_tsf_lsw = 0;
7130 } else {
7131 if (unlikely(roaming))
7132 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7133 else
7134 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7135 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7136 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7137 }
7138
afbf30a2 7139 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
43f66a6c
JK		 7140
7141 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7142 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7143 priv->assoc_request.atim_window = network->atim_window;
7144 } else {
afbf30a2 7145 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
43f66a6c
JK		 7146 priv->assoc_request.atim_window = 0;
7147 }
7148
43f66a6c 7149 priv->assoc_request.listen_interval = network->listen_interval;
bf79451e 7150
43f66a6c
JK		 7151 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7152 if (err) {
7153 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7154 return err;
7155 }
7156
7157 rates->ieee_mode = priv->assoc_request.ieee_mode;
7158 rates->purpose = IPW_RATE_CONNECT;
7159 ipw_send_supported_rates(priv, rates);
bf79451e 7160
43f66a6c
JK		 7161 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7162 priv->sys_config.dot11g_auto_detection = 1;
7163 else
7164 priv->sys_config.dot11g_auto_detection = 0;
c848d0af
JK		 7165
7166 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7167 priv->sys_config.answer_broadcast_ssid_probe = 1;
7168 else
7169 priv->sys_config.answer_broadcast_ssid_probe = 0;
7170
43f66a6c
JK		 7171 err = ipw_send_system_config(priv, &priv->sys_config);
7172 if (err) {
7173 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7174 return err;
7175 }
bf79451e 7176
43f66a6c 7177 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
ea2b26e0 7178 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
43f66a6c
JK		 7179 if (err) {
7180 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7181 return err;
7182 }
7183
7184 /*
7185 * If preemption is enabled, it is possible for the association
7186 * to complete before we return from ipw_send_associate. Therefore
7187 * we have to be sure and update our priviate data first.
7188 */
7189 priv->channel = network->channel;
7190 memcpy(priv->bssid, network->bssid, ETH_ALEN);
bf79451e 7191 priv->status |= STATUS_ASSOCIATING;
43f66a6c
JK		 7192 priv->status &= ~STATUS_SECURITY_UPDATED;
7193
7194 priv->assoc_network = network;
7195
b095c381
JK		 7196#ifdef CONFIG_IPW_QOS
7197 ipw_qos_association(priv, network);
7198#endif
7199
43f66a6c
JK		 7200 err = ipw_send_associate(priv, &priv->assoc_request);
7201 if (err) {
7202 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7203 return err;
7204 }
bf79451e
JG		 7205
7206 IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
43f66a6c
JK		 7207 escape_essid(priv->essid, priv->essid_len),
7208 MAC_ARG(priv->bssid));
7209
7210 return 0;
7211}
7212
7213static void ipw_roam(void *data)
7214{
7215 struct ipw_priv *priv = data;
7216 struct ieee80211_network *network = NULL;
7217 struct ipw_network_match match = {
7218 .network = priv->assoc_network
7219 };
7220
7221 /* The roaming process is as follows:
bf79451e
JG		 7222 *
7223 * 1. Missed beacon threshold triggers the roaming process by
43f66a6c
JK		 7224 * setting the status ROAM bit and requesting a scan.
7225 * 2. When the scan completes, it schedules the ROAM work
7226 * 3. The ROAM work looks at all of the known networks for one that
7227 * is a better network than the currently associated. If none
7228 * found, the ROAM process is over (ROAM bit cleared)
7229 * 4. If a better network is found, a disassociation request is
7230 * sent.
7231 * 5. When the disassociation completes, the roam work is again
7232 * scheduled. The second time through, the driver is no longer
7233 * associated, and the newly selected network is sent an
bf79451e 7234 * association request.
43f66a6c
JK		 7235 * 6. At this point ,the roaming process is complete and the ROAM
7236 * status bit is cleared.
7237 */
7238
7239 /* If we are no longer associated, and the roaming bit is no longer
7240 * set, then we are not actively roaming, so just return */
7241 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7242 return;
bf79451e 7243
43f66a6c 7244 if (priv->status & STATUS_ASSOCIATED) {
bf79451e 7245 /* First pass through ROAM process -- look for a better
43f66a6c 7246 * network */
a613bffd 7247 unsigned long flags;
43f66a6c
JK		 7248 u8 rssi = priv->assoc_network->stats.rssi;
7249 priv->assoc_network->stats.rssi = -128;
a613bffd 7250 spin_lock_irqsave(&priv->ieee->lock, flags);
43f66a6c
JK		 7251 list_for_each_entry(network, &priv->ieee->network_list, list) {
7252 if (network != priv->assoc_network)
7253 ipw_best_network(priv, &match, network, 1);
7254 }
a613bffd 7255 spin_unlock_irqrestore(&priv->ieee->lock, flags);
43f66a6c 7256 priv->assoc_network->stats.rssi = rssi;
bf79451e 7257
43f66a6c
JK		 7258 if (match.network == priv->assoc_network) {
7259 IPW_DEBUG_ASSOC("No better APs in this network to "
7260 "roam to.\n");
7261 priv->status &= ~STATUS_ROAMING;
7262 ipw_debug_config(priv);
7263 return;
7264 }
bf79451e 7265
43f66a6c
JK		 7266 ipw_send_disassociate(priv, 1);
7267 priv->assoc_network = match.network;
7268
7269 return;
bf79451e 7270 }
43f66a6c
JK		 7271
7272 /* Second pass through ROAM process -- request association */
7273 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7274 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7275 priv->status &= ~STATUS_ROAMING;
7276}
7277
c848d0af
JK		 7278static void ipw_bg_roam(void *data)
7279{
7280 struct ipw_priv *priv = data;
7281 down(&priv->sem);
7282 ipw_roam(data);
7283 up(&priv->sem);
7284}
7285
7286static int ipw_associate(void *data)
43f66a6c
JK		 7287{
7288 struct ipw_priv *priv = data;
7289
7290 struct ieee80211_network *network = NULL;
7291 struct ipw_network_match match = {
7292 .network = NULL
7293 };
7294 struct ipw_supported_rates *rates;
7295 struct list_head *element;
a613bffd 7296 unsigned long flags;
43f66a6c 7297
b095c381
JK		 7298 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7299 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7300 return 0;
7301 }
7302
c848d0af 7303 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
afbf30a2
JK		 7304 IPW_DEBUG_ASSOC("Not attempting association (already in "
7305 "progress)\n");
c848d0af
JK		 7306 return 0;
7307 }
7308
e6324726
HL		 7309 if (priv->status & STATUS_DISASSOCIATING) {
7310 IPW_DEBUG_ASSOC("Not attempting association (in "
7311 "disassociating)\n ");
7312 queue_work(priv->workqueue, &priv->associate);
7313 return 0;
7314 }
7315
c848d0af 7316 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
afbf30a2
JK		 7317 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7318 "initialized)\n");
c848d0af
JK		 7319 return 0;
7320 }
43f66a6c
JK		 7321
7322 if (!(priv->config & CFG_ASSOCIATE) &&
7323 !(priv->config & (CFG_STATIC_ESSID |
0edd5b44 7324 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
43f66a6c 7325 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
c848d0af 7326 return 0;
43f66a6c
JK		 7327 }
7328
a613bffd
JK		 7329 /* Protect our use of the network_list */
7330 spin_lock_irqsave(&priv->ieee->lock, flags);
bf79451e 7331 list_for_each_entry(network, &priv->ieee->network_list, list)
0edd5b44 7332 ipw_best_network(priv, &match, network, 0);
43f66a6c
JK		 7333
7334 network = match.network;
7335 rates = &match.rates;
7336
7337 if (network == NULL &&
7338 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7339 priv->config & CFG_ADHOC_CREATE &&
7340 priv->config & CFG_STATIC_ESSID &&
a613bffd 7341 priv->config & CFG_STATIC_CHANNEL &&
43f66a6c
JK		 7342 !list_empty(&priv->ieee->network_free_list)) {
7343 element = priv->ieee->network_free_list.next;
0edd5b44 7344 network = list_entry(element, struct ieee80211_network, list);
43f66a6c
JK		 7345 ipw_adhoc_create(priv, network);
7346 rates = &priv->rates;
7347 list_del(element);
7348 list_add_tail(&network->list, &priv->ieee->network_list);
7349 }
a613bffd 7350 spin_unlock_irqrestore(&priv->ieee->lock, flags);
bf79451e 7351
43f66a6c
JK		 7352 /* If we reached the end of the list, then we don't have any valid
7353 * matching APs */
7354 if (!network) {
7355 ipw_debug_config(priv);
7356
b095c381
JK		 7357 if (!(priv->status & STATUS_SCANNING)) {
7358 if (!(priv->config & CFG_SPEED_SCAN))
7359 queue_delayed_work(priv->workqueue,
7360 &priv->request_scan,
7361 SCAN_INTERVAL);
7362 else
7363 queue_work(priv->workqueue,
7364 &priv->request_scan);
7365 }
bf79451e 7366
c848d0af 7367 return 0;
43f66a6c
JK		 7368 }
7369
7370 ipw_associate_network(priv, network, rates, 0);
c848d0af
JK		 7371
7372 return 1;
7373}
7374
7375static void ipw_bg_associate(void *data)
7376{
7377 struct ipw_priv *priv = data;
7378 down(&priv->sem);
7379 ipw_associate(data);
7380 up(&priv->sem);
43f66a6c 7381}
bf79451e 7382
b095c381
JK		 7383static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7384 struct sk_buff *skb)
7385{
7386 struct ieee80211_hdr *hdr;
7387 u16 fc;
7388
7389 hdr = (struct ieee80211_hdr *)skb->data;
7390 fc = le16_to_cpu(hdr->frame_ctl);
7391 if (!(fc & IEEE80211_FCTL_PROTECTED))
7392 return;
7393
7394 fc &= ~IEEE80211_FCTL_PROTECTED;
7395 hdr->frame_ctl = cpu_to_le16(fc);
7396 switch (priv->ieee->sec.level) {
7397 case SEC_LEVEL_3:
7398 /* Remove CCMP HDR */
7399 memmove(skb->data + IEEE80211_3ADDR_LEN,
7400 skb->data + IEEE80211_3ADDR_LEN + 8,
7401 skb->len - IEEE80211_3ADDR_LEN - 8);
f4ff497d 7402 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
b095c381
JK		 7403 break;
7404 case SEC_LEVEL_2:
7405 break;
7406 case SEC_LEVEL_1:
7407 /* Remove IV */
7408 memmove(skb->data + IEEE80211_3ADDR_LEN,
7409 skb->data + IEEE80211_3ADDR_LEN + 4,
7410 skb->len - IEEE80211_3ADDR_LEN - 4);
f4ff497d 7411 skb_trim(skb, skb->len - 8); /* IV + ICV */
b095c381
JK		 7412 break;
7413 case SEC_LEVEL_0:
7414 break;
7415 default:
7416 printk(KERN_ERR "Unknow security level %d\n",
7417 priv->ieee->sec.level);
7418 break;
7419 }
43f66a6c 7420}
bf79451e 7421
b095c381
JK		 7422static void ipw_handle_data_packet(struct ipw_priv *priv,
7423 struct ipw_rx_mem_buffer *rxb,
7424 struct ieee80211_rx_stats *stats)
43f66a6c 7425{
567deaf6 7426 struct ieee80211_hdr_4addr *hdr;
43f66a6c
JK		 7427 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7428
7429 /* We received data from the HW, so stop the watchdog */
7430 priv->net_dev->trans_start = jiffies;
7431
bf79451e 7432 /* We only process data packets if the
43f66a6c 7433 * interface is open */
a613bffd 7434 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
43f66a6c
JK		 7435 skb_tailroom(rxb->skb))) {
7436 priv->ieee->stats.rx_errors++;
7437 priv->wstats.discard.misc++;
7438 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7439 return;
7440 } else if (unlikely(!netif_running(priv->net_dev))) {
7441 priv->ieee->stats.rx_dropped++;
7442 priv->wstats.discard.misc++;
7443 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7444 return;
7445 }
7446
7447 /* Advance skb->data to the start of the actual payload */
aaa4d308 7448 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
43f66a6c
JK		 7449
7450 /* Set the size of the skb to the size of the frame */
a613bffd 7451 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
43f66a6c
JK		 7452
7453 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7454
b095c381 7455 /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
567deaf6
HL		 7456 hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7457 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
9d5b880b
HL		 7458 ((is_multicast_ether_addr(hdr->addr1) ||
7459 is_broadcast_ether_addr(hdr->addr1)) ?
567deaf6 7460 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
b095c381
JK		 7461 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7462
bf79451e 7463 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
43f66a6c 7464 priv->ieee->stats.rx_errors++;
a613bffd 7465 else { /* ieee80211_rx succeeded, so it now owns the SKB */
43f66a6c 7466 rxb->skb = NULL;
b095c381 7467 __ipw_led_activity_on(priv);
a613bffd 7468 }
43f66a6c
JK		 7469}
7470
24a47dbd
MK		 7471#ifdef CONFIG_IEEE80211_RADIOTAP
7472static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7473 struct ipw_rx_mem_buffer *rxb,
7474 struct ieee80211_rx_stats *stats)
7475{
7476 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7477 struct ipw_rx_frame *frame = &pkt->u.frame;
7478
7479 /* initial pull of some data */
7480 u16 received_channel = frame->received_channel;
7481 u8 antennaAndPhy = frame->antennaAndPhy;
7482 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7483 u16 pktrate = frame->rate;
7484
7485 /* Magic struct that slots into the radiotap header -- no reason
7486 * to build this manually element by element, we can write it much
7487 * more efficiently than we can parse it. ORDER MATTERS HERE */
7488 struct ipw_rt_hdr {
7489 struct ieee80211_radiotap_header rt_hdr;
7490 u8 rt_flags; /* radiotap packet flags */
7491 u8 rt_rate; /* rate in 500kb/s */
7492 u16 rt_channel; /* channel in mhz */
7493 u16 rt_chbitmask; /* channel bitfield */
7494 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
7495 u8 rt_antenna; /* antenna number */
7496 } *ipw_rt;
7497
7498 short len = le16_to_cpu(pkt->u.frame.length);
7499
7500 /* We received data from the HW, so stop the watchdog */
7501 priv->net_dev->trans_start = jiffies;
7502
7503 /* We only process data packets if the
7504 * interface is open */
7505 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7506 skb_tailroom(rxb->skb))) {
7507 priv->ieee->stats.rx_errors++;
7508 priv->wstats.discard.misc++;
7509 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7510 return;
7511 } else if (unlikely(!netif_running(priv->net_dev))) {
7512 priv->ieee->stats.rx_dropped++;
7513 priv->wstats.discard.misc++;
7514 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7515 return;
7516 }
7517
7518 /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7519 * that now */
7520 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7521 /* FIXME: Should alloc bigger skb instead */
7522 priv->ieee->stats.rx_dropped++;
7523 priv->wstats.discard.misc++;
7524 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7525 return;
7526 }
7527
7528 /* copy the frame itself */
7529 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7530 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7531
7532 /* Zero the radiotap static buffer ... We only need to zero the bytes NOT
7533 * part of our real header, saves a little time.
7534 *
7535 * No longer necessary since we fill in all our data. Purge before merging
7536 * patch officially.
7537 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7538 * IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7539 */
7540
7541 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7542
7543 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7544 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7545 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total header+data */
7546
7547 /* Big bitfield of all the fields we provide in radiotap */
7548 ipw_rt->rt_hdr.it_present =
7549 ((1 << IEEE80211_RADIOTAP_FLAGS) |
7550 (1 << IEEE80211_RADIOTAP_RATE) |
7551 (1 << IEEE80211_RADIOTAP_CHANNEL) |
7552 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7553 (1 << IEEE80211_RADIOTAP_ANTENNA));
7554
7555 /* Zero the flags, we'll add to them as we go */
7556 ipw_rt->rt_flags = 0;
7557
7558 /* Convert signal to DBM */
7559 ipw_rt->rt_dbmsignal = antsignal;
7560
7561 /* Convert the channel data and set the flags */
7562 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7563 if (received_channel > 14) { /* 802.11a */
7564 ipw_rt->rt_chbitmask =
7565 cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7566 } else if (antennaAndPhy & 32) { /* 802.11b */
7567 ipw_rt->rt_chbitmask =
7568 cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7569 } else { /* 802.11g */
7570 ipw_rt->rt_chbitmask =
7571 (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7572 }
7573
7574 /* set the rate in multiples of 500k/s */
7575 switch (pktrate) {
7576 case IPW_TX_RATE_1MB:
7577 ipw_rt->rt_rate = 2;
7578 break;
7579 case IPW_TX_RATE_2MB:
7580 ipw_rt->rt_rate = 4;
7581 break;
7582 case IPW_TX_RATE_5MB:
7583 ipw_rt->rt_rate = 10;
7584 break;
7585 case IPW_TX_RATE_6MB:
7586 ipw_rt->rt_rate = 12;
7587 break;
7588 case IPW_TX_RATE_9MB:
7589 ipw_rt->rt_rate = 18;
7590 break;
7591 case IPW_TX_RATE_11MB:
7592 ipw_rt->rt_rate = 22;
7593 break;
7594 case IPW_TX_RATE_12MB:
7595 ipw_rt->rt_rate = 24;
7596 break;
7597 case IPW_TX_RATE_18MB:
7598 ipw_rt->rt_rate = 36;
7599 break;
7600 case IPW_TX_RATE_24MB:
7601 ipw_rt->rt_rate = 48;
7602 break;
7603 case IPW_TX_RATE_36MB:
7604 ipw_rt->rt_rate = 72;
7605 break;
7606 case IPW_TX_RATE_48MB:
7607 ipw_rt->rt_rate = 96;
7608 break;
7609 case IPW_TX_RATE_54MB:
7610 ipw_rt->rt_rate = 108;
7611 break;
7612 default:
7613 ipw_rt->rt_rate = 0;
7614 break;
7615 }
7616
7617 /* antenna number */
7618 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7619
7620 /* set the preamble flag if we have it */
7621 if ((antennaAndPhy & 64))
7622 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7623
7624 /* Set the size of the skb to the size of the frame */
7625 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
43f66a6c
JK		 7626
7627 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7628
bf79451e 7629 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
43f66a6c 7630 priv->ieee->stats.rx_errors++;
24a47dbd
MK		 7631 else { /* ieee80211_rx succeeded, so it now owns the SKB */
7632 rxb->skb = NULL;
7633 /* no LED during capture */
7634 }
7635}
7636#endif
7637
ea2b26e0
JK		 7638static inline int is_network_packet(struct ipw_priv *priv,
7639 struct ieee80211_hdr_4addr *header)
7640{
7641 /* Filter incoming packets to determine if they are targetted toward
7642 * this network, discarding packets coming from ourselves */
7643 switch (priv->ieee->iw_mode) {
a613bffd 7644 case IW_MODE_ADHOC: /* Header: Dest. | Source | BSSID */
c848d0af
JK		 7645 /* packets from our adapter are dropped (echo) */
7646 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7647 return 0;
7648
90700fd9
PJ		 7649 /* {broad,multi}cast packets to our BSSID go through */
7650 if (is_multicast_ether_addr(header->addr1) ||
7651 is_broadcast_ether_addr(header->addr1))
ea2b26e0 7652 return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
a613bffd
JK		 7653
7654 /* packets to our adapter go through */
7655 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7656 ETH_ALEN);
a613bffd 7657
90700fd9 7658 case IW_MODE_INFRA: /* Header: Dest. | BSSID | Source */
c848d0af
JK		 7659 /* packets from our adapter are dropped (echo) */
7660 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7661 return 0;
7662
90700fd9
PJ		 7663 /* {broad,multi}cast packets to our BSS go through */
7664 if (is_multicast_ether_addr(header->addr1) ||
7665 is_broadcast_ether_addr(header->addr1))
a613bffd
JK		 7666 return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7667
7668 /* packets to our adapter go through */
7669 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7670 ETH_ALEN);
ea2b26e0 7671 }
a613bffd 7672
ea2b26e0
JK		 7673 return 1;
7674}
7675
afbf30a2
JK		 7676#define IPW_PACKET_RETRY_TIME HZ
7677
7678static inline int is_duplicate_packet(struct ipw_priv *priv,
7679 struct ieee80211_hdr_4addr *header)
7680{
afbf30a2
JK		 7681 u16 sc = le16_to_cpu(header->seq_ctl);
7682 u16 seq = WLAN_GET_SEQ_SEQ(sc);
7683 u16 frag = WLAN_GET_SEQ_FRAG(sc);
7684 u16 *last_seq, *last_frag;
7685 unsigned long *last_time;
7686
7687 switch (priv->ieee->iw_mode) {
7688 case IW_MODE_ADHOC:
7689 {
7690 struct list_head *p;
7691 struct ipw_ibss_seq *entry = NULL;
7692 u8 *mac = header->addr2;
7693 int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7694
7695 __list_for_each(p, &priv->ibss_mac_hash[index]) {
7696 entry =
7697 list_entry(p, struct ipw_ibss_seq, list);
7698 if (!memcmp(entry->mac, mac, ETH_ALEN))
7699 break;
7700 }
7701 if (p == &priv->ibss_mac_hash[index]) {
7702 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7703 if (!entry) {
7704 IPW_ERROR
7705 ("Cannot malloc new mac entry\n");
7706 return 0;
7707 }
7708 memcpy(entry->mac, mac, ETH_ALEN);
7709 entry->seq_num = seq;
7710 entry->frag_num = frag;
7711 entry->packet_time = jiffies;
7712 list_add(&entry->list,
7713 &priv->ibss_mac_hash[index]);
7714 return 0;
7715 }
7716 last_seq = &entry->seq_num;
7717 last_frag = &entry->frag_num;
7718 last_time = &entry->packet_time;
7719 break;
7720 }
7721 case IW_MODE_INFRA:
7722 last_seq = &priv->last_seq_num;
7723 last_frag = &priv->last_frag_num;
7724 last_time = &priv->last_packet_time;
7725 break;
7726 default:
7727 return 0;
7728 }
7729 if ((*last_seq == seq) &&
7730 time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7731 if (*last_frag == frag)
7732 goto drop;
7733 if (*last_frag + 1 != frag)
7734 /* out-of-order fragment */
7735 goto drop;
afbf30a2
JK		 7736 } else
7737 *last_seq = seq;
7738
f57ce7ce 7739 *last_frag = frag;
afbf30a2
JK		 7740 *last_time = jiffies;
7741 return 0;
7742
7743 drop:
87b016cb
ZY		 7744 /* Comment this line now since we observed the card receives
7745 * duplicate packets but the FCTL_RETRY bit is not set in the
7746 * IBSS mode with fragmentation enabled.
7747 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
afbf30a2
JK		 7748 return 1;
7749}
7750
b095c381
JK		 7751static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7752 struct ipw_rx_mem_buffer *rxb,
7753 struct ieee80211_rx_stats *stats)
7754{
7755 struct sk_buff *skb = rxb->skb;
7756 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7757 struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7758 (skb->data + IPW_RX_FRAME_SIZE);
7759
7760 ieee80211_rx_mgt(priv->ieee, header, stats);
7761
7762 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7763 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7764 IEEE80211_STYPE_PROBE_RESP) ||
7765 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7766 IEEE80211_STYPE_BEACON))) {
7767 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7768 ipw_add_station(priv, header->addr2);
7769 }
7770
7771 if (priv->config & CFG_NET_STATS) {
7772 IPW_DEBUG_HC("sending stat packet\n");
7773
7774 /* Set the size of the skb to the size of the full
7775 * ipw header and 802.11 frame */
7776 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7777 IPW_RX_FRAME_SIZE);
7778
7779 /* Advance past the ipw packet header to the 802.11 frame */
7780 skb_pull(skb, IPW_RX_FRAME_SIZE);
7781
7782 /* Push the ieee80211_rx_stats before the 802.11 frame */
7783 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7784
7785 skb->dev = priv->ieee->dev;
7786
7787 /* Point raw at the ieee80211_stats */
7788 skb->mac.raw = skb->data;
7789
7790 skb->pkt_type = PACKET_OTHERHOST;
7791 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7792 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7793 netif_rx(skb);
43f66a6c 7794 rxb->skb = NULL;
b095c381 7795 }
43f66a6c
JK		 7796}
7797
43f66a6c
JK		 7798/*
7799 * Main entry function for recieving a packet with 80211 headers. This
7800 * should be called when ever the FW has notified us that there is a new
7801 * skb in the recieve queue.
7802 */
7803static void ipw_rx(struct ipw_priv *priv)
7804{
7805 struct ipw_rx_mem_buffer *rxb;
7806 struct ipw_rx_packet *pkt;
0dacca1f 7807 struct ieee80211_hdr_4addr *header;
43f66a6c
JK		 7808 u32 r, w, i;
7809 u8 network_packet;
7810
b095c381
JK		 7811 r = ipw_read32(priv, IPW_RX_READ_INDEX);
7812 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
43f66a6c
JK		 7813 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7814
7815 while (i != r) {
7816 rxb = priv->rxq->queue[i];
0f52bf90 7817#ifdef CONFIG_IPW2200_DEBUG
43f66a6c
JK		 7818 if (unlikely(rxb == NULL)) {
7819 printk(KERN_CRIT "Queue not allocated!\n");
7820 break;
7821 }
7822#endif
7823 priv->rxq->queue[i] = NULL;
7824
7825 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
b095c381 7826 IPW_RX_BUF_SIZE,
43f66a6c
JK		 7827 PCI_DMA_FROMDEVICE);
7828
7829 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7830 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7831 pkt->header.message_type,
0edd5b44 7832 pkt->header.rx_seq_num, pkt->header.control_bits);
43f66a6c
JK		 7833
7834 switch (pkt->header.message_type) {
0edd5b44
JG		 7835 case RX_FRAME_TYPE: /* 802.11 frame */ {
7836 struct ieee80211_rx_stats stats = {
c848d0af
JK		 7837 .rssi =
7838 le16_to_cpu(pkt->u.frame.rssi_dbm) -
0edd5b44 7839 IPW_RSSI_TO_DBM,
c848d0af
JK		 7840 .signal =
7841 le16_to_cpu(pkt->u.frame.signal),
7842 .noise =
7843 le16_to_cpu(pkt->u.frame.noise),
0edd5b44
JG		 7844 .rate = pkt->u.frame.rate,
7845 .mac_time = jiffies,
7846 .received_channel =
7847 pkt->u.frame.received_channel,
7848 .freq =
7849 (pkt->u.frame.
7850 control & (1 << 0)) ?
7851 IEEE80211_24GHZ_BAND :
7852 IEEE80211_52GHZ_BAND,
a613bffd 7853 .len = le16_to_cpu(pkt->u.frame.length),
0edd5b44
JG		 7854 };
7855
7856 if (stats.rssi != 0)
7857 stats.mask |= IEEE80211_STATMASK_RSSI;
7858 if (stats.signal != 0)
7859 stats.mask |= IEEE80211_STATMASK_SIGNAL;
c848d0af
JK		 7860 if (stats.noise != 0)
7861 stats.mask |= IEEE80211_STATMASK_NOISE;
0edd5b44
JG		 7862 if (stats.rate != 0)
7863 stats.mask |= IEEE80211_STATMASK_RATE;
7864
7865 priv->rx_packets++;
43f66a6c 7866
b095c381 7867#ifdef CONFIG_IPW2200_MONITOR
0edd5b44 7868 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
24a47dbd
MK		 7869#ifdef CONFIG_IEEE80211_RADIOTAP
7870 ipw_handle_data_packet_monitor(priv,
7871 rxb,
7872 &stats);
7873#else
0edd5b44
JG		 7874 ipw_handle_data_packet(priv, rxb,
7875 &stats);
24a47dbd 7876#endif
0edd5b44
JG		 7877 break;
7878 }
43f66a6c 7879#endif
bf79451e 7880
0edd5b44 7881 header =
0dacca1f
JK		 7882 (struct ieee80211_hdr_4addr *)(rxb->skb->
7883 data +
7884 IPW_RX_FRAME_SIZE);
43f66a6c
JK		 7885 /* TODO: Check Ad-Hoc dest/source and make sure
7886 * that we are actually parsing these packets
bf79451e 7887 * correctly -- we should probably use the
43f66a6c
JK		 7888 * frame control of the packet and disregard
7889 * the current iw_mode */
0edd5b44 7890
ea2b26e0
JK		 7891 network_packet =
7892 is_network_packet(priv, header);
0edd5b44
JG		 7893 if (network_packet && priv->assoc_network) {
7894 priv->assoc_network->stats.rssi =
7895 stats.rssi;
7896 average_add(&priv->average_rssi,
7897 stats.rssi);
7898 priv->last_rx_rssi = stats.rssi;
7899 }
7900
7901 IPW_DEBUG_RX("Frame: len=%u\n",
a613bffd 7902 le16_to_cpu(pkt->u.frame.length));
0edd5b44 7903
a613bffd
JK		 7904 if (le16_to_cpu(pkt->u.frame.length) <
7905 frame_hdr_len(header)) {
0edd5b44
JG		 7906 IPW_DEBUG_DROP
7907 ("Received packet is too small. "
7908 "Dropping.\n");
7909 priv->ieee->stats.rx_errors++;
7910 priv->wstats.discard.misc++;
7911 break;
7912 }
7913
a613bffd
JK		 7914 switch (WLAN_FC_GET_TYPE
7915 (le16_to_cpu(header->frame_ctl))) {
b095c381 7916
0edd5b44 7917 case IEEE80211_FTYPE_MGMT:
b095c381
JK		 7918 ipw_handle_mgmt_packet(priv, rxb,
7919 &stats);
0edd5b44
JG		 7920 break;
7921
7922 case IEEE80211_FTYPE_CTL:
7923 break;
7924
7925 case IEEE80211_FTYPE_DATA:
afbf30a2
JK		 7926 if (unlikely(!network_packet ||
7927 is_duplicate_packet(priv,
7928 header)))
7929 {
0edd5b44
JG		 7930 IPW_DEBUG_DROP("Dropping: "
7931 MAC_FMT ", "
7932 MAC_FMT ", "
7933 MAC_FMT "\n",
7934 MAC_ARG(header->
7935 addr1),
7936 MAC_ARG(header->
7937 addr2),
7938 MAC_ARG(header->
7939 addr3));
b095c381
JK		 7940 break;
7941 }
7942
7943 ipw_handle_data_packet(priv, rxb,
7944 &stats);
7945
0edd5b44
JG		 7946 break;
7947 }
43f66a6c
JK		 7948 break;
7949 }
bf79451e 7950
0edd5b44
JG		 7951 case RX_HOST_NOTIFICATION_TYPE:{
7952 IPW_DEBUG_RX
7953 ("Notification: subtype=%02X flags=%02X size=%d\n",
43f66a6c
JK		 7954 pkt->u.notification.subtype,
7955 pkt->u.notification.flags,
7956 pkt->u.notification.size);
0edd5b44
JG		 7957 ipw_rx_notification(priv, &pkt->u.notification);
7958 break;
7959 }
43f66a6c
JK		 7960
7961 default:
7962 IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7963 pkt->header.message_type);
7964 break;
7965 }
bf79451e
JG		 7966
7967 /* For now we just don't re-use anything. We can tweak this
7968 * later to try and re-use notification packets and SKBs that
43f66a6c
JK		 7969 * fail to Rx correctly */
7970 if (rxb->skb != NULL) {
7971 dev_kfree_skb_any(rxb->skb);
7972 rxb->skb = NULL;
7973 }
bf79451e 7974
43f66a6c 7975 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
b095c381 7976 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
43f66a6c 7977 list_add_tail(&rxb->list, &priv->rxq->rx_used);
bf79451e 7978
43f66a6c
JK		 7979 i = (i + 1) % RX_QUEUE_SIZE;
7980 }
7981
7982 /* Backtrack one entry */
7983 priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7984
7985 ipw_rx_queue_restock(priv);
7986}
7987
afbf30a2
JK		 7988#define DEFAULT_RTS_THRESHOLD 2304U
7989#define MIN_RTS_THRESHOLD 1U
7990#define MAX_RTS_THRESHOLD 2304U
7991#define DEFAULT_BEACON_INTERVAL 100U
7992#define DEFAULT_SHORT_RETRY_LIMIT 7U
7993#define DEFAULT_LONG_RETRY_LIMIT 4U
7994
7995static int ipw_sw_reset(struct ipw_priv *priv, int init)
43f66a6c 7996{
afbf30a2
JK		 7997 int band, modulation;
7998 int old_mode = priv->ieee->iw_mode;
43f66a6c 7999
afbf30a2
JK		 8000 /* Initialize module parameter values here */
8001 priv->config = 0;
43f66a6c 8002
afbf30a2
JK		 8003 /* We default to disabling the LED code as right now it causes
8004 * too many systems to lock up... */
8005 if (!led)
8006 priv->config |= CFG_NO_LED;
43f66a6c 8007
afbf30a2
JK		 8008 if (associate)
8009 priv->config |= CFG_ASSOCIATE;
8010 else
8011 IPW_DEBUG_INFO("Auto associate disabled.\n");
bf79451e 8012
afbf30a2
JK		 8013 if (auto_create)
8014 priv->config |= CFG_ADHOC_CREATE;
8015 else
8016 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
43f66a6c 8017
afbf30a2
JK		 8018 if (disable) {
8019 priv->status |= STATUS_RF_KILL_SW;
8020 IPW_DEBUG_INFO("Radio disabled.\n");
43f66a6c 8021 }
bf79451e 8022
afbf30a2
JK		 8023 if (channel != 0) {
8024 priv->config |= CFG_STATIC_CHANNEL;
8025 priv->channel = channel;
8026 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8027 /* TODO: Validate that provided channel is in range */
43f66a6c 8028 }
afbf30a2
JK		 8029#ifdef CONFIG_IPW_QOS
8030 ipw_qos_init(priv, qos_enable, qos_burst_enable,
8031 burst_duration_CCK, burst_duration_OFDM);
8032#endif /* CONFIG_IPW_QOS */
43f66a6c 8033
afbf30a2
JK		 8034 switch (mode) {
8035 case 1:
8036 priv->ieee->iw_mode = IW_MODE_ADHOC;
8037 priv->net_dev->type = ARPHRD_ETHER;
8038
8039 break;
8040#ifdef CONFIG_IPW2200_MONITOR
8041 case 2:
8042 priv->ieee->iw_mode = IW_MODE_MONITOR;
24a47dbd
MK		 8043#ifdef CONFIG_IEEE80211_RADIOTAP
8044 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8045#else
afbf30a2 8046 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8047#endif
afbf30a2
JK		 8048 break;
8049#endif
8050 default:
8051 case 0:
8052 priv->net_dev->type = ARPHRD_ETHER;
8053 priv->ieee->iw_mode = IW_MODE_INFRA;
8054 break;
43f66a6c
JK		 8055 }
8056
afbf30a2
JK		 8057 if (hwcrypto) {
8058 priv->ieee->host_encrypt = 0;
8059 priv->ieee->host_encrypt_msdu = 0;
8060 priv->ieee->host_decrypt = 0;
567deaf6 8061 priv->ieee->host_mc_decrypt = 0;
afbf30a2
JK		 8062 }
8063 IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
43f66a6c 8064
e402c937
ZY		 8065 /* IPW2200/2915 is abled to do hardware fragmentation. */
8066 priv->ieee->host_open_frag = 0;
bf79451e 8067
afbf30a2
JK		 8068 if ((priv->pci_dev->device == 0x4223) ||
8069 (priv->pci_dev->device == 0x4224)) {
8070 if (init)
8071 printk(KERN_INFO DRV_NAME
8072 ": Detected Intel PRO/Wireless 2915ABG Network "
8073 "Connection\n");
8074 priv->ieee->abg_true = 1;
8075 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8076 modulation = IEEE80211_OFDM_MODULATION |
8077 IEEE80211_CCK_MODULATION;
8078 priv->adapter = IPW_2915ABG;
8079 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
43f66a6c 8080 } else {
afbf30a2
JK		 8081 if (init)
8082 printk(KERN_INFO DRV_NAME
8083 ": Detected Intel PRO/Wireless 2200BG Network "
8084 "Connection\n");
bf79451e 8085
afbf30a2
JK		 8086 priv->ieee->abg_true = 0;
8087 band = IEEE80211_24GHZ_BAND;
8088 modulation = IEEE80211_OFDM_MODULATION |
8089 IEEE80211_CCK_MODULATION;
8090 priv->adapter = IPW_2200BG;
8091 priv->ieee->mode = IEEE_G | IEEE_B;
43f66a6c
JK		 8092 }
8093
afbf30a2
JK		 8094 priv->ieee->freq_band = band;
8095 priv->ieee->modulation = modulation;
43f66a6c 8096
afbf30a2 8097 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
bf79451e 8098
afbf30a2
JK		 8099 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8100 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
43f66a6c 8101
afbf30a2
JK		 8102 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8103 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8104 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
43f66a6c 8105
afbf30a2
JK		 8106 /* If power management is turned on, default to AC mode */
8107 priv->power_mode = IPW_POWER_AC;
8108 priv->tx_power = IPW_TX_POWER_DEFAULT;
8109
0ece35b5 8110 return old_mode == priv->ieee->iw_mode;
43f66a6c
JK		 8111}
8112
8113/*
8114 * This file defines the Wireless Extension handlers. It does not
8115 * define any methods of hardware manipulation and relies on the
8116 * functions defined in ipw_main to provide the HW interaction.
bf79451e
JG		 8117 *
8118 * The exception to this is the use of the ipw_get_ordinal()
43f66a6c
JK		 8119 * function used to poll the hardware vs. making unecessary calls.
8120 *
8121 */
8122
bf79451e
JG		 8123static int ipw_wx_get_name(struct net_device *dev,
8124 struct iw_request_info *info,
43f66a6c
JK		 8125 union iwreq_data *wrqu, char *extra)
8126{
8127 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af
JK		 8128 down(&priv->sem);
8129 if (priv->status & STATUS_RF_KILL_MASK)
a613bffd 8130 strcpy(wrqu->name, "radio off");
c848d0af 8131 else if (!(priv->status & STATUS_ASSOCIATED))
43f66a6c 8132 strcpy(wrqu->name, "unassociated");
bf79451e 8133 else
43f66a6c
JK		 8134 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8135 ipw_modes[priv->assoc_request.ieee_mode]);
8136 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
c848d0af 8137 up(&priv->sem);
43f66a6c
JK		 8138 return 0;
8139}
8140
8141static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8142{
8143 if (channel == 0) {
8144 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8145 priv->config &= ~CFG_STATIC_CHANNEL;
c848d0af
JK		 8146 IPW_DEBUG_ASSOC("Attempting to associate with new "
8147 "parameters.\n");
8148 ipw_associate(priv);
43f66a6c
JK		 8149 return 0;
8150 }
8151
8152 priv->config |= CFG_STATIC_CHANNEL;
8153
8154 if (priv->channel == channel) {
0edd5b44
JG		 8155 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8156 channel);
43f66a6c
JK		 8157 return 0;
8158 }
8159
8160 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8161 priv->channel = channel;
8162
b095c381
JK		 8163#ifdef CONFIG_IPW2200_MONITOR
8164 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
afbf30a2 8165 int i;
b095c381 8166 if (priv->status & STATUS_SCANNING) {
afbf30a2 8167 IPW_DEBUG_SCAN("Scan abort triggered due to "
b095c381 8168 "channel change.\n");
afbf30a2 8169 ipw_abort_scan(priv);
b095c381
JK		 8170 }
8171
8172 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8173 udelay(10);
8174
8175 if (priv->status & STATUS_SCANNING)
8176 IPW_DEBUG_SCAN("Still scanning...\n");
8177 else
8178 IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8179 1000 - i);
8180
8181 return 0;
43f66a6c 8182 }
b095c381
JK		 8183#endif /* CONFIG_IPW2200_MONITOR */
8184
c848d0af
JK		 8185 /* Network configuration changed -- force [re]association */
8186 IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8187 if (!ipw_disassociate(priv))
43f66a6c 8188 ipw_associate(priv);
43f66a6c
JK		 8189
8190 return 0;
8191}
8192
bf79451e
JG		 8193static int ipw_wx_set_freq(struct net_device *dev,
8194 struct iw_request_info *info,
8195 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 8196{
8197 struct ipw_priv *priv = ieee80211_priv(dev);
1fe0adb4 8198 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
43f66a6c 8199 struct iw_freq *fwrq = &wrqu->freq;
afbf30a2 8200 int ret = 0, i;
1fe0adb4
LH		 8201 u8 channel, flags;
8202 int band;
b095c381
JK		 8203
8204 if (fwrq->m == 0) {
8205 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8206 down(&priv->sem);
8207 ret = ipw_set_channel(priv, 0);
8208 up(&priv->sem);
8209 return ret;
8210 }
43f66a6c
JK		 8211 /* if setting by freq convert to channel */
8212 if (fwrq->e == 1) {
1fe0adb4 8213 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
b095c381
JK		 8214 if (channel == 0)
8215 return -EINVAL;
8216 } else
8217 channel = fwrq->m;
bf79451e 8218
1fe0adb4 8219 if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
b095c381 8220 return -EINVAL;
43f66a6c 8221
1fe0adb4
LH		 8222 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8223 i = ipw_channel_to_index(priv->ieee, channel);
afbf30a2
JK		 8224 if (i == -1)
8225 return -EINVAL;
bf79451e 8226
1fe0adb4
LH		 8227 flags = (band == IEEE80211_24GHZ_BAND) ?
8228 geo->bg[i].flags : geo->a[i].flags;
8229 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
afbf30a2
JK		 8230 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8231 return -EINVAL;
43f66a6c
JK		 8232 }
8233 }
bf79451e 8234
43f66a6c 8235 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
c848d0af 8236 down(&priv->sem);
b095c381 8237 ret = ipw_set_channel(priv, channel);
c848d0af
JK		 8238 up(&priv->sem);
8239 return ret;
43f66a6c
JK		 8240}
8241
bf79451e
JG		 8242static int ipw_wx_get_freq(struct net_device *dev,
8243 struct iw_request_info *info,
43f66a6c
JK		 8244 union iwreq_data *wrqu, char *extra)
8245{
8246 struct ipw_priv *priv = ieee80211_priv(dev);
8247
8248 wrqu->freq.e = 0;
8249
8250 /* If we are associated, trying to associate, or have a statically
8251 * configured CHANNEL then return that; otherwise return ANY */
c848d0af 8252 down(&priv->sem);
43f66a6c
JK		 8253 if (priv->config & CFG_STATIC_CHANNEL ||
8254 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8255 wrqu->freq.m = priv->channel;
bf79451e 8256 else
43f66a6c
JK		 8257 wrqu->freq.m = 0;
8258
c848d0af 8259 up(&priv->sem);
43f66a6c
JK		 8260 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8261 return 0;
8262}
8263
bf79451e
JG		 8264static int ipw_wx_set_mode(struct net_device *dev,
8265 struct iw_request_info *info,
43f66a6c
JK		 8266 union iwreq_data *wrqu, char *extra)
8267{
8268 struct ipw_priv *priv = ieee80211_priv(dev);
8269 int err = 0;
8270
8271 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8272
43f66a6c 8273 switch (wrqu->mode) {
b095c381 8274#ifdef CONFIG_IPW2200_MONITOR
43f66a6c
JK		 8275 case IW_MODE_MONITOR:
8276#endif
8277 case IW_MODE_ADHOC:
8278 case IW_MODE_INFRA:
8279 break;
8280 case IW_MODE_AUTO:
8281 wrqu->mode = IW_MODE_INFRA;
8282 break;
8283 default:
8284 return -EINVAL;
8285 }
b095c381
JK		 8286 if (wrqu->mode == priv->ieee->iw_mode)
8287 return 0;
43f66a6c 8288
b095c381 8289 down(&priv->sem);
43f66a6c 8290
afbf30a2
JK		 8291 ipw_sw_reset(priv, 0);
8292
b095c381 8293#ifdef CONFIG_IPW2200_MONITOR
bf79451e 8294 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
43f66a6c 8295 priv->net_dev->type = ARPHRD_ETHER;
bf79451e
JG		 8296
8297 if (wrqu->mode == IW_MODE_MONITOR)
24a47dbd
MK		 8298#ifdef CONFIG_IEEE80211_RADIOTAP
8299 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8300#else
43f66a6c 8301 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 8302#endif
b095c381 8303#endif /* CONFIG_IPW2200_MONITOR */
bf79451e 8304
bf79451e 8305 /* Free the existing firmware and reset the fw_loaded
43f66a6c 8306 * flag so ipw_load() will bring in the new firmawre */
afbf30a2 8307 free_firmware();
43f66a6c
JK		 8308
8309 priv->ieee->iw_mode = wrqu->mode;
bf79451e 8310
c848d0af
JK		 8311 queue_work(priv->workqueue, &priv->adapter_restart);
8312 up(&priv->sem);
0edd5b44 8313 return err;
43f66a6c
JK		 8314}
8315
bf79451e 8316static int ipw_wx_get_mode(struct net_device *dev,
0edd5b44
JG		 8317 struct iw_request_info *info,
8318 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 8319{
8320 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 8321 down(&priv->sem);
43f66a6c
JK		 8322 wrqu->mode = priv->ieee->iw_mode;
8323 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
c848d0af 8324 up(&priv->sem);
43f66a6c
JK		 8325 return 0;
8326}
8327
43f66a6c
JK		 8328/* Values are in microsecond */
8329static const s32 timeout_duration[] = {
8330 350000,
8331 250000,
8332 75000,
8333 37000,
8334 25000,
8335};
8336
8337static const s32 period_duration[] = {
8338 400000,
8339 700000,
8340 1000000,
8341 1000000,
8342 1000000
8343};
8344
bf79451e
JG		 8345static int ipw_wx_get_range(struct net_device *dev,
8346 struct iw_request_info *info,
43f66a6c
JK		 8347 union iwreq_data *wrqu, char *extra)
8348{
8349 struct ipw_priv *priv = ieee80211_priv(dev);
8350 struct iw_range *range = (struct iw_range *)extra;
1fe0adb4 8351 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
b095c381 8352 int i = 0, j;
43f66a6c
JK		 8353
8354 wrqu->data.length = sizeof(*range);
8355 memset(range, 0, sizeof(*range));
8356
8357 /* 54Mbs == ~27 Mb/s real (802.11g) */
bf79451e 8358 range->throughput = 27 * 1000 * 1000;
43f66a6c
JK		 8359
8360 range->max_qual.qual = 100;
8361 /* TODO: Find real max RSSI and stick here */
8362 range->max_qual.level = 0;
c848d0af 8363 range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
0edd5b44 8364 range->max_qual.updated = 7; /* Updated all three */
43f66a6c
JK		 8365
8366 range->avg_qual.qual = 70;
8367 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
0edd5b44 8368 range->avg_qual.level = 0; /* FIXME to real average level */
43f66a6c 8369 range->avg_qual.noise = 0;
0edd5b44 8370 range->avg_qual.updated = 7; /* Updated all three */
c848d0af 8371 down(&priv->sem);
0edd5b44 8372 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
43f66a6c 8373
bf79451e
JG		 8374 for (i = 0; i < range->num_bitrates; i++)
8375 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
0edd5b44 8376 500000;
bf79451e 8377
43f66a6c
JK		 8378 range->max_rts = DEFAULT_RTS_THRESHOLD;
8379 range->min_frag = MIN_FRAG_THRESHOLD;
8380 range->max_frag = MAX_FRAG_THRESHOLD;
8381
8382 range->encoding_size[0] = 5;
bf79451e 8383 range->encoding_size[1] = 13;
43f66a6c
JK		 8384 range->num_encoding_sizes = 2;
8385 range->max_encoding_tokens = WEP_KEYS;
8386
8387 /* Set the Wireless Extension versions */
8388 range->we_version_compiled = WIRELESS_EXT;
8389 range->we_version_source = 16;
8390
b095c381
JK		 8391 i = 0;
8392 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8393 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
8394 i++, j++) {
8395 range->freq[i].i = geo->bg[j].channel;
8396 range->freq[i].m = geo->bg[j].freq * 100000;
8397 range->freq[i].e = 1;
8398 }
8399 }
43f66a6c 8400
b095c381
JK		 8401 if (priv->ieee->mode & IEEE_A) {
8402 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
8403 i++, j++) {
8404 range->freq[i].i = geo->a[j].channel;
8405 range->freq[i].m = geo->a[j].freq * 100000;
8406 range->freq[i].e = 1;
8407 }
43f66a6c 8408 }
b095c381
JK		 8409
8410 range->num_channels = i;
8411 range->num_frequency = i;
8412
c848d0af 8413 up(&priv->sem);
97a78ca9
BB		 8414
8415 /* Event capability (kernel + driver) */
8416 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8417 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8418 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8419 range->event_capa[1] = IW_EVENT_CAPA_K_1;
43f66a6c
JK		 8420
8421 IPW_DEBUG_WX("GET Range\n");
8422 return 0;
8423}
8424
bf79451e
JG		 8425static int ipw_wx_set_wap(struct net_device *dev,
8426 struct iw_request_info *info,
43f66a6c
JK		 8427 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
bf79451e 8438 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
43f66a6c 8439 return -EINVAL;
c848d0af 8440 down(&priv->sem);
43f66a6c
JK		 8441 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;
c848d0af
JK		 8446 IPW_DEBUG_ASSOC("Attempting to associate with new "
8447 "parameters.\n");
8448 ipw_associate(priv);
8449 up(&priv->sem);
43f66a6c
JK		 8450 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");
c848d0af 8456 up(&priv->sem);
43f66a6c
JK		 8457 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
c848d0af
JK		 8465 /* Network configuration changed -- force [re]association */
8466 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8467 if (!ipw_disassociate(priv))
43f66a6c 8468 ipw_associate(priv);
43f66a6c 8469
c848d0af 8470 up(&priv->sem);
43f66a6c
JK		 8471 return 0;
8472}
8473
bf79451e
JG		 8474static int ipw_wx_get_wap(struct net_device *dev,
8475 struct iw_request_info *info,
43f66a6c
JK		 8476 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 */
c848d0af 8481 down(&priv->sem);
bf79451e 8482 if (priv->config & CFG_STATIC_BSSID ||
43f66a6c
JK		 8483 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8484 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
afbf30a2 8485 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
43f66a6c
JK		 8486 } 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));
c848d0af 8491 up(&priv->sem);
43f66a6c
JK		 8492 return 0;
8493}
8494
bf79451e
JG		 8495static int ipw_wx_set_essid(struct net_device *dev,
8496 struct iw_request_info *info,
43f66a6c
JK		 8497 union iwreq_data *wrqu, char *extra)
8498{
8499 struct ipw_priv *priv = ieee80211_priv(dev);
0edd5b44 8500 char *essid = ""; /* ANY */
43f66a6c 8501 int length = 0;
c848d0af 8502 down(&priv->sem);
43f66a6c
JK		 8503 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");
afbf30a2
JK		 8509 if ((priv->config & CFG_STATIC_ESSID) &&
8510 !(priv->status & (STATUS_ASSOCIATED |
43f66a6c
JK		 8511 STATUS_ASSOCIATING))) {
8512 IPW_DEBUG_ASSOC("Attempting to associate with new "
8513 "parameters.\n");
afbf30a2 8514 priv->config &= ~CFG_STATIC_ESSID;
43f66a6c
JK		 8515 ipw_associate(priv);
8516 }
c848d0af 8517 up(&priv->sem);
43f66a6c
JK		 8518 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");
c848d0af 8527 up(&priv->sem);
43f66a6c
JK		 8528 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);
bf79451e 8536
c848d0af
JK		 8537 /* Network configuration changed -- force [re]association */
8538 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8539 if (!ipw_disassociate(priv))
43f66a6c 8540 ipw_associate(priv);
43f66a6c 8541
c848d0af 8542 up(&priv->sem);
43f66a6c
JK		 8543 return 0;
8544}
8545
bf79451e
JG		 8546static int ipw_wx_get_essid(struct net_device *dev,
8547 struct iw_request_info *info,
43f66a6c
JK		 8548 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 */
c848d0af 8554 down(&priv->sem);
43f66a6c 8555 if (priv->config & CFG_STATIC_ESSID ||
bf79451e
JG		 8556 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8557 IPW_DEBUG_WX("Getting essid: '%s'\n",
43f66a6c 8558 escape_essid(priv->essid, priv->essid_len));
bf79451e 8559 memcpy(extra, priv->essid, priv->essid_len);
43f66a6c 8560 wrqu->essid.length = priv->essid_len;
0edd5b44 8561 wrqu->essid.flags = 1; /* active */
43f66a6c
JK		 8562 } else {
8563 IPW_DEBUG_WX("Getting essid: ANY\n");
8564 wrqu->essid.length = 0;
0edd5b44 8565 wrqu->essid.flags = 0; /* active */
43f66a6c 8566 }
c848d0af 8567 up(&priv->sem);
43f66a6c
JK		 8568 return 0;
8569}
8570
bf79451e
JG		 8571static int ipw_wx_set_nick(struct net_device *dev,
8572 struct iw_request_info *info,
43f66a6c 8573 union iwreq_data *wrqu, char *extra)
bf79451e 8574{
43f66a6c
JK		 8575 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;
c848d0af 8580 down(&priv->sem);
0edd5b44 8581 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
43f66a6c 8582 memset(priv->nick, 0, sizeof(priv->nick));
0edd5b44 8583 memcpy(priv->nick, extra, wrqu->data.length);
43f66a6c 8584 IPW_DEBUG_TRACE("<<\n");
c848d0af 8585 up(&priv->sem);
43f66a6c
JK		 8586 return 0;
8587
8588}
8589
bf79451e
JG		 8590static int ipw_wx_get_nick(struct net_device *dev,
8591 struct iw_request_info *info,
43f66a6c 8592 union iwreq_data *wrqu, char *extra)
bf79451e 8593{
43f66a6c
JK		 8594 struct ipw_priv *priv = ieee80211_priv(dev);
8595 IPW_DEBUG_WX("Getting nick\n");
c848d0af 8596 down(&priv->sem);
43f66a6c
JK		 8597 wrqu->data.length = strlen(priv->nick) + 1;
8598 memcpy(extra, priv->nick, wrqu->data.length);
0edd5b44 8599 wrqu->data.flags = 1; /* active */
c848d0af 8600 up(&priv->sem);
43f66a6c
JK		 8601 return 0;
8602}
8603
43f66a6c
JK		 8604static int ipw_wx_set_rate(struct net_device *dev,
8605 struct iw_request_info *info,
8606 union iwreq_data *wrqu, char *extra)
bf79451e 8607{
ea2b26e0
JK		 8608 /* 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");
c848d0af 8693 down(&priv->sem);
b095c381 8694 if (mask == IEEE80211_DEFAULT_RATES_MASK) {
ea2b26e0 8695 priv->config &= ~CFG_FIXED_RATE;
b095c381
JK		 8696 ipw_set_fixed_rate(priv, priv->ieee->mode);
8697 } else
ea2b26e0
JK		 8698 priv->config |= CFG_FIXED_RATE;
8699
c848d0af
JK		 8700 if (priv->rates_mask == mask) {
8701 IPW_DEBUG_WX("Mask set to current mask.\n");
8702 up(&priv->sem);
8703 return 0;
ea2b26e0
JK		 8704 }
8705
c848d0af
JK		 8706 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
8713 up(&priv->sem);
ea2b26e0 8714 return 0;
43f66a6c
JK		 8715}
8716
bf79451e
JG		 8717static int ipw_wx_get_rate(struct net_device *dev,
8718 struct iw_request_info *info,
43f66a6c 8719 union iwreq_data *wrqu, char *extra)
bf79451e 8720{
0edd5b44 8721 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 8722 down(&priv->sem);
43f66a6c 8723 wrqu->bitrate.value = priv->last_rate;
c848d0af 8724 up(&priv->sem);
43f66a6c
JK		 8725 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8726 return 0;
8727}
8728
bf79451e
JG		 8729static int ipw_wx_set_rts(struct net_device *dev,
8730 struct iw_request_info *info,
43f66a6c 8731 union iwreq_data *wrqu, char *extra)
bf79451e 8732{
43f66a6c 8733 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 8734 down(&priv->sem);
43f66a6c
JK		 8735 if (wrqu->rts.disabled)
8736 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8737 else {
8738 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
c848d0af
JK		 8739 wrqu->rts.value > MAX_RTS_THRESHOLD) {
8740 up(&priv->sem);
43f66a6c 8741 return -EINVAL;
c848d0af 8742 }
43f66a6c
JK		 8743 priv->rts_threshold = wrqu->rts.value;
8744 }
8745
8746 ipw_send_rts_threshold(priv, priv->rts_threshold);
c848d0af 8747 up(&priv->sem);
43f66a6c
JK		 8748 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8749 return 0;
8750}
8751
bf79451e
JG		 8752static int ipw_wx_get_rts(struct net_device *dev,
8753 struct iw_request_info *info,
43f66a6c 8754 union iwreq_data *wrqu, char *extra)
bf79451e 8755{
43f66a6c 8756 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 8757 down(&priv->sem);
43f66a6c
JK		 8758 wrqu->rts.value = priv->rts_threshold;
8759 wrqu->rts.fixed = 0; /* no auto select */
0edd5b44 8760 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
c848d0af 8761 up(&priv->sem);
43f66a6c
JK		 8762 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8763 return 0;
8764}
8765
bf79451e
JG		 8766static int ipw_wx_set_txpow(struct net_device *dev,
8767 struct iw_request_info *info,
43f66a6c 8768 union iwreq_data *wrqu, char *extra)
bf79451e 8769{
43f66a6c 8770 struct ipw_priv *priv = ieee80211_priv(dev);
6de9f7f2 8771 int err = 0;
43f66a6c 8772
c848d0af
JK		 8773 down(&priv->sem);
8774 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
6de9f7f2
ZY		 8775 err = -EINPROGRESS;
8776 goto out;
43f66a6c 8777 }
43f66a6c 8778
b095c381
JK		 8779 if (!wrqu->power.fixed)
8780 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8781
c848d0af 8782 if (wrqu->power.flags != IW_TXPOW_DBM) {
6de9f7f2
ZY		 8783 err = -EINVAL;
8784 goto out;
c848d0af 8785 }
43f66a6c 8786
b095c381 8787 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
afbf30a2 8788 (wrqu->power.value < IPW_TX_POWER_MIN)) {
6de9f7f2
ZY		 8789 err = -EINVAL;
8790 goto out;
c848d0af 8791 }
43f66a6c 8792
43f66a6c 8793 priv->tx_power = wrqu->power.value;
6de9f7f2
ZY		 8794 err = ipw_set_tx_power(priv);
8795 out:
c848d0af 8796 up(&priv->sem);
6de9f7f2 8797 return err;
43f66a6c
JK		 8798}
8799
bf79451e
JG		 8800static int ipw_wx_get_txpow(struct net_device *dev,
8801 struct iw_request_info *info,
43f66a6c 8802 union iwreq_data *wrqu, char *extra)
bf79451e 8803{
43f66a6c 8804 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 8805 down(&priv->sem);
43f66a6c
JK		 8806 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;
c848d0af 8810 up(&priv->sem);
43f66a6c 8811
bf79451e 8812 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
22501c8e 8813 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
43f66a6c
JK		 8814
8815 return 0;
8816}
8817
bf79451e 8818static int ipw_wx_set_frag(struct net_device *dev,
0edd5b44
JG		 8819 struct iw_request_info *info,
8820 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 8821{
8822 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 8823 down(&priv->sem);
43f66a6c
JK		 8824 if (wrqu->frag.disabled)
8825 priv->ieee->fts = DEFAULT_FTS;
8826 else {
8827 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
b095c381
JK		 8828 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8829 up(&priv->sem);
43f66a6c 8830 return -EINVAL;
b095c381 8831 }
bf79451e 8832
43f66a6c
JK		 8833 priv->ieee->fts = wrqu->frag.value & ~0x1;
8834 }
8835
8836 ipw_send_frag_threshold(priv, wrqu->frag.value);
c848d0af 8837 up(&priv->sem);
43f66a6c
JK		 8838 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8839 return 0;
8840}
8841
bf79451e 8842static int ipw_wx_get_frag(struct net_device *dev,
0edd5b44
JG		 8843 struct iw_request_info *info,
8844 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 8845{
8846 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 8847 down(&priv->sem);
43f66a6c
JK		 8848 wrqu->frag.value = priv->ieee->fts;
8849 wrqu->frag.fixed = 0; /* no auto select */
0edd5b44 8850 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
c848d0af 8851 up(&priv->sem);
43f66a6c
JK		 8852 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8853
8854 return 0;
8855}
8856
bf79451e
JG		 8857static int ipw_wx_set_retry(struct net_device *dev,
8858 struct iw_request_info *info,
43f66a6c 8859 union iwreq_data *wrqu, char *extra)
bf79451e 8860{
afbf30a2
JK		 8861 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
8872 down(&priv->sem);
8873 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);
8884 up(&priv->sem);
8885 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8886 priv->short_retry_limit, priv->long_retry_limit);
8887 return 0;
43f66a6c
JK		 8888}
8889
bf79451e
JG		 8890static int ipw_wx_get_retry(struct net_device *dev,
8891 struct iw_request_info *info,
43f66a6c 8892 union iwreq_data *wrqu, char *extra)
bf79451e 8893{
afbf30a2
JK		 8894 struct ipw_priv *priv = ieee80211_priv(dev);
8895
8896 down(&priv->sem);
8897 wrqu->retry.disabled = 0;
8898
8899 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
8900 up(&priv->sem);
8901 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 }
8914 up(&priv->sem);
8915
8916 IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8917
8918 return 0;
8919}
8920
afbf30a2
JK		 8921static 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
efb3442c
PE		 8927 if (!(priv->status & STATUS_INIT) ||
8928 (priv->status & STATUS_EXIT_PENDING))
8929 return 0;
8930
afbf30a2
JK		 8931 down(&priv->sem);
8932
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)) {
8942 err = wait_event_interruptible(priv->wait_state,
8943 !(priv->
8944 status & (STATUS_SCANNING |
8945 STATUS_SCAN_ABORTING)));
8946 if (err) {
8947 IPW_DEBUG_HC("aborting direct scan");
8948 goto done;
8949 }
8950 }
8951 memset(&scan, 0, sizeof(scan));
8952
8953 if (priv->config & CFG_SPEED_SCAN)
8954 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8955 cpu_to_le16(30);
8956 else
8957 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8958 cpu_to_le16(20);
8959
8960 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8961 cpu_to_le16(20);
1fe0adb4 8962 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
afbf30a2
JK		 8963 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8964
8965 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8966
8967 err = ipw_send_ssid(priv, essid, essid_len);
8968 if (err) {
8969 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8970 goto done;
8971 }
8972 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8973
8974 ipw_add_scan_channels(priv, &scan, scan_type);
8975
8976 err = ipw_send_scan_request_ext(priv, &scan);
8977 if (err) {
8978 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8979 goto done;
8980 }
8981
8982 priv->status |= STATUS_SCANNING;
8983
8984 done:
8985 up(&priv->sem);
8986 return err;
43f66a6c
JK		 8987}
8988
bf79451e
JG		 8989static int ipw_wx_set_scan(struct net_device *dev,
8990 struct iw_request_info *info,
43f66a6c
JK		 8991 union iwreq_data *wrqu, char *extra)
8992{
8993 struct ipw_priv *priv = ieee80211_priv(dev);
afbf30a2
JK		 8994 struct iw_scan_req *req = NULL;
8995 if (wrqu->data.length
8996 && wrqu->data.length == sizeof(struct iw_scan_req)) {
8997 req = (struct iw_scan_req *)extra;
8998 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
8999 ipw_request_direct_scan(priv, req->essid,
9000 req->essid_len);
9001 return 0;
9002 }
9003 }
8935f39e 9004
43f66a6c 9005 IPW_DEBUG_WX("Start scan\n");
b095c381
JK		 9006
9007 queue_work(priv->workqueue, &priv->request_scan);
9008
43f66a6c
JK		 9009 return 0;
9010}
9011
bf79451e
JG		 9012static int ipw_wx_get_scan(struct net_device *dev,
9013 struct iw_request_info *info,
43f66a6c 9014 union iwreq_data *wrqu, char *extra)
bf79451e 9015{
43f66a6c
JK		 9016 struct ipw_priv *priv = ieee80211_priv(dev);
9017 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9018}
9019
bf79451e 9020static int ipw_wx_set_encode(struct net_device *dev,
0edd5b44
JG		 9021 struct iw_request_info *info,
9022 union iwreq_data *wrqu, char *key)
43f66a6c
JK		 9023{
9024 struct ipw_priv *priv = ieee80211_priv(dev);
afbf30a2 9025 int ret;
caeff81b 9026 u32 cap = priv->capability;
afbf30a2
JK		 9027
9028 down(&priv->sem);
9029 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
afbf30a2 9030
caeff81b
HL		 9031 /* In IBSS mode, we need to notify the firmware to update
9032 * the beacon info after we changed the capability. */
9033 if (cap != priv->capability &&
9034 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9035 priv->status & STATUS_ASSOCIATED)
9036 ipw_disassociate(priv);
9037
9038 up(&priv->sem);
afbf30a2 9039 return ret;
43f66a6c
JK		 9040}
9041
bf79451e 9042static int ipw_wx_get_encode(struct net_device *dev,
0edd5b44
JG		 9043 struct iw_request_info *info,
9044 union iwreq_data *wrqu, char *key)
43f66a6c
JK		 9045{
9046 struct ipw_priv *priv = ieee80211_priv(dev);
9047 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9048}
9049
bf79451e 9050static int ipw_wx_set_power(struct net_device *dev,
0edd5b44
JG		 9051 struct iw_request_info *info,
9052 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 9053{
9054 struct ipw_priv *priv = ieee80211_priv(dev);
9055 int err;
c848d0af 9056 down(&priv->sem);
43f66a6c
JK		 9057 if (wrqu->power.disabled) {
9058 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9059 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9060 if (err) {
9061 IPW_DEBUG_WX("failed setting power mode.\n");
c848d0af 9062 up(&priv->sem);
43f66a6c
JK		 9063 return err;
9064 }
43f66a6c 9065 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
c848d0af 9066 up(&priv->sem);
43f66a6c 9067 return 0;
bf79451e 9068 }
43f66a6c
JK		 9069
9070 switch (wrqu->power.flags & IW_POWER_MODE) {
0edd5b44
JG		 9071 case IW_POWER_ON: /* If not specified */
9072 case IW_POWER_MODE: /* If set all mask */
9073 case IW_POWER_ALL_R: /* If explicitely state all */
43f66a6c 9074 break;
0edd5b44 9075 default: /* Otherwise we don't support it */
43f66a6c
JK		 9076 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9077 wrqu->power.flags);
c848d0af 9078 up(&priv->sem);
bf79451e 9079 return -EOPNOTSUPP;
43f66a6c 9080 }
bf79451e 9081
43f66a6c
JK		 9082 /* If the user hasn't specified a power management mode yet, default
9083 * to BATTERY */
0edd5b44 9084 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
43f66a6c 9085 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
bf79451e 9086 else
43f66a6c
JK		 9087 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9088 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9089 if (err) {
9090 IPW_DEBUG_WX("failed setting power mode.\n");
c848d0af 9091 up(&priv->sem);
43f66a6c
JK		 9092 return err;
9093 }
9094
0edd5b44 9095 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
c848d0af 9096 up(&priv->sem);
43f66a6c
JK		 9097 return 0;
9098}
9099
bf79451e 9100static int ipw_wx_get_power(struct net_device *dev,
0edd5b44
JG		 9101 struct iw_request_info *info,
9102 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 9103{
9104 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 9105 down(&priv->sem);
a613bffd 9106 if (!(priv->power_mode & IPW_POWER_ENABLED))
43f66a6c 9107 wrqu->power.disabled = 1;
a613bffd 9108 else
43f66a6c 9109 wrqu->power.disabled = 0;
43f66a6c 9110
c848d0af 9111 up(&priv->sem);
43f66a6c 9112 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
bf79451e 9113
43f66a6c
JK		 9114 return 0;
9115}
9116
bf79451e 9117static int ipw_wx_set_powermode(struct net_device *dev,
0edd5b44
JG		 9118 struct iw_request_info *info,
9119 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 9120{
9121 struct ipw_priv *priv = ieee80211_priv(dev);
9122 int mode = *(int *)extra;
9123 int err;
c848d0af 9124 down(&priv->sem);
43f66a6c
JK		 9125 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9126 mode = IPW_POWER_AC;
9127 priv->power_mode = mode;
9128 } else {
9129 priv->power_mode = IPW_POWER_ENABLED | mode;
9130 }
bf79451e 9131
43f66a6c
JK		 9132 if (priv->power_mode != mode) {
9133 err = ipw_send_power_mode(priv, mode);
bf79451e 9134
43f66a6c
JK		 9135 if (err) {
9136 IPW_DEBUG_WX("failed setting power mode.\n");
c848d0af 9137 up(&priv->sem);
43f66a6c
JK		 9138 return err;
9139 }
9140 }
c848d0af 9141 up(&priv->sem);
43f66a6c
JK		 9142 return 0;
9143}
9144
9145#define MAX_WX_STRING 80
bf79451e 9146static int ipw_wx_get_powermode(struct net_device *dev,
0edd5b44
JG		 9147 struct iw_request_info *info,
9148 union iwreq_data *wrqu, char *extra)
43f66a6c
JK		 9149{
9150 struct ipw_priv *priv = ieee80211_priv(dev);
9151 int level = IPW_POWER_LEVEL(priv->power_mode);
9152 char *p = extra;
9153
9154 p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9155
9156 switch (level) {
9157 case IPW_POWER_AC:
9158 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9159 break;
9160 case IPW_POWER_BATTERY:
9161 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9162 break;
9163 default:
9164 p += snprintf(p, MAX_WX_STRING - (p - extra),
bf79451e 9165 "(Timeout %dms, Period %dms)",
43f66a6c
JK		 9166 timeout_duration[level - 1] / 1000,
9167 period_duration[level - 1] / 1000);
9168 }
9169
9170 if (!(priv->power_mode & IPW_POWER_ENABLED))
0edd5b44 9171 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
43f66a6c
JK		 9172
9173 wrqu->data.length = p - extra + 1;
9174
9175 return 0;
9176}
9177
9178static int ipw_wx_set_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9179 struct iw_request_info *info,
9180 union iwreq_data *wrqu, char *extra)
43f66a6c 9181{
0edd5b44 9182 struct ipw_priv *priv = ieee80211_priv(dev);
43f66a6c
JK		 9183 int mode = *(int *)extra;
9184 u8 band = 0, modulation = 0;
9185
9186 if (mode == 0 || mode & ~IEEE_MODE_MASK) {
0edd5b44 9187 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
43f66a6c
JK		 9188 return -EINVAL;
9189 }
c848d0af 9190 down(&priv->sem);
43f66a6c 9191 if (priv->adapter == IPW_2915ABG) {
a33a1982 9192 priv->ieee->abg_true = 1;
43f66a6c
JK		 9193 if (mode & IEEE_A) {
9194 band |= IEEE80211_52GHZ_BAND;
9195 modulation |= IEEE80211_OFDM_MODULATION;
9196 } else
a33a1982 9197 priv->ieee->abg_true = 0;
43f66a6c
JK		 9198 } else {
9199 if (mode & IEEE_A) {
9200 IPW_WARNING("Attempt to set 2200BG into "
9201 "802.11a mode\n");
c848d0af 9202 up(&priv->sem);
43f66a6c
JK		 9203 return -EINVAL;
9204 }
9205
a33a1982 9206 priv->ieee->abg_true = 0;
43f66a6c
JK		 9207 }
9208
9209 if (mode & IEEE_B) {
9210 band |= IEEE80211_24GHZ_BAND;
9211 modulation |= IEEE80211_CCK_MODULATION;
9212 } else
a33a1982 9213 priv->ieee->abg_true = 0;
bf79451e 9214
43f66a6c
JK		 9215 if (mode & IEEE_G) {
9216 band |= IEEE80211_24GHZ_BAND;
9217 modulation |= IEEE80211_OFDM_MODULATION;
9218 } else
a33a1982 9219 priv->ieee->abg_true = 0;
43f66a6c
JK		 9220
9221 priv->ieee->mode = mode;
9222 priv->ieee->freq_band = band;
9223 priv->ieee->modulation = modulation;
0edd5b44 9224 init_supported_rates(priv, &priv->rates);
43f66a6c 9225
c848d0af
JK		 9226 /* Network configuration changed -- force [re]association */
9227 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9228 if (!ipw_disassociate(priv)) {
43f66a6c 9229 ipw_send_supported_rates(priv, &priv->rates);
c848d0af
JK		 9230 ipw_associate(priv);
9231 }
43f66a6c 9232
a613bffd
JK		 9233 /* Update the band LEDs */
9234 ipw_led_band_on(priv);
43f66a6c 9235
bf79451e 9236 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
43f66a6c 9237 mode & IEEE_A ? 'a' : '.',
0edd5b44 9238 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
c848d0af 9239 up(&priv->sem);
43f66a6c
JK		 9240 return 0;
9241}
9242
9243static int ipw_wx_get_wireless_mode(struct net_device *dev,
0edd5b44
JG		 9244 struct iw_request_info *info,
9245 union iwreq_data *wrqu, char *extra)
43f66a6c 9246{
0edd5b44 9247 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 9248 down(&priv->sem);
ea2b26e0
JK		 9249 switch (priv->ieee->mode) {
9250 case IEEE_A:
43f66a6c
JK		 9251 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9252 break;
ea2b26e0
JK		 9253 case IEEE_B:
9254 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9255 break;
9256 case IEEE_A | IEEE_B:
9257 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9258 break;
9259 case IEEE_G:
9260 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9261 break;
9262 case IEEE_A | IEEE_G:
9263 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9264 break;
9265 case IEEE_B | IEEE_G:
9266 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9267 break;
9268 case IEEE_A | IEEE_B | IEEE_G:
9269 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9270 break;
9271 default:
9272 strncpy(extra, "unknown", MAX_WX_STRING);
43f66a6c 9273 break;
bf79451e
JG		 9274 }
9275
43f66a6c
JK		 9276 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9277
0edd5b44 9278 wrqu->data.length = strlen(extra) + 1;
b095c381
JK		 9279 up(&priv->sem);
9280
9281 return 0;
9282}
9283
9284static int ipw_wx_set_preamble(struct net_device *dev,
9285 struct iw_request_info *info,
9286 union iwreq_data *wrqu, char *extra)
9287{
9288 struct ipw_priv *priv = ieee80211_priv(dev);
9289 int mode = *(int *)extra;
9290 down(&priv->sem);
9291 /* Switching from SHORT -> LONG requires a disassociation */
9292 if (mode == 1) {
9293 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9294 priv->config |= CFG_PREAMBLE_LONG;
9295
9296 /* Network configuration changed -- force [re]association */
9297 IPW_DEBUG_ASSOC
9298 ("[re]association triggered due to preamble change.\n");
9299 if (!ipw_disassociate(priv))
9300 ipw_associate(priv);
9301 }
9302 goto done;
9303 }
43f66a6c 9304
b095c381
JK		 9305 if (mode == 0) {
9306 priv->config &= ~CFG_PREAMBLE_LONG;
9307 goto done;
9308 }
9309 up(&priv->sem);
9310 return -EINVAL;
9311
9312 done:
9313 up(&priv->sem);
9314 return 0;
9315}
9316
9317static int ipw_wx_get_preamble(struct net_device *dev,
9318 struct iw_request_info *info,
9319 union iwreq_data *wrqu, char *extra)
9320{
9321 struct ipw_priv *priv = ieee80211_priv(dev);
9322 down(&priv->sem);
9323 if (priv->config & CFG_PREAMBLE_LONG)
9324 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9325 else
9326 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9327 up(&priv->sem);
0edd5b44 9328 return 0;
43f66a6c
JK		 9329}
9330
b095c381
JK		 9331#ifdef CONFIG_IPW2200_MONITOR
9332static int ipw_wx_set_monitor(struct net_device *dev,
bf79451e 9333 struct iw_request_info *info,
43f66a6c 9334 union iwreq_data *wrqu, char *extra)
bf79451e 9335{
43f66a6c
JK		 9336 struct ipw_priv *priv = ieee80211_priv(dev);
9337 int *parms = (int *)extra;
9338 int enable = (parms[0] > 0);
b095c381
JK		 9339 down(&priv->sem);
9340 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
43f66a6c
JK		 9341 if (enable) {
9342 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
24a47dbd
MK		 9343#ifdef CONFIG_IEEE80211_RADIOTAP
9344 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9345#else
43f66a6c 9346 priv->net_dev->type = ARPHRD_IEEE80211;
24a47dbd 9347#endif
b095c381 9348 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c 9349 }
bf79451e 9350
43f66a6c
JK		 9351 ipw_set_channel(priv, parms[1]);
9352 } else {
b095c381
JK		 9353 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9354 up(&priv->sem);
43f66a6c 9355 return 0;
b095c381 9356 }
43f66a6c 9357 priv->net_dev->type = ARPHRD_ETHER;
b095c381 9358 queue_work(priv->workqueue, &priv->adapter_restart);
43f66a6c 9359 }
b095c381 9360 up(&priv->sem);
43f66a6c
JK		 9361 return 0;
9362}
9363
b095c381
JK		 9364#endif // CONFIG_IPW2200_MONITOR
9365
bf79451e
JG		 9366static int ipw_wx_reset(struct net_device *dev,
9367 struct iw_request_info *info,
43f66a6c 9368 union iwreq_data *wrqu, char *extra)
bf79451e 9369{
43f66a6c
JK		 9370 struct ipw_priv *priv = ieee80211_priv(dev);
9371 IPW_DEBUG_WX("RESET\n");
b095c381
JK		 9372 queue_work(priv->workqueue, &priv->adapter_restart);
9373 return 0;
9374}
9375
b095c381
JK		 9376static int ipw_wx_sw_reset(struct net_device *dev,
9377 struct iw_request_info *info,
9378 union iwreq_data *wrqu, char *extra)
ea2b26e0
JK		 9379{
9380 struct ipw_priv *priv = ieee80211_priv(dev);
b095c381
JK		 9381 union iwreq_data wrqu_sec = {
9382 .encoding = {
9383 .flags = IW_ENCODE_DISABLED,
9384 },
9385 };
afbf30a2 9386 int ret;
c848d0af 9387
b095c381 9388 IPW_DEBUG_WX("SW_RESET\n");
ea2b26e0 9389
b095c381 9390 down(&priv->sem);
ea2b26e0 9391
afbf30a2
JK		 9392 ret = ipw_sw_reset(priv, 0);
9393 if (!ret) {
9394 free_firmware();
9395 ipw_adapter_restart(priv);
9396 }
ea2b26e0 9397
b095c381
JK		 9398 /* The SW reset bit might have been toggled on by the 'disable'
9399 * module parameter, so take appropriate action */
9400 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
ea2b26e0 9401
b095c381
JK		 9402 up(&priv->sem);
9403 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
c848d0af 9404 down(&priv->sem);
bf79451e 9405
b095c381
JK		 9406 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9407 /* Configuration likely changed -- force [re]association */
9408 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9409 "reset.\n");
9410 if (!ipw_disassociate(priv))
9411 ipw_associate(priv);
43f66a6c 9412 }
b095c381 9413
c848d0af 9414 up(&priv->sem);
43f66a6c 9415
43f66a6c
JK		 9416 return 0;
9417}
43f66a6c
JK		 9418
9419/* Rebase the WE IOCTLs to zero for the handler array */
9420#define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
0edd5b44 9421static iw_handler ipw_wx_handlers[] = {
ea2b26e0
JK		 9422 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9423 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9424 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9425 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9426 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9427 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9428 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9429 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9430 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9431 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9432 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9433 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9434 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9435 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9436 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9437 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9438 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9439 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9440 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9441 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9442 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9443 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9444 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9445 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9446 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9447 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9448 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9449 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
a613bffd
JK		 9450 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9451 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9452 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9453 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
afbf30a2
JK		 9454 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9455 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9456 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9457 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9458 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9459 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9460 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
43f66a6c
JK		 9461};
9462
b095c381
JK		 9463enum {
9464 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9465 IPW_PRIV_GET_POWER,
9466 IPW_PRIV_SET_MODE,
9467 IPW_PRIV_GET_MODE,
9468 IPW_PRIV_SET_PREAMBLE,
9469 IPW_PRIV_GET_PREAMBLE,
9470 IPW_PRIV_RESET,
9471 IPW_PRIV_SW_RESET,
9472#ifdef CONFIG_IPW2200_MONITOR
9473 IPW_PRIV_SET_MONITOR,
9474#endif
9475};
43f66a6c 9476
bf79451e 9477static struct iw_priv_args ipw_priv_args[] = {
43f66a6c 9478 {
0edd5b44
JG		 9479 .cmd = IPW_PRIV_SET_POWER,
9480 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9481 .name = "set_power"},
43f66a6c 9482 {
0edd5b44
JG		 9483 .cmd = IPW_PRIV_GET_POWER,
9484 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9485 .name = "get_power"},
43f66a6c 9486 {
0edd5b44
JG		 9487 .cmd = IPW_PRIV_SET_MODE,
9488 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9489 .name = "set_mode"},
43f66a6c 9490 {
0edd5b44
JG		 9491 .cmd = IPW_PRIV_GET_MODE,
9492 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9493 .name = "get_mode"},
43f66a6c 9494 {
ea2b26e0
JK		 9495 .cmd = IPW_PRIV_SET_PREAMBLE,
9496 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9497 .name = "set_preamble"},
9498 {
9499 .cmd = IPW_PRIV_GET_PREAMBLE,
9500 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9501 .name = "get_preamble"},
43f66a6c 9502 {
0edd5b44
JG		 9503 IPW_PRIV_RESET,
9504 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
b095c381
JK		 9505 {
9506 IPW_PRIV_SW_RESET,
9507 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9508#ifdef CONFIG_IPW2200_MONITOR
9509 {
9510 IPW_PRIV_SET_MONITOR,
9511 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9512#endif /* CONFIG_IPW2200_MONITOR */
43f66a6c
JK		 9513};
9514
9515static iw_handler ipw_priv_handler[] = {
9516 ipw_wx_set_powermode,
9517 ipw_wx_get_powermode,
9518 ipw_wx_set_wireless_mode,
9519 ipw_wx_get_wireless_mode,
ea2b26e0
JK		 9520 ipw_wx_set_preamble,
9521 ipw_wx_get_preamble,
bf79451e 9522 ipw_wx_reset,
b095c381
JK		 9523 ipw_wx_sw_reset,
9524#ifdef CONFIG_IPW2200_MONITOR
9525 ipw_wx_set_monitor,
43f66a6c
JK		 9526#endif
9527};
9528
0edd5b44 9529static struct iw_handler_def ipw_wx_handler_def = {
ea2b26e0
JK		 9530 .standard = ipw_wx_handlers,
9531 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9532 .num_private = ARRAY_SIZE(ipw_priv_handler),
9533 .num_private_args = ARRAY_SIZE(ipw_priv_args),
9534 .private = ipw_priv_handler,
9535 .private_args = ipw_priv_args,
97a78ca9 9536 .get_wireless_stats = ipw_get_wireless_stats,
43f66a6c
JK		 9537};
9538
43f66a6c
JK		 9539/*
9540 * Get wireless statistics.
9541 * Called by /proc/net/wireless
9542 * Also called by SIOCGIWSTATS
9543 */
0edd5b44 9544static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
43f66a6c
JK		 9545{
9546 struct ipw_priv *priv = ieee80211_priv(dev);
9547 struct iw_statistics *wstats;
bf79451e 9548
43f66a6c
JK		 9549 wstats = &priv->wstats;
9550
ea2b26e0 9551 /* if hw is disabled, then ipw_get_ordinal() can't be called.
afbf30a2 9552 * netdev->get_wireless_stats seems to be called before fw is
43f66a6c
JK		 9553 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
9554 * and associated; if not associcated, the values are all meaningless
9555 * anyway, so set them all to NULL and INVALID */
9556 if (!(priv->status & STATUS_ASSOCIATED)) {
9557 wstats->miss.beacon = 0;
9558 wstats->discard.retries = 0;
9559 wstats->qual.qual = 0;
9560 wstats->qual.level = 0;
9561 wstats->qual.noise = 0;
9562 wstats->qual.updated = 7;
9563 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
0edd5b44 9564 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
43f66a6c 9565 return wstats;
bf79451e 9566 }
43f66a6c
JK		 9567
9568 wstats->qual.qual = priv->quality;
9569 wstats->qual.level = average_value(&priv->average_rssi);
9570 wstats->qual.noise = average_value(&priv->average_noise);
9571 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
0edd5b44 9572 IW_QUAL_NOISE_UPDATED;
43f66a6c
JK		 9573
9574 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9575 wstats->discard.retries = priv->last_tx_failures;
9576 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
bf79451e 9577
43f66a6c
JK		 9578/* if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9579 goto fail_get_ordinal;
9580 wstats->discard.retries += tx_retry; */
bf79451e 9581
43f66a6c
JK		 9582 return wstats;
9583}
9584
43f66a6c
JK		 9585/* net device stuff */
9586
9587static inline void init_sys_config(struct ipw_sys_config *sys_config)
9588{
0edd5b44
JG		 9589 memset(sys_config, 0, sizeof(struct ipw_sys_config));
9590 sys_config->bt_coexistence = 1; /* We may need to look into prvStaBtConfig */
43f66a6c
JK		 9591 sys_config->answer_broadcast_ssid_probe = 0;
9592 sys_config->accept_all_data_frames = 0;
9593 sys_config->accept_non_directed_frames = 1;
9594 sys_config->exclude_unicast_unencrypted = 0;
9595 sys_config->disable_unicast_decryption = 1;
9596 sys_config->exclude_multicast_unencrypted = 0;
9597 sys_config->disable_multicast_decryption = 1;
9598 sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
0edd5b44 9599 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
43f66a6c 9600 sys_config->dot11g_auto_detection = 0;
bf79451e 9601 sys_config->enable_cts_to_self = 0;
43f66a6c 9602 sys_config->bt_coexist_collision_thr = 0;
c848d0af 9603 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
43f66a6c
JK		 9604}
9605
9606static int ipw_net_open(struct net_device *dev)
9607{
9608 struct ipw_priv *priv = ieee80211_priv(dev);
9609 IPW_DEBUG_INFO("dev->open\n");
9610 /* we should be verifying the device is ready to be opened */
c848d0af 9611 down(&priv->sem);
bf79451e
JG		 9612 if (!(priv->status & STATUS_RF_KILL_MASK) &&
9613 (priv->status & STATUS_ASSOCIATED))
43f66a6c 9614 netif_start_queue(dev);
c848d0af 9615 up(&priv->sem);
43f66a6c
JK		 9616 return 0;
9617}
9618
9619static int ipw_net_stop(struct net_device *dev)
9620{
9621 IPW_DEBUG_INFO("dev->close\n");
9622 netif_stop_queue(dev);
9623 return 0;
9624}
9625
9626/*
9627todo:
9628
9629modify to send one tfd per fragment instead of using chunking. otherwise
9630we need to heavily modify the ieee80211_skb_to_txb.
9631*/
9632
227d2dc1
JK		 9633static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9634 int pri)
43f66a6c 9635{
0dacca1f 9636 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
0edd5b44 9637 txb->fragments[0]->data;
43f66a6c
JK		 9638 int i = 0;
9639 struct tfd_frame *tfd;
b095c381
JK		 9640#ifdef CONFIG_IPW_QOS
9641 int tx_id = ipw_get_tx_queue_number(priv, pri);
9642 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9643#else
43f66a6c 9644 struct clx2_tx_queue *txq = &priv->txq[0];
b095c381 9645#endif
43f66a6c
JK		 9646 struct clx2_queue *q = &txq->q;
9647 u8 id, hdr_len, unicast;
9648 u16 remaining_bytes;
c848d0af 9649 int fc;
43f66a6c 9650
227d2dc1
JK		 9651 /* If there isn't room in the queue, we return busy and let the
9652 * network stack requeue the packet for us */
9653 if (ipw_queue_space(q) < q->high_mark)
9654 return NETDEV_TX_BUSY;
43f66a6c
JK		 9655
9656 switch (priv->ieee->iw_mode) {
9657 case IW_MODE_ADHOC:
9658 hdr_len = IEEE80211_3ADDR_LEN;
9d5b880b
HL		 9659 unicast = !(is_multicast_ether_addr(hdr->addr1) ||
9660 is_broadcast_ether_addr(hdr->addr1));
43f66a6c
JK		 9661 id = ipw_find_station(priv, hdr->addr1);
9662 if (id == IPW_INVALID_STATION) {
9663 id = ipw_add_station(priv, hdr->addr1);
9664 if (id == IPW_INVALID_STATION) {
9665 IPW_WARNING("Attempt to send data to "
bf79451e 9666 "invalid cell: " MAC_FMT "\n",
43f66a6c
JK		 9667 MAC_ARG(hdr->addr1));
9668 goto drop;
9669 }
9670 }
9671 break;
9672
9673 case IW_MODE_INFRA:
9674 default:
9d5b880b
HL		 9675 unicast = !(is_multicast_ether_addr(hdr->addr3) ||
9676 is_broadcast_ether_addr(hdr->addr3));
43f66a6c
JK		 9677 hdr_len = IEEE80211_3ADDR_LEN;
9678 id = 0;
9679 break;
9680 }
9681
9682 tfd = &txq->bd[q->first_empty];
9683 txq->txb[q->first_empty] = txb;
9684 memset(tfd, 0, sizeof(*tfd));
9685 tfd->u.data.station_number = id;
9686
9687 tfd->control_flags.message_type = TX_FRAME_TYPE;
9688 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9689
9690 tfd->u.data.cmd_id = DINO_CMD_TX;
a613bffd 9691 tfd->u.data.len = cpu_to_le16(txb->payload_size);
43f66a6c 9692 remaining_bytes = txb->payload_size;
bf79451e 9693
43f66a6c 9694 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
b095c381 9695 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
43f66a6c 9696 else
b095c381 9697 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
43f66a6c 9698
ea2b26e0
JK		 9699 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9700 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
43f66a6c 9701
c848d0af
JK		 9702 fc = le16_to_cpu(hdr->frame_ctl);
9703 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
43f66a6c
JK		 9704
9705 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9706
b095c381
JK		 9707 if (likely(unicast))
9708 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9709
9710 if (txb->encrypted && !priv->ieee->host_encrypt) {
9711 switch (priv->ieee->sec.level) {
9712 case SEC_LEVEL_3:
9713 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9714 IEEE80211_FCTL_PROTECTED;
9715 /* XXX: ACK flag must be set for CCMP even if it
9716 * is a multicast/broadcast packet, because CCMP
9717 * group communication encrypted by GTK is
9718 * actually done by the AP. */
9719 if (!unicast)
9720 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9721
9722 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9723 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9724 tfd->u.data.key_index = 0;
9725 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9726 break;
9727 case SEC_LEVEL_2:
9728 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9729 IEEE80211_FCTL_PROTECTED;
9730 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9731 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9732 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9733 break;
9734 case SEC_LEVEL_1:
9735 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9736 IEEE80211_FCTL_PROTECTED;
9737 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9738 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9739 40)
9740 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9741 else
9742 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9743 break;
9744 case SEC_LEVEL_0:
9745 break;
9746 default:
9747 printk(KERN_ERR "Unknow security level %d\n",
9748 priv->ieee->sec.level);
9749 break;
9750 }
9751 } else
9752 /* No hardware encryption */
9753 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9754
9755#ifdef CONFIG_IPW_QOS
9756 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9757#endif /* CONFIG_IPW_QOS */
9758
43f66a6c 9759 /* payload */
a613bffd
JK		 9760 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9761 txb->nr_frags));
9762 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9763 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9764 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9765 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9766 i, le32_to_cpu(tfd->u.data.num_chunks),
9767 txb->fragments[i]->len - hdr_len);
bf79451e 9768 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
43f66a6c
JK		 9769 i, tfd->u.data.num_chunks,
9770 txb->fragments[i]->len - hdr_len);
bf79451e 9771 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
43f66a6c
JK		 9772 txb->fragments[i]->len - hdr_len);
9773
0edd5b44 9774 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 9775 cpu_to_le32(pci_map_single
9776 (priv->pci_dev,
9777 txb->fragments[i]->data + hdr_len,
9778 txb->fragments[i]->len - hdr_len,
9779 PCI_DMA_TODEVICE));
9780 tfd->u.data.chunk_len[i] =
9781 cpu_to_le16(txb->fragments[i]->len - hdr_len);
43f66a6c
JK		 9782 }
9783
9784 if (i != txb->nr_frags) {
9785 struct sk_buff *skb;
9786 u16 remaining_bytes = 0;
9787 int j;
9788
9789 for (j = i; j < txb->nr_frags; j++)
9790 remaining_bytes += txb->fragments[j]->len - hdr_len;
9791
9792 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9793 remaining_bytes);
9794 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9795 if (skb != NULL) {
a613bffd 9796 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
43f66a6c
JK		 9797 for (j = i; j < txb->nr_frags; j++) {
9798 int size = txb->fragments[j]->len - hdr_len;
afbf30a2 9799
43f66a6c 9800 printk(KERN_INFO "Adding frag %d %d...\n",
0edd5b44 9801 j, size);
43f66a6c 9802 memcpy(skb_put(skb, size),
0edd5b44 9803 txb->fragments[j]->data + hdr_len, size);
43f66a6c
JK		 9804 }
9805 dev_kfree_skb_any(txb->fragments[i]);
9806 txb->fragments[i] = skb;
0edd5b44 9807 tfd->u.data.chunk_ptr[i] =
a613bffd
JK		 9808 cpu_to_le32(pci_map_single
9809 (priv->pci_dev, skb->data,
9810 tfd->u.data.chunk_len[i],
9811 PCI_DMA_TODEVICE));
9812
9813 tfd->u.data.num_chunks =
9814 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9815 1);
bf79451e 9816 }
43f66a6c
JK		 9817 }
9818
9819 /* kick DMA */
9820 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9821 ipw_write32(priv, q->reg_w, q->first_empty);
9822
227d2dc1 9823 return NETDEV_TX_OK;
43f66a6c 9824
0edd5b44 9825 drop:
43f66a6c
JK		 9826 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9827 ieee80211_txb_free(txb);
227d2dc1
JK		 9828 return NETDEV_TX_OK;
9829}
9830
9831static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9832{
9833 struct ipw_priv *priv = ieee80211_priv(dev);
9834#ifdef CONFIG_IPW_QOS
9835 int tx_id = ipw_get_tx_queue_number(priv, pri);
9836 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9837#else
9838 struct clx2_tx_queue *txq = &priv->txq[0];
9839#endif /* CONFIG_IPW_QOS */
9840
9841 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9842 return 1;
9843
9844 return 0;
43f66a6c
JK		 9845}
9846
9847static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
c8d42d1a 9848 struct net_device *dev, int pri)
43f66a6c
JK		 9849{
9850 struct ipw_priv *priv = ieee80211_priv(dev);
9851 unsigned long flags;
227d2dc1 9852 int ret;
43f66a6c
JK		 9853
9854 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
43f66a6c
JK		 9855 spin_lock_irqsave(&priv->lock, flags);
9856
9857 if (!(priv->status & STATUS_ASSOCIATED)) {
9858 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9859 priv->ieee->stats.tx_carrier_errors++;
9860 netif_stop_queue(dev);
9861 goto fail_unlock;
9862 }
9863
227d2dc1
JK		 9864 ret = ipw_tx_skb(priv, txb, pri);
9865 if (ret == NETDEV_TX_OK)
9866 __ipw_led_activity_on(priv);
43f66a6c 9867 spin_unlock_irqrestore(&priv->lock, flags);
43f66a6c 9868
227d2dc1 9869 return ret;
43f66a6c 9870
0edd5b44 9871 fail_unlock:
43f66a6c
JK		 9872 spin_unlock_irqrestore(&priv->lock, flags);
9873 return 1;
9874}
9875
9876static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9877{
9878 struct ipw_priv *priv = ieee80211_priv(dev);
bf79451e 9879
43f66a6c
JK		 9880 priv->ieee->stats.tx_packets = priv->tx_packets;
9881 priv->ieee->stats.rx_packets = priv->rx_packets;
9882 return &priv->ieee->stats;
9883}
9884
9885static void ipw_net_set_multicast_list(struct net_device *dev)
9886{
9887
9888}
9889
9890static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9891{
9892 struct ipw_priv *priv = ieee80211_priv(dev);
9893 struct sockaddr *addr = p;
9894 if (!is_valid_ether_addr(addr->sa_data))
9895 return -EADDRNOTAVAIL;
c848d0af 9896 down(&priv->sem);
43f66a6c
JK		 9897 priv->config |= CFG_CUSTOM_MAC;
9898 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9899 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9900 priv->net_dev->name, MAC_ARG(priv->mac_addr));
a613bffd 9901 queue_work(priv->workqueue, &priv->adapter_restart);
c848d0af 9902 up(&priv->sem);
43f66a6c
JK		 9903 return 0;
9904}
9905
bf79451e 9906static void ipw_ethtool_get_drvinfo(struct net_device *dev,
43f66a6c
JK		 9907 struct ethtool_drvinfo *info)
9908{
9909 struct ipw_priv *p = ieee80211_priv(dev);
9910 char vers[64];
9911 char date[32];
9912 u32 len;
9913
9914 strcpy(info->driver, DRV_NAME);
9915 strcpy(info->version, DRV_VERSION);
9916
9917 len = sizeof(vers);
9918 ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9919 len = sizeof(date);
9920 ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9921
0edd5b44 9922 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
43f66a6c
JK		 9923 vers, date);
9924 strcpy(info->bus_info, pci_name(p->pci_dev));
b095c381 9925 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 9926}
9927
9928static u32 ipw_ethtool_get_link(struct net_device *dev)
9929{
9930 struct ipw_priv *priv = ieee80211_priv(dev);
9931 return (priv->status & STATUS_ASSOCIATED) != 0;
9932}
9933
9934static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9935{
b095c381 9936 return IPW_EEPROM_IMAGE_SIZE;
43f66a6c
JK		 9937}
9938
9939static int ipw_ethtool_get_eeprom(struct net_device *dev,
0edd5b44 9940 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c
JK		 9941{
9942 struct ipw_priv *p = ieee80211_priv(dev);
9943
b095c381 9944 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 9945 return -EINVAL;
c848d0af 9946 down(&p->sem);
afbf30a2 9947 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
c848d0af 9948 up(&p->sem);
43f66a6c
JK		 9949 return 0;
9950}
9951
9952static int ipw_ethtool_set_eeprom(struct net_device *dev,
0edd5b44 9953 struct ethtool_eeprom *eeprom, u8 * bytes)
43f66a6c
JK		 9954{
9955 struct ipw_priv *p = ieee80211_priv(dev);
9956 int i;
9957
b095c381 9958 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
43f66a6c 9959 return -EINVAL;
c848d0af 9960 down(&p->sem);
afbf30a2 9961 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
bf79451e 9962 for (i = IPW_EEPROM_DATA;
b095c381 9963 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
43f66a6c 9964 ipw_write8(p, i, p->eeprom[i]);
c848d0af 9965 up(&p->sem);
43f66a6c
JK		 9966 return 0;
9967}
9968
9969static struct ethtool_ops ipw_ethtool_ops = {
ea2b26e0
JK		 9970 .get_link = ipw_ethtool_get_link,
9971 .get_drvinfo = ipw_ethtool_get_drvinfo,
9972 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9973 .get_eeprom = ipw_ethtool_get_eeprom,
9974 .set_eeprom = ipw_ethtool_set_eeprom,
43f66a6c
JK		 9975};
9976
9977static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9978{
9979 struct ipw_priv *priv = data;
9980 u32 inta, inta_mask;
bf79451e 9981
43f66a6c
JK		 9982 if (!priv)
9983 return IRQ_NONE;
9984
9985 spin_lock(&priv->lock);
9986
9987 if (!(priv->status & STATUS_INT_ENABLED)) {
9988 /* Shared IRQ */
9989 goto none;
9990 }
9991
b095c381
JK		 9992 inta = ipw_read32(priv, IPW_INTA_RW);
9993 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
bf79451e 9994
43f66a6c
JK		 9995 if (inta == 0xFFFFFFFF) {
9996 /* Hardware disappeared */
9997 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
9998 goto none;
9999 }
10000
b095c381 10001 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
43f66a6c
JK		 10002 /* Shared interrupt */
10003 goto none;
10004 }
10005
10006 /* tell the device to stop sending interrupts */
10007 ipw_disable_interrupts(priv);
bf79451e 10008
43f66a6c 10009 /* ack current interrupts */
b095c381
JK		 10010 inta &= (IPW_INTA_MASK_ALL & inta_mask);
10011 ipw_write32(priv, IPW_INTA_RW, inta);
bf79451e 10012
43f66a6c
JK		 10013 /* Cache INTA value for our tasklet */
10014 priv->isr_inta = inta;
10015
10016 tasklet_schedule(&priv->irq_tasklet);
10017
0edd5b44 10018 spin_unlock(&priv->lock);
43f66a6c
JK		 10019
10020 return IRQ_HANDLED;
0edd5b44 10021 none:
43f66a6c
JK		 10022 spin_unlock(&priv->lock);
10023 return IRQ_NONE;
10024}
10025
10026static void ipw_rf_kill(void *adapter)
10027{
10028 struct ipw_priv *priv = adapter;
10029 unsigned long flags;
bf79451e 10030
43f66a6c
JK		 10031 spin_lock_irqsave(&priv->lock, flags);
10032
10033 if (rf_kill_active(priv)) {
10034 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10035 if (priv->workqueue)
10036 queue_delayed_work(priv->workqueue,
10037 &priv->rf_kill, 2 * HZ);
10038 goto exit_unlock;
10039 }
10040
10041 /* RF Kill is now disabled, so bring the device back up */
10042
10043 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10044 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10045 "device\n");
10046
10047 /* we can not do an adapter restart while inside an irq lock */
10048 queue_work(priv->workqueue, &priv->adapter_restart);
bf79451e 10049 } else
43f66a6c
JK		 10050 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
10051 "enabled\n");
10052
0edd5b44 10053 exit_unlock:
43f66a6c
JK		 10054 spin_unlock_irqrestore(&priv->lock, flags);
10055}
10056
c848d0af
JK		 10057static void ipw_bg_rf_kill(void *data)
10058{
10059 struct ipw_priv *priv = data;
10060 down(&priv->sem);
10061 ipw_rf_kill(data);
10062 up(&priv->sem);
10063}
10064
a613bffd
JK		 10065void ipw_link_up(struct ipw_priv *priv)
10066{
afbf30a2
JK		 10067 priv->last_seq_num = -1;
10068 priv->last_frag_num = -1;
10069 priv->last_packet_time = 0;
10070
a613bffd
JK		 10071 netif_carrier_on(priv->net_dev);
10072 if (netif_queue_stopped(priv->net_dev)) {
10073 IPW_DEBUG_NOTIF("waking queue\n");
10074 netif_wake_queue(priv->net_dev);
10075 } else {
10076 IPW_DEBUG_NOTIF("starting queue\n");
10077 netif_start_queue(priv->net_dev);
10078 }
10079
c848d0af 10080 cancel_delayed_work(&priv->request_scan);
a613bffd
JK		 10081 ipw_reset_stats(priv);
10082 /* Ensure the rate is updated immediately */
10083 priv->last_rate = ipw_get_current_rate(priv);
10084 ipw_gather_stats(priv);
10085 ipw_led_link_up(priv);
10086 notify_wx_assoc_event(priv);
10087
10088 if (priv->config & CFG_BACKGROUND_SCAN)
10089 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10090}
10091
c848d0af
JK		 10092static void ipw_bg_link_up(void *data)
10093{
10094 struct ipw_priv *priv = data;
10095 down(&priv->sem);
10096 ipw_link_up(data);
10097 up(&priv->sem);
10098}
10099
a613bffd
JK		 10100void ipw_link_down(struct ipw_priv *priv)
10101{
10102 ipw_led_link_down(priv);
10103 netif_carrier_off(priv->net_dev);
10104 netif_stop_queue(priv->net_dev);
10105 notify_wx_assoc_event(priv);
10106
10107 /* Cancel any queued work ... */
10108 cancel_delayed_work(&priv->request_scan);
10109 cancel_delayed_work(&priv->adhoc_check);
10110 cancel_delayed_work(&priv->gather_stats);
10111
10112 ipw_reset_stats(priv);
10113
afbf30a2
JK		 10114 if (!(priv->status & STATUS_EXIT_PENDING)) {
10115 /* Queue up another scan... */
10116 queue_work(priv->workqueue, &priv->request_scan);
10117 }
a613bffd
JK		 10118}
10119
c848d0af
JK		 10120static void ipw_bg_link_down(void *data)
10121{
10122 struct ipw_priv *priv = data;
10123 down(&priv->sem);
10124 ipw_link_down(data);
10125 up(&priv->sem);
43f66a6c
JK		 10126}
10127
10128static int ipw_setup_deferred_work(struct ipw_priv *priv)
10129{
10130 int ret = 0;
10131
43f66a6c 10132 priv->workqueue = create_workqueue(DRV_NAME);
43f66a6c 10133 init_waitqueue_head(&priv->wait_command_queue);
afbf30a2 10134 init_waitqueue_head(&priv->wait_state);
43f66a6c 10135
c848d0af
JK		 10136 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10137 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10138 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
d8bad6df 10139 INIT_WORK(&priv->system_config, ipw_system_config, priv);
c848d0af
JK		 10140 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10141 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10142 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10143 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10144 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
bf79451e 10145 INIT_WORK(&priv->request_scan,
43f66a6c 10146 (void (*)(void *))ipw_request_scan, priv);
bf79451e 10147 INIT_WORK(&priv->gather_stats,
c848d0af
JK		 10148 (void (*)(void *))ipw_bg_gather_stats, priv);
10149 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10150 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10151 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10152 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10153 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10154 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10155 priv);
10156 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
a613bffd 10157 priv);
c848d0af 10158 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
a613bffd 10159 priv);
c848d0af
JK		 10160 INIT_WORK(&priv->merge_networks,
10161 (void (*)(void *))ipw_merge_adhoc_network, priv);
43f66a6c 10162
b095c381
JK		 10163#ifdef CONFIG_IPW_QOS
10164 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10165 priv);
10166#endif /* CONFIG_IPW_QOS */
43f66a6c
JK		 10167
10168 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10169 ipw_irq_tasklet, (unsigned long)priv);
10170
10171 return ret;
10172}
10173
43f66a6c
JK		 10174static void shim__set_security(struct net_device *dev,
10175 struct ieee80211_security *sec)
10176{
10177 struct ipw_priv *priv = ieee80211_priv(dev);
10178 int i;
bf79451e 10179 for (i = 0; i < 4; i++) {
43f66a6c 10180 if (sec->flags & (1 << i)) {
afbf30a2 10181 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
b095c381 10182 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
43f66a6c 10183 if (sec->key_sizes[i] == 0)
b095c381
JK		 10184 priv->ieee->sec.flags &= ~(1 << i);
10185 else {
10186 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
43f66a6c 10187 sec->key_sizes[i]);
b095c381
JK		 10188 priv->ieee->sec.flags |= (1 << i);
10189 }
43f66a6c 10190 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10191 } else if (sec->level != SEC_LEVEL_1)
10192 priv->ieee->sec.flags &= ~(1 << i);
43f66a6c
JK		 10193 }
10194
b095c381 10195 if (sec->flags & SEC_ACTIVE_KEY) {
43f66a6c 10196 if (sec->active_key <= 3) {
b095c381
JK		 10197 priv->ieee->sec.active_key = sec->active_key;
10198 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
bf79451e 10199 } else
b095c381 10200 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c 10201 priv->status |= STATUS_SECURITY_UPDATED;
b095c381
JK		 10202 } else
10203 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
43f66a6c
JK		 10204
10205 if ((sec->flags & SEC_AUTH_MODE) &&
b095c381
JK		 10206 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10207 priv->ieee->sec.auth_mode = sec->auth_mode;
10208 priv->ieee->sec.flags |= SEC_AUTH_MODE;
43f66a6c
JK		 10209 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10210 priv->capability |= CAP_SHARED_KEY;
10211 else
10212 priv->capability &= ~CAP_SHARED_KEY;
10213 priv->status |= STATUS_SECURITY_UPDATED;
10214 }
bf79451e 10215
b095c381
JK		 10216 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10217 priv->ieee->sec.flags |= SEC_ENABLED;
10218 priv->ieee->sec.enabled = sec->enabled;
43f66a6c 10219 priv->status |= STATUS_SECURITY_UPDATED;
bf79451e 10220 if (sec->enabled)
43f66a6c
JK		 10221 priv->capability |= CAP_PRIVACY_ON;
10222 else
10223 priv->capability &= ~CAP_PRIVACY_ON;
10224 }
bf79451e 10225
afbf30a2
JK		 10226 if (sec->flags & SEC_ENCRYPT)
10227 priv->ieee->sec.encrypt = sec->encrypt;
bf79451e 10228
b095c381
JK		 10229 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10230 priv->ieee->sec.level = sec->level;
10231 priv->ieee->sec.flags |= SEC_LEVEL;
43f66a6c
JK		 10232 priv->status |= STATUS_SECURITY_UPDATED;
10233 }
10234
1fbfea54
ZY		 10235 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10236 ipw_set_hwcrypto_keys(priv);
10237
bf79451e
JG		 10238 /* To match current functionality of ipw2100 (which works well w/
10239 * various supplicants, we don't force a disassociate if the
43f66a6c
JK		 10240 * privacy capability changes ... */
10241#if 0
10242 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
bf79451e 10243 (((priv->assoc_request.capability &
43f66a6c 10244 WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
bf79451e 10245 (!(priv->assoc_request.capability &
0edd5b44 10246 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
43f66a6c
JK		 10247 IPW_DEBUG_ASSOC("Disassociating due to capability "
10248 "change.\n");
10249 ipw_disassociate(priv);
10250 }
10251#endif
10252}
10253
bf79451e 10254static int init_supported_rates(struct ipw_priv *priv,
43f66a6c
JK		 10255 struct ipw_supported_rates *rates)
10256{
10257 /* TODO: Mask out rates based on priv->rates_mask */
10258
10259 memset(rates, 0, sizeof(*rates));
0edd5b44 10260 /* configure supported rates */
43f66a6c
JK		 10261 switch (priv->ieee->freq_band) {
10262 case IEEE80211_52GHZ_BAND:
10263 rates->ieee_mode = IPW_A_MODE;
10264 rates->purpose = IPW_RATE_CAPABILITIES;
10265 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10266 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10267 break;
10268
0edd5b44 10269 default: /* Mixed or 2.4Ghz */
43f66a6c
JK		 10270 rates->ieee_mode = IPW_G_MODE;
10271 rates->purpose = IPW_RATE_CAPABILITIES;
10272 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10273 IEEE80211_CCK_DEFAULT_RATES_MASK);
10274 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10275 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10276 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10277 }
10278 break;
10279 }
10280
10281 return 0;
10282}
10283
bf79451e 10284static int ipw_config(struct ipw_priv *priv)
43f66a6c 10285{
43f66a6c
JK		 10286 /* This is only called from ipw_up, which resets/reloads the firmware
10287 so, we don't need to first disable the card before we configure
10288 it */
6de9f7f2 10289 if (ipw_set_tx_power(priv))
43f66a6c
JK		 10290 goto error;
10291
10292 /* initialize adapter address */
10293 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10294 goto error;
10295
10296 /* set basic system config settings */
10297 init_sys_config(&priv->sys_config);
c848d0af
JK		 10298 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10299 priv->sys_config.answer_broadcast_ssid_probe = 1;
10300 else
10301 priv->sys_config.answer_broadcast_ssid_probe = 0;
10302
43f66a6c
JK		 10303 if (ipw_send_system_config(priv, &priv->sys_config))
10304 goto error;
10305
0edd5b44
JG		 10306 init_supported_rates(priv, &priv->rates);
10307 if (ipw_send_supported_rates(priv, &priv->rates))
43f66a6c
JK		 10308 goto error;
10309
10310 /* Set request-to-send threshold */
10311 if (priv->rts_threshold) {
10312 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10313 goto error;
10314 }
b095c381
JK		 10315#ifdef CONFIG_IPW_QOS
10316 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10317 ipw_qos_activate(priv, NULL);
10318#endif /* CONFIG_IPW_QOS */
43f66a6c
JK		 10319
10320 if (ipw_set_random_seed(priv))
10321 goto error;
bf79451e 10322
43f66a6c
JK		 10323 /* final state transition to the RUN state */
10324 if (ipw_send_host_complete(priv))
10325 goto error;
10326
e666619e
JK		 10327 priv->status |= STATUS_INIT;
10328
10329 ipw_led_init(priv);
10330 ipw_led_radio_on(priv);
10331 priv->notif_missed_beacons = 0;
10332
10333 /* Set hardware WEP key if it is configured. */
10334 if ((priv->capability & CAP_PRIVACY_ON) &&
10335 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10336 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10337 ipw_set_hwcrypto_keys(priv);
43f66a6c
JK		 10338
10339 return 0;
bf79451e 10340
0edd5b44 10341 error:
43f66a6c
JK		 10342 return -EIO;
10343}
10344
4f36f808
JK		 10345/*
10346 * NOTE:
10347 *
10348 * These tables have been tested in conjunction with the
10349 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10350 *
10351 * Altering this values, using it on other hardware, or in geographies
10352 * not intended for resale of the above mentioned Intel adapters has
10353 * not been tested.
10354 *
10355 */
10356static const struct ieee80211_geo ipw_geos[] = {
10357 { /* Restricted */
10358 "---",
10359 .bg_channels = 11,
10360 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10361 {2427, 4}, {2432, 5}, {2437, 6},
10362 {2442, 7}, {2447, 8}, {2452, 9},
10363 {2457, 10}, {2462, 11}},
10364 },
10365
10366 { /* Custom US/Canada */
10367 "ZZF",
10368 .bg_channels = 11,
10369 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10370 {2427, 4}, {2432, 5}, {2437, 6},
10371 {2442, 7}, {2447, 8}, {2452, 9},
10372 {2457, 10}, {2462, 11}},
10373 .a_channels = 8,
10374 .a = {{5180, 36},
10375 {5200, 40},
10376 {5220, 44},
10377 {5240, 48},
10378 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10379 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10380 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10381 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10382 },
10383
10384 { /* Rest of World */
10385 "ZZD",
10386 .bg_channels = 13,
10387 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10388 {2427, 4}, {2432, 5}, {2437, 6},
10389 {2442, 7}, {2447, 8}, {2452, 9},
10390 {2457, 10}, {2462, 11}, {2467, 12},
10391 {2472, 13}},
10392 },
10393
10394 { /* Custom USA & Europe & High */
10395 "ZZA",
10396 .bg_channels = 11,
10397 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10398 {2427, 4}, {2432, 5}, {2437, 6},
10399 {2442, 7}, {2447, 8}, {2452, 9},
10400 {2457, 10}, {2462, 11}},
10401 .a_channels = 13,
10402 .a = {{5180, 36},
10403 {5200, 40},
10404 {5220, 44},
10405 {5240, 48},
10406 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10407 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10408 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10409 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10410 {5745, 149},
10411 {5765, 153},
10412 {5785, 157},
10413 {5805, 161},
10414 {5825, 165}},
10415 },
10416
10417 { /* Custom NA & Europe */
10418 "ZZB",
10419 .bg_channels = 11,
10420 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10421 {2427, 4}, {2432, 5}, {2437, 6},
10422 {2442, 7}, {2447, 8}, {2452, 9},
10423 {2457, 10}, {2462, 11}},
10424 .a_channels = 13,
10425 .a = {{5180, 36},
10426 {5200, 40},
10427 {5220, 44},
10428 {5240, 48},
10429 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10430 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10431 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10432 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10433 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10434 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10435 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10436 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10437 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10438 },
10439
10440 { /* Custom Japan */
10441 "ZZC",
10442 .bg_channels = 11,
10443 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10444 {2427, 4}, {2432, 5}, {2437, 6},
10445 {2442, 7}, {2447, 8}, {2452, 9},
10446 {2457, 10}, {2462, 11}},
10447 .a_channels = 4,
10448 .a = {{5170, 34}, {5190, 38},
10449 {5210, 42}, {5230, 46}},
10450 },
10451
10452 { /* Custom */
10453 "ZZM",
10454 .bg_channels = 11,
10455 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10456 {2427, 4}, {2432, 5}, {2437, 6},
10457 {2442, 7}, {2447, 8}, {2452, 9},
10458 {2457, 10}, {2462, 11}},
10459 },
10460
10461 { /* Europe */
10462 "ZZE",
10463 .bg_channels = 13,
10464 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10465 {2427, 4}, {2432, 5}, {2437, 6},
10466 {2442, 7}, {2447, 8}, {2452, 9},
10467 {2457, 10}, {2462, 11}, {2467, 12},
10468 {2472, 13}},
10469 .a_channels = 19,
10470 .a = {{5180, 36},
10471 {5200, 40},
10472 {5220, 44},
10473 {5240, 48},
10474 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10475 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10476 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10477 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10478 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10479 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10480 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10481 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10482 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10483 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10484 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10485 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10486 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10487 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10488 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10489 },
10490
10491 { /* Custom Japan */
10492 "ZZJ",
10493 .bg_channels = 14,
10494 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10495 {2427, 4}, {2432, 5}, {2437, 6},
10496 {2442, 7}, {2447, 8}, {2452, 9},
10497 {2457, 10}, {2462, 11}, {2467, 12},
10498 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10499 .a_channels = 4,
10500 .a = {{5170, 34}, {5190, 38},
10501 {5210, 42}, {5230, 46}},
10502 },
10503
03520576
JK		 10504 { /* Rest of World */
10505 "ZZR",
10506 .bg_channels = 14,
10507 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10508 {2427, 4}, {2432, 5}, {2437, 6},
10509 {2442, 7}, {2447, 8}, {2452, 9},
10510 {2457, 10}, {2462, 11}, {2467, 12},
10511 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10512 IEEE80211_CH_PASSIVE_ONLY}},
10513 },
10514
4f36f808
JK		 10515 { /* High Band */
10516 "ZZH",
10517 .bg_channels = 13,
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},
10522 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10523 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10524 .a_channels = 4,
10525 .a = {{5745, 149}, {5765, 153},
10526 {5785, 157}, {5805, 161}},
10527 },
10528
10529 { /* Custom Europe */
10530 "ZZG",
10531 .bg_channels = 13,
10532 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10533 {2427, 4}, {2432, 5}, {2437, 6},
10534 {2442, 7}, {2447, 8}, {2452, 9},
10535 {2457, 10}, {2462, 11},
10536 {2467, 12}, {2472, 13}},
10537 .a_channels = 4,
10538 .a = {{5180, 36}, {5200, 40},
10539 {5220, 44}, {5240, 48}},
10540 },
10541
10542 { /* Europe */
10543 "ZZK",
10544 .bg_channels = 13,
10545 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10546 {2427, 4}, {2432, 5}, {2437, 6},
10547 {2442, 7}, {2447, 8}, {2452, 9},
10548 {2457, 10}, {2462, 11},
10549 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10550 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10551 .a_channels = 24,
10552 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10553 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10554 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10555 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10556 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10557 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10558 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10559 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10560 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10561 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10562 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10563 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10564 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10565 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10566 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10567 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10568 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10569 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10570 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10571 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10572 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10573 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10574 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10575 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10576 },
10577
10578 { /* Europe */
10579 "ZZL",
10580 .bg_channels = 11,
10581 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10582 {2427, 4}, {2432, 5}, {2437, 6},
10583 {2442, 7}, {2447, 8}, {2452, 9},
10584 {2457, 10}, {2462, 11}},
10585 .a_channels = 13,
10586 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10587 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10588 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10589 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10590 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10591 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10592 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10593 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10594 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10595 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10596 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10597 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10598 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10599 }
afbf30a2
JK		 10600};
10601
1fe0adb4
LH		 10602/* GEO code borrowed from ieee80211_geo.c */
10603static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
10604{
10605 int i;
10606
10607 /* Driver needs to initialize the geography map before using
10608 * these helper functions */
10609 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10610
10611 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10612 for (i = 0; i < ieee->geo.bg_channels; i++)
10613 /* NOTE: If G mode is currently supported but
10614 * this is a B only channel, we don't see it
10615 * as valid. */
10616 if ((ieee->geo.bg[i].channel == channel) &&
10617 (!(ieee->mode & IEEE_G) ||
10618 !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
10619 return IEEE80211_24GHZ_BAND;
10620
10621 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10622 for (i = 0; i < ieee->geo.a_channels; i++)
10623 if (ieee->geo.a[i].channel == channel)
10624 return IEEE80211_52GHZ_BAND;
10625
10626 return 0;
10627}
10628
10629static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
10630{
10631 int i;
10632
10633 /* Driver needs to initialize the geography map before using
10634 * these helper functions */
10635 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10636
10637 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10638 for (i = 0; i < ieee->geo.bg_channels; i++)
10639 if (ieee->geo.bg[i].channel == channel)
10640 return i;
10641
10642 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10643 for (i = 0; i < ieee->geo.a_channels; i++)
10644 if (ieee->geo.a[i].channel == channel)
10645 return i;
10646
10647 return -1;
10648}
10649
10650static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
10651{
10652 int i;
10653
10654 /* Driver needs to initialize the geography map before using
10655 * these helper functions */
10656 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10657
10658 freq /= 100000;
10659
10660 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10661 for (i = 0; i < ieee->geo.bg_channels; i++)
10662 if (ieee->geo.bg[i].freq == freq)
10663 return ieee->geo.bg[i].channel;
10664
10665 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10666 for (i = 0; i < ieee->geo.a_channels; i++)
10667 if (ieee->geo.a[i].freq == freq)
10668 return ieee->geo.a[i].channel;
10669
10670 return 0;
10671}
10672
10673static int ipw_set_geo(struct ieee80211_device *ieee,
10674 const struct ieee80211_geo *geo)
10675{
10676 memcpy(ieee->geo.name, geo->name, 3);
10677 ieee->geo.name[3] = '\0';
10678 ieee->geo.bg_channels = geo->bg_channels;
10679 ieee->geo.a_channels = geo->a_channels;
10680 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
10681 sizeof(struct ieee80211_channel));
10682 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
10683 sizeof(struct ieee80211_channel));
10684 return 0;
10685}
10686
10687static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
10688{
10689 return &ieee->geo;
10690}
10691
43f66a6c
JK		 10692#define MAX_HW_RESTARTS 5
10693static int ipw_up(struct ipw_priv *priv)
10694{
4f36f808 10695 int rc, i, j;
43f66a6c
JK		 10696
10697 if (priv->status & STATUS_EXIT_PENDING)
10698 return -EIO;
10699
f6c5cb7c
JK		 10700 if (cmdlog && !priv->cmdlog) {
10701 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10702 GFP_KERNEL);
10703 if (priv->cmdlog == NULL) {
10704 IPW_ERROR("Error allocating %d command log entries.\n",
10705 cmdlog);
10706 } else {
10707 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10708 priv->cmdlog_len = cmdlog;
10709 }
10710 }
10711
0edd5b44 10712 for (i = 0; i < MAX_HW_RESTARTS; i++) {
bf79451e 10713 /* Load the microcode, firmware, and eeprom.
43f66a6c
JK		 10714 * Also start the clocks. */
10715 rc = ipw_load(priv);
10716 if (rc) {
a4f6bbb3 10717 IPW_ERROR("Unable to load firmware: %d\n", rc);
43f66a6c
JK		 10718 return rc;
10719 }
10720
10721 ipw_init_ordinals(priv);
10722 if (!(priv->config & CFG_CUSTOM_MAC))
10723 eeprom_parse_mac(priv, priv->mac_addr);
10724 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10725
4f36f808
JK		 10726 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10727 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10728 ipw_geos[j].name, 3))
10729 break;
10730 }
03520576
JK		 10731 if (j == ARRAY_SIZE(ipw_geos)) {
10732 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10733 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10734 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10735 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
4f36f808 10736 j = 0;
03520576 10737 }
1fe0adb4 10738 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
4f36f808
JK		 10739 IPW_WARNING("Could not set geography.");
10740 return 0;
10741 }
10742
10743 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
10744 j, priv->ieee->geo.name);
afbf30a2 10745
b095c381
JK		 10746 if (priv->status & STATUS_RF_KILL_SW) {
10747 IPW_WARNING("Radio disabled by module parameter.\n");
10748 return 0;
10749 } else if (rf_kill_active(priv)) {
10750 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10751 "Kill switch must be turned off for "
10752 "wireless networking to work.\n");
10753 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10754 2 * HZ);
43f66a6c 10755 return 0;
c848d0af 10756 }
43f66a6c
JK		 10757
10758 rc = ipw_config(priv);
10759 if (!rc) {
10760 IPW_DEBUG_INFO("Configured device on count %i\n", i);
e666619e
JK		 10761
10762 /* If configure to try and auto-associate, kick
10763 * off a scan. */
10764 queue_work(priv->workqueue, &priv->request_scan);
afbf30a2 10765
43f66a6c 10766 return 0;
43f66a6c 10767 }
bf79451e 10768
c848d0af 10769 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
43f66a6c
JK		 10770 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10771 i, MAX_HW_RESTARTS);
10772
10773 /* We had an error bringing up the hardware, so take it
10774 * all the way back down so we can try again */
10775 ipw_down(priv);
10776 }
10777
bf79451e 10778 /* tried to restart and config the device for as long as our
43f66a6c 10779 * patience could withstand */
0edd5b44 10780 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
c848d0af 10781
43f66a6c
JK		 10782 return -EIO;
10783}
10784
c848d0af
JK		 10785static void ipw_bg_up(void *data)
10786{
10787 struct ipw_priv *priv = data;
10788 down(&priv->sem);
10789 ipw_up(data);
10790 up(&priv->sem);
10791}
10792
b095c381 10793static void ipw_deinit(struct ipw_priv *priv)
43f66a6c 10794{
b095c381
JK		 10795 int i;
10796
10797 if (priv->status & STATUS_SCANNING) {
10798 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10799 ipw_abort_scan(priv);
10800 }
10801
10802 if (priv->status & STATUS_ASSOCIATED) {
10803 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10804 ipw_disassociate(priv);
10805 }
10806
10807 ipw_led_shutdown(priv);
10808
10809 /* Wait up to 1s for status to change to not scanning and not
10810 * associated (disassociation can take a while for a ful 802.11
10811 * exchange */
10812 for (i = 1000; i && (priv->status &
10813 (STATUS_DISASSOCIATING |
10814 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10815 udelay(10);
10816
10817 if (priv->status & (STATUS_DISASSOCIATING |
10818 STATUS_ASSOCIATED | STATUS_SCANNING))
10819 IPW_DEBUG_INFO("Still associated or scanning...\n");
10820 else
10821 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10822
43f66a6c 10823 /* Attempt to disable the card */
43f66a6c 10824 ipw_send_card_disable(priv, 0);
b095c381
JK		 10825
10826 priv->status &= ~STATUS_INIT;
10827}
10828
10829static void ipw_down(struct ipw_priv *priv)
10830{
10831 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10832
10833 priv->status |= STATUS_EXIT_PENDING;
10834
10835 if (ipw_is_init(priv))
10836 ipw_deinit(priv);
10837
10838 /* Wipe out the EXIT_PENDING status bit if we are not actually
10839 * exiting the module */
10840 if (!exit_pending)
10841 priv->status &= ~STATUS_EXIT_PENDING;
43f66a6c
JK		 10842
10843 /* tell the device to stop sending interrupts */
10844 ipw_disable_interrupts(priv);
10845
10846 /* Clear all bits but the RF Kill */
b095c381 10847 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
43f66a6c
JK		 10848 netif_carrier_off(priv->net_dev);
10849 netif_stop_queue(priv->net_dev);
10850
10851 ipw_stop_nic(priv);
a613bffd
JK		 10852
10853 ipw_led_radio_off(priv);
43f66a6c
JK		 10854}
10855
c848d0af
JK		 10856static void ipw_bg_down(void *data)
10857{
10858 struct ipw_priv *priv = data;
10859 down(&priv->sem);
10860 ipw_down(data);
10861 up(&priv->sem);
43f66a6c
JK		 10862}
10863
10864/* Called by register_netdev() */
10865static int ipw_net_init(struct net_device *dev)
10866{
10867 struct ipw_priv *priv = ieee80211_priv(dev);
c848d0af 10868 down(&priv->sem);
43f66a6c 10869
c848d0af
JK		 10870 if (ipw_up(priv)) {
10871 up(&priv->sem);
43f66a6c 10872 return -EIO;
c848d0af 10873 }
43f66a6c 10874
c848d0af 10875 up(&priv->sem);
43f66a6c
JK		 10876 return 0;
10877}
10878
10879/* PCI driver stuff */
10880static struct pci_device_id card_ids[] = {
10881 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10882 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10883 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10884 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10885 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10886 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10887 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10888 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10889 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10890 {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10891 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10892 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10893 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10894 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10895 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10896 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10897 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10898 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
0edd5b44 10899 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
a613bffd 10900 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
0edd5b44
JG		 10901 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10902 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
bf79451e 10903
43f66a6c
JK		 10904 /* required last entry */
10905 {0,}
10906};
10907
10908MODULE_DEVICE_TABLE(pci, card_ids);
10909
10910static struct attribute *ipw_sysfs_entries[] = {
10911 &dev_attr_rf_kill.attr,
10912 &dev_attr_direct_dword.attr,
10913 &dev_attr_indirect_byte.attr,
10914 &dev_attr_indirect_dword.attr,
10915 &dev_attr_mem_gpio_reg.attr,
10916 &dev_attr_command_event_reg.attr,
10917 &dev_attr_nic_type.attr,
10918 &dev_attr_status.attr,
10919 &dev_attr_cfg.attr,
b39860c6
JK		 10920 &dev_attr_error.attr,
10921 &dev_attr_event_log.attr,
f6c5cb7c 10922 &dev_attr_cmd_log.attr,
43f66a6c
JK		 10923 &dev_attr_eeprom_delay.attr,
10924 &dev_attr_ucode_version.attr,
10925 &dev_attr_rtc.attr,
a613bffd
JK		 10926 &dev_attr_scan_age.attr,
10927 &dev_attr_led.attr,
b095c381
JK		 10928 &dev_attr_speed_scan.attr,
10929 &dev_attr_net_stats.attr,
43f66a6c
JK		 10930 NULL
10931};
10932
10933static struct attribute_group ipw_attribute_group = {
10934 .name = NULL, /* put in device directory */
0edd5b44 10935 .attrs = ipw_sysfs_entries,
43f66a6c
JK		 10936};
10937
0edd5b44 10938static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
43f66a6c
JK		 10939{
10940 int err = 0;
10941 struct net_device *net_dev;
10942 void __iomem *base;
10943 u32 length, val;
10944 struct ipw_priv *priv;
afbf30a2 10945 int i;
43f66a6c
JK		 10946
10947 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10948 if (net_dev == NULL) {
10949 err = -ENOMEM;
10950 goto out;
10951 }
10952
10953 priv = ieee80211_priv(net_dev);
10954 priv->ieee = netdev_priv(net_dev);
a613bffd 10955
43f66a6c
JK		 10956 priv->net_dev = net_dev;
10957 priv->pci_dev = pdev;
0f52bf90 10958#ifdef CONFIG_IPW2200_DEBUG
43f66a6c
JK		 10959 ipw_debug_level = debug;
10960#endif
10961 spin_lock_init(&priv->lock);
afbf30a2
JK		 10962 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10963 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
43f66a6c 10964
c848d0af 10965 init_MUTEX(&priv->sem);
43f66a6c
JK		 10966 if (pci_enable_device(pdev)) {
10967 err = -ENODEV;
10968 goto out_free_ieee80211;
10969 }
10970
10971 pci_set_master(pdev);
10972
0e08b44e 10973 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
bf79451e 10974 if (!err)
0e08b44e 10975 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
43f66a6c
JK		 10976 if (err) {
10977 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10978 goto out_pci_disable_device;
10979 }
10980
10981 pci_set_drvdata(pdev, priv);
10982
10983 err = pci_request_regions(pdev, DRV_NAME);
bf79451e 10984 if (err)
43f66a6c
JK		 10985 goto out_pci_disable_device;
10986
bf79451e 10987 /* We disable the RETRY_TIMEOUT register (0x41) to keep
43f66a6c 10988 * PCI Tx retries from interfering with C3 CPU state */
bf79451e
JG		 10989 pci_read_config_dword(pdev, 0x40, &val);
10990 if ((val & 0x0000ff00) != 0)
43f66a6c 10991 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
bf79451e 10992
43f66a6c
JK		 10993 length = pci_resource_len(pdev, 0);
10994 priv->hw_len = length;
bf79451e 10995
43f66a6c
JK		 10996 base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10997 if (!base) {
10998 err = -ENODEV;
10999 goto out_pci_release_regions;
11000 }
11001
11002 priv->hw_base = base;
11003 IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11004 IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11005
11006 err = ipw_setup_deferred_work(priv);
11007 if (err) {
11008 IPW_ERROR("Unable to setup deferred work\n");
11009 goto out_iounmap;
11010 }
11011
b095c381 11012 ipw_sw_reset(priv, 1);
43f66a6c 11013
0edd5b44 11014 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
43f66a6c
JK		 11015 if (err) {
11016 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11017 goto out_destroy_workqueue;
11018 }
11019
11020 SET_MODULE_OWNER(net_dev);
11021 SET_NETDEV_DEV(net_dev, &pdev->dev);
11022
c848d0af
JK		 11023 down(&priv->sem);
11024
43f66a6c
JK		 11025 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11026 priv->ieee->set_security = shim__set_security;
227d2dc1 11027 priv->ieee->is_queue_full = ipw_net_is_queue_full;
43f66a6c 11028
b095c381 11029#ifdef CONFIG_IPW_QOS
3b9990cb
JK		 11030 priv->ieee->handle_probe_response = ipw_handle_beacon;
11031 priv->ieee->handle_beacon = ipw_handle_probe_response;
11032 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
b095c381
JK		 11033#endif /* CONFIG_IPW_QOS */
11034
c848d0af
JK		 11035 priv->ieee->perfect_rssi = -20;
11036 priv->ieee->worst_rssi = -85;
43f66a6c
JK		 11037
11038 net_dev->open = ipw_net_open;
11039 net_dev->stop = ipw_net_stop;
11040 net_dev->init = ipw_net_init;
11041 net_dev->get_stats = ipw_net_get_stats;
11042 net_dev->set_multicast_list = ipw_net_set_multicast_list;
11043 net_dev->set_mac_address = ipw_net_set_mac_address;
97a78ca9
BB		 11044 priv->wireless_data.spy_data = &priv->ieee->spy_data;
11045 priv->wireless_data.ieee80211 = priv->ieee;
11046 net_dev->wireless_data = &priv->wireless_data;
43f66a6c
JK		 11047 net_dev->wireless_handlers = &ipw_wx_handler_def;
11048 net_dev->ethtool_ops = &ipw_ethtool_ops;
11049 net_dev->irq = pdev->irq;
0edd5b44 11050 net_dev->base_addr = (unsigned long)priv->hw_base;
43f66a6c
JK		 11051 net_dev->mem_start = pci_resource_start(pdev, 0);
11052 net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
11053
11054 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11055 if (err) {
11056 IPW_ERROR("failed to create sysfs device attributes\n");
c848d0af 11057 up(&priv->sem);
43f66a6c
JK		 11058 goto out_release_irq;
11059 }
11060
c848d0af 11061 up(&priv->sem);
43f66a6c
JK		 11062 err = register_netdev(net_dev);
11063 if (err) {
11064 IPW_ERROR("failed to register network device\n");
a613bffd 11065 goto out_remove_sysfs;
43f66a6c 11066 }
43f66a6c
JK		 11067 return 0;
11068
a613bffd 11069 out_remove_sysfs:
43f66a6c 11070 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
0edd5b44 11071 out_release_irq:
43f66a6c 11072 free_irq(pdev->irq, priv);
0edd5b44 11073 out_destroy_workqueue:
43f66a6c
JK		 11074 destroy_workqueue(priv->workqueue);
11075 priv->workqueue = NULL;
0edd5b44 11076 out_iounmap:
43f66a6c 11077 iounmap(priv->hw_base);
0edd5b44 11078 out_pci_release_regions:
43f66a6c 11079 pci_release_regions(pdev);
0edd5b44 11080 out_pci_disable_device:
43f66a6c
JK		 11081 pci_disable_device(pdev);
11082 pci_set_drvdata(pdev, NULL);
0edd5b44 11083 out_free_ieee80211:
43f66a6c 11084 free_ieee80211(priv->net_dev);
0edd5b44 11085 out:
43f66a6c
JK		 11086 return err;
11087}
11088
11089static void ipw_pci_remove(struct pci_dev *pdev)
11090{
11091 struct ipw_priv *priv = pci_get_drvdata(pdev);
afbf30a2
JK		 11092 struct list_head *p, *q;
11093 int i;
b095c381 11094
43f66a6c
JK		 11095 if (!priv)
11096 return;
11097
b095c381 11098 down(&priv->sem);
43f66a6c 11099
afbf30a2 11100 priv->status |= STATUS_EXIT_PENDING;
43f66a6c 11101 ipw_down(priv);
43f66a6c
JK		 11102 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11103
b095c381 11104 up(&priv->sem);
43f66a6c
JK		 11105
11106 unregister_netdev(priv->net_dev);
11107
11108 if (priv->rxq) {
11109 ipw_rx_queue_free(priv, priv->rxq);
11110 priv->rxq = NULL;
11111 }
11112 ipw_tx_queue_free(priv);
11113
f6c5cb7c
JK		 11114 if (priv->cmdlog) {
11115 kfree(priv->cmdlog);
11116 priv->cmdlog = NULL;
11117 }
43f66a6c
JK		 11118 /* ipw_down will ensure that there is no more pending work
11119 * in the workqueue's, so we can safely remove them now. */
a613bffd
JK		 11120 cancel_delayed_work(&priv->adhoc_check);
11121 cancel_delayed_work(&priv->gather_stats);
11122 cancel_delayed_work(&priv->request_scan);
11123 cancel_delayed_work(&priv->rf_kill);
11124 cancel_delayed_work(&priv->scan_check);
11125 destroy_workqueue(priv->workqueue);
11126 priv->workqueue = NULL;
43f66a6c 11127
afbf30a2
JK		 11128 /* Free MAC hash list for ADHOC */
11129 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11130 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11131 kfree(list_entry(p, struct ipw_ibss_seq, list));
11132 list_del(p);
11133 }
11134 }
11135
b39860c6
JK		 11136 if (priv->error) {
11137 ipw_free_error_log(priv->error);
11138 priv->error = NULL;
43f66a6c
JK		 11139 }
11140
11141 free_irq(pdev->irq, priv);
11142 iounmap(priv->hw_base);
11143 pci_release_regions(pdev);
11144 pci_disable_device(pdev);
11145 pci_set_drvdata(pdev, NULL);
11146 free_ieee80211(priv->net_dev);
afbf30a2 11147 free_firmware();
43f66a6c
JK		 11148}
11149
43f66a6c 11150#ifdef CONFIG_PM
583a4e88 11151static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
43f66a6c
JK		 11152{
11153 struct ipw_priv *priv = pci_get_drvdata(pdev);
11154 struct net_device *dev = priv->net_dev;
11155
11156 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11157
0edd5b44 11158 /* Take down the device; powers it off, etc. */
43f66a6c
JK		 11159 ipw_down(priv);
11160
11161 /* Remove the PRESENT state of the device */
11162 netif_device_detach(dev);
11163
43f66a6c 11164 pci_save_state(pdev);
43f66a6c 11165 pci_disable_device(pdev);
583a4e88 11166 pci_set_power_state(pdev, pci_choose_state(pdev, state));
bf79451e 11167
43f66a6c
JK		 11168 return 0;
11169}
11170
11171static int ipw_pci_resume(struct pci_dev *pdev)
11172{
11173 struct ipw_priv *priv = pci_get_drvdata(pdev);
11174 struct net_device *dev = priv->net_dev;
11175 u32 val;
bf79451e 11176
43f66a6c
JK		 11177 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11178
ea2b26e0 11179 pci_set_power_state(pdev, PCI_D0);
43f66a6c 11180 pci_enable_device(pdev);
43f66a6c 11181 pci_restore_state(pdev);
ea2b26e0 11182
43f66a6c
JK		 11183 /*
11184 * Suspend/Resume resets the PCI configuration space, so we have to
11185 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11186 * from interfering with C3 CPU state. pci_restore_state won't help
11187 * here since it only restores the first 64 bytes pci config header.
11188 */
bf79451e
JG		 11189 pci_read_config_dword(pdev, 0x40, &val);
11190 if ((val & 0x0000ff00) != 0)
43f66a6c
JK		 11191 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11192
11193 /* Set the device back into the PRESENT state; this will also wake
11194 * the queue of needed */
11195 netif_device_attach(dev);
11196
11197 /* Bring the device back up */
11198 queue_work(priv->workqueue, &priv->up);
bf79451e 11199
43f66a6c
JK		 11200 return 0;
11201}
11202#endif
11203
11204/* driver initialization stuff */
11205static struct pci_driver ipw_driver = {
11206 .name = DRV_NAME,
11207 .id_table = card_ids,
11208 .probe = ipw_pci_probe,
11209 .remove = __devexit_p(ipw_pci_remove),
11210#ifdef CONFIG_PM
11211 .suspend = ipw_pci_suspend,
11212 .resume = ipw_pci_resume,
11213#endif
11214};
11215
11216static int __init ipw_init(void)
11217{
11218 int ret;
11219
11220 printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11221 printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11222
11223 ret = pci_module_init(&ipw_driver);
11224 if (ret) {
11225 IPW_ERROR("Unable to initialize PCI module\n");
11226 return ret;
11227 }
11228
0edd5b44 11229 ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
43f66a6c
JK		 11230 if (ret) {
11231 IPW_ERROR("Unable to create driver sysfs file\n");
11232 pci_unregister_driver(&ipw_driver);
11233 return ret;
11234 }
11235
11236 return ret;
11237}
11238
11239static void __exit ipw_exit(void)
11240{
11241 driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11242 pci_unregister_driver(&ipw_driver);
11243}
11244
11245module_param(disable, int, 0444);
11246MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11247
11248module_param(associate, int, 0444);
11249MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11250
11251module_param(auto_create, int, 0444);
11252MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11253
a613bffd 11254module_param(led, int, 0444);
c848d0af 11255MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
a613bffd 11256
43f66a6c
JK		 11257module_param(debug, int, 0444);
11258MODULE_PARM_DESC(debug, "debug output mask");
11259
11260module_param(channel, int, 0444);
bf79451e 11261MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
43f66a6c 11262
b095c381
JK		 11263#ifdef CONFIG_IPW_QOS
11264module_param(qos_enable, int, 0444);
11265MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11266
11267module_param(qos_burst_enable, int, 0444);
11268MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11269
11270module_param(qos_no_ack_mask, int, 0444);
11271MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
43f66a6c 11272
b095c381
JK		 11273module_param(burst_duration_CCK, int, 0444);
11274MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11275
11276module_param(burst_duration_OFDM, int, 0444);
11277MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11278#endif /* CONFIG_IPW_QOS */
11279
11280#ifdef CONFIG_IPW2200_MONITOR
43f66a6c
JK		 11281module_param(mode, int, 0444);
11282MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11283#else
11284module_param(mode, int, 0444);
11285MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11286#endif
11287
b095c381
JK		 11288module_param(hwcrypto, int, 0444);
11289MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11290
f6c5cb7c
JK		 11291module_param(cmdlog, int, 0444);
11292MODULE_PARM_DESC(cmdlog,
11293 "allocate a ring buffer for logging firmware commands");
11294
43f66a6c
JK		 11295module_exit(ipw_exit);
11296module_init(ipw_init);
Ubuntu Eoan Linux kernel mirror