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