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