aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/ipw2200.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/ipw2200.c')
-rw-r--r--drivers/net/wireless/ipw2200.c6609
1 files changed, 5258 insertions, 1351 deletions
diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index 3db0c32afe82..136884cef908 100644
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -1,6 +1,6 @@
1/****************************************************************************** 1/******************************************************************************
2 2
3 Copyright(c) 2003 - 2004 Intel Corporation. All rights reserved. 3 Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
4 4
5 802.11 status code portion of this file from ethereal-0.10.6: 5 802.11 status code portion of this file from ethereal-0.10.6:
6 Copyright 2000, Axis Communications AB 6 Copyright 2000, Axis Communications AB
@@ -32,29 +32,101 @@
32 32
33#include "ipw2200.h" 33#include "ipw2200.h"
34 34
35#define IPW2200_VERSION "1.0.0" 35#define IPW2200_VERSION "git-1.0.8"
36#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver" 36#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
37#define DRV_COPYRIGHT "Copyright(c) 2003-2004 Intel Corporation" 37#define DRV_COPYRIGHT "Copyright(c) 2003-2005 Intel Corporation"
38#define DRV_VERSION IPW2200_VERSION 38#define DRV_VERSION IPW2200_VERSION
39 39
40#define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
41
40MODULE_DESCRIPTION(DRV_DESCRIPTION); 42MODULE_DESCRIPTION(DRV_DESCRIPTION);
41MODULE_VERSION(DRV_VERSION); 43MODULE_VERSION(DRV_VERSION);
42MODULE_AUTHOR(DRV_COPYRIGHT); 44MODULE_AUTHOR(DRV_COPYRIGHT);
43MODULE_LICENSE("GPL"); 45MODULE_LICENSE("GPL");
44 46
47static int cmdlog = 0;
45static int debug = 0; 48static int debug = 0;
46static int channel = 0; 49static int channel = 0;
47static char *ifname;
48static int mode = 0; 50static int mode = 0;
49 51
50static u32 ipw_debug_level; 52static u32 ipw_debug_level;
51static int associate = 1; 53static int associate = 1;
52static int auto_create = 1; 54static int auto_create = 1;
55static int led = 0;
53static int disable = 0; 56static int disable = 0;
57static int hwcrypto = 1;
54static const char ipw_modes[] = { 58static const char ipw_modes[] = {
55 'a', 'b', 'g', '?' 59 'a', 'b', 'g', '?'
56}; 60};
57 61
62#ifdef CONFIG_IPW_QOS
63static int qos_enable = 0;
64static int qos_burst_enable = 0;
65static int qos_no_ack_mask = 0;
66static int burst_duration_CCK = 0;
67static int burst_duration_OFDM = 0;
68
69static struct ieee80211_qos_parameters def_qos_parameters_OFDM = {
70 {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
71 QOS_TX3_CW_MIN_OFDM},
72 {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
73 QOS_TX3_CW_MAX_OFDM},
74 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
75 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
76 {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
77 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
78};
79
80static struct ieee80211_qos_parameters def_qos_parameters_CCK = {
81 {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
82 QOS_TX3_CW_MIN_CCK},
83 {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
84 QOS_TX3_CW_MAX_CCK},
85 {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
86 {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
87 {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
88 QOS_TX3_TXOP_LIMIT_CCK}
89};
90
91static struct ieee80211_qos_parameters def_parameters_OFDM = {
92 {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
93 DEF_TX3_CW_MIN_OFDM},
94 {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
95 DEF_TX3_CW_MAX_OFDM},
96 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
97 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
98 {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
99 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
100};
101
102static struct ieee80211_qos_parameters def_parameters_CCK = {
103 {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
104 DEF_TX3_CW_MIN_CCK},
105 {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
106 DEF_TX3_CW_MAX_CCK},
107 {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
108 {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
109 {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
110 DEF_TX3_TXOP_LIMIT_CCK}
111};
112
113static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
114
115static int from_priority_to_tx_queue[] = {
116 IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
117 IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
118};
119
120static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
121
122static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
123 *qos_param);
124static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
125 *qos_param);
126#endif /* CONFIG_IPW_QOS */
127
128static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
129static void ipw_remove_current_network(struct ipw_priv *priv);
58static void ipw_rx(struct ipw_priv *priv); 130static void ipw_rx(struct ipw_priv *priv);
59static int ipw_queue_tx_reclaim(struct ipw_priv *priv, 131static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
60 struct clx2_tx_queue *txq, int qindex); 132 struct clx2_tx_queue *txq, int qindex);
@@ -68,42 +140,24 @@ static void ipw_tx_queue_free(struct ipw_priv *);
68static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *); 140static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
69static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *); 141static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
70static void ipw_rx_queue_replenish(void *); 142static void ipw_rx_queue_replenish(void *);
71
72static int ipw_up(struct ipw_priv *); 143static int ipw_up(struct ipw_priv *);
144static void ipw_bg_up(void *);
73static void ipw_down(struct ipw_priv *); 145static void ipw_down(struct ipw_priv *);
146static void ipw_bg_down(void *);
74static int ipw_config(struct ipw_priv *); 147static int ipw_config(struct ipw_priv *);
75static int init_supported_rates(struct ipw_priv *priv, 148static int init_supported_rates(struct ipw_priv *priv,
76 struct ipw_supported_rates *prates); 149 struct ipw_supported_rates *prates);
150static void ipw_set_hwcrypto_keys(struct ipw_priv *);
151static void ipw_send_wep_keys(struct ipw_priv *, int);
77 152
78static u8 band_b_active_channel[MAX_B_CHANNELS] = { 153static int ipw_is_valid_channel(struct ieee80211_device *, u8);
79 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0 154static int ipw_channel_to_index(struct ieee80211_device *, u8);
80}; 155static u8 ipw_freq_to_channel(struct ieee80211_device *, u32);
81static u8 band_a_active_channel[MAX_A_CHANNELS] = { 156static int ipw_set_geo(struct ieee80211_device *, const struct ieee80211_geo *);
82 36, 40, 44, 48, 149, 153, 157, 161, 165, 52, 56, 60, 64, 0 157static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *);
83};
84 158
85static int is_valid_channel(int mode_mask, int channel) 159static int snprint_line(char *buf, size_t count,
86{ 160 const u8 * data, u32 len, u32 ofs)
87 int i;
88
89 if (!channel)
90 return 0;
91
92 if (mode_mask & IEEE_A)
93 for (i = 0; i < MAX_A_CHANNELS; i++)
94 if (band_a_active_channel[i] == channel)
95 return IEEE_A;
96
97 if (mode_mask & (IEEE_B | IEEE_G))
98 for (i = 0; i < MAX_B_CHANNELS; i++)
99 if (band_b_active_channel[i] == channel)
100 return mode_mask & (IEEE_B | IEEE_G);
101
102 return 0;
103}
104
105static char *snprint_line(char *buf, size_t count,
106 const u8 * data, u32 len, u32 ofs)
107{ 161{
108 int out, i, j, l; 162 int out, i, j, l;
109 char c; 163 char c;
@@ -134,7 +188,7 @@ static char *snprint_line(char *buf, size_t count,
134 out += snprintf(buf + out, count - out, " "); 188 out += snprintf(buf + out, count - out, " ");
135 } 189 }
136 190
137 return buf; 191 return out;
138} 192}
139 193
140static void printk_buf(int level, const u8 * data, u32 len) 194static void printk_buf(int level, const u8 * data, u32 len)
@@ -145,14 +199,33 @@ static void printk_buf(int level, const u8 * data, u32 len)
145 return; 199 return;
146 200
147 while (len) { 201 while (len) {
148 printk(KERN_DEBUG "%s\n", 202 snprint_line(line, sizeof(line), &data[ofs],
149 snprint_line(line, sizeof(line), &data[ofs], 203 min(len, 16U), ofs);
150 min(len, 16U), ofs)); 204 printk(KERN_DEBUG "%s\n", line);
151 ofs += 16; 205 ofs += 16;
152 len -= min(len, 16U); 206 len -= min(len, 16U);
153 } 207 }
154} 208}
155 209
210static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
211{
212 size_t out = size;
213 u32 ofs = 0;
214 int total = 0;
215
216 while (size && len) {
217 out = snprint_line(output, size, &data[ofs],
218 min_t(size_t, len, 16U), ofs);
219
220 ofs += 16;
221 output += out;
222 size -= out;
223 len -= min_t(size_t, len, 16U);
224 total += out;
225 }
226 return total;
227}
228
156static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg); 229static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
157#define ipw_read_reg32(a, b) _ipw_read_reg32(a, b) 230#define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
158 231
@@ -226,38 +299,42 @@ static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
226#define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs) 299#define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)
227 300
228static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int); 301static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
229#define ipw_read_indirect(a, b, c, d) \ 302static inline void __ipw_read_indirect(const char *f, int l,
230 IPW_DEBUG_IO("%s %d: read_inddirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \ 303 struct ipw_priv *a, u32 b, u8 * c, int d)
231 _ipw_read_indirect(a, b, c, d) 304{
305 IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
306 d);
307 _ipw_read_indirect(a, b, c, d);
308}
309
310#define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
232 311
233static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data, 312static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
234 int num); 313 int num);
235#define ipw_write_indirect(a, b, c, d) \ 314#define ipw_write_indirect(a, b, c, d) \
236 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \ 315 IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
237 _ipw_write_indirect(a, b, c, d) 316 _ipw_write_indirect(a, b, c, d)
238 317
239/* indirect write s */ 318/* indirect write s */
240static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value) 319static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
241{ 320{
242 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value); 321 IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
243 _ipw_write32(priv, CX2_INDIRECT_ADDR, reg); 322 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
244 _ipw_write32(priv, CX2_INDIRECT_DATA, value); 323 _ipw_write32(priv, IPW_INDIRECT_DATA, value);
245} 324}
246 325
247static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value) 326static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
248{ 327{
249 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value); 328 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
250 _ipw_write32(priv, CX2_INDIRECT_ADDR, reg & CX2_INDIRECT_ADDR_MASK); 329 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
251 _ipw_write8(priv, CX2_INDIRECT_DATA, value); 330 _ipw_write8(priv, IPW_INDIRECT_DATA, value);
252 IPW_DEBUG_IO(" reg = 0x%8lX : value = 0x%8X\n",
253 (unsigned long)(priv->hw_base + CX2_INDIRECT_DATA), value);
254} 331}
255 332
256static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value) 333static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
257{ 334{
258 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value); 335 IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
259 _ipw_write32(priv, CX2_INDIRECT_ADDR, reg & CX2_INDIRECT_ADDR_MASK); 336 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
260 _ipw_write16(priv, CX2_INDIRECT_DATA, value); 337 _ipw_write16(priv, IPW_INDIRECT_DATA, value);
261} 338}
262 339
263/* indirect read s */ 340/* indirect read s */
@@ -265,9 +342,9 @@ static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
265static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg) 342static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
266{ 343{
267 u32 word; 344 u32 word;
268 _ipw_write32(priv, CX2_INDIRECT_ADDR, reg & CX2_INDIRECT_ADDR_MASK); 345 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
269 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg); 346 IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
270 word = _ipw_read32(priv, CX2_INDIRECT_DATA); 347 word = _ipw_read32(priv, IPW_INDIRECT_DATA);
271 return (word >> ((reg & 0x3) * 8)) & 0xff; 348 return (word >> ((reg & 0x3) * 8)) & 0xff;
272} 349}
273 350
@@ -277,8 +354,8 @@ static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
277 354
278 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg); 355 IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
279 356
280 _ipw_write32(priv, CX2_INDIRECT_ADDR, reg); 357 _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
281 value = _ipw_read32(priv, CX2_INDIRECT_DATA); 358 value = _ipw_read32(priv, IPW_INDIRECT_DATA);
282 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value); 359 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
283 return value; 360 return value;
284} 361}
@@ -287,67 +364,69 @@ static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
287static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf, 364static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
288 int num) 365 int num)
289{ 366{
290 u32 aligned_addr = addr & CX2_INDIRECT_ADDR_MASK; 367 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
291 u32 dif_len = addr - aligned_addr; 368 u32 dif_len = addr - aligned_addr;
292 u32 aligned_len;
293 u32 i; 369 u32 i;
294 370
295 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num); 371 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
296 372
373 if (num <= 0) {
374 return;
375 }
376
297 /* Read the first nibble byte by byte */ 377 /* Read the first nibble byte by byte */
298 if (unlikely(dif_len)) { 378 if (unlikely(dif_len)) {
379 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
299 /* Start reading at aligned_addr + dif_len */ 380 /* Start reading at aligned_addr + dif_len */
300 _ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr); 381 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
301 for (i = dif_len; i < 4; i++, buf++) 382 *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
302 *buf = _ipw_read8(priv, CX2_INDIRECT_DATA + i);
303 num -= dif_len;
304 aligned_addr += 4; 383 aligned_addr += 4;
305 } 384 }
306 385
307 /* Read DWs through autoinc register */ 386 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
308 _ipw_write32(priv, CX2_AUTOINC_ADDR, aligned_addr); 387 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
309 aligned_len = num & CX2_INDIRECT_ADDR_MASK; 388 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
310 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
311 *(u32 *) buf = ipw_read32(priv, CX2_AUTOINC_DATA);
312 389
313 /* Copy the last nibble */ 390 /* Copy the last nibble */
314 dif_len = num - aligned_len; 391 if (unlikely(num)) {
315 _ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr); 392 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
316 for (i = 0; i < dif_len; i++, buf++) 393 for (i = 0; num > 0; i++, num--)
317 *buf = ipw_read8(priv, CX2_INDIRECT_DATA + i); 394 *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
395 }
318} 396}
319 397
320static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf, 398static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
321 int num) 399 int num)
322{ 400{
323 u32 aligned_addr = addr & CX2_INDIRECT_ADDR_MASK; 401 u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
324 u32 dif_len = addr - aligned_addr; 402 u32 dif_len = addr - aligned_addr;
325 u32 aligned_len;
326 u32 i; 403 u32 i;
327 404
328 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num); 405 IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
329 406
407 if (num <= 0) {
408 return;
409 }
410
330 /* Write the first nibble byte by byte */ 411 /* Write the first nibble byte by byte */
331 if (unlikely(dif_len)) { 412 if (unlikely(dif_len)) {
332 /* Start writing at aligned_addr + dif_len */ 413 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
333 _ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr); 414 /* Start reading at aligned_addr + dif_len */
334 for (i = dif_len; i < 4; i++, buf++) 415 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
335 _ipw_write8(priv, CX2_INDIRECT_DATA + i, *buf); 416 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
336 num -= dif_len;
337 aligned_addr += 4; 417 aligned_addr += 4;
338 } 418 }
339 419
340 /* Write DWs through autoinc register */ 420 _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
341 _ipw_write32(priv, CX2_AUTOINC_ADDR, aligned_addr); 421 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
342 aligned_len = num & CX2_INDIRECT_ADDR_MASK; 422 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
343 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
344 _ipw_write32(priv, CX2_AUTOINC_DATA, *(u32 *) buf);
345 423
346 /* Copy the last nibble */ 424 /* Copy the last nibble */
347 dif_len = num - aligned_len; 425 if (unlikely(num)) {
348 _ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr); 426 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
349 for (i = 0; i < dif_len; i++, buf++) 427 for (i = 0; num > 0; i++, num--, buf++)
350 _ipw_write8(priv, CX2_INDIRECT_DATA + i, *buf); 428 _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
429 }
351} 430}
352 431
353static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf, 432static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
@@ -371,7 +450,7 @@ static inline void ipw_enable_interrupts(struct ipw_priv *priv)
371 if (priv->status & STATUS_INT_ENABLED) 450 if (priv->status & STATUS_INT_ENABLED)
372 return; 451 return;
373 priv->status |= STATUS_INT_ENABLED; 452 priv->status |= STATUS_INT_ENABLED;
374 ipw_write32(priv, CX2_INTA_MASK_R, CX2_INTA_MASK_ALL); 453 ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
375} 454}
376 455
377static inline void ipw_disable_interrupts(struct ipw_priv *priv) 456static inline void ipw_disable_interrupts(struct ipw_priv *priv)
@@ -379,9 +458,10 @@ static inline void ipw_disable_interrupts(struct ipw_priv *priv)
379 if (!(priv->status & STATUS_INT_ENABLED)) 458 if (!(priv->status & STATUS_INT_ENABLED))
380 return; 459 return;
381 priv->status &= ~STATUS_INT_ENABLED; 460 priv->status &= ~STATUS_INT_ENABLED;
382 ipw_write32(priv, CX2_INTA_MASK_R, ~CX2_INTA_MASK_ALL); 461 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
383} 462}
384 463
464#ifdef CONFIG_IPW_DEBUG
385static char *ipw_error_desc(u32 val) 465static char *ipw_error_desc(u32 val)
386{ 466{
387 switch (val) { 467 switch (val) {
@@ -394,81 +474,65 @@ static char *ipw_error_desc(u32 val)
394 case IPW_FW_ERROR_MEMORY_OVERFLOW: 474 case IPW_FW_ERROR_MEMORY_OVERFLOW:
395 return "MEMORY_OVERFLOW"; 475 return "MEMORY_OVERFLOW";
396 case IPW_FW_ERROR_BAD_PARAM: 476 case IPW_FW_ERROR_BAD_PARAM:
397 return "ERROR_BAD_PARAM"; 477 return "BAD_PARAM";
398 case IPW_FW_ERROR_BAD_CHECKSUM: 478 case IPW_FW_ERROR_BAD_CHECKSUM:
399 return "ERROR_BAD_CHECKSUM"; 479 return "BAD_CHECKSUM";
400 case IPW_FW_ERROR_NMI_INTERRUPT: 480 case IPW_FW_ERROR_NMI_INTERRUPT:
401 return "ERROR_NMI_INTERRUPT"; 481 return "NMI_INTERRUPT";
402 case IPW_FW_ERROR_BAD_DATABASE: 482 case IPW_FW_ERROR_BAD_DATABASE:
403 return "ERROR_BAD_DATABASE"; 483 return "BAD_DATABASE";
404 case IPW_FW_ERROR_ALLOC_FAIL: 484 case IPW_FW_ERROR_ALLOC_FAIL:
405 return "ERROR_ALLOC_FAIL"; 485 return "ALLOC_FAIL";
406 case IPW_FW_ERROR_DMA_UNDERRUN: 486 case IPW_FW_ERROR_DMA_UNDERRUN:
407 return "ERROR_DMA_UNDERRUN"; 487 return "DMA_UNDERRUN";
408 case IPW_FW_ERROR_DMA_STATUS: 488 case IPW_FW_ERROR_DMA_STATUS:
409 return "ERROR_DMA_STATUS"; 489 return "DMA_STATUS";
410 case IPW_FW_ERROR_DINOSTATUS_ERROR: 490 case IPW_FW_ERROR_DINO_ERROR:
411 return "ERROR_DINOSTATUS_ERROR"; 491 return "DINO_ERROR";
412 case IPW_FW_ERROR_EEPROMSTATUS_ERROR: 492 case IPW_FW_ERROR_EEPROM_ERROR:
413 return "ERROR_EEPROMSTATUS_ERROR"; 493 return "EEPROM_ERROR";
414 case IPW_FW_ERROR_SYSASSERT: 494 case IPW_FW_ERROR_SYSASSERT:
415 return "ERROR_SYSASSERT"; 495 return "SYSASSERT";
416 case IPW_FW_ERROR_FATAL_ERROR: 496 case IPW_FW_ERROR_FATAL_ERROR:
417 return "ERROR_FATALSTATUS_ERROR"; 497 return "FATAL_ERROR";
418 default: 498 default:
419 return "UNKNOWNSTATUS_ERROR"; 499 return "UNKNOWN_ERROR";
420 } 500 }
421} 501}
422 502
423static void ipw_dump_nic_error_log(struct ipw_priv *priv) 503static void ipw_dump_error_log(struct ipw_priv *priv,
504 struct ipw_fw_error *error)
424{ 505{
425 u32 desc, time, blink1, blink2, ilink1, ilink2, idata, i, count, base; 506 u32 i;
426
427 base = ipw_read32(priv, IPWSTATUS_ERROR_LOG);
428 count = ipw_read_reg32(priv, base);
429 507
430 if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) { 508 if (!error) {
431 IPW_ERROR("Start IPW Error Log Dump:\n"); 509 IPW_ERROR("Error allocating and capturing error log. "
432 IPW_ERROR("Status: 0x%08X, Config: %08X\n", 510 "Nothing to dump.\n");
433 priv->status, priv->config); 511 return;
434 } 512 }
435 513
436 for (i = ERROR_START_OFFSET; 514 IPW_ERROR("Start IPW Error Log Dump:\n");
437 i <= count * ERROR_ELEM_SIZE; i += ERROR_ELEM_SIZE) { 515 IPW_ERROR("Status: 0x%08X, Config: %08X\n",
438 desc = ipw_read_reg32(priv, base + i); 516 error->status, error->config);
439 time = ipw_read_reg32(priv, base + i + 1 * sizeof(u32));
440 blink1 = ipw_read_reg32(priv, base + i + 2 * sizeof(u32));
441 blink2 = ipw_read_reg32(priv, base + i + 3 * sizeof(u32));
442 ilink1 = ipw_read_reg32(priv, base + i + 4 * sizeof(u32));
443 ilink2 = ipw_read_reg32(priv, base + i + 5 * sizeof(u32));
444 idata = ipw_read_reg32(priv, base + i + 6 * sizeof(u32));
445 517
518 for (i = 0; i < error->elem_len; i++)
446 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n", 519 IPW_ERROR("%s %i 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
447 ipw_error_desc(desc), time, blink1, blink2, 520 ipw_error_desc(error->elem[i].desc),
448 ilink1, ilink2, idata); 521 error->elem[i].time,
449 } 522 error->elem[i].blink1,
523 error->elem[i].blink2,
524 error->elem[i].link1,
525 error->elem[i].link2, error->elem[i].data);
526 for (i = 0; i < error->log_len; i++)
527 IPW_ERROR("%i\t0x%08x\t%i\n",
528 error->log[i].time,
529 error->log[i].data, error->log[i].event);
450} 530}
531#endif
451 532
452static void ipw_dump_nic_event_log(struct ipw_priv *priv) 533static inline int ipw_is_init(struct ipw_priv *priv)
453{ 534{
454 u32 ev, time, data, i, count, base; 535 return (priv->status & STATUS_INIT) ? 1 : 0;
455
456 base = ipw_read32(priv, IPW_EVENT_LOG);
457 count = ipw_read_reg32(priv, base);
458
459 if (EVENT_START_OFFSET <= count * EVENT_ELEM_SIZE)
460 IPW_ERROR("Start IPW Event Log Dump:\n");
461
462 for (i = EVENT_START_OFFSET;
463 i <= count * EVENT_ELEM_SIZE; i += EVENT_ELEM_SIZE) {
464 ev = ipw_read_reg32(priv, base + i);
465 time = ipw_read_reg32(priv, base + i + 1 * sizeof(u32));
466 data = ipw_read_reg32(priv, base + i + 2 * sizeof(u32));
467
468#ifdef CONFIG_IPW_DEBUG
469 IPW_ERROR("%i\t0x%08x\t%i\n", time, data, ev);
470#endif
471 }
472} 536}
473 537
474static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len) 538static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
@@ -636,6 +700,340 @@ static void ipw_init_ordinals(struct ipw_priv *priv)
636 700
637} 701}
638 702
703u32 ipw_register_toggle(u32 reg)
704{
705 reg &= ~IPW_START_STANDBY;
706 if (reg & IPW_GATE_ODMA)
707 reg &= ~IPW_GATE_ODMA;
708 if (reg & IPW_GATE_IDMA)
709 reg &= ~IPW_GATE_IDMA;
710 if (reg & IPW_GATE_ADMA)
711 reg &= ~IPW_GATE_ADMA;
712 return reg;
713}
714
715/*
716 * LED behavior:
717 * - On radio ON, turn on any LEDs that require to be on during start
718 * - On initialization, start unassociated blink
719 * - On association, disable unassociated blink
720 * - On disassociation, start unassociated blink
721 * - On radio OFF, turn off any LEDs started during radio on
722 *
723 */
724#define LD_TIME_LINK_ON 300
725#define LD_TIME_LINK_OFF 2700
726#define LD_TIME_ACT_ON 250
727
728void ipw_led_link_on(struct ipw_priv *priv)
729{
730 unsigned long flags;
731 u32 led;
732
733 /* If configured to not use LEDs, or nic_type is 1,
734 * then we don't toggle a LINK led */
735 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
736 return;
737
738 spin_lock_irqsave(&priv->lock, flags);
739
740 if (!(priv->status & STATUS_RF_KILL_MASK) &&
741 !(priv->status & STATUS_LED_LINK_ON)) {
742 IPW_DEBUG_LED("Link LED On\n");
743 led = ipw_read_reg32(priv, IPW_EVENT_REG);
744 led |= priv->led_association_on;
745
746 led = ipw_register_toggle(led);
747
748 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
749 ipw_write_reg32(priv, IPW_EVENT_REG, led);
750
751 priv->status |= STATUS_LED_LINK_ON;
752
753 /* If we aren't associated, schedule turning the LED off */
754 if (!(priv->status & STATUS_ASSOCIATED))
755 queue_delayed_work(priv->workqueue,
756 &priv->led_link_off,
757 LD_TIME_LINK_ON);
758 }
759
760 spin_unlock_irqrestore(&priv->lock, flags);
761}
762
763static void ipw_bg_led_link_on(void *data)
764{
765 struct ipw_priv *priv = data;
766 down(&priv->sem);
767 ipw_led_link_on(data);
768 up(&priv->sem);
769}
770
771void ipw_led_link_off(struct ipw_priv *priv)
772{
773 unsigned long flags;
774 u32 led;
775
776 /* If configured not to use LEDs, or nic type is 1,
777 * then we don't goggle the LINK led. */
778 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
779 return;
780
781 spin_lock_irqsave(&priv->lock, flags);
782
783 if (priv->status & STATUS_LED_LINK_ON) {
784 led = ipw_read_reg32(priv, IPW_EVENT_REG);
785 led &= priv->led_association_off;
786 led = ipw_register_toggle(led);
787
788 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
789 ipw_write_reg32(priv, IPW_EVENT_REG, led);
790
791 IPW_DEBUG_LED("Link LED Off\n");
792
793 priv->status &= ~STATUS_LED_LINK_ON;
794
795 /* If we aren't associated and the radio is on, schedule
796 * turning the LED on (blink while unassociated) */
797 if (!(priv->status & STATUS_RF_KILL_MASK) &&
798 !(priv->status & STATUS_ASSOCIATED))
799 queue_delayed_work(priv->workqueue, &priv->led_link_on,
800 LD_TIME_LINK_OFF);
801
802 }
803
804 spin_unlock_irqrestore(&priv->lock, flags);
805}
806
807static void ipw_bg_led_link_off(void *data)
808{
809 struct ipw_priv *priv = data;
810 down(&priv->sem);
811 ipw_led_link_off(data);
812 up(&priv->sem);
813}
814
815static inline void __ipw_led_activity_on(struct ipw_priv *priv)
816{
817 u32 led;
818
819 if (priv->config & CFG_NO_LED)
820 return;
821
822 if (priv->status & STATUS_RF_KILL_MASK)
823 return;
824
825 if (!(priv->status & STATUS_LED_ACT_ON)) {
826 led = ipw_read_reg32(priv, IPW_EVENT_REG);
827 led |= priv->led_activity_on;
828
829 led = ipw_register_toggle(led);
830
831 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
832 ipw_write_reg32(priv, IPW_EVENT_REG, led);
833
834 IPW_DEBUG_LED("Activity LED On\n");
835
836 priv->status |= STATUS_LED_ACT_ON;
837
838 cancel_delayed_work(&priv->led_act_off);
839 queue_delayed_work(priv->workqueue, &priv->led_act_off,
840 LD_TIME_ACT_ON);
841 } else {
842 /* Reschedule LED off for full time period */
843 cancel_delayed_work(&priv->led_act_off);
844 queue_delayed_work(priv->workqueue, &priv->led_act_off,
845 LD_TIME_ACT_ON);
846 }
847}
848
849void ipw_led_activity_on(struct ipw_priv *priv)
850{
851 unsigned long flags;
852 spin_lock_irqsave(&priv->lock, flags);
853 __ipw_led_activity_on(priv);
854 spin_unlock_irqrestore(&priv->lock, flags);
855}
856
857void ipw_led_activity_off(struct ipw_priv *priv)
858{
859 unsigned long flags;
860 u32 led;
861
862 if (priv->config & CFG_NO_LED)
863 return;
864
865 spin_lock_irqsave(&priv->lock, flags);
866
867 if (priv->status & STATUS_LED_ACT_ON) {
868 led = ipw_read_reg32(priv, IPW_EVENT_REG);
869 led &= priv->led_activity_off;
870
871 led = ipw_register_toggle(led);
872
873 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
874 ipw_write_reg32(priv, IPW_EVENT_REG, led);
875
876 IPW_DEBUG_LED("Activity LED Off\n");
877
878 priv->status &= ~STATUS_LED_ACT_ON;
879 }
880
881 spin_unlock_irqrestore(&priv->lock, flags);
882}
883
884static void ipw_bg_led_activity_off(void *data)
885{
886 struct ipw_priv *priv = data;
887 down(&priv->sem);
888 ipw_led_activity_off(data);
889 up(&priv->sem);
890}
891
892void ipw_led_band_on(struct ipw_priv *priv)
893{
894 unsigned long flags;
895 u32 led;
896
897 /* Only nic type 1 supports mode LEDs */
898 if (priv->config & CFG_NO_LED ||
899 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
900 return;
901
902 spin_lock_irqsave(&priv->lock, flags);
903
904 led = ipw_read_reg32(priv, IPW_EVENT_REG);
905 if (priv->assoc_network->mode == IEEE_A) {
906 led |= priv->led_ofdm_on;
907 led &= priv->led_association_off;
908 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
909 } else if (priv->assoc_network->mode == IEEE_G) {
910 led |= priv->led_ofdm_on;
911 led |= priv->led_association_on;
912 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
913 } else {
914 led &= priv->led_ofdm_off;
915 led |= priv->led_association_on;
916 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
917 }
918
919 led = ipw_register_toggle(led);
920
921 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
922 ipw_write_reg32(priv, IPW_EVENT_REG, led);
923
924 spin_unlock_irqrestore(&priv->lock, flags);
925}
926
927void ipw_led_band_off(struct ipw_priv *priv)
928{
929 unsigned long flags;
930 u32 led;
931
932 /* Only nic type 1 supports mode LEDs */
933 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
934 return;
935
936 spin_lock_irqsave(&priv->lock, flags);
937
938 led = ipw_read_reg32(priv, IPW_EVENT_REG);
939 led &= priv->led_ofdm_off;
940 led &= priv->led_association_off;
941
942 led = ipw_register_toggle(led);
943
944 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
945 ipw_write_reg32(priv, IPW_EVENT_REG, led);
946
947 spin_unlock_irqrestore(&priv->lock, flags);
948}
949
950void ipw_led_radio_on(struct ipw_priv *priv)
951{
952 ipw_led_link_on(priv);
953}
954
955void ipw_led_radio_off(struct ipw_priv *priv)
956{
957 ipw_led_activity_off(priv);
958 ipw_led_link_off(priv);
959}
960
961void ipw_led_link_up(struct ipw_priv *priv)
962{
963 /* Set the Link Led on for all nic types */
964 ipw_led_link_on(priv);
965}
966
967void ipw_led_link_down(struct ipw_priv *priv)
968{
969 ipw_led_activity_off(priv);
970 ipw_led_link_off(priv);
971
972 if (priv->status & STATUS_RF_KILL_MASK)
973 ipw_led_radio_off(priv);
974}
975
976void ipw_led_init(struct ipw_priv *priv)
977{
978 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
979
980 /* Set the default PINs for the link and activity leds */
981 priv->led_activity_on = IPW_ACTIVITY_LED;
982 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
983
984 priv->led_association_on = IPW_ASSOCIATED_LED;
985 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
986
987 /* Set the default PINs for the OFDM leds */
988 priv->led_ofdm_on = IPW_OFDM_LED;
989 priv->led_ofdm_off = ~(IPW_OFDM_LED);
990
991 switch (priv->nic_type) {
992 case EEPROM_NIC_TYPE_1:
993 /* In this NIC type, the LEDs are reversed.... */
994 priv->led_activity_on = IPW_ASSOCIATED_LED;
995 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
996 priv->led_association_on = IPW_ACTIVITY_LED;
997 priv->led_association_off = ~(IPW_ACTIVITY_LED);
998
999 if (!(priv->config & CFG_NO_LED))
1000 ipw_led_band_on(priv);
1001
1002 /* And we don't blink link LEDs for this nic, so
1003 * just return here */
1004 return;
1005
1006 case EEPROM_NIC_TYPE_3:
1007 case EEPROM_NIC_TYPE_2:
1008 case EEPROM_NIC_TYPE_4:
1009 case EEPROM_NIC_TYPE_0:
1010 break;
1011
1012 default:
1013 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1014 priv->nic_type);
1015 priv->nic_type = EEPROM_NIC_TYPE_0;
1016 break;
1017 }
1018
1019 if (!(priv->config & CFG_NO_LED)) {
1020 if (priv->status & STATUS_ASSOCIATED)
1021 ipw_led_link_on(priv);
1022 else
1023 ipw_led_link_off(priv);
1024 }
1025}
1026
1027void ipw_led_shutdown(struct ipw_priv *priv)
1028{
1029 ipw_led_activity_off(priv);
1030 ipw_led_link_off(priv);
1031 ipw_led_band_off(priv);
1032 cancel_delayed_work(&priv->led_link_on);
1033 cancel_delayed_work(&priv->led_link_off);
1034 cancel_delayed_work(&priv->led_act_off);
1035}
1036
639/* 1037/*
640 * The following adds a new attribute to the sysfs representation 1038 * The following adds a new attribute to the sysfs representation
641 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/) 1039 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
@@ -647,8 +1045,9 @@ static ssize_t show_debug_level(struct device_driver *d, char *buf)
647{ 1045{
648 return sprintf(buf, "0x%08X\n", ipw_debug_level); 1046 return sprintf(buf, "0x%08X\n", ipw_debug_level);
649} 1047}
650static ssize_t store_debug_level(struct device_driver *d, 1048
651 const char *buf, size_t count) 1049static ssize_t store_debug_level(struct device_driver *d, const char *buf,
1050 size_t count)
652{ 1051{
653 char *p = (char *)buf; 1052 char *p = (char *)buf;
654 u32 val; 1053 u32 val;
@@ -672,75 +1071,263 @@ static ssize_t store_debug_level(struct device_driver *d,
672static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO, 1071static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
673 show_debug_level, store_debug_level); 1072 show_debug_level, store_debug_level);
674 1073
675static ssize_t show_status(struct device *d, 1074static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
676 struct device_attribute *attr, char *buf)
677{ 1075{
678 struct ipw_priv *p = d->driver_data; 1076 return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
679 return sprintf(buf, "0x%08x\n", (int)p->status);
680} 1077}
681 1078
682static DEVICE_ATTR(status, S_IRUGO, show_status, NULL); 1079static void ipw_capture_event_log(struct ipw_priv *priv,
1080 u32 log_len, struct ipw_event *log)
1081{
1082 u32 base;
683 1083
684static ssize_t show_cfg(struct device *d, struct device_attribute *attr, 1084 if (log_len) {
685 char *buf) 1085 base = ipw_read32(priv, IPW_EVENT_LOG);
1086 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1087 (u8 *) log, sizeof(*log) * log_len);
1088 }
1089}
1090
1091static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
686{ 1092{
687 struct ipw_priv *p = d->driver_data; 1093 struct ipw_fw_error *error;
688 return sprintf(buf, "0x%08x\n", (int)p->config); 1094 u32 log_len = ipw_get_event_log_len(priv);
1095 u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1096 u32 elem_len = ipw_read_reg32(priv, base);
1097
1098 error = kmalloc(sizeof(*error) +
1099 sizeof(*error->elem) * elem_len +
1100 sizeof(*error->log) * log_len, GFP_ATOMIC);
1101 if (!error) {
1102 IPW_ERROR("Memory allocation for firmware error log "
1103 "failed.\n");
1104 return NULL;
1105 }
1106 error->jiffies = jiffies;
1107 error->status = priv->status;
1108 error->config = priv->config;
1109 error->elem_len = elem_len;
1110 error->log_len = log_len;
1111 error->elem = (struct ipw_error_elem *)error->payload;
1112 error->log = (struct ipw_event *)(error->elem +
1113 (sizeof(*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;
689} 1122}
690 1123
691static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL); 1124static void ipw_free_error_log(struct ipw_fw_error *error)
1125{
1126 if (error)
1127 kfree(error);
1128}
692 1129
693static ssize_t show_nic_type(struct device *d, 1130static ssize_t show_event_log(struct device *d,
694 struct device_attribute *attr, char *buf) 1131 struct device_attribute *attr, char *buf)
695{ 1132{
696 struct ipw_priv *p = d->driver_data; 1133 struct ipw_priv *priv = dev_get_drvdata(d);
697 u8 type = p->eeprom[EEPROM_NIC_TYPE]; 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}
698 1148
699 switch (type) { 1149static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);
700 case EEPROM_NIC_TYPE_STANDARD: 1150
701 return sprintf(buf, "STANDARD\n"); 1151static ssize_t show_error(struct device *d,
702 case EEPROM_NIC_TYPE_DELL: 1152 struct device_attribute *attr, char *buf)
703 return sprintf(buf, "DELL\n"); 1153{
704 case EEPROM_NIC_TYPE_FUJITSU: 1154 struct ipw_priv *priv = dev_get_drvdata(d);
705 return sprintf(buf, "FUJITSU\n"); 1155 u32 len = 0, i;
706 case EEPROM_NIC_TYPE_IBM: 1156 if (!priv->error)
707 return sprintf(buf, "IBM\n"); 1157 return 0;
708 case EEPROM_NIC_TYPE_HP: 1158 len += snprintf(buf + len, PAGE_SIZE - len,
709 return sprintf(buf, "HP\n"); 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;
710 } 1194 }
1195 return count;
1196}
1197
1198static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);
711 1199
712 return sprintf(buf, "UNKNOWN\n"); 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;
713} 1223}
714 1224
715static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL); 1225static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);
716 1226
717static ssize_t dump_error_log(struct device *d, 1227static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
718 struct device_attribute *attr, const char *buf, 1228 char *buf)
719 size_t count)
720{ 1229{
721 char *p = (char *)buf; 1230 struct ipw_priv *priv = dev_get_drvdata(d);
1231 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1232}
722 1233
723 if (p[0] == '1') 1234static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
724 ipw_dump_nic_error_log((struct ipw_priv *)d->driver_data); 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;
725 1246
726 return strnlen(buf, count); 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;
727} 1268}
728 1269
729static DEVICE_ATTR(dump_errors, S_IWUSR, NULL, dump_error_log); 1270static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
730 1271
731static ssize_t dump_event_log(struct device *d, 1272static ssize_t show_led(struct device *d, struct device_attribute *attr,
732 struct device_attribute *attr, const char *buf, 1273 char *buf)
733 size_t count)
734{ 1274{
735 char *p = (char *)buf; 1275 struct ipw_priv *priv = dev_get_drvdata(d);
1276 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1277}
736 1278
737 if (p[0] == '1') 1279static ssize_t store_led(struct device *d, struct device_attribute *attr,
738 ipw_dump_nic_event_log((struct ipw_priv *)d->driver_data); 1280 const char *buf, size_t count)
1281{
1282 struct ipw_priv *priv = dev_get_drvdata(d);
739 1283
740 return strnlen(buf, count); 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);
741} 1310}
742 1311
743static DEVICE_ATTR(dump_events, S_IWUSR, NULL, dump_event_log); 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);
744 1331
745static ssize_t show_ucode_version(struct device *d, 1332static ssize_t show_ucode_version(struct device *d,
746 struct device_attribute *attr, char *buf) 1333 struct device_attribute *attr, char *buf)
@@ -798,7 +1385,7 @@ static ssize_t show_command_event_reg(struct device *d,
798 u32 reg = 0; 1385 u32 reg = 0;
799 struct ipw_priv *p = d->driver_data; 1386 struct ipw_priv *p = d->driver_data;
800 1387
801 reg = ipw_read_reg32(p, CX2_INTERNAL_CMD_EVENT); 1388 reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
802 return sprintf(buf, "0x%08x\n", reg); 1389 return sprintf(buf, "0x%08x\n", reg);
803} 1390}
804static ssize_t store_command_event_reg(struct device *d, 1391static ssize_t store_command_event_reg(struct device *d,
@@ -809,7 +1396,7 @@ static ssize_t store_command_event_reg(struct device *d,
809 struct ipw_priv *p = d->driver_data; 1396 struct ipw_priv *p = d->driver_data;
810 1397
811 sscanf(buf, "%x", &reg); 1398 sscanf(buf, "%x", &reg);
812 ipw_write_reg32(p, CX2_INTERNAL_CMD_EVENT, reg); 1399 ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
813 return strnlen(buf, count); 1400 return strnlen(buf, count);
814} 1401}
815 1402
@@ -845,6 +1432,7 @@ static ssize_t show_indirect_dword(struct device *d,
845{ 1432{
846 u32 reg = 0; 1433 u32 reg = 0;
847 struct ipw_priv *priv = d->driver_data; 1434 struct ipw_priv *priv = d->driver_data;
1435
848 if (priv->status & STATUS_INDIRECT_DWORD) 1436 if (priv->status & STATUS_INDIRECT_DWORD)
849 reg = ipw_read_reg32(priv, priv->indirect_dword); 1437 reg = ipw_read_reg32(priv, priv->indirect_dword);
850 else 1438 else
@@ -871,6 +1459,7 @@ static ssize_t show_indirect_byte(struct device *d,
871{ 1459{
872 u8 reg = 0; 1460 u8 reg = 0;
873 struct ipw_priv *priv = d->driver_data; 1461 struct ipw_priv *priv = d->driver_data;
1462
874 if (priv->status & STATUS_INDIRECT_BYTE) 1463 if (priv->status & STATUS_INDIRECT_BYTE)
875 reg = ipw_read_reg8(priv, priv->indirect_byte); 1464 reg = ipw_read_reg8(priv, priv->indirect_byte);
876 else 1465 else
@@ -945,7 +1534,7 @@ static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
945static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio) 1534static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
946{ 1535{
947 if ((disable_radio ? 1 : 0) == 1536 if ((disable_radio ? 1 : 0) ==
948 (priv->status & STATUS_RF_KILL_SW ? 1 : 0)) 1537 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
949 return 0; 1538 return 0;
950 1539
951 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n", 1540 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
@@ -954,10 +1543,8 @@ static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
954 if (disable_radio) { 1543 if (disable_radio) {
955 priv->status |= STATUS_RF_KILL_SW; 1544 priv->status |= STATUS_RF_KILL_SW;
956 1545
957 if (priv->workqueue) { 1546 if (priv->workqueue)
958 cancel_delayed_work(&priv->request_scan); 1547 cancel_delayed_work(&priv->request_scan);
959 }
960 wake_up_interruptible(&priv->wait_command_queue);
961 queue_work(priv->workqueue, &priv->down); 1548 queue_work(priv->workqueue, &priv->down);
962 } else { 1549 } else {
963 priv->status &= ~STATUS_RF_KILL_SW; 1550 priv->status &= ~STATUS_RF_KILL_SW;
@@ -987,6 +1574,93 @@ static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
987 1574
988static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill); 1575static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
989 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
990static void ipw_irq_tasklet(struct ipw_priv *priv) 1664static void ipw_irq_tasklet(struct ipw_priv *priv)
991{ 1665{
992 u32 inta, inta_mask, handled = 0; 1666 u32 inta, inta_mask, handled = 0;
@@ -995,102 +1669,135 @@ static void ipw_irq_tasklet(struct ipw_priv *priv)
995 1669
996 spin_lock_irqsave(&priv->lock, flags); 1670 spin_lock_irqsave(&priv->lock, flags);
997 1671
998 inta = ipw_read32(priv, CX2_INTA_RW); 1672 inta = ipw_read32(priv, IPW_INTA_RW);
999 inta_mask = ipw_read32(priv, CX2_INTA_MASK_R); 1673 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1000 inta &= (CX2_INTA_MASK_ALL & inta_mask); 1674 inta &= (IPW_INTA_MASK_ALL & inta_mask);
1001 1675
1002 /* Add any cached INTA values that need to be handled */ 1676 /* Add any cached INTA values that need to be handled */
1003 inta |= priv->isr_inta; 1677 inta |= priv->isr_inta;
1004 1678
1005 /* handle all the justifications for the interrupt */ 1679 /* handle all the justifications for the interrupt */
1006 if (inta & CX2_INTA_BIT_RX_TRANSFER) { 1680 if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1007 ipw_rx(priv); 1681 ipw_rx(priv);
1008 handled |= CX2_INTA_BIT_RX_TRANSFER; 1682 handled |= IPW_INTA_BIT_RX_TRANSFER;
1009 } 1683 }
1010 1684
1011 if (inta & CX2_INTA_BIT_TX_CMD_QUEUE) { 1685 if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1012 IPW_DEBUG_HC("Command completed.\n"); 1686 IPW_DEBUG_HC("Command completed.\n");
1013 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1); 1687 rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1014 priv->status &= ~STATUS_HCMD_ACTIVE; 1688 priv->status &= ~STATUS_HCMD_ACTIVE;
1015 wake_up_interruptible(&priv->wait_command_queue); 1689 wake_up_interruptible(&priv->wait_command_queue);
1016 handled |= CX2_INTA_BIT_TX_CMD_QUEUE; 1690 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1017 } 1691 }
1018 1692
1019 if (inta & CX2_INTA_BIT_TX_QUEUE_1) { 1693 if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
1020 IPW_DEBUG_TX("TX_QUEUE_1\n"); 1694 IPW_DEBUG_TX("TX_QUEUE_1\n");
1021 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0); 1695 rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1022 handled |= CX2_INTA_BIT_TX_QUEUE_1; 1696 handled |= IPW_INTA_BIT_TX_QUEUE_1;
1023 } 1697 }
1024 1698
1025 if (inta & CX2_INTA_BIT_TX_QUEUE_2) { 1699 if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
1026 IPW_DEBUG_TX("TX_QUEUE_2\n"); 1700 IPW_DEBUG_TX("TX_QUEUE_2\n");
1027 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1); 1701 rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1028 handled |= CX2_INTA_BIT_TX_QUEUE_2; 1702 handled |= IPW_INTA_BIT_TX_QUEUE_2;
1029 } 1703 }
1030 1704
1031 if (inta & CX2_INTA_BIT_TX_QUEUE_3) { 1705 if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
1032 IPW_DEBUG_TX("TX_QUEUE_3\n"); 1706 IPW_DEBUG_TX("TX_QUEUE_3\n");
1033 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2); 1707 rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1034 handled |= CX2_INTA_BIT_TX_QUEUE_3; 1708 handled |= IPW_INTA_BIT_TX_QUEUE_3;
1035 } 1709 }
1036 1710
1037 if (inta & CX2_INTA_BIT_TX_QUEUE_4) { 1711 if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
1038 IPW_DEBUG_TX("TX_QUEUE_4\n"); 1712 IPW_DEBUG_TX("TX_QUEUE_4\n");
1039 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3); 1713 rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
1040 handled |= CX2_INTA_BIT_TX_QUEUE_4; 1714 handled |= IPW_INTA_BIT_TX_QUEUE_4;
1041 } 1715 }
1042 1716
1043 if (inta & CX2_INTA_BIT_STATUS_CHANGE) { 1717 if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
1044 IPW_WARNING("STATUS_CHANGE\n"); 1718 IPW_WARNING("STATUS_CHANGE\n");
1045 handled |= CX2_INTA_BIT_STATUS_CHANGE; 1719 handled |= IPW_INTA_BIT_STATUS_CHANGE;
1046 } 1720 }
1047 1721
1048 if (inta & CX2_INTA_BIT_BEACON_PERIOD_EXPIRED) { 1722 if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
1049 IPW_WARNING("TX_PERIOD_EXPIRED\n"); 1723 IPW_WARNING("TX_PERIOD_EXPIRED\n");
1050 handled |= CX2_INTA_BIT_BEACON_PERIOD_EXPIRED; 1724 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
1051 } 1725 }
1052 1726
1053 if (inta & CX2_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) { 1727 if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
1054 IPW_WARNING("HOST_CMD_DONE\n"); 1728 IPW_WARNING("HOST_CMD_DONE\n");
1055 handled |= CX2_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE; 1729 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
1056 } 1730 }
1057 1731
1058 if (inta & CX2_INTA_BIT_FW_INITIALIZATION_DONE) { 1732 if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
1059 IPW_WARNING("FW_INITIALIZATION_DONE\n"); 1733 IPW_WARNING("FW_INITIALIZATION_DONE\n");
1060 handled |= CX2_INTA_BIT_FW_INITIALIZATION_DONE; 1734 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
1061 } 1735 }
1062 1736
1063 if (inta & CX2_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) { 1737 if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
1064 IPW_WARNING("PHY_OFF_DONE\n"); 1738 IPW_WARNING("PHY_OFF_DONE\n");
1065 handled |= CX2_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE; 1739 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
1066 } 1740 }
1067 1741
1068 if (inta & CX2_INTA_BIT_RF_KILL_DONE) { 1742 if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
1069 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n"); 1743 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
1070 priv->status |= STATUS_RF_KILL_HW; 1744 priv->status |= STATUS_RF_KILL_HW;
1071 wake_up_interruptible(&priv->wait_command_queue); 1745 wake_up_interruptible(&priv->wait_command_queue);
1072 netif_carrier_off(priv->net_dev); 1746 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1073 netif_stop_queue(priv->net_dev);
1074 cancel_delayed_work(&priv->request_scan); 1747 cancel_delayed_work(&priv->request_scan);
1748 schedule_work(&priv->link_down);
1075 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ); 1749 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
1076 handled |= CX2_INTA_BIT_RF_KILL_DONE; 1750 handled |= IPW_INTA_BIT_RF_KILL_DONE;
1077 } 1751 }
1078 1752
1079 if (inta & CX2_INTA_BIT_FATAL_ERROR) { 1753 if (inta & IPW_INTA_BIT_FATAL_ERROR) {
1080 IPW_ERROR("Firmware error detected. Restarting.\n"); 1754 IPW_ERROR("Firmware error detected. Restarting.\n");
1755 if (priv->error) {
1756 IPW_ERROR("Sysfs 'error' log already exists.\n");
1081#ifdef CONFIG_IPW_DEBUG 1757#ifdef CONFIG_IPW_DEBUG
1082 if (ipw_debug_level & IPW_DL_FW_ERRORS) { 1758 if (ipw_debug_level & IPW_DL_FW_ERRORS) {
1083 ipw_dump_nic_error_log(priv); 1759 struct ipw_fw_error *error =
1084 ipw_dump_nic_event_log(priv); 1760 ipw_alloc_error_log(priv);
1085 } 1761 ipw_dump_error_log(priv, error);
1762 if (error)
1763 ipw_free_error_log(error);
1764 }
1086#endif 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
1087 queue_work(priv->workqueue, &priv->adapter_restart); 1794 queue_work(priv->workqueue, &priv->adapter_restart);
1088 handled |= CX2_INTA_BIT_FATAL_ERROR; 1795 handled |= IPW_INTA_BIT_FATAL_ERROR;
1089 } 1796 }
1090 1797
1091 if (inta & CX2_INTA_BIT_PARITY_ERROR) { 1798 if (inta & IPW_INTA_BIT_PARITY_ERROR) {
1092 IPW_ERROR("Parity error\n"); 1799 IPW_ERROR("Parity error\n");
1093 handled |= CX2_INTA_BIT_PARITY_ERROR; 1800 handled |= IPW_INTA_BIT_PARITY_ERROR;
1094 } 1801 }
1095 1802
1096 if (handled != inta) { 1803 if (handled != inta) {
@@ -1103,7 +1810,6 @@ static void ipw_irq_tasklet(struct ipw_priv *priv)
1103 spin_unlock_irqrestore(&priv->lock, flags); 1810 spin_unlock_irqrestore(&priv->lock, flags);
1104} 1811}
1105 1812
1106#ifdef CONFIG_IPW_DEBUG
1107#define IPW_CMD(x) case IPW_CMD_ ## x : return #x 1813#define IPW_CMD(x) case IPW_CMD_ ## x : return #x
1108static char *get_cmd_string(u8 cmd) 1814static char *get_cmd_string(u8 cmd)
1109{ 1815{
@@ -1162,44 +1868,78 @@ static char *get_cmd_string(u8 cmd)
1162 return "UNKNOWN"; 1868 return "UNKNOWN";
1163 } 1869 }
1164} 1870}
1165#endif /* CONFIG_IPW_DEBUG */
1166 1871
1167#define HOST_COMPLETE_TIMEOUT HZ 1872#define HOST_COMPLETE_TIMEOUT HZ
1168static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd) 1873static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
1169{ 1874{
1170 int rc = 0; 1875 int rc = 0;
1876 unsigned long flags;
1171 1877
1878 spin_lock_irqsave(&priv->lock, flags);
1172 if (priv->status & STATUS_HCMD_ACTIVE) { 1879 if (priv->status & STATUS_HCMD_ACTIVE) {
1173 IPW_ERROR("Already sending a command\n"); 1880 IPW_ERROR("Failed to send %s: Already sending a command.\n",
1174 return -1; 1881 get_cmd_string(cmd->cmd));
1882 spin_unlock_irqrestore(&priv->lock, flags);
1883 return -EAGAIN;
1175 } 1884 }
1176 1885
1177 priv->status |= STATUS_HCMD_ACTIVE; 1886 priv->status |= STATUS_HCMD_ACTIVE;
1178 1887
1179 IPW_DEBUG_HC("Sending %s command (#%d), %d bytes\n", 1888 if (priv->cmdlog) {
1180 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len); 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);
1181 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len); 1900 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
1182 1901
1183 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0); 1902 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
1184 if (rc) 1903 if (rc) {
1185 return 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);
1186 1911
1187 rc = wait_event_interruptible_timeout(priv->wait_command_queue, 1912 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
1188 !(priv-> 1913 !(priv->
1189 status & STATUS_HCMD_ACTIVE), 1914 status & STATUS_HCMD_ACTIVE),
1190 HOST_COMPLETE_TIMEOUT); 1915 HOST_COMPLETE_TIMEOUT);
1191 if (rc == 0) { 1916 if (rc == 0) {
1192 IPW_DEBUG_INFO("Command completion failed out after %dms.\n", 1917 spin_lock_irqsave(&priv->lock, flags);
1193 jiffies_to_msecs(HOST_COMPLETE_TIMEOUT)); 1918 if (priv->status & STATUS_HCMD_ACTIVE) {
1194 priv->status &= ~STATUS_HCMD_ACTIVE; 1919 IPW_ERROR("Failed to send %s: Command timed out.\n",
1195 return -EIO; 1920 get_cmd_string(cmd->cmd));
1196 } 1921 priv->status &= ~STATUS_HCMD_ACTIVE;
1197 if (priv->status & STATUS_RF_KILL_MASK) { 1922 spin_unlock_irqrestore(&priv->lock, flags);
1198 IPW_DEBUG_INFO("Command aborted due to RF Kill Switch\n"); 1923 rc = -EIO;
1199 return -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;
1200 } 1935 }
1201 1936
1202 return 0; 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;
1203} 1943}
1204 1944
1205static int ipw_send_host_complete(struct ipw_priv *priv) 1945static int ipw_send_host_complete(struct ipw_priv *priv)
@@ -1214,12 +1954,7 @@ static int ipw_send_host_complete(struct ipw_priv *priv)
1214 return -1; 1954 return -1;
1215 } 1955 }
1216 1956
1217 if (ipw_send_cmd(priv, &cmd)) { 1957 return ipw_send_cmd(priv, &cmd);
1218 IPW_ERROR("failed to send HOST_COMPLETE command\n");
1219 return -1;
1220 }
1221
1222 return 0;
1223} 1958}
1224 1959
1225static int ipw_send_system_config(struct ipw_priv *priv, 1960static int ipw_send_system_config(struct ipw_priv *priv,
@@ -1235,13 +1970,8 @@ static int ipw_send_system_config(struct ipw_priv *priv,
1235 return -1; 1970 return -1;
1236 } 1971 }
1237 1972
1238 memcpy(&cmd.param, config, sizeof(*config)); 1973 memcpy(cmd.param, config, sizeof(*config));
1239 if (ipw_send_cmd(priv, &cmd)) { 1974 return ipw_send_cmd(priv, &cmd);
1240 IPW_ERROR("failed to send SYSTEM_CONFIG command\n");
1241 return -1;
1242 }
1243
1244 return 0;
1245} 1975}
1246 1976
1247static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len) 1977static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
@@ -1256,13 +1986,8 @@ static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
1256 return -1; 1986 return -1;
1257 } 1987 }
1258 1988
1259 memcpy(&cmd.param, ssid, cmd.len); 1989 memcpy(cmd.param, ssid, cmd.len);
1260 if (ipw_send_cmd(priv, &cmd)) { 1990 return ipw_send_cmd(priv, &cmd);
1261 IPW_ERROR("failed to send SSID command\n");
1262 return -1;
1263 }
1264
1265 return 0;
1266} 1991}
1267 1992
1268static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac) 1993static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
@@ -1280,16 +2005,15 @@ static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
1280 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n", 2005 IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
1281 priv->net_dev->name, MAC_ARG(mac)); 2006 priv->net_dev->name, MAC_ARG(mac));
1282 2007
1283 memcpy(&cmd.param, mac, ETH_ALEN); 2008 memcpy(cmd.param, mac, ETH_ALEN);
1284 2009 return ipw_send_cmd(priv, &cmd);
1285 if (ipw_send_cmd(priv, &cmd)) {
1286 IPW_ERROR("failed to send ADAPTER_ADDRESS command\n");
1287 return -1;
1288 }
1289
1290 return 0;
1291} 2010}
1292 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 */
1293static void ipw_adapter_restart(void *adapter) 2017static void ipw_adapter_restart(void *adapter)
1294{ 2018{
1295 struct ipw_priv *priv = adapter; 2019 struct ipw_priv *priv = adapter;
@@ -1298,12 +2022,25 @@ static void ipw_adapter_restart(void *adapter)
1298 return; 2022 return;
1299 2023
1300 ipw_down(priv); 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
1301 if (ipw_up(priv)) { 2030 if (ipw_up(priv)) {
1302 IPW_ERROR("Failed to up device\n"); 2031 IPW_ERROR("Failed to up device\n");
1303 return; 2032 return;
1304 } 2033 }
1305} 2034}
1306 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
1307#define IPW_SCAN_CHECK_WATCHDOG (5 * HZ) 2044#define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
1308 2045
1309static void ipw_scan_check(void *data) 2046static void ipw_scan_check(void *data)
@@ -1313,10 +2050,18 @@ static void ipw_scan_check(void *data)
1313 IPW_DEBUG_SCAN("Scan completion watchdog resetting " 2050 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
1314 "adapter (%dms).\n", 2051 "adapter (%dms).\n",
1315 IPW_SCAN_CHECK_WATCHDOG / 100); 2052 IPW_SCAN_CHECK_WATCHDOG / 100);
1316 ipw_adapter_restart(priv); 2053 queue_work(priv->workqueue, &priv->adapter_restart);
1317 } 2054 }
1318} 2055}
1319 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
1320static int ipw_send_scan_request_ext(struct ipw_priv *priv, 2065static int ipw_send_scan_request_ext(struct ipw_priv *priv,
1321 struct ipw_scan_request_ext *request) 2066 struct ipw_scan_request_ext *request)
1322{ 2067{
@@ -1325,20 +2070,8 @@ static int ipw_send_scan_request_ext(struct ipw_priv *priv,
1325 .len = sizeof(*request) 2070 .len = sizeof(*request)
1326 }; 2071 };
1327 2072
1328 if (!priv || !request) { 2073 memcpy(cmd.param, request, sizeof(*request));
1329 IPW_ERROR("Invalid args\n"); 2074 return ipw_send_cmd(priv, &cmd);
1330 return -1;
1331 }
1332
1333 memcpy(&cmd.param, request, sizeof(*request));
1334 if (ipw_send_cmd(priv, &cmd)) {
1335 IPW_ERROR("failed to send SCAN_REQUEST_EXT command\n");
1336 return -1;
1337 }
1338
1339 queue_delayed_work(priv->workqueue, &priv->scan_check,
1340 IPW_SCAN_CHECK_WATCHDOG);
1341 return 0;
1342} 2075}
1343 2076
1344static int ipw_send_scan_abort(struct ipw_priv *priv) 2077static int ipw_send_scan_abort(struct ipw_priv *priv)
@@ -1353,12 +2086,7 @@ static int ipw_send_scan_abort(struct ipw_priv *priv)
1353 return -1; 2086 return -1;
1354 } 2087 }
1355 2088
1356 if (ipw_send_cmd(priv, &cmd)) { 2089 return ipw_send_cmd(priv, &cmd);
1357 IPW_ERROR("failed to send SCAN_ABORT command\n");
1358 return -1;
1359 }
1360
1361 return 0;
1362} 2090}
1363 2091
1364static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens) 2092static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
@@ -1370,12 +2098,7 @@ static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
1370 struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *) 2098 struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
1371 &cmd.param; 2099 &cmd.param;
1372 calib->beacon_rssi_raw = sens; 2100 calib->beacon_rssi_raw = sens;
1373 if (ipw_send_cmd(priv, &cmd)) { 2101 return ipw_send_cmd(priv, &cmd);
1374 IPW_ERROR("failed to send SENSITIVITY CALIB command\n");
1375 return -1;
1376 }
1377
1378 return 0;
1379} 2102}
1380 2103
1381static int ipw_send_associate(struct ipw_priv *priv, 2104static int ipw_send_associate(struct ipw_priv *priv,
@@ -1386,18 +2109,26 @@ static int ipw_send_associate(struct ipw_priv *priv,
1386 .len = sizeof(*associate) 2109 .len = sizeof(*associate)
1387 }; 2110 };
1388 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
1389 if (!priv || !associate) { 2125 if (!priv || !associate) {
1390 IPW_ERROR("Invalid args\n"); 2126 IPW_ERROR("Invalid args\n");
1391 return -1; 2127 return -1;
1392 } 2128 }
1393 2129
1394 memcpy(&cmd.param, associate, sizeof(*associate)); 2130 memcpy(cmd.param, &tmp_associate, sizeof(*associate));
1395 if (ipw_send_cmd(priv, &cmd)) { 2131 return ipw_send_cmd(priv, &cmd);
1396 IPW_ERROR("failed to send ASSOCIATE command\n");
1397 return -1;
1398 }
1399
1400 return 0;
1401} 2132}
1402 2133
1403static int ipw_send_supported_rates(struct ipw_priv *priv, 2134static int ipw_send_supported_rates(struct ipw_priv *priv,
@@ -1413,13 +2144,8 @@ static int ipw_send_supported_rates(struct ipw_priv *priv,
1413 return -1; 2144 return -1;
1414 } 2145 }
1415 2146
1416 memcpy(&cmd.param, rates, sizeof(*rates)); 2147 memcpy(cmd.param, rates, sizeof(*rates));
1417 if (ipw_send_cmd(priv, &cmd)) { 2148 return ipw_send_cmd(priv, &cmd);
1418 IPW_ERROR("failed to send SUPPORTED_RATES command\n");
1419 return -1;
1420 }
1421
1422 return 0;
1423} 2149}
1424 2150
1425static int ipw_set_random_seed(struct ipw_priv *priv) 2151static int ipw_set_random_seed(struct ipw_priv *priv)
@@ -1436,15 +2162,9 @@ static int ipw_set_random_seed(struct ipw_priv *priv)
1436 2162
1437 get_random_bytes(&cmd.param, sizeof(u32)); 2163 get_random_bytes(&cmd.param, sizeof(u32));
1438 2164
1439 if (ipw_send_cmd(priv, &cmd)) { 2165 return ipw_send_cmd(priv, &cmd);
1440 IPW_ERROR("failed to send SEED_NUMBER command\n");
1441 return -1;
1442 }
1443
1444 return 0;
1445} 2166}
1446 2167
1447#if 0
1448static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off) 2168static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
1449{ 2169{
1450 struct host_cmd cmd = { 2170 struct host_cmd cmd = {
@@ -1459,14 +2179,8 @@ static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
1459 2179
1460 *((u32 *) & cmd.param) = phy_off; 2180 *((u32 *) & cmd.param) = phy_off;
1461 2181
1462 if (ipw_send_cmd(priv, &cmd)) { 2182 return ipw_send_cmd(priv, &cmd);
1463 IPW_ERROR("failed to send CARD_DISABLE command\n");
1464 return -1;
1465 }
1466
1467 return 0;
1468} 2183}
1469#endif
1470 2184
1471static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power) 2185static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
1472{ 2186{
@@ -1480,12 +2194,51 @@ static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
1480 return -1; 2194 return -1;
1481 } 2195 }
1482 2196
1483 memcpy(&cmd.param, power, sizeof(*power)); 2197 memcpy(cmd.param, power, sizeof(*power));
1484 if (ipw_send_cmd(priv, &cmd)) { 2198 return ipw_send_cmd(priv, &cmd);
1485 IPW_ERROR("failed to send TX_POWER command\n"); 2199}
1486 return -1; 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;
1487 } 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;
1488 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 }
1489 return 0; 2242 return 0;
1490} 2243}
1491 2244
@@ -1504,13 +2257,8 @@ static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
1504 return -1; 2257 return -1;
1505 } 2258 }
1506 2259
1507 memcpy(&cmd.param, &rts_threshold, sizeof(rts_threshold)); 2260 memcpy(cmd.param, &rts_threshold, sizeof(rts_threshold));
1508 if (ipw_send_cmd(priv, &cmd)) { 2261 return ipw_send_cmd(priv, &cmd);
1509 IPW_ERROR("failed to send RTS_THRESHOLD command\n");
1510 return -1;
1511 }
1512
1513 return 0;
1514} 2262}
1515 2263
1516static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag) 2264static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
@@ -1528,13 +2276,8 @@ static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
1528 return -1; 2276 return -1;
1529 } 2277 }
1530 2278
1531 memcpy(&cmd.param, &frag_threshold, sizeof(frag_threshold)); 2279 memcpy(cmd.param, &frag_threshold, sizeof(frag_threshold));
1532 if (ipw_send_cmd(priv, &cmd)) { 2280 return ipw_send_cmd(priv, &cmd);
1533 IPW_ERROR("failed to send FRAG_THRESHOLD command\n");
1534 return -1;
1535 }
1536
1537 return 0;
1538} 2281}
1539 2282
1540static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode) 2283static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
@@ -1564,12 +2307,27 @@ static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
1564 break; 2307 break;
1565 } 2308 }
1566 2309
1567 if (ipw_send_cmd(priv, &cmd)) { 2310 return ipw_send_cmd(priv, &cmd);
1568 IPW_ERROR("failed to send POWER_MODE command\n"); 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");
1569 return -1; 2326 return -1;
1570 } 2327 }
1571 2328
1572 return 0; 2329 memcpy(cmd.param, &retry_limit, sizeof(retry_limit));
2330 return ipw_send_cmd(priv, &cmd);
1573} 2331}
1574 2332
1575/* 2333/*
@@ -1671,8 +2429,7 @@ static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
1671/* data's copy of the eeprom data */ 2429/* data's copy of the eeprom data */
1672static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac) 2430static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
1673{ 2431{
1674 u8 *ee = (u8 *) priv->eeprom; 2432 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
1675 memcpy(mac, &ee[EEPROM_MAC_ADDRESS], 6);
1676} 2433}
1677 2434
1678/* 2435/*
@@ -1692,7 +2449,7 @@ static void ipw_eeprom_init_sram(struct ipw_priv *priv)
1692 2449
1693 /* read entire contents of eeprom into private buffer */ 2450 /* read entire contents of eeprom into private buffer */
1694 for (i = 0; i < 128; i++) 2451 for (i = 0; i < 128; i++)
1695 eeprom[i] = eeprom_read_u16(priv, (u8) i); 2452 eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
1696 2453
1697 /* 2454 /*
1698 If the data looks correct, then copy it to our private 2455 If the data looks correct, then copy it to our private
@@ -1703,7 +2460,7 @@ static void ipw_eeprom_init_sram(struct ipw_priv *priv)
1703 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n"); 2460 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
1704 2461
1705 /* write the eeprom data to sram */ 2462 /* write the eeprom data to sram */
1706 for (i = 0; i < CX2_EEPROM_IMAGE_SIZE; i++) 2463 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
1707 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]); 2464 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
1708 2465
1709 /* Do not load eeprom data on fatal error or suspend */ 2466 /* Do not load eeprom data on fatal error or suspend */
@@ -1723,14 +2480,14 @@ static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
1723 count >>= 2; 2480 count >>= 2;
1724 if (!count) 2481 if (!count)
1725 return; 2482 return;
1726 _ipw_write32(priv, CX2_AUTOINC_ADDR, start); 2483 _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
1727 while (count--) 2484 while (count--)
1728 _ipw_write32(priv, CX2_AUTOINC_DATA, 0); 2485 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
1729} 2486}
1730 2487
1731static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv) 2488static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
1732{ 2489{
1733 ipw_zero_memory(priv, CX2_SHARED_SRAM_DMA_CONTROL, 2490 ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
1734 CB_NUMBER_OF_ELEMENTS_SMALL * 2491 CB_NUMBER_OF_ELEMENTS_SMALL *
1735 sizeof(struct command_block)); 2492 sizeof(struct command_block));
1736} 2493}
@@ -1744,7 +2501,7 @@ static int ipw_fw_dma_enable(struct ipw_priv *priv)
1744 ipw_fw_dma_reset_command_blocks(priv); 2501 ipw_fw_dma_reset_command_blocks(priv);
1745 2502
1746 /* Write CB base address */ 2503 /* Write CB base address */
1747 ipw_write_reg32(priv, CX2_DMA_I_CB_BASE, CX2_SHARED_SRAM_DMA_CONTROL); 2504 ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
1748 2505
1749 IPW_DEBUG_FW("<< : \n"); 2506 IPW_DEBUG_FW("<< : \n");
1750 return 0; 2507 return 0;
@@ -1758,7 +2515,7 @@ static void ipw_fw_dma_abort(struct ipw_priv *priv)
1758 2515
1759 //set the Stop and Abort bit 2516 //set the Stop and Abort bit
1760 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT; 2517 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
1761 ipw_write_reg32(priv, CX2_DMA_I_DMA_CONTROL, control); 2518 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
1762 priv->sram_desc.last_cb_index = 0; 2519 priv->sram_desc.last_cb_index = 0;
1763 2520
1764 IPW_DEBUG_FW("<< \n"); 2521 IPW_DEBUG_FW("<< \n");
@@ -1768,7 +2525,7 @@ static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
1768 struct command_block *cb) 2525 struct command_block *cb)
1769{ 2526{
1770 u32 address = 2527 u32 address =
1771 CX2_SHARED_SRAM_DMA_CONTROL + 2528 IPW_SHARED_SRAM_DMA_CONTROL +
1772 (sizeof(struct command_block) * index); 2529 (sizeof(struct command_block) * index);
1773 IPW_DEBUG_FW(">> :\n"); 2530 IPW_DEBUG_FW(">> :\n");
1774 2531
@@ -1792,13 +2549,13 @@ static int ipw_fw_dma_kick(struct ipw_priv *priv)
1792 &priv->sram_desc.cb_list[index]); 2549 &priv->sram_desc.cb_list[index]);
1793 2550
1794 /* Enable the DMA in the CSR register */ 2551 /* Enable the DMA in the CSR register */
1795 ipw_clear_bit(priv, CX2_RESET_REG, 2552 ipw_clear_bit(priv, IPW_RESET_REG,
1796 CX2_RESET_REG_MASTER_DISABLED | 2553 IPW_RESET_REG_MASTER_DISABLED |
1797 CX2_RESET_REG_STOP_MASTER); 2554 IPW_RESET_REG_STOP_MASTER);
1798 2555
1799 /* Set the Start bit. */ 2556 /* Set the Start bit. */
1800 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START; 2557 control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
1801 ipw_write_reg32(priv, CX2_DMA_I_DMA_CONTROL, control); 2558 ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
1802 2559
1803 IPW_DEBUG_FW("<< :\n"); 2560 IPW_DEBUG_FW("<< :\n");
1804 return 0; 2561 return 0;
@@ -1811,12 +2568,12 @@ static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
1811 u32 cb_fields_address = 0; 2568 u32 cb_fields_address = 0;
1812 2569
1813 IPW_DEBUG_FW(">> :\n"); 2570 IPW_DEBUG_FW(">> :\n");
1814 address = ipw_read_reg32(priv, CX2_DMA_I_CURRENT_CB); 2571 address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
1815 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address); 2572 IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
1816 2573
1817 /* Read the DMA Controlor register */ 2574 /* Read the DMA Controlor register */
1818 register_value = ipw_read_reg32(priv, CX2_DMA_I_DMA_CONTROL); 2575 register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
1819 IPW_DEBUG_FW_INFO("CX2_DMA_I_DMA_CONTROL is 0x%x \n", register_value); 2576 IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
1820 2577
1821 /* Print the CB values */ 2578 /* Print the CB values */
1822 cb_fields_address = address; 2579 cb_fields_address = address;
@@ -1845,9 +2602,9 @@ static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
1845 u32 current_cb_index = 0; 2602 u32 current_cb_index = 0;
1846 2603
1847 IPW_DEBUG_FW("<< :\n"); 2604 IPW_DEBUG_FW("<< :\n");
1848 current_cb_address = ipw_read_reg32(priv, CX2_DMA_I_CURRENT_CB); 2605 current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
1849 2606
1850 current_cb_index = (current_cb_address - CX2_SHARED_SRAM_DMA_CONTROL) / 2607 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
1851 sizeof(struct command_block); 2608 sizeof(struct command_block);
1852 2609
1853 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n", 2610 IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
@@ -1976,8 +2733,8 @@ static int ipw_fw_dma_wait(struct ipw_priv *priv)
1976 ipw_fw_dma_abort(priv); 2733 ipw_fw_dma_abort(priv);
1977 2734
1978 /*Disable the DMA in the CSR register */ 2735 /*Disable the DMA in the CSR register */
1979 ipw_set_bit(priv, CX2_RESET_REG, 2736 ipw_set_bit(priv, IPW_RESET_REG,
1980 CX2_RESET_REG_MASTER_DISABLED | CX2_RESET_REG_STOP_MASTER); 2737 IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
1981 2738
1982 IPW_DEBUG_FW("<< dmaWaitSync \n"); 2739 IPW_DEBUG_FW("<< dmaWaitSync \n");
1983 return 0; 2740 return 0;
@@ -1987,6 +2744,9 @@ static void ipw_remove_current_network(struct ipw_priv *priv)
1987{ 2744{
1988 struct list_head *element, *safe; 2745 struct list_head *element, *safe;
1989 struct ieee80211_network *network = NULL; 2746 struct ieee80211_network *network = NULL;
2747 unsigned long flags;
2748
2749 spin_lock_irqsave(&priv->ieee->lock, flags);
1990 list_for_each_safe(element, safe, &priv->ieee->network_list) { 2750 list_for_each_safe(element, safe, &priv->ieee->network_list) {
1991 network = list_entry(element, struct ieee80211_network, list); 2751 network = list_entry(element, struct ieee80211_network, list);
1992 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) { 2752 if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
@@ -1995,6 +2755,7 @@ static void ipw_remove_current_network(struct ipw_priv *priv)
1995 &priv->ieee->network_free_list); 2755 &priv->ieee->network_free_list);
1996 } 2756 }
1997 } 2757 }
2758 spin_unlock_irqrestore(&priv->ieee->lock, flags);
1998} 2759}
1999 2760
2000/** 2761/**
@@ -2037,10 +2798,10 @@ static int ipw_stop_master(struct ipw_priv *priv)
2037 2798
2038 IPW_DEBUG_TRACE(">> \n"); 2799 IPW_DEBUG_TRACE(">> \n");
2039 /* stop master. typical delay - 0 */ 2800 /* stop master. typical delay - 0 */
2040 ipw_set_bit(priv, CX2_RESET_REG, CX2_RESET_REG_STOP_MASTER); 2801 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2041 2802
2042 rc = ipw_poll_bit(priv, CX2_RESET_REG, 2803 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2043 CX2_RESET_REG_MASTER_DISABLED, 100); 2804 IPW_RESET_REG_MASTER_DISABLED, 100);
2044 if (rc < 0) { 2805 if (rc < 0) {
2045 IPW_ERROR("stop master failed in 10ms\n"); 2806 IPW_ERROR("stop master failed in 10ms\n");
2046 return -1; 2807 return -1;
@@ -2056,7 +2817,7 @@ static void ipw_arc_release(struct ipw_priv *priv)
2056 IPW_DEBUG_TRACE(">> \n"); 2817 IPW_DEBUG_TRACE(">> \n");
2057 mdelay(5); 2818 mdelay(5);
2058 2819
2059 ipw_clear_bit(priv, CX2_RESET_REG, CBD_RESET_REG_PRINCETON_RESET); 2820 ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2060 2821
2061 /* no one knows timing, for safety add some delay */ 2822 /* no one knows timing, for safety add some delay */
2062 mdelay(5); 2823 mdelay(5);
@@ -2073,13 +2834,12 @@ struct fw_chunk {
2073}; 2834};
2074 2835
2075#define IPW_FW_MAJOR_VERSION 2 2836#define IPW_FW_MAJOR_VERSION 2
2076#define IPW_FW_MINOR_VERSION 2 2837#define IPW_FW_MINOR_VERSION 4
2077 2838
2078#define IPW_FW_MINOR(x) ((x & 0xff) >> 8) 2839#define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2079#define IPW_FW_MAJOR(x) (x & 0xff) 2840#define IPW_FW_MAJOR(x) (x & 0xff)
2080 2841
2081#define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | \ 2842#define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2082 IPW_FW_MAJOR_VERSION)
2083 2843
2084#define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \ 2844#define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2085"." __stringify(IPW_FW_MINOR_VERSION) "-" 2845"." __stringify(IPW_FW_MINOR_VERSION) "-"
@@ -2107,8 +2867,8 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2107 2867
2108// spin_lock_irqsave(&priv->lock, flags); 2868// spin_lock_irqsave(&priv->lock, flags);
2109 2869
2110 for (addr = CX2_SHARED_LOWER_BOUND; 2870 for (addr = IPW_SHARED_LOWER_BOUND;
2111 addr < CX2_REGISTER_DOMAIN1_END; addr += 4) { 2871 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2112 ipw_write32(priv, addr, 0); 2872 ipw_write32(priv, addr, 0);
2113 } 2873 }
2114 2874
@@ -2117,16 +2877,16 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2117 /* destroy DMA queues */ 2877 /* destroy DMA queues */
2118 /* reset sequence */ 2878 /* reset sequence */
2119 2879
2120 ipw_write_reg32(priv, CX2_MEM_HALT_AND_RESET, CX2_BIT_HALT_RESET_ON); 2880 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2121 ipw_arc_release(priv); 2881 ipw_arc_release(priv);
2122 ipw_write_reg32(priv, CX2_MEM_HALT_AND_RESET, CX2_BIT_HALT_RESET_OFF); 2882 ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2123 mdelay(1); 2883 mdelay(1);
2124 2884
2125 /* reset PHY */ 2885 /* reset PHY */
2126 ipw_write_reg32(priv, CX2_INTERNAL_CMD_EVENT, CX2_BASEBAND_POWER_DOWN); 2886 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2127 mdelay(1); 2887 mdelay(1);
2128 2888
2129 ipw_write_reg32(priv, CX2_INTERNAL_CMD_EVENT, 0); 2889 ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2130 mdelay(1); 2890 mdelay(1);
2131 2891
2132 /* enable ucode store */ 2892 /* enable ucode store */
@@ -2144,18 +2904,19 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2144 */ 2904 */
2145 /* load new ipw uCode */ 2905 /* load new ipw uCode */
2146 for (i = 0; i < len / 2; i++) 2906 for (i = 0; i < len / 2; i++)
2147 ipw_write_reg16(priv, CX2_BASEBAND_CONTROL_STORE, image[i]); 2907 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2908 cpu_to_le16(image[i]));
2148 2909
2149 /* enable DINO */ 2910 /* enable DINO */
2150 ipw_write_reg8(priv, CX2_BASEBAND_CONTROL_STATUS, 0); 2911 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2151 ipw_write_reg8(priv, CX2_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM); 2912 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2152 2913
2153 /* this is where the igx / win driver deveates from the VAP driver. */ 2914 /* this is where the igx / win driver deveates from the VAP driver. */
2154 2915
2155 /* wait for alive response */ 2916 /* wait for alive response */
2156 for (i = 0; i < 100; i++) { 2917 for (i = 0; i < 100; i++) {
2157 /* poll for incoming data */ 2918 /* poll for incoming data */
2158 cr = ipw_read_reg8(priv, CX2_BASEBAND_CONTROL_STATUS); 2919 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2159 if (cr & DINO_RXFIFO_DATA) 2920 if (cr & DINO_RXFIFO_DATA)
2160 break; 2921 break;
2161 mdelay(1); 2922 mdelay(1);
@@ -2167,7 +2928,8 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2167 2928
2168 for (i = 0; i < ARRAY_SIZE(response_buffer); i++) 2929 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2169 response_buffer[i] = 2930 response_buffer[i] =
2170 ipw_read_reg32(priv, CX2_BASEBAND_RX_FIFO_READ); 2931 le32_to_cpu(ipw_read_reg32(priv,
2932 IPW_BASEBAND_RX_FIFO_READ));
2171 memcpy(&priv->dino_alive, response_buffer, 2933 memcpy(&priv->dino_alive, response_buffer,
2172 sizeof(priv->dino_alive)); 2934 sizeof(priv->dino_alive));
2173 if (priv->dino_alive.alive_command == 1 2935 if (priv->dino_alive.alive_command == 1
@@ -2196,7 +2958,7 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2196 2958
2197 /* disable DINO, otherwise for some reason 2959 /* disable DINO, otherwise for some reason
2198 firmware have problem getting alive resp. */ 2960 firmware have problem getting alive resp. */
2199 ipw_write_reg8(priv, CX2_BASEBAND_CONTROL_STATUS, 0); 2961 ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2200 2962
2201// spin_unlock_irqrestore(&priv->lock, flags); 2963// spin_unlock_irqrestore(&priv->lock, flags);
2202 2964
@@ -2236,13 +2998,14 @@ static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
2236 * offeset*/ 2998 * offeset*/
2237 /* Dma loading */ 2999 /* Dma loading */
2238 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset, 3000 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
2239 chunk->address, chunk->length); 3001 le32_to_cpu(chunk->address),
3002 le32_to_cpu(chunk->length));
2240 if (rc) { 3003 if (rc) {
2241 IPW_DEBUG_INFO("dmaAddBuffer Failed\n"); 3004 IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
2242 goto out; 3005 goto out;
2243 } 3006 }
2244 3007
2245 offset += chunk->length; 3008 offset += le32_to_cpu(chunk->length);
2246 } while (offset < len); 3009 } while (offset < len);
2247 3010
2248 /* Run the DMA and wait for the answer */ 3011 /* Run the DMA and wait for the answer */
@@ -2268,16 +3031,16 @@ static int ipw_stop_nic(struct ipw_priv *priv)
2268 int rc = 0; 3031 int rc = 0;
2269 3032
2270 /* stop */ 3033 /* stop */
2271 ipw_write32(priv, CX2_RESET_REG, CX2_RESET_REG_STOP_MASTER); 3034 ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2272 3035
2273 rc = ipw_poll_bit(priv, CX2_RESET_REG, 3036 rc = ipw_poll_bit(priv, IPW_RESET_REG,
2274 CX2_RESET_REG_MASTER_DISABLED, 500); 3037 IPW_RESET_REG_MASTER_DISABLED, 500);
2275 if (rc < 0) { 3038 if (rc < 0) {
2276 IPW_ERROR("wait for reg master disabled failed\n"); 3039 IPW_ERROR("wait for reg master disabled failed\n");
2277 return rc; 3040 return rc;
2278 } 3041 }
2279 3042
2280 ipw_set_bit(priv, CX2_RESET_REG, CBD_RESET_REG_PRINCETON_RESET); 3043 ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
2281 3044
2282 return rc; 3045 return rc;
2283} 3046}
@@ -2287,14 +3050,14 @@ static void ipw_start_nic(struct ipw_priv *priv)
2287 IPW_DEBUG_TRACE(">>\n"); 3050 IPW_DEBUG_TRACE(">>\n");
2288 3051
2289 /* prvHwStartNic release ARC */ 3052 /* prvHwStartNic release ARC */
2290 ipw_clear_bit(priv, CX2_RESET_REG, 3053 ipw_clear_bit(priv, IPW_RESET_REG,
2291 CX2_RESET_REG_MASTER_DISABLED | 3054 IPW_RESET_REG_MASTER_DISABLED |
2292 CX2_RESET_REG_STOP_MASTER | 3055 IPW_RESET_REG_STOP_MASTER |
2293 CBD_RESET_REG_PRINCETON_RESET); 3056 CBD_RESET_REG_PRINCETON_RESET);
2294 3057
2295 /* enable power management */ 3058 /* enable power management */
2296 ipw_set_bit(priv, CX2_GP_CNTRL_RW, 3059 ipw_set_bit(priv, IPW_GP_CNTRL_RW,
2297 CX2_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY); 3060 IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
2298 3061
2299 IPW_DEBUG_TRACE("<<\n"); 3062 IPW_DEBUG_TRACE("<<\n");
2300} 3063}
@@ -2307,25 +3070,25 @@ static int ipw_init_nic(struct ipw_priv *priv)
2307 /* reset */ 3070 /* reset */
2308 /*prvHwInitNic */ 3071 /*prvHwInitNic */
2309 /* set "initialization complete" bit to move adapter to D0 state */ 3072 /* set "initialization complete" bit to move adapter to D0 state */
2310 ipw_set_bit(priv, CX2_GP_CNTRL_RW, CX2_GP_CNTRL_BIT_INIT_DONE); 3073 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
2311 3074
2312 /* low-level PLL activation */ 3075 /* low-level PLL activation */
2313 ipw_write32(priv, CX2_READ_INT_REGISTER, 3076 ipw_write32(priv, IPW_READ_INT_REGISTER,
2314 CX2_BIT_INT_HOST_SRAM_READ_INT_REGISTER); 3077 IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
2315 3078
2316 /* wait for clock stabilization */ 3079 /* wait for clock stabilization */
2317 rc = ipw_poll_bit(priv, CX2_GP_CNTRL_RW, 3080 rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
2318 CX2_GP_CNTRL_BIT_CLOCK_READY, 250); 3081 IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
2319 if (rc < 0) 3082 if (rc < 0)
2320 IPW_DEBUG_INFO("FAILED wait for clock stablization\n"); 3083 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
2321 3084
2322 /* assert SW reset */ 3085 /* assert SW reset */
2323 ipw_set_bit(priv, CX2_RESET_REG, CX2_RESET_REG_SW_RESET); 3086 ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
2324 3087
2325 udelay(10); 3088 udelay(10);
2326 3089
2327 /* set "initialization complete" bit to move adapter to D0 state */ 3090 /* set "initialization complete" bit to move adapter to D0 state */
2328 ipw_set_bit(priv, CX2_GP_CNTRL_RW, CX2_GP_CNTRL_BIT_INIT_DONE); 3091 ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
2329 3092
2330 IPW_DEBUG_TRACE(">>\n"); 3093 IPW_DEBUG_TRACE(">>\n");
2331 return 0; 3094 return 0;
@@ -2337,14 +3100,19 @@ static int ipw_init_nic(struct ipw_priv *priv)
2337static int ipw_reset_nic(struct ipw_priv *priv) 3100static int ipw_reset_nic(struct ipw_priv *priv)
2338{ 3101{
2339 int rc = 0; 3102 int rc = 0;
3103 unsigned long flags;
2340 3104
2341 IPW_DEBUG_TRACE(">>\n"); 3105 IPW_DEBUG_TRACE(">>\n");
2342 3106
2343 rc = ipw_init_nic(priv); 3107 rc = ipw_init_nic(priv);
2344 3108
3109 spin_lock_irqsave(&priv->lock, flags);
2345 /* Clear the 'host command active' bit... */ 3110 /* Clear the 'host command active' bit... */
2346 priv->status &= ~STATUS_HCMD_ACTIVE; 3111 priv->status &= ~STATUS_HCMD_ACTIVE;
2347 wake_up_interruptible(&priv->wait_command_queue); 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);
2348 3116
2349 IPW_DEBUG_TRACE("<<\n"); 3117 IPW_DEBUG_TRACE("<<\n");
2350 return rc; 3118 return rc;
@@ -2364,22 +3132,23 @@ static int ipw_get_fw(struct ipw_priv *priv,
2364 } 3132 }
2365 3133
2366 header = (struct fw_header *)(*fw)->data; 3134 header = (struct fw_header *)(*fw)->data;
2367 if (IPW_FW_MAJOR(header->version) != IPW_FW_MAJOR_VERSION) { 3135 if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
2368 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n", 3136 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
2369 name, 3137 name,
2370 IPW_FW_MAJOR(header->version), IPW_FW_MAJOR_VERSION); 3138 IPW_FW_MAJOR(le32_to_cpu(header->version)),
3139 IPW_FW_MAJOR_VERSION);
2371 return -EINVAL; 3140 return -EINVAL;
2372 } 3141 }
2373 3142
2374 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n", 3143 IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
2375 name, 3144 name,
2376 IPW_FW_MAJOR(header->version), 3145 IPW_FW_MAJOR(le32_to_cpu(header->version)),
2377 IPW_FW_MINOR(header->version), 3146 IPW_FW_MINOR(le32_to_cpu(header->version)),
2378 (*fw)->size - sizeof(struct fw_header)); 3147 (*fw)->size - sizeof(struct fw_header));
2379 return 0; 3148 return 0;
2380} 3149}
2381 3150
2382#define CX2_RX_BUF_SIZE (3000) 3151#define IPW_RX_BUF_SIZE (3000)
2383 3152
2384static inline void ipw_rx_queue_reset(struct ipw_priv *priv, 3153static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
2385 struct ipw_rx_queue *rxq) 3154 struct ipw_rx_queue *rxq)
@@ -2398,8 +3167,9 @@ static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
2398 * to an SKB, so we need to unmap and free potential storage */ 3167 * to an SKB, so we need to unmap and free potential storage */
2399 if (rxq->pool[i].skb != NULL) { 3168 if (rxq->pool[i].skb != NULL) {
2400 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr, 3169 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
2401 CX2_RX_BUF_SIZE, PCI_DMA_FROMDEVICE); 3170 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
2402 dev_kfree_skb(rxq->pool[i].skb); 3171 dev_kfree_skb(rxq->pool[i].skb);
3172 rxq->pool[i].skb = NULL;
2403 } 3173 }
2404 list_add_tail(&rxq->pool[i].list, &rxq->rx_used); 3174 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
2405 } 3175 }
@@ -2417,6 +3187,19 @@ static int fw_loaded = 0;
2417static const struct firmware *bootfw = NULL; 3187static const struct firmware *bootfw = NULL;
2418static const struct firmware *firmware = NULL; 3188static const struct firmware *firmware = NULL;
2419static const struct firmware *ucode = 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)
2420#endif 3203#endif
2421 3204
2422static int ipw_load(struct ipw_priv *priv) 3205static int ipw_load(struct ipw_priv *priv)
@@ -2445,10 +3228,10 @@ static int ipw_load(struct ipw_priv *priv)
2445 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss")); 3228 rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
2446 break; 3229 break;
2447 3230
2448#ifdef CONFIG_IPW_PROMISC 3231#ifdef CONFIG_IPW2200_MONITOR
2449 case IW_MODE_MONITOR: 3232 case IW_MODE_MONITOR:
2450 rc = ipw_get_fw(priv, &ucode, 3233 rc = ipw_get_fw(priv, &ucode,
2451 IPW_FW_NAME("ibss_ucode")); 3234 IPW_FW_NAME("sniffer_ucode"));
2452 if (rc) 3235 if (rc)
2453 goto error; 3236 goto error;
2454 3237
@@ -2487,11 +3270,11 @@ static int ipw_load(struct ipw_priv *priv)
2487 3270
2488 retry: 3271 retry:
2489 /* Ensure interrupts are disabled */ 3272 /* Ensure interrupts are disabled */
2490 ipw_write32(priv, CX2_INTA_MASK_R, ~CX2_INTA_MASK_ALL); 3273 ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
2491 priv->status &= ~STATUS_INT_ENABLED; 3274 priv->status &= ~STATUS_INT_ENABLED;
2492 3275
2493 /* ack pending interrupts */ 3276 /* ack pending interrupts */
2494 ipw_write32(priv, CX2_INTA_RW, CX2_INTA_MASK_ALL); 3277 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
2495 3278
2496 ipw_stop_nic(priv); 3279 ipw_stop_nic(priv);
2497 3280
@@ -2501,14 +3284,14 @@ static int ipw_load(struct ipw_priv *priv)
2501 goto error; 3284 goto error;
2502 } 3285 }
2503 3286
2504 ipw_zero_memory(priv, CX2_NIC_SRAM_LOWER_BOUND, 3287 ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
2505 CX2_NIC_SRAM_UPPER_BOUND - CX2_NIC_SRAM_LOWER_BOUND); 3288 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
2506 3289
2507 /* DMA the initial boot firmware into the device */ 3290 /* DMA the initial boot firmware into the device */
2508 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header), 3291 rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
2509 bootfw->size - sizeof(struct fw_header)); 3292 bootfw->size - sizeof(struct fw_header));
2510 if (rc < 0) { 3293 if (rc < 0) {
2511 IPW_ERROR("Unable to load boot firmware\n"); 3294 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
2512 goto error; 3295 goto error;
2513 } 3296 }
2514 3297
@@ -2516,8 +3299,8 @@ static int ipw_load(struct ipw_priv *priv)
2516 ipw_start_nic(priv); 3299 ipw_start_nic(priv);
2517 3300
2518 /* wait for the device to finish it's initial startup sequence */ 3301 /* wait for the device to finish it's initial startup sequence */
2519 rc = ipw_poll_bit(priv, CX2_INTA_RW, 3302 rc = ipw_poll_bit(priv, IPW_INTA_RW,
2520 CX2_INTA_BIT_FW_INITIALIZATION_DONE, 500); 3303 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
2521 if (rc < 0) { 3304 if (rc < 0) {
2522 IPW_ERROR("device failed to boot initial fw image\n"); 3305 IPW_ERROR("device failed to boot initial fw image\n");
2523 goto error; 3306 goto error;
@@ -2525,13 +3308,13 @@ static int ipw_load(struct ipw_priv *priv)
2525 IPW_DEBUG_INFO("initial device response after %dms\n", rc); 3308 IPW_DEBUG_INFO("initial device response after %dms\n", rc);
2526 3309
2527 /* ack fw init done interrupt */ 3310 /* ack fw init done interrupt */
2528 ipw_write32(priv, CX2_INTA_RW, CX2_INTA_BIT_FW_INITIALIZATION_DONE); 3311 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
2529 3312
2530 /* DMA the ucode into the device */ 3313 /* DMA the ucode into the device */
2531 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header), 3314 rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
2532 ucode->size - sizeof(struct fw_header)); 3315 ucode->size - sizeof(struct fw_header));
2533 if (rc < 0) { 3316 if (rc < 0) {
2534 IPW_ERROR("Unable to load ucode\n"); 3317 IPW_ERROR("Unable to load ucode: %d\n", rc);
2535 goto error; 3318 goto error;
2536 } 3319 }
2537 3320
@@ -2543,7 +3326,7 @@ static int ipw_load(struct ipw_priv *priv)
2543 sizeof(struct fw_header), 3326 sizeof(struct fw_header),
2544 firmware->size - sizeof(struct fw_header)); 3327 firmware->size - sizeof(struct fw_header));
2545 if (rc < 0) { 3328 if (rc < 0) {
2546 IPW_ERROR("Unable to load firmware\n"); 3329 IPW_ERROR("Unable to load firmware: %d\n", rc);
2547 goto error; 3330 goto error;
2548 } 3331 }
2549 3332
@@ -2556,12 +3339,14 @@ static int ipw_load(struct ipw_priv *priv)
2556 } 3339 }
2557 3340
2558 /* Ensure interrupts are disabled */ 3341 /* Ensure interrupts are disabled */
2559 ipw_write32(priv, CX2_INTA_MASK_R, ~CX2_INTA_MASK_ALL); 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);
2560 3345
2561 /* kick start the device */ 3346 /* kick start the device */
2562 ipw_start_nic(priv); 3347 ipw_start_nic(priv);
2563 3348
2564 if (ipw_read32(priv, CX2_INTA_RW) & CX2_INTA_BIT_PARITY_ERROR) { 3349 if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
2565 if (retries > 0) { 3350 if (retries > 0) {
2566 IPW_WARNING("Parity error. Retrying init.\n"); 3351 IPW_WARNING("Parity error. Retrying init.\n");
2567 retries--; 3352 retries--;
@@ -2574,8 +3359,8 @@ static int ipw_load(struct ipw_priv *priv)
2574 } 3359 }
2575 3360
2576 /* wait for the device */ 3361 /* wait for the device */
2577 rc = ipw_poll_bit(priv, CX2_INTA_RW, 3362 rc = ipw_poll_bit(priv, IPW_INTA_RW,
2578 CX2_INTA_BIT_FW_INITIALIZATION_DONE, 500); 3363 IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
2579 if (rc < 0) { 3364 if (rc < 0) {
2580 IPW_ERROR("device failed to start after 500ms\n"); 3365 IPW_ERROR("device failed to start after 500ms\n");
2581 goto error; 3366 goto error;
@@ -2583,7 +3368,7 @@ static int ipw_load(struct ipw_priv *priv)
2583 IPW_DEBUG_INFO("device response after %dms\n", rc); 3368 IPW_DEBUG_INFO("device response after %dms\n", rc);
2584 3369
2585 /* ack fw init done interrupt */ 3370 /* ack fw init done interrupt */
2586 ipw_write32(priv, CX2_INTA_RW, CX2_INTA_BIT_FW_INITIALIZATION_DONE); 3371 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
2587 3372
2588 /* read eeprom data and initialize the eeprom region of sram */ 3373 /* read eeprom data and initialize the eeprom region of sram */
2589 priv->eeprom_delay = 1; 3374 priv->eeprom_delay = 1;
@@ -2595,10 +3380,10 @@ static int ipw_load(struct ipw_priv *priv)
2595 /* Ensure our queue has valid packets */ 3380 /* Ensure our queue has valid packets */
2596 ipw_rx_queue_replenish(priv); 3381 ipw_rx_queue_replenish(priv);
2597 3382
2598 ipw_write32(priv, CX2_RX_READ_INDEX, priv->rxq->read); 3383 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
2599 3384
2600 /* ack pending interrupts */ 3385 /* ack pending interrupts */
2601 ipw_write32(priv, CX2_INTA_RW, CX2_INTA_MASK_ALL); 3386 ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
2602 3387
2603#ifndef CONFIG_PM 3388#ifndef CONFIG_PM
2604 release_firmware(bootfw); 3389 release_firmware(bootfw);
@@ -2755,16 +3540,18 @@ static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
2755 return; 3540 return;
2756 3541
2757 /* sanity check */ 3542 /* sanity check */
2758 if (bd->u.data.num_chunks > NUM_TFD_CHUNKS) { 3543 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
2759 IPW_ERROR("Too many chunks: %i\n", bd->u.data.num_chunks); 3544 IPW_ERROR("Too many chunks: %i\n",
3545 le32_to_cpu(bd->u.data.num_chunks));
2760 /** @todo issue fatal error, it is quite serious situation */ 3546 /** @todo issue fatal error, it is quite serious situation */
2761 return; 3547 return;
2762 } 3548 }
2763 3549
2764 /* unmap chunks if any */ 3550 /* unmap chunks if any */
2765 for (i = 0; i < bd->u.data.num_chunks; i++) { 3551 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
2766 pci_unmap_single(dev, bd->u.data.chunk_ptr[i], 3552 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
2767 bd->u.data.chunk_len[i], PCI_DMA_TODEVICE); 3553 le16_to_cpu(bd->u.data.chunk_len[i]),
3554 PCI_DMA_TODEVICE);
2768 if (txq->txb[txq->q.last_used]) { 3555 if (txq->txb[txq->q.last_used]) {
2769 ieee80211_txb_free(txq->txb[txq->q.last_used]); 3556 ieee80211_txb_free(txq->txb[txq->q.last_used]);
2770 txq->txb[txq->q.last_used] = NULL; 3557 txq->txb[txq->q.last_used] = NULL;
@@ -2821,21 +3608,6 @@ static void ipw_tx_queue_free(struct ipw_priv *priv)
2821 ipw_queue_tx_free(priv, &priv->txq[3]); 3608 ipw_queue_tx_free(priv, &priv->txq[3]);
2822} 3609}
2823 3610
2824static void inline __maybe_wake_tx(struct ipw_priv *priv)
2825{
2826 if (netif_running(priv->net_dev)) {
2827 switch (priv->port_type) {
2828 case DCR_TYPE_MU_BSS:
2829 case DCR_TYPE_MU_IBSS:
2830 if (!(priv->status & STATUS_ASSOCIATED)) {
2831 return;
2832 }
2833 }
2834 netif_wake_queue(priv->net_dev);
2835 }
2836
2837}
2838
2839static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid) 3611static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
2840{ 3612{
2841 /* First 3 bytes are manufacturer */ 3613 /* First 3 bytes are manufacturer */
@@ -2898,7 +3670,13 @@ static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
2898{ 3670{
2899 int err; 3671 int err;
2900 3672
2901 if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))) { 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)) {
2902 IPW_DEBUG_ASSOC("Disassociating while not associated.\n"); 3680 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
2903 return; 3681 return;
2904 } 3682 }
@@ -2915,6 +3693,7 @@ static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
2915 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET; 3693 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
2916 else 3694 else
2917 priv->assoc_request.assoc_type = HC_DISASSOCIATE; 3695 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3696
2918 err = ipw_send_associate(priv, &priv->assoc_request); 3697 err = ipw_send_associate(priv, &priv->assoc_request);
2919 if (err) { 3698 if (err) {
2920 IPW_DEBUG_HC("Attempt to send [dis]associate command " 3699 IPW_DEBUG_HC("Attempt to send [dis]associate command "
@@ -2924,20 +3703,27 @@ static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
2924 3703
2925} 3704}
2926 3705
2927static void ipw_disassociate(void *data) 3706static int ipw_disassociate(void *data)
2928{ 3707{
3708 struct ipw_priv *priv = data;
3709 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3710 return 0;
2929 ipw_send_disassociate(data, 0); 3711 ipw_send_disassociate(data, 0);
3712 return 1;
2930} 3713}
2931 3714
2932static void notify_wx_assoc_event(struct ipw_priv *priv) 3715static void ipw_bg_disassociate(void *data)
2933{ 3716{
2934 union iwreq_data wrqu; 3717 struct ipw_priv *priv = data;
2935 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 3718 down(&priv->sem);
2936 if (priv->status & STATUS_ASSOCIATED) 3719 ipw_disassociate(data);
2937 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN); 3720 up(&priv->sem);
2938 else 3721}
2939 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN); 3722
2940 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL); 3723static void ipw_system_config(void *data)
3724{
3725 struct ipw_priv *priv = data;
3726 ipw_send_system_config(priv, &priv->sys_config);
2941} 3727}
2942 3728
2943struct ipw_status_code { 3729struct ipw_status_code {
@@ -2997,7 +3783,7 @@ static const char *ipw_get_status_code(u16 status)
2997{ 3783{
2998 int i; 3784 int i;
2999 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++) 3785 for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3000 if (ipw_status_codes[i].status == status) 3786 if (ipw_status_codes[i].status == (status & 0xff))
3001 return ipw_status_codes[i].reason; 3787 return ipw_status_codes[i].reason;
3002 return "Unknown status value."; 3788 return "Unknown status value.";
3003} 3789}
@@ -3076,18 +3862,30 @@ static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
3076 while (i && !(mask & i)) 3862 while (i && !(mask & i))
3077 i >>= 1; 3863 i >>= 1;
3078 switch (i) { 3864 switch (i) {
3079 case IEEE80211_CCK_RATE_1MB_MASK: return 1000000; 3865 case IEEE80211_CCK_RATE_1MB_MASK:
3080 case IEEE80211_CCK_RATE_2MB_MASK: return 2000000; 3866 return 1000000;
3081 case IEEE80211_CCK_RATE_5MB_MASK: return 5500000; 3867 case IEEE80211_CCK_RATE_2MB_MASK:
3082 case IEEE80211_OFDM_RATE_6MB_MASK: return 6000000; 3868 return 2000000;
3083 case IEEE80211_OFDM_RATE_9MB_MASK: return 9000000; 3869 case IEEE80211_CCK_RATE_5MB_MASK:
3084 case IEEE80211_CCK_RATE_11MB_MASK: return 11000000; 3870 return 5500000;
3085 case IEEE80211_OFDM_RATE_12MB_MASK: return 12000000; 3871 case IEEE80211_OFDM_RATE_6MB_MASK:
3086 case IEEE80211_OFDM_RATE_18MB_MASK: return 18000000; 3872 return 6000000;
3087 case IEEE80211_OFDM_RATE_24MB_MASK: return 24000000; 3873 case IEEE80211_OFDM_RATE_9MB_MASK:
3088 case IEEE80211_OFDM_RATE_36MB_MASK: return 36000000; 3874 return 9000000;
3089 case IEEE80211_OFDM_RATE_48MB_MASK: return 48000000; 3875 case IEEE80211_CCK_RATE_11MB_MASK:
3090 case IEEE80211_OFDM_RATE_54MB_MASK: return 54000000; 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;
3091 } 3889 }
3092 3890
3093 if (priv->ieee->mode == IEEE_B) 3891 if (priv->ieee->mode == IEEE_B)
@@ -3115,25 +3913,35 @@ static u32 ipw_get_current_rate(struct ipw_priv *priv)
3115 return ipw_get_max_rate(priv); 3913 return ipw_get_max_rate(priv);
3116 3914
3117 switch (rate) { 3915 switch (rate) {
3118 case IPW_TX_RATE_1MB: return 1000000; 3916 case IPW_TX_RATE_1MB:
3119 case IPW_TX_RATE_2MB: return 2000000; 3917 return 1000000;
3120 case IPW_TX_RATE_5MB: return 5500000; 3918 case IPW_TX_RATE_2MB:
3121 case IPW_TX_RATE_6MB: return 6000000; 3919 return 2000000;
3122 case IPW_TX_RATE_9MB: return 9000000; 3920 case IPW_TX_RATE_5MB:
3123 case IPW_TX_RATE_11MB: return 11000000; 3921 return 5500000;
3124 case IPW_TX_RATE_12MB: return 12000000; 3922 case IPW_TX_RATE_6MB:
3125 case IPW_TX_RATE_18MB: return 18000000; 3923 return 6000000;
3126 case IPW_TX_RATE_24MB: return 24000000; 3924 case IPW_TX_RATE_9MB:
3127 case IPW_TX_RATE_36MB: return 36000000; 3925 return 9000000;
3128 case IPW_TX_RATE_48MB: return 48000000; 3926 case IPW_TX_RATE_11MB:
3129 case IPW_TX_RATE_54MB: return 54000000; 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;
3130 } 3940 }
3131 3941
3132 return 0; 3942 return 0;
3133} 3943}
3134 3944
3135#define PERFECT_RSSI (-50)
3136#define WORST_RSSI (-85)
3137#define IPW_STATS_INTERVAL (2 * HZ) 3945#define IPW_STATS_INTERVAL (2 * HZ)
3138static void ipw_gather_stats(struct ipw_priv *priv) 3946static void ipw_gather_stats(struct ipw_priv *priv)
3139{ 3947{
@@ -3145,6 +3953,7 @@ static void ipw_gather_stats(struct ipw_priv *priv)
3145 s16 rssi; 3953 s16 rssi;
3146 u32 beacon_quality, signal_quality, tx_quality, rx_quality, 3954 u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3147 rate_quality; 3955 rate_quality;
3956 u32 max_rate;
3148 3957
3149 if (!(priv->status & STATUS_ASSOCIATED)) { 3958 if (!(priv->status & STATUS_ASSOCIATED)) {
3150 priv->quality = 0; 3959 priv->quality = 0;
@@ -3201,7 +4010,8 @@ static void ipw_gather_stats(struct ipw_priv *priv)
3201 beacon_quality, missed_beacons_percent); 4010 beacon_quality, missed_beacons_percent);
3202 4011
3203 priv->last_rate = ipw_get_current_rate(priv); 4012 priv->last_rate = ipw_get_current_rate(priv);
3204 rate_quality = priv->last_rate * 40 / priv->last_rate + 60; 4013 max_rate = ipw_get_max_rate(priv);
4014 rate_quality = priv->last_rate * 40 / max_rate + 60;
3205 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n", 4015 IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
3206 rate_quality, priv->last_rate / 1000000); 4016 rate_quality, priv->last_rate / 1000000);
3207 4017
@@ -3222,13 +4032,20 @@ static void ipw_gather_stats(struct ipw_priv *priv)
3222 tx_quality, tx_failures_delta, tx_packets_delta); 4032 tx_quality, tx_failures_delta, tx_packets_delta);
3223 4033
3224 rssi = average_value(&priv->average_rssi); 4034 rssi = average_value(&priv->average_rssi);
3225 if (rssi > PERFECT_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)
3226 signal_quality = 100; 4045 signal_quality = 100;
3227 else if (rssi < WORST_RSSI) 4046 else if (signal_quality < 1)
3228 signal_quality = 0; 4047 signal_quality = 0;
3229 else 4048
3230 signal_quality = (rssi - WORST_RSSI) * 100 /
3231 (PERFECT_RSSI - WORST_RSSI);
3232 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n", 4049 IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
3233 signal_quality, rssi); 4050 signal_quality, rssi);
3234 4051
@@ -3257,6 +4074,85 @@ static void ipw_gather_stats(struct ipw_priv *priv)
3257 IPW_STATS_INTERVAL); 4074 IPW_STATS_INTERVAL);
3258} 4075}
3259 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
3260/** 4156/**
3261 * Handle host notification packet. 4157 * Handle host notification packet.
3262 * Called from interrupt routine 4158 * Called from interrupt routine
@@ -3264,6 +4160,8 @@ static void ipw_gather_stats(struct ipw_priv *priv)
3264static inline void ipw_rx_notification(struct ipw_priv *priv, 4160static inline void ipw_rx_notification(struct ipw_priv *priv,
3265 struct ipw_rx_notification *notif) 4161 struct ipw_rx_notification *notif)
3266{ 4162{
4163 notif->size = le16_to_cpu(notif->size);
4164
3267 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size); 4165 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
3268 4166
3269 switch (notif->subtype) { 4167 switch (notif->subtype) {
@@ -3307,30 +4205,44 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3307 4205
3308 priv->status &= ~STATUS_ASSOCIATING; 4206 priv->status &= ~STATUS_ASSOCIATING;
3309 priv->status |= STATUS_ASSOCIATED; 4207 priv->status |= STATUS_ASSOCIATED;
3310 4208 queue_work(priv->workqueue,
3311 netif_carrier_on(priv->net_dev); 4209 &priv->system_config);
3312 if (netif_queue_stopped(priv->net_dev)) { 4210
3313 IPW_DEBUG_NOTIF 4211#ifdef CONFIG_IPW_QOS
3314 ("waking queue\n"); 4212#define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
3315 netif_wake_queue(priv->net_dev); 4213 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
3316 } else { 4214 if ((priv->status & STATUS_AUTH) &&
3317 IPW_DEBUG_NOTIF 4215 (IPW_GET_PACKET_STYPE(&notif->u.raw)
3318 ("starting queue\n"); 4216 == IEEE80211_STYPE_ASSOC_RESP)) {
3319 netif_start_queue(priv-> 4217 if ((sizeof
3320 net_dev); 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 }
3321 } 4241 }
4242#endif
3322 4243
3323 ipw_reset_stats(priv); 4244 schedule_work(&priv->link_up);
3324 /* Ensure the rate is updated immediately */
3325 priv->last_rate =
3326 ipw_get_current_rate(priv);
3327 schedule_work(&priv->gather_stats);
3328 notify_wx_assoc_event(priv);
3329 4245
3330/* queue_delayed_work(priv->workqueue,
3331 &priv->request_scan,
3332 SCAN_ASSOCIATED_INTERVAL);
3333*/
3334 break; 4246 break;
3335 } 4247 }
3336 4248
@@ -3363,12 +4275,7 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3363 STATUS_AUTH | 4275 STATUS_AUTH |
3364 STATUS_ASSOCIATED); 4276 STATUS_ASSOCIATED);
3365 4277
3366 netif_carrier_off(priv-> 4278 schedule_work(&priv->link_down);
3367 net_dev);
3368 netif_stop_queue(priv->net_dev);
3369 queue_work(priv->workqueue,
3370 &priv->request_scan);
3371 notify_wx_assoc_event(priv);
3372 break; 4279 break;
3373 } 4280 }
3374 4281
@@ -3383,6 +4290,24 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3383 } 4290 }
3384 4291
3385 case CMAS_INIT:{ 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
3386 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | 4311 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
3387 IPW_DL_ASSOC, 4312 IPW_DL_ASSOC,
3388 "disassociated: '%s' " MAC_FMT 4313 "disassociated: '%s' " MAC_FMT
@@ -3395,35 +4320,21 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3395 ~(STATUS_DISASSOCIATING | 4320 ~(STATUS_DISASSOCIATING |
3396 STATUS_ASSOCIATING | 4321 STATUS_ASSOCIATING |
3397 STATUS_ASSOCIATED | STATUS_AUTH); 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);
3398 4329
3399 netif_stop_queue(priv->net_dev); 4330 schedule_work(&priv->link_down);
3400 if (!(priv->status & STATUS_ROAMING)) {
3401 netif_carrier_off(priv->
3402 net_dev);
3403 notify_wx_assoc_event(priv);
3404
3405 /* Cancel any queued work ... */
3406 cancel_delayed_work(&priv->
3407 request_scan);
3408 cancel_delayed_work(&priv->
3409 adhoc_check);
3410
3411 /* Queue up another scan... */
3412 queue_work(priv->workqueue,
3413 &priv->request_scan);
3414
3415 cancel_delayed_work(&priv->
3416 gather_stats);
3417 } else {
3418 priv->status |= STATUS_ROAMING;
3419 queue_work(priv->workqueue,
3420 &priv->request_scan);
3421 }
3422 4331
3423 ipw_reset_stats(priv);
3424 break; 4332 break;
3425 } 4333 }
3426 4334
4335 case CMAS_RX_ASSOC_RESP:
4336 break;
4337
3427 default: 4338 default:
3428 IPW_ERROR("assoc: unknown (%d)\n", 4339 IPW_ERROR("assoc: unknown (%d)\n",
3429 assoc->state); 4340 assoc->state);
@@ -3466,11 +4377,7 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3466 STATUS_AUTH | 4377 STATUS_AUTH |
3467 STATUS_ASSOCIATED); 4378 STATUS_ASSOCIATED);
3468 4379
3469 netif_carrier_off(priv->net_dev); 4380 schedule_work(&priv->link_down);
3470 netif_stop_queue(priv->net_dev);
3471 queue_work(priv->workqueue,
3472 &priv->request_scan);
3473 notify_wx_assoc_event(priv);
3474 break; 4381 break;
3475 4382
3476 case CMAS_TX_AUTH_SEQ_1: 4383 case CMAS_TX_AUTH_SEQ_1:
@@ -3512,6 +4419,7 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3512 case CMAS_RX_ASSOC_RESP: 4419 case CMAS_RX_ASSOC_RESP:
3513 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | 4420 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
3514 IPW_DL_ASSOC, "RX_ASSOC_RESP\n"); 4421 IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4422
3515 break; 4423 break;
3516 case CMAS_ASSOCIATED: 4424 case CMAS_ASSOCIATED:
3517 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | 4425 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
@@ -3556,43 +4464,67 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3556 priv->status &= 4464 priv->status &=
3557 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING); 4465 ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3558 4466
4467 wake_up_interruptible(&priv->wait_state);
3559 cancel_delayed_work(&priv->scan_check); 4468 cancel_delayed_work(&priv->scan_check);
3560 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
3561 if (!(priv->status & (STATUS_ASSOCIATED | 4485 if (!(priv->status & (STATUS_ASSOCIATED |
3562 STATUS_ASSOCIATING | 4486 STATUS_ASSOCIATING |
3563 STATUS_ROAMING | 4487 STATUS_ROAMING |
3564 STATUS_DISASSOCIATING))) 4488 STATUS_DISASSOCIATING)))
3565 queue_work(priv->workqueue, &priv->associate); 4489 queue_work(priv->workqueue, &priv->associate);
3566 else if (priv->status & STATUS_ROAMING) { 4490 else if (priv->status & STATUS_ROAMING) {
3567 /* If a scan completed and we are in roam mode, then 4491 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
3568 * the scan that completed was the one requested as a 4492 /* If a scan completed and we are in roam mode, then
3569 * result of entering roam... so, schedule the 4493 * the scan that completed was the one requested as a
3570 * roam work */ 4494 * result of entering roam... so, schedule the
3571 queue_work(priv->workqueue, &priv->roam); 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;
3572 } else if (priv->status & STATUS_SCAN_PENDING) 4501 } else if (priv->status & STATUS_SCAN_PENDING)
3573 queue_work(priv->workqueue, 4502 queue_work(priv->workqueue,
3574 &priv->request_scan); 4503 &priv->request_scan);
3575 4504 else if (priv->config & CFG_BACKGROUND_SCAN
3576 priv->ieee->scans++; 4505 && priv->status & STATUS_ASSOCIATED)
4506 queue_delayed_work(priv->workqueue,
4507 &priv->request_scan, HZ);
3577 break; 4508 break;
3578 } 4509 }
3579 4510
3580 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{ 4511 case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
3581 struct notif_frag_length *x = &notif->u.frag_len; 4512 struct notif_frag_length *x = &notif->u.frag_len;
3582 4513
3583 if (notif->size == sizeof(*x)) { 4514 if (notif->size == sizeof(*x))
3584 IPW_ERROR("Frag length: %d\n", x->frag_length); 4515 IPW_ERROR("Frag length: %d\n",
3585 } else { 4516 le16_to_cpu(x->frag_length));
4517 else
3586 IPW_ERROR("Frag length of wrong size %d " 4518 IPW_ERROR("Frag length of wrong size %d "
3587 "(should be %zd)\n", 4519 "(should be %zd)\n",
3588 notif->size, sizeof(*x)); 4520 notif->size, sizeof(*x));
3589 }
3590 break; 4521 break;
3591 } 4522 }
3592 4523
3593 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{ 4524 case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
3594 struct notif_link_deterioration *x = 4525 struct notif_link_deterioration *x =
3595 &notif->u.link_deterioration; 4526 &notif->u.link_deterioration;
4527
3596 if (notif->size == sizeof(*x)) { 4528 if (notif->size == sizeof(*x)) {
3597 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE, 4529 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
3598 "link deterioration: '%s' " MAC_FMT 4530 "link deterioration: '%s' " MAC_FMT
@@ -3612,11 +4544,9 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3612 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{ 4544 case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
3613 IPW_ERROR("Dino config\n"); 4545 IPW_ERROR("Dino config\n");
3614 if (priv->hcmd 4546 if (priv->hcmd
3615 && priv->hcmd->cmd == HOST_CMD_DINO_CONFIG) { 4547 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
3616 /* TODO: Do anything special? */
3617 } else {
3618 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n"); 4548 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
3619 } 4549
3620 break; 4550 break;
3621 } 4551 }
3622 4552
@@ -3629,36 +4559,11 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3629 break; 4559 break;
3630 } 4560 }
3631 4561
3632 if (x->state == HOST_NOTIFICATION_STATUS_BEACON_MISSING) { 4562 if (le32_to_cpu(x->state) ==
3633 if (priv->status & STATUS_SCANNING) { 4563 HOST_NOTIFICATION_STATUS_BEACON_MISSING)
3634 /* Stop scan to keep fw from getting 4564 ipw_handle_missed_beacon(priv,
3635 * stuck... */ 4565 le32_to_cpu(x->
3636 queue_work(priv->workqueue, 4566 number));
3637 &priv->abort_scan);
3638 }
3639
3640 if (x->number > priv->missed_beacon_threshold &&
3641 priv->status & STATUS_ASSOCIATED) {
3642 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
3643 IPW_DL_STATE,
3644 "Missed beacon: %d - disassociate\n",
3645 x->number);
3646 queue_work(priv->workqueue,
3647 &priv->disassociate);
3648 } else if (x->number > priv->roaming_threshold) {
3649 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
3650 "Missed beacon: %d - initiate "
3651 "roaming\n", x->number);
3652 queue_work(priv->workqueue,
3653 &priv->roam);
3654 } else {
3655 IPW_DEBUG_NOTIF("Missed beacon: %d\n",
3656 x->number);
3657 }
3658
3659 priv->notif_missed_beacons = x->number;
3660
3661 }
3662 4567
3663 break; 4568 break;
3664 } 4569 }
@@ -3697,7 +4602,8 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
3697 case HOST_NOTIFICATION_NOISE_STATS:{ 4602 case HOST_NOTIFICATION_NOISE_STATS:{
3698 if (notif->size == sizeof(u32)) { 4603 if (notif->size == sizeof(u32)) {
3699 priv->last_noise = 4604 priv->last_noise =
3700 (u8) (notif->u.noise.value & 0xff); 4605 (u8) (le32_to_cpu(notif->u.noise.value) &
4606 0xff);
3701 average_add(&priv->average_noise, 4607 average_add(&priv->average_noise,
3702 priv->last_noise); 4608 priv->last_noise);
3703 break; 4609 break;
@@ -3730,43 +4636,43 @@ static int ipw_queue_reset(struct ipw_priv *priv)
3730 ipw_tx_queue_free(priv); 4636 ipw_tx_queue_free(priv);
3731 /* Tx CMD queue */ 4637 /* Tx CMD queue */
3732 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd, 4638 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
3733 CX2_TX_CMD_QUEUE_READ_INDEX, 4639 IPW_TX_CMD_QUEUE_READ_INDEX,
3734 CX2_TX_CMD_QUEUE_WRITE_INDEX, 4640 IPW_TX_CMD_QUEUE_WRITE_INDEX,
3735 CX2_TX_CMD_QUEUE_BD_BASE, 4641 IPW_TX_CMD_QUEUE_BD_BASE,
3736 CX2_TX_CMD_QUEUE_BD_SIZE); 4642 IPW_TX_CMD_QUEUE_BD_SIZE);
3737 if (rc) { 4643 if (rc) {
3738 IPW_ERROR("Tx Cmd queue init failed\n"); 4644 IPW_ERROR("Tx Cmd queue init failed\n");
3739 goto error; 4645 goto error;
3740 } 4646 }
3741 /* Tx queue(s) */ 4647 /* Tx queue(s) */
3742 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx, 4648 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
3743 CX2_TX_QUEUE_0_READ_INDEX, 4649 IPW_TX_QUEUE_0_READ_INDEX,
3744 CX2_TX_QUEUE_0_WRITE_INDEX, 4650 IPW_TX_QUEUE_0_WRITE_INDEX,
3745 CX2_TX_QUEUE_0_BD_BASE, CX2_TX_QUEUE_0_BD_SIZE); 4651 IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
3746 if (rc) { 4652 if (rc) {
3747 IPW_ERROR("Tx 0 queue init failed\n"); 4653 IPW_ERROR("Tx 0 queue init failed\n");
3748 goto error; 4654 goto error;
3749 } 4655 }
3750 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx, 4656 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
3751 CX2_TX_QUEUE_1_READ_INDEX, 4657 IPW_TX_QUEUE_1_READ_INDEX,
3752 CX2_TX_QUEUE_1_WRITE_INDEX, 4658 IPW_TX_QUEUE_1_WRITE_INDEX,
3753 CX2_TX_QUEUE_1_BD_BASE, CX2_TX_QUEUE_1_BD_SIZE); 4659 IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
3754 if (rc) { 4660 if (rc) {
3755 IPW_ERROR("Tx 1 queue init failed\n"); 4661 IPW_ERROR("Tx 1 queue init failed\n");
3756 goto error; 4662 goto error;
3757 } 4663 }
3758 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx, 4664 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
3759 CX2_TX_QUEUE_2_READ_INDEX, 4665 IPW_TX_QUEUE_2_READ_INDEX,
3760 CX2_TX_QUEUE_2_WRITE_INDEX, 4666 IPW_TX_QUEUE_2_WRITE_INDEX,
3761 CX2_TX_QUEUE_2_BD_BASE, CX2_TX_QUEUE_2_BD_SIZE); 4667 IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
3762 if (rc) { 4668 if (rc) {
3763 IPW_ERROR("Tx 2 queue init failed\n"); 4669 IPW_ERROR("Tx 2 queue init failed\n");
3764 goto error; 4670 goto error;
3765 } 4671 }
3766 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx, 4672 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
3767 CX2_TX_QUEUE_3_READ_INDEX, 4673 IPW_TX_QUEUE_3_READ_INDEX,
3768 CX2_TX_QUEUE_3_WRITE_INDEX, 4674 IPW_TX_QUEUE_3_WRITE_INDEX,
3769 CX2_TX_QUEUE_3_BD_BASE, CX2_TX_QUEUE_3_BD_SIZE); 4675 IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
3770 if (rc) { 4676 if (rc) {
3771 IPW_ERROR("Tx 3 queue init failed\n"); 4677 IPW_ERROR("Tx 3 queue init failed\n");
3772 goto error; 4678 goto error;
@@ -3814,9 +4720,10 @@ static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
3814 priv->tx_packets++; 4720 priv->tx_packets++;
3815 } 4721 }
3816 done: 4722 done:
3817 if (ipw_queue_space(q) > q->low_mark && qindex >= 0) { 4723 if ((ipw_queue_space(q) > q->low_mark) &&
3818 __maybe_wake_tx(priv); 4724 (qindex >= 0) &&
3819 } 4725 (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4726 netif_wake_queue(priv->net_dev);
3820 used = q->first_empty - q->last_used; 4727 used = q->first_empty - q->last_used;
3821 if (used < 0) 4728 if (used < 0)
3822 used += q->n_bd; 4729 used += q->n_bd;
@@ -3857,7 +4764,7 @@ static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
3857 * Rx theory of operation 4764 * Rx theory of operation
3858 * 4765 *
3859 * The host allocates 32 DMA target addresses and passes the host address 4766 * The host allocates 32 DMA target addresses and passes the host address
3860 * to the firmware at register CX2_RFDS_TABLE_LOWER + N * RFD_SIZE where N is 4767 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
3861 * 0 to 31 4768 * 0 to 31
3862 * 4769 *
3863 * Rx Queue Indexes 4770 * Rx Queue Indexes
@@ -3941,7 +4848,7 @@ static void ipw_rx_queue_restock(struct ipw_priv *priv)
3941 rxb = list_entry(element, struct ipw_rx_mem_buffer, list); 4848 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
3942 list_del(element); 4849 list_del(element);
3943 4850
3944 ipw_write32(priv, CX2_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE, 4851 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
3945 rxb->dma_addr); 4852 rxb->dma_addr);
3946 rxq->queue[rxq->write] = rxb; 4853 rxq->queue[rxq->write] = rxb;
3947 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE; 4854 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
@@ -3956,7 +4863,7 @@ static void ipw_rx_queue_restock(struct ipw_priv *priv)
3956 4863
3957 /* If we've added more space for the firmware to place data, tell it */ 4864 /* If we've added more space for the firmware to place data, tell it */
3958 if (write != rxq->write) 4865 if (write != rxq->write)
3959 ipw_write32(priv, CX2_RX_WRITE_INDEX, rxq->write); 4866 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
3960} 4867}
3961 4868
3962/* 4869/*
@@ -3977,7 +4884,7 @@ static void ipw_rx_queue_replenish(void *data)
3977 while (!list_empty(&rxq->rx_used)) { 4884 while (!list_empty(&rxq->rx_used)) {
3978 element = rxq->rx_used.next; 4885 element = rxq->rx_used.next;
3979 rxb = list_entry(element, struct ipw_rx_mem_buffer, list); 4886 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
3980 rxb->skb = alloc_skb(CX2_RX_BUF_SIZE, GFP_ATOMIC); 4887 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
3981 if (!rxb->skb) { 4888 if (!rxb->skb) {
3982 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n", 4889 printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
3983 priv->net_dev->name); 4890 priv->net_dev->name);
@@ -3991,7 +4898,7 @@ static void ipw_rx_queue_replenish(void *data)
3991 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data; 4898 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
3992 rxb->dma_addr = 4899 rxb->dma_addr =
3993 pci_map_single(priv->pci_dev, rxb->skb->data, 4900 pci_map_single(priv->pci_dev, rxb->skb->data,
3994 CX2_RX_BUF_SIZE, PCI_DMA_FROMDEVICE); 4901 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3995 4902
3996 list_add_tail(&rxb->list, &rxq->rx_free); 4903 list_add_tail(&rxb->list, &rxq->rx_free);
3997 rxq->free_count++; 4904 rxq->free_count++;
@@ -4001,6 +4908,14 @@ static void ipw_rx_queue_replenish(void *data)
4001 ipw_rx_queue_restock(priv); 4908 ipw_rx_queue_restock(priv);
4002} 4909}
4003 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
4004/* Assumes that the skb field of the buffers in 'pool' is kept accurate. 4919/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4005 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL 4920 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL
4006 * This free routine walks the list of POOL entries and if SKB is set to 4921 * This free routine walks the list of POOL entries and if SKB is set to
@@ -4016,7 +4931,7 @@ static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4016 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) { 4931 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4017 if (rxq->pool[i].skb != NULL) { 4932 if (rxq->pool[i].skb != NULL) {
4018 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr, 4933 pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4019 CX2_RX_BUF_SIZE, PCI_DMA_FROMDEVICE); 4934 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4020 dev_kfree_skb(rxq->pool[i].skb); 4935 dev_kfree_skb(rxq->pool[i].skb);
4021 } 4936 }
4022 } 4937 }
@@ -4135,8 +5050,18 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
4135 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES); 5050 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
4136 rates->num_rates = 0; 5051 rates->num_rates = 0;
4137 for (i = 0; i < num_rates; i++) { 5052 for (i = 0; i < num_rates; i++) {
4138 if (!ipw_is_rate_in_mask 5053 if (!ipw_is_rate_in_mask(priv, network->mode,
4139 (priv, network->mode, network->rates[i])) { 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
4140 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n", 5065 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
4141 network->rates[i], priv->rates_mask); 5066 network->rates[i], priv->rates_mask);
4142 continue; 5067 continue;
@@ -4145,11 +5070,20 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
4145 rates->supported_rates[rates->num_rates++] = network->rates[i]; 5070 rates->supported_rates[rates->num_rates++] = network->rates[i];
4146 } 5071 }
4147 5072
4148 num_rates = 5073 num_rates = min(network->rates_ex_len,
4149 min(network->rates_ex_len, (u8) (IPW_MAX_RATES - num_rates)); 5074 (u8) (IPW_MAX_RATES - num_rates));
4150 for (i = 0; i < num_rates; i++) { 5075 for (i = 0; i < num_rates; i++) {
4151 if (!ipw_is_rate_in_mask 5076 if (!ipw_is_rate_in_mask(priv, network->mode,
4152 (priv, network->mode, network->rates_ex[i])) { 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
4153 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n", 5087 IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
4154 network->rates_ex[i], priv->rates_mask); 5088 network->rates_ex[i], priv->rates_mask);
4155 continue; 5089 continue;
@@ -4159,7 +5093,7 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
4159 network->rates_ex[i]; 5093 network->rates_ex[i];
4160 } 5094 }
4161 5095
4162 return rates->num_rates; 5096 return 1;
4163} 5097}
4164 5098
4165static inline void ipw_copy_rates(struct ipw_supported_rates *dest, 5099static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
@@ -4241,6 +5175,216 @@ struct ipw_network_match {
4241 struct ipw_supported_rates rates; 5175 struct ipw_supported_rates rates;
4242}; 5176};
4243 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
4244static int ipw_best_network(struct ipw_priv *priv, 5388static int ipw_best_network(struct ipw_priv *priv,
4245 struct ipw_network_match *match, 5389 struct ipw_network_match *match,
4246 struct ieee80211_network *network, int roaming) 5390 struct ieee80211_network *network, int roaming)
@@ -4322,9 +5466,9 @@ static int ipw_best_network(struct ipw_priv *priv,
4322 /* If this network has already had an association attempt within the 5466 /* If this network has already had an association attempt within the
4323 * last 3 seconds, do not try and associate again... */ 5467 * last 3 seconds, do not try and associate again... */
4324 if (network->last_associate && 5468 if (network->last_associate &&
4325 time_after(network->last_associate + (HZ * 5UL), jiffies)) { 5469 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
4326 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded " 5470 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
4327 "because of storming (%lu since last " 5471 "because of storming (%lus since last "
4328 "assoc attempt).\n", 5472 "assoc attempt).\n",
4329 escape_essid(network->ssid, network->ssid_len), 5473 escape_essid(network->ssid, network->ssid_len),
4330 MAC_ARG(network->bssid), 5474 MAC_ARG(network->bssid),
@@ -4334,12 +5478,12 @@ static int ipw_best_network(struct ipw_priv *priv,
4334 5478
4335 /* Now go through and see if the requested network is valid... */ 5479 /* Now go through and see if the requested network is valid... */
4336 if (priv->ieee->scan_age != 0 && 5480 if (priv->ieee->scan_age != 0 &&
4337 jiffies - network->last_scanned > priv->ieee->scan_age) { 5481 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
4338 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded " 5482 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
4339 "because of age: %lums.\n", 5483 "because of age: %lums.\n",
4340 escape_essid(network->ssid, network->ssid_len), 5484 escape_essid(network->ssid, network->ssid_len),
4341 MAC_ARG(network->bssid), 5485 MAC_ARG(network->bssid),
4342 (jiffies - network->last_scanned) / (HZ / 100)); 5486 1000 * (jiffies - network->last_scanned) / HZ);
4343 return 0; 5487 return 0;
4344 } 5488 }
4345 5489
@@ -4367,6 +5511,15 @@ static int ipw_best_network(struct ipw_priv *priv,
4367 return 0; 5511 return 0;
4368 } 5512 }
4369 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
4370 if ((priv->config & CFG_STATIC_BSSID) && 5523 if ((priv->config & CFG_STATIC_BSSID) &&
4371 memcmp(network->bssid, priv->bssid, ETH_ALEN)) { 5524 memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
4372 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded " 5525 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
@@ -4386,7 +5539,26 @@ static int ipw_best_network(struct ipw_priv *priv,
4386 return 0; 5539 return 0;
4387 } 5540 }
4388 5541
4389 ipw_compatible_rates(priv, network, &rates); 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
4390 if (rates.num_rates == 0) { 5562 if (rates.num_rates == 0) {
4391 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded " 5563 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
4392 "because of no compatible rates.\n", 5564 "because of no compatible rates.\n",
@@ -4413,6 +5585,9 @@ static int ipw_best_network(struct ipw_priv *priv,
4413static void ipw_adhoc_create(struct ipw_priv *priv, 5585static void ipw_adhoc_create(struct ipw_priv *priv,
4414 struct ieee80211_network *network) 5586 struct ieee80211_network *network)
4415{ 5587{
5588 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5589 int i;
5590
4416 /* 5591 /*
4417 * For the purposes of scanning, we can set our wireless mode 5592 * For the purposes of scanning, we can set our wireless mode
4418 * to trigger scans across combinations of bands, but when it 5593 * to trigger scans across combinations of bands, but when it
@@ -4423,22 +5598,47 @@ static void ipw_adhoc_create(struct ipw_priv *priv,
4423 * chossen band. Attempting to create a new ad-hoc network 5598 * chossen band. Attempting to create a new ad-hoc network
4424 * with an invalid channel for wireless mode will trigger a 5599 * with an invalid channel for wireless mode will trigger a
4425 * FW fatal error. 5600 * FW fatal error.
5601 *
4426 */ 5602 */
4427 network->mode = is_valid_channel(priv->ieee->mode, priv->channel); 5603 switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
4428 if (network->mode) { 5604 case IEEE80211_52GHZ_BAND:
4429 network->channel = priv->channel; 5605 network->mode = IEEE_A;
4430 } else { 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:
4431 IPW_WARNING("Overriding invalid channel\n"); 5630 IPW_WARNING("Overriding invalid channel\n");
4432 if (priv->ieee->mode & IEEE_A) { 5631 if (priv->ieee->mode & IEEE_A) {
4433 network->mode = IEEE_A; 5632 network->mode = IEEE_A;
4434 priv->channel = band_a_active_channel[0]; 5633 priv->channel = geo->a[0].channel;
4435 } else if (priv->ieee->mode & IEEE_G) { 5634 } else if (priv->ieee->mode & IEEE_G) {
4436 network->mode = IEEE_G; 5635 network->mode = IEEE_G;
4437 priv->channel = band_b_active_channel[0]; 5636 priv->channel = geo->bg[0].channel;
4438 } else { 5637 } else {
4439 network->mode = IEEE_B; 5638 network->mode = IEEE_B;
4440 priv->channel = band_b_active_channel[0]; 5639 priv->channel = geo->bg[0].channel;
4441 } 5640 }
5641 break;
4442 } 5642 }
4443 5643
4444 network->channel = priv->channel; 5644 network->channel = priv->channel;
@@ -4448,6 +5648,8 @@ static void ipw_adhoc_create(struct ipw_priv *priv,
4448 memcpy(network->ssid, priv->essid, priv->essid_len); 5648 memcpy(network->ssid, priv->essid, priv->essid_len);
4449 memset(&network->stats, 0, sizeof(network->stats)); 5649 memset(&network->stats, 0, sizeof(network->stats));
4450 network->capability = WLAN_CAPABILITY_IBSS; 5650 network->capability = WLAN_CAPABILITY_IBSS;
5651 if (!(priv->config & CFG_PREAMBLE_LONG))
5652 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
4451 if (priv->capability & CAP_PRIVACY_ON) 5653 if (priv->capability & CAP_PRIVACY_ON)
4452 network->capability |= WLAN_CAPABILITY_PRIVACY; 5654 network->capability |= WLAN_CAPABILITY_PRIVACY;
4453 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH); 5655 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
@@ -4464,13 +5666,35 @@ static void ipw_adhoc_create(struct ipw_priv *priv,
4464 network->beacon_interval = 100; /* Default */ 5666 network->beacon_interval = 100; /* Default */
4465 network->listen_interval = 10; /* Default */ 5667 network->listen_interval = 10; /* Default */
4466 network->atim_window = 0; /* Default */ 5668 network->atim_window = 0; /* Default */
4467#ifdef CONFIG_IEEE80211_WPA
4468 network->wpa_ie_len = 0; 5669 network->wpa_ie_len = 0;
4469 network->rsn_ie_len = 0; 5670 network->rsn_ie_len = 0;
4470#endif /* CONFIG_IEEE80211_WPA */
4471} 5671}
4472 5672
4473static void ipw_send_wep_keys(struct ipw_priv *priv) 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)
4474{ 5698{
4475 struct ipw_wep_key *key; 5699 struct ipw_wep_key *key;
4476 int i; 5700 int i;
@@ -4483,19 +5707,97 @@ static void ipw_send_wep_keys(struct ipw_priv *priv)
4483 key->cmd_id = DINO_CMD_WEP_KEY; 5707 key->cmd_id = DINO_CMD_WEP_KEY;
4484 key->seq_num = 0; 5708 key->seq_num = 0;
4485 5709
5710 /* Note: AES keys cannot be set for multiple times.
5711 * Only set it at the first time. */
4486 for (i = 0; i < 4; i++) { 5712 for (i = 0; i < 4; i++) {
4487 key->key_index = i; 5713 key->key_index = i | type;
4488 if (!(priv->sec.flags & (1 << i))) { 5714 if (!(priv->ieee->sec.flags & (1 << i))) {
4489 key->key_size = 0; 5715 key->key_size = 0;
4490 } else { 5716 continue;
4491 key->key_size = priv->sec.key_sizes[i];
4492 memcpy(key->key, priv->sec.keys[i], key->key_size);
4493 } 5717 }
4494 5718
4495 if (ipw_send_cmd(priv, &cmd)) { 5719 key->key_size = priv->ieee->sec.key_sizes[i];
4496 IPW_ERROR("failed to send WEP_KEY command\n"); 5720 memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);
4497 return; 5721
4498 } 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;
4499 } 5801 }
4500} 5802}
4501 5803
@@ -4503,9 +5805,12 @@ static void ipw_adhoc_check(void *data)
4503{ 5805{
4504 struct ipw_priv *priv = data; 5806 struct ipw_priv *priv = data;
4505 5807
4506 if (priv->missed_adhoc_beacons++ > priv->missed_beacon_threshold && 5808 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
4507 !(priv->config & CFG_ADHOC_PERSIST)) { 5809 !(priv->config & CFG_ADHOC_PERSIST)) {
4508 IPW_DEBUG_SCAN("Disassociating due to missed beacons\n"); 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);
4509 ipw_remove_current_network(priv); 5814 ipw_remove_current_network(priv);
4510 ipw_disassociate(priv); 5815 ipw_disassociate(priv);
4511 return; 5816 return;
@@ -4515,6 +5820,14 @@ static void ipw_adhoc_check(void *data)
4515 priv->assoc_request.beacon_interval); 5820 priv->assoc_request.beacon_interval);
4516} 5821}
4517 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
4518#ifdef CONFIG_IPW_DEBUG 5831#ifdef CONFIG_IPW_DEBUG
4519static void ipw_debug_config(struct ipw_priv *priv) 5832static void ipw_debug_config(struct ipw_priv *priv)
4520{ 5833{
@@ -4530,7 +5843,8 @@ static void ipw_debug_config(struct ipw_priv *priv)
4530 else 5843 else
4531 IPW_DEBUG_INFO("ESSID unlocked.\n"); 5844 IPW_DEBUG_INFO("ESSID unlocked.\n");
4532 if (priv->config & CFG_STATIC_BSSID) 5845 if (priv->config & CFG_STATIC_BSSID)
4533 IPW_DEBUG_INFO("BSSID locked to %d\n", priv->channel); 5846 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5847 MAC_ARG(priv->bssid));
4534 else 5848 else
4535 IPW_DEBUG_INFO("BSSID unlocked.\n"); 5849 IPW_DEBUG_INFO("BSSID unlocked.\n");
4536 if (priv->capability & CAP_PRIVACY_ON) 5850 if (priv->capability & CAP_PRIVACY_ON)
@@ -4543,8 +5857,7 @@ static void ipw_debug_config(struct ipw_priv *priv)
4543#define ipw_debug_config(x) do {} while (0) 5857#define ipw_debug_config(x) do {} while (0)
4544#endif 5858#endif
4545 5859
4546static inline void ipw_set_fixed_rate(struct ipw_priv *priv, 5860static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
4547 struct ieee80211_network *network)
4548{ 5861{
4549 /* TODO: Verify that this works... */ 5862 /* TODO: Verify that this works... */
4550 struct ipw_fixed_rate fr = { 5863 struct ipw_fixed_rate fr = {
@@ -4561,6 +5874,8 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
4561 /* IEEE_A */ 5874 /* IEEE_A */
4562 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) { 5875 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
4563 /* Invalid fixed rate mask */ 5876 /* Invalid fixed rate mask */
5877 IPW_DEBUG_WX
5878 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
4564 fr.tx_rates = 0; 5879 fr.tx_rates = 0;
4565 break; 5880 break;
4566 } 5881 }
@@ -4570,9 +5885,11 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
4570 5885
4571 default: /* 2.4Ghz or Mixed */ 5886 default: /* 2.4Ghz or Mixed */
4572 /* IEEE_B */ 5887 /* IEEE_B */
4573 if (network->mode == IEEE_B) { 5888 if (mode == IEEE_B) {
4574 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) { 5889 if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
4575 /* Invalid fixed rate mask */ 5890 /* Invalid fixed rate mask */
5891 IPW_DEBUG_WX
5892 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
4576 fr.tx_rates = 0; 5893 fr.tx_rates = 0;
4577 } 5894 }
4578 break; 5895 break;
@@ -4582,6 +5899,8 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
4582 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK | 5899 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
4583 IEEE80211_OFDM_RATES_MASK)) { 5900 IEEE80211_OFDM_RATES_MASK)) {
4584 /* Invalid fixed rate mask */ 5901 /* Invalid fixed rate mask */
5902 IPW_DEBUG_WX
5903 ("invalid fixed rate mask in ipw_set_fixed_rate\n");
4585 fr.tx_rates = 0; 5904 fr.tx_rates = 0;
4586 break; 5905 break;
4587 } 5906 }
@@ -4609,6 +5928,1112 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
4609 ipw_write_reg32(priv, reg, *(u32 *) & fr); 5928 ipw_write_reg32(priv, reg, *(u32 *) & fr);
4610} 5929}
4611 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
4612static int ipw_associate_network(struct ipw_priv *priv, 7037static int ipw_associate_network(struct ipw_priv *priv,
4613 struct ieee80211_network *network, 7038 struct ieee80211_network *network,
4614 struct ipw_supported_rates *rates, int roaming) 7039 struct ipw_supported_rates *rates, int roaming)
@@ -4616,7 +7041,7 @@ static int ipw_associate_network(struct ipw_priv *priv,
4616 int err; 7041 int err;
4617 7042
4618 if (priv->config & CFG_FIXED_RATE) 7043 if (priv->config & CFG_FIXED_RATE)
4619 ipw_set_fixed_rate(priv, network); 7044 ipw_set_fixed_rate(priv, network->mode);
4620 7045
4621 if (!(priv->config & CFG_STATIC_ESSID)) { 7046 if (!(priv->config & CFG_STATIC_ESSID)) {
4622 priv->essid_len = min(network->ssid_len, 7047 priv->essid_len = min(network->ssid_len,
@@ -4631,14 +7056,22 @@ static int ipw_associate_network(struct ipw_priv *priv,
4631 if ((priv->capability & CAP_PRIVACY_ON) && 7056 if ((priv->capability & CAP_PRIVACY_ON) &&
4632 (priv->capability & CAP_SHARED_KEY)) { 7057 (priv->capability & CAP_SHARED_KEY)) {
4633 priv->assoc_request.auth_type = AUTH_SHARED_KEY; 7058 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
4634 priv->assoc_request.auth_key = priv->sec.active_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);
4635 } else { 7065 } else {
4636 priv->assoc_request.auth_type = AUTH_OPEN; 7066 priv->assoc_request.auth_type = AUTH_OPEN;
4637 priv->assoc_request.auth_key = 0; 7067 priv->assoc_request.auth_key = 0;
4638 } 7068 }
4639 7069
4640 if (priv->capability & CAP_PRIVACY_ON) 7070 if (priv->ieee->wpa_ie_len) {
4641 ipw_send_wep_keys(priv); 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 }
4642 7075
4643 /* 7076 /*
4644 * It is valid for our ieee device to support multiple modes, but 7077 * It is valid for our ieee device to support multiple modes, but
@@ -4652,20 +7085,41 @@ static int ipw_associate_network(struct ipw_priv *priv,
4652 else if (network->mode & priv->ieee->mode & IEEE_B) 7085 else if (network->mode & priv->ieee->mode & IEEE_B)
4653 priv->assoc_request.ieee_mode = IPW_B_MODE; 7086 priv->assoc_request.ieee_mode = IPW_B_MODE;
4654 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
4655 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, " 7105 IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
4656 "802.11%c [%d], enc=%s%s%s%c%c\n", 7106 "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
4657 roaming ? "Rea" : "A", 7107 roaming ? "Rea" : "A",
4658 escape_essid(priv->essid, priv->essid_len), 7108 escape_essid(priv->essid, priv->essid_len),
4659 network->channel, 7109 network->channel,
4660 ipw_modes[priv->assoc_request.ieee_mode], 7110 ipw_modes[priv->assoc_request.ieee_mode],
4661 rates->num_rates, 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",
4662 priv->capability & CAP_PRIVACY_ON ? "on " : "off", 7116 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
4663 priv->capability & CAP_PRIVACY_ON ? 7117 priv->capability & CAP_PRIVACY_ON ?
4664 (priv->capability & CAP_SHARED_KEY ? "(shared)" : 7118 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
4665 "(open)") : "", 7119 "(open)") : "",
4666 priv->capability & CAP_PRIVACY_ON ? " key=" : "", 7120 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
4667 priv->capability & CAP_PRIVACY_ON ? 7121 priv->capability & CAP_PRIVACY_ON ?
4668 '1' + priv->sec.active_key : '.', 7122 '1' + priv->ieee->sec.active_key : '.',
4669 priv->capability & CAP_PRIVACY_ON ? '.' : ' '); 7123 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
4670 7124
4671 priv->assoc_request.beacon_interval = network->beacon_interval; 7125 priv->assoc_request.beacon_interval = network->beacon_interval;
@@ -4683,17 +7137,16 @@ static int ipw_associate_network(struct ipw_priv *priv,
4683 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0]; 7137 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
4684 } 7138 }
4685 7139
4686 memcpy(&priv->assoc_request.bssid, network->bssid, ETH_ALEN); 7140 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
4687 7141
4688 if (priv->ieee->iw_mode == IW_MODE_ADHOC) { 7142 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
4689 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN); 7143 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
4690 priv->assoc_request.atim_window = network->atim_window; 7144 priv->assoc_request.atim_window = network->atim_window;
4691 } else { 7145 } else {
4692 memcpy(&priv->assoc_request.dest, network->bssid, ETH_ALEN); 7146 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
4693 priv->assoc_request.atim_window = 0; 7147 priv->assoc_request.atim_window = 0;
4694 } 7148 }
4695 7149
4696 priv->assoc_request.capability = network->capability;
4697 priv->assoc_request.listen_interval = network->listen_interval; 7150 priv->assoc_request.listen_interval = network->listen_interval;
4698 7151
4699 err = ipw_send_ssid(priv, priv->essid, priv->essid_len); 7152 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
@@ -4710,6 +7163,12 @@ static int ipw_associate_network(struct ipw_priv *priv,
4710 priv->sys_config.dot11g_auto_detection = 1; 7163 priv->sys_config.dot11g_auto_detection = 1;
4711 else 7164 else
4712 priv->sys_config.dot11g_auto_detection = 0; 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
4713 err = ipw_send_system_config(priv, &priv->sys_config); 7172 err = ipw_send_system_config(priv, &priv->sys_config);
4714 if (err) { 7173 if (err) {
4715 IPW_DEBUG_HC("Attempt to send sys config command failed.\n"); 7174 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
@@ -4717,7 +7176,7 @@ static int ipw_associate_network(struct ipw_priv *priv,
4717 } 7176 }
4718 7177
4719 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi); 7178 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
4720 err = ipw_set_sensitivity(priv, network->stats.rssi); 7179 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
4721 if (err) { 7180 if (err) {
4722 IPW_DEBUG_HC("Attempt to send associate command failed.\n"); 7181 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
4723 return err; 7182 return err;
@@ -4735,6 +7194,10 @@ static int ipw_associate_network(struct ipw_priv *priv,
4735 7194
4736 priv->assoc_network = network; 7195 priv->assoc_network = network;
4737 7196
7197#ifdef CONFIG_IPW_QOS
7198 ipw_qos_association(priv, network);
7199#endif
7200
4738 err = ipw_send_associate(priv, &priv->assoc_request); 7201 err = ipw_send_associate(priv, &priv->assoc_request);
4739 if (err) { 7202 if (err) {
4740 IPW_DEBUG_HC("Attempt to send associate command failed.\n"); 7203 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
@@ -4782,12 +7245,15 @@ static void ipw_roam(void *data)
4782 if (priv->status & STATUS_ASSOCIATED) { 7245 if (priv->status & STATUS_ASSOCIATED) {
4783 /* First pass through ROAM process -- look for a better 7246 /* First pass through ROAM process -- look for a better
4784 * network */ 7247 * network */
7248 unsigned long flags;
4785 u8 rssi = priv->assoc_network->stats.rssi; 7249 u8 rssi = priv->assoc_network->stats.rssi;
4786 priv->assoc_network->stats.rssi = -128; 7250 priv->assoc_network->stats.rssi = -128;
7251 spin_lock_irqsave(&priv->ieee->lock, flags);
4787 list_for_each_entry(network, &priv->ieee->network_list, list) { 7252 list_for_each_entry(network, &priv->ieee->network_list, list) {
4788 if (network != priv->assoc_network) 7253 if (network != priv->assoc_network)
4789 ipw_best_network(priv, &match, network, 1); 7254 ipw_best_network(priv, &match, network, 1);
4790 } 7255 }
7256 spin_unlock_irqrestore(&priv->ieee->lock, flags);
4791 priv->assoc_network->stats.rssi = rssi; 7257 priv->assoc_network->stats.rssi = rssi;
4792 7258
4793 if (match.network == priv->assoc_network) { 7259 if (match.network == priv->assoc_network) {
@@ -4810,7 +7276,15 @@ static void ipw_roam(void *data)
4810 priv->status &= ~STATUS_ROAMING; 7276 priv->status &= ~STATUS_ROAMING;
4811} 7277}
4812 7278
4813static void ipw_associate(void *data) 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)
4814{ 7288{
4815 struct ipw_priv *priv = data; 7289 struct ipw_priv *priv = data;
4816 7290
@@ -4820,14 +7294,41 @@ static void ipw_associate(void *data)
4820 }; 7294 };
4821 struct ipw_supported_rates *rates; 7295 struct ipw_supported_rates *rates;
4822 struct list_head *element; 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 }
4823 7322
4824 if (!(priv->config & CFG_ASSOCIATE) && 7323 if (!(priv->config & CFG_ASSOCIATE) &&
4825 !(priv->config & (CFG_STATIC_ESSID | 7324 !(priv->config & (CFG_STATIC_ESSID |
4826 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) { 7325 CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
4827 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n"); 7326 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
4828 return; 7327 return 0;
4829 } 7328 }
4830 7329
7330 /* Protect our use of the network_list */
7331 spin_lock_irqsave(&priv->ieee->lock, flags);
4831 list_for_each_entry(network, &priv->ieee->network_list, list) 7332 list_for_each_entry(network, &priv->ieee->network_list, list)
4832 ipw_best_network(priv, &match, network, 0); 7333 ipw_best_network(priv, &match, network, 0);
4833 7334
@@ -4838,6 +7339,7 @@ static void ipw_associate(void *data)
4838 priv->ieee->iw_mode == IW_MODE_ADHOC && 7339 priv->ieee->iw_mode == IW_MODE_ADHOC &&
4839 priv->config & CFG_ADHOC_CREATE && 7340 priv->config & CFG_ADHOC_CREATE &&
4840 priv->config & CFG_STATIC_ESSID && 7341 priv->config & CFG_STATIC_ESSID &&
7342 priv->config & CFG_STATIC_CHANNEL &&
4841 !list_empty(&priv->ieee->network_free_list)) { 7343 !list_empty(&priv->ieee->network_free_list)) {
4842 element = priv->ieee->network_free_list.next; 7344 element = priv->ieee->network_free_list.next;
4843 network = list_entry(element, struct ieee80211_network, list); 7345 network = list_entry(element, struct ieee80211_network, list);
@@ -4846,25 +7348,83 @@ static void ipw_associate(void *data)
4846 list_del(element); 7348 list_del(element);
4847 list_add_tail(&network->list, &priv->ieee->network_list); 7349 list_add_tail(&network->list, &priv->ieee->network_list);
4848 } 7350 }
7351 spin_unlock_irqrestore(&priv->ieee->lock, flags);
4849 7352
4850 /* If we reached the end of the list, then we don't have any valid 7353 /* If we reached the end of the list, then we don't have any valid
4851 * matching APs */ 7354 * matching APs */
4852 if (!network) { 7355 if (!network) {
4853 ipw_debug_config(priv); 7356 ipw_debug_config(priv);
4854 7357
4855 queue_delayed_work(priv->workqueue, &priv->request_scan, 7358 if (!(priv->status & STATUS_SCANNING)) {
4856 SCAN_INTERVAL); 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 }
4857 7367
4858 return; 7368 return 0;
4859 } 7369 }
4860 7370
4861 ipw_associate_network(priv, network, rates, 0); 7371 ipw_associate_network(priv, network, rates, 0);
7372
7373 return 1;
4862} 7374}
4863 7375
4864static inline void ipw_handle_data_packet(struct ipw_priv *priv, 7376static void ipw_bg_associate(void *data)
4865 struct ipw_rx_mem_buffer *rxb,
4866 struct ieee80211_rx_stats *stats)
4867{ 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;
4868 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data; 7428 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
4869 7429
4870 /* We received data from the HW, so stop the watchdog */ 7430 /* We received data from the HW, so stop the watchdog */
@@ -4872,7 +7432,7 @@ static inline void ipw_handle_data_packet(struct ipw_priv *priv,
4872 7432
4873 /* We only process data packets if the 7433 /* We only process data packets if the
4874 * interface is open */ 7434 * interface is open */
4875 if (unlikely((pkt->u.frame.length + IPW_RX_FRAME_SIZE) > 7435 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
4876 skb_tailroom(rxb->skb))) { 7436 skb_tailroom(rxb->skb))) {
4877 priv->ieee->stats.rx_errors++; 7437 priv->ieee->stats.rx_errors++;
4878 priv->wstats.discard.misc++; 7438 priv->wstats.discard.misc++;
@@ -4889,14 +7449,351 @@ static inline void ipw_handle_data_packet(struct ipw_priv *priv,
4889 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data)); 7449 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
4890 7450
4891 /* Set the size of the skb to the size of the frame */ 7451 /* Set the size of the skb to the size of the frame */
4892 skb_put(rxb->skb, pkt->u.frame.length); 7452 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
4893 7453
4894 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len); 7454 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
4895 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
4896 if (!ieee80211_rx(priv->ieee, rxb->skb, stats)) 7464 if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
4897 priv->ieee->stats.rx_errors++; 7465 priv->ieee->stats.rx_errors++;
4898 else /* ieee80211_rx succeeded, so it now owns the SKB */ 7466 else { /* ieee80211_rx succeeded, so it now owns the SKB */
4899 rxb->skb = NULL; 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 }
4900} 7797}
4901 7798
4902/* 7799/*
@@ -4912,8 +7809,8 @@ static void ipw_rx(struct ipw_priv *priv)
4912 u32 r, w, i; 7809 u32 r, w, i;
4913 u8 network_packet; 7810 u8 network_packet;
4914 7811
4915 r = ipw_read32(priv, CX2_RX_READ_INDEX); 7812 r = ipw_read32(priv, IPW_RX_READ_INDEX);
4916 w = ipw_read32(priv, CX2_RX_WRITE_INDEX); 7813 w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
4917 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE; 7814 i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
4918 7815
4919 while (i != r) { 7816 while (i != r) {
@@ -4927,7 +7824,7 @@ static void ipw_rx(struct ipw_priv *priv)
4927 priv->rxq->queue[i] = NULL; 7824 priv->rxq->queue[i] = NULL;
4928 7825
4929 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr, 7826 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
4930 CX2_RX_BUF_SIZE, 7827 IPW_RX_BUF_SIZE,
4931 PCI_DMA_FROMDEVICE); 7828 PCI_DMA_FROMDEVICE);
4932 7829
4933 pkt = (struct ipw_rx_packet *)rxb->skb->data; 7830 pkt = (struct ipw_rx_packet *)rxb->skb->data;
@@ -4938,9 +7835,13 @@ static void ipw_rx(struct ipw_priv *priv)
4938 switch (pkt->header.message_type) { 7835 switch (pkt->header.message_type) {
4939 case RX_FRAME_TYPE: /* 802.11 frame */ { 7836 case RX_FRAME_TYPE: /* 802.11 frame */ {
4940 struct ieee80211_rx_stats stats = { 7837 struct ieee80211_rx_stats stats = {
4941 .rssi = pkt->u.frame.rssi_dbm - 7838 .rssi =
7839 le16_to_cpu(pkt->u.frame.rssi_dbm) -
4942 IPW_RSSI_TO_DBM, 7840 IPW_RSSI_TO_DBM,
4943 .signal = pkt->u.frame.signal, 7841 .signal =
7842 le16_to_cpu(pkt->u.frame.signal),
7843 .noise =
7844 le16_to_cpu(pkt->u.frame.noise),
4944 .rate = pkt->u.frame.rate, 7845 .rate = pkt->u.frame.rate,
4945 .mac_time = jiffies, 7846 .mac_time = jiffies,
4946 .received_channel = 7847 .received_channel =
@@ -4950,22 +7851,30 @@ static void ipw_rx(struct ipw_priv *priv)
4950 control & (1 << 0)) ? 7851 control & (1 << 0)) ?
4951 IEEE80211_24GHZ_BAND : 7852 IEEE80211_24GHZ_BAND :
4952 IEEE80211_52GHZ_BAND, 7853 IEEE80211_52GHZ_BAND,
4953 .len = pkt->u.frame.length, 7854 .len = le16_to_cpu(pkt->u.frame.length),
4954 }; 7855 };
4955 7856
4956 if (stats.rssi != 0) 7857 if (stats.rssi != 0)
4957 stats.mask |= IEEE80211_STATMASK_RSSI; 7858 stats.mask |= IEEE80211_STATMASK_RSSI;
4958 if (stats.signal != 0) 7859 if (stats.signal != 0)
4959 stats.mask |= IEEE80211_STATMASK_SIGNAL; 7860 stats.mask |= IEEE80211_STATMASK_SIGNAL;
7861 if (stats.noise != 0)
7862 stats.mask |= IEEE80211_STATMASK_NOISE;
4960 if (stats.rate != 0) 7863 if (stats.rate != 0)
4961 stats.mask |= IEEE80211_STATMASK_RATE; 7864 stats.mask |= IEEE80211_STATMASK_RATE;
4962 7865
4963 priv->rx_packets++; 7866 priv->rx_packets++;
4964 7867
4965#ifdef CONFIG_IPW_PROMISC 7868#ifdef CONFIG_IPW2200_MONITOR
4966 if (priv->ieee->iw_mode == IW_MODE_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
4967 ipw_handle_data_packet(priv, rxb, 7875 ipw_handle_data_packet(priv, rxb,
4968 &stats); 7876 &stats);
7877#endif
4969 break; 7878 break;
4970 } 7879 }
4971#endif 7880#endif
@@ -4979,35 +7888,9 @@ static void ipw_rx(struct ipw_priv *priv)
4979 * correctly -- we should probably use the 7888 * correctly -- we should probably use the
4980 * frame control of the packet and disregard 7889 * frame control of the packet and disregard
4981 * the current iw_mode */ 7890 * the current iw_mode */
4982 switch (priv->ieee->iw_mode) {
4983 case IW_MODE_ADHOC:
4984 network_packet =
4985 !memcmp(header->addr1,
4986 priv->net_dev->dev_addr,
4987 ETH_ALEN) ||
4988 !memcmp(header->addr3,
4989 priv->bssid, ETH_ALEN) ||
4990 is_broadcast_ether_addr(header->
4991 addr1)
4992 || is_multicast_ether_addr(header->
4993 addr1);
4994 break;
4995
4996 case IW_MODE_INFRA:
4997 default:
4998 network_packet =
4999 !memcmp(header->addr3,
5000 priv->bssid, ETH_ALEN) ||
5001 !memcmp(header->addr1,
5002 priv->net_dev->dev_addr,
5003 ETH_ALEN) ||
5004 is_broadcast_ether_addr(header->
5005 addr1)
5006 || is_multicast_ether_addr(header->
5007 addr1);
5008 break;
5009 }
5010 7891
7892 network_packet =
7893 is_network_packet(priv, header);
5011 if (network_packet && priv->assoc_network) { 7894 if (network_packet && priv->assoc_network) {
5012 priv->assoc_network->stats.rssi = 7895 priv->assoc_network->stats.rssi =
5013 stats.rssi; 7896 stats.rssi;
@@ -5017,9 +7900,10 @@ static void ipw_rx(struct ipw_priv *priv)
5017 } 7900 }
5018 7901
5019 IPW_DEBUG_RX("Frame: len=%u\n", 7902 IPW_DEBUG_RX("Frame: len=%u\n",
5020 pkt->u.frame.length); 7903 le16_to_cpu(pkt->u.frame.length));
5021 7904
5022 if (pkt->u.frame.length < frame_hdr_len(header)) { 7905 if (le16_to_cpu(pkt->u.frame.length) <
7906 frame_hdr_len(header)) {
5023 IPW_DEBUG_DROP 7907 IPW_DEBUG_DROP
5024 ("Received packet is too small. " 7908 ("Received packet is too small. "
5025 "Dropping.\n"); 7909 "Dropping.\n");
@@ -5028,34 +7912,22 @@ static void ipw_rx(struct ipw_priv *priv)
5028 break; 7912 break;
5029 } 7913 }
5030 7914
5031 switch (WLAN_FC_GET_TYPE(header->frame_ctl)) { 7915 switch (WLAN_FC_GET_TYPE
7916 (le16_to_cpu(header->frame_ctl))) {
7917
5032 case IEEE80211_FTYPE_MGMT: 7918 case IEEE80211_FTYPE_MGMT:
5033 ieee80211_rx_mgt(priv->ieee, header, 7919 ipw_handle_mgmt_packet(priv, rxb,
5034 &stats); 7920 &stats);
5035 if (priv->ieee->iw_mode == IW_MODE_ADHOC
5036 &&
5037 ((WLAN_FC_GET_STYPE
5038 (header->frame_ctl) ==
5039 IEEE80211_STYPE_PROBE_RESP)
5040 ||
5041 (WLAN_FC_GET_STYPE
5042 (header->frame_ctl) ==
5043 IEEE80211_STYPE_BEACON))
5044 && !memcmp(header->addr3,
5045 priv->bssid, ETH_ALEN))
5046 ipw_add_station(priv,
5047 header->addr2);
5048 break; 7921 break;
5049 7922
5050 case IEEE80211_FTYPE_CTL: 7923 case IEEE80211_FTYPE_CTL:
5051 break; 7924 break;
5052 7925
5053 case IEEE80211_FTYPE_DATA: 7926 case IEEE80211_FTYPE_DATA:
5054 if (network_packet) 7927 if (unlikely(!network_packet ||
5055 ipw_handle_data_packet(priv, 7928 is_duplicate_packet(priv,
5056 rxb, 7929 header)))
5057 &stats); 7930 {
5058 else
5059 IPW_DEBUG_DROP("Dropping: " 7931 IPW_DEBUG_DROP("Dropping: "
5060 MAC_FMT ", " 7932 MAC_FMT ", "
5061 MAC_FMT ", " 7933 MAC_FMT ", "
@@ -5066,6 +7938,12 @@ static void ipw_rx(struct ipw_priv *priv)
5066 addr2), 7938 addr2),
5067 MAC_ARG(header-> 7939 MAC_ARG(header->
5068 addr3)); 7940 addr3));
7941 break;
7942 }
7943
7944 ipw_handle_data_packet(priv, rxb,
7945 &stats);
7946
5069 break; 7947 break;
5070 } 7948 }
5071 break; 7949 break;
@@ -5096,7 +7974,7 @@ static void ipw_rx(struct ipw_priv *priv)
5096 } 7974 }
5097 7975
5098 pci_unmap_single(priv->pci_dev, rxb->dma_addr, 7976 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
5099 CX2_RX_BUF_SIZE, PCI_DMA_FROMDEVICE); 7977 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
5100 list_add_tail(&rxb->list, &priv->rxq->rx_used); 7978 list_add_tail(&rxb->list, &priv->rxq->rx_used);
5101 7979
5102 i = (i + 1) % RX_QUEUE_SIZE; 7980 i = (i + 1) % RX_QUEUE_SIZE;
@@ -5108,128 +7986,129 @@ static void ipw_rx(struct ipw_priv *priv)
5108 ipw_rx_queue_restock(priv); 7986 ipw_rx_queue_restock(priv);
5109} 7987}
5110 7988
5111static void ipw_abort_scan(struct ipw_priv *priv) 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)
5112{ 7997{
5113 int err; 7998 int band, modulation;
7999 int old_mode = priv->ieee->iw_mode;
5114 8000
5115 if (priv->status & STATUS_SCAN_ABORTING) { 8001 /* Initialize module parameter values here */
5116 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n"); 8002 priv->config = 0;
5117 return;
5118 }
5119 priv->status |= STATUS_SCAN_ABORTING;
5120 8003
5121 err = ipw_send_scan_abort(priv); 8004 /* We default to disabling the LED code as right now it causes
5122 if (err) 8005 * too many systems to lock up... */
5123 IPW_DEBUG_HC("Request to abort scan failed.\n"); 8006 if (!led)
5124} 8007 priv->config |= CFG_NO_LED;
5125 8008
5126static int ipw_request_scan(struct ipw_priv *priv) 8009 if (associate)
5127{ 8010 priv->config |= CFG_ASSOCIATE;
5128 struct ipw_scan_request_ext scan; 8011 else
5129 int channel_index = 0; 8012 IPW_DEBUG_INFO("Auto associate disabled.\n");
5130 int i, err, scan_type;
5131 8013
5132 if (priv->status & STATUS_EXIT_PENDING) { 8014 if (auto_create)
5133 IPW_DEBUG_SCAN("Aborting scan due to device shutdown\n"); 8015 priv->config |= CFG_ADHOC_CREATE;
5134 priv->status |= STATUS_SCAN_PENDING; 8016 else
5135 return 0; 8017 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
5136 }
5137 8018
5138 if (priv->status & STATUS_SCANNING) { 8019 if (disable) {
5139 IPW_DEBUG_HC("Concurrent scan requested. Aborting first.\n"); 8020 priv->status |= STATUS_RF_KILL_SW;
5140 priv->status |= STATUS_SCAN_PENDING; 8021 IPW_DEBUG_INFO("Radio disabled.\n");
5141 ipw_abort_scan(priv);
5142 return 0;
5143 } 8022 }
5144 8023
5145 if (priv->status & STATUS_SCAN_ABORTING) { 8024 if (channel != 0) {
5146 IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n"); 8025 priv->config |= CFG_STATIC_CHANNEL;
5147 priv->status |= STATUS_SCAN_PENDING; 8026 priv->channel = channel;
5148 return 0; 8027 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8028 /* TODO: Validate that provided channel is in range */
5149 } 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 */
5150 8034
5151 if (priv->status & STATUS_RF_KILL_MASK) { 8035 switch (mode) {
5152 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n"); 8036 case 1:
5153 priv->status |= STATUS_SCAN_PENDING; 8037 priv->ieee->iw_mode = IW_MODE_ADHOC;
5154 return 0; 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;
5155 } 8056 }
5156 8057
5157 memset(&scan, 0, sizeof(scan)); 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");
5158 8065
5159 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] = 20; 8066 /* IPW2200/2915 is abled to do hardware fragmentation. */
5160 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] = 20; 8067 priv->ieee->host_open_frag = 0;
5161 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = 20;
5162
5163 scan.full_scan_index = ieee80211_get_scans(priv->ieee);
5164 /* If we are roaming, then make this a directed scan for the current
5165 * network. Otherwise, ensure that every other scan is a fast
5166 * channel hop scan */
5167 if ((priv->status & STATUS_ROAMING)
5168 || (!(priv->status & STATUS_ASSOCIATED)
5169 && (priv->config & CFG_STATIC_ESSID)
5170 && (scan.full_scan_index % 2))) {
5171 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
5172 if (err) {
5173 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
5174 return err;
5175 }
5176 8068
5177 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN; 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;
5178 } else { 8081 } else {
5179 scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN; 8082 if (init)
5180 } 8083 printk(KERN_INFO DRV_NAME
5181 8084 ": Detected Intel PRO/Wireless 2200BG Network "
5182 if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) { 8085 "Connection\n");
5183 int start = channel_index;
5184 for (i = 0; i < MAX_A_CHANNELS; i++) {
5185 if (band_a_active_channel[i] == 0)
5186 break;
5187 if ((priv->status & STATUS_ASSOCIATED) &&
5188 band_a_active_channel[i] == priv->channel)
5189 continue;
5190 channel_index++;
5191 scan.channels_list[channel_index] =
5192 band_a_active_channel[i];
5193 ipw_set_scan_type(&scan, channel_index, scan_type);
5194 }
5195 8086
5196 if (start != channel_index) { 8087 priv->ieee->abg_true = 0;
5197 scan.channels_list[start] = (u8) (IPW_A_MODE << 6) | 8088 band = IEEE80211_24GHZ_BAND;
5198 (channel_index - start); 8089 modulation = IEEE80211_OFDM_MODULATION |
5199 channel_index++; 8090 IEEE80211_CCK_MODULATION;
5200 } 8091 priv->adapter = IPW_2200BG;
8092 priv->ieee->mode = IEEE_G | IEEE_B;
5201 } 8093 }
5202 8094
5203 if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) { 8095 priv->ieee->freq_band = band;
5204 int start = channel_index; 8096 priv->ieee->modulation = modulation;
5205 for (i = 0; i < MAX_B_CHANNELS; i++) {
5206 if (band_b_active_channel[i] == 0)
5207 break;
5208 if ((priv->status & STATUS_ASSOCIATED) &&
5209 band_b_active_channel[i] == priv->channel)
5210 continue;
5211 channel_index++;
5212 scan.channels_list[channel_index] =
5213 band_b_active_channel[i];
5214 ipw_set_scan_type(&scan, channel_index, scan_type);
5215 }
5216 8097
5217 if (start != channel_index) { 8098 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
5218 scan.channels_list[start] = (u8) (IPW_B_MODE << 6) |
5219 (channel_index - start);
5220 }
5221 }
5222 8099
5223 err = ipw_send_scan_request_ext(priv, &scan); 8100 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
5224 if (err) { 8101 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
5225 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
5226 return -EIO;
5227 }
5228 8102
5229 priv->status |= STATUS_SCANNING; 8103 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
5230 priv->status &= ~STATUS_SCAN_PENDING; 8104 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8105 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
5231 8106
5232 return 0; 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;
5233} 8112}
5234 8113
5235/* 8114/*
@@ -5247,12 +8126,16 @@ static int ipw_wx_get_name(struct net_device *dev,
5247 union iwreq_data *wrqu, char *extra) 8126 union iwreq_data *wrqu, char *extra)
5248{ 8127{
5249 struct ipw_priv *priv = ieee80211_priv(dev); 8128 struct ipw_priv *priv = ieee80211_priv(dev);
5250 if (!(priv->status & STATUS_ASSOCIATED)) 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))
5251 strcpy(wrqu->name, "unassociated"); 8133 strcpy(wrqu->name, "unassociated");
5252 else 8134 else
5253 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c", 8135 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
5254 ipw_modes[priv->assoc_request.ieee_mode]); 8136 ipw_modes[priv->assoc_request.ieee_mode]);
5255 IPW_DEBUG_WX("Name: %s\n", wrqu->name); 8137 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8138 up(&priv->sem);
5256 return 0; 8139 return 0;
5257} 8140}
5258 8141
@@ -5261,13 +8144,9 @@ static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
5261 if (channel == 0) { 8144 if (channel == 0) {
5262 IPW_DEBUG_INFO("Setting channel to ANY (0)\n"); 8145 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
5263 priv->config &= ~CFG_STATIC_CHANNEL; 8146 priv->config &= ~CFG_STATIC_CHANNEL;
5264 if (!(priv->status & (STATUS_SCANNING | STATUS_ASSOCIATED | 8147 IPW_DEBUG_ASSOC("Attempting to associate with new "
5265 STATUS_ASSOCIATING))) { 8148 "parameters.\n");
5266 IPW_DEBUG_ASSOC("Attempting to associate with new " 8149 ipw_associate(priv);
5267 "parameters.\n");
5268 ipw_associate(priv);
5269 }
5270
5271 return 0; 8150 return 0;
5272 } 8151 }
5273 8152
@@ -5282,14 +8161,32 @@ static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
5282 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel); 8161 IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
5283 priv->channel = channel; 8162 priv->channel = channel;
5284 8163
5285 /* If we are currently associated, or trying to associate 8164#ifdef CONFIG_IPW2200_MONITOR
5286 * then see if this is a new channel (causing us to disassociate) */ 8165 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
5287 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) { 8166 int i;
5288 IPW_DEBUG_ASSOC("Disassociating due to channel change.\n"); 8167 if (priv->status & STATUS_SCANNING) {
5289 ipw_disassociate(priv); 8168 IPW_DEBUG_SCAN("Scan abort triggered due to "
5290 } else { 8169 "channel change.\n");
5291 ipw_associate(priv); 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;
5292 } 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);
5293 8190
5294 return 0; 8191 return 0;
5295} 8192}
@@ -5299,29 +8196,48 @@ static int ipw_wx_set_freq(struct net_device *dev,
5299 union iwreq_data *wrqu, char *extra) 8196 union iwreq_data *wrqu, char *extra)
5300{ 8197{
5301 struct ipw_priv *priv = ieee80211_priv(dev); 8198 struct ipw_priv *priv = ieee80211_priv(dev);
8199 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5302 struct iw_freq *fwrq = &wrqu->freq; 8200 struct iw_freq *fwrq = &wrqu->freq;
5303 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 }
5304 /* if setting by freq convert to channel */ 8212 /* if setting by freq convert to channel */
5305 if (fwrq->e == 1) { 8213 if (fwrq->e == 1) {
5306 if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) { 8214 channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
5307 int f = fwrq->m / 100000; 8215 if (channel == 0)
5308 int c = 0; 8216 return -EINVAL;
8217 } else
8218 channel = fwrq->m;
8219
8220 if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8221 return -EINVAL;
5309 8222
5310 while ((c < REG_MAX_CHANNEL) && 8223 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5311 (f != ipw_frequencies[c])) 8224 i = ipw_channel_to_index(priv->ieee, channel);
5312 c++; 8225 if (i == -1)
8226 return -EINVAL;
5313 8227
5314 /* hack to fall through */ 8228 flags = (band == IEEE80211_24GHZ_BAND) ?
5315 fwrq->e = 0; 8229 geo->bg[i].flags : geo->a[i].flags;
5316 fwrq->m = c + 1; 8230 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8231 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8232 return -EINVAL;
5317 } 8233 }
5318 } 8234 }
5319 8235
5320 if (fwrq->e > 0 || fwrq->m > 1000)
5321 return -EOPNOTSUPP;
5322
5323 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m); 8236 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
5324 return ipw_set_channel(priv, (u8) fwrq->m); 8237 down(&priv->sem);
8238 ret = ipw_set_channel(priv, channel);
8239 up(&priv->sem);
8240 return ret;
5325} 8241}
5326 8242
5327static int ipw_wx_get_freq(struct net_device *dev, 8243static int ipw_wx_get_freq(struct net_device *dev,
@@ -5334,12 +8250,14 @@ static int ipw_wx_get_freq(struct net_device *dev,
5334 8250
5335 /* If we are associated, trying to associate, or have a statically 8251 /* If we are associated, trying to associate, or have a statically
5336 * configured CHANNEL then return that; otherwise return ANY */ 8252 * configured CHANNEL then return that; otherwise return ANY */
8253 down(&priv->sem);
5337 if (priv->config & CFG_STATIC_CHANNEL || 8254 if (priv->config & CFG_STATIC_CHANNEL ||
5338 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) 8255 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
5339 wrqu->freq.m = priv->channel; 8256 wrqu->freq.m = priv->channel;
5340 else 8257 else
5341 wrqu->freq.m = 0; 8258 wrqu->freq.m = 0;
5342 8259
8260 up(&priv->sem);
5343 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel); 8261 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
5344 return 0; 8262 return 0;
5345} 8263}
@@ -5353,11 +8271,8 @@ static int ipw_wx_set_mode(struct net_device *dev,
5353 8271
5354 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode); 8272 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
5355 8273
5356 if (wrqu->mode == priv->ieee->iw_mode)
5357 return 0;
5358
5359 switch (wrqu->mode) { 8274 switch (wrqu->mode) {
5360#ifdef CONFIG_IPW_PROMISC 8275#ifdef CONFIG_IPW2200_MONITOR
5361 case IW_MODE_MONITOR: 8276 case IW_MODE_MONITOR:
5362#endif 8277#endif
5363 case IW_MODE_ADHOC: 8278 case IW_MODE_ADHOC:
@@ -5369,31 +8284,33 @@ static int ipw_wx_set_mode(struct net_device *dev,
5369 default: 8284 default:
5370 return -EINVAL; 8285 return -EINVAL;
5371 } 8286 }
8287 if (wrqu->mode == priv->ieee->iw_mode)
8288 return 0;
8289
8290 down(&priv->sem);
8291
8292 ipw_sw_reset(priv, 0);
5372 8293
5373#ifdef CONFIG_IPW_PROMISC 8294#ifdef CONFIG_IPW2200_MONITOR
5374 if (priv->ieee->iw_mode == IW_MODE_MONITOR) 8295 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
5375 priv->net_dev->type = ARPHRD_ETHER; 8296 priv->net_dev->type = ARPHRD_ETHER;
5376 8297
5377 if (wrqu->mode == IW_MODE_MONITOR) 8298 if (wrqu->mode == IW_MODE_MONITOR)
8299#ifdef CONFIG_IEEE80211_RADIOTAP
8300 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8301#else
5378 priv->net_dev->type = ARPHRD_IEEE80211; 8302 priv->net_dev->type = ARPHRD_IEEE80211;
5379#endif /* CONFIG_IPW_PROMISC */ 8303#endif
8304#endif /* CONFIG_IPW2200_MONITOR */
5380 8305
5381#ifdef CONFIG_PM
5382 /* Free the existing firmware and reset the fw_loaded 8306 /* Free the existing firmware and reset the fw_loaded
5383 * flag so ipw_load() will bring in the new firmawre */ 8307 * flag so ipw_load() will bring in the new firmawre */
5384 if (fw_loaded) { 8308 free_firmware();
5385 fw_loaded = 0;
5386 }
5387
5388 release_firmware(bootfw);
5389 release_firmware(ucode);
5390 release_firmware(firmware);
5391 bootfw = ucode = firmware = NULL;
5392#endif
5393 8309
5394 priv->ieee->iw_mode = wrqu->mode; 8310 priv->ieee->iw_mode = wrqu->mode;
5395 ipw_adapter_restart(priv);
5396 8311
8312 queue_work(priv->workqueue, &priv->adapter_restart);
8313 up(&priv->sem);
5397 return err; 8314 return err;
5398} 8315}
5399 8316
@@ -5402,20 +8319,13 @@ static int ipw_wx_get_mode(struct net_device *dev,
5402 union iwreq_data *wrqu, char *extra) 8319 union iwreq_data *wrqu, char *extra)
5403{ 8320{
5404 struct ipw_priv *priv = ieee80211_priv(dev); 8321 struct ipw_priv *priv = ieee80211_priv(dev);
5405 8322 down(&priv->sem);
5406 wrqu->mode = priv->ieee->iw_mode; 8323 wrqu->mode = priv->ieee->iw_mode;
5407 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode); 8324 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
5408 8325 up(&priv->sem);
5409 return 0; 8326 return 0;
5410} 8327}
5411 8328
5412#define DEFAULT_RTS_THRESHOLD 2304U
5413#define MIN_RTS_THRESHOLD 1U
5414#define MAX_RTS_THRESHOLD 2304U
5415#define DEFAULT_BEACON_INTERVAL 100U
5416#define DEFAULT_SHORT_RETRY_LIMIT 7U
5417#define DEFAULT_LONG_RETRY_LIMIT 4U
5418
5419/* Values are in microsecond */ 8329/* Values are in microsecond */
5420static const s32 timeout_duration[] = { 8330static const s32 timeout_duration[] = {
5421 350000, 8331 350000,
@@ -5439,8 +8349,8 @@ static int ipw_wx_get_range(struct net_device *dev,
5439{ 8349{
5440 struct ipw_priv *priv = ieee80211_priv(dev); 8350 struct ipw_priv *priv = ieee80211_priv(dev);
5441 struct iw_range *range = (struct iw_range *)extra; 8351 struct iw_range *range = (struct iw_range *)extra;
5442 u16 val; 8352 const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5443 int i; 8353 int i = 0, j;
5444 8354
5445 wrqu->data.length = sizeof(*range); 8355 wrqu->data.length = sizeof(*range);
5446 memset(range, 0, sizeof(*range)); 8356 memset(range, 0, sizeof(*range));
@@ -5451,7 +8361,7 @@ static int ipw_wx_get_range(struct net_device *dev,
5451 range->max_qual.qual = 100; 8361 range->max_qual.qual = 100;
5452 /* TODO: Find real max RSSI and stick here */ 8362 /* TODO: Find real max RSSI and stick here */
5453 range->max_qual.level = 0; 8363 range->max_qual.level = 0;
5454 range->max_qual.noise = 0; 8364 range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
5455 range->max_qual.updated = 7; /* Updated all three */ 8365 range->max_qual.updated = 7; /* Updated all three */
5456 8366
5457 range->avg_qual.qual = 70; 8367 range->avg_qual.qual = 70;
@@ -5459,7 +8369,7 @@ static int ipw_wx_get_range(struct net_device *dev,
5459 range->avg_qual.level = 0; /* FIXME to real average level */ 8369 range->avg_qual.level = 0; /* FIXME to real average level */
5460 range->avg_qual.noise = 0; 8370 range->avg_qual.noise = 0;
5461 range->avg_qual.updated = 7; /* Updated all three */ 8371 range->avg_qual.updated = 7; /* Updated all three */
5462 8372 down(&priv->sem);
5463 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES); 8373 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
5464 8374
5465 for (i = 0; i < range->num_bitrates; i++) 8375 for (i = 0; i < range->num_bitrates; i++)
@@ -5479,19 +8389,35 @@ static int ipw_wx_get_range(struct net_device *dev,
5479 range->we_version_compiled = WIRELESS_EXT; 8389 range->we_version_compiled = WIRELESS_EXT;
5480 range->we_version_source = 16; 8390 range->we_version_source = 16;
5481 8391
5482 range->num_channels = FREQ_COUNT; 8392 i = 0;
5483 8393 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
5484 val = 0; 8394 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
5485 for (i = 0; i < FREQ_COUNT; i++) { 8395 i++, j++) {
5486 range->freq[val].i = i + 1; 8396 range->freq[i].i = geo->bg[j].channel;
5487 range->freq[val].m = ipw_frequencies[i] * 100000; 8397 range->freq[i].m = geo->bg[j].freq * 100000;
5488 range->freq[val].e = 1; 8398 range->freq[i].e = 1;
5489 val++; 8399 }
8400 }
5490 8401
5491 if (val == IW_MAX_FREQUENCIES) 8402 if (priv->ieee->mode & IEEE_A) {
5492 break; 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 }
5493 } 8409 }
5494 range->num_frequency = val; 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;
5495 8421
5496 IPW_DEBUG_WX("GET Range\n"); 8422 IPW_DEBUG_WX("GET Range\n");
5497 return 0; 8423 return 0;
@@ -5512,25 +8438,23 @@ static int ipw_wx_set_wap(struct net_device *dev,
5512 8438
5513 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER) 8439 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
5514 return -EINVAL; 8440 return -EINVAL;
5515 8441 down(&priv->sem);
5516 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) || 8442 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
5517 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) { 8443 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
5518 /* we disable mandatory BSSID association */ 8444 /* we disable mandatory BSSID association */
5519 IPW_DEBUG_WX("Setting AP BSSID to ANY\n"); 8445 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
5520 priv->config &= ~CFG_STATIC_BSSID; 8446 priv->config &= ~CFG_STATIC_BSSID;
5521 if (!(priv->status & (STATUS_SCANNING | STATUS_ASSOCIATED | 8447 IPW_DEBUG_ASSOC("Attempting to associate with new "
5522 STATUS_ASSOCIATING))) { 8448 "parameters.\n");
5523 IPW_DEBUG_ASSOC("Attempting to associate with new " 8449 ipw_associate(priv);
5524 "parameters.\n"); 8450 up(&priv->sem);
5525 ipw_associate(priv);
5526 }
5527
5528 return 0; 8451 return 0;
5529 } 8452 }
5530 8453
5531 priv->config |= CFG_STATIC_BSSID; 8454 priv->config |= CFG_STATIC_BSSID;
5532 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) { 8455 if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
5533 IPW_DEBUG_WX("BSSID set to current BSSID.\n"); 8456 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8457 up(&priv->sem);
5534 return 0; 8458 return 0;
5535 } 8459 }
5536 8460
@@ -5539,15 +8463,12 @@ static int ipw_wx_set_wap(struct net_device *dev,
5539 8463
5540 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN); 8464 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
5541 8465
5542 /* If we are currently associated, or trying to associate 8466 /* Network configuration changed -- force [re]association */
5543 * then see if this is a new BSSID (causing us to disassociate) */ 8467 IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
5544 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) { 8468 if (!ipw_disassociate(priv))
5545 IPW_DEBUG_ASSOC("Disassociating due to BSSID change.\n");
5546 ipw_disassociate(priv);
5547 } else {
5548 ipw_associate(priv); 8469 ipw_associate(priv);
5549 }
5550 8470
8471 up(&priv->sem);
5551 return 0; 8472 return 0;
5552} 8473}
5553 8474
@@ -5558,15 +8479,17 @@ static int ipw_wx_get_wap(struct net_device *dev,
5558 struct ipw_priv *priv = ieee80211_priv(dev); 8479 struct ipw_priv *priv = ieee80211_priv(dev);
5559 /* If we are associated, trying to associate, or have a statically 8480 /* If we are associated, trying to associate, or have a statically
5560 * configured BSSID then return that; otherwise return ANY */ 8481 * configured BSSID then return that; otherwise return ANY */
8482 down(&priv->sem);
5561 if (priv->config & CFG_STATIC_BSSID || 8483 if (priv->config & CFG_STATIC_BSSID ||
5562 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) { 8484 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
5563 wrqu->ap_addr.sa_family = ARPHRD_ETHER; 8485 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
5564 memcpy(wrqu->ap_addr.sa_data, &priv->bssid, ETH_ALEN); 8486 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
5565 } else 8487 } else
5566 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN); 8488 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
5567 8489
5568 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n", 8490 IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
5569 MAC_ARG(wrqu->ap_addr.sa_data)); 8491 MAC_ARG(wrqu->ap_addr.sa_data));
8492 up(&priv->sem);
5570 return 0; 8493 return 0;
5571} 8494}
5572 8495
@@ -5577,21 +8500,22 @@ static int ipw_wx_set_essid(struct net_device *dev,
5577 struct ipw_priv *priv = ieee80211_priv(dev); 8500 struct ipw_priv *priv = ieee80211_priv(dev);
5578 char *essid = ""; /* ANY */ 8501 char *essid = ""; /* ANY */
5579 int length = 0; 8502 int length = 0;
5580 8503 down(&priv->sem);
5581 if (wrqu->essid.flags && wrqu->essid.length) { 8504 if (wrqu->essid.flags && wrqu->essid.length) {
5582 length = wrqu->essid.length - 1; 8505 length = wrqu->essid.length - 1;
5583 essid = extra; 8506 essid = extra;
5584 } 8507 }
5585 if (length == 0) { 8508 if (length == 0) {
5586 IPW_DEBUG_WX("Setting ESSID to ANY\n"); 8509 IPW_DEBUG_WX("Setting ESSID to ANY\n");
5587 priv->config &= ~CFG_STATIC_ESSID; 8510 if ((priv->config & CFG_STATIC_ESSID) &&
5588 if (!(priv->status & (STATUS_SCANNING | STATUS_ASSOCIATED | 8511 !(priv->status & (STATUS_ASSOCIATED |
5589 STATUS_ASSOCIATING))) { 8512 STATUS_ASSOCIATING))) {
5590 IPW_DEBUG_ASSOC("Attempting to associate with new " 8513 IPW_DEBUG_ASSOC("Attempting to associate with new "
5591 "parameters.\n"); 8514 "parameters.\n");
8515 priv->config &= ~CFG_STATIC_ESSID;
5592 ipw_associate(priv); 8516 ipw_associate(priv);
5593 } 8517 }
5594 8518 up(&priv->sem);
5595 return 0; 8519 return 0;
5596 } 8520 }
5597 8521
@@ -5601,6 +8525,7 @@ static int ipw_wx_set_essid(struct net_device *dev,
5601 8525
5602 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) { 8526 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
5603 IPW_DEBUG_WX("ESSID set to current ESSID.\n"); 8527 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8528 up(&priv->sem);
5604 return 0; 8529 return 0;
5605 } 8530 }
5606 8531
@@ -5610,15 +8535,12 @@ static int ipw_wx_set_essid(struct net_device *dev,
5610 priv->essid_len = length; 8535 priv->essid_len = length;
5611 memcpy(priv->essid, essid, priv->essid_len); 8536 memcpy(priv->essid, essid, priv->essid_len);
5612 8537
5613 /* If we are currently associated, or trying to associate 8538 /* Network configuration changed -- force [re]association */
5614 * then see if this is a new ESSID (causing us to disassociate) */ 8539 IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
5615 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) { 8540 if (!ipw_disassociate(priv))
5616 IPW_DEBUG_ASSOC("Disassociating due to ESSID change.\n");
5617 ipw_disassociate(priv);
5618 } else {
5619 ipw_associate(priv); 8541 ipw_associate(priv);
5620 }
5621 8542
8543 up(&priv->sem);
5622 return 0; 8544 return 0;
5623} 8545}
5624 8546
@@ -5630,6 +8552,7 @@ static int ipw_wx_get_essid(struct net_device *dev,
5630 8552
5631 /* If we are associated, trying to associate, or have a statically 8553 /* If we are associated, trying to associate, or have a statically
5632 * configured ESSID then return that; otherwise return ANY */ 8554 * configured ESSID then return that; otherwise return ANY */
8555 down(&priv->sem);
5633 if (priv->config & CFG_STATIC_ESSID || 8556 if (priv->config & CFG_STATIC_ESSID ||
5634 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) { 8557 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
5635 IPW_DEBUG_WX("Getting essid: '%s'\n", 8558 IPW_DEBUG_WX("Getting essid: '%s'\n",
@@ -5642,7 +8565,7 @@ static int ipw_wx_get_essid(struct net_device *dev,
5642 wrqu->essid.length = 0; 8565 wrqu->essid.length = 0;
5643 wrqu->essid.flags = 0; /* active */ 8566 wrqu->essid.flags = 0; /* active */
5644 } 8567 }
5645 8568 up(&priv->sem);
5646 return 0; 8569 return 0;
5647} 8570}
5648 8571
@@ -5655,11 +8578,12 @@ static int ipw_wx_set_nick(struct net_device *dev,
5655 IPW_DEBUG_WX("Setting nick to '%s'\n", extra); 8578 IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
5656 if (wrqu->data.length > IW_ESSID_MAX_SIZE) 8579 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
5657 return -E2BIG; 8580 return -E2BIG;
5658 8581 down(&priv->sem);
5659 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick)); 8582 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
5660 memset(priv->nick, 0, sizeof(priv->nick)); 8583 memset(priv->nick, 0, sizeof(priv->nick));
5661 memcpy(priv->nick, extra, wrqu->data.length); 8584 memcpy(priv->nick, extra, wrqu->data.length);
5662 IPW_DEBUG_TRACE("<<\n"); 8585 IPW_DEBUG_TRACE("<<\n");
8586 up(&priv->sem);
5663 return 0; 8587 return 0;
5664 8588
5665} 8589}
@@ -5670,9 +8594,11 @@ static int ipw_wx_get_nick(struct net_device *dev,
5670{ 8594{
5671 struct ipw_priv *priv = ieee80211_priv(dev); 8595 struct ipw_priv *priv = ieee80211_priv(dev);
5672 IPW_DEBUG_WX("Getting nick\n"); 8596 IPW_DEBUG_WX("Getting nick\n");
8597 down(&priv->sem);
5673 wrqu->data.length = strlen(priv->nick) + 1; 8598 wrqu->data.length = strlen(priv->nick) + 1;
5674 memcpy(extra, priv->nick, wrqu->data.length); 8599 memcpy(extra, priv->nick, wrqu->data.length);
5675 wrqu->data.flags = 1; /* active */ 8600 wrqu->data.flags = 1; /* active */
8601 up(&priv->sem);
5676 return 0; 8602 return 0;
5677} 8603}
5678 8604
@@ -5680,8 +8606,113 @@ static int ipw_wx_set_rate(struct net_device *dev,
5680 struct iw_request_info *info, 8606 struct iw_request_info *info,
5681 union iwreq_data *wrqu, char *extra) 8607 union iwreq_data *wrqu, char *extra)
5682{ 8608{
5683 IPW_DEBUG_WX("0x%p, 0x%p, 0x%p\n", dev, info, wrqu); 8609 /* TODO: We should use semaphores or locks for access to priv */
5684 return -EOPNOTSUPP; 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;
5685} 8716}
5686 8717
5687static int ipw_wx_get_rate(struct net_device *dev, 8718static int ipw_wx_get_rate(struct net_device *dev,
@@ -5689,8 +8720,9 @@ static int ipw_wx_get_rate(struct net_device *dev,
5689 union iwreq_data *wrqu, char *extra) 8720 union iwreq_data *wrqu, char *extra)
5690{ 8721{
5691 struct ipw_priv *priv = ieee80211_priv(dev); 8722 struct ipw_priv *priv = ieee80211_priv(dev);
8723 down(&priv->sem);
5692 wrqu->bitrate.value = priv->last_rate; 8724 wrqu->bitrate.value = priv->last_rate;
5693 8725 up(&priv->sem);
5694 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value); 8726 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
5695 return 0; 8727 return 0;
5696} 8728}
@@ -5700,18 +8732,20 @@ static int ipw_wx_set_rts(struct net_device *dev,
5700 union iwreq_data *wrqu, char *extra) 8732 union iwreq_data *wrqu, char *extra)
5701{ 8733{
5702 struct ipw_priv *priv = ieee80211_priv(dev); 8734 struct ipw_priv *priv = ieee80211_priv(dev);
5703 8735 down(&priv->sem);
5704 if (wrqu->rts.disabled) 8736 if (wrqu->rts.disabled)
5705 priv->rts_threshold = DEFAULT_RTS_THRESHOLD; 8737 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
5706 else { 8738 else {
5707 if (wrqu->rts.value < MIN_RTS_THRESHOLD || 8739 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
5708 wrqu->rts.value > MAX_RTS_THRESHOLD) 8740 wrqu->rts.value > MAX_RTS_THRESHOLD) {
8741 up(&priv->sem);
5709 return -EINVAL; 8742 return -EINVAL;
5710 8743 }
5711 priv->rts_threshold = wrqu->rts.value; 8744 priv->rts_threshold = wrqu->rts.value;
5712 } 8745 }
5713 8746
5714 ipw_send_rts_threshold(priv, priv->rts_threshold); 8747 ipw_send_rts_threshold(priv, priv->rts_threshold);
8748 up(&priv->sem);
5715 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold); 8749 IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
5716 return 0; 8750 return 0;
5717} 8751}
@@ -5721,10 +8755,11 @@ static int ipw_wx_get_rts(struct net_device *dev,
5721 union iwreq_data *wrqu, char *extra) 8755 union iwreq_data *wrqu, char *extra)
5722{ 8756{
5723 struct ipw_priv *priv = ieee80211_priv(dev); 8757 struct ipw_priv *priv = ieee80211_priv(dev);
8758 down(&priv->sem);
5724 wrqu->rts.value = priv->rts_threshold; 8759 wrqu->rts.value = priv->rts_threshold;
5725 wrqu->rts.fixed = 0; /* no auto select */ 8760 wrqu->rts.fixed = 0; /* no auto select */
5726 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD); 8761 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
5727 8762 up(&priv->sem);
5728 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value); 8763 IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
5729 return 0; 8764 return 0;
5730} 8765}
@@ -5734,41 +8769,33 @@ static int ipw_wx_set_txpow(struct net_device *dev,
5734 union iwreq_data *wrqu, char *extra) 8769 union iwreq_data *wrqu, char *extra)
5735{ 8770{
5736 struct ipw_priv *priv = ieee80211_priv(dev); 8771 struct ipw_priv *priv = ieee80211_priv(dev);
5737 struct ipw_tx_power tx_power; 8772 int err = 0;
5738 int i;
5739
5740 if (ipw_radio_kill_sw(priv, wrqu->power.disabled))
5741 return -EINPROGRESS;
5742
5743 if (wrqu->power.flags != IW_TXPOW_DBM)
5744 return -EINVAL;
5745 8773
5746 if ((wrqu->power.value > 20) || (wrqu->power.value < -12)) 8774 down(&priv->sem);
5747 return -EINVAL; 8775 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
8776 err = -EINPROGRESS;
8777 goto out;
8778 }
5748 8779
5749 priv->tx_power = wrqu->power.value; 8780 if (!wrqu->power.fixed)
8781 wrqu->power.value = IPW_TX_POWER_DEFAULT;
5750 8782
5751 memset(&tx_power, 0, sizeof(tx_power)); 8783 if (wrqu->power.flags != IW_TXPOW_DBM) {
5752 8784 err = -EINVAL;
5753 /* configure device for 'G' band */ 8785 goto out;
5754 tx_power.ieee_mode = IPW_G_MODE;
5755 tx_power.num_channels = 11;
5756 for (i = 0; i < 11; i++) {
5757 tx_power.channels_tx_power[i].channel_number = i + 1;
5758 tx_power.channels_tx_power[i].tx_power = priv->tx_power;
5759 } 8786 }
5760 if (ipw_send_tx_power(priv, &tx_power))
5761 goto error;
5762 8787
5763 /* configure device to also handle 'B' band */ 8788 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
5764 tx_power.ieee_mode = IPW_B_MODE; 8789 (wrqu->power.value < IPW_TX_POWER_MIN)) {
5765 if (ipw_send_tx_power(priv, &tx_power)) 8790 err = -EINVAL;
5766 goto error; 8791 goto out;
5767 8792 }
5768 return 0;
5769 8793
5770 error: 8794 priv->tx_power = wrqu->power.value;
5771 return -EIO; 8795 err = ipw_set_tx_power(priv);
8796 out:
8797 up(&priv->sem);
8798 return err;
5772} 8799}
5773 8800
5774static int ipw_wx_get_txpow(struct net_device *dev, 8801static int ipw_wx_get_txpow(struct net_device *dev,
@@ -5776,14 +8803,15 @@ static int ipw_wx_get_txpow(struct net_device *dev,
5776 union iwreq_data *wrqu, char *extra) 8803 union iwreq_data *wrqu, char *extra)
5777{ 8804{
5778 struct ipw_priv *priv = ieee80211_priv(dev); 8805 struct ipw_priv *priv = ieee80211_priv(dev);
5779 8806 down(&priv->sem);
5780 wrqu->power.value = priv->tx_power; 8807 wrqu->power.value = priv->tx_power;
5781 wrqu->power.fixed = 1; 8808 wrqu->power.fixed = 1;
5782 wrqu->power.flags = IW_TXPOW_DBM; 8809 wrqu->power.flags = IW_TXPOW_DBM;
5783 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0; 8810 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
8811 up(&priv->sem);
5784 8812
5785 IPW_DEBUG_WX("GET TX Power -> %s %d \n", 8813 IPW_DEBUG_WX("GET TX Power -> %s %d \n",
5786 wrqu->power.disabled ? "ON" : "OFF", wrqu->power.value); 8814 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
5787 8815
5788 return 0; 8816 return 0;
5789} 8817}
@@ -5793,18 +8821,21 @@ static int ipw_wx_set_frag(struct net_device *dev,
5793 union iwreq_data *wrqu, char *extra) 8821 union iwreq_data *wrqu, char *extra)
5794{ 8822{
5795 struct ipw_priv *priv = ieee80211_priv(dev); 8823 struct ipw_priv *priv = ieee80211_priv(dev);
5796 8824 down(&priv->sem);
5797 if (wrqu->frag.disabled) 8825 if (wrqu->frag.disabled)
5798 priv->ieee->fts = DEFAULT_FTS; 8826 priv->ieee->fts = DEFAULT_FTS;
5799 else { 8827 else {
5800 if (wrqu->frag.value < MIN_FRAG_THRESHOLD || 8828 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
5801 wrqu->frag.value > MAX_FRAG_THRESHOLD) 8829 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8830 up(&priv->sem);
5802 return -EINVAL; 8831 return -EINVAL;
8832 }
5803 8833
5804 priv->ieee->fts = wrqu->frag.value & ~0x1; 8834 priv->ieee->fts = wrqu->frag.value & ~0x1;
5805 } 8835 }
5806 8836
5807 ipw_send_frag_threshold(priv, wrqu->frag.value); 8837 ipw_send_frag_threshold(priv, wrqu->frag.value);
8838 up(&priv->sem);
5808 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value); 8839 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
5809 return 0; 8840 return 0;
5810} 8841}
@@ -5814,10 +8845,11 @@ static int ipw_wx_get_frag(struct net_device *dev,
5814 union iwreq_data *wrqu, char *extra) 8845 union iwreq_data *wrqu, char *extra)
5815{ 8846{
5816 struct ipw_priv *priv = ieee80211_priv(dev); 8847 struct ipw_priv *priv = ieee80211_priv(dev);
8848 down(&priv->sem);
5817 wrqu->frag.value = priv->ieee->fts; 8849 wrqu->frag.value = priv->ieee->fts;
5818 wrqu->frag.fixed = 0; /* no auto select */ 8850 wrqu->frag.fixed = 0; /* no auto select */
5819 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS); 8851 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
5820 8852 up(&priv->sem);
5821 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value); 8853 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
5822 8854
5823 return 0; 8855 return 0;
@@ -5827,16 +8859,128 @@ static int ipw_wx_set_retry(struct net_device *dev,
5827 struct iw_request_info *info, 8859 struct iw_request_info *info,
5828 union iwreq_data *wrqu, char *extra) 8860 union iwreq_data *wrqu, char *extra)
5829{ 8861{
5830 IPW_DEBUG_WX("0x%p, 0x%p, 0x%p\n", dev, info, wrqu); 8862 struct ipw_priv *priv = ieee80211_priv(dev);
5831 return -EOPNOTSUPP; 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;
5832} 8889}
5833 8890
5834static int ipw_wx_get_retry(struct net_device *dev, 8891static int ipw_wx_get_retry(struct net_device *dev,
5835 struct iw_request_info *info, 8892 struct iw_request_info *info,
5836 union iwreq_data *wrqu, char *extra) 8893 union iwreq_data *wrqu, char *extra)
5837{ 8894{
5838 IPW_DEBUG_WX("0x%p, 0x%p, 0x%p\n", dev, info, wrqu); 8895 struct ipw_priv *priv = ieee80211_priv(dev);
5839 return -EOPNOTSUPP; 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 down(&priv->sem);
8929
8930 if (priv->status & STATUS_RF_KILL_MASK) {
8931 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8932 priv->status |= STATUS_SCAN_PENDING;
8933 goto done;
8934 }
8935
8936 IPW_DEBUG_HC("starting request direct scan!\n");
8937
8938 if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
8939 err = wait_event_interruptible(priv->wait_state,
8940 !(priv->
8941 status & (STATUS_SCANNING |
8942 STATUS_SCAN_ABORTING)));
8943 if (err) {
8944 IPW_DEBUG_HC("aborting direct scan");
8945 goto done;
8946 }
8947 }
8948 memset(&scan, 0, sizeof(scan));
8949
8950 if (priv->config & CFG_SPEED_SCAN)
8951 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8952 cpu_to_le16(30);
8953 else
8954 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8955 cpu_to_le16(20);
8956
8957 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8958 cpu_to_le16(20);
8959 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8960 scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8961
8962 scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8963
8964 err = ipw_send_ssid(priv, essid, essid_len);
8965 if (err) {
8966 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8967 goto done;
8968 }
8969 scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8970
8971 ipw_add_scan_channels(priv, &scan, scan_type);
8972
8973 err = ipw_send_scan_request_ext(priv, &scan);
8974 if (err) {
8975 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8976 goto done;
8977 }
8978
8979 priv->status |= STATUS_SCANNING;
8980
8981 done:
8982 up(&priv->sem);
8983 return err;
5840} 8984}
5841 8985
5842static int ipw_wx_set_scan(struct net_device *dev, 8986static int ipw_wx_set_scan(struct net_device *dev,
@@ -5844,9 +8988,21 @@ static int ipw_wx_set_scan(struct net_device *dev,
5844 union iwreq_data *wrqu, char *extra) 8988 union iwreq_data *wrqu, char *extra)
5845{ 8989{
5846 struct ipw_priv *priv = ieee80211_priv(dev); 8990 struct ipw_priv *priv = ieee80211_priv(dev);
8991 struct iw_scan_req *req = NULL;
8992 if (wrqu->data.length
8993 && wrqu->data.length == sizeof(struct iw_scan_req)) {
8994 req = (struct iw_scan_req *)extra;
8995 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
8996 ipw_request_direct_scan(priv, req->essid,
8997 req->essid_len);
8998 return 0;
8999 }
9000 }
9001
5847 IPW_DEBUG_WX("Start scan\n"); 9002 IPW_DEBUG_WX("Start scan\n");
5848 if (ipw_request_scan(priv)) 9003
5849 return -EIO; 9004 queue_work(priv->workqueue, &priv->request_scan);
9005
5850 return 0; 9006 return 0;
5851} 9007}
5852 9008
@@ -5863,7 +9019,21 @@ static int ipw_wx_set_encode(struct net_device *dev,
5863 union iwreq_data *wrqu, char *key) 9019 union iwreq_data *wrqu, char *key)
5864{ 9020{
5865 struct ipw_priv *priv = ieee80211_priv(dev); 9021 struct ipw_priv *priv = ieee80211_priv(dev);
5866 return ieee80211_wx_set_encode(priv->ieee, info, wrqu, key); 9022 int ret;
9023 u32 cap = priv->capability;
9024
9025 down(&priv->sem);
9026 ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9027
9028 /* In IBSS mode, we need to notify the firmware to update
9029 * the beacon info after we changed the capability. */
9030 if (cap != priv->capability &&
9031 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9032 priv->status & STATUS_ASSOCIATED)
9033 ipw_disassociate(priv);
9034
9035 up(&priv->sem);
9036 return ret;
5867} 9037}
5868 9038
5869static int ipw_wx_get_encode(struct net_device *dev, 9039static int ipw_wx_get_encode(struct net_device *dev,
@@ -5880,17 +9050,17 @@ static int ipw_wx_set_power(struct net_device *dev,
5880{ 9050{
5881 struct ipw_priv *priv = ieee80211_priv(dev); 9051 struct ipw_priv *priv = ieee80211_priv(dev);
5882 int err; 9052 int err;
5883 9053 down(&priv->sem);
5884 if (wrqu->power.disabled) { 9054 if (wrqu->power.disabled) {
5885 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode); 9055 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
5886 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM); 9056 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
5887 if (err) { 9057 if (err) {
5888 IPW_DEBUG_WX("failed setting power mode.\n"); 9058 IPW_DEBUG_WX("failed setting power mode.\n");
9059 up(&priv->sem);
5889 return err; 9060 return err;
5890 } 9061 }
5891
5892 IPW_DEBUG_WX("SET Power Management Mode -> off\n"); 9062 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
5893 9063 up(&priv->sem);
5894 return 0; 9064 return 0;
5895 } 9065 }
5896 9066
@@ -5902,6 +9072,7 @@ static int ipw_wx_set_power(struct net_device *dev,
5902 default: /* Otherwise we don't support it */ 9072 default: /* Otherwise we don't support it */
5903 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n", 9073 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
5904 wrqu->power.flags); 9074 wrqu->power.flags);
9075 up(&priv->sem);
5905 return -EOPNOTSUPP; 9076 return -EOPNOTSUPP;
5906 } 9077 }
5907 9078
@@ -5914,11 +9085,12 @@ static int ipw_wx_set_power(struct net_device *dev,
5914 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode)); 9085 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
5915 if (err) { 9086 if (err) {
5916 IPW_DEBUG_WX("failed setting power mode.\n"); 9087 IPW_DEBUG_WX("failed setting power mode.\n");
9088 up(&priv->sem);
5917 return err; 9089 return err;
5918 } 9090 }
5919 9091
5920 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode); 9092 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
5921 9093 up(&priv->sem);
5922 return 0; 9094 return 0;
5923} 9095}
5924 9096
@@ -5927,13 +9099,13 @@ static int ipw_wx_get_power(struct net_device *dev,
5927 union iwreq_data *wrqu, char *extra) 9099 union iwreq_data *wrqu, char *extra)
5928{ 9100{
5929 struct ipw_priv *priv = ieee80211_priv(dev); 9101 struct ipw_priv *priv = ieee80211_priv(dev);
5930 9102 down(&priv->sem);
5931 if (!(priv->power_mode & IPW_POWER_ENABLED)) { 9103 if (!(priv->power_mode & IPW_POWER_ENABLED))
5932 wrqu->power.disabled = 1; 9104 wrqu->power.disabled = 1;
5933 } else { 9105 else
5934 wrqu->power.disabled = 0; 9106 wrqu->power.disabled = 0;
5935 }
5936 9107
9108 up(&priv->sem);
5937 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode); 9109 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
5938 9110
5939 return 0; 9111 return 0;
@@ -5946,7 +9118,7 @@ static int ipw_wx_set_powermode(struct net_device *dev,
5946 struct ipw_priv *priv = ieee80211_priv(dev); 9118 struct ipw_priv *priv = ieee80211_priv(dev);
5947 int mode = *(int *)extra; 9119 int mode = *(int *)extra;
5948 int err; 9120 int err;
5949 9121 down(&priv->sem);
5950 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) { 9122 if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
5951 mode = IPW_POWER_AC; 9123 mode = IPW_POWER_AC;
5952 priv->power_mode = mode; 9124 priv->power_mode = mode;
@@ -5959,10 +9131,11 @@ static int ipw_wx_set_powermode(struct net_device *dev,
5959 9131
5960 if (err) { 9132 if (err) {
5961 IPW_DEBUG_WX("failed setting power mode.\n"); 9133 IPW_DEBUG_WX("failed setting power mode.\n");
9134 up(&priv->sem);
5962 return err; 9135 return err;
5963 } 9136 }
5964 } 9137 }
5965 9138 up(&priv->sem);
5966 return 0; 9139 return 0;
5967} 9140}
5968 9141
@@ -6011,7 +9184,7 @@ static int ipw_wx_set_wireless_mode(struct net_device *dev,
6011 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode); 9184 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
6012 return -EINVAL; 9185 return -EINVAL;
6013 } 9186 }
6014 9187 down(&priv->sem);
6015 if (priv->adapter == IPW_2915ABG) { 9188 if (priv->adapter == IPW_2915ABG) {
6016 priv->ieee->abg_true = 1; 9189 priv->ieee->abg_true = 1;
6017 if (mode & IEEE_A) { 9190 if (mode & IEEE_A) {
@@ -6023,6 +9196,7 @@ static int ipw_wx_set_wireless_mode(struct net_device *dev,
6023 if (mode & IEEE_A) { 9196 if (mode & IEEE_A) {
6024 IPW_WARNING("Attempt to set 2200BG into " 9197 IPW_WARNING("Attempt to set 2200BG into "
6025 "802.11a mode\n"); 9198 "802.11a mode\n");
9199 up(&priv->sem);
6026 return -EINVAL; 9200 return -EINVAL;
6027 } 9201 }
6028 9202
@@ -6046,20 +9220,20 @@ static int ipw_wx_set_wireless_mode(struct net_device *dev,
6046 priv->ieee->modulation = modulation; 9220 priv->ieee->modulation = modulation;
6047 init_supported_rates(priv, &priv->rates); 9221 init_supported_rates(priv, &priv->rates);
6048 9222
6049 /* If we are currently associated, or trying to associate 9223 /* Network configuration changed -- force [re]association */
6050 * then see if this is a new configuration (causing us to 9224 IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
6051 * disassociate) */ 9225 if (!ipw_disassociate(priv)) {
6052 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
6053 /* The resulting association will trigger
6054 * the new rates to be sent to the device */
6055 IPW_DEBUG_ASSOC("Disassociating due to mode change.\n");
6056 ipw_disassociate(priv);
6057 } else
6058 ipw_send_supported_rates(priv, &priv->rates); 9226 ipw_send_supported_rates(priv, &priv->rates);
9227 ipw_associate(priv);
9228 }
9229
9230 /* Update the band LEDs */
9231 ipw_led_band_on(priv);
6059 9232
6060 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n", 9233 IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
6061 mode & IEEE_A ? 'a' : '.', 9234 mode & IEEE_A ? 'a' : '.',
6062 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.'); 9235 mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9236 up(&priv->sem);
6063 return 0; 9237 return 0;
6064} 9238}
6065 9239
@@ -6068,124 +9242,234 @@ static int ipw_wx_get_wireless_mode(struct net_device *dev,
6068 union iwreq_data *wrqu, char *extra) 9242 union iwreq_data *wrqu, char *extra)
6069{ 9243{
6070 struct ipw_priv *priv = ieee80211_priv(dev); 9244 struct ipw_priv *priv = ieee80211_priv(dev);
6071 9245 down(&priv->sem);
6072 switch (priv->ieee->freq_band) { 9246 switch (priv->ieee->mode) {
6073 case IEEE80211_24GHZ_BAND: 9247 case IEEE_A:
6074 switch (priv->ieee->modulation) {
6075 case IEEE80211_CCK_MODULATION:
6076 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
6077 break;
6078 case IEEE80211_OFDM_MODULATION:
6079 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
6080 break;
6081 default:
6082 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
6083 break;
6084 }
6085 break;
6086
6087 case IEEE80211_52GHZ_BAND:
6088 strncpy(extra, "802.11a (1)", MAX_WX_STRING); 9248 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
6089 break; 9249 break;
6090 9250 case IEEE_B:
6091 default: /* Mixed Band */ 9251 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
6092 switch (priv->ieee->modulation) { 9252 break;
6093 case IEEE80211_CCK_MODULATION: 9253 case IEEE_A | IEEE_B:
6094 strncpy(extra, "802.11ab (3)", MAX_WX_STRING); 9254 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
6095 break; 9255 break;
6096 case IEEE80211_OFDM_MODULATION: 9256 case IEEE_G:
6097 strncpy(extra, "802.11ag (5)", MAX_WX_STRING); 9257 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
6098 break; 9258 break;
6099 default: 9259 case IEEE_A | IEEE_G:
6100 strncpy(extra, "802.11abg (7)", MAX_WX_STRING); 9260 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
6101 break; 9261 break;
6102 } 9262 case IEEE_B | IEEE_G:
9263 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9264 break;
9265 case IEEE_A | IEEE_B | IEEE_G:
9266 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9267 break;
9268 default:
9269 strncpy(extra, "unknown", MAX_WX_STRING);
6103 break; 9270 break;
6104 } 9271 }
6105 9272
6106 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra); 9273 IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
6107 9274
6108 wrqu->data.length = strlen(extra) + 1; 9275 wrqu->data.length = strlen(extra) + 1;
9276 up(&priv->sem);
6109 9277
6110 return 0; 9278 return 0;
6111} 9279}
6112 9280
6113#ifdef CONFIG_IPW_PROMISC 9281static int ipw_wx_set_preamble(struct net_device *dev,
6114static int ipw_wx_set_promisc(struct net_device *dev, 9282 struct iw_request_info *info,
9283 union iwreq_data *wrqu, char *extra)
9284{
9285 struct ipw_priv *priv = ieee80211_priv(dev);
9286 int mode = *(int *)extra;
9287 down(&priv->sem);
9288 /* Switching from SHORT -> LONG requires a disassociation */
9289 if (mode == 1) {
9290 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9291 priv->config |= CFG_PREAMBLE_LONG;
9292
9293 /* Network configuration changed -- force [re]association */
9294 IPW_DEBUG_ASSOC
9295 ("[re]association triggered due to preamble change.\n");
9296 if (!ipw_disassociate(priv))
9297 ipw_associate(priv);
9298 }
9299 goto done;
9300 }
9301
9302 if (mode == 0) {
9303 priv->config &= ~CFG_PREAMBLE_LONG;
9304 goto done;
9305 }
9306 up(&priv->sem);
9307 return -EINVAL;
9308
9309 done:
9310 up(&priv->sem);
9311 return 0;
9312}
9313
9314static int ipw_wx_get_preamble(struct net_device *dev,
9315 struct iw_request_info *info,
9316 union iwreq_data *wrqu, char *extra)
9317{
9318 struct ipw_priv *priv = ieee80211_priv(dev);
9319 down(&priv->sem);
9320 if (priv->config & CFG_PREAMBLE_LONG)
9321 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9322 else
9323 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9324 up(&priv->sem);
9325 return 0;
9326}
9327
9328#ifdef CONFIG_IPW2200_MONITOR
9329static int ipw_wx_set_monitor(struct net_device *dev,
6115 struct iw_request_info *info, 9330 struct iw_request_info *info,
6116 union iwreq_data *wrqu, char *extra) 9331 union iwreq_data *wrqu, char *extra)
6117{ 9332{
6118 struct ipw_priv *priv = ieee80211_priv(dev); 9333 struct ipw_priv *priv = ieee80211_priv(dev);
6119 int *parms = (int *)extra; 9334 int *parms = (int *)extra;
6120 int enable = (parms[0] > 0); 9335 int enable = (parms[0] > 0);
6121 9336 down(&priv->sem);
6122 IPW_DEBUG_WX("SET PROMISC: %d %d\n", enable, parms[1]); 9337 IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
6123 if (enable) { 9338 if (enable) {
6124 if (priv->ieee->iw_mode != IW_MODE_MONITOR) { 9339 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9340#ifdef CONFIG_IEEE80211_RADIOTAP
9341 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9342#else
6125 priv->net_dev->type = ARPHRD_IEEE80211; 9343 priv->net_dev->type = ARPHRD_IEEE80211;
6126 ipw_adapter_restart(priv); 9344#endif
9345 queue_work(priv->workqueue, &priv->adapter_restart);
6127 } 9346 }
6128 9347
6129 ipw_set_channel(priv, parms[1]); 9348 ipw_set_channel(priv, parms[1]);
6130 } else { 9349 } else {
6131 if (priv->ieee->iw_mode != IW_MODE_MONITOR) 9350 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9351 up(&priv->sem);
6132 return 0; 9352 return 0;
9353 }
6133 priv->net_dev->type = ARPHRD_ETHER; 9354 priv->net_dev->type = ARPHRD_ETHER;
6134 ipw_adapter_restart(priv); 9355 queue_work(priv->workqueue, &priv->adapter_restart);
6135 } 9356 }
9357 up(&priv->sem);
6136 return 0; 9358 return 0;
6137} 9359}
6138 9360
9361#endif // CONFIG_IPW2200_MONITOR
9362
6139static int ipw_wx_reset(struct net_device *dev, 9363static int ipw_wx_reset(struct net_device *dev,
6140 struct iw_request_info *info, 9364 struct iw_request_info *info,
6141 union iwreq_data *wrqu, char *extra) 9365 union iwreq_data *wrqu, char *extra)
6142{ 9366{
6143 struct ipw_priv *priv = ieee80211_priv(dev); 9367 struct ipw_priv *priv = ieee80211_priv(dev);
6144 IPW_DEBUG_WX("RESET\n"); 9368 IPW_DEBUG_WX("RESET\n");
6145 ipw_adapter_restart(priv); 9369 queue_work(priv->workqueue, &priv->adapter_restart);
9370 return 0;
9371}
9372
9373static int ipw_wx_sw_reset(struct net_device *dev,
9374 struct iw_request_info *info,
9375 union iwreq_data *wrqu, char *extra)
9376{
9377 struct ipw_priv *priv = ieee80211_priv(dev);
9378 union iwreq_data wrqu_sec = {
9379 .encoding = {
9380 .flags = IW_ENCODE_DISABLED,
9381 },
9382 };
9383 int ret;
9384
9385 IPW_DEBUG_WX("SW_RESET\n");
9386
9387 down(&priv->sem);
9388
9389 ret = ipw_sw_reset(priv, 0);
9390 if (!ret) {
9391 free_firmware();
9392 ipw_adapter_restart(priv);
9393 }
9394
9395 /* The SW reset bit might have been toggled on by the 'disable'
9396 * module parameter, so take appropriate action */
9397 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9398
9399 up(&priv->sem);
9400 ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9401 down(&priv->sem);
9402
9403 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9404 /* Configuration likely changed -- force [re]association */
9405 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9406 "reset.\n");
9407 if (!ipw_disassociate(priv))
9408 ipw_associate(priv);
9409 }
9410
9411 up(&priv->sem);
9412
6146 return 0; 9413 return 0;
6147} 9414}
6148#endif // CONFIG_IPW_PROMISC
6149 9415
6150/* Rebase the WE IOCTLs to zero for the handler array */ 9416/* Rebase the WE IOCTLs to zero for the handler array */
6151#define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT] 9417#define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
6152static iw_handler ipw_wx_handlers[] = { 9418static iw_handler ipw_wx_handlers[] = {
6153 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name, 9419 IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
6154 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq, 9420 IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
6155 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq, 9421 IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
6156 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode, 9422 IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
6157 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode, 9423 IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
6158 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range, 9424 IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
6159 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap, 9425 IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
6160 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap, 9426 IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
6161 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan, 9427 IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
6162 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan, 9428 IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
6163 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid, 9429 IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
6164 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid, 9430 IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
6165 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick, 9431 IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
6166 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick, 9432 IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
6167 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate, 9433 IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
6168 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate, 9434 IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
6169 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts, 9435 IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
6170 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts, 9436 IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
6171 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag, 9437 IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
6172 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag, 9438 IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
6173 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow, 9439 IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
6174 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow, 9440 IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
6175 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry, 9441 IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
6176 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry, 9442 IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
6177 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode, 9443 IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
6178 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode, 9444 IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
6179 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power, 9445 IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
6180 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power, 9446 IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9447 IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9448 IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9449 IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9450 IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9451 IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9452 IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9453 IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9454 IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9455 IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9456 IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9457 IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
6181}; 9458};
6182 9459
6183#define IPW_PRIV_SET_POWER SIOCIWFIRSTPRIV 9460enum {
6184#define IPW_PRIV_GET_POWER SIOCIWFIRSTPRIV+1 9461 IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
6185#define IPW_PRIV_SET_MODE SIOCIWFIRSTPRIV+2 9462 IPW_PRIV_GET_POWER,
6186#define IPW_PRIV_GET_MODE SIOCIWFIRSTPRIV+3 9463 IPW_PRIV_SET_MODE,
6187#define IPW_PRIV_SET_PROMISC SIOCIWFIRSTPRIV+4 9464 IPW_PRIV_GET_MODE,
6188#define IPW_PRIV_RESET SIOCIWFIRSTPRIV+5 9465 IPW_PRIV_SET_PREAMBLE,
9466 IPW_PRIV_GET_PREAMBLE,
9467 IPW_PRIV_RESET,
9468 IPW_PRIV_SW_RESET,
9469#ifdef CONFIG_IPW2200_MONITOR
9470 IPW_PRIV_SET_MONITOR,
9471#endif
9472};
6189 9473
6190static struct iw_priv_args ipw_priv_args[] = { 9474static struct iw_priv_args ipw_priv_args[] = {
6191 { 9475 {
@@ -6204,14 +9488,25 @@ static struct iw_priv_args ipw_priv_args[] = {
6204 .cmd = IPW_PRIV_GET_MODE, 9488 .cmd = IPW_PRIV_GET_MODE,
6205 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING, 9489 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
6206 .name = "get_mode"}, 9490 .name = "get_mode"},
6207#ifdef CONFIG_IPW_PROMISC
6208 { 9491 {
6209 IPW_PRIV_SET_PROMISC, 9492 .cmd = IPW_PRIV_SET_PREAMBLE,
6210 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"}, 9493 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9494 .name = "set_preamble"},
9495 {
9496 .cmd = IPW_PRIV_GET_PREAMBLE,
9497 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9498 .name = "get_preamble"},
6211 { 9499 {
6212 IPW_PRIV_RESET, 9500 IPW_PRIV_RESET,
6213 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"}, 9501 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
6214#endif /* CONFIG_IPW_PROMISC */ 9502 {
9503 IPW_PRIV_SW_RESET,
9504 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9505#ifdef CONFIG_IPW2200_MONITOR
9506 {
9507 IPW_PRIV_SET_MONITOR,
9508 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9509#endif /* CONFIG_IPW2200_MONITOR */
6215}; 9510};
6216 9511
6217static iw_handler ipw_priv_handler[] = { 9512static iw_handler ipw_priv_handler[] = {
@@ -6219,19 +9514,23 @@ static iw_handler ipw_priv_handler[] = {
6219 ipw_wx_get_powermode, 9514 ipw_wx_get_powermode,
6220 ipw_wx_set_wireless_mode, 9515 ipw_wx_set_wireless_mode,
6221 ipw_wx_get_wireless_mode, 9516 ipw_wx_get_wireless_mode,
6222#ifdef CONFIG_IPW_PROMISC 9517 ipw_wx_set_preamble,
6223 ipw_wx_set_promisc, 9518 ipw_wx_get_preamble,
6224 ipw_wx_reset, 9519 ipw_wx_reset,
9520 ipw_wx_sw_reset,
9521#ifdef CONFIG_IPW2200_MONITOR
9522 ipw_wx_set_monitor,
6225#endif 9523#endif
6226}; 9524};
6227 9525
6228static struct iw_handler_def ipw_wx_handler_def = { 9526static struct iw_handler_def ipw_wx_handler_def = {
6229 .standard = ipw_wx_handlers, 9527 .standard = ipw_wx_handlers,
6230 .num_standard = ARRAY_SIZE(ipw_wx_handlers), 9528 .num_standard = ARRAY_SIZE(ipw_wx_handlers),
6231 .num_private = ARRAY_SIZE(ipw_priv_handler), 9529 .num_private = ARRAY_SIZE(ipw_priv_handler),
6232 .num_private_args = ARRAY_SIZE(ipw_priv_args), 9530 .num_private_args = ARRAY_SIZE(ipw_priv_args),
6233 .private = ipw_priv_handler, 9531 .private = ipw_priv_handler,
6234 .private_args = ipw_priv_args, 9532 .private_args = ipw_priv_args,
9533 .get_wireless_stats = ipw_get_wireless_stats,
6235}; 9534};
6236 9535
6237/* 9536/*
@@ -6246,8 +9545,8 @@ static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
6246 9545
6247 wstats = &priv->wstats; 9546 wstats = &priv->wstats;
6248 9547
6249 /* if hw is disabled, then ipw2100_get_ordinal() can't be called. 9548 /* if hw is disabled, then ipw_get_ordinal() can't be called.
6250 * ipw2100_wx_wireless_stats seems to be called before fw is 9549 * netdev->get_wireless_stats seems to be called before fw is
6251 * initialized. STATUS_ASSOCIATED will only be set if the hw is up 9550 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
6252 * and associated; if not associcated, the values are all meaningless 9551 * and associated; if not associcated, the values are all meaningless
6253 * anyway, so set them all to NULL and INVALID */ 9552 * anyway, so set them all to NULL and INVALID */
@@ -6298,7 +9597,7 @@ static inline void init_sys_config(struct ipw_sys_config *sys_config)
6298 sys_config->dot11g_auto_detection = 0; 9597 sys_config->dot11g_auto_detection = 0;
6299 sys_config->enable_cts_to_self = 0; 9598 sys_config->enable_cts_to_self = 0;
6300 sys_config->bt_coexist_collision_thr = 0; 9599 sys_config->bt_coexist_collision_thr = 0;
6301 sys_config->pass_noise_stats_to_host = 1; 9600 sys_config->pass_noise_stats_to_host = 1; //1 -- fix for 256
6302} 9601}
6303 9602
6304static int ipw_net_open(struct net_device *dev) 9603static int ipw_net_open(struct net_device *dev)
@@ -6306,9 +9605,11 @@ static int ipw_net_open(struct net_device *dev)
6306 struct ipw_priv *priv = ieee80211_priv(dev); 9605 struct ipw_priv *priv = ieee80211_priv(dev);
6307 IPW_DEBUG_INFO("dev->open\n"); 9606 IPW_DEBUG_INFO("dev->open\n");
6308 /* we should be verifying the device is ready to be opened */ 9607 /* we should be verifying the device is ready to be opened */
9608 down(&priv->sem);
6309 if (!(priv->status & STATUS_RF_KILL_MASK) && 9609 if (!(priv->status & STATUS_RF_KILL_MASK) &&
6310 (priv->status & STATUS_ASSOCIATED)) 9610 (priv->status & STATUS_ASSOCIATED))
6311 netif_start_queue(dev); 9611 netif_start_queue(dev);
9612 up(&priv->sem);
6312 return 0; 9613 return 0;
6313} 9614}
6314 9615
@@ -6326,22 +9627,34 @@ modify to send one tfd per fragment instead of using chunking. otherwise
6326we need to heavily modify the ieee80211_skb_to_txb. 9627we need to heavily modify the ieee80211_skb_to_txb.
6327*/ 9628*/
6328 9629
6329static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb) 9630static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9631 int pri)
6330{ 9632{
6331 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *) 9633 struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
6332 txb->fragments[0]->data; 9634 txb->fragments[0]->data;
6333 int i = 0; 9635 int i = 0;
6334 struct tfd_frame *tfd; 9636 struct tfd_frame *tfd;
9637#ifdef CONFIG_IPW_QOS
9638 int tx_id = ipw_get_tx_queue_number(priv, pri);
9639 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9640#else
6335 struct clx2_tx_queue *txq = &priv->txq[0]; 9641 struct clx2_tx_queue *txq = &priv->txq[0];
9642#endif
6336 struct clx2_queue *q = &txq->q; 9643 struct clx2_queue *q = &txq->q;
6337 u8 id, hdr_len, unicast; 9644 u8 id, hdr_len, unicast;
6338 u16 remaining_bytes; 9645 u16 remaining_bytes;
9646 int fc;
9647
9648 /* If there isn't room in the queue, we return busy and let the
9649 * network stack requeue the packet for us */
9650 if (ipw_queue_space(q) < q->high_mark)
9651 return NETDEV_TX_BUSY;
6339 9652
6340 switch (priv->ieee->iw_mode) { 9653 switch (priv->ieee->iw_mode) {
6341 case IW_MODE_ADHOC: 9654 case IW_MODE_ADHOC:
6342 hdr_len = IEEE80211_3ADDR_LEN; 9655 hdr_len = IEEE80211_3ADDR_LEN;
6343 unicast = !is_broadcast_ether_addr(hdr->addr1) && 9656 unicast = !(is_multicast_ether_addr(hdr->addr1) ||
6344 !is_multicast_ether_addr(hdr->addr1); 9657 is_broadcast_ether_addr(hdr->addr1));
6345 id = ipw_find_station(priv, hdr->addr1); 9658 id = ipw_find_station(priv, hdr->addr1);
6346 if (id == IPW_INVALID_STATION) { 9659 if (id == IPW_INVALID_STATION) {
6347 id = ipw_add_station(priv, hdr->addr1); 9660 id = ipw_add_station(priv, hdr->addr1);
@@ -6356,8 +9669,8 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
6356 9669
6357 case IW_MODE_INFRA: 9670 case IW_MODE_INFRA:
6358 default: 9671 default:
6359 unicast = !is_broadcast_ether_addr(hdr->addr3) && 9672 unicast = !(is_multicast_ether_addr(hdr->addr3) ||
6360 !is_multicast_ether_addr(hdr->addr3); 9673 is_broadcast_ether_addr(hdr->addr3));
6361 hdr_len = IEEE80211_3ADDR_LEN; 9674 hdr_len = IEEE80211_3ADDR_LEN;
6362 id = 0; 9675 id = 0;
6363 break; 9676 break;
@@ -6372,26 +9685,83 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
6372 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK; 9685 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
6373 9686
6374 tfd->u.data.cmd_id = DINO_CMD_TX; 9687 tfd->u.data.cmd_id = DINO_CMD_TX;
6375 tfd->u.data.len = txb->payload_size; 9688 tfd->u.data.len = cpu_to_le16(txb->payload_size);
6376 remaining_bytes = txb->payload_size; 9689 remaining_bytes = txb->payload_size;
6377 if (unlikely(!unicast))
6378 tfd->u.data.tx_flags = DCT_FLAG_NO_WEP;
6379 else
6380 tfd->u.data.tx_flags = DCT_FLAG_NO_WEP | DCT_FLAG_ACK_REQD;
6381 9690
6382 if (priv->assoc_request.ieee_mode == IPW_B_MODE) 9691 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
6383 tfd->u.data.tx_flags_ext = DCT_FLAG_EXT_MODE_CCK; 9692 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
6384 else 9693 else
6385 tfd->u.data.tx_flags_ext = DCT_FLAG_EXT_MODE_OFDM; 9694 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
6386 9695
6387 if (priv->config & CFG_PREAMBLE) 9696 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
6388 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREMBL; 9697 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9698
9699 fc = le16_to_cpu(hdr->frame_ctl);
9700 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
6389 9701
6390 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len); 9702 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
6391 9703
9704 if (likely(unicast))
9705 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9706
9707 if (txb->encrypted && !priv->ieee->host_encrypt) {
9708 switch (priv->ieee->sec.level) {
9709 case SEC_LEVEL_3:
9710 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9711 IEEE80211_FCTL_PROTECTED;
9712 /* XXX: ACK flag must be set for CCMP even if it
9713 * is a multicast/broadcast packet, because CCMP
9714 * group communication encrypted by GTK is
9715 * actually done by the AP. */
9716 if (!unicast)
9717 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9718
9719 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9720 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9721 tfd->u.data.key_index = 0;
9722 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9723 break;
9724 case SEC_LEVEL_2:
9725 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9726 IEEE80211_FCTL_PROTECTED;
9727 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9728 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9729 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9730 break;
9731 case SEC_LEVEL_1:
9732 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9733 IEEE80211_FCTL_PROTECTED;
9734 tfd->u.data.key_index = priv->ieee->tx_keyidx;
9735 if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9736 40)
9737 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9738 else
9739 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9740 break;
9741 case SEC_LEVEL_0:
9742 break;
9743 default:
9744 printk(KERN_ERR "Unknow security level %d\n",
9745 priv->ieee->sec.level);
9746 break;
9747 }
9748 } else
9749 /* No hardware encryption */
9750 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9751
9752#ifdef CONFIG_IPW_QOS
9753 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9754#endif /* CONFIG_IPW_QOS */
9755
6392 /* payload */ 9756 /* payload */
6393 tfd->u.data.num_chunks = min((u8) (NUM_TFD_CHUNKS - 2), txb->nr_frags); 9757 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
6394 for (i = 0; i < tfd->u.data.num_chunks; i++) { 9758 txb->nr_frags));
9759 IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9760 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9761 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9762 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9763 i, le32_to_cpu(tfd->u.data.num_chunks),
9764 txb->fragments[i]->len - hdr_len);
6395 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n", 9765 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
6396 i, tfd->u.data.num_chunks, 9766 i, tfd->u.data.num_chunks,
6397 txb->fragments[i]->len - hdr_len); 9767 txb->fragments[i]->len - hdr_len);
@@ -6399,11 +9769,13 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
6399 txb->fragments[i]->len - hdr_len); 9769 txb->fragments[i]->len - hdr_len);
6400 9770
6401 tfd->u.data.chunk_ptr[i] = 9771 tfd->u.data.chunk_ptr[i] =
6402 pci_map_single(priv->pci_dev, 9772 cpu_to_le32(pci_map_single
6403 txb->fragments[i]->data + hdr_len, 9773 (priv->pci_dev,
6404 txb->fragments[i]->len - hdr_len, 9774 txb->fragments[i]->data + hdr_len,
6405 PCI_DMA_TODEVICE); 9775 txb->fragments[i]->len - hdr_len,
6406 tfd->u.data.chunk_len[i] = txb->fragments[i]->len - hdr_len; 9776 PCI_DMA_TODEVICE));
9777 tfd->u.data.chunk_len[i] =
9778 cpu_to_le16(txb->fragments[i]->len - hdr_len);
6407 } 9779 }
6408 9780
6409 if (i != txb->nr_frags) { 9781 if (i != txb->nr_frags) {
@@ -6418,9 +9790,10 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
6418 remaining_bytes); 9790 remaining_bytes);
6419 skb = alloc_skb(remaining_bytes, GFP_ATOMIC); 9791 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
6420 if (skb != NULL) { 9792 if (skb != NULL) {
6421 tfd->u.data.chunk_len[i] = remaining_bytes; 9793 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
6422 for (j = i; j < txb->nr_frags; j++) { 9794 for (j = i; j < txb->nr_frags; j++) {
6423 int size = txb->fragments[j]->len - hdr_len; 9795 int size = txb->fragments[j]->len - hdr_len;
9796
6424 printk(KERN_INFO "Adding frag %d %d...\n", 9797 printk(KERN_INFO "Adding frag %d %d...\n",
6425 j, size); 9798 j, size);
6426 memcpy(skb_put(skb, size), 9799 memcpy(skb_put(skb, size),
@@ -6429,10 +9802,14 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
6429 dev_kfree_skb_any(txb->fragments[i]); 9802 dev_kfree_skb_any(txb->fragments[i]);
6430 txb->fragments[i] = skb; 9803 txb->fragments[i] = skb;
6431 tfd->u.data.chunk_ptr[i] = 9804 tfd->u.data.chunk_ptr[i] =
6432 pci_map_single(priv->pci_dev, skb->data, 9805 cpu_to_le32(pci_map_single
6433 tfd->u.data.chunk_len[i], 9806 (priv->pci_dev, skb->data,
6434 PCI_DMA_TODEVICE); 9807 tfd->u.data.chunk_len[i],
6435 tfd->u.data.num_chunks++; 9808 PCI_DMA_TODEVICE));
9809
9810 tfd->u.data.num_chunks =
9811 cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9812 1);
6436 } 9813 }
6437 } 9814 }
6438 9815
@@ -6440,14 +9817,28 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
6440 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd); 9817 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
6441 ipw_write32(priv, q->reg_w, q->first_empty); 9818 ipw_write32(priv, q->reg_w, q->first_empty);
6442 9819
6443 if (ipw_queue_space(q) < q->high_mark) 9820 return NETDEV_TX_OK;
6444 netif_stop_queue(priv->net_dev);
6445
6446 return;
6447 9821
6448 drop: 9822 drop:
6449 IPW_DEBUG_DROP("Silently dropping Tx packet.\n"); 9823 IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
6450 ieee80211_txb_free(txb); 9824 ieee80211_txb_free(txb);
9825 return NETDEV_TX_OK;
9826}
9827
9828static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9829{
9830 struct ipw_priv *priv = ieee80211_priv(dev);
9831#ifdef CONFIG_IPW_QOS
9832 int tx_id = ipw_get_tx_queue_number(priv, pri);
9833 struct clx2_tx_queue *txq = &priv->txq[tx_id];
9834#else
9835 struct clx2_tx_queue *txq = &priv->txq[0];
9836#endif /* CONFIG_IPW_QOS */
9837
9838 if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9839 return 1;
9840
9841 return 0;
6451} 9842}
6452 9843
6453static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb, 9844static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
@@ -6455,9 +9846,9 @@ static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
6455{ 9846{
6456 struct ipw_priv *priv = ieee80211_priv(dev); 9847 struct ipw_priv *priv = ieee80211_priv(dev);
6457 unsigned long flags; 9848 unsigned long flags;
9849 int ret;
6458 9850
6459 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size); 9851 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
6460
6461 spin_lock_irqsave(&priv->lock, flags); 9852 spin_lock_irqsave(&priv->lock, flags);
6462 9853
6463 if (!(priv->status & STATUS_ASSOCIATED)) { 9854 if (!(priv->status & STATUS_ASSOCIATED)) {
@@ -6467,10 +9858,12 @@ static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
6467 goto fail_unlock; 9858 goto fail_unlock;
6468 } 9859 }
6469 9860
6470 ipw_tx_skb(priv, txb); 9861 ret = ipw_tx_skb(priv, txb, pri);
6471 9862 if (ret == NETDEV_TX_OK)
9863 __ipw_led_activity_on(priv);
6472 spin_unlock_irqrestore(&priv->lock, flags); 9864 spin_unlock_irqrestore(&priv->lock, flags);
6473 return 0; 9865
9866 return ret;
6474 9867
6475 fail_unlock: 9868 fail_unlock:
6476 spin_unlock_irqrestore(&priv->lock, flags); 9869 spin_unlock_irqrestore(&priv->lock, flags);
@@ -6497,11 +9890,13 @@ static int ipw_net_set_mac_address(struct net_device *dev, void *p)
6497 struct sockaddr *addr = p; 9890 struct sockaddr *addr = p;
6498 if (!is_valid_ether_addr(addr->sa_data)) 9891 if (!is_valid_ether_addr(addr->sa_data))
6499 return -EADDRNOTAVAIL; 9892 return -EADDRNOTAVAIL;
9893 down(&priv->sem);
6500 priv->config |= CFG_CUSTOM_MAC; 9894 priv->config |= CFG_CUSTOM_MAC;
6501 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN); 9895 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
6502 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n", 9896 printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
6503 priv->net_dev->name, MAC_ARG(priv->mac_addr)); 9897 priv->net_dev->name, MAC_ARG(priv->mac_addr));
6504 ipw_adapter_restart(priv); 9898 queue_work(priv->workqueue, &priv->adapter_restart);
9899 up(&priv->sem);
6505 return 0; 9900 return 0;
6506} 9901}
6507 9902
@@ -6524,7 +9919,7 @@ static void ipw_ethtool_get_drvinfo(struct net_device *dev,
6524 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)", 9919 snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
6525 vers, date); 9920 vers, date);
6526 strcpy(info->bus_info, pci_name(p->pci_dev)); 9921 strcpy(info->bus_info, pci_name(p->pci_dev));
6527 info->eedump_len = CX2_EEPROM_IMAGE_SIZE; 9922 info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
6528} 9923}
6529 9924
6530static u32 ipw_ethtool_get_link(struct net_device *dev) 9925static u32 ipw_ethtool_get_link(struct net_device *dev)
@@ -6535,7 +9930,7 @@ static u32 ipw_ethtool_get_link(struct net_device *dev)
6535 9930
6536static int ipw_ethtool_get_eeprom_len(struct net_device *dev) 9931static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
6537{ 9932{
6538 return CX2_EEPROM_IMAGE_SIZE; 9933 return IPW_EEPROM_IMAGE_SIZE;
6539} 9934}
6540 9935
6541static int ipw_ethtool_get_eeprom(struct net_device *dev, 9936static int ipw_ethtool_get_eeprom(struct net_device *dev,
@@ -6543,10 +9938,11 @@ static int ipw_ethtool_get_eeprom(struct net_device *dev,
6543{ 9938{
6544 struct ipw_priv *p = ieee80211_priv(dev); 9939 struct ipw_priv *p = ieee80211_priv(dev);
6545 9940
6546 if (eeprom->offset + eeprom->len > CX2_EEPROM_IMAGE_SIZE) 9941 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
6547 return -EINVAL; 9942 return -EINVAL;
6548 9943 down(&p->sem);
6549 memcpy(bytes, &((u8 *) p->eeprom)[eeprom->offset], eeprom->len); 9944 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9945 up(&p->sem);
6550 return 0; 9946 return 0;
6551} 9947}
6552 9948
@@ -6556,23 +9952,23 @@ static int ipw_ethtool_set_eeprom(struct net_device *dev,
6556 struct ipw_priv *p = ieee80211_priv(dev); 9952 struct ipw_priv *p = ieee80211_priv(dev);
6557 int i; 9953 int i;
6558 9954
6559 if (eeprom->offset + eeprom->len > CX2_EEPROM_IMAGE_SIZE) 9955 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
6560 return -EINVAL; 9956 return -EINVAL;
6561 9957 down(&p->sem);
6562 memcpy(&((u8 *) p->eeprom)[eeprom->offset], bytes, eeprom->len); 9958 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
6563 for (i = IPW_EEPROM_DATA; 9959 for (i = IPW_EEPROM_DATA;
6564 i < IPW_EEPROM_DATA + CX2_EEPROM_IMAGE_SIZE; i++) 9960 i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
6565 ipw_write8(p, i, p->eeprom[i]); 9961 ipw_write8(p, i, p->eeprom[i]);
6566 9962 up(&p->sem);
6567 return 0; 9963 return 0;
6568} 9964}
6569 9965
6570static struct ethtool_ops ipw_ethtool_ops = { 9966static struct ethtool_ops ipw_ethtool_ops = {
6571 .get_link = ipw_ethtool_get_link, 9967 .get_link = ipw_ethtool_get_link,
6572 .get_drvinfo = ipw_ethtool_get_drvinfo, 9968 .get_drvinfo = ipw_ethtool_get_drvinfo,
6573 .get_eeprom_len = ipw_ethtool_get_eeprom_len, 9969 .get_eeprom_len = ipw_ethtool_get_eeprom_len,
6574 .get_eeprom = ipw_ethtool_get_eeprom, 9970 .get_eeprom = ipw_ethtool_get_eeprom,
6575 .set_eeprom = ipw_ethtool_set_eeprom, 9971 .set_eeprom = ipw_ethtool_set_eeprom,
6576}; 9972};
6577 9973
6578static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs) 9974static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
@@ -6590,8 +9986,8 @@ static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
6590 goto none; 9986 goto none;
6591 } 9987 }
6592 9988
6593 inta = ipw_read32(priv, CX2_INTA_RW); 9989 inta = ipw_read32(priv, IPW_INTA_RW);
6594 inta_mask = ipw_read32(priv, CX2_INTA_MASK_R); 9990 inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
6595 9991
6596 if (inta == 0xFFFFFFFF) { 9992 if (inta == 0xFFFFFFFF) {
6597 /* Hardware disappeared */ 9993 /* Hardware disappeared */
@@ -6599,7 +9995,7 @@ static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
6599 goto none; 9995 goto none;
6600 } 9996 }
6601 9997
6602 if (!(inta & (CX2_INTA_MASK_ALL & inta_mask))) { 9998 if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
6603 /* Shared interrupt */ 9999 /* Shared interrupt */
6604 goto none; 10000 goto none;
6605 } 10001 }
@@ -6608,8 +10004,8 @@ static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
6608 ipw_disable_interrupts(priv); 10004 ipw_disable_interrupts(priv);
6609 10005
6610 /* ack current interrupts */ 10006 /* ack current interrupts */
6611 inta &= (CX2_INTA_MASK_ALL & inta_mask); 10007 inta &= (IPW_INTA_MASK_ALL & inta_mask);
6612 ipw_write32(priv, CX2_INTA_RW, inta); 10008 ipw_write32(priv, IPW_INTA_RW, inta);
6613 10009
6614 /* Cache INTA value for our tasklet */ 10010 /* Cache INTA value for our tasklet */
6615 priv->isr_inta = inta; 10011 priv->isr_inta = inta;
@@ -6655,28 +10051,116 @@ static void ipw_rf_kill(void *adapter)
6655 spin_unlock_irqrestore(&priv->lock, flags); 10051 spin_unlock_irqrestore(&priv->lock, flags);
6656} 10052}
6657 10053
10054static void ipw_bg_rf_kill(void *data)
10055{
10056 struct ipw_priv *priv = data;
10057 down(&priv->sem);
10058 ipw_rf_kill(data);
10059 up(&priv->sem);
10060}
10061
10062void ipw_link_up(struct ipw_priv *priv)
10063{
10064 priv->last_seq_num = -1;
10065 priv->last_frag_num = -1;
10066 priv->last_packet_time = 0;
10067
10068 netif_carrier_on(priv->net_dev);
10069 if (netif_queue_stopped(priv->net_dev)) {
10070 IPW_DEBUG_NOTIF("waking queue\n");
10071 netif_wake_queue(priv->net_dev);
10072 } else {
10073 IPW_DEBUG_NOTIF("starting queue\n");
10074 netif_start_queue(priv->net_dev);
10075 }
10076
10077 cancel_delayed_work(&priv->request_scan);
10078 ipw_reset_stats(priv);
10079 /* Ensure the rate is updated immediately */
10080 priv->last_rate = ipw_get_current_rate(priv);
10081 ipw_gather_stats(priv);
10082 ipw_led_link_up(priv);
10083 notify_wx_assoc_event(priv);
10084
10085 if (priv->config & CFG_BACKGROUND_SCAN)
10086 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10087}
10088
10089static void ipw_bg_link_up(void *data)
10090{
10091 struct ipw_priv *priv = data;
10092 down(&priv->sem);
10093 ipw_link_up(data);
10094 up(&priv->sem);
10095}
10096
10097void ipw_link_down(struct ipw_priv *priv)
10098{
10099 ipw_led_link_down(priv);
10100 netif_carrier_off(priv->net_dev);
10101 netif_stop_queue(priv->net_dev);
10102 notify_wx_assoc_event(priv);
10103
10104 /* Cancel any queued work ... */
10105 cancel_delayed_work(&priv->request_scan);
10106 cancel_delayed_work(&priv->adhoc_check);
10107 cancel_delayed_work(&priv->gather_stats);
10108
10109 ipw_reset_stats(priv);
10110
10111 if (!(priv->status & STATUS_EXIT_PENDING)) {
10112 /* Queue up another scan... */
10113 queue_work(priv->workqueue, &priv->request_scan);
10114 }
10115}
10116
10117static void ipw_bg_link_down(void *data)
10118{
10119 struct ipw_priv *priv = data;
10120 down(&priv->sem);
10121 ipw_link_down(data);
10122 up(&priv->sem);
10123}
10124
6658static int ipw_setup_deferred_work(struct ipw_priv *priv) 10125static int ipw_setup_deferred_work(struct ipw_priv *priv)
6659{ 10126{
6660 int ret = 0; 10127 int ret = 0;
6661 10128
6662 priv->workqueue = create_workqueue(DRV_NAME); 10129 priv->workqueue = create_workqueue(DRV_NAME);
6663 init_waitqueue_head(&priv->wait_command_queue); 10130 init_waitqueue_head(&priv->wait_command_queue);
6664 10131 init_waitqueue_head(&priv->wait_state);
6665 INIT_WORK(&priv->adhoc_check, ipw_adhoc_check, priv); 10132
6666 INIT_WORK(&priv->associate, ipw_associate, priv); 10133 INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
6667 INIT_WORK(&priv->disassociate, ipw_disassociate, priv); 10134 INIT_WORK(&priv->associate, ipw_bg_associate, priv);
6668 INIT_WORK(&priv->rx_replenish, ipw_rx_queue_replenish, priv); 10135 INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
6669 INIT_WORK(&priv->adapter_restart, ipw_adapter_restart, priv); 10136 INIT_WORK(&priv->system_config, ipw_system_config, priv);
6670 INIT_WORK(&priv->rf_kill, ipw_rf_kill, priv); 10137 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
6671 INIT_WORK(&priv->up, (void (*)(void *))ipw_up, priv); 10138 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
6672 INIT_WORK(&priv->down, (void (*)(void *))ipw_down, priv); 10139 INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10140 INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10141 INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
6673 INIT_WORK(&priv->request_scan, 10142 INIT_WORK(&priv->request_scan,
6674 (void (*)(void *))ipw_request_scan, priv); 10143 (void (*)(void *))ipw_request_scan, priv);
6675 INIT_WORK(&priv->gather_stats, 10144 INIT_WORK(&priv->gather_stats,
6676 (void (*)(void *))ipw_gather_stats, priv); 10145 (void (*)(void *))ipw_bg_gather_stats, priv);
6677 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_abort_scan, priv); 10146 INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
6678 INIT_WORK(&priv->roam, ipw_roam, priv); 10147 INIT_WORK(&priv->roam, ipw_bg_roam, priv);
6679 INIT_WORK(&priv->scan_check, ipw_scan_check, priv); 10148 INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10149 INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10150 INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10151 INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10152 priv);
10153 INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10154 priv);
10155 INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10156 priv);
10157 INIT_WORK(&priv->merge_networks,
10158 (void (*)(void *))ipw_merge_adhoc_network, priv);
10159
10160#ifdef CONFIG_IPW_QOS
10161 INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10162 priv);
10163#endif /* CONFIG_IPW_QOS */
6680 10164
6681 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long)) 10165 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
6682 ipw_irq_tasklet, (unsigned long)priv); 10166 ipw_irq_tasklet, (unsigned long)priv);
@@ -6689,34 +10173,36 @@ static void shim__set_security(struct net_device *dev,
6689{ 10173{
6690 struct ipw_priv *priv = ieee80211_priv(dev); 10174 struct ipw_priv *priv = ieee80211_priv(dev);
6691 int i; 10175 int i;
6692
6693 for (i = 0; i < 4; i++) { 10176 for (i = 0; i < 4; i++) {
6694 if (sec->flags & (1 << i)) { 10177 if (sec->flags & (1 << i)) {
6695 priv->sec.key_sizes[i] = sec->key_sizes[i]; 10178 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10179 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
6696 if (sec->key_sizes[i] == 0) 10180 if (sec->key_sizes[i] == 0)
6697 priv->sec.flags &= ~(1 << i); 10181 priv->ieee->sec.flags &= ~(1 << i);
6698 else 10182 else {
6699 memcpy(priv->sec.keys[i], sec->keys[i], 10183 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
6700 sec->key_sizes[i]); 10184 sec->key_sizes[i]);
6701 priv->sec.flags |= (1 << i); 10185 priv->ieee->sec.flags |= (1 << i);
10186 }
6702 priv->status |= STATUS_SECURITY_UPDATED; 10187 priv->status |= STATUS_SECURITY_UPDATED;
6703 } 10188 } else if (sec->level != SEC_LEVEL_1)
10189 priv->ieee->sec.flags &= ~(1 << i);
6704 } 10190 }
6705 10191
6706 if ((sec->flags & SEC_ACTIVE_KEY) && 10192 if (sec->flags & SEC_ACTIVE_KEY) {
6707 priv->sec.active_key != sec->active_key) {
6708 if (sec->active_key <= 3) { 10193 if (sec->active_key <= 3) {
6709 priv->sec.active_key = sec->active_key; 10194 priv->ieee->sec.active_key = sec->active_key;
6710 priv->sec.flags |= SEC_ACTIVE_KEY; 10195 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
6711 } else 10196 } else
6712 priv->sec.flags &= ~SEC_ACTIVE_KEY; 10197 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
6713 priv->status |= STATUS_SECURITY_UPDATED; 10198 priv->status |= STATUS_SECURITY_UPDATED;
6714 } 10199 } else
10200 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
6715 10201
6716 if ((sec->flags & SEC_AUTH_MODE) && 10202 if ((sec->flags & SEC_AUTH_MODE) &&
6717 (priv->sec.auth_mode != sec->auth_mode)) { 10203 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
6718 priv->sec.auth_mode = sec->auth_mode; 10204 priv->ieee->sec.auth_mode = sec->auth_mode;
6719 priv->sec.flags |= SEC_AUTH_MODE; 10205 priv->ieee->sec.flags |= SEC_AUTH_MODE;
6720 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY) 10206 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
6721 priv->capability |= CAP_SHARED_KEY; 10207 priv->capability |= CAP_SHARED_KEY;
6722 else 10208 else
@@ -6724,9 +10210,9 @@ static void shim__set_security(struct net_device *dev,
6724 priv->status |= STATUS_SECURITY_UPDATED; 10210 priv->status |= STATUS_SECURITY_UPDATED;
6725 } 10211 }
6726 10212
6727 if (sec->flags & SEC_ENABLED && priv->sec.enabled != sec->enabled) { 10213 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
6728 priv->sec.flags |= SEC_ENABLED; 10214 priv->ieee->sec.flags |= SEC_ENABLED;
6729 priv->sec.enabled = sec->enabled; 10215 priv->ieee->sec.enabled = sec->enabled;
6730 priv->status |= STATUS_SECURITY_UPDATED; 10216 priv->status |= STATUS_SECURITY_UPDATED;
6731 if (sec->enabled) 10217 if (sec->enabled)
6732 priv->capability |= CAP_PRIVACY_ON; 10218 priv->capability |= CAP_PRIVACY_ON;
@@ -6734,12 +10220,18 @@ static void shim__set_security(struct net_device *dev,
6734 priv->capability &= ~CAP_PRIVACY_ON; 10220 priv->capability &= ~CAP_PRIVACY_ON;
6735 } 10221 }
6736 10222
6737 if (sec->flags & SEC_LEVEL && priv->sec.level != sec->level) { 10223 if (sec->flags & SEC_ENCRYPT)
6738 priv->sec.level = sec->level; 10224 priv->ieee->sec.encrypt = sec->encrypt;
6739 priv->sec.flags |= SEC_LEVEL; 10225
10226 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10227 priv->ieee->sec.level = sec->level;
10228 priv->ieee->sec.flags |= SEC_LEVEL;
6740 priv->status |= STATUS_SECURITY_UPDATED; 10229 priv->status |= STATUS_SECURITY_UPDATED;
6741 } 10230 }
6742 10231
10232 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10233 ipw_set_hwcrypto_keys(priv);
10234
6743 /* To match current functionality of ipw2100 (which works well w/ 10235 /* To match current functionality of ipw2100 (which works well w/
6744 * various supplicants, we don't force a disassociate if the 10236 * various supplicants, we don't force a disassociate if the
6745 * privacy capability changes ... */ 10237 * privacy capability changes ... */
@@ -6788,29 +10280,10 @@ static int init_supported_rates(struct ipw_priv *priv,
6788 10280
6789static int ipw_config(struct ipw_priv *priv) 10281static int ipw_config(struct ipw_priv *priv)
6790{ 10282{
6791 int i;
6792 struct ipw_tx_power tx_power;
6793
6794 memset(&priv->sys_config, 0, sizeof(priv->sys_config));
6795 memset(&tx_power, 0, sizeof(tx_power));
6796
6797 /* This is only called from ipw_up, which resets/reloads the firmware 10283 /* This is only called from ipw_up, which resets/reloads the firmware
6798 so, we don't need to first disable the card before we configure 10284 so, we don't need to first disable the card before we configure
6799 it */ 10285 it */
6800 10286 if (ipw_set_tx_power(priv))
6801 /* configure device for 'G' band */
6802 tx_power.ieee_mode = IPW_G_MODE;
6803 tx_power.num_channels = 11;
6804 for (i = 0; i < 11; i++) {
6805 tx_power.channels_tx_power[i].channel_number = i + 1;
6806 tx_power.channels_tx_power[i].tx_power = priv->tx_power;
6807 }
6808 if (ipw_send_tx_power(priv, &tx_power))
6809 goto error;
6810
6811 /* configure device to also handle 'B' band */
6812 tx_power.ieee_mode = IPW_B_MODE;
6813 if (ipw_send_tx_power(priv, &tx_power))
6814 goto error; 10287 goto error;
6815 10288
6816 /* initialize adapter address */ 10289 /* initialize adapter address */
@@ -6819,6 +10292,11 @@ static int ipw_config(struct ipw_priv *priv)
6819 10292
6820 /* set basic system config settings */ 10293 /* set basic system config settings */
6821 init_sys_config(&priv->sys_config); 10294 init_sys_config(&priv->sys_config);
10295 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10296 priv->sys_config.answer_broadcast_ssid_probe = 1;
10297 else
10298 priv->sys_config.answer_broadcast_ssid_probe = 0;
10299
6822 if (ipw_send_system_config(priv, &priv->sys_config)) 10300 if (ipw_send_system_config(priv, &priv->sys_config))
6823 goto error; 10301 goto error;
6824 10302
@@ -6831,6 +10309,10 @@ static int ipw_config(struct ipw_priv *priv)
6831 if (ipw_send_rts_threshold(priv, priv->rts_threshold)) 10309 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
6832 goto error; 10310 goto error;
6833 } 10311 }
10312#ifdef CONFIG_IPW_QOS
10313 IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10314 ipw_qos_activate(priv, NULL);
10315#endif /* CONFIG_IPW_QOS */
6834 10316
6835 if (ipw_set_random_seed(priv)) 10317 if (ipw_set_random_seed(priv))
6836 goto error; 10318 goto error;
@@ -6839,9 +10321,17 @@ static int ipw_config(struct ipw_priv *priv)
6839 if (ipw_send_host_complete(priv)) 10321 if (ipw_send_host_complete(priv))
6840 goto error; 10322 goto error;
6841 10323
6842 /* If configured to try and auto-associate, kick off a scan */ 10324 priv->status |= STATUS_INIT;
6843 if ((priv->config & CFG_ASSOCIATE) && ipw_request_scan(priv)) 10325
6844 goto error; 10326 ipw_led_init(priv);
10327 ipw_led_radio_on(priv);
10328 priv->notif_missed_beacons = 0;
10329
10330 /* Set hardware WEP key if it is configured. */
10331 if ((priv->capability & CAP_PRIVACY_ON) &&
10332 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10333 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10334 ipw_set_hwcrypto_keys(priv);
6845 10335
6846 return 0; 10336 return 0;
6847 10337
@@ -6849,20 +10339,379 @@ static int ipw_config(struct ipw_priv *priv)
6849 return -EIO; 10339 return -EIO;
6850} 10340}
6851 10341
10342/*
10343 * NOTE:
10344 *
10345 * These tables have been tested in conjunction with the
10346 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10347 *
10348 * Altering this values, using it on other hardware, or in geographies
10349 * not intended for resale of the above mentioned Intel adapters has
10350 * not been tested.
10351 *
10352 */
10353static const struct ieee80211_geo ipw_geos[] = {
10354 { /* Restricted */
10355 "---",
10356 .bg_channels = 11,
10357 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10358 {2427, 4}, {2432, 5}, {2437, 6},
10359 {2442, 7}, {2447, 8}, {2452, 9},
10360 {2457, 10}, {2462, 11}},
10361 },
10362
10363 { /* Custom US/Canada */
10364 "ZZF",
10365 .bg_channels = 11,
10366 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10367 {2427, 4}, {2432, 5}, {2437, 6},
10368 {2442, 7}, {2447, 8}, {2452, 9},
10369 {2457, 10}, {2462, 11}},
10370 .a_channels = 8,
10371 .a = {{5180, 36},
10372 {5200, 40},
10373 {5220, 44},
10374 {5240, 48},
10375 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10376 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10377 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10378 {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10379 },
10380
10381 { /* Rest of World */
10382 "ZZD",
10383 .bg_channels = 13,
10384 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10385 {2427, 4}, {2432, 5}, {2437, 6},
10386 {2442, 7}, {2447, 8}, {2452, 9},
10387 {2457, 10}, {2462, 11}, {2467, 12},
10388 {2472, 13}},
10389 },
10390
10391 { /* Custom USA & Europe & High */
10392 "ZZA",
10393 .bg_channels = 11,
10394 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10395 {2427, 4}, {2432, 5}, {2437, 6},
10396 {2442, 7}, {2447, 8}, {2452, 9},
10397 {2457, 10}, {2462, 11}},
10398 .a_channels = 13,
10399 .a = {{5180, 36},
10400 {5200, 40},
10401 {5220, 44},
10402 {5240, 48},
10403 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10404 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10405 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10406 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10407 {5745, 149},
10408 {5765, 153},
10409 {5785, 157},
10410 {5805, 161},
10411 {5825, 165}},
10412 },
10413
10414 { /* Custom NA & Europe */
10415 "ZZB",
10416 .bg_channels = 11,
10417 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10418 {2427, 4}, {2432, 5}, {2437, 6},
10419 {2442, 7}, {2447, 8}, {2452, 9},
10420 {2457, 10}, {2462, 11}},
10421 .a_channels = 13,
10422 .a = {{5180, 36},
10423 {5200, 40},
10424 {5220, 44},
10425 {5240, 48},
10426 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10427 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10428 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10429 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10430 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10431 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10432 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10433 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10434 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10435 },
10436
10437 { /* Custom Japan */
10438 "ZZC",
10439 .bg_channels = 11,
10440 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10441 {2427, 4}, {2432, 5}, {2437, 6},
10442 {2442, 7}, {2447, 8}, {2452, 9},
10443 {2457, 10}, {2462, 11}},
10444 .a_channels = 4,
10445 .a = {{5170, 34}, {5190, 38},
10446 {5210, 42}, {5230, 46}},
10447 },
10448
10449 { /* Custom */
10450 "ZZM",
10451 .bg_channels = 11,
10452 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10453 {2427, 4}, {2432, 5}, {2437, 6},
10454 {2442, 7}, {2447, 8}, {2452, 9},
10455 {2457, 10}, {2462, 11}},
10456 },
10457
10458 { /* Europe */
10459 "ZZE",
10460 .bg_channels = 13,
10461 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10462 {2427, 4}, {2432, 5}, {2437, 6},
10463 {2442, 7}, {2447, 8}, {2452, 9},
10464 {2457, 10}, {2462, 11}, {2467, 12},
10465 {2472, 13}},
10466 .a_channels = 19,
10467 .a = {{5180, 36},
10468 {5200, 40},
10469 {5220, 44},
10470 {5240, 48},
10471 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10472 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10473 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10474 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10475 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10476 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10477 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10478 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10479 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10480 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10481 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10482 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10483 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10484 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10485 {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10486 },
10487
10488 { /* Custom Japan */
10489 "ZZJ",
10490 .bg_channels = 14,
10491 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10492 {2427, 4}, {2432, 5}, {2437, 6},
10493 {2442, 7}, {2447, 8}, {2452, 9},
10494 {2457, 10}, {2462, 11}, {2467, 12},
10495 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10496 .a_channels = 4,
10497 .a = {{5170, 34}, {5190, 38},
10498 {5210, 42}, {5230, 46}},
10499 },
10500
10501 { /* Rest of World */
10502 "ZZR",
10503 .bg_channels = 14,
10504 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10505 {2427, 4}, {2432, 5}, {2437, 6},
10506 {2442, 7}, {2447, 8}, {2452, 9},
10507 {2457, 10}, {2462, 11}, {2467, 12},
10508 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10509 IEEE80211_CH_PASSIVE_ONLY}},
10510 },
10511
10512 { /* High Band */
10513 "ZZH",
10514 .bg_channels = 13,
10515 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10516 {2427, 4}, {2432, 5}, {2437, 6},
10517 {2442, 7}, {2447, 8}, {2452, 9},
10518 {2457, 10}, {2462, 11},
10519 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10520 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10521 .a_channels = 4,
10522 .a = {{5745, 149}, {5765, 153},
10523 {5785, 157}, {5805, 161}},
10524 },
10525
10526 { /* Custom Europe */
10527 "ZZG",
10528 .bg_channels = 13,
10529 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10530 {2427, 4}, {2432, 5}, {2437, 6},
10531 {2442, 7}, {2447, 8}, {2452, 9},
10532 {2457, 10}, {2462, 11},
10533 {2467, 12}, {2472, 13}},
10534 .a_channels = 4,
10535 .a = {{5180, 36}, {5200, 40},
10536 {5220, 44}, {5240, 48}},
10537 },
10538
10539 { /* Europe */
10540 "ZZK",
10541 .bg_channels = 13,
10542 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10543 {2427, 4}, {2432, 5}, {2437, 6},
10544 {2442, 7}, {2447, 8}, {2452, 9},
10545 {2457, 10}, {2462, 11},
10546 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10547 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10548 .a_channels = 24,
10549 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10550 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10551 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10552 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10553 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10554 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10555 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10556 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10557 {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10558 {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10559 {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10560 {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10561 {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10562 {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10563 {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10564 {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10565 {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10566 {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10567 {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10568 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10569 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10570 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10571 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10572 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10573 },
10574
10575 { /* Europe */
10576 "ZZL",
10577 .bg_channels = 11,
10578 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10579 {2427, 4}, {2432, 5}, {2437, 6},
10580 {2442, 7}, {2447, 8}, {2452, 9},
10581 {2457, 10}, {2462, 11}},
10582 .a_channels = 13,
10583 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10584 {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10585 {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10586 {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10587 {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10588 {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10589 {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10590 {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10591 {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10592 {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10593 {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10594 {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10595 {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10596 }
10597};
10598
10599/* GEO code borrowed from ieee80211_geo.c */
10600static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
10601{
10602 int i;
10603
10604 /* Driver needs to initialize the geography map before using
10605 * these helper functions */
10606 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10607
10608 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10609 for (i = 0; i < ieee->geo.bg_channels; i++)
10610 /* NOTE: If G mode is currently supported but
10611 * this is a B only channel, we don't see it
10612 * as valid. */
10613 if ((ieee->geo.bg[i].channel == channel) &&
10614 (!(ieee->mode & IEEE_G) ||
10615 !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
10616 return IEEE80211_24GHZ_BAND;
10617
10618 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10619 for (i = 0; i < ieee->geo.a_channels; i++)
10620 if (ieee->geo.a[i].channel == channel)
10621 return IEEE80211_52GHZ_BAND;
10622
10623 return 0;
10624}
10625
10626static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
10627{
10628 int i;
10629
10630 /* Driver needs to initialize the geography map before using
10631 * these helper functions */
10632 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10633
10634 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10635 for (i = 0; i < ieee->geo.bg_channels; i++)
10636 if (ieee->geo.bg[i].channel == channel)
10637 return i;
10638
10639 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10640 for (i = 0; i < ieee->geo.a_channels; i++)
10641 if (ieee->geo.a[i].channel == channel)
10642 return i;
10643
10644 return -1;
10645}
10646
10647static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
10648{
10649 int i;
10650
10651 /* Driver needs to initialize the geography map before using
10652 * these helper functions */
10653 BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);
10654
10655 freq /= 100000;
10656
10657 if (ieee->freq_band & IEEE80211_24GHZ_BAND)
10658 for (i = 0; i < ieee->geo.bg_channels; i++)
10659 if (ieee->geo.bg[i].freq == freq)
10660 return ieee->geo.bg[i].channel;
10661
10662 if (ieee->freq_band & IEEE80211_52GHZ_BAND)
10663 for (i = 0; i < ieee->geo.a_channels; i++)
10664 if (ieee->geo.a[i].freq == freq)
10665 return ieee->geo.a[i].channel;
10666
10667 return 0;
10668}
10669
10670static int ipw_set_geo(struct ieee80211_device *ieee,
10671 const struct ieee80211_geo *geo)
10672{
10673 memcpy(ieee->geo.name, geo->name, 3);
10674 ieee->geo.name[3] = '\0';
10675 ieee->geo.bg_channels = geo->bg_channels;
10676 ieee->geo.a_channels = geo->a_channels;
10677 memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
10678 sizeof(struct ieee80211_channel));
10679 memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
10680 sizeof(struct ieee80211_channel));
10681 return 0;
10682}
10683
10684static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
10685{
10686 return &ieee->geo;
10687}
10688
6852#define MAX_HW_RESTARTS 5 10689#define MAX_HW_RESTARTS 5
6853static int ipw_up(struct ipw_priv *priv) 10690static int ipw_up(struct ipw_priv *priv)
6854{ 10691{
6855 int rc, i; 10692 int rc, i, j;
6856 10693
6857 if (priv->status & STATUS_EXIT_PENDING) 10694 if (priv->status & STATUS_EXIT_PENDING)
6858 return -EIO; 10695 return -EIO;
6859 10696
10697 if (cmdlog && !priv->cmdlog) {
10698 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10699 GFP_KERNEL);
10700 if (priv->cmdlog == NULL) {
10701 IPW_ERROR("Error allocating %d command log entries.\n",
10702 cmdlog);
10703 } else {
10704 memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10705 priv->cmdlog_len = cmdlog;
10706 }
10707 }
10708
6860 for (i = 0; i < MAX_HW_RESTARTS; i++) { 10709 for (i = 0; i < MAX_HW_RESTARTS; i++) {
6861 /* Load the microcode, firmware, and eeprom. 10710 /* Load the microcode, firmware, and eeprom.
6862 * Also start the clocks. */ 10711 * Also start the clocks. */
6863 rc = ipw_load(priv); 10712 rc = ipw_load(priv);
6864 if (rc) { 10713 if (rc) {
6865 IPW_ERROR("Unable to load firmware: 0x%08X\n", rc); 10714 IPW_ERROR("Unable to load firmware: %d\n", rc);
6866 return rc; 10715 return rc;
6867 } 10716 }
6868 10717
@@ -6871,20 +10720,50 @@ static int ipw_up(struct ipw_priv *priv)
6871 eeprom_parse_mac(priv, priv->mac_addr); 10720 eeprom_parse_mac(priv, priv->mac_addr);
6872 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN); 10721 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
6873 10722
6874 if (priv->status & STATUS_RF_KILL_MASK) 10723 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10724 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10725 ipw_geos[j].name, 3))
10726 break;
10727 }
10728 if (j == ARRAY_SIZE(ipw_geos)) {
10729 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10730 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10731 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10732 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10733 j = 0;
10734 }
10735 if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
10736 IPW_WARNING("Could not set geography.");
10737 return 0;
10738 }
10739
10740 IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
10741 j, priv->ieee->geo.name);
10742
10743 if (priv->status & STATUS_RF_KILL_SW) {
10744 IPW_WARNING("Radio disabled by module parameter.\n");
10745 return 0;
10746 } else if (rf_kill_active(priv)) {
10747 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10748 "Kill switch must be turned off for "
10749 "wireless networking to work.\n");
10750 queue_delayed_work(priv->workqueue, &priv->rf_kill,
10751 2 * HZ);
6875 return 0; 10752 return 0;
10753 }
6876 10754
6877 rc = ipw_config(priv); 10755 rc = ipw_config(priv);
6878 if (!rc) { 10756 if (!rc) {
6879 IPW_DEBUG_INFO("Configured device on count %i\n", i); 10757 IPW_DEBUG_INFO("Configured device on count %i\n", i);
6880 priv->notif_missed_beacons = 0; 10758
6881 netif_start_queue(priv->net_dev); 10759 /* If configure to try and auto-associate, kick
10760 * off a scan. */
10761 queue_work(priv->workqueue, &priv->request_scan);
10762
6882 return 0; 10763 return 0;
6883 } else {
6884 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n",
6885 rc);
6886 } 10764 }
6887 10765
10766 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
6888 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n", 10767 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
6889 i, MAX_HW_RESTARTS); 10768 i, MAX_HW_RESTARTS);
6890 10769
@@ -6896,47 +10775,101 @@ static int ipw_up(struct ipw_priv *priv)
6896 /* tried to restart and config the device for as long as our 10775 /* tried to restart and config the device for as long as our
6897 * patience could withstand */ 10776 * patience could withstand */
6898 IPW_ERROR("Unable to initialize device after %d attempts.\n", i); 10777 IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10778
6899 return -EIO; 10779 return -EIO;
6900} 10780}
6901 10781
6902static void ipw_down(struct ipw_priv *priv) 10782static void ipw_bg_up(void *data)
10783{
10784 struct ipw_priv *priv = data;
10785 down(&priv->sem);
10786 ipw_up(data);
10787 up(&priv->sem);
10788}
10789
10790static void ipw_deinit(struct ipw_priv *priv)
6903{ 10791{
10792 int i;
10793
10794 if (priv->status & STATUS_SCANNING) {
10795 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10796 ipw_abort_scan(priv);
10797 }
10798
10799 if (priv->status & STATUS_ASSOCIATED) {
10800 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10801 ipw_disassociate(priv);
10802 }
10803
10804 ipw_led_shutdown(priv);
10805
10806 /* Wait up to 1s for status to change to not scanning and not
10807 * associated (disassociation can take a while for a ful 802.11
10808 * exchange */
10809 for (i = 1000; i && (priv->status &
10810 (STATUS_DISASSOCIATING |
10811 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10812 udelay(10);
10813
10814 if (priv->status & (STATUS_DISASSOCIATING |
10815 STATUS_ASSOCIATED | STATUS_SCANNING))
10816 IPW_DEBUG_INFO("Still associated or scanning...\n");
10817 else
10818 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10819
6904 /* Attempt to disable the card */ 10820 /* Attempt to disable the card */
6905#if 0
6906 ipw_send_card_disable(priv, 0); 10821 ipw_send_card_disable(priv, 0);
6907#endif 10822
10823 priv->status &= ~STATUS_INIT;
10824}
10825
10826static void ipw_down(struct ipw_priv *priv)
10827{
10828 int exit_pending = priv->status & STATUS_EXIT_PENDING;
10829
10830 priv->status |= STATUS_EXIT_PENDING;
10831
10832 if (ipw_is_init(priv))
10833 ipw_deinit(priv);
10834
10835 /* Wipe out the EXIT_PENDING status bit if we are not actually
10836 * exiting the module */
10837 if (!exit_pending)
10838 priv->status &= ~STATUS_EXIT_PENDING;
6908 10839
6909 /* tell the device to stop sending interrupts */ 10840 /* tell the device to stop sending interrupts */
6910 ipw_disable_interrupts(priv); 10841 ipw_disable_interrupts(priv);
6911 10842
6912 /* Clear all bits but the RF Kill */ 10843 /* Clear all bits but the RF Kill */
6913 priv->status &= STATUS_RF_KILL_MASK; 10844 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
6914
6915 netif_carrier_off(priv->net_dev); 10845 netif_carrier_off(priv->net_dev);
6916 netif_stop_queue(priv->net_dev); 10846 netif_stop_queue(priv->net_dev);
6917 10847
6918 ipw_stop_nic(priv); 10848 ipw_stop_nic(priv);
10849
10850 ipw_led_radio_off(priv);
10851}
10852
10853static void ipw_bg_down(void *data)
10854{
10855 struct ipw_priv *priv = data;
10856 down(&priv->sem);
10857 ipw_down(data);
10858 up(&priv->sem);
6919} 10859}
6920 10860
6921/* Called by register_netdev() */ 10861/* Called by register_netdev() */
6922static int ipw_net_init(struct net_device *dev) 10862static int ipw_net_init(struct net_device *dev)
6923{ 10863{
6924 struct ipw_priv *priv = ieee80211_priv(dev); 10864 struct ipw_priv *priv = ieee80211_priv(dev);
10865 down(&priv->sem);
6925 10866
6926 if (priv->status & STATUS_RF_KILL_SW) { 10867 if (ipw_up(priv)) {
6927 IPW_WARNING("Radio disabled by module parameter.\n"); 10868 up(&priv->sem);
6928 return 0;
6929 } else if (rf_kill_active(priv)) {
6930 IPW_WARNING("Radio Frequency Kill Switch is On:\n"
6931 "Kill switch must be turned off for "
6932 "wireless networking to work.\n");
6933 queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
6934 return 0;
6935 }
6936
6937 if (ipw_up(priv))
6938 return -EIO; 10869 return -EIO;
10870 }
6939 10871
10872 up(&priv->sem);
6940 return 0; 10873 return 0;
6941} 10874}
6942 10875
@@ -6961,7 +10894,7 @@ static struct pci_device_id card_ids[] = {
6961 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0}, 10894 {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
6962 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 10895 {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
6963 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */ 10896 {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
6964 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* 2225BG */ 10897 {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
6965 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */ 10898 {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
6966 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */ 10899 {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
6967 10900
@@ -6981,11 +10914,16 @@ static struct attribute *ipw_sysfs_entries[] = {
6981 &dev_attr_nic_type.attr, 10914 &dev_attr_nic_type.attr,
6982 &dev_attr_status.attr, 10915 &dev_attr_status.attr,
6983 &dev_attr_cfg.attr, 10916 &dev_attr_cfg.attr,
6984 &dev_attr_dump_errors.attr, 10917 &dev_attr_error.attr,
6985 &dev_attr_dump_events.attr, 10918 &dev_attr_event_log.attr,
10919 &dev_attr_cmd_log.attr,
6986 &dev_attr_eeprom_delay.attr, 10920 &dev_attr_eeprom_delay.attr,
6987 &dev_attr_ucode_version.attr, 10921 &dev_attr_ucode_version.attr,
6988 &dev_attr_rtc.attr, 10922 &dev_attr_rtc.attr,
10923 &dev_attr_scan_age.attr,
10924 &dev_attr_led.attr,
10925 &dev_attr_speed_scan.attr,
10926 &dev_attr_net_stats.attr,
6989 NULL 10927 NULL
6990}; 10928};
6991 10929
@@ -7001,7 +10939,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
7001 void __iomem *base; 10939 void __iomem *base;
7002 u32 length, val; 10940 u32 length, val;
7003 struct ipw_priv *priv; 10941 struct ipw_priv *priv;
7004 int band, modulation; 10942 int i;
7005 10943
7006 net_dev = alloc_ieee80211(sizeof(struct ipw_priv)); 10944 net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
7007 if (net_dev == NULL) { 10945 if (net_dev == NULL) {
@@ -7011,13 +10949,17 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
7011 10949
7012 priv = ieee80211_priv(net_dev); 10950 priv = ieee80211_priv(net_dev);
7013 priv->ieee = netdev_priv(net_dev); 10951 priv->ieee = netdev_priv(net_dev);
10952
7014 priv->net_dev = net_dev; 10953 priv->net_dev = net_dev;
7015 priv->pci_dev = pdev; 10954 priv->pci_dev = pdev;
7016#ifdef CONFIG_IPW_DEBUG 10955#ifdef CONFIG_IPW_DEBUG
7017 ipw_debug_level = debug; 10956 ipw_debug_level = debug;
7018#endif 10957#endif
7019 spin_lock_init(&priv->lock); 10958 spin_lock_init(&priv->lock);
10959 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10960 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
7020 10961
10962 init_MUTEX(&priv->sem);
7021 if (pci_enable_device(pdev)) { 10963 if (pci_enable_device(pdev)) {
7022 err = -ENODEV; 10964 err = -ENODEV;
7023 goto out_free_ieee80211; 10965 goto out_free_ieee80211;
@@ -7064,90 +11006,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
7064 goto out_iounmap; 11006 goto out_iounmap;
7065 } 11007 }
7066 11008
7067 /* Initialize module parameter values here */ 11009 ipw_sw_reset(priv, 1);
7068 if (ifname)
7069 strncpy(net_dev->name, ifname, IFNAMSIZ);
7070
7071 if (associate)
7072 priv->config |= CFG_ASSOCIATE;
7073 else
7074 IPW_DEBUG_INFO("Auto associate disabled.\n");
7075
7076 if (auto_create)
7077 priv->config |= CFG_ADHOC_CREATE;
7078 else
7079 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
7080
7081 if (disable) {
7082 priv->status |= STATUS_RF_KILL_SW;
7083 IPW_DEBUG_INFO("Radio disabled.\n");
7084 }
7085
7086 if (channel != 0) {
7087 priv->config |= CFG_STATIC_CHANNEL;
7088 priv->channel = channel;
7089 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
7090 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
7091 /* TODO: Validate that provided channel is in range */
7092 }
7093
7094 switch (mode) {
7095 case 1:
7096 priv->ieee->iw_mode = IW_MODE_ADHOC;
7097 break;
7098#ifdef CONFIG_IPW_PROMISC
7099 case 2:
7100 priv->ieee->iw_mode = IW_MODE_MONITOR;
7101 break;
7102#endif
7103 default:
7104 case 0:
7105 priv->ieee->iw_mode = IW_MODE_INFRA;
7106 break;
7107 }
7108
7109 if ((priv->pci_dev->device == 0x4223) ||
7110 (priv->pci_dev->device == 0x4224)) {
7111 printk(KERN_INFO DRV_NAME
7112 ": Detected Intel PRO/Wireless 2915ABG Network "
7113 "Connection\n");
7114 priv->ieee->abg_true = 1;
7115 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
7116 modulation = IEEE80211_OFDM_MODULATION |
7117 IEEE80211_CCK_MODULATION;
7118 priv->adapter = IPW_2915ABG;
7119 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
7120 } else {
7121 if (priv->pci_dev->device == 0x4221)
7122 printk(KERN_INFO DRV_NAME
7123 ": Detected Intel PRO/Wireless 2225BG Network "
7124 "Connection\n");
7125 else
7126 printk(KERN_INFO DRV_NAME
7127 ": Detected Intel PRO/Wireless 2200BG Network "
7128 "Connection\n");
7129
7130 priv->ieee->abg_true = 0;
7131 band = IEEE80211_24GHZ_BAND;
7132 modulation = IEEE80211_OFDM_MODULATION |
7133 IEEE80211_CCK_MODULATION;
7134 priv->adapter = IPW_2200BG;
7135 priv->ieee->mode = IEEE_G | IEEE_B;
7136 }
7137
7138 priv->ieee->freq_band = band;
7139 priv->ieee->modulation = modulation;
7140
7141 priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
7142
7143 priv->missed_beacon_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
7144 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
7145
7146 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
7147
7148 /* If power management is turned on, default to AC mode */
7149 priv->power_mode = IPW_POWER_AC;
7150 priv->tx_power = IPW_DEFAULT_TX_POWER;
7151 11010
7152 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv); 11011 err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
7153 if (err) { 11012 if (err) {
@@ -7158,8 +11017,20 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
7158 SET_MODULE_OWNER(net_dev); 11017 SET_MODULE_OWNER(net_dev);
7159 SET_NETDEV_DEV(net_dev, &pdev->dev); 11018 SET_NETDEV_DEV(net_dev, &pdev->dev);
7160 11019
11020 down(&priv->sem);
11021
7161 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit; 11022 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
7162 priv->ieee->set_security = shim__set_security; 11023 priv->ieee->set_security = shim__set_security;
11024 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11025
11026#ifdef CONFIG_IPW_QOS
11027 priv->ieee->handle_probe_response = ipw_handle_beacon;
11028 priv->ieee->handle_beacon = ipw_handle_probe_response;
11029 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11030#endif /* CONFIG_IPW_QOS */
11031
11032 priv->ieee->perfect_rssi = -20;
11033 priv->ieee->worst_rssi = -85;
7163 11034
7164 net_dev->open = ipw_net_open; 11035 net_dev->open = ipw_net_open;
7165 net_dev->stop = ipw_net_stop; 11036 net_dev->stop = ipw_net_stop;
@@ -7167,7 +11038,9 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
7167 net_dev->get_stats = ipw_net_get_stats; 11038 net_dev->get_stats = ipw_net_get_stats;
7168 net_dev->set_multicast_list = ipw_net_set_multicast_list; 11039 net_dev->set_multicast_list = ipw_net_set_multicast_list;
7169 net_dev->set_mac_address = ipw_net_set_mac_address; 11040 net_dev->set_mac_address = ipw_net_set_mac_address;
7170 net_dev->get_wireless_stats = ipw_get_wireless_stats; 11041 priv->wireless_data.spy_data = &priv->ieee->spy_data;
11042 priv->wireless_data.ieee80211 = priv->ieee;
11043 net_dev->wireless_data = &priv->wireless_data;
7171 net_dev->wireless_handlers = &ipw_wx_handler_def; 11044 net_dev->wireless_handlers = &ipw_wx_handler_def;
7172 net_dev->ethtool_ops = &ipw_ethtool_ops; 11045 net_dev->ethtool_ops = &ipw_ethtool_ops;
7173 net_dev->irq = pdev->irq; 11046 net_dev->irq = pdev->irq;
@@ -7178,18 +11051,19 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
7178 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group); 11051 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
7179 if (err) { 11052 if (err) {
7180 IPW_ERROR("failed to create sysfs device attributes\n"); 11053 IPW_ERROR("failed to create sysfs device attributes\n");
11054 up(&priv->sem);
7181 goto out_release_irq; 11055 goto out_release_irq;
7182 } 11056 }
7183 11057
11058 up(&priv->sem);
7184 err = register_netdev(net_dev); 11059 err = register_netdev(net_dev);
7185 if (err) { 11060 if (err) {
7186 IPW_ERROR("failed to register network device\n"); 11061 IPW_ERROR("failed to register network device\n");
7187 goto out_remove_group; 11062 goto out_remove_sysfs;
7188 } 11063 }
7189
7190 return 0; 11064 return 0;
7191 11065
7192 out_remove_group: 11066 out_remove_sysfs:
7193 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group); 11067 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
7194 out_release_irq: 11068 out_release_irq:
7195 free_irq(pdev->irq, priv); 11069 free_irq(pdev->irq, priv);
@@ -7212,14 +11086,19 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
7212static void ipw_pci_remove(struct pci_dev *pdev) 11086static void ipw_pci_remove(struct pci_dev *pdev)
7213{ 11087{
7214 struct ipw_priv *priv = pci_get_drvdata(pdev); 11088 struct ipw_priv *priv = pci_get_drvdata(pdev);
11089 struct list_head *p, *q;
11090 int i;
11091
7215 if (!priv) 11092 if (!priv)
7216 return; 11093 return;
7217 11094
7218 priv->status |= STATUS_EXIT_PENDING; 11095 down(&priv->sem);
7219 11096
11097 priv->status |= STATUS_EXIT_PENDING;
11098 ipw_down(priv);
7220 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group); 11099 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
7221 11100
7222 ipw_down(priv); 11101 up(&priv->sem);
7223 11102
7224 unregister_netdev(priv->net_dev); 11103 unregister_netdev(priv->net_dev);
7225 11104
@@ -7229,16 +11108,31 @@ static void ipw_pci_remove(struct pci_dev *pdev)
7229 } 11108 }
7230 ipw_tx_queue_free(priv); 11109 ipw_tx_queue_free(priv);
7231 11110
11111 if (priv->cmdlog) {
11112 kfree(priv->cmdlog);
11113 priv->cmdlog = NULL;
11114 }
7232 /* ipw_down will ensure that there is no more pending work 11115 /* ipw_down will ensure that there is no more pending work
7233 * in the workqueue's, so we can safely remove them now. */ 11116 * in the workqueue's, so we can safely remove them now. */
7234 if (priv->workqueue) { 11117 cancel_delayed_work(&priv->adhoc_check);
7235 cancel_delayed_work(&priv->adhoc_check); 11118 cancel_delayed_work(&priv->gather_stats);
7236 cancel_delayed_work(&priv->gather_stats); 11119 cancel_delayed_work(&priv->request_scan);
7237 cancel_delayed_work(&priv->request_scan); 11120 cancel_delayed_work(&priv->rf_kill);
7238 cancel_delayed_work(&priv->rf_kill); 11121 cancel_delayed_work(&priv->scan_check);
7239 cancel_delayed_work(&priv->scan_check); 11122 destroy_workqueue(priv->workqueue);
7240 destroy_workqueue(priv->workqueue); 11123 priv->workqueue = NULL;
7241 priv->workqueue = NULL; 11124
11125 /* Free MAC hash list for ADHOC */
11126 for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11127 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11128 kfree(list_entry(p, struct ipw_ibss_seq, list));
11129 list_del(p);
11130 }
11131 }
11132
11133 if (priv->error) {
11134 ipw_free_error_log(priv->error);
11135 priv->error = NULL;
7242 } 11136 }
7243 11137
7244 free_irq(pdev->irq, priv); 11138 free_irq(pdev->irq, priv);
@@ -7247,15 +11141,7 @@ static void ipw_pci_remove(struct pci_dev *pdev)
7247 pci_disable_device(pdev); 11141 pci_disable_device(pdev);
7248 pci_set_drvdata(pdev, NULL); 11142 pci_set_drvdata(pdev, NULL);
7249 free_ieee80211(priv->net_dev); 11143 free_ieee80211(priv->net_dev);
7250 11144 free_firmware();
7251#ifdef CONFIG_PM
7252 if (fw_loaded) {
7253 release_firmware(bootfw);
7254 release_firmware(ucode);
7255 release_firmware(firmware);
7256 fw_loaded = 0;
7257 }
7258#endif
7259} 11145}
7260 11146
7261#ifdef CONFIG_PM 11147#ifdef CONFIG_PM
@@ -7287,13 +11173,10 @@ static int ipw_pci_resume(struct pci_dev *pdev)
7287 11173
7288 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name); 11174 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
7289 11175
7290 pci_set_power_state(pdev, 0); 11176 pci_set_power_state(pdev, PCI_D0);
7291 pci_enable_device(pdev); 11177 pci_enable_device(pdev);
7292#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)
7293 pci_restore_state(pdev, priv->pm_state);
7294#else
7295 pci_restore_state(pdev); 11178 pci_restore_state(pdev);
7296#endif 11179
7297 /* 11180 /*
7298 * Suspend/Resume resets the PCI configuration space, so we have to 11181 * Suspend/Resume resets the PCI configuration space, so we have to
7299 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries 11182 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
@@ -7365,16 +11248,33 @@ MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
7365module_param(auto_create, int, 0444); 11248module_param(auto_create, int, 0444);
7366MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)"); 11249MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
7367 11250
11251module_param(led, int, 0444);
11252MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11253
7368module_param(debug, int, 0444); 11254module_param(debug, int, 0444);
7369MODULE_PARM_DESC(debug, "debug output mask"); 11255MODULE_PARM_DESC(debug, "debug output mask");
7370 11256
7371module_param(channel, int, 0444); 11257module_param(channel, int, 0444);
7372MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])"); 11258MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
7373 11259
7374module_param(ifname, charp, 0444); 11260#ifdef CONFIG_IPW_QOS
7375MODULE_PARM_DESC(ifname, "network device name (default eth%d)"); 11261module_param(qos_enable, int, 0444);
11262MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11263
11264module_param(qos_burst_enable, int, 0444);
11265MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11266
11267module_param(qos_no_ack_mask, int, 0444);
11268MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
7376 11269
7377#ifdef CONFIG_IPW_PROMISC 11270module_param(burst_duration_CCK, int, 0444);
11271MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11272
11273module_param(burst_duration_OFDM, int, 0444);
11274MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11275#endif /* CONFIG_IPW_QOS */
11276
11277#ifdef CONFIG_IPW2200_MONITOR
7378module_param(mode, int, 0444); 11278module_param(mode, int, 0444);
7379MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)"); 11279MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
7380#else 11280#else
@@ -7382,5 +11282,12 @@ module_param(mode, int, 0444);
7382MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)"); 11282MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
7383#endif 11283#endif
7384 11284
11285module_param(hwcrypto, int, 0444);
11286MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");
11287
11288module_param(cmdlog, int, 0444);
11289MODULE_PARM_DESC(cmdlog,
11290 "allocate a ring buffer for logging firmware commands");
11291
7385module_exit(ipw_exit); 11292module_exit(ipw_exit);
7386module_init(ipw_init); 11293module_init(ipw_init);
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-21 17:34:53 -0400