nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 diff -Naur r8187_orig/ieee80211/ieee80211_crypt.c r8187_rawtx/ieee80211/ieee80211_crypt.c
2 --- r8187_orig/ieee80211/ieee80211_crypt.c 2007-01-15 03:00:37.000000000 +0100
3 +++ r8187_rawtx/ieee80211/ieee80211_crypt.c 2007-05-16 22:00:07.000000000 +0200
4 @@ -11,7 +11,6 @@
5 *
6 */
7  
8 -#include <linux/config.h>
9 #include <linux/version.h>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 @@ -19,6 +18,12 @@
13 #include <asm/string.h>
14 #include <asm/errno.h>
15  
16 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
17 +#include <linux/config.h>
18 +#else
19 +#include <linux/autoconf.h>
20 +#endif
21 +
22 #include "ieee80211.h"
23  
24 MODULE_AUTHOR("Jouni Malinen");
25 diff -Naur r8187_orig/ieee80211/ieee80211_crypt_ccmp.c r8187_rawtx/ieee80211/ieee80211_crypt_ccmp.c
26 --- r8187_orig/ieee80211/ieee80211_crypt_ccmp.c 2007-01-15 03:00:37.000000000 +0100
27 +++ r8187_rawtx/ieee80211/ieee80211_crypt_ccmp.c 2007-05-16 22:00:07.000000000 +0200
28 @@ -9,7 +9,6 @@
29 * more details.
30 */
31  
32 -#include <linux/config.h>
33 #include <linux/version.h>
34 #include <linux/module.h>
35 #include <linux/init.h>
36 @@ -22,11 +21,22 @@
37 #include <asm/string.h>
38 #include <linux/wireless.h>
39  
40 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
41 +#include <linux/config.h>
42 +#else
43 +#include <linux/autoconf.h>
44 +#endif
45 +
46 #include "ieee80211.h"
47  
48  
49 #include <linux/crypto.h>
50 -#include <asm/scatterlist.h>
51 +
52 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
53 + #include <asm/scatterlist.h>
54 +#else
55 + #include <linux/scatterlist.h>
56 +#endif
57  
58 MODULE_AUTHOR("Jouni Malinen");
59 MODULE_DESCRIPTION("Host AP crypt: CCMP");
60 diff -Naur r8187_orig/ieee80211/ieee80211_crypt_tkip.c r8187_rawtx/ieee80211/ieee80211_crypt_tkip.c
61 --- r8187_orig/ieee80211/ieee80211_crypt_tkip.c 2007-01-15 03:00:37.000000000 +0100
62 +++ r8187_rawtx/ieee80211/ieee80211_crypt_tkip.c 2007-05-16 22:00:07.000000000 +0200
63 @@ -9,7 +9,6 @@
64 * more details.
65 */
66  
67 -#include <linux/config.h>
68 #include <linux/version.h>
69 #include <linux/module.h>
70 #include <linux/init.h>
71 @@ -21,11 +20,21 @@
72 #include <linux/if_arp.h>
73 #include <asm/string.h>
74  
75 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
76 +#include <linux/config.h>
77 +#else
78 +#include <linux/autoconf.h>
79 +#endif
80 +
81 #include "ieee80211.h"
82  
83 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
84 + #include <asm/scatterlist.h>
85 +#else
86 + #include <linux/scatterlist.h>
87 +#endif
88  
89 #include <linux/crypto.h>
90 -#include <asm/scatterlist.h>
91 #include <linux/crc32.h>
92  
93 MODULE_AUTHOR("Jouni Malinen");
94 @@ -431,7 +440,11 @@
95 static int michael_mic(struct ieee80211_tkip_data *tkey, u8 *key, u8 *hdr,
96 u8 *data, size_t data_len, u8 *mic)
97 {
98 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
99 + struct hash_desc desc;
100 +#endif
101 struct scatterlist sg[2];
102 + int ret = 0;
103  
104 if (tkey->tfm_michael == NULL) {
105 printk(KERN_WARNING "michael_mic: tfm_michael == NULL\n");
106 @@ -445,12 +458,20 @@
107 sg[1].offset = offset_in_page(data);
108 sg[1].length = data_len;
109  
110 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
111 crypto_digest_init(tkey->tfm_michael);
112 crypto_digest_setkey(tkey->tfm_michael, key, 8);
113 crypto_digest_update(tkey->tfm_michael, sg, 2);
114 crypto_digest_final(tkey->tfm_michael, mic);
115 +#else
116 + if (crypto_hash_setkey(tkey->tfm_michael, key, 8))
117 + return -1;
118 + desc.tfm = tkey->tfm_michael;
119 + desc.flags = 0;
120 + ret = crypto_hash_digest(&desc, sg, data_len + 16, mic);
121 +#endif
122  
123 - return 0;
124 + return ret;
125 }
126  
127 static void michael_mic_hdr(struct sk_buff *skb, u8 *hdr)
128 diff -Naur r8187_orig/ieee80211/ieee80211_crypt_wep.c r8187_rawtx/ieee80211/ieee80211_crypt_wep.c
129 --- r8187_orig/ieee80211/ieee80211_crypt_wep.c 2007-01-15 03:00:37.000000000 +0100
130 +++ r8187_rawtx/ieee80211/ieee80211_crypt_wep.c 2007-05-16 22:00:07.000000000 +0200
131 @@ -9,7 +9,6 @@
132 * more details.
133 */
134  
135 -#include <linux/config.h>
136 #include <linux/version.h>
137 #include <linux/module.h>
138 #include <linux/init.h>
139 @@ -18,11 +17,21 @@
140 #include <linux/skbuff.h>
141 #include <asm/string.h>
142  
143 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
144 +#include <linux/config.h>
145 +#else
146 +#include <linux/autoconf.h>
147 +#endif
148 +
149 #include "ieee80211.h"
150  
151 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
152 + #include <asm/scatterlist.h>
153 +#else
154 + #include <linux/scatterlist.h>
155 +#endif
156  
157 #include <linux/crypto.h>
158 -#include <asm/scatterlist.h>
159 #include <linux/crc32.h>
160  
161 MODULE_AUTHOR("Jouni Malinen");
162 diff -Naur r8187_orig/ieee80211/ieee80211.h r8187_rawtx/ieee80211/ieee80211.h
163 --- r8187_orig/ieee80211/ieee80211.h 2007-12-05 09:27:45.000000000 +0100
164 +++ r8187_rawtx/ieee80211/ieee80211.h 2007-05-16 22:00:11.000000000 +0200
165 @@ -108,6 +108,8 @@
166 #define ieee80211_start_protocol ieee80211_start_protocol_rtl
167 #define ieee80211_stop_protocol ieee80211_stop_protocol_rtl
168 #define ieee80211_rx_mgt ieee80211_rx_mgt_rtl
169 +#define ieee80211_stop_queue ieee80211_stop_queue_rtl
170 +#define ieee80211_wake_queue ieee80211_wake_queue_rtl
171  
172  
173 typedef struct ieee_param {
174 @@ -193,6 +195,22 @@
175 struct list_head list;
176 };
177  
178 +#define LWNG_CAP_DID_BASE (4 | (1 << 6)) /* section 4, group 1 */
179 +/* ARPHRD_IEEE80211_PRISM uses a bloated version of Prism2 RX frame header
180 + * (from linux-wlan-ng) */
181 +struct linux_wlan_ng_val {
182 + u32 did;
183 + u16 status, len;
184 + u32 data;
185 +} __attribute__ ((packed));
186 +
187 +struct linux_wlan_ng_prism_hdr {
188 + u32 msgcode, msglen;
189 + char devname[16];
190 + struct linux_wlan_ng_val hosttime, mactime, channel, rssi, sq, signal,
191 + noise, rate, istx, frmlen;
192 +} __attribute__ ((packed));
193 +
194 struct ieee80211_hdr {
195 u16 frame_ctl;
196 u16 duration_id;
197 @@ -1064,10 +1082,15 @@
198 struct timer_list beacon_timer;
199  
200 struct work_struct associate_complete_wq;
201 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
202 + struct delayed_work associate_retry_wq;
203 + struct delayed_work softmac_scan_wq;
204 +#else
205 struct work_struct associate_retry_wq;
206 + struct work_struct softmac_scan_wq;
207 +#endif
208 struct work_struct start_ibss_wq;
209 struct work_struct associate_procedure_wq;
210 - struct work_struct softmac_scan_wq;
211 struct work_struct wx_sync_scan_wq;
212 struct work_struct ps_request_tx_ack_wq;//for ps
213 struct work_struct hw_wakeup_wq;
214 @@ -1390,7 +1413,11 @@
215 extern int ieee80211_wx_get_freq(struct ieee80211_device *ieee, struct iw_request_info *a,
216 union iwreq_data *wrqu, char *b);
217  
218 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
219 +extern void ieee80211_wx_sync_scan_wq(struct work_struct *work);
220 +#else
221 extern void ieee80211_wx_sync_scan_wq(struct ieee80211_device *ieee);
222 +#endif
223  
224 extern int ieee80211_wx_set_rawtx(struct ieee80211_device *ieee,
225 struct iw_request_info *info,
226 diff -Naur r8187_orig/ieee80211/ieee80211_module.c r8187_rawtx/ieee80211/ieee80211_module.c
227 --- r8187_orig/ieee80211/ieee80211_module.c 2007-12-03 10:07:33.000000000 +0100
228 +++ r8187_rawtx/ieee80211/ieee80211_module.c 2007-05-16 22:00:07.000000000 +0200
229 @@ -31,7 +31,6 @@
230 *******************************************************************************/
231  
232 #include <linux/compiler.h>
233 -#include <linux/config.h>
234 #include <linux/errno.h>
235 #include <linux/if_arp.h>
236 #include <linux/in6.h>
237 @@ -52,6 +51,12 @@
238 #include <asm/uaccess.h>
239 #include <net/arp.h>
240  
241 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
242 +#include <linux/config.h>
243 +#else
244 +#include <linux/autoconf.h>
245 +#endif
246 +
247 #include "ieee80211.h"
248  
249 MODULE_DESCRIPTION("802.11 data/management/control stack");
250 diff -Naur r8187_orig/ieee80211/ieee80211_rx.c r8187_rawtx/ieee80211/ieee80211_rx.c
251 --- r8187_orig/ieee80211/ieee80211_rx.c 2007-01-15 03:00:37.000000000 +0100
252 +++ r8187_rawtx/ieee80211/ieee80211_rx.c 2007-05-16 22:00:07.000000000 +0200
253 @@ -22,7 +22,6 @@
254  
255  
256 #include <linux/compiler.h>
257 -#include <linux/config.h>
258 #include <linux/errno.h>
259 #include <linux/if_arp.h>
260 #include <linux/in6.h>
261 @@ -43,18 +42,85 @@
262 #include <asm/uaccess.h>
263 #include <linux/ctype.h>
264  
265 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
266 +#include <linux/config.h>
267 +#else
268 +#include <linux/autoconf.h>
269 +#endif
270 +
271 #include "ieee80211.h"
272  
273 static inline void ieee80211_monitor_rx(struct ieee80211_device *ieee,
274 struct sk_buff *skb,
275 struct ieee80211_rx_stats *rx_stats)
276 {
277 - struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
278 - u16 fc = le16_to_cpu(hdr->frame_ctl);
279 + struct ieee80211_hdr *hdr1 = (struct ieee80211_hdr *)skb->data;
280 + u16 fc = le16_to_cpu(hdr1->frame_ctl);
281 +//begin prism header code
282 + int prism_header;
283 + int hdrlen, phdrlen, head_need, tail_need;
284 +
285 + if (ieee->dev->type == ARPHRD_IEEE80211_PRISM) {
286 + prism_header = 1;
287 + phdrlen = sizeof(struct linux_wlan_ng_prism_hdr);
288 + } else {
289 + prism_header = 0;
290 + phdrlen = 0;
291 + }
292  
293 + hdrlen = ieee80211_get_hdrlen(fc);
294 +
295 + /* check if there is enough room for extra data; if not, expand skb
296 + * buffer to be large enough for the changes */
297 + head_need = phdrlen;
298 + tail_need = 0;
299 +#ifdef PRISM2_ADD_BOGUS_CRC
300 + tail_need += 4;
301 +#endif /* PRISM2_ADD_BOGUS_CRC */
302 +
303 + head_need -= skb_headroom(skb);
304 + tail_need -= skb_tailroom(skb);
305 +
306 + if (head_need > 0 || tail_need > 0) {
307 + if (pskb_expand_head(skb, head_need > 0 ? head_need : 0,
308 + tail_need > 0 ? tail_need : 0,
309 + GFP_ATOMIC)) {
310 + printk(KERN_DEBUG "%s: ieee80211_rx failed to "
311 + "reallocate skb buffer\n", ieee->dev->name);
312 + dev_kfree_skb_any(skb);
313 + return;
314 + }
315 + }
316 +
317 + if (prism_header == 1) {
318 + struct linux_wlan_ng_prism_hdr *hdr;
319 + hdr = (struct linux_wlan_ng_prism_hdr *)
320 + skb_push(skb, phdrlen);
321 + memset(hdr, 0, phdrlen);
322 + hdr->msgcode = LWNG_CAP_DID_BASE;
323 + hdr->msglen = sizeof(*hdr);
324 + memcpy(hdr->devname, ieee->dev->name, sizeof(hdr->devname));
325 +#define LWNG_SETVAL(f,i,s,l,d) \
326 +hdr->f.did = LWNG_CAP_DID_BASE | (i << 12); \
327 +hdr->f.status = s; hdr->f.len = l; hdr->f.data = d
328 + LWNG_SETVAL(hosttime, 1, 0, 4, jiffies);
329 + LWNG_SETVAL(mactime, 2, 0, 4, ((u32)rx_stats->mac_time));
330 + LWNG_SETVAL(channel, 3, 1 /* no value */, 4, 0);
331 + LWNG_SETVAL(rssi, 4, 1 /* no value */, 4, 0);
332 + LWNG_SETVAL(sq, 5, 1 /* no value */, 4, 0);
333 + LWNG_SETVAL(signal, 6, 0, 4, rx_stats->signal);
334 + LWNG_SETVAL(noise, 7, 0, 4, rx_stats->noise);
335 + LWNG_SETVAL(rate, 8, 0, 4, rx_stats->rate / 5);
336 + LWNG_SETVAL(istx, 9, 0, 4, 0);
337 + LWNG_SETVAL(frmlen, 10, 0, 4, skb->len - phdrlen);
338 +#undef LWNG_SETVAL
339 + }
340 +//end prism header code
341 skb->dev = ieee->dev;
342 skb->mac.raw = skb->data;
343 - skb_pull(skb, ieee80211_get_hdrlen(fc));
344 + skb_pull(skb, hdrlen);
345 + if (prism_header)
346 + skb_pull(skb, phdrlen);
347 skb->pkt_type = PACKET_OTHERHOST;
348 skb->protocol = __constant_htons(ETH_P_80211_RAW);
349 memset(skb->cb, 0, sizeof(skb->cb));
350 diff -Naur r8187_orig/ieee80211/ieee80211_softmac.c r8187_rawtx/ieee80211/ieee80211_softmac.c
351 --- r8187_orig/ieee80211/ieee80211_softmac.c 2007-12-05 09:26:56.000000000 +0100
352 +++ r8187_rawtx/ieee80211/ieee80211_softmac.c 2007-05-16 22:00:07.000000000 +0200
353 @@ -1,14 +1,14 @@
354 /* IEEE 802.11 SoftMAC layer
355 * Copyright (c) 2005 Andrea Merello <andreamrl@tiscali.it>
356 *
357 - * Mostly extracted from the rtl8180-sa2400 driver for the
358 + * Mostly extracted from the rtl8180-sa2400 driver for the
359 * in-kernel generic ieee802.11 stack.
360 *
361 * Few lines might be stolen from other part of the ieee80211
362 * stack. Copyright who own it's copyright
363 *
364 * WPA code stolen from the ipw2200 driver.
365 - * Copyright who own it's copyright.
366 + * Copyright who own it's copyright.
367 *
368 * released under the GPL
369 */
370 @@ -37,25 +37,25 @@
371 unsigned int ieee80211_MFIE_rate_len(struct ieee80211_device *ieee)
372 {
373 unsigned int rate_len = 0;
374 -
375 +
376 if (ieee->modulation & IEEE80211_CCK_MODULATION)
377 rate_len = IEEE80211_CCK_RATE_LEN + 2;
378 -
379 +
380 if (ieee->modulation & IEEE80211_OFDM_MODULATION)
381 -
382 +
383 rate_len += IEEE80211_OFDM_RATE_LEN + 2;
384 -
385 +
386 return rate_len;
387 }
388  
389 -/* pleace the MFIE rate, tag to the memory (double) poined.
390 +/* pleace the MFIE rate, tag to the memory (double) poined.
391 * Then it updates the pointer so that
392 * it points after the new MFIE tag added.
393 - */
394 + */
395 void ieee80211_MFIE_Brate(struct ieee80211_device *ieee, u8 **tag_p)
396 {
397 - u8 *tag = *tag_p;
398 -
399 + u8 *tag = *tag_p;
400 +
401 if (ieee->modulation & IEEE80211_CCK_MODULATION){
402 *tag++ = MFIE_TYPE_RATES;
403 *tag++ = 4;
404 @@ -64,17 +64,17 @@
405 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_5MB;
406 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_11MB;
407 }
408 -
409 +
410 /* We may add an option for custom rates that specific HW might support */
411 *tag_p = tag;
412 }
413  
414 void ieee80211_MFIE_Grate(struct ieee80211_device *ieee, u8 **tag_p)
415 -{
416 - u8 *tag = *tag_p;
417 -
418 +{
419 + u8 *tag = *tag_p;
420 +
421 if (ieee->modulation & IEEE80211_OFDM_MODULATION){
422 -
423 +
424 *tag++ = MFIE_TYPE_RATES_EX;
425 *tag++ = 8;
426 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_6MB;
427 @@ -85,9 +85,9 @@
428 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_36MB;
429 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_48MB;
430 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_54MB;
431 -
432 +
433 }
434 -
435 +
436 /* We may add an option for custom rates that specific HW might support */
437 *tag_p = tag;
438 }
439 @@ -96,11 +96,11 @@
440 {
441 int nh;
442 nh = (ieee->mgmt_queue_head +1) % MGMT_QUEUE_NUM;
443 -
444 +
445 /*
446 * if the queue is full but we have newer frames then
447 * just overwrites the oldest.
448 - *
449 + *
450 * if (nh == ieee->mgmt_queue_tail)
451 * return -1;
452 */ //david, 2007.1.23
453 @@ -110,22 +110,22 @@
454 ieee->mgmt_queue_head = nh;
455 ieee->mgmt_queue_ring[nh] = skb;
456 }
457 -
458 +
459 //return 0;
460 }
461  
462 struct sk_buff *dequeue_mgmt(struct ieee80211_device *ieee)
463 {
464 struct sk_buff *ret;
465 -
466 +
467 if(ieee->mgmt_queue_tail == ieee->mgmt_queue_head)
468 return NULL;
469 -
470 +
471 ret = ieee->mgmt_queue_ring[ieee->mgmt_queue_tail];
472 -
473 - ieee->mgmt_queue_tail =
474 +
475 + ieee->mgmt_queue_tail =
476 (ieee->mgmt_queue_tail+1) % MGMT_QUEUE_NUM;
477 -
478 +
479 return ret;
480 }
481  
482 @@ -143,19 +143,19 @@
483 short single = ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE;
484 struct ieee80211_hdr_3addr *header=
485 (struct ieee80211_hdr_3addr *) skb->data;
486 -
487 -
488 +
489 +
490 spin_lock_irqsave(&ieee->lock, flags);
491 -
492 +
493 /* called with 2nd param 0, no mgmt lock required */
494 ieee80211_sta_wakeup(ieee,0);
495 -
496 +
497 if(single){
498 -
499 +
500 if(ieee->queue_stop){
501 -
502 +
503 enqueue_mgmt(ieee,skb);
504 -
505 +
506 }else{
507 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl << 4);
508  
509 @@ -163,28 +163,28 @@
510 ieee->seq_ctrl = 0;
511 else
512 ieee->seq_ctrl++;
513 -
514 +
515 /* avoid watchdog triggers */
516 ieee->dev->trans_start = jiffies;
517 ieee->softmac_data_hard_start_xmit(skb,ieee->dev,ieee->basic_rate);
518 //added by david, 2007.1.23
519 dev_kfree_skb_any(skb);
520 }
521 -
522 +
523 spin_unlock_irqrestore(&ieee->lock, flags);
524 }else{
525 spin_unlock_irqrestore(&ieee->lock, flags);
526 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags);
527 -
528 +
529 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl << 4);
530 -
531 +
532 if (ieee->seq_ctrl == 0xFFF)
533 ieee->seq_ctrl = 0;
534 else
535 ieee->seq_ctrl++;
536 -
537 +
538 ieee->softmac_hard_start_xmit(skb,ieee->dev);
539 -
540 +
541 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags);
542 }
543 }
544 @@ -192,36 +192,36 @@
545  
546 inline void softmac_ps_mgmt_xmit(struct sk_buff *skb, struct ieee80211_device *ieee)
547 {
548 -
549 +
550 short single = ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE;
551 struct ieee80211_hdr_3addr *header =
552 (struct ieee80211_hdr_3addr *) skb->data;
553 -
554 -
555 +
556 +
557 if(single){
558 -
559 +
560 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl << 4);
561  
562 if (ieee->seq_ctrl == 0xFFF)
563 ieee->seq_ctrl = 0;
564 else
565 ieee->seq_ctrl++;
566 -
567 +
568 /* avoid watchdog triggers */
569 ieee->dev->trans_start = jiffies;
570 ieee->softmac_data_hard_start_xmit(skb,ieee->dev,ieee->basic_rate);
571 -
572 +
573 }else{
574 -
575 +
576 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl << 4);
577 -
578 +
579 if (ieee->seq_ctrl == 0xFFF)
580 ieee->seq_ctrl = 0;
581 else
582 ieee->seq_ctrl++;
583  
584 ieee->softmac_hard_start_xmit(skb,ieee->dev);
585 -
586 +
587 }
588 }
589  
590 @@ -231,35 +231,35 @@
591 u8 *tag;
592 struct sk_buff *skb;
593 struct ieee80211_probe_request *req;
594 -
595 +
596 len = ieee->current_network.ssid_len;
597 -
598 +
599 rate_len = ieee80211_MFIE_rate_len(ieee);
600 -
601 +
602 skb = dev_alloc_skb(sizeof(struct ieee80211_probe_request) +
603 2 + len + rate_len);
604 -
605 - if (!skb)
606 +
607 + if (!skb)
608 return NULL;
609 -
610 +
611 req = (struct ieee80211_probe_request *) skb_put(skb,sizeof(struct ieee80211_probe_request));
612 - if (ieee->ps == IEEE80211_PS_DISABLED)
613 + if (ieee->ps == IEEE80211_PS_DISABLED)
614 req->header.frame_ctl = IEEE80211_STYPE_PROBE_REQ;//changed!!
615 - else
616 + else
617 req->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ|IEEE80211_FCTL_PM);//tony ,for ps ctl bit
618 - req->header.duration_id = 0; //FIXME: is this OK ?
619 -
620 + req->header.duration_id = 0; //FIXME: is this OK ?
621 +
622 memset(req->header.addr1, 0xff, ETH_ALEN);
623 memcpy(req->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
624 memset(req->header.addr3, 0xff, ETH_ALEN);
625 -
626 +
627 tag = (u8 *) skb_put(skb,len+2+rate_len);
628 -
629 +
630 *tag++ = MFIE_TYPE_SSID;
631 *tag++ = len;
632 memcpy(tag, ieee->current_network.ssid, len);
633 tag += len;
634 -
635 +
636 ieee80211_MFIE_Brate(ieee,&tag);
637 ieee80211_MFIE_Grate(ieee,&tag);
638 return skb;
639 @@ -269,18 +269,18 @@
640 void ieee80211_send_beacon(struct ieee80211_device *ieee)
641 {
642 struct sk_buff *skb;
643 -
644 - unsigned long flags;
645 -
646 +
647 + unsigned long flags;
648 +
649 skb = ieee80211_get_beacon_(ieee);
650 if (skb){
651 softmac_mgmt_xmit(skb, ieee);
652 ieee->softmac_stats.tx_beacons++;
653 }
654  
655 - ieee->beacon_timer.expires = jiffies +
656 + ieee->beacon_timer.expires = jiffies +
657 (MSECS( ieee->current_network.beacon_interval -5));
658 -
659 +
660 spin_lock_irqsave(&ieee->beacon_lock,flags);
661 if(ieee->beacon_txing)
662 add_timer(&ieee->beacon_timer);
663 @@ -299,7 +299,7 @@
664 void ieee80211_send_probe(struct ieee80211_device *ieee)
665 {
666 struct sk_buff *skb;
667 -
668 +
669 skb = ieee80211_probe_req(ieee);
670 if (skb){
671 softmac_mgmt_xmit(skb, ieee);
672 @@ -316,29 +316,29 @@
673 }
674  
675 /* this performs syncro scan blocking the caller until all channels
676 - * in the allowed channel map has been checked.
677 + * in the allowed channel map has been checked.
678 */
679 void ieee80211_softmac_scan_syncro(struct ieee80211_device *ieee)
680 {
681 short ch = 0;
682 -
683 +
684 down(&ieee->scan_sem);
685 -
686 +
687 while(1)
688 {
689 -
690 +
691 do{
692 ch++;
693 - if (ch > MAX_CHANNEL_NUMBER)
694 + if (ch > MAX_CHANNEL_NUMBER)
695 goto out; /* scan completed */
696 -
697 +
698 }while(!ieee->channel_map[ch]);
699 -
700 +
701 /* this fuction can be called in two situations
702 * 1- We have switched to ad-hoc mode and we are
703 * performing a complete syncro scan before conclude
704 - * there are no interesting cell and to create a
705 - * new one. In this case the link state is
706 + * there are no interesting cell and to create a
707 + * new one. In this case the link state is
708 * IEEE80211_NOLINK until we found an interesting cell.
709 * If so the ieee8021_new_net, called by the RX path
710 * will set the state to IEEE80211_LINKED, so we stop
711 @@ -351,24 +351,24 @@
712 * not filter RX frames and the channel is changing.
713 * So the only situation in witch are interested is to check
714 * if the state become LINKED because of the #1 situation
715 - */
716 -
717 + */
718 +
719 if (ieee->state == IEEE80211_LINKED)
720 goto out;
721 -
722 +
723 ieee->set_chan(ieee->dev, ch);
724 // printk(KERN_INFO "current probe channel is %d!\n",ch);
725 ieee80211_send_probe_requests(ieee);
726 -
727 +
728 /* this prevent excessive time wait when we
729 * need to wait for a syncro scan to end..
730 - */
731 + */
732 if (ieee->sync_scan_hurryup)
733 goto out;
734  
735  
736 msleep_interruptible_rtl(IEEE80211_SOFTMAC_SCAN_TIME);
737 -
738 +
739 }
740 out:
741 ieee->sync_scan_hurryup = 0;
742 @@ -379,43 +379,50 @@
743 void ieee80211_softmac_scan(struct ieee80211_device *ieee)
744 {
745 short watchdog = 0;
746 -
747 +
748 do{
749 - ieee->current_network.channel =
750 + ieee->current_network.channel =
751 (ieee->current_network.channel + 1) % MAX_CHANNEL_NUMBER;
752 - if (watchdog++ > MAX_CHANNEL_NUMBER)
753 + if (watchdog++ > MAX_CHANNEL_NUMBER)
754 return; /* no good chans */
755 -
756 +
757 }while(!ieee->channel_map[ieee->current_network.channel]);
758 -
759 +
760  
761 schedule_work(&ieee->softmac_scan_wq);
762 }
763 #endif
764  
765 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
766 +void ieee80211_softmac_scan_wq(struct work_struct *work)
767 +{
768 + struct delayed_work *dwork = container_of(work, struct delayed_work, work);
769 + struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, softmac_scan_wq);
770 +#else
771 void ieee80211_softmac_scan_wq(struct ieee80211_device *ieee)
772 -{
773 +{
774 +#endif
775 short watchdog = 0;
776 down(&ieee->scan_sem);
777 -
778 -
779 +
780 +
781 do{
782 - ieee->current_network.channel =
783 + ieee->current_network.channel =
784 (ieee->current_network.channel + 1) % MAX_CHANNEL_NUMBER;
785 - if (watchdog++ > MAX_CHANNEL_NUMBER)
786 + if (watchdog++ > MAX_CHANNEL_NUMBER)
787 goto out; /* no good chans */
788 -
789 +
790 }while(!ieee->channel_map[ieee->current_network.channel]);
791 -
792 +
793 if (ieee->scanning == 0 )
794 goto out;
795 -
796 +
797 ieee->set_chan(ieee->dev, ieee->current_network.channel);
798 ieee80211_send_probe_requests(ieee);
799  
800 -#if 0
801 +#if 0
802 ieee->.expires = jiffies + (IEEE80211_SOFTMAC_SCAN_TIME);
803 - if (ieee->scanning == 1)
804 + if (ieee->scanning == 1)
805 add_timer(&ieee->scan_timer);
806 #endif
807 queue_delayed_work(ieee->wq, &ieee->softmac_scan_wq, IEEE80211_SOFTMAC_SCAN_TIME);
808 @@ -428,7 +435,7 @@
809 {
810 unsigned long flags;
811 struct ieee80211_device *ieee = (struct ieee80211_device *)_dev;
812 -
813 +
814 spin_lock_irqsave(&ieee->lock, flags);
815 ieee80211_softmac_scan(ieee);
816 spin_unlock_irqrestore(&ieee->lock, flags);
817 @@ -438,13 +445,13 @@
818  
819 void ieee80211_beacons_start(struct ieee80211_device *ieee)
820 {
821 - unsigned long flags;
822 + unsigned long flags;
823  
824 spin_lock_irqsave(&ieee->beacon_lock,flags);
825  
826 ieee->beacon_txing = 1;
827 ieee80211_send_beacon(ieee);
828 -
829 +
830 spin_unlock_irqrestore(&ieee->beacon_lock,flags);
831 }
832  
833 @@ -476,25 +483,25 @@
834 if(ieee->start_send_beacons)
835 ieee->start_send_beacons(ieee->dev);
836 if(ieee->softmac_features & IEEE_SOFTMAC_BEACONS)
837 - ieee80211_beacons_start(ieee);
838 + ieee80211_beacons_start(ieee);
839 }
840  
841  
842 void ieee80211_softmac_stop_scan(struct ieee80211_device *ieee)
843 {
844 -// unsigned long flags;
845 -
846 +// unsigned long flags;
847 +
848 //ieee->sync_scan_hurryup = 1;
849 -
850 +
851 down(&ieee->scan_sem);
852 // spin_lock_irqsave(&ieee->lock, flags);
853 -
854 +
855 if (ieee->scanning == 1){
856 ieee->scanning = 0;
857 //del_timer_sync(&ieee->scan_timer);
858 cancel_delayed_work(&ieee->softmac_scan_wq);
859 }
860 -
861 +
862 // spin_unlock_irqrestore(&ieee->lock, flags);
863 up(&ieee->scan_sem);
864 }
865 @@ -510,62 +517,66 @@
866 /* called with ieee->lock held */
867 void ieee80211_start_scan(struct ieee80211_device *ieee)
868 {
869 - if (ieee->softmac_features & IEEE_SOFTMAC_SCAN){
870 + if (ieee->softmac_features & IEEE_SOFTMAC_SCAN){
871 if (ieee->scanning == 0){
872 ieee->scanning = 1;
873 //ieee80211_softmac_scan(ieee);
874 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
875 queue_work(ieee->wq, &ieee->softmac_scan_wq);
876 +#else
877 + queue_delayed_work(ieee->wq, &ieee->softmac_scan_wq, 0);
878 +#endif
879 }
880 }else
881 ieee->start_scan(ieee->dev);
882 -
883 +
884 }
885  
886 /* called with wx_sem held */
887 void ieee80211_start_scan_syncro(struct ieee80211_device *ieee)
888 {
889 ieee->sync_scan_hurryup = 0;
890 -
891 +
892 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN)
893 ieee80211_softmac_scan_syncro(ieee);
894 else
895 ieee->scan_syncro(ieee->dev);
896 -
897 +
898 }
899  
900 -inline struct sk_buff *ieee80211_authentication_req(struct ieee80211_network *beacon,
901 +inline struct sk_buff *ieee80211_authentication_req(struct ieee80211_network *beacon,
902 struct ieee80211_device *ieee, int challengelen)
903 {
904 - struct sk_buff *skb;
905 + struct sk_buff *skb;
906 struct ieee80211_authentication *auth;
907 -
908 - skb = dev_alloc_skb(sizeof(struct ieee80211_authentication) + challengelen);
909 -
910 +
911 + skb = dev_alloc_skb(sizeof(struct ieee80211_authentication) + challengelen);
912 +
913 if (!skb) return NULL;
914 -
915 +
916 auth = (struct ieee80211_authentication *)
917 skb_put(skb, sizeof(struct ieee80211_authentication));
918 -
919 +
920 auth->header.frame_ctl = IEEE80211_STYPE_AUTH;
921 if (challengelen) auth->header.frame_ctl |= IEEE80211_FCTL_WEP;
922 if (ieee->ps != IEEE80211_PS_DISABLED) auth->header.frame_ctl |= IEEE80211_FCTL_PM;//tony 060624
923  
924 -
925 +
926 auth->header.duration_id = 0x013a; //FIXME
927 -
928 +
929 memcpy(auth->header.addr1, beacon->bssid, ETH_ALEN);
930 memcpy(auth->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
931 memcpy(auth->header.addr3, beacon->bssid, ETH_ALEN);
932 -
933 +
934 auth->algorithm = ieee->open_wep ? WLAN_AUTH_OPEN : WLAN_AUTH_SHARED_KEY;
935 -
936 +
937 auth->transaction = cpu_to_le16(ieee->associate_seq);
938 ieee->associate_seq++;
939 -
940 +
941 auth->status = cpu_to_le16(WLAN_STATUS_SUCCESS);
942 -
943 +
944 return skb;
945 -
946 +
947 }
948  
949 static struct sk_buff* ieee80211_probe_resp(struct ieee80211_device *ieee, u8 *dest)
950 @@ -577,23 +588,23 @@
951 int encrypt;
952 int atim_len,erp_len;
953 struct ieee80211_crypt_data* crypt;
954 -
955 +
956 char *ssid = ieee->current_network.ssid;
957 int ssid_len = ieee->current_network.ssid_len;
958 int rate_len = ieee->current_network.rates_len+2;
959 int rate_ex_len = ieee->current_network.rates_ex_len;
960 if(rate_ex_len > 0) rate_ex_len+=2;
961 -
962 +
963 if(ieee->current_network.capability & WLAN_CAPABILITY_IBSS)
964 atim_len = 4;
965 else
966 atim_len = 0;
967 -
968 - if(ieee80211_is_54g(ieee->current_network))
969 +
970 + if(ieee80211_is_54g(ieee->current_network))
971 erp_len = 3;
972 else
973 erp_len = 0;
974 -
975 +
976 beacon_size = sizeof(struct ieee80211_probe_response)+
977 ssid_len
978 +3 //channel
979 @@ -601,72 +612,72 @@
980 +rate_ex_len
981 +atim_len
982 +erp_len;
983 -
984 +
985 skb = dev_alloc_skb(beacon_size);
986 -
987 - if (!skb)
988 +
989 + if (!skb)
990 return NULL;
991 -
992 +
993 beacon_buf = (struct ieee80211_probe_response*) skb_put(skb, beacon_size);
994 -
995 +
996 memcpy (beacon_buf->header.addr1, dest,ETH_ALEN);
997 memcpy (beacon_buf->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
998 memcpy (beacon_buf->header.addr3, ieee->current_network.bssid, ETH_ALEN);
999  
1000 beacon_buf->header.duration_id = 0; //FIXME
1001 - beacon_buf->beacon_interval =
1002 + beacon_buf->beacon_interval =
1003 cpu_to_le16(ieee->current_network.beacon_interval);
1004 - beacon_buf->capability =
1005 + beacon_buf->capability =
1006 cpu_to_le16(ieee->current_network.capability & WLAN_CAPABILITY_IBSS);
1007 -
1008 +
1009 if(ieee->short_slot && (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_SLOT))
1010 - cpu_to_le16((beacon_buf->capability |= WLAN_CAPABILITY_SHORT_SLOT));
1011 -
1012 + cpu_to_le16((beacon_buf->capability |= WLAN_CAPABILITY_SHORT_SLOT));
1013 +
1014 crypt = ieee->crypt[ieee->tx_keyidx];
1015  
1016 - encrypt = ieee->host_encrypt && crypt && crypt->ops &&
1017 + encrypt = ieee->host_encrypt && crypt && crypt->ops &&
1018 (0 == strcmp(crypt->ops->name, "WEP"));
1019  
1020 - if (encrypt)
1021 + if (encrypt)
1022 beacon_buf->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
1023 -
1024 -
1025 +
1026 +
1027 beacon_buf->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_PROBE_RESP);
1028 -
1029 - beacon_buf->info_element.id = MFIE_TYPE_SSID;
1030 +
1031 + beacon_buf->info_element.id = MFIE_TYPE_SSID;
1032 beacon_buf->info_element.len = ssid_len;
1033 -
1034 +
1035 tag = (u8*) beacon_buf->info_element.data;
1036 -
1037 +
1038 memcpy(tag, ssid, ssid_len);
1039 -
1040 +
1041 tag += ssid_len;
1042 -
1043 +
1044 *(tag++) = MFIE_TYPE_RATES;
1045 - *(tag++) = rate_len-2;
1046 + *(tag++) = rate_len-2;
1047 memcpy(tag,ieee->current_network.rates,rate_len-2);
1048 tag+=rate_len-2;
1049 -
1050 +
1051 *(tag++) = MFIE_TYPE_DS_SET;
1052 *(tag++) = 1;
1053 *(tag++) = ieee->current_network.channel;
1054 -
1055 +
1056 if(atim_len){
1057 *(tag++) = MFIE_TYPE_IBSS_SET;
1058 *(tag++) = 2;
1059 *((u16*)(tag)) = cpu_to_le16(ieee->current_network.atim_window);
1060 tag+=2;
1061 }
1062 -
1063 +
1064 if(erp_len){
1065 *(tag++) = MFIE_TYPE_ERP;
1066 *(tag++) = 1;
1067 - *(tag++) = 0;
1068 + *(tag++) = 0;
1069 }
1070 -
1071 +
1072 if(rate_ex_len){
1073 *(tag++) = MFIE_TYPE_RATES_EX;
1074 - *(tag++) = rate_ex_len-2;
1075 + *(tag++) = rate_ex_len-2;
1076 memcpy(tag,ieee->current_network.rates_ex,rate_ex_len-2);
1077 tag+=rate_ex_len-2;
1078 }
1079 @@ -679,52 +690,52 @@
1080 {
1081 struct sk_buff *skb;
1082 u8* tag;
1083 -
1084 +
1085 struct ieee80211_crypt_data* crypt;
1086 struct ieee80211_assoc_response_frame *assoc;
1087 short encrypt;
1088 -
1089 +
1090 unsigned int rate_len = ieee80211_MFIE_rate_len(ieee);
1091 int len = sizeof(struct ieee80211_assoc_response_frame) + rate_len;
1092 -
1093 - skb = dev_alloc_skb(len);
1094 -
1095 - if (!skb)
1096 +
1097 + skb = dev_alloc_skb(len);
1098 +
1099 + if (!skb)
1100 return NULL;
1101 -
1102 +
1103 assoc = (struct ieee80211_assoc_response_frame *)
1104 skb_put(skb,sizeof(struct ieee80211_assoc_response_frame));
1105 -
1106 +
1107 assoc->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP);
1108 memcpy(assoc->header.addr1, dest,ETH_ALEN);
1109 memcpy(assoc->header.addr3, ieee->dev->dev_addr, ETH_ALEN);
1110 memcpy(assoc->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1111 - assoc->capability = cpu_to_le16(ieee->iw_mode == IW_MODE_MASTER ?
1112 + assoc->capability = cpu_to_le16(ieee->iw_mode == IW_MODE_MASTER ?
1113 WLAN_CAPABILITY_BSS : WLAN_CAPABILITY_IBSS);
1114 -
1115 -
1116 +
1117 +
1118 if(ieee->short_slot)
1119 assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT);
1120 -
1121 +
1122 if (ieee->host_encrypt)
1123 crypt = ieee->crypt[ieee->tx_keyidx];
1124 else crypt = NULL;
1125 -
1126 +
1127 encrypt = ( crypt && crypt->ops);
1128 -
1129 +
1130 if (encrypt)
1131 assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
1132 -
1133 +
1134 assoc->status = 0;
1135 assoc->aid = cpu_to_le16(ieee->assoc_id);
1136 if (ieee->assoc_id == 0x2007) ieee->assoc_id=0;
1137 else ieee->assoc_id++;
1138 -
1139 +
1140 tag = (u8*) skb_put(skb, rate_len);
1141 -
1142 +
1143 ieee80211_MFIE_Brate(ieee, &tag);
1144 ieee80211_MFIE_Grate(ieee, &tag);
1145 -
1146 +
1147 return skb;
1148 }
1149  
1150 @@ -732,59 +743,59 @@
1151 {
1152 struct sk_buff *skb;
1153 struct ieee80211_authentication *auth;
1154 -
1155 - skb = dev_alloc_skb(sizeof(struct ieee80211_authentication)+1);
1156 -
1157 - if (!skb)
1158 +
1159 + skb = dev_alloc_skb(sizeof(struct ieee80211_authentication)+1);
1160 +
1161 + if (!skb)
1162 return NULL;
1163 -
1164 +
1165 skb->len = sizeof(struct ieee80211_authentication);
1166 -
1167 +
1168 auth = (struct ieee80211_authentication *)skb->data;
1169 -
1170 +
1171 auth->status = cpu_to_le16(status);
1172 auth->transaction = cpu_to_le16(2);
1173 auth->algorithm = cpu_to_le16(WLAN_AUTH_OPEN);
1174 -
1175 +
1176 memcpy(auth->header.addr3, ieee->dev->dev_addr, ETH_ALEN);
1177 memcpy(auth->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1178 memcpy(auth->header.addr1, dest, ETH_ALEN);
1179 - auth->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_AUTH);
1180 + auth->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_AUTH);
1181 return skb;
1182 -
1183 -
1184 +
1185 +
1186 }
1187  
1188 struct sk_buff* ieee80211_null_func(struct ieee80211_device *ieee,short pwr)
1189 {
1190 struct sk_buff *skb;
1191 struct ieee80211_hdr_3addr* hdr;
1192 -
1193 - skb = dev_alloc_skb(sizeof(struct ieee80211_hdr_3addr));
1194 -
1195 - if (!skb)
1196 +
1197 + skb = dev_alloc_skb(sizeof(struct ieee80211_hdr_3addr));
1198 +
1199 + if (!skb)
1200 return NULL;
1201 -
1202 +
1203 hdr = (struct ieee80211_hdr_3addr*)skb_put(skb,sizeof(struct ieee80211_hdr_3addr));
1204 -
1205 +
1206 memcpy(hdr->addr1, ieee->current_network.bssid, ETH_ALEN);
1207 memcpy(hdr->addr2, ieee->dev->dev_addr, ETH_ALEN);
1208 memcpy(hdr->addr3, ieee->current_network.bssid, ETH_ALEN);
1209 -
1210 - hdr->frame_ctl = cpu_to_le16(IEEE80211_FTYPE_DATA |
1211 - IEEE80211_STYPE_NULLFUNC | IEEE80211_FCTL_TODS |
1212 - (pwr ? IEEE80211_FCTL_PM:0));
1213 -
1214 +
1215 + hdr->frame_ctl = cpu_to_le16(IEEE80211_FTYPE_DATA |
1216 + IEEE80211_STYPE_NULLFUNC | IEEE80211_FCTL_TODS |
1217 + (pwr ? IEEE80211_FCTL_PM:0));
1218 +
1219 return skb;
1220 -
1221 -
1222 +
1223 +
1224 }
1225  
1226  
1227 void ieee80211_resp_to_assoc_rq(struct ieee80211_device *ieee, u8* dest)
1228 {
1229 struct sk_buff *buf = ieee80211_assoc_resp(ieee, dest);
1230 -
1231 +
1232 if (buf)
1233 softmac_mgmt_xmit(buf, ieee);
1234 }
1235 @@ -793,7 +804,7 @@
1236 void ieee80211_resp_to_auth(struct ieee80211_device *ieee, int s, u8* dest)
1237 {
1238 struct sk_buff *buf = ieee80211_auth_resp(ieee, s, dest);
1239 -
1240 +
1241 if (buf)
1242 softmac_mgmt_xmit(buf, ieee);
1243 }
1244 @@ -801,10 +812,10 @@
1245  
1246 void ieee80211_resp_to_probe(struct ieee80211_device *ieee, u8 *dest)
1247 {
1248 -
1249 +
1250 struct sk_buff *buf = ieee80211_probe_resp(ieee, dest);
1251 -
1252 - if (buf)
1253 +
1254 + if (buf)
1255 softmac_mgmt_xmit(buf, ieee);
1256 }
1257  
1258 @@ -812,72 +823,72 @@
1259 inline struct sk_buff *ieee80211_association_req(struct ieee80211_network *beacon,struct ieee80211_device *ieee)
1260 {
1261 struct sk_buff *skb;
1262 -
1263 +
1264 struct ieee80211_assoc_request_frame *hdr;
1265 u8 *tag;
1266 -
1267 +
1268 unsigned int wpa_len = beacon->wpa_ie_len;
1269 unsigned int rsn_len = beacon->rsn_ie_len;
1270 -
1271 +
1272 unsigned int rate_len = ieee80211_MFIE_rate_len(ieee);
1273 -
1274 -
1275 -
1276 +
1277 +
1278 +
1279 int len=sizeof(struct ieee80211_assoc_request_frame)+
1280 + beacon->ssid_len//essid tagged val
1281 + rate_len//rates tagged val
1282 + rsn_len
1283 + wpa_len;
1284 -
1285 +
1286 skb = dev_alloc_skb(len);
1287 -
1288 - if (!skb)
1289 +
1290 + if (!skb)
1291 return NULL;
1292 -
1293 +
1294 hdr = (struct ieee80211_assoc_request_frame *)
1295 skb_put(skb, sizeof(struct ieee80211_assoc_request_frame));
1296 -
1297 -
1298 +
1299 +
1300 hdr->header.frame_ctl = IEEE80211_STYPE_ASSOC_REQ;
1301 if (ieee->ps != IEEE80211_PS_DISABLED) hdr->header.frame_ctl |= IEEE80211_FCTL_PM; //tony
1302 hdr->header.duration_id= 37; //FIXME
1303 memcpy(hdr->header.addr1, beacon->bssid, ETH_ALEN);
1304 memcpy(hdr->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1305 memcpy(hdr->header.addr3, beacon->bssid, ETH_ALEN);
1306 -
1307 +
1308 hdr->capability = cpu_to_le16(WLAN_CAPABILITY_BSS);
1309 - if (beacon->capability & WLAN_CAPABILITY_PRIVACY )
1310 + if (beacon->capability & WLAN_CAPABILITY_PRIVACY )
1311 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
1312 if(beacon->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
1313 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE); //tony 20060606
1314 -
1315 +
1316 if(ieee->short_slot)
1317 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT);
1318 -
1319 +
1320 hdr->listen_interval = 0xa; //FIXME
1321 -
1322 +
1323 hdr->info_element.id = MFIE_TYPE_SSID;
1324  
1325 hdr->info_element.len = beacon->ssid_len;
1326 tag = skb_put(skb, beacon->ssid_len);
1327 memcpy(tag, beacon->ssid, beacon->ssid_len);
1328 -
1329 - tag = skb_put(skb, rate_len);
1330 -
1331 +
1332 + tag = skb_put(skb, rate_len);
1333 +
1334 ieee80211_MFIE_Brate(ieee, &tag);
1335 ieee80211_MFIE_Grate(ieee, &tag);
1336 -
1337 +
1338 tag = skb_put(skb,wpa_len);
1339 -
1340 +
1341 if(wpa_len) {
1342 if(wpa_len > (22 + 2) )
1343 {
1344 beacon->wpa_ie[wpa_len - 2] = 0;
1345 }
1346 -
1347 +
1348 }
1349 memcpy(tag,beacon->wpa_ie,wpa_len);
1350 -
1351 +
1352 tag = skb_put(skb,rsn_len);
1353  
1354 if(rsn_len) {
1355 @@ -890,12 +901,12 @@
1356  
1357 void ieee80211_associate_abort(struct ieee80211_device *ieee)
1358 {
1359 -
1360 +
1361 unsigned long flags;
1362 spin_lock_irqsave(&ieee->lock, flags);
1363 -
1364 +
1365 ieee->associate_seq++;
1366 -
1367 +
1368 /* don't scan, and avoid to have the RX path possibily
1369 * try again to associate. Even do not react to AUTH or
1370 * ASSOC response. Just wait for the retry wq to be scheduled.
1371 @@ -903,17 +914,17 @@
1372 * with, so we retry or just get back to NO_LINK and scanning
1373 */
1374 if (ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATING){
1375 - IEEE80211_DEBUG_MGMT("Authentication failed\n");
1376 + IEEE80211_DEBUG_MGMT("Authentication failed\n");
1377 ieee->softmac_stats.no_auth_rs++;
1378 }else{
1379 - IEEE80211_DEBUG_MGMT("Association failed\n");
1380 + IEEE80211_DEBUG_MGMT("Association failed\n");
1381 ieee->softmac_stats.no_ass_rs++;
1382 }
1383 -
1384 +
1385 ieee->state = IEEE80211_ASSOCIATING_RETRY;
1386 -
1387 +
1388 queue_delayed_work(ieee->wq, &ieee->associate_retry_wq, IEEE80211_SOFTMAC_ASSOC_RETRY_TIME);
1389 -
1390 +
1391 spin_unlock_irqrestore(&ieee->lock, flags);
1392 }
1393  
1394 @@ -927,50 +938,50 @@
1395 {
1396 struct ieee80211_network *beacon = &ieee->current_network;
1397 struct sk_buff *skb;
1398 -
1399 +
1400 IEEE80211_DEBUG_MGMT("Stopping scan\n");
1401 -
1402 +
1403 ieee->softmac_stats.tx_auth_rq++;
1404 skb=ieee80211_authentication_req(beacon, ieee, 0);
1405 -
1406 - if (!skb)
1407 +
1408 + if (!skb)
1409 ieee80211_associate_abort(ieee);
1410 - else{
1411 + else{
1412 ieee->state = IEEE80211_ASSOCIATING_AUTHENTICATING ;
1413 IEEE80211_DEBUG_MGMT("Sending authentication request\n");
1414 softmac_mgmt_xmit(skb, ieee);
1415 ieee->associate_timer.expires = jiffies + (HZ / 2);
1416 add_timer(&ieee->associate_timer);
1417 - }
1418 + }
1419 }
1420  
1421 void ieee80211_auth_challenge(struct ieee80211_device *ieee, u8 *challenge, int chlen)
1422 {
1423 - u8 *c;
1424 + u8 *c;
1425 struct sk_buff *skb;
1426 struct ieee80211_network *beacon = &ieee->current_network;
1427 // int hlen = sizeof(struct ieee80211_authentication);
1428 -
1429 +
1430 ieee->associate_seq++;
1431 ieee->softmac_stats.tx_auth_rq++;
1432 -
1433 +
1434 skb = ieee80211_authentication_req(beacon, ieee, chlen+2);
1435 - if (!skb)
1436 + if (!skb)
1437 ieee80211_associate_abort(ieee);
1438 else{
1439 c = skb_put(skb, chlen+2);
1440 *(c++) = MFIE_TYPE_CHALLENGE;
1441 *(c++) = chlen;
1442 memcpy(c, challenge, chlen);
1443 -
1444 +
1445 IEEE80211_DEBUG_MGMT("Sending authentication challenge response\n");
1446 -
1447 +
1448 ieee80211_encrypt_fragment(ieee, skb, sizeof(struct ieee80211_hdr_3addr ));
1449 -
1450 +
1451 softmac_mgmt_xmit(skb, ieee);
1452 ieee->associate_timer.expires = jiffies + (HZ / 2);
1453 add_timer(&ieee->associate_timer);
1454 - }
1455 + }
1456 kfree(challenge);
1457 }
1458  
1459 @@ -978,28 +989,34 @@
1460 {
1461 struct sk_buff* skb;
1462 struct ieee80211_network *beacon = &ieee->current_network;
1463 -
1464 +
1465 del_timer_sync(&ieee->associate_timer);
1466 -
1467 +
1468 IEEE80211_DEBUG_MGMT("Sending association request\n");
1469 -
1470 +
1471 ieee->softmac_stats.tx_ass_rq++;
1472 skb=ieee80211_association_req(beacon, ieee);
1473 - if (!skb)
1474 + if (!skb)
1475 ieee80211_associate_abort(ieee);
1476 else{
1477 softmac_mgmt_xmit(skb, ieee);
1478 ieee->associate_timer.expires = jiffies + (HZ / 2);
1479 add_timer(&ieee->associate_timer);
1480 - }
1481 + }
1482 }
1483  
1484 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
1485 +void ieee80211_associate_complete_wq(struct work_struct *work)
1486 +{
1487 + struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, associate_complete_wq);
1488 +#else
1489 void ieee80211_associate_complete_wq(struct ieee80211_device *ieee)
1490 {
1491 +#endif
1492 printk(KERN_INFO "Associated successfully\n");
1493 - if(ieee80211_is_54g(ieee->current_network) &&
1494 + if(ieee80211_is_54g(ieee->current_network) &&
1495 (ieee->modulation & IEEE80211_OFDM_MODULATION)){
1496 -
1497 +
1498 ieee->rate = 540;
1499 printk(KERN_INFO"Using G rates\n");
1500 }else{
1501 @@ -1007,7 +1024,7 @@
1502 printk(KERN_INFO"Using B rates\n");
1503 }
1504 ieee->link_change(ieee->dev);
1505 - notify_wx_assoc_event(ieee);
1506 + notify_wx_assoc_event(ieee);
1507 if (ieee->data_hard_resume)
1508 ieee->data_hard_resume(ieee->dev);
1509 netif_carrier_on(ieee->dev);
1510 @@ -1017,52 +1034,58 @@
1511 {
1512  
1513 del_timer_sync(&ieee->associate_timer);
1514 -
1515 +
1516 ieee->seq_ctrl = 0;
1517 ieee->state = IEEE80211_LINKED;
1518 IEEE80211_DEBUG_MGMT("Successfully associated\n");
1519 -
1520 +
1521 queue_work(ieee->wq, &ieee->associate_complete_wq);
1522 }
1523  
1524 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
1525 +void ieee80211_associate_procedure_wq(struct work_struct *work)
1526 +{
1527 + struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, associate_procedure_wq);
1528 +#else
1529 void ieee80211_associate_procedure_wq(struct ieee80211_device *ieee)
1530 {
1531 +#endif
1532 ieee->sync_scan_hurryup = 1;
1533 down(&ieee->wx_sem);
1534 -
1535 +
1536 if (ieee->data_hard_stop)
1537 ieee->data_hard_stop(ieee->dev);
1538 -
1539 +
1540 ieee80211_stop_scan(ieee);
1541 ieee->set_chan(ieee->dev, ieee->current_network.channel);
1542 -
1543 +
1544 ieee->associate_seq = 1;
1545 ieee80211_associate_step1(ieee);
1546 -
1547 +
1548 up(&ieee->wx_sem);
1549 }
1550  
1551 inline void ieee80211_softmac_new_net(struct ieee80211_device *ieee, struct ieee80211_network *net)
1552 {
1553 -
1554 +
1555 u8 tmp_ssid[IW_ESSID_MAX_SIZE+1];
1556 int tmp_ssid_len = 0;
1557 -
1558 +
1559 short apset,ssidset,ssidbroad,apmatch,ssidmatch;
1560 -
1561 - /* we are interested in new new only if we are not associated
1562 +
1563 + /* we are interested in new new only if we are not associated
1564 * and we are not associating / authenticating
1565 */
1566 if (ieee->state != IEEE80211_NOLINK)
1567 - return;
1568 -
1569 + return;
1570 +
1571 if ((ieee->iw_mode == IW_MODE_INFRA) && !(net->capability & WLAN_CAPABILITY_BSS))
1572 return;
1573 -
1574 +
1575 if ((ieee->iw_mode == IW_MODE_ADHOC) && !(net->capability & WLAN_CAPABILITY_IBSS))
1576 return;
1577  
1578 -
1579 +
1580 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC){
1581 /* if the user specified the AP MAC, we need also the essid
1582 * This could be obtained by beacons or, if the network does not
1583 @@ -1073,23 +1096,23 @@
1584 ssidbroad = !(net->ssid_len == 0 || net->ssid[0]== '\0');
1585 apmatch = (memcmp(ieee->current_network.bssid, net->bssid, ETH_ALEN)==0);
1586 ssidmatch = (0==strncmp(ieee->current_network.ssid, net->ssid, net->ssid_len));
1587 -
1588 -
1589 -
1590 +
1591 +
1592 +
1593 if ( /* if the user set the AP check if match.
1594 * if the network does not broadcast essid we check the user supplyed ANY essid
1595 * if the network does broadcast and the user does not set essid it is OK
1596 * if the network does broadcast and the user did set essid chech if essid match
1597 */
1598 - ( apset && apmatch &&
1599 - ((ssidset && ssidbroad && ssidmatch) || (ssidbroad && !ssidset) || (!ssidbroad && ssidset)) ) ||
1600 + ( apset && apmatch &&
1601 + ((ssidset && ssidbroad && ssidmatch) || (ssidbroad && !ssidset) || (!ssidbroad && ssidset)) ) ||
1602 /* if the ap is not set, check that the user set the bssid
1603 * and the network does bradcast and that those two bssid matches
1604 - */
1605 - (!apset && ssidset && ssidbroad && ssidmatch)
1606 + */
1607 + (!apset && ssidset && ssidbroad && ssidmatch)
1608 ){
1609 -
1610 -
1611 +
1612 +
1613 /* if the essid is hidden replace it with the
1614 * essid provided by the user.
1615 */
1616 @@ -1098,18 +1121,18 @@
1617 tmp_ssid_len = ieee->current_network.ssid_len;
1618 }
1619 memcpy(&ieee->current_network, net, sizeof(struct ieee80211_network));
1620 -
1621 +
1622 if (!ssidbroad){
1623 strncpy(ieee->current_network.ssid, tmp_ssid, IW_ESSID_MAX_SIZE);
1624 ieee->current_network.ssid_len = tmp_ssid_len;
1625 }
1626 printk(KERN_INFO"Linking with %s\n",ieee->current_network.ssid);
1627 -
1628 +
1629 if (ieee->iw_mode == IW_MODE_INFRA){
1630 ieee->state = IEEE80211_ASSOCIATING;
1631 queue_work(ieee->wq, &ieee->associate_procedure_wq);
1632 }else{
1633 - if(ieee80211_is_54g(ieee->current_network) &&
1634 + if(ieee80211_is_54g(ieee->current_network) &&
1635 (ieee->modulation & IEEE80211_OFDM_MODULATION)){
1636 ieee->rate = 540;
1637 printk(KERN_INFO"Using G rates\n");
1638 @@ -1119,7 +1142,7 @@
1639 }
1640 ieee->state = IEEE80211_LINKED;
1641 }
1642 -
1643 +
1644 }
1645 }
1646  
1647 @@ -1127,26 +1150,26 @@
1648  
1649 void ieee80211_softmac_check_all_nets(struct ieee80211_device *ieee)
1650 {
1651 -
1652 +
1653 unsigned long flags;
1654 struct ieee80211_network *target;
1655 -
1656 +
1657 spin_lock_irqsave(&ieee->lock, flags);
1658 -
1659 +
1660 list_for_each_entry(target, &ieee->network_list, list) {
1661 -
1662 +
1663 /* if the state become different that NOLINK means
1664 * we had found what we are searching for
1665 */
1666 - if (ieee->state != IEEE80211_NOLINK)
1667 + if (ieee->state != IEEE80211_NOLINK)
1668 break;
1669 -
1670 +
1671 //if (ieee->scan_age == 0 || time_after(target->last_scanned + ieee->scan_age, jiffies))
1672 ieee80211_softmac_new_net(ieee, target);
1673 }
1674 -
1675 +
1676 spin_unlock_irqrestore(&ieee->lock, flags);
1677 -
1678 +
1679 }
1680  
1681  
1682 @@ -1154,7 +1177,7 @@
1683 {
1684 struct ieee80211_authentication *a;
1685 u8 *t;
1686 - if (skb->len < (sizeof(struct ieee80211_authentication)-sizeof(struct ieee80211_info_element))){
1687 + if (skb->len < (sizeof(struct ieee80211_authentication)-sizeof(struct ieee80211_info_element))){
1688 IEEE80211_DEBUG_MGMT("invalid len in auth resp: %d\n",skb->len);
1689 return 0xcafe;
1690 }
1691 @@ -1162,34 +1185,34 @@
1692 a = (struct ieee80211_authentication*) skb->data;
1693 if(skb->len > (sizeof(struct ieee80211_authentication) +3)){
1694 t = skb->data + sizeof(struct ieee80211_authentication);
1695 -
1696 +
1697 if(*(t++) == MFIE_TYPE_CHALLENGE){
1698 *chlen = *(t++);
1699 *challenge = (u8*)kmalloc(*chlen, GFP_ATOMIC);
1700 memcpy(*challenge, t, *chlen);
1701 }
1702 }
1703 -
1704 +
1705 return cpu_to_le16(a->status);
1706 -
1707 +
1708 }
1709  
1710  
1711 int auth_rq_parse(struct sk_buff *skb,u8* dest)
1712 {
1713 struct ieee80211_authentication *a;
1714 -
1715 - if (skb->len < (sizeof(struct ieee80211_authentication)-sizeof(struct ieee80211_info_element))){
1716 - IEEE80211_DEBUG_MGMT("invalid len in auth request: %d\n",skb->len);
1717 +
1718 + if (skb->len < (sizeof(struct ieee80211_authentication)-sizeof(struct ieee80211_info_element))){
1719 + IEEE80211_DEBUG_MGMT("invalid len in auth request: %d\n",skb->len);
1720 return -1;
1721 }
1722 a = (struct ieee80211_authentication*) skb->data;
1723 -
1724 +
1725 memcpy(dest,a->header.addr2, ETH_ALEN);
1726 -
1727 - if (le16_to_cpu(a->algorithm) != WLAN_AUTH_OPEN)
1728 +
1729 + if (le16_to_cpu(a->algorithm) != WLAN_AUTH_OPEN)
1730 return WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG;
1731 -
1732 +
1733 return WLAN_STATUS_SUCCESS;
1734 }
1735  
1736 @@ -1199,21 +1222,21 @@
1737 u8 *skbend;
1738 u8 *ssid=NULL;
1739 u8 ssidlen = 0;
1740 -
1741 +
1742 struct ieee80211_hdr_3addr *header =
1743 (struct ieee80211_hdr_3addr *) skb->data;
1744 -
1745 - if (skb->len < sizeof (struct ieee80211_hdr_3addr ))
1746 +
1747 + if (skb->len < sizeof (struct ieee80211_hdr_3addr ))
1748 return -1; /* corrupted */
1749 -
1750 +
1751 memcpy(src,header->addr2, ETH_ALEN);
1752 -
1753 +
1754 skbend = (u8*)skb->data + skb->len;
1755 -
1756 +
1757 tag = skb->data + sizeof (struct ieee80211_hdr_3addr );
1758 -
1759 +
1760 while (tag+1 < skbend){
1761 - if (*tag == 0){
1762 + if (*tag == 0){
1763 ssid = tag+2;
1764 ssidlen = *(tag+1);
1765 break;
1766 @@ -1222,41 +1245,41 @@
1767 tag = tag + *(tag); /* point to the last data byte of the tag */
1768 tag++; /* point to the next tag */
1769 }
1770 -
1771 +
1772 //IEEE80211DMESG("Card MAC address is "MACSTR, MAC2STR(src));
1773 if (ssidlen == 0) return 1;
1774 -
1775 +
1776 if (!ssid) return 1; /* ssid not found in tagged param */
1777 return (!strncmp(ssid, ieee->current_network.ssid, ssidlen));
1778 -
1779 +
1780 }
1781  
1782 int assoc_rq_parse(struct sk_buff *skb,u8* dest)
1783 {
1784 struct ieee80211_assoc_request_frame *a;
1785 -
1786 - if (skb->len < (sizeof(struct ieee80211_assoc_request_frame) -
1787 - sizeof(struct ieee80211_info_element))) {
1788 -
1789 +
1790 + if (skb->len < (sizeof(struct ieee80211_assoc_request_frame) -
1791 + sizeof(struct ieee80211_info_element))) {
1792 +
1793 IEEE80211_DEBUG_MGMT("invalid len in auth request:%d \n", skb->len);
1794 return -1;
1795 }
1796 -
1797 +
1798 a = (struct ieee80211_assoc_request_frame*) skb->data;
1799 -
1800 +
1801 memcpy(dest,a->header.addr2,ETH_ALEN);
1802 -
1803 +
1804 return 0;
1805 }
1806  
1807 static inline u16 assoc_parse(struct sk_buff *skb, int *aid)
1808 {
1809 struct ieee80211_assoc_response_frame *a;
1810 - if (skb->len < sizeof(struct ieee80211_assoc_response_frame)){
1811 + if (skb->len < sizeof(struct ieee80211_assoc_response_frame)){
1812 IEEE80211_DEBUG_MGMT("invalid len in auth resp: %d\n", skb->len);
1813 return 0xcafe;
1814 }
1815 -
1816 +
1817 a = (struct ieee80211_assoc_response_frame*) skb->data;
1818 *aid = le16_to_cpu(a->aid) & 0x3fff;
1819 return le16_to_cpu(a->status);
1820 @@ -1266,7 +1289,7 @@
1821 ieee80211_rx_probe_rq(struct ieee80211_device *ieee, struct sk_buff *skb)
1822 {
1823 u8 dest[ETH_ALEN];
1824 -
1825 +
1826 //IEEE80211DMESG("Rx probe");
1827 ieee->softmac_stats.rx_probe_rq++;
1828 //DMESG("Dest is "MACSTR, MAC2STR(dest));
1829 @@ -1284,26 +1307,26 @@
1830 int status;
1831 //IEEE80211DMESG("Rx probe");
1832 ieee->softmac_stats.rx_auth_rq++;
1833 -
1834 +
1835 if ((status = auth_rq_parse(skb, dest))!= -1){
1836 ieee80211_resp_to_auth(ieee, status, dest);
1837 }
1838 //DMESG("Dest is "MACSTR, MAC2STR(dest));
1839 -
1840 +
1841 }
1842  
1843 static inline void
1844 ieee80211_rx_assoc_rq(struct ieee80211_device *ieee, struct sk_buff *skb)
1845 {
1846 -
1847 +
1848 u8 dest[ETH_ALEN];
1849 //unsigned long flags;
1850 -
1851 +
1852 ieee->softmac_stats.rx_ass_rq++;
1853 if (assoc_rq_parse(skb,dest) != -1){
1854 ieee80211_resp_to_assoc_rq(ieee, dest);
1855 }
1856 -
1857 +
1858 printk(KERN_INFO"New client associated: "MAC_FMT"\n", MAC_ARG(dest));
1859 //FIXME
1860 #if 0
1861 @@ -1317,24 +1340,24 @@
1862  
1863 void ieee80211_sta_ps_send_null_frame(struct ieee80211_device *ieee, short pwr)
1864 {
1865 -
1866 +
1867 struct sk_buff *buf = ieee80211_null_func(ieee, pwr);
1868 -
1869 +
1870 if (buf)
1871 softmac_ps_mgmt_xmit(buf, ieee);
1872 // printk(KERN_INFO "ieee80211_sta_ps_send_null_frame!\n");
1873  
1874 -}
1875 +}
1876  
1877  
1878 short ieee80211_sta_ps_sleep(struct ieee80211_device *ieee, u32 *time_h, u32 *time_l)
1879 -{
1880 +{
1881 int timeout = ieee->ps_timeout;
1882 u8 dtim;
1883 /*if(ieee->ps == IEEE80211_PS_DISABLED ||
1884 - ieee->iw_mode != IW_MODE_INFRA ||
1885 + ieee->iw_mode != IW_MODE_INFRA ||
1886 ieee->state != IEEE80211_LINKED)
1887 -
1888 +
1889 return 0;
1890 */
1891 dtim = ieee->current_network.dtim_data;
1892 @@ -1343,7 +1366,7 @@
1893 return 0;
1894 printk(KERN_INFO "VALID\n");
1895 ieee->current_network.dtim_data = IEEE80211_DTIM_INVALID;
1896 -
1897 +
1898 if(dtim & ((IEEE80211_DTIM_UCAST | IEEE80211_DTIM_MBCAST)& ieee->ps))
1899 return 2;
1900 printk(KERN_INFO "no UCAST\n");
1901 @@ -1358,11 +1381,11 @@
1902 return 0;
1903 printk(KERN_INFO "cc\n");
1904 if(time_l){
1905 - *time_l = ieee->current_network.last_dtim_sta_time[0]
1906 - + (ieee->current_network.beacon_interval
1907 + *time_l = ieee->current_network.last_dtim_sta_time[0]
1908 + + (ieee->current_network.beacon_interval
1909 * ieee->current_network.dtim_period) * 1000;
1910 }
1911 -
1912 +
1913 if(time_h){
1914 *time_h = ieee->current_network.last_dtim_sta_time[1];
1915 if(time_l && *time_l < ieee->current_network.last_dtim_sta_time[0])
1916 @@ -1372,8 +1395,8 @@
1917 ieee->ps_tl=*time_l;
1918 // printk(KERN_INFO "ieee->ps_tl %lu!\n",ieee->ps_tl);
1919 return 1;
1920 -
1921 -
1922 +
1923 +
1924 }
1925  
1926 inline void ieee80211_sta_ps(struct ieee80211_device *ieee)
1927 @@ -1381,72 +1404,72 @@
1928  
1929 u32 th,tl;
1930 short sleep;
1931 -
1932 +
1933 unsigned long flags,flags2;
1934 //// printk(KERN_INFO "enter ieee80211_sta_ps!\n");
1935 spin_lock_irqsave(&ieee->lock, flags);
1936 -
1937 +
1938 if((ieee->ps == IEEE80211_PS_DISABLED ||
1939 - ieee->iw_mode != IW_MODE_INFRA ||
1940 + ieee->iw_mode != IW_MODE_INFRA ||
1941 ieee->state != IEEE80211_LINKED)){
1942 -
1943 +
1944 // #warning CHECK_LOCK_HERE
1945 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
1946 -
1947 - ieee80211_sta_wakeup(ieee, 1);
1948 +
1949 + ieee80211_sta_wakeup(ieee, 1);
1950 printk(KERN_WARNING "wakeup 1!\n" );
1951 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
1952 }
1953 -
1954 +
1955 sleep = ieee80211_sta_ps_sleep(ieee,&th, &tl);
1956 /* 2 wake, 1 sleep, 0 do nothing */
1957 //printk(KERN_INFO "sleep %d,th %lu, tl %lu,sta_sleep %d\n",sleep,th,tl,ieee->sta_sleep);
1958 if(sleep == 0)
1959 goto out;
1960 -
1961 +
1962 if(sleep == 1){
1963 -
1964 +
1965 if(ieee->sta_sleep == 1)
1966 //ieee->enter_sleep_state(ieee->dev,th,tl);
1967 queue_work(ieee->wq,&ieee->hw_sleep_wq);
1968 -
1969 +
1970 else if(ieee->sta_sleep == 0){
1971 // printk("send null 1\n");
1972 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
1973 -
1974 +
1975 if(ieee->ps_is_queue_empty(ieee->dev)){
1976 -
1977 -
1978 +
1979 +
1980 ieee->sta_sleep = 2;
1981 -
1982 +
1983 // ieee->ps_request_tx_ack(ieee->dev);
1984 // printk(KERN_INFO "ps request address %lu!\n",ieee->ps_request_tx_ack);
1985 - // queue_work(ieee->wq,&ieee->ps_request_tx_ack_wq);
1986 + // queue_work(ieee->wq,&ieee->ps_request_tx_ack_wq);
1987 ieee80211_sta_ps_send_null_frame(ieee,1);
1988 ieee80211_sta_ps_send_null_frame(ieee,1);
1989 -
1990 +
1991 ieee->ps_th = th;
1992 ieee->ps_tl = tl;
1993 // udelay(100);
1994 ieee80211_ps_tx_ack(ieee,1);//add without interrupt like 8185
1995 - }
1996 + }
1997 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
1998 -
1999 +
2000 }
2001 -
2002 -
2003 +
2004 +
2005 }else if(sleep == 2){
2006 // #warning CHECK_LOCK_HERE
2007 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
2008 -
2009 +
2010 ieee80211_sta_wakeup(ieee,1);
2011 printk(KERN_WARNING "wakeup 2!\n" );
2012 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
2013 }
2014  
2015 -out:
2016 +out:
2017 spin_unlock_irqrestore(&ieee->lock, flags);
2018 -
2019 +
2020 }
2021  
2022 void ieee80211_sta_wakeup(struct ieee80211_device *ieee, short nl)
2023 @@ -1460,14 +1483,14 @@
2024 ieee80211_sta_ps_send_null_frame(ieee, 0);
2025 }
2026 return;
2027 -
2028 +
2029 }
2030 - if(ieee->sta_sleep == 1)
2031 + if(ieee->sta_sleep == 1)
2032 //ieee->sta_wake_up(ieee->dev);
2033 queue_work(ieee->wq,&ieee->hw_wakeup_wq);
2034 -
2035 +
2036 ieee->sta_sleep = 0;
2037 -
2038 +
2039 if(nl){
2040 //ieee->ps_request_tx_ack(ieee->dev);
2041 //queue_work(ieee->wq,&ieee->ps_request_tx_ack_wq);
2042 @@ -1480,7 +1503,7 @@
2043 unsigned long flags,flags2;
2044 // printk(KERN_INFO "ieee80211_ps_tx_ack,success %d,sta_sleep %d!\n",success,ieee->sta_sleep);
2045 spin_lock_irqsave(&ieee->lock, flags);
2046 -
2047 +
2048 if(ieee->sta_sleep == 2){
2049 /* Null frame with PS bit set */
2050 if(success){
2051 @@ -1495,7 +1518,7 @@
2052 }
2053 /* 21112005 - tx again null without PS bit if lost */
2054 else {
2055 -
2056 +
2057 if((ieee->sta_sleep == 0) && !success){
2058 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
2059 ieee80211_sta_ps_send_null_frame(ieee, 0);
2060 @@ -1519,66 +1542,66 @@
2061 header = (struct ieee80211_hdr_3addr *) skb->data;
2062 if(!ieee->proto_started)
2063 return 0;
2064 -
2065 +
2066 if(ieee->sta_sleep || (ieee->ps != IEEE80211_PS_DISABLED &&
2067 - ieee->iw_mode == IW_MODE_INFRA &&
2068 + ieee->iw_mode == IW_MODE_INFRA &&
2069 ieee->state == IEEE80211_LINKED)) {
2070 //// printk(KERN_INFO "schedule ps task!\n");
2071 tasklet_schedule(&ieee->ps_task);}
2072 -
2073 +
2074 if(WLAN_FC_GET_STYPE(header->frame_ctl) != IEEE80211_STYPE_PROBE_RESP &&
2075 WLAN_FC_GET_STYPE(header->frame_ctl) != IEEE80211_STYPE_BEACON)
2076 ieee->last_rx_ps_time = jiffies;
2077 -
2078 +
2079 switch (WLAN_FC_GET_STYPE(header->frame_ctl)) {
2080 -
2081 +
2082 case IEEE80211_STYPE_ASSOC_RESP:
2083 case IEEE80211_STYPE_REASSOC_RESP:
2084 -
2085 +
2086 IEEE80211_DEBUG_MGMT("received [RE]ASSOCIATION RESPONSE (%d)\n",
2087 WLAN_FC_GET_STYPE(header->frame_ctl));
2088 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&
2089 - ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATED &&
2090 + ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATED &&
2091 ieee->iw_mode == IW_MODE_INFRA){
2092 if (0 == (errcode=assoc_parse(skb, &aid))){
2093 -
2094 +
2095 ieee->state=IEEE80211_LINKED;
2096 ieee->assoc_id = aid;
2097 ieee->softmac_stats.rx_ass_ok++;
2098 -
2099 +
2100 ieee80211_associate_complete(ieee);
2101 }else{
2102 ieee->softmac_stats.rx_ass_err++;
2103 IEEE80211_DEBUG_MGMT(
2104 "Association response status code 0x%x\n",
2105 errcode);
2106 - ieee80211_associate_abort(ieee);
2107 + ieee80211_associate_abort(ieee);
2108 }
2109 }
2110 break;
2111 -
2112 +
2113 case IEEE80211_STYPE_ASSOC_REQ:
2114 case IEEE80211_STYPE_REASSOC_REQ:
2115 -
2116 +
2117 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&
2118 ieee->iw_mode == IW_MODE_MASTER)
2119 -
2120 +
2121 ieee80211_rx_assoc_rq(ieee, skb);
2122 break;
2123 -
2124 +
2125 case IEEE80211_STYPE_AUTH:
2126 -
2127 +
2128 if (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE){
2129 - if (ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATING &&
2130 + if (ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATING &&
2131 ieee->iw_mode == IW_MODE_INFRA){
2132 -
2133 +
2134 IEEE80211_DEBUG_MGMT("Received authentication response");
2135 -
2136 +
2137 if (0 == (errcode=auth_parse(skb, &challenge, &chlen))){
2138 if(ieee->open_wep || !challenge){
2139 ieee->state = IEEE80211_ASSOCIATING_AUTHENTICATED;
2140 ieee->softmac_stats.rx_auth_rs_ok++;
2141 -
2142 +
2143 ieee80211_associate_step2(ieee);
2144 }else{
2145 ieee80211_auth_challenge(ieee, challenge, chlen);
2146 @@ -1588,47 +1611,47 @@
2147 IEEE80211_DEBUG_MGMT("Authentication respose status code 0x%x",errcode);
2148 ieee80211_associate_abort(ieee);
2149 }
2150 -
2151 +
2152 }else if (ieee->iw_mode == IW_MODE_MASTER){
2153 ieee80211_rx_auth_rq(ieee, skb);
2154 }
2155 }
2156 break;
2157 -
2158 +
2159 case IEEE80211_STYPE_PROBE_REQ:
2160 -
2161 - if ((ieee->softmac_features & IEEE_SOFTMAC_PROBERS) &&
2162 - ((ieee->iw_mode == IW_MODE_ADHOC ||
2163 +
2164 + if ((ieee->softmac_features & IEEE_SOFTMAC_PROBERS) &&
2165 + ((ieee->iw_mode == IW_MODE_ADHOC ||
2166 ieee->iw_mode == IW_MODE_MASTER) &&
2167 ieee->state == IEEE80211_LINKED))
2168 -
2169 +
2170 ieee80211_rx_probe_rq(ieee, skb);
2171 break;
2172 -
2173 +
2174 case IEEE80211_STYPE_DISASSOC:
2175 case IEEE80211_STYPE_DEAUTH:
2176 - /* FIXME for now repeat all the association procedure
2177 + /* FIXME for now repeat all the association procedure
2178 * both for disassociation and deauthentication
2179 */
2180 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&
2181 - ieee->state == IEEE80211_LINKED &&
2182 + ieee->state == IEEE80211_LINKED &&
2183 ieee->iw_mode == IW_MODE_INFRA){
2184 -
2185 +
2186 ieee->state = IEEE80211_ASSOCIATING;
2187 ieee->softmac_stats.reassoc++;
2188 -
2189 +
2190 notify_wx_assoc_event(ieee);
2191 -
2192 +
2193 queue_work(ieee->wq, &ieee->associate_procedure_wq);
2194 }
2195 -
2196 +
2197 break;
2198 -
2199 - default:
2200 +
2201 + default:
2202 return -1;
2203 break;
2204 }
2205 -
2206 +
2207 //dev_kfree_skb_any(skb);
2208 return 0;
2209 }
2210 @@ -1646,21 +1669,20 @@
2211 * This might be useful if each fragment need it's own
2212 * descriptor, thus just keep a total free memory > than
2213 * the max fragmentation treshold is not enought.. If the
2214 - * ieee802.11 stack passed a TXB struct then you needed
2215 - * to keep N free descriptors where
2216 + * ieee802.11 stack passed a TXB struct then you needed
2217 + * to keep N free descriptors where
2218 * N = MAX_PACKET_SIZE / MIN_FRAG_TRESHOLD
2219 * In this way you need just one and the 802.11 stack
2220 - * will take care of buffering fragments and pass them to
2221 + * will take care of buffering fragments and pass them to
2222 * to the driver later, when it wakes the queue.
2223 - */
2224 -
2225 + */
2226 +
2227 void ieee80211_softmac_xmit(struct ieee80211_txb *txb, struct ieee80211_device *ieee)
2228 {
2229 -
2230 -
2231 +
2232 +
2233 unsigned long flags;
2234 int i;
2235 -
2236 spin_lock_irqsave(&ieee->lock,flags);
2237 #if 0
2238 if(ieee->queue_stop){
2239 @@ -1671,13 +1693,13 @@
2240 err = 1;
2241 goto exit;
2242 }
2243 -
2244 +
2245 ieee->stats.tx_bytes+=skb->len;
2246 -
2247 -
2248 +
2249 +
2250 txb=ieee80211_skb_to_txb(ieee,skb);
2251 -
2252 -
2253 +
2254 +
2255 if(txb==NULL){
2256 IEEE80211DMESG("WW: IEEE stack failed to provide txb");
2257 //dev_kfree_skb_any(skb);
2258 @@ -1691,9 +1713,8 @@
2259 }
2260 /* called with 2nd parm 0, no tx mgmt lock required */
2261 ieee80211_sta_wakeup(ieee,0);
2262 -
2263 for(i = 0; i < txb->nr_frags; i++) {
2264 -
2265 +
2266 if (ieee->queue_stop){
2267 //added by david. 2007.1.23
2268 if(ieee->tx_pending.txb != NULL) {
2269 @@ -1709,16 +1730,16 @@
2270 //(i+1)<txb->nr_frags);
2271 ieee->stats.tx_packets++;
2272 ieee->stats.tx_bytes += txb->fragments[i]->len;
2273 - ieee->dev->trans_start = jiffies;
2274 + ieee->dev->trans_start = jiffies;
2275 }
2276 - }
2277 + }
2278 lost:
2279 //ieee80211_txb_free(txb);
2280 -
2281 +
2282 exit:
2283 atomic_dec(&ieee->tx_pending_txb);
2284 spin_unlock_irqrestore(&ieee->lock,flags);
2285 -
2286 +
2287 }
2288  
2289 /* called with ieee->lock acquired */
2290 @@ -1726,13 +1747,13 @@
2291 {
2292 int i;
2293 for(i = ieee->tx_pending.frag; i < ieee->tx_pending.txb->nr_frags; i++) {
2294 -
2295 +
2296 if (ieee->queue_stop){
2297 ieee->tx_pending.frag = i;
2298 return;
2299 }else{
2300 -
2301 - ieee->softmac_data_hard_start_xmit(
2302 +
2303 + ieee->softmac_data_hard_start_xmit(
2304 ieee->tx_pending.txb->fragments[i],
2305 ieee->dev,ieee->rate);
2306 //(i+1)<ieee->tx_pending.txb->nr_frags);
2307 @@ -1740,8 +1761,8 @@
2308 ieee->dev->trans_start = jiffies;
2309 }
2310 }
2311 -
2312 -
2313 +
2314 +
2315 //ieee80211_txb_free(ieee->tx_pending.txb);
2316 ieee->tx_pending.txb = NULL;
2317 }
2318 @@ -1751,7 +1772,7 @@
2319 {
2320 unsigned long flags;
2321 struct sk_buff *ret;
2322 -
2323 +
2324 spin_lock_irqsave(&ieee->lock,flags);
2325 // added by david, 2007.1.23
2326 while((ret = dequeue_mgmt(ieee)) != NULL) {
2327 @@ -1773,17 +1794,17 @@
2328 unsigned long flags;
2329 struct sk_buff *skb;
2330 struct ieee80211_hdr_3addr *header;
2331 -
2332 +
2333 spin_lock_irqsave(&ieee->lock,flags);
2334 if (! ieee->queue_stop) goto exit;
2335 -
2336 +
2337 ieee->queue_stop = 0;
2338 -
2339 +
2340 if(ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE){
2341 while (!ieee->queue_stop && (skb = dequeue_mgmt(ieee))){
2342 -
2343 +
2344 header = (struct ieee80211_hdr_3addr *) skb->data;
2345 -
2346 +
2347 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl << 4);
2348  
2349 if (ieee->seq_ctrl == 0xFFF)
2350 @@ -1799,12 +1820,12 @@
2351 }
2352 if (!ieee->queue_stop && ieee->tx_pending.txb)
2353 ieee80211_resume_tx(ieee);
2354 -
2355 +
2356 if (!ieee->queue_stop && netif_queue_stopped(ieee->dev)){
2357 ieee->softmac_stats.swtxawake++;
2358 netif_wake_queue(ieee->dev);
2359 }
2360 -
2361 +
2362 exit :
2363 spin_unlock_irqrestore(&ieee->lock,flags);
2364 }
2365 @@ -1821,17 +1842,17 @@
2366 }
2367 ieee->queue_stop = 1;
2368 //spin_unlock_irqrestore(&ieee->lock,flags);
2369 -
2370 +
2371 }
2372  
2373  
2374 inline void ieee80211_randomize_cell(struct ieee80211_device *ieee)
2375 {
2376 -
2377 +
2378 get_random_bytes(ieee->current_network.bssid, ETH_ALEN);
2379 -
2380 +
2381 /* an IBSS cell address must have the two less significant
2382 - * bits of the first byte = 2
2383 + * bits of the first byte = 2
2384 */
2385 ieee->current_network.bssid[0] &= ~0x01;
2386 ieee->current_network.bssid[0] |= 0x02;
2387 @@ -1841,61 +1862,68 @@
2388 void ieee80211_start_master_bss(struct ieee80211_device *ieee)
2389 {
2390 ieee->assoc_id = 1;
2391 -
2392 +
2393 if (ieee->current_network.ssid_len == 0){
2394 - strncpy(ieee->current_network.ssid,
2395 + strncpy(ieee->current_network.ssid,
2396 IEEE80211_DEFAULT_TX_ESSID,
2397 IW_ESSID_MAX_SIZE);
2398 -
2399 +
2400 ieee->current_network.ssid_len = strlen(IEEE80211_DEFAULT_TX_ESSID);
2401 ieee->ssid_set = 1;
2402 }
2403 -
2404 +
2405 memcpy(ieee->current_network.bssid, ieee->dev->dev_addr, ETH_ALEN);
2406 -
2407 +
2408 ieee->set_chan(ieee->dev, ieee->current_network.channel);
2409 ieee->state = IEEE80211_LINKED;
2410 ieee->link_change(ieee->dev);
2411 notify_wx_assoc_event(ieee);
2412 -
2413 +
2414 if (ieee->data_hard_resume)
2415 ieee->data_hard_resume(ieee->dev);
2416 -
2417 +
2418 netif_carrier_on(ieee->dev);
2419 }
2420  
2421 void ieee80211_start_monitor_mode(struct ieee80211_device *ieee)
2422 {
2423 if(ieee->raw_tx){
2424 -
2425 +
2426 if (ieee->data_hard_resume)
2427 ieee->data_hard_resume(ieee->dev);
2428 -
2429 +
2430 netif_carrier_on(ieee->dev);
2431 }
2432 }
2433 +
2434 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
2435 +void ieee80211_start_ibss_wq(struct work_struct *work)
2436 +{
2437 + struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, start_ibss_wq);
2438 +#else
2439 void ieee80211_start_ibss_wq(struct ieee80211_device *ieee)
2440 {
2441 -
2442 +#endif
2443 +
2444 /* iwconfig mode ad-hoc will schedule this and return
2445 * on the other hand this will block further iwconfig SET
2446 * operations because of the wx_sem hold.
2447 * Anyway some most set operations set a flag to speed-up
2448 - * (abort) this wq (when syncro scanning) before sleeping
2449 + * (abort) this wq (when syncro scanning) before sleeping
2450 * on the semaphore
2451 */
2452 -
2453 +
2454 down(&ieee->wx_sem);
2455 -
2456 +
2457 if (ieee->current_network.ssid_len == 0){
2458 strcpy(ieee->current_network.ssid,IEEE80211_DEFAULT_TX_ESSID);
2459 ieee->current_network.ssid_len = strlen(IEEE80211_DEFAULT_TX_ESSID);
2460 ieee->ssid_set = 1;
2461 - }
2462 -
2463 + }
2464 +
2465 /* check if we have this cell in our network list */
2466 ieee80211_softmac_check_all_nets(ieee);
2467 -
2468 +
2469 /* if not then the state is not linked. Maybe the user swithced to
2470 * ad-hoc mode just after being in monitor mode, or just after
2471 * being very few time in managed mode (so the card have had no
2472 @@ -1915,25 +1943,25 @@
2473  
2474 /* the network definitively is not here.. create a new cell */
2475 if (ieee->state == IEEE80211_NOLINK){
2476 - printk("creating new IBSS cell\n");
2477 + printk("creating new IBSS cell\n");
2478 if(!ieee->wap_set)
2479 ieee80211_randomize_cell(ieee);
2480 -
2481 +
2482 if(ieee->modulation & IEEE80211_CCK_MODULATION){
2483 -
2484 +
2485 ieee->current_network.rates_len = 4;
2486 -
2487 +
2488 ieee->current_network.rates[0] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
2489 ieee->current_network.rates[1] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
2490 ieee->current_network.rates[2] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_5MB;
2491 ieee->current_network.rates[3] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_11MB;
2492 -
2493 +
2494 }else
2495 ieee->current_network.rates_len = 0;
2496 -
2497 +
2498 if(ieee->modulation & IEEE80211_OFDM_MODULATION){
2499 ieee->current_network.rates_ex_len = 8;
2500 -
2501 +
2502 ieee->current_network.rates_ex[0] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_6MB;
2503 ieee->current_network.rates_ex[1] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_9MB;
2504 ieee->current_network.rates_ex[2] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_12MB;
2505 @@ -1942,34 +1970,34 @@
2506 ieee->current_network.rates_ex[5] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_36MB;
2507 ieee->current_network.rates_ex[6] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_48MB;
2508 ieee->current_network.rates_ex[7] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_54MB;
2509 -
2510 +
2511 ieee->rate = 540;
2512 }else{
2513 ieee->current_network.rates_ex_len = 0;
2514 ieee->rate = 110;
2515 }
2516 -
2517 +
2518 ieee->current_network.atim_window = 0;
2519 ieee->current_network.capability = WLAN_CAPABILITY_IBSS;
2520 if(ieee->short_slot)
2521 ieee->current_network.capability |= WLAN_CAPABILITY_SHORT_SLOT;
2522 -
2523 +
2524 }
2525 -
2526 +
2527 ieee->state = IEEE80211_LINKED;
2528 -
2529 +
2530 ieee->set_chan(ieee->dev, ieee->current_network.channel);
2531 ieee->link_change(ieee->dev);
2532 -
2533 +
2534 notify_wx_assoc_event(ieee);
2535 -
2536 +
2537 ieee80211_start_send_beacons(ieee);
2538 -
2539 +
2540 if (ieee->data_hard_resume)
2541 ieee->data_hard_resume(ieee->dev);
2542 -
2543 +
2544 netif_carrier_on(ieee->dev);
2545 -
2546 +
2547 up(&ieee->wx_sem);
2548 }
2549  
2550 @@ -1988,7 +2016,7 @@
2551 * in associating / authenticating phase) start the background scanning.
2552 */
2553 ieee80211_softmac_check_all_nets(ieee);
2554 -
2555 +
2556 /* ensure no-one start an associating process (thus setting
2557 * the ieee->state to ieee80211_ASSOCIATING) while we
2558 * have just cheked it and we are going to enable scan.
2559 @@ -1997,10 +2025,10 @@
2560 * the rx path), so we cannot be in the middle of such function
2561 */
2562 spin_lock_irqsave(&ieee->lock, flags);
2563 -
2564 +
2565 if (ieee->state == IEEE80211_NOLINK)
2566 ieee80211_start_scan(ieee);
2567 -
2568 +
2569 spin_unlock_irqrestore(&ieee->lock, flags);
2570 }
2571  
2572 @@ -2008,30 +2036,38 @@
2573 void ieee80211_disassociate(struct ieee80211_device *ieee)
2574 {
2575 netif_carrier_off(ieee->dev);
2576 -
2577 +
2578 if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)
2579 ieee80211_reset_queue(ieee);
2580 -
2581 +
2582 if (ieee->data_hard_stop)
2583 ieee->data_hard_stop(ieee->dev);
2584 -
2585 +
2586 ieee->state = IEEE80211_NOLINK;
2587 ieee->link_change(ieee->dev);
2588 notify_wx_assoc_event(ieee);
2589 -
2590 +
2591 }
2592 +
2593 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
2594 +void ieee80211_associate_retry_wq(struct work_struct *work)
2595 +{
2596 + struct delayed_work *dwork = container_of(work, struct delayed_work, work);
2597 + struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, associate_retry_wq);
2598 +#else
2599 void ieee80211_associate_retry_wq(struct ieee80211_device *ieee)
2600 {
2601 +#endif
2602 unsigned long flags;
2603 -
2604 +
2605 down(&ieee->wx_sem);
2606 if(!ieee->proto_started)
2607 goto exit;
2608 -
2609 +
2610 if(ieee->state != IEEE80211_ASSOCIATING_RETRY)
2611 goto exit;
2612 -
2613 - /* until we do not set the state to IEEE80211_NOLINK
2614 +
2615 + /* until we do not set the state to IEEE80211_NOLINK
2616 * there are no possibility to have someone else trying
2617 * to start an association procdure (we get here with
2618 * ieee->state = IEEE80211_ASSOCIATING).
2619 @@ -2041,18 +2077,18 @@
2620 * RX path works with ieee->lock held so there are no
2621 * problems. If we are still disassociated then start a scan.
2622 * the lock here is necessary to ensure no one try to start
2623 - * an association procedure when we have just checked the
2624 + * an association procedure when we have just checked the
2625 * state and we are going to start the scan.
2626 */
2627 ieee->state = IEEE80211_NOLINK;
2628  
2629 ieee80211_softmac_check_all_nets(ieee);
2630 -
2631 +
2632 spin_lock_irqsave(&ieee->lock, flags);
2633 -
2634 +
2635 if(ieee->state == IEEE80211_NOLINK)
2636 ieee80211_start_scan(ieee);
2637 -
2638 +
2639 spin_unlock_irqrestore(&ieee->lock, flags);
2640  
2641 exit:
2642 @@ -2062,39 +2098,39 @@
2643 struct sk_buff *ieee80211_get_beacon_(struct ieee80211_device *ieee)
2644 {
2645 u8 broadcast_addr[] = {0xff,0xff,0xff,0xff,0xff,0xff};
2646 -
2647 +
2648 struct sk_buff *skb;
2649 struct ieee80211_probe_response *b;
2650 -
2651 +
2652 skb = ieee80211_probe_resp(ieee, broadcast_addr);
2653 -
2654 - if (!skb)
2655 +
2656 + if (!skb)
2657 return NULL;
2658 -
2659 +
2660 b = (struct ieee80211_probe_response *) skb->data;
2661 b->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_BEACON);
2662 -
2663 +
2664 return skb;
2665 -
2666 +
2667 }
2668  
2669 struct sk_buff *ieee80211_get_beacon(struct ieee80211_device *ieee)
2670 {
2671 struct sk_buff *skb;
2672 struct ieee80211_probe_response *b;
2673 -
2674 +
2675 skb = ieee80211_get_beacon_(ieee);
2676 - if(!skb)
2677 + if(!skb)
2678 return NULL;
2679 -
2680 - b = (struct ieee80211_probe_response *) skb->data;
2681 +
2682 + b = (struct ieee80211_probe_response *) skb->data;
2683 b->header.seq_ctrl = cpu_to_le16(ieee->seq_ctrl << 4);
2684 -
2685 +
2686 if (ieee->seq_ctrl == 0xFFF)
2687 ieee->seq_ctrl = 0;
2688 else
2689 ieee->seq_ctrl++;
2690 -
2691 +
2692 return skb;
2693 }
2694  
2695 @@ -2111,14 +2147,14 @@
2696 {
2697 if (!ieee->proto_started)
2698 return;
2699 -
2700 +
2701 ieee->proto_started = 0;
2702 -
2703 +
2704 ieee80211_stop_send_beacons(ieee);
2705 -
2706 +
2707 del_timer_sync(&ieee->associate_timer);
2708 - cancel_delayed_work(&ieee->associate_retry_wq);
2709 -
2710 + cancel_delayed_work(&ieee->associate_retry_wq);
2711 +
2712 ieee80211_stop_scan(ieee);
2713  
2714 ieee80211_disassociate(ieee);
2715 @@ -2135,28 +2171,28 @@
2716 void ieee80211_start_protocol(struct ieee80211_device *ieee)
2717 {
2718 short ch = 0;
2719 -
2720 +
2721 if (ieee->proto_started)
2722 return;
2723 -
2724 +
2725 ieee->proto_started = 1;
2726 -
2727 +
2728 if (ieee->current_network.channel == 0){
2729 do{
2730 ch++;
2731 - if (ch > MAX_CHANNEL_NUMBER)
2732 + if (ch > MAX_CHANNEL_NUMBER)
2733 return; /* no channel found */
2734 -
2735 +
2736 }while(!ieee->channel_map[ch]);
2737 -
2738 +
2739 ieee->current_network.channel = ch;
2740 }
2741 -
2742 +
2743 if (ieee->current_network.beacon_interval == 0)
2744 ieee->current_network.beacon_interval = 100;
2745 -
2746 +
2747 ieee->set_chan(ieee->dev,ieee->current_network.channel);
2748 -
2749 +
2750 ieee->last_seq_num = -1;
2751 ieee->last_frag_num = -1;
2752 ieee->last_packet_time = 0;
2753 @@ -2167,18 +2203,18 @@
2754 * attempts does not fail just because the user provide the essid
2755 * and the nic is still checking for the AP MAC ??
2756 */
2757 -
2758 +
2759 if (ieee->iw_mode == IW_MODE_INFRA)
2760 ieee80211_start_bss(ieee);
2761 -
2762 +
2763 else if (ieee->iw_mode == IW_MODE_ADHOC)
2764 ieee80211_start_ibss(ieee);
2765 -
2766 +
2767 else if (ieee->iw_mode == IW_MODE_MASTER)
2768 ieee80211_start_master_bss(ieee);
2769 -
2770 +
2771 else if(ieee->iw_mode == IW_MODE_MONITOR)
2772 - ieee80211_start_monitor_mode(ieee);
2773 + ieee80211_start_monitor_mode(ieee);
2774 }
2775  
2776  
2777 @@ -2186,11 +2222,11 @@
2778 void ieee80211_softmac_init(struct ieee80211_device *ieee)
2779 {
2780 memset(&ieee->current_network, 0, sizeof(struct ieee80211_network));
2781 -
2782 +
2783 ieee->state = IEEE80211_NOLINK;
2784 ieee->sync_scan_hurryup = 0;
2785 ieee->seq_ctrl = 0;
2786 -
2787 +
2788 ieee->assoc_id = 0;
2789 ieee->queue_stop = 0;
2790 ieee->scanning = 0;
2791 @@ -2203,7 +2239,7 @@
2792 ieee->ps = IEEE80211_PS_DISABLED;
2793 ieee->sta_sleep = 0;
2794  
2795 -
2796 +
2797 init_mgmt_queue(ieee);
2798 #if 0
2799 init_timer(&ieee->scan_timer);
2800 @@ -2211,7 +2247,7 @@
2801 ieee->scan_timer.function = ieee80211_softmac_scan_cb;
2802 #endif
2803 ieee->tx_pending.txb = NULL;
2804 -
2805 +
2806 init_timer(&ieee->associate_timer);
2807 ieee->associate_timer.data = (unsigned long)ieee;
2808 ieee->associate_timer.function = ieee80211_associate_abort_cb;
2809 @@ -2219,28 +2255,37 @@
2810 init_timer(&ieee->beacon_timer);
2811 ieee->beacon_timer.data = (unsigned long) ieee;
2812 ieee->beacon_timer.function = ieee80211_send_beacon_cb;
2813 -
2814 +
2815 #ifdef PF_SYNCTHREAD
2816 ieee->wq = create_workqueue(DRV_NAME,0);
2817 -#else
2818 +#else
2819 ieee->wq = create_workqueue(DRV_NAME);
2820 #endif
2821 -
2822 +
2823 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
2824 INIT_WORK(&ieee->start_ibss_wq,(void(*)(void*)) ieee80211_start_ibss_wq,ieee);
2825 INIT_WORK(&ieee->associate_retry_wq,(void(*)(void*)) ieee80211_associate_retry_wq,ieee);
2826 INIT_WORK(&ieee->associate_complete_wq,(void(*)(void*)) ieee80211_associate_complete_wq,ieee);
2827 INIT_WORK(&ieee->associate_procedure_wq,(void(*)(void*)) ieee80211_associate_procedure_wq,ieee);
2828 INIT_WORK(&ieee->softmac_scan_wq,(void(*)(void*)) ieee80211_softmac_scan_wq,ieee);
2829 INIT_WORK(&ieee->wx_sync_scan_wq,(void(*)(void*)) ieee80211_wx_sync_scan_wq,ieee);
2830 +#else
2831 + INIT_WORK(&ieee->start_ibss_wq, ieee80211_start_ibss_wq);
2832 + INIT_DELAYED_WORK(&ieee->associate_retry_wq, ieee80211_associate_retry_wq);
2833 + INIT_WORK(&ieee->associate_complete_wq, ieee80211_associate_complete_wq);
2834 + INIT_WORK(&ieee->associate_procedure_wq, ieee80211_associate_procedure_wq);
2835 + INIT_DELAYED_WORK(&ieee->softmac_scan_wq, ieee80211_softmac_scan_wq);
2836 + INIT_WORK(&ieee->wx_sync_scan_wq, ieee80211_wx_sync_scan_wq);
2837 +#endif
2838 /// INIT_WORK(&ieee->ps_request_tx_ack_wq,(void(*)(void*))ieee->ps_request_tx_ack,ieee->dev);//for ps 07.26
2839 -
2840 +
2841  
2842 sema_init(&ieee->wx_sem, 1);
2843 sema_init(&ieee->scan_sem, 1);
2844 -
2845 +
2846 spin_lock_init(&ieee->mgmt_tx_lock);
2847 spin_lock_init(&ieee->beacon_lock);
2848 -
2849 +
2850 tasklet_init(&ieee->ps_task,
2851 (void(*)(unsigned long)) ieee80211_sta_ps,
2852 (unsigned long)ieee);
2853 @@ -2250,20 +2295,20 @@
2854 void ieee80211_softmac_free(struct ieee80211_device *ieee)
2855 {
2856 down(&ieee->wx_sem);
2857 -
2858 +
2859 del_timer_sync(&ieee->associate_timer);
2860 cancel_delayed_work(&ieee->associate_retry_wq);
2861 destroy_workqueue(ieee->wq);
2862 -
2863 +
2864 up(&ieee->wx_sem);
2865 }
2866  
2867 -/********************************************************
2868 +/********************************************************
2869 * Start of WPA code. *
2870 * this is stolen from the ipw2200 driver *
2871 ********************************************************/
2872  
2873 -
2874 +
2875 static int ieee80211_wpa_enable(struct ieee80211_device *ieee, int value)
2876 {
2877 /* This is called when wpa_supplicant loads and closes the driver
2878 @@ -2273,7 +2318,7 @@
2879 return 0;
2880 }
2881  
2882 -
2883 +
2884 void ieee80211_wpa_assoc_frame(struct ieee80211_device *ieee, char *wpa_ie, int wpa_ie_len)
2885 {
2886 /* make sure WPA is enabled */
2887 @@ -2285,7 +2330,7 @@
2888  
2889 static int ieee80211_wpa_mlme(struct ieee80211_device *ieee, int command, int reason)
2890 {
2891 -
2892 +
2893 int ret = 0;
2894  
2895 switch (command) {
2896 @@ -2339,7 +2384,7 @@
2897  
2898 static int ieee80211_wpa_set_auth_algs(struct ieee80211_device *ieee, int value)
2899 {
2900 -
2901 +
2902 struct ieee80211_security sec = {
2903 .flags = SEC_AUTH_MODE,
2904 };
2905 @@ -2435,7 +2480,7 @@
2906 struct ieee_param *param, int param_len)
2907 {
2908 int ret = 0;
2909 -
2910 +
2911 struct ieee80211_crypto_ops *ops;
2912 struct ieee80211_crypt_data **crypt;
2913  
2914 @@ -2600,7 +2645,7 @@
2915 ret = -EINVAL;
2916 goto out;
2917 }
2918 -
2919 +
2920 param = (struct ieee_param *)kmalloc(p->length, GFP_KERNEL);
2921 if (param == NULL){
2922 ret = -ENOMEM;
2923 @@ -2644,7 +2689,7 @@
2924 kfree(param);
2925 out:
2926 up(&ieee->wx_sem);
2927 -
2928 +
2929 return ret;
2930 }
2931  
2932 diff -Naur r8187_orig/ieee80211/ieee80211_softmac_wx.c r8187_rawtx/ieee80211/ieee80211_softmac_wx.c
2933 --- r8187_orig/ieee80211/ieee80211_softmac_wx.c 2007-01-15 03:00:37.000000000 +0100
2934 +++ r8187_rawtx/ieee80211/ieee80211_softmac_wx.c 2007-05-16 22:00:07.000000000 +0200
2935 @@ -236,7 +236,7 @@
2936 int ieee80211_wx_set_mode(struct ieee80211_device *ieee, struct iw_request_info *a,
2937 union iwreq_data *wrqu, char *b)
2938 {
2939 -
2940 + short prev = ieee->raw_tx;
2941 ieee->sync_scan_hurryup = 1;
2942  
2943 down(&ieee->wx_sem);
2944 @@ -246,7 +246,7 @@
2945  
2946 if (wrqu->mode == IW_MODE_MONITOR){
2947  
2948 - ieee->dev->type = ARPHRD_IEEE80211;
2949 + ieee->dev->type = ARPHRD_IEEE80211_PRISM;
2950 }else{
2951 ieee->dev->type = ARPHRD_ETHER;
2952 }
2953 @@ -259,13 +259,37 @@
2954 ieee80211_start_protocol(ieee);
2955 }
2956  
2957 + if(ieee->iw_mode == IW_MODE_MONITOR)
2958 + {
2959 + ieee->raw_tx = 1;
2960 + if(prev == 0 && ieee->raw_tx){
2961 + if (ieee->data_hard_resume)
2962 + ieee->data_hard_resume(ieee->dev);
2963 +
2964 + netif_carrier_on(ieee->dev);
2965 + }
2966 +
2967 + netif_carrier_on(ieee->dev);
2968 + }
2969 + else
2970 + {
2971 + ieee->raw_tx = 0;
2972 + }
2973 +
2974 +
2975 out:
2976 up(&ieee->wx_sem);
2977 return 0;
2978 }
2979  
2980 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
2981 +void ieee80211_wx_sync_scan_wq(struct work_struct *work)
2982 +{
2983 + struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, wx_sync_scan_wq);
2984 +#else
2985 void ieee80211_wx_sync_scan_wq(struct ieee80211_device *ieee)
2986 {
2987 +#endif
2988 short chan;
2989  
2990 chan = ieee->current_network.channel;
2991 @@ -356,7 +380,11 @@
2992 spin_lock_irqsave(&ieee->lock, flags);
2993  
2994 if (wrqu->essid.flags && wrqu->essid.length) {
2995 +#if WIRELESS_EXT > 20
2996 + len = min((int)wrqu->essid.length, IW_ESSID_MAX_SIZE);
2997 +#else
2998 len = ((wrqu->essid.length-1) < IW_ESSID_MAX_SIZE) ? (wrqu->essid.length-1) : IW_ESSID_MAX_SIZE;
2999 +#endif
3000  
3001 strncpy(ieee->current_network.ssid, extra, len);
3002 ieee->current_network.ssid_len = len;
3003 diff -Naur r8187_orig/ieee80211/ieee80211_tx.c r8187_rawtx/ieee80211/ieee80211_tx.c
3004 --- r8187_orig/ieee80211/ieee80211_tx.c 2007-12-05 09:53:21.000000000 +0100
3005 +++ r8187_rawtx/ieee80211/ieee80211_tx.c 2007-05-16 22:00:07.000000000 +0200
3006 @@ -32,7 +32,6 @@
3007 ******************************************************************************/
3008  
3009 #include <linux/compiler.h>
3010 -#include <linux/config.h>
3011 #include <linux/errno.h>
3012 #include <linux/if_arp.h>
3013 #include <linux/in6.h>
3014 @@ -52,6 +51,12 @@
3015 #include <linux/etherdevice.h>
3016 #include <asm/uaccess.h>
3017  
3018 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
3019 +#include <linux/config.h>
3020 +#else
3021 +#include <linux/autoconf.h>
3022 +#endif
3023 +
3024 #include "ieee80211.h"
3025  
3026  
3027 @@ -481,19 +486,19 @@
3028 ieee->seq_ctrl++;
3029 //---
3030 }else{
3031 - if (unlikely(skb->len < sizeof(struct ieee80211_hdr_3addr))) {
3032 + if (unlikely(skb->len < 14)) {
3033 printk(KERN_WARNING "%s: skb too small (%d).\n",
3034 ieee->dev->name, skb->len);
3035 goto success;
3036 }
3037 -
3038 +
3039 txb = ieee80211_alloc_txb(1, skb->len, GFP_ATOMIC);
3040 if(!txb){
3041 printk(KERN_WARNING "%s: Could not allocate TXB\n",
3042 ieee->dev->name);
3043 goto failed;
3044 }
3045 -
3046 + txb->nr_frags = 1;
3047 txb->encrypted = 0;
3048 txb->payload_size = skb->len;
3049 memcpy(skb_put(txb->fragments[0],skb->len), skb->data, skb->len);
3050 diff -Naur r8187_orig/Makefile r8187_rawtx/Makefile
3051 --- r8187_orig/Makefile 1970-01-01 01:00:00.000000000 +0100
3052 +++ r8187_rawtx/Makefile 2007-05-13 09:54:38.000000000 +0200
3053 @@ -0,0 +1,36 @@
3054 +prefix = /lib/modules/$(shell uname -r)/kernel/drivers/net/wireless
3055 +r8187dir = $(prefix)/rtl8187
3056 +ieeedir = $(prefix)/rtl_ieee80211
3057 +
3058 +default: all
3059 +
3060 +all:
3061 + $(MAKE) -C ieee80211 $(@)
3062 + -chmod +x symvers
3063 + -./symvers
3064 + $(MAKE) -C rtl8187 $(@)
3065 +
3066 +install:
3067 + install -d $(ieeedir)
3068 + install -d $(r8187dir)
3069 + install -m 644 ./ieee80211/*.ko $(ieeedir)
3070 + install -m 644 ./rtl8187/*.ko $(r8187dir)
3071 + -depmod -ae
3072 +
3073 +uninstall:
3074 + -rm -f $(ieeedir)/ieee80211-rtl.ko
3075 + -rm -f $(ieeedir)/ieee80211_crypt-rtl.ko
3076 + -rm -f $(ieeedir)/ieee80211_crypt_ccmp-rtl.ko
3077 + -rm -f $(ieeedir)/ieee80211_crypt_tkip-rtl.ko
3078 + -rm -f $(ieeedir)/ieee80211_crypt_wep-rtl.ko
3079 + -rm -f $(r8187dir)/r8187.ko
3080 + -rm -fr $(ieeedir)
3081 + -rm -fr $(r8187dir)
3082 + -depmod -ae
3083 +
3084 +clean:
3085 + $(MAKE) -C ieee80211 $(@)
3086 + $(MAKE) -C rtl8187 $(@)
3087 +
3088 +distclean: clean
3089 +
3090 diff -Naur r8187_orig/rtl8187/ieee80211.h r8187_rawtx/rtl8187/ieee80211.h
3091 --- r8187_orig/rtl8187/ieee80211.h 2007-12-05 09:50:41.000000000 +0100
3092 +++ r8187_rawtx/rtl8187/ieee80211.h 2007-05-16 21:51:38.000000000 +0200
3093 @@ -108,6 +108,8 @@
3094 #define ieee80211_start_protocol ieee80211_start_protocol_rtl
3095 #define ieee80211_stop_protocol ieee80211_stop_protocol_rtl
3096 #define ieee80211_rx_mgt ieee80211_rx_mgt_rtl
3097 +#define ieee80211_stop_queue ieee80211_stop_queue_rtl
3098 +#define ieee80211_wake_queue ieee80211_wake_queue_rtl
3099  
3100  
3101 typedef struct ieee_param {
3102 @@ -193,6 +195,22 @@
3103 struct list_head list;
3104 };
3105  
3106 +#define LWNG_CAP_DID_BASE (4 | (1 << 6)) /* section 4, group 1 */
3107 +/* ARPHRD_IEEE80211_PRISM uses a bloated version of Prism2 RX frame header
3108 + * (from linux-wlan-ng) */
3109 +struct linux_wlan_ng_val {
3110 + u32 did;
3111 + u16 status, len;
3112 + u32 data;
3113 +} __attribute__ ((packed));
3114 +
3115 +struct linux_wlan_ng_prism_hdr {
3116 + u32 msgcode, msglen;
3117 + char devname[16];
3118 + struct linux_wlan_ng_val hosttime, mactime, channel, rssi, sq, signal,
3119 + noise, rate, istx, frmlen;
3120 +} __attribute__ ((packed));
3121 +
3122 struct ieee80211_hdr {
3123 u16 frame_ctl;
3124 u16 duration_id;
3125 @@ -1064,10 +1082,15 @@
3126 struct timer_list beacon_timer;
3127  
3128 struct work_struct associate_complete_wq;
3129 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
3130 + struct delayed_work associate_retry_wq;
3131 + struct delayed_work softmac_scan_wq;
3132 +#else
3133 struct work_struct associate_retry_wq;
3134 + struct work_struct softmac_scan_wq;
3135 +#endif
3136 struct work_struct start_ibss_wq;
3137 struct work_struct associate_procedure_wq;
3138 - struct work_struct softmac_scan_wq;
3139 struct work_struct wx_sync_scan_wq;
3140 struct work_struct ps_request_tx_ack_wq;//for ps
3141 struct work_struct hw_wakeup_wq;
3142 @@ -1390,7 +1413,11 @@
3143 extern int ieee80211_wx_get_freq(struct ieee80211_device *ieee, struct iw_request_info *a,
3144 union iwreq_data *wrqu, char *b);
3145  
3146 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
3147 +extern void ieee80211_wx_sync_scan_wq(struct work_struct *work);
3148 +#else
3149 extern void ieee80211_wx_sync_scan_wq(struct ieee80211_device *ieee);
3150 +#endif
3151  
3152 extern int ieee80211_wx_set_rawtx(struct ieee80211_device *ieee,
3153 struct iw_request_info *info,
3154 diff -Naur r8187_orig/rtl8187/r8180_hw.h r8187_rawtx/rtl8187/r8180_hw.h
3155 --- r8187_orig/rtl8187/r8180_hw.h 2007-12-03 12:30:10.000000000 +0100
3156 +++ r8187_rawtx/rtl8187/r8180_hw.h 2007-05-16 21:51:38.000000000 +0200
3157 @@ -1,16 +1,16 @@
3158 -/*
3159 +/*
3160 This is part of rtl8187 OpenSource driver.
3161 - Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
3162 + Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
3163 Released under the terms of GPL (General Public Licence)
3164 -
3165 - Parts of this driver are based on the GPL part of the
3166 +
3167 + Parts of this driver are based on the GPL part of the
3168 official Realtek driver.
3169 - Parts of this driver are based on the rtl8180 driver skeleton
3170 + Parts of this driver are based on the rtl8180 driver skeleton
3171 from Patric Schenke & Andres Salomon.
3172 - Parts of this driver are based on the Intel Pro Wireless
3173 + Parts of this driver are based on the Intel Pro Wireless
3174 2100 GPL driver.
3175 -
3176 - We want to tanks the Authors of those projects
3177 +
3178 + We want to tanks the Authors of those projects
3179 and the Ndiswrapper project Authors.
3180 */
3181  
3182 @@ -20,7 +20,7 @@
3183 #ifndef R8180_HW
3184 #define R8180_HW
3185  
3186 -#define MAX_SLEEP_TIME (10000000)
3187 +#define MAX_SLEEP_TIME (10000000)
3188 #define MIN_SLEEP_TIME (50000)
3189  
3190 #define RTL8187_RF_INDEX 0x8225
3191 @@ -80,7 +80,7 @@
3192 #define EPROM_CMD_OPERATING_MODE_SHIFT 6
3193 #define EPROM_CMD_OPERATING_MODE_MASK ((1<<7)|(1<<6))
3194 #define EPROM_CMD_CONFIG 0x3
3195 -#define EPROM_CMD_NORMAL 0
3196 +#define EPROM_CMD_NORMAL 0
3197 #define EPROM_CMD_LOAD 1
3198 #define EPROM_CMD_PROGRAM 2
3199 #define EPROM_CS_SHIFT 3
3200 @@ -193,8 +193,8 @@
3201  
3202  
3203  
3204 -/*
3205 - * Operational registers offsets in PCI (I/O) space.
3206 +/*
3207 + * Operational registers offsets in PCI (I/O) space.
3208 * RealTek names are used.
3209 */
3210  
3211 @@ -310,7 +310,7 @@
3212 /* following are for rtl8185 */
3213 #define RFPinsOutput 0x80
3214 #define RFPinsEnable 0x82
3215 -#define RF_TIMING 0x8c
3216 +#define RF_TIMING 0x8c
3217 #define RFPinsSelect 0x84
3218 #define ANAPARAM2 0x60
3219 #define RF_PARA 0x88
3220 @@ -339,7 +339,7 @@
3221 #define MIN_RESP_RATE_SHIFT 0
3222 #define RATE_FALLBACK 0xbe
3223 /*
3224 - * 0x0084 - 0x00D3 is selected to page 1 when PSEn bit (bit0, PSR)
3225 + * 0x0084 - 0x00D3 is selected to page 1 when PSEn bit (bit0, PSR)
3226 * is set to 1
3227 */
3228  
3229 @@ -380,7 +380,7 @@
3230  
3231  
3232 /*
3233 - * 0x0084 - 0x00D3 is selected to page 0 when PSEn bit (bit0, PSR)
3234 + * 0x0084 - 0x00D3 is selected to page 0 when PSEn bit (bit0, PSR)
3235 * is set to 0
3236 */
3237  
3238 @@ -437,7 +437,7 @@
3239  
3240  
3241 /*
3242 - * Bitmasks for specific register functions.
3243 + * Bitmasks for specific register functions.
3244 * Names are derived from the register name and function name.
3245 *
3246 * <REGISTER>_<FUNCTION>[<bit>]
3247 @@ -501,7 +501,7 @@
3248 #define TCR_HWVERID_SHIFT 25
3249 #define TCR_SWPLCPLEN ((1<<24))
3250 #define TCR_PLCP_LEN TCR_SAT // rtl8180
3251 -#define TCR_MXDMA_MASK ((1<<23)|(1<<22)|(1<<21))
3252 +#define TCR_MXDMA_MASK ((1<<23)|(1<<22)|(1<<21))
3253 #define TCR_MXDMA_1024 6
3254 #define TCR_MXDMA_2048 7
3255 #define TCR_MXDMA_SHIFT 21
3256 diff -Naur r8187_orig/rtl8187/r8180_rtl8225.h r8187_rawtx/rtl8187/r8180_rtl8225.h
3257 --- r8187_orig/rtl8187/r8180_rtl8225.h 2007-01-15 03:00:37.000000000 +0100
3258 +++ r8187_rawtx/rtl8187/r8180_rtl8225.h 2007-05-16 21:51:38.000000000 +0200
3259 @@ -48,4 +48,5 @@
3260  
3261 extern u32 rtl8225_chan[];
3262  
3263 +void rtl8225z2_SetTXPowerLevel(struct net_device *dev, short ch);
3264 #endif
3265 diff -Naur r8187_orig/rtl8187/r8180_wx.c r8187_rawtx/rtl8187/r8180_wx.c
3266 --- r8187_orig/rtl8187/r8180_wx.c 2007-03-02 04:22:29.000000000 +0100
3267 +++ r8187_rawtx/rtl8187/r8180_wx.c 2007-05-16 21:51:33.000000000 +0200
3268 @@ -21,7 +21,7 @@
3269  
3270 #include "r8187.h"
3271 #include "r8180_hw.h"
3272 -
3273 +#include "r8180_rtl8225.h"
3274  
3275 //#define RATE_COUNT 4
3276 u32 rtl8180_rates[] = {1000000,2000000,5500000,11000000,
3277 @@ -121,22 +121,72 @@
3278 return ret;
3279 }
3280  
3281 -static int r8180_wx_set_rawtx(struct net_device *dev,
3282 - struct iw_request_info *info,
3283 - union iwreq_data *wrqu, char *extra)
3284 +static int r8180_wx_get_txpow(struct net_device *dev,
3285 + struct iw_request_info *info,
3286 + union iwreq_data *wrqu, char *extra)
3287 {
3288 struct r8180_priv *priv = ieee80211_priv(dev);
3289 - int ret;
3290 -
3291 + int i=0;
3292 down(&priv->wx_sem);
3293 -
3294 - ret = ieee80211_wx_set_rawtx(priv->ieee80211, info, wrqu, extra);
3295 -
3296 + wrqu->power.value = 0;
3297 + for(i=0; i<15; i++)
3298 + {
3299 + if(priv->chtxpwr[i] > wrqu->power.value) wrqu->power.value = priv->chtxpwr[i];
3300 + if(priv->chtxpwr_ofdm[i] > wrqu->power.value) wrqu->power.value = priv->chtxpwr_ofdm[i];
3301 + }
3302 + wrqu->power.fixed = 1;
3303 + wrqu->power.flags = IW_TXPOW_DBM;
3304 + wrqu->power.disabled = 0;
3305 up(&priv->wx_sem);
3306 -
3307 +
3308 + return 0;
3309 +}
3310 +
3311 +#if 1
3312 +static int r8180_wx_set_txpow(struct net_device *dev,
3313 + struct iw_request_info *info,
3314 + union iwreq_data *wrqu, char *extra)
3315 +{
3316 + int ret = 0, i=0;
3317 + struct r8180_priv *priv = ieee80211_priv(dev);
3318 +
3319 + down(&priv->wx_sem);
3320 +
3321 + if (wrqu->power.flags != IW_TXPOW_DBM)
3322 + {
3323 + ret = -EINVAL;
3324 + goto out;
3325 + }
3326 +
3327 + if(wrqu->power.value > priv->txpwr_max)
3328 + {
3329 + ret = -EINVAL;
3330 + goto out;
3331 + }
3332 +
3333 + if(wrqu->power.value < 0)
3334 + {
3335 + ret = -EINVAL;
3336 + goto out;
3337 + }
3338 +
3339 + for(i=1;i<15;i++)
3340 + {
3341 + priv->chtxpwr[i] = priv->chtxpwr_orig[i] - (priv->txpwr_max - wrqu->power.value);
3342 + if(priv->chtxpwr[i] > priv->chtxpwr_orig[i]) priv->chtxpwr[i] = 0;
3343 +
3344 + priv->chtxpwr_ofdm[i] = priv->chtxpwr_ofdm_orig[i] - (priv->txpwr_max - wrqu->power.value);
3345 + if(priv->chtxpwr_ofdm[i] > priv->chtxpwr_ofdm_orig[i]) priv->chtxpwr_ofdm[i] = 0;
3346 + }
3347 + rtl8225z2_SetTXPowerLevel(dev, 1);
3348 +
3349 + out:
3350 + up(&priv->wx_sem);
3351 +
3352 return ret;
3353  
3354 }
3355 +#endif
3356  
3357 static int r8180_wx_set_rts(struct net_device *dev,
3358 struct iw_request_info *info,
3359 @@ -836,6 +886,7 @@
3360  
3361 }
3362  
3363 +#if 0
3364 static int r8180_wx_radio_on(struct net_device *dev,
3365 struct iw_request_info *info,
3366 union iwreq_data *wrqu, char *extra)
3367 @@ -871,6 +922,7 @@
3368 return 0;
3369  
3370 }
3371 +#endif
3372  
3373 static int r8180_wx_set_channelplan(struct net_device *dev,
3374 struct iw_request_info *info,
3375 @@ -965,8 +1017,8 @@
3376 r8180_wx_get_rts, /* SIOCGIWRTS */
3377 r8180_wx_set_frag, /* SIOCSIWFRAG */
3378 r8180_wx_get_frag, /* SIOCGIWFRAG */
3379 - dummy, /* SIOCSIWTXPOW */
3380 - dummy, /* SIOCGIWTXPOW */
3381 + r8180_wx_set_txpow, /* SIOCSIWTXPOW */
3382 + r8180_wx_get_txpow, /* SIOCGIWTXPOW */
3383 r8180_wx_set_retry, /* SIOCSIWRETRY */
3384 r8180_wx_get_retry, /* SIOCGIWRETRY */
3385 r8180_wx_set_enc, /* SIOCSIWENCODE */
3386 @@ -1007,7 +1059,7 @@
3387 },
3388 {
3389 SIOCIWFIRSTPRIV + 0x6,
3390 - IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "rawtx"
3391 + 0, 0, "dummy"
3392 },
3393 { SIOCIWFIRSTPRIV + 0x7,
3394 0, 0, "dummy"
3395 @@ -1053,11 +1105,11 @@
3396 },
3397 {
3398 SIOCIWFIRSTPRIV + 0x12,
3399 - 0, 0, "radioon"
3400 + 0, 0, "dummy"
3401 },
3402 {
3403 SIOCIWFIRSTPRIV + 0x13,
3404 - 0, 0, "radiooff"
3405 + 0, 0, "dummy"
3406 },
3407 {
3408 SIOCIWFIRSTPRIV + 0x14,
3409 @@ -1089,7 +1141,7 @@
3410 dummy,
3411 r8180_wx_set_scan_type,
3412 dummy,
3413 - r8180_wx_set_rawtx,
3414 + dummy,
3415 dummy,
3416 r8180_wx_set_iwmode,
3417 r8180_wx_get_iwmode,
3418 @@ -1101,8 +1153,8 @@
3419 r8180_wx_get_sigqual,
3420 r8180_wx_reset_stats,
3421 dummy,
3422 - r8180_wx_radio_on,
3423 - r8180_wx_radio_off,
3424 + dummy,
3425 + dummy,
3426 r8180_wx_set_channelplan,
3427 r8180_wx_get_channelplan,
3428 dummy,
3429 diff -Naur r8187_orig/rtl8187/r8187_core.c r8187_rawtx/rtl8187/r8187_core.c
3430 --- r8187_orig/rtl8187/r8187_core.c 2007-03-28 08:39:13.000000000 +0200
3431 +++ r8187_rawtx/rtl8187/r8187_core.c 2007-05-16 21:51:33.000000000 +0200
3432 @@ -1,27 +1,27 @@
3433 /*
3434 This is part of rtl8187 OpenSource driver - v 0.1
3435 - Copyright (C) Andrea Merello 2005 <andreamrl@tiscali.it>
3436 + Copyright (C) Andrea Merello 2005 <andreamrl@tiscali.it>
3437 Released under the terms of GPL (General Public License)
3438 -
3439 -
3440 - Parts of this driver are based on the rtl8180 driver skeleton
3441 +
3442 +
3443 + Parts of this driver are based on the rtl8180 driver skeleton
3444 from Patric Schenke & Andres Salomon.
3445  
3446 Parts of this driver are based on the Intel Pro Wireless 2*00 GPL drivers.
3447 -
3448 +
3449 some ideas might be derived from David Young rtl8180 netbsd driver.
3450 -
3451 +
3452 Parts of the usb code are from the r8150.c driver in linux kernel
3453 -
3454 +
3455 Some ideas borrowed from the 8139too.c driver included in linux kernel.
3456 -
3457 - We (I?) want to thanks the Authors of those projecs and also the
3458 +
3459 + We (I?) want to thanks the Authors of those projecs and also the
3460 Ndiswrapper's project Authors.
3461 -
3462 - A special big thanks goes also to Realtek corp. for their help in my
3463 - attempt to add RTL8187 and RTL8225 support, and to David Young also.
3464  
3465 - - Please note that this file is a modified version from rtl8180-sa2400
3466 + A special big thanks goes also to Realtek corp. for their help in my
3467 + attempt to add RTL8187 and RTL8225 support, and to David Young also.
3468 +
3469 + - Please note that this file is a modified version from rtl8180-sa2400
3470 drv. So some other people have contributed to this project, and they are
3471 thanked in the rtl8180-sa2400 CHANGELOG.
3472 */
3473 @@ -83,6 +83,10 @@
3474 #define USB_VENDOR_ID_NETGEAR 0x0846
3475 #endif
3476  
3477 +#if !(defined(CONFIG_USB_EHCI_HCD) || defined (CONFIG_USB_EHCI_HCD_MODULE))
3478 + #error Build your kernel with ehci_hcd support!
3479 +#endif
3480 +
3481 static struct usb_device_id rtl8187_usb_id_tbl[] = {
3482 {USB_DEVICE(USB_VENDOR_ID_REALTEK, 0x8187)},
3483 {USB_DEVICE(USB_VENDOR_ID_NETGEAR, 0x6100)},
3484 @@ -137,7 +141,7 @@
3485  
3486 static int __devinit rtl8187_usb_probe(struct usb_interface *intf,
3487 const struct usb_device_id *id);
3488 -
3489 +
3490 static void __devexit rtl8187_usb_disconnect(struct usb_interface *intf);
3491  
3492 static struct usb_driver rtl8187_usb_driver = {
3493 @@ -161,10 +165,10 @@
3494  
3495 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
3496 {
3497 -
3498 +
3499 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3500 struct usb_device *udev = priv->udev;
3501 -
3502 +
3503 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3504 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
3505 indx|0xfe00, 0, &data, 1, HZ / 2);
3506 @@ -173,10 +177,10 @@
3507  
3508 void write_nic_byte(struct net_device *dev, int indx, u8 data)
3509 {
3510 -
3511 +
3512 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3513 struct usb_device *udev = priv->udev;
3514 -
3515 +
3516 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3517 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
3518 indx|0xff00, 0, &data, 1, HZ / 2);
3519 @@ -185,10 +189,10 @@
3520  
3521 void write_nic_word(struct net_device *dev, int indx, u16 data)
3522 {
3523 -
3524 +
3525 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3526 struct usb_device *udev = priv->udev;
3527 -
3528 +
3529 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3530 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
3531 indx|0xff00, 0, &data, 2, HZ / 2);
3532 @@ -197,23 +201,23 @@
3533  
3534 void write_nic_dword(struct net_device *dev, int indx, u32 data)
3535 {
3536 -
3537 +
3538 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3539 struct usb_device *udev = priv->udev;
3540 -
3541 +
3542 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
3543 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
3544 indx|0xff00, 0, &data, 4, HZ / 2);
3545 }
3546 -
3547 -
3548 -
3549 +
3550 +
3551 +
3552 u8 read_nic_byte(struct net_device *dev, int indx)
3553 {
3554 u8 data;
3555 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3556 struct usb_device *udev = priv->udev;
3557 -
3558 +
3559 usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
3560 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
3561 indx|0xff00, 0, &data, 1, HZ / 2);
3562 @@ -225,20 +229,20 @@
3563 u8 data;
3564 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3565 struct usb_device *udev = priv->udev;
3566 -
3567 +
3568 usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
3569 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
3570 indx|0xfe00, 0, &data, 1, HZ / 2);
3571 return data;
3572 }
3573  
3574 -
3575 +
3576 u16 read_nic_word(struct net_device *dev, int indx)
3577 {
3578 u16 data;
3579 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3580 struct usb_device *udev = priv->udev;
3581 -
3582 +
3583 usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
3584 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
3585 indx|0xff00, 0, &data, 2, HZ / 2);
3586 @@ -251,14 +255,14 @@
3587 u32 data;
3588 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3589 struct usb_device *udev = priv->udev;
3590 -
3591 +
3592 usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
3593 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
3594 indx|0xff00, 0, &data, 4, HZ / 2);
3595 return data;
3596 }
3597  
3598 -/* this might still called in what was the PHY rtl8185/rtl8187 common code
3599 +/* this might still called in what was the PHY rtl8185/rtl8187 common code
3600 * plans are to possibilty turn it again in one common code...
3601 */
3602 inline void force_pci_posting(struct net_device *dev)
3603 @@ -271,8 +275,17 @@
3604 //void set_nic_txring(struct net_device *dev);
3605 static struct net_device_stats *rtl8180_stats(struct net_device *dev);
3606 void rtl8180_commit(struct net_device *dev);
3607 -void rtl8180_restart(struct net_device *dev);
3608 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
3609 +void rtl8180_rq_tx_ack(struct work_struct *work);
3610 +#else
3611 void rtl8180_rq_tx_ack(struct net_device *dev);
3612 +#endif
3613 +
3614 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
3615 +void rtl8180_restart(struct work_struct *work);
3616 +#else
3617 +void rtl8180_restart(struct net_device *dev);
3618 +#endif
3619  
3620 /****************************************************************************
3621 -----------------------------PROCFS STUFF-------------------------
3622 @@ -286,12 +299,12 @@
3623 {
3624 struct net_device *dev = data;
3625 // struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3626 -
3627 +
3628 int len = 0;
3629 int i,n;
3630 -
3631 +
3632 int max=0xff;
3633 -
3634 +
3635 /* This dump the current register page */
3636 for(n=0;n<=max;)
3637 {
3638 @@ -308,7 +321,7 @@
3639 len += snprintf(page + len, count - len,"\n");
3640  
3641  
3642 -
3643 +
3644 *eof = 1;
3645 return len;
3646  
3647 @@ -321,15 +334,15 @@
3648 {
3649 struct net_device *dev = data;
3650 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3651 -
3652 +
3653 int len = 0;
3654 -
3655 +
3656 len += snprintf(page + len, count - len,
3657 "NIC int: %lu\n"
3658 "Total int: %lu\n",
3659 priv->stats.ints,
3660 priv->stats.shints);
3661 -
3662 +
3663 *eof = 1;
3664 return len;
3665 }
3666 @@ -341,12 +354,12 @@
3667 {
3668 struct net_device *dev = data;
3669 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3670 -
3671 +
3672 int len = 0;
3673 unsigned long totalOK;
3674 totalOK=priv->stats.txnpokint+priv->stats.txhpokint+priv->stats.txlpokint;
3675  
3676 -
3677 +
3678 len += snprintf(page + len, count - len,
3679 /* "TX normal priority ok int: %lu\n"
3680 "TX normal priority error int: %lu\n"
3681 @@ -363,7 +376,7 @@
3682 "TX HW queue: %d\n"
3683 "TX lp dropped: %lu\n"
3684 "TX np dropped: %lu\n"
3685 - "TX total data packets %lu\n",
3686 + "TX total data packets %lu\n",
3687 // "TX beacon aborted: %lu\n",
3688 priv->stats.txnpokint,
3689 priv->stats.txnperr,
3690 @@ -391,13 +404,13 @@
3691 priv->stats.txerr,
3692 priv->stats.txretry,
3693 priv->stats.txbeaconok,
3694 - priv->stats.txbeaconerr
3695 + priv->stats.txbeaconerr
3696  
3697 );
3698 -
3699 +
3700 *eof = 1;
3701 return len;
3702 -}
3703 +}
3704  
3705  
3706  
3707 @@ -407,9 +420,9 @@
3708 {
3709 struct net_device *dev = data;
3710 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3711 -
3712 +
3713 int len = 0;
3714 -
3715 +
3716 len += snprintf(page + len, count - len,
3717 /*"RX packets: %lu\n"
3718 "RX urb status error: %lu\n"
3719 @@ -431,21 +444,22 @@
3720 priv->stats.rxicverr
3721  
3722 );
3723 -
3724 +
3725 *eof = 1;
3726 return len;
3727 -}
3728 -
3729 +}
3730  
3731 +#if WIRELESS_EXT < 17
3732 static struct iw_statistics *r8180_get_wireless_stats(struct net_device *dev)
3733 {
3734 struct r8180_priv *priv = ieee80211_priv(dev);
3735  
3736 return &priv->wstats;
3737 }
3738 +#endif
3739  
3740 void rtl8180_proc_module_init(void)
3741 -{
3742 +{
3743 DMESG("Initializing proc filesystem");
3744 rtl8180_proc=create_proc_entry(RTL8187_MODULE_NAME, S_IFDIR, proc_net);
3745 }
3746 @@ -477,8 +491,8 @@
3747 {
3748 struct proc_dir_entry *e;
3749 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3750 - priv->dir_dev = create_proc_entry(dev->name,
3751 - S_IFDIR | S_IRUGO | S_IXUGO,
3752 + priv->dir_dev = create_proc_entry(dev->name,
3753 + S_IFDIR | S_IRUGO | S_IXUGO,
3754 rtl8180_proc);
3755 if (!priv->dir_dev) {
3756 DMESGE("Unable to initialize /proc/net/rtl8187/%s\n",
3757 @@ -488,7 +502,7 @@
3758 #if 0
3759 e = create_proc_read_entry("stats-hw", S_IFREG | S_IRUGO,
3760 priv->dir_dev, proc_get_stats_hw, dev);
3761 -
3762 +
3763 if (!e) {
3764 DMESGE("Unable to initialize "
3765 "/proc/net/rtl8187/%s/stats-hw\n",
3766 @@ -497,17 +511,17 @@
3767 #endif
3768 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
3769 priv->dir_dev, proc_get_stats_rx, dev);
3770 -
3771 +
3772 if (!e) {
3773 DMESGE("Unable to initialize "
3774 "/proc/net/rtl8187/%s/stats-rx\n",
3775 dev->name);
3776 }
3777 -
3778 -
3779 +
3780 +
3781 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
3782 priv->dir_dev, proc_get_stats_tx, dev);
3783 -
3784 +
3785 if (!e) {
3786 DMESGE("Unable to initialize "
3787 "/proc/net/rtl8187/%s/stats-tx\n",
3788 @@ -516,27 +530,27 @@
3789 #if 0
3790 e = create_proc_read_entry("stats-ieee", S_IFREG | S_IRUGO,
3791 priv->dir_dev, proc_get_stats_ieee, dev);
3792 -
3793 +
3794 if (!e) {
3795 DMESGE("Unable to initialize "
3796 "/proc/net/rtl8187/%s/stats-ieee\n",
3797 dev->name);
3798 }
3799 -
3800 -
3801 +
3802 +
3803 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
3804 priv->dir_dev, proc_get_stats_ap, dev);
3805 -
3806 +
3807 if (!e) {
3808 DMESGE("Unable to initialize "
3809 "/proc/net/rtl8187/%s/stats-ap\n",
3810 dev->name);
3811 }
3812 #endif
3813 -
3814 +
3815 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
3816 priv->dir_dev, proc_get_registers, dev);
3817 -
3818 +
3819 if (!e) {
3820 DMESGE("Unable to initialize "
3821 "/proc/net/rtl8187/%s/registers\n",
3822 @@ -552,14 +566,14 @@
3823 {
3824 int i;
3825 u8 *buf =(u8*)buffer;
3826 -
3827 +
3828 printk("ASCII BUFFER DUMP (len: %x):\n",len);
3829 -
3830 +
3831 for(i=0;i<len;i++)
3832 printk("%c",buf[i]);
3833 -
3834 +
3835 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
3836 -
3837 +
3838 for(i=0;i<len;i++)
3839 printk("%x",buf[i]);
3840  
3841 @@ -569,10 +583,10 @@
3842 short check_nic_enought_desc(struct net_device *dev, priority_t priority)
3843 {
3844 struct r8180_priv *priv = ieee80211_priv(dev);
3845 -
3846 - int used = atomic_read((priority == NORM_PRIORITY) ?
3847 +
3848 + int used = atomic_read((priority == NORM_PRIORITY) ?
3849 &priv->tx_np_pending : &priv->tx_lp_pending);
3850 -
3851 +
3852 return (used < MAX_TX_URB);
3853 }
3854  
3855 @@ -600,9 +614,9 @@
3856 int i;
3857 int n;
3858 int max=0xff;
3859 -
3860 - DMESG("Dumping NIC register map");
3861 -
3862 +
3863 + DMESG("Dumping NIC register map");
3864 +
3865 for(n=0;n<=max;)
3866 {
3867 printk( "\nD: %2x> ", n);
3868 @@ -619,11 +633,11 @@
3869  
3870 void rtl8180_irq_enable(struct net_device *dev)
3871 {
3872 - struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3873 + struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3874 //priv->irq_enabled = 1;
3875 /*
3876 - write_nic_word(dev,INTA_MASK,INTA_RXOK | INTA_RXDESCERR | INTA_RXOVERFLOW |\
3877 - INTA_TXOVERFLOW | INTA_HIPRIORITYDESCERR | INTA_HIPRIORITYDESCOK |\
3878 + write_nic_word(dev,INTA_MASK,INTA_RXOK | INTA_RXDESCERR | INTA_RXOVERFLOW |\
3879 + INTA_TXOVERFLOW | INTA_HIPRIORITYDESCERR | INTA_HIPRIORITYDESCOK |\
3880 INTA_NORMPRIORITYDESCERR | INTA_NORMPRIORITYDESCOK |\
3881 INTA_LOWPRIORITYDESCERR | INTA_LOWPRIORITYDESCOK | INTA_TIMEOUT);
3882 */
3883 @@ -633,7 +647,7 @@
3884  
3885 void rtl8180_irq_disable(struct net_device *dev)
3886 {
3887 -// struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3888 +// struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3889  
3890 write_nic_word(dev,INTA_MASK,0);
3891 force_pci_posting(dev);
3892 @@ -657,27 +671,27 @@
3893 {
3894 struct r8180_priv *priv = ieee80211_priv(dev);
3895 u8 msr;
3896 -
3897 +
3898 msr = read_nic_byte(dev, MSR);
3899 msr &= ~ MSR_LINK_MASK;
3900 -
3901 +
3902 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
3903 - * msr must be updated if the state is ASSOCIATING.
3904 + * msr must be updated if the state is ASSOCIATING.
3905 * this is intentional and make sense for ad-hoc and
3906 * master (see the create BSS/IBSS func)
3907 */
3908 - if (priv->ieee80211->state == IEEE80211_LINKED){
3909 -
3910 + if (priv->ieee80211->state == IEEE80211_LINKED){
3911 +
3912 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
3913 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
3914 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3915 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
3916 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
3917 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
3918 -
3919 +
3920 }else
3921 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
3922 -
3923 +
3924 write_nic_byte(dev, MSR, msr);
3925 }
3926  
3927 @@ -687,20 +701,20 @@
3928 u32 tx;
3929 priv->chan=ch;
3930 #if 0
3931 - if(priv->ieee80211->iw_mode == IW_MODE_ADHOC ||
3932 + if(priv->ieee80211->iw_mode == IW_MODE_ADHOC ||
3933 priv->ieee80211->iw_mode == IW_MODE_MASTER){
3934 -
3935 - priv->ieee80211->link_state = WLAN_LINK_ASSOCIATED;
3936 +
3937 + priv->ieee80211->link_state = WLAN_LINK_ASSOCIATED;
3938 priv->ieee80211->master_chan = ch;
3939 - rtl8180_update_beacon_ch(dev);
3940 + rtl8180_update_beacon_ch(dev);
3941 }
3942 #endif
3943 -
3944 +
3945 /* this hack should avoid frame TX during channel setting*/
3946 tx = read_nic_dword(dev,TX_CONF);
3947 tx &= ~TX_LOOPBACK_MASK;
3948  
3949 -#ifndef LOOP_TEST
3950 +#ifndef LOOP_TEST
3951 write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
3952  
3953 priv->rf_set_chan(dev,priv->chan);
3954 @@ -715,25 +729,25 @@
3955 {
3956 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3957 int err;
3958 -
3959 +
3960 // u8 *rx;
3961 -
3962 +
3963 //DMESG("starting RX");
3964 /*rx = kmalloc(RX_URB_SIZE*sizeof(u8),GFP_ATOMIC);
3965 - if(!rx){
3966 + if(!rx){
3967 DMESGE("unable to allocate RX buffer");
3968 return;
3969 }*/
3970 -
3971 +
3972 usb_fill_bulk_urb(rx_urb,priv->udev,
3973 usb_rcvbulkpipe(priv->udev,0x81), rx_urb->transfer_buffer,
3974 - RX_URB_SIZE,rtl8187_rx_isr,dev);
3975 - err = usb_submit_urb(rx_urb, GFP_ATOMIC);
3976 + RX_URB_SIZE,rtl8187_rx_isr, dev);
3977 + err = usb_submit_urb(rx_urb, GFP_ATOMIC);
3978 if(err && err != -EPERM){
3979 DMESGE("cannot submit RX command. URB_STATUS %x",rx_urb->status);
3980 -
3981 +
3982 }
3983 -
3984 +
3985 }
3986  
3987  
3988 @@ -741,30 +755,30 @@
3989 {
3990 int i;
3991 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
3992 -
3993 +
3994 if(!priv->rx_urb)
3995 DMESGE("Cannot intiate RX urb mechanism");
3996 - for(i=0;i<MAX_RX_URB;i++) // RX_MAX_URB is 1
3997 + for(i=0;i<MAX_RX_URB;i++) // RX_MAX_URB is 1
3998 rtl8187_rx_urbsubmit(dev,priv->rx_urb[i]);
3999 priv->tx_urb_index = 0;
4000 -
4001 +
4002 }
4003  
4004 void rtl8187_set_rxconf(struct net_device *dev)
4005 {
4006 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
4007 u32 rxconf;
4008 -
4009 +
4010 rxconf=read_nic_dword(dev,RX_CONF);
4011 rxconf = rxconf &~ MAC_FILTER_MASK;
4012 rxconf = rxconf | (1<<ACCEPT_MNG_FRAME_SHIFT);
4013 rxconf = rxconf | (1<<ACCEPT_DATA_FRAME_SHIFT);
4014 rxconf = rxconf | (1<<ACCEPT_BCAST_FRAME_SHIFT);
4015 rxconf = rxconf | (1<<ACCEPT_MCAST_FRAME_SHIFT);
4016 - rxconf = rxconf | (1<<ACCEPT_CTL_FRAME_SHIFT);
4017 + rxconf = rxconf | (1<<ACCEPT_CTL_FRAME_SHIFT);
4018  
4019 if (dev->flags & IFF_PROMISC) DMESG ("NIC in promisc mode");
4020 -
4021 +
4022 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
4023 dev->flags & IFF_PROMISC){
4024 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
4025 @@ -772,40 +786,40 @@
4026 rxconf = rxconf | (1<<ACCEPT_NICMAC_FRAME_SHIFT);
4027 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
4028 }
4029 -
4030 +
4031 /*if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
4032 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
4033 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
4034 }*/
4035 -
4036 +
4037 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
4038 rxconf = rxconf | (1<<ACCEPT_ICVERR_FRAME_SHIFT);
4039 rxconf = rxconf | (1<<ACCEPT_PWR_FRAME_SHIFT);
4040 }
4041 -
4042 +
4043 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
4044 rxconf = rxconf | (1<<ACCEPT_CRCERR_FRAME_SHIFT);
4045 -
4046 -
4047 +
4048 +
4049 rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
4050 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
4051 -
4052 -
4053 +
4054 +
4055 rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
4056 -
4057 +
4058 rxconf = rxconf &~ MAX_RX_DMA_MASK;
4059 rxconf = rxconf | (MAX_RX_DMA_2048<<MAX_RX_DMA_SHIFT);
4060 -
4061 +
4062 rxconf = rxconf | RCR_ONLYERLPKT;
4063 -
4064 +
4065 // rxconf = rxconf &~ RCR_CS_MASK;
4066 // rxconf = rxconf | (1<<RCR_CS_SHIFT);
4067  
4068 - write_nic_dword(dev, RX_CONF, rxconf);
4069 -
4070 + write_nic_dword(dev, RX_CONF, rxconf);
4071 +
4072 // V rtl suggested V //
4073 // write_nic_dword(dev, RX_CONF, 0x901ce70e);
4074 -
4075 +
4076 //fix_rx_fifo(dev);
4077 // //set_nic_rxring(dev);
4078 #ifdef DEBUG_RX
4079 @@ -816,23 +830,23 @@
4080 void rtl8180_rx_enable(struct net_device *dev)
4081 {
4082 u8 cmd;
4083 -
4084 -
4085 +
4086 +
4087 rtl8187_rx_initiate(dev);
4088  
4089 - rtl8187_set_rxconf(dev);
4090 + rtl8187_set_rxconf(dev);
4091  
4092 cmd=read_nic_byte(dev,CMD);
4093 write_nic_byte(dev,CMD,cmd | (1<<CMD_RX_ENABLE_SHIFT));
4094 #if 0
4095 - /* In rtl8139 driver seems that DMA threshold has to be written
4096 - * after enabling RX, so we rewrite RX_CONFIG register
4097 + /* In rtl8139 driver seems that DMA threshold has to be written
4098 + * after enabling RX, so we rewrite RX_CONFIG register
4099 */
4100 //mdelay(100);
4101 - write_nic_dword(dev, RX_CONF, rxconf);
4102 -
4103 + write_nic_dword(dev, RX_CONF, rxconf);
4104 +
4105 #endif
4106 -
4107 +
4108 }
4109  
4110  
4111 @@ -842,36 +856,36 @@
4112 u8 byte;
4113 u32 txconf;
4114 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
4115 -
4116 +
4117 byte = read_nic_byte(dev,CW_CONF);
4118 byte &= ~(1<<CW_CONF_PERPACKET_CW_SHIFT);
4119 byte &= ~(1<<CW_CONF_PERPACKET_RETRY_SHIFT);
4120 write_nic_byte(dev, CW_CONF, byte);
4121 -
4122 +
4123 byte = read_nic_byte(dev, TX_AGC_CTL);
4124 byte &= ~(1<<TX_AGC_CTL_PERPACKET_GAIN_SHIFT);
4125 byte &= ~(1<<TX_AGC_CTL_PERPACKET_ANTSEL_SHIFT);
4126 byte &= ~(1<<TX_AGC_CTL_FEEDBACK_ANT);
4127 write_nic_byte(dev, TX_AGC_CTL, byte);
4128 -
4129 +
4130 txconf= read_nic_dword(dev,TX_CONF);
4131 -
4132 +
4133 #if 0
4134 if(priv->card_8185){
4135 -
4136 +
4137 txconf = txconf &~ (1<<TCR_PROBE_NOTIMESTAMP_SHIFT);
4138 -
4139 +
4140 }else{
4141 -
4142 - if(priv->ieee80211->hw_seq)
4143 +
4144 + if(priv->ieee80211->hw_seq)
4145 txconf= txconf &~ (1<<TX_CONF_HEADER_AUTOICREMENT_SHIFT);
4146 - else
4147 + else
4148 txconf= txconf | (1<<TX_CONF_HEADER_AUTOICREMENT_SHIFT);
4149 }
4150 #endif
4151  
4152 txconf = txconf &~ TX_LOOPBACK_MASK;
4153 -
4154 +
4155 #ifndef LOOP_TEST
4156 txconf = txconf | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT);
4157 #else
4158 @@ -879,23 +893,26 @@
4159 #endif
4160 txconf = txconf &~ TCR_DPRETRY_MASK;
4161 txconf = txconf &~ TCR_RTSRETRY_MASK;
4162 -
4163 - txconf = txconf | (priv->retry_data<<TX_DPRETRY_SHIFT); // long
4164 - txconf = txconf | (priv->retry_rts<<TX_RTSRETRY_SHIFT); // short
4165 -
4166 +
4167 + if(priv->ieee80211->iw_mode != IW_MODE_MONITOR)
4168 + {
4169 + txconf = txconf | (priv->retry_data<<TX_DPRETRY_SHIFT); // long
4170 + txconf = txconf | (priv->retry_rts<<TX_RTSRETRY_SHIFT); // short
4171 + }
4172 +
4173 txconf = txconf &~ (1<<TX_NOCRC_SHIFT);
4174 -
4175 +
4176 txconf = txconf &~ TCR_MXDMA_MASK;
4177 txconf = txconf | (TCR_MXDMA_2048<<TCR_MXDMA_SHIFT);
4178 -
4179 +
4180 txconf = txconf | TCR_CWMIN;
4181 txconf = txconf | TCR_DISCW;
4182 txconf = txconf &~ TCR_SWPLCPLEN;
4183 -
4184 +
4185 txconf=txconf | (1<<TX_NOICV_SHIFT);
4186 -
4187 +
4188 write_nic_dword(dev,TX_CONF,txconf);
4189 -
4190 +
4191 // V RTL suggested V //
4192 // write_nic_dword(dev,TX_CONF,0x00e00707);
4193  
4194 @@ -903,9 +920,9 @@
4195 #ifdef DEBUG_TX
4196 DMESG("txconf: %x %x",txconf,read_nic_dword(dev,TX_CONF));
4197 #endif
4198 -
4199 +
4200 cmd=read_nic_byte(dev,CMD);
4201 - write_nic_byte(dev,CMD,cmd | (1<<CMD_TX_ENABLE_SHIFT));
4202 + write_nic_byte(dev,CMD,cmd | (1<<CMD_TX_ENABLE_SHIFT));
4203  
4204 // mdelay(100);
4205 //write_nic_dword(dev,TX_CONF,txconf);
4206 @@ -923,13 +940,13 @@
4207 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
4208 priv->dma_poll_mask &=~(1<<TX_DMA_STOP_BEACON_SHIFT);
4209 rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
4210 - write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
4211 + write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
4212 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
4213 }
4214  
4215  
4216 void rtl8180_
4217 -_disable(struct net_device *dev)
4218 +_disable(struct net_device *dev)
4219 {
4220 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
4221 priv->dma_poll_mask |= (1<<TX_DMA_STOP_BEACON_SHIFT);
4222 @@ -946,7 +963,7 @@
4223 u8 cmd;
4224 int i;
4225 struct r8180_priv *priv = ieee80211_priv(dev);
4226 -
4227 +
4228 cmd=read_nic_byte(dev,CMD);
4229 write_nic_byte(dev, CMD, cmd &~ \
4230 ((1<<CMD_RX_ENABLE_SHIFT)|(1<<CMD_TX_ENABLE_SHIFT)));
4231 @@ -957,9 +974,9 @@
4232 usb_kill_urb(priv->rx_urb[i]);
4233 }
4234 /*while (read_nic_byte(dev,CMD) & (1<<CMD_RX_ENABLE_SHIFT))
4235 - udelay(10);
4236 + udelay(10);
4237 */
4238 -
4239 +
4240 // if(!priv->rx_skb_complete)
4241 // dev_kfree_skb_any(priv->rx_skb);
4242 }
4243 @@ -971,13 +988,13 @@
4244 int i;
4245 u32 *tmp;
4246 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
4247 -
4248 +
4249 priv->txbeaconring = (u32*)pci_alloc_consistent(priv->pdev,
4250 - sizeof(u32)*8*count,
4251 + sizeof(u32)*8*count,
4252 &priv->txbeaconringdma);
4253 if (!priv->txbeaconring) return -1;
4254 for (tmp=priv->txbeaconring,i=0;i<count;i++){
4255 - *tmp = *tmp &~ (1<<31); // descriptor empty, owned by the drv
4256 + *tmp = *tmp &~ (1<<31); // descriptor empty, owned by the drv
4257 /*
4258 *(tmp+2) = (u32)dma_tmp;
4259 *(tmp+3) = bufsize;
4260 @@ -986,7 +1003,7 @@
4261 *(tmp+4) = (u32)priv->txbeaconringdma+((i+1)*8*4);
4262 else
4263 *(tmp+4) = (u32)priv->txbeaconringdma;
4264 -
4265 +
4266 tmp=tmp+8;
4267 }
4268 #endif
4269 @@ -996,15 +1013,15 @@
4270  
4271 void rtl8180_reset(struct net_device *dev)
4272 {
4273 -
4274 +
4275 u8 cr;
4276 -
4277 +
4278 /* make sure the analog power is on before
4279 * reset, otherwise reset may fail
4280 */
4281 rtl8180_set_anaparam(dev, RTL8225_ANAPARAM_ON);
4282 rtl8185_set_anaparam2(dev, RTL8225_ANAPARAM2_ON);
4283 -
4284 +
4285 rtl8180_irq_disable(dev);
4286  
4287 mdelay(200);
4288 @@ -1012,19 +1029,19 @@
4289 write_nic_byte_E(dev,0x18,0x11);
4290 write_nic_byte_E(dev,0x18,0x00);
4291 mdelay(200);
4292 -
4293 +
4294 cr=read_nic_byte(dev,CMD);
4295 cr = cr & 2;
4296 cr = cr | (1<<CMD_RST_SHIFT);
4297 write_nic_byte(dev,CMD,cr);
4298 -
4299 +
4300 force_pci_posting(dev);
4301 -
4302 +
4303 mdelay(200);
4304 -
4305 - if(read_nic_byte(dev,CMD) & (1<<CMD_RST_SHIFT))
4306 +
4307 + if(read_nic_byte(dev,CMD) & (1<<CMD_RST_SHIFT))
4308 DMESGW("Card reset timeout!");
4309 - else
4310 + else
4311 DMESG("Card successfully reset");
4312  
4313 rtl8180_set_mode(dev,EPROM_CMD_LOAD);
4314 @@ -1036,13 +1053,13 @@
4315 */
4316 rtl8180_set_anaparam(dev, RTL8225_ANAPARAM_ON);
4317 rtl8185_set_anaparam2(dev, RTL8225_ANAPARAM2_ON);
4318 -
4319 +
4320 }
4321  
4322 inline u16 ieeerate2rtlrate(int rate)
4323 {
4324 switch(rate){
4325 - case 10:
4326 + case 10:
4327 return 0;
4328 case 20:
4329 return 1;
4330 @@ -1068,14 +1085,14 @@
4331 return 11;
4332 default:
4333 return 3;
4334 -
4335 +
4336 }
4337 }
4338 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
4339 inline u16 rtl8180_rate2rate(short rate)
4340 {
4341 if (rate >11) return 0;
4342 - return rtl_rate[rate];
4343 + return rtl_rate[rate];
4344 }
4345  
4346  
4347 @@ -1089,49 +1106,49 @@
4348 u16 N_DBPSOfRate(u16 DataRate)
4349 {
4350 u16 N_DBPS = 24;
4351 -
4352 +
4353 switch(DataRate)
4354 {
4355 case 60:
4356 N_DBPS = 24;
4357 break;
4358 -
4359 +
4360 case 90:
4361 N_DBPS = 36;
4362 break;
4363 -
4364 +
4365 case 120:
4366 N_DBPS = 48;
4367 break;
4368 -
4369 +
4370 case 180:
4371 N_DBPS = 72;
4372 break;
4373 -
4374 +
4375 case 240:
4376 N_DBPS = 96;
4377 break;
4378 -
4379 +
4380 case 360:
4381 N_DBPS = 144;
4382 break;
4383 -
4384 +
4385 case 480:
4386 N_DBPS = 192;
4387 break;
4388 -
4389 +
4390 case 540:
4391 N_DBPS = 216;
4392 break;
4393 -
4394 +
4395 default:
4396 break;
4397 }
4398 -
4399 +
4400 return N_DBPS;
4401 }
4402  
4403 -u16 ComputeTxTime(
4404 +u16 ComputeTxTime(
4405 u16 FrameLength,
4406 u16 DataRate,
4407 u8 bManagementFrame,
4408 @@ -1146,7 +1163,7 @@
4409 {
4410 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
4411 { // long preamble
4412 - FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
4413 + FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
4414 }
4415 else
4416 { // Short preamble
4417 @@ -1156,14 +1173,14 @@
4418 FrameTime ++;
4419 } else { //802.11g DSSS-OFDM PLCP length field calculation.
4420 N_DBPS = N_DBPSOfRate(DataRate);
4421 - Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
4422 + Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
4423 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
4424 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
4425 }
4426 return FrameTime;
4427 }
4428  
4429 -
4430 +
4431 #if 0
4432 void rtl8187_rx_isr(struct urb *rx_urb, struct pt_regs *regs)
4433 {
4434 @@ -1172,7 +1189,7 @@
4435  
4436 priv->rxurb_task = rx_urb;
4437 // DMESGW("David: Rx tasklet start!");
4438 - tasklet_schedule(&priv->irq_rx_tasklet);
4439 + tasklet_schedule(&priv->irq_rx_tasklet);
4440 // DMESGW("=David: Rx tasklet finish!");
4441 }
4442 #endif
4443 @@ -1223,13 +1240,14 @@
4444 void rtl8180_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
4445 {
4446 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
4447 -
4448 - short morefrag = 0;
4449 +
4450 + short morefrag = 0;
4451 unsigned long flags;
4452 struct ieee80211_hdr *h = (struct ieee80211_hdr *) skb->data;
4453  
4454 - if (le16_to_cpu(h->frame_ctl) & IEEE80211_FCTL_MOREFRAGS)
4455 - morefrag = 1;
4456 + if(priv->ieee80211->iw_mode != IW_MODE_MONITOR)
4457 + if (le16_to_cpu(h->frame_ctl) & IEEE80211_FCTL_MOREFRAGS)
4458 + morefrag = 1;
4459 // DMESG("%x %x", h->frame_ctl, h->seq_ctl);
4460 /*
4461 * This function doesn't require lock because we make
4462 @@ -1238,25 +1256,24 @@
4463 * the ieee stack, or from the try_wake_queue (again trought
4464 * the ieee stack.
4465 */
4466 - spin_lock_irqsave(&priv->tx_lock,flags);
4467 -
4468 + spin_lock_irqsave(&priv->tx_lock,flags);
4469 +
4470 //DMESG("TX");
4471 if (!check_nic_enought_desc(dev, LOW_PRIORITY)){
4472 DMESG("Error: no TX slot ");
4473 ieee80211_stop_queue(priv->ieee80211);
4474 }
4475 -
4476 -
4477 +
4478 rtl8180_tx(dev, skb->data, skb->len, LOW_PRIORITY, morefrag,
4479 ieeerate2rtlrate(rate));
4480  
4481 priv->stats.txdatapkt++;
4482 -
4483 +
4484 if (!check_nic_enought_desc(dev, LOW_PRIORITY))
4485 ieee80211_stop_queue(priv->ieee80211);
4486 -
4487 - spin_unlock_irqrestore(&priv->tx_lock,flags);
4488 -
4489 +
4490 + spin_unlock_irqrestore(&priv->tx_lock,flags);
4491 +
4492 }
4493 #if 0
4494 /* This is a rough attempt to TX a frame
4495 @@ -1269,9 +1286,9 @@
4496 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
4497 int ret;
4498 unsigned long flags;
4499 -
4500 +
4501 spin_lock_irqsave(&priv->tx_lock,flags);
4502 -
4503 +
4504 ret = rtl8180_tx(dev, (u32*)skb->data, skb->len, NORM_PRIORITY, 0,DEFAULT_BASICRATE);
4505 /*
4506 int i;
4507 @@ -1281,9 +1298,9 @@
4508 */
4509 priv->ieee80211->stats.tx_bytes+=skb->len;
4510 priv->ieee80211->stats.tx_packets++;
4511 -
4512 - spin_unlock_irqrestore(&priv->tx_lock,flags);
4513 -
4514 +
4515 + spin_unlock_irqrestore(&priv->tx_lock,flags);
4516 +
4517 dev_kfree_skb_any(skb);
4518 return ret;
4519 }
4520 @@ -1296,7 +1313,7 @@
4521 u16 duration;
4522 u16 drift;
4523 *ext=0;
4524 -
4525 +
4526 switch(rate){
4527 case 0://1mbps
4528 *ext=0;
4529 @@ -1305,7 +1322,7 @@
4530 if(drift ==0 ) break;
4531 duration++;
4532 break;
4533 -
4534 +
4535 case 1://2mbps
4536 *ext=0;
4537 duration = ((len+4)<<4) /0x4;
4538 @@ -1313,30 +1330,30 @@
4539 if(drift ==0 ) break;
4540 duration++;
4541 break;
4542 -
4543 +
4544 case 2: //5.5mbps
4545 *ext=0;
4546 duration = ((len+4)<<4) /0xb;
4547 drift = ((len+4)<<4) % 0xb;
4548 - if(drift ==0 )
4549 + if(drift ==0 )
4550 break;
4551 duration++;
4552 break;
4553 -
4554 +
4555 default:
4556 - case 3://11mbps
4557 + case 3://11mbps
4558 *ext=0;
4559 duration = ((len+4)<<4) /0x16;
4560 drift = ((len+4)<<4) % 0x16;
4561 - if(drift ==0 )
4562 + if(drift ==0 )
4563 break;
4564 duration++;
4565 - if(drift > 6)
4566 + if(drift > 6)
4567 break;
4568 *ext=1;
4569 break;
4570 }
4571 -
4572 +
4573 return duration;
4574 }
4575 #endif
4576 @@ -1369,10 +1386,10 @@
4577 if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
4578 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
4579 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
4580 - write_nic_byte(dev, MSR, msr);
4581 + write_nic_byte(dev, MSR, msr);
4582 }
4583 -
4584 -
4585 +
4586 +
4587 }
4588  
4589  
4590 @@ -1382,21 +1399,21 @@
4591 struct r8180_priv *priv = ieee80211_priv(dev);
4592 struct ieee80211_network *net;
4593 net = & priv->ieee80211->current_network;
4594 -
4595 -
4596 +
4597 +
4598 write_nic_dword(dev,BSSID,((u32*)net->bssid)[0]);
4599 write_nic_word(dev,BSSID+4,((u16*)net->bssid)[2]);
4600 //for(i=0;i<ETH_ALEN;i++)
4601 // write_nic_byte(dev,BSSID+i,net->bssid[i]);
4602  
4603 rtl8180_update_msr(dev);
4604 -
4605 +
4606 // rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
4607 write_nic_word(dev, AtimWnd, 2);
4608 - write_nic_word(dev, AtimtrItv, 100);
4609 + write_nic_word(dev, AtimtrItv, 100);
4610 write_nic_word(dev, BEACON_INTERVAL, net->beacon_interval);
4611 write_nic_word(dev, BcnIntTime, 100);
4612 -
4613 +
4614  
4615 }
4616  
4617 @@ -1406,18 +1423,18 @@
4618 struct r8180_priv *priv = ieee80211_priv(dev);
4619 struct sk_buff *skb;
4620 int i = 0;
4621 -
4622 +
4623 rtl8187_net_update(dev);
4624 -
4625 +
4626 skb = ieee80211_get_beacon(priv->ieee80211);
4627 -
4628 -
4629 - if(!skb){
4630 +
4631 +
4632 + if(!skb){
4633 DMESG("not enought memory for allocating beacon");
4634 return;
4635 }
4636 -
4637 -#if 0
4638 +
4639 +#if 0
4640 while(MAX_TX_URB!=atomic_read(&priv->tx_np_pending)){
4641 msleep_interruptible_rtl(HZ/2);
4642 if(i++ > 20){
4643 @@ -1427,7 +1444,7 @@
4644 }
4645 #endif
4646 write_nic_byte(dev, BQREQ, read_nic_byte(dev, BQREQ) | (1<<7));
4647 -
4648 +
4649 i=0;
4650 //while(!read_nic_byte(dev,BQREQ & (1<<7)))
4651 while( (read_nic_byte(dev, BQREQ) & (1<<7)) == 0 )
4652 @@ -1438,7 +1455,7 @@
4653 return ;
4654 }
4655 }
4656 -
4657 +
4658 rtl8180_tx(dev, skb->data, skb->len, NORM_PRIORITY,
4659 0, priv->ieee80211->basic_rate);
4660  
4661 @@ -1461,15 +1478,15 @@
4662 }
4663  
4664  
4665 -/* This function do the real dirty work: it sends a TX command
4666 - * descriptor plus data URB
4667 +/* This function do the real dirty work: it sends a TX command
4668 + * descriptor plus data URB
4669 */
4670 -
4671 +
4672 short rtl8180_tx(struct net_device *dev, u8* txbuf, int len, priority_t priority,
4673 short morefrag, short rate)
4674 {
4675 //u32 *tx;
4676 - u8 *tx;
4677 + u8 *tx;
4678 u8 *pdata;
4679 u8 seg = ((u32)txbuf % 4);
4680 u32 *pdata32;
4681 @@ -1480,7 +1497,7 @@
4682 int pend;
4683 int status;
4684 struct urb *tx_urb;
4685 - int urb_len;
4686 + int urb_len;
4687 u16 AckCtsTime;
4688 u16 FrameTime;
4689 u16 duration;
4690 @@ -1498,20 +1515,20 @@
4691 priv->stats.txlpdrop++;
4692 return -1;
4693 }
4694 -
4695 -#if 0
4696 +
4697 +#if 0
4698 //tx = kmalloc((len + 4*3), GFP_ATOMIC);
4699 urb_len = len + 4*3;
4700 if((0 == urb_len%64)||(0 == urb_len%512)) {
4701 - urb_len += 1;
4702 + urb_len += 1;
4703 }
4704 tx = kmalloc(urb_len, GFP_ATOMIC);
4705 if(!tx) return -ENOMEM;
4706 - //printk(KERN_WARNING "urb_len = %d\n", urb_len);
4707 + //printk(KERN_WARNING "urb_len = %d\n", urb_len);
4708 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
4709 -
4710 +
4711 if(!tx_urb){
4712 -
4713 +
4714 kfree(tx);
4715 return -ENOMEM;
4716 }
4717 @@ -1519,7 +1536,7 @@
4718 //urb_len = TX_URB_SIZE;
4719 urb_len = len + 4*3;
4720 if((0 == urb_len%64)||(0 == urb_len%512)) {
4721 - urb_len += 1;
4722 + urb_len += 1;
4723 }
4724  
4725 tx_urb = priv->tx_context[priv->tx_urb_index].tx_urb;
4726 @@ -1527,7 +1544,7 @@
4727 pdata = tx + 12;
4728 priv->tx_urb_index = (priv->tx_urb_index + 1) % MAX_TX_URB;
4729 #endif
4730 -#if 0
4731 +#if 0
4732 memcpy(tx+3,txbuf,len);
4733 tx[0] = 0;
4734 tx[0] |= len & 0xfff;
4735 @@ -1535,7 +1552,7 @@
4736 // printk(KERN_INFO "preamble mode %d,rate %d!\n",priv->plcp_preamble_mode,rate);
4737 if (priv->ieee80211->current_network.capability&WLAN_CAPABILITY_SHORT_PREAMBLE)
4738 if (priv->plcp_preamble_mode==1 && rate!=0) { // short mode now, not long!
4739 - tx[0] |= (1<<16);
4740 + tx[0] |= (1<<16);
4741 // printk(KERN_INFO "use short preamble!\n");
4742 } // enable short preamble mode.
4743  
4744 @@ -1548,11 +1565,11 @@
4745 AckCtsTime = ComputeTxTime(14, 10,0, 0); // AckCTSLng = 14 use 1M bps send
4746 FrameTime = ComputeTxTime(len + 4, rtl8180_rate2rate(rate), 0, tx[0]&(1<<16));
4747 // RTS/CTS time is calculate as follow
4748 - duration = FrameTime + 3*10 + 2*AckCtsTime; //10us is the SifsTime;
4749 + duration = FrameTime + 3*10 + 2*AckCtsTime; //10us is the SifsTime;
4750 tx[1] |= duration; //Need to edit here! ----hikaru
4751 printk(KERN_INFO "duration %d!\n",duration);
4752 }
4753 - else
4754 + else
4755 tx[1]=0;
4756 //if(len > priv->rts_threshold){
4757 // tx[0] |= (1<<23); //ENABLE RTS
4758 @@ -1562,18 +1579,18 @@
4759 tx[0] |= (ieeerate2rtlrate(priv->ieee80211->basic_rate) << 19); /* RTS RATE - should be basic rate */
4760 tx[0] |= (rate << 24);
4761 // tx[1] = 0;
4762 -
4763 +
4764 // duration = rtl8180_len2duration(len,
4765 -// rate,&ext);
4766 +// rate,&ext);
4767 // tx[1] |= (duration & 0x7fff) <<16;
4768 // if(ext) tx[1] |= (1<<31);
4769  
4770 -
4771 +
4772 // tx[2] = 0x303020;
4773 tx[2] = 3; // CW min
4774 tx[2] |= (7<<4); //CW max
4775 tx[2] |= (11<<8);//(priv->retry_data<<8); //retry lim
4776 -
4777 +
4778 // printk("%x\n%x\n",tx[0],tx[1]);
4779  
4780 #ifdef DUMP_TX
4781 @@ -1601,12 +1618,12 @@
4782 }
4783 #endif
4784 //memcpy(pdata, txbuf, len);
4785 -
4786 +
4787 //tx[0] = 0;
4788 //tx[1] = 0;
4789 tx[2] = 0;
4790 tx[3] = 0;
4791 -
4792 +
4793 //tx[0] |= len & 0xfff;
4794 tx[0] = len & 0xff;
4795 tx[1] = (len & 0x0f00) >> 8;
4796 @@ -1614,25 +1631,25 @@
4797  
4798 if (priv->ieee80211->current_network.capability&WLAN_CAPABILITY_SHORT_PREAMBLE)
4799 if (priv->plcp_preamble_mode==1 && rate!=0) { // short mode now, not long!
4800 - tx[2] |= 1;
4801 + tx[2] |= 1;
4802  
4803 - }
4804 + }
4805  
4806 if ( (len>priv->rts) && priv->rts && priority==LOW_PRIORITY){
4807 tx[2] |= (1<<7); //enalbe RTS function
4808 AckCtsTime = ComputeTxTime(14, 10,0, 0); // AckCTSLng = 14 use 1M bps send
4809 FrameTime = ComputeTxTime(len + 4, rtl8180_rate2rate(rate), 0, tx[2]&1);
4810 // RTS/CTS time is calculate as follow
4811 - duration = FrameTime + 3*10 + 2*AckCtsTime; //10us is the SifsTime;
4812 + duration = FrameTime + 3*10 + 2*AckCtsTime; //10us is the SifsTime;
4813 tx[4] |= duration & 0xff; //Need to edit here! ----hikaru
4814 - tx[5] |= (duration & 0xff00) >> 8;
4815 + tx[5] |= (duration & 0xff00) >> 8;
4816 printk(KERN_INFO "duration %d!\n",duration);
4817 }
4818 else {
4819 tx[4] = 0;
4820 tx[5] = 0;
4821 }
4822 -
4823 +
4824 if(morefrag) tx[2] |= (1<<1);
4825 tx[2] |= (ieeerate2rtlrate(priv->ieee80211->basic_rate) << 3); /* RTS RATE - should be basic rate */
4826 tx[3] |= rate;
4827 @@ -1640,7 +1657,7 @@
4828 tx[8] = 3; // CW min
4829 tx[8] |= (7<<4); //CW max
4830 tx[9] |= 11;//(priv->retry_data<<8); //retry lim
4831 -
4832 +
4833  
4834 /* FIXME check what EP is for low/norm PRI */
4835 usb_fill_bulk_urb(tx_urb,priv->udev,
4836 @@ -1662,7 +1679,7 @@
4837 }
4838 }
4839  
4840 -
4841 +
4842  
4843 //void rtl8180_irq_rx_tasklet(struct r8180_priv * priv);
4844  
4845 @@ -1671,70 +1688,70 @@
4846 {
4847 struct r8180_priv *priv = ieee80211_priv(dev);
4848 int i,j;
4849 -
4850 +
4851 priv->rx_urb = (struct urb**) kmalloc (sizeof(struct urb*) * MAX_RX_URB, GFP_KERNEL);
4852 -
4853 +
4854 for(i=0;i<MAX_RX_URB;i++){
4855 priv->rx_urb[i] = usb_alloc_urb(0,GFP_KERNEL);
4856 - if(!priv->rx_urb[i])
4857 + if(!priv->rx_urb[i])
4858 goto destroy;
4859 -
4860 +
4861 priv->rx_urb[i]->transfer_buffer = kmalloc(RX_URB_SIZE, GFP_KERNEL);
4862 - if(!priv->rx_urb[i]->transfer_buffer)
4863 + if(!priv->rx_urb[i]->transfer_buffer)
4864 goto destroy1;
4865 -
4866 +
4867 priv->rx_urb[i]->transfer_buffer_length = RX_URB_SIZE;
4868 }
4869  
4870 for(j=0; j < MAX_TX_URB; j++){
4871 struct tx_urb_context *ptrcontext = &priv->tx_context[j];
4872 u8 seg_size;
4873 -
4874 +
4875 ptrcontext->tx_urb = usb_alloc_urb(0,GFP_KERNEL);
4876 - if(!ptrcontext->tx_urb)
4877 + if(!ptrcontext->tx_urb)
4878 goto destroy_tx;
4879 -
4880 +
4881 ptrcontext->transfer_buffer = kmalloc(TX_URB_SIZE, GFP_KERNEL);
4882 - if(!ptrcontext->transfer_buffer)
4883 + if(!ptrcontext->transfer_buffer)
4884 goto destroy1_tx;
4885 // set tx_urb 4 byte align
4886 seg_size = (u32)ptrcontext->transfer_buffer % 4;
4887 ptrcontext->ptalign_buf = ptrcontext->transfer_buffer + ((seg_size > 0)? (4 - seg_size):0);
4888 }
4889 -
4890 +
4891 return 0;
4892  
4893 destroy1_tx:
4894 usb_free_urb(priv->tx_context[j].tx_urb);
4895 -
4896 +
4897 destroy_tx:
4898 while (--j >= 0){
4899 kfree(priv->tx_context[j].transfer_buffer);
4900 usb_free_urb(priv->tx_context[j].tx_urb);
4901 }
4902 -
4903 +
4904 destroy1:
4905 usb_free_urb(priv->rx_urb[i]);
4906 -
4907 +
4908 destroy:
4909 while (--i >= 0){
4910 kfree(priv->rx_urb[i]->transfer_buffer);
4911 usb_free_urb(priv->rx_urb[i]);
4912 }
4913 -
4914 +
4915 kfree(priv->rx_urb);
4916 -
4917 +
4918 priv->rx_urb = NULL;
4919 DMESGE("Endpoint Alloc Failure");
4920 return -ENOMEM;
4921 -
4922 +
4923 }
4924  
4925 void rtl8187_usb_deleteendpoints(struct net_device *dev)
4926 {
4927 struct r8180_priv *priv = ieee80211_priv(dev);
4928 int i,j;
4929 -
4930 +
4931 if(priv->rx_urb){
4932 for(i=0;i<MAX_RX_URB;i++){
4933 usb_kill_urb(priv->rx_urb[i]);
4934 @@ -1743,12 +1760,12 @@
4935 }
4936 kfree(priv->rx_urb);
4937 priv->rx_urb = NULL;
4938 -
4939 +
4940 }
4941 //added by david. 2007.1.30
4942 for(j=0; j < MAX_TX_URB; j++){
4943 struct tx_urb_context *ptrcontext = &priv->tx_context[j];
4944 -
4945 +
4946 usb_kill_urb(ptrcontext->tx_urb);
4947 kfree(ptrcontext->transfer_buffer);
4948 ptrcontext->transfer_buffer = NULL;
4949 @@ -1763,16 +1780,16 @@
4950 int i;
4951 u16 word;
4952 int basic_rate,min_rr_rate,max_rr_rate;
4953 -
4954 +
4955 // struct r8180_priv *priv = ieee80211_priv(dev);
4956 -
4957 - //if (ieee80211_is_54g(priv->ieee80211->current_network) &&
4958 +
4959 + //if (ieee80211_is_54g(priv->ieee80211->current_network) &&
4960 // priv->ieee80211->state == IEEE80211_LINKED){
4961 basic_rate = ieeerate2rtlrate(240);
4962 min_rr_rate = ieeerate2rtlrate(60);
4963 max_rr_rate = ieeerate2rtlrate(240);
4964 -
4965 -//
4966 +
4967 +//
4968 // }else{
4969 // basic_rate = ieeerate2rtlrate(20);
4970 // min_rr_rate = ieeerate2rtlrate(10);
4971 @@ -1784,7 +1801,7 @@
4972  
4973 word = read_nic_word(dev, BRSR);
4974 word &= ~BRSR_MBR_8185;
4975 -
4976 +
4977  
4978 for(i=0;i<=basic_rate;i++)
4979 word |= (1<<i);
4980 @@ -1797,7 +1814,7 @@
4981 void rtl8187_link_change(struct net_device *dev)
4982 {
4983 // int i;
4984 -
4985 +
4986 struct r8180_priv *priv = ieee80211_priv(dev);
4987 //write_nic_word(dev, BintrItv, net->beacon_interval);
4988 rtl8187_net_update(dev);
4989 @@ -1813,10 +1830,15 @@
4990  
4991 #define HW_WAKE_DELAY 5
4992  
4993 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
4994 +void rtl8180_hw_wakeup(struct work_struct *work)
4995 +{
4996 + struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, hw_wakeup_wq);
4997 + struct net_device *dev = ieee->dev;
4998 +#else
4999 void rtl8180_hw_wakeup(struct net_device *dev)
5000 {
5001 - //unsigned long flags;
5002 -
5003 +#endif
5004 struct r8180_priv *priv = ieee80211_priv(dev);
5005 printk(KERN_INFO "enter rtl8180_hw_wakeup!\n");
5006 if (!priv->ps_sleep_finish) {
5007 @@ -1829,7 +1851,7 @@
5008 // spin_lock_irqsave(&priv->ps_lock,flags);
5009 //DMESG("Waken up!");
5010 // write_nic_byte(dev,CONFIG4,read_nic_byte(dev,CONFIG4)&~CONFIG4_PWRMGT);
5011 -
5012 +
5013 if(priv->rf_wakeup)
5014 priv->rf_wakeup(dev);
5015 priv->ps_sleep_finish=0;
5016 @@ -1853,19 +1875,32 @@
5017 schedule_work(&priv->rtl8180_hw_wakeup_wq);
5018 printk(KERN_INFO "timer wakup schedule!\n");
5019 }
5020 -void rtl8180_rq_tx_ack(struct net_device *dev){
5021 -
5022 +
5023 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
5024 +void rtl8180_rq_tx_ack(struct work_struct *work)
5025 +{
5026 + struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, ps_request_tx_ack_wq);
5027 + struct net_device *dev = ieee->dev;
5028 +#else
5029 +void rtl8180_rq_tx_ack(struct net_device *dev)
5030 +{
5031 +#endif
5032 struct r8180_priv *priv = ieee80211_priv(dev);
5033 // write_nic_byte(dev,CONFIG4,read_nic_byte(dev,CONFIG4)|CONFIG4_PWRMGT);
5034 priv->ack_tx_to_ieee = 1;
5035 // printk(KERN_INFO "rtl8180_rq_tx_ack!\n");
5036 }
5037  
5038 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
5039 +void rtl8180_hw_sleep(struct work_struct *work)
5040 +{
5041 + struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, hw_sleep_wq);
5042 + struct net_device *dev = ieee->dev;
5043 +#else
5044 void rtl8180_hw_sleep(struct net_device *dev)
5045 {
5046 -
5047 +#endif
5048 struct r8180_priv *priv = ieee80211_priv(dev);
5049 -
5050 u32 rb,tl;
5051 //unsigned long flags;
5052 u32 timeout;
5053 @@ -1886,27 +1921,27 @@
5054 rb = read_nic_dword(dev, TSFTR);
5055 //// printk(KERN_INFO "enter rtl8180_hw_sleep!\n");
5056 // spin_lock_irqsave(&priv->ps_lock,flags);
5057 -
5058 +
5059 /* Writing HW register with 0 equals to disable
5060 * the timer, that is not really what we want
5061 */
5062 tl = priv->ieee80211->ps_tl;
5063 // printk(KERN_INFO "tl is %lu!\n",tl);
5064 tl -= HW_WAKE_DELAY*1000;
5065 -
5066 +
5067 if(tl == 0) tl = 1;
5068 -
5069 +
5070 /* FIXME HACK FIXME HACK */
5071 // force_pci_posting(dev);
5072 // mdelay(1);
5073 -
5074 +
5075 // rb = read_nic_dword(dev, TSFTR);
5076 #ifdef TONY_PS
5077 printk(KERN_INFO "tl %lu, rb %lu!\n",tl,rb);
5078 #endif
5079 -
5080 +
5081 //DMESG("sleep until %x, hw @:%x",tl,rb);
5082 -
5083 +
5084 /* If the interval in witch we are requested to sleep is too
5085 * short then give up and remain awake
5086 */
5087 @@ -1914,12 +1949,12 @@
5088 if(((rb<tl)&& (tl-rb) < MIN_SLEEP_TIME)
5089 ||((rb>tl)&& (rb-tl) < MIN_SLEEP_TIME))
5090 return;
5091 -
5092 +
5093 // write_nic_dword(dev, TimerInt, tl);
5094 //DMESG("sleep..");
5095 // rb = read_nic_dword(dev, TSFTR);
5096 -
5097 - /* if we suspect the TimerInt is gone beyond tl
5098 +
5099 + /* if we suspect the TimerInt is gone beyond tl
5100 * while setting it, then give up
5101 */
5102 if(((tl > rb) && ((tl-rb) > MAX_SLEEP_TIME))||
5103 @@ -1927,29 +1962,29 @@
5104 return;
5105  
5106 if (rb>tl)
5107 - timeout = (rb-tl)>>10;//divide by 1024
5108 + timeout = (rb-tl)>>10;//divide by 1024
5109 else
5110 - timeout = (tl-rb)>>10;
5111 + timeout = (tl-rb)>>10;
5112  
5113 // if(priv->rf_sleep)
5114 // priv->rf_sleep(dev);
5115 priv->ps_timer.expires = jiffies+timeout;
5116 //// printk(KERN_INFO "jiffies %lu, timeout %lu!\n",jiffies,timeout);
5117 add_timer(&priv->ps_timer);
5118 -
5119 +
5120 if(priv->rf_sleep)
5121 priv->rf_sleep(dev);
5122 priv->ps_sleep_finish=1;
5123 // }
5124 // up(&priv->power_sem);
5125 -// spin_unlock_irqrestore(&priv->ps_lock,flags);
5126 +// spin_unlock_irqrestore(&priv->ps_lock,flags);
5127 printk(KERN_INFO "leave sleep!\n");
5128 }
5129  
5130 short rtl8180_is_tx_queue_empty(struct net_device *dev){
5131 -
5132 +
5133 struct r8180_priv *priv = ieee80211_priv(dev);
5134 -
5135 +
5136 int used;
5137 #ifdef TONY_TRACK
5138 DMESG("enter rtl8180_is_tx_queue_empty!\n");
5139 @@ -1957,11 +1992,11 @@
5140  
5141 used = atomic_read(&priv->tx_np_pending);
5142 //// printk(KERN_INFO "np used %d!\n",used);
5143 - if (used) return 0;
5144 + if (used) return 0;
5145 used = atomic_read(&priv->tx_lp_pending);
5146 //// printk(KERN_INFO "lp used %d!\n",used);
5147 if (used) return 0;
5148 -
5149 +
5150 return 1;
5151 }
5152  
5153 @@ -1969,7 +2004,7 @@
5154  
5155 short rtl8180_init(struct net_device *dev)
5156 {
5157 -
5158 +
5159 struct r8180_priv *priv = ieee80211_priv(dev);
5160 int i, j;
5161 u16 word;
5162 @@ -1977,16 +2012,16 @@
5163 //u16 version;
5164 //u8 hw_version;
5165 //u8 config3;
5166 -
5167 +
5168 //FIXME: these constants are placed in a bad pleace.
5169  
5170 // priv->txbuffsize = 1024;
5171 // priv->txringcount = 32;
5172 // priv->rxbuffersize = 1024;
5173 -// priv->rxringcount = 32;
5174 +// priv->rxringcount = 32;
5175 // priv->txbeaconcount = 3;
5176 // priv->rx_skb_complete = 1;
5177 - //priv->txnp_pending.ispending=0;
5178 + //priv->txnp_pending.ispending=0;
5179 /* ^^ the SKB does not containt a partial RXed
5180 * packet (is empty)
5181 */
5182 @@ -2004,9 +2039,9 @@
5183 ch >>= 1;
5184 }
5185 //memcpy(priv->stats,0,sizeof(struct Stats));
5186 -
5187 +
5188 //priv->irq_enabled=0;
5189 -
5190 +
5191 // priv->stats.rxdmafail=0;
5192 priv->stats.txrdu=0;
5193 // priv->stats.rxrdu=0;
5194 @@ -2042,7 +2077,7 @@
5195  
5196 priv->ps_sleep_finish=0;
5197 priv->ieee80211->iw_mode = IW_MODE_INFRA;
5198 -
5199 +
5200 priv->retry_rts = DEFAULT_RETRY_RTS;
5201 priv->retry_data = DEFAULT_RETRY_DATA;
5202 priv->ieee80211->rate = 110; //11 mbps
5203 @@ -2050,11 +2085,19 @@
5204 priv->ieee80211->mode = IEEE_G|IEEE_B; //2007.1.25
5205 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
5206 spin_lock_init(&priv->tx_lock);
5207 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
5208 INIT_WORK(&priv->reset_wq,(void(*)(void*)) rtl8180_restart,dev);
5209 INIT_WORK(&priv->rtl8180_hw_wakeup_wq,(void(*)(void*))rtl8180_hw_wakeup,dev);
5210 INIT_WORK(&priv->ieee80211->ps_request_tx_ack_wq,(void(*)(void*))rtl8180_rq_tx_ack,dev);
5211 INIT_WORK(&priv->ieee80211->hw_wakeup_wq,(void(*)(void*))rtl8180_hw_wakeup,dev);
5212 INIT_WORK(&priv->ieee80211->hw_sleep_wq,(void(*)(void*))rtl8180_hw_sleep,dev);
5213 +#else
5214 + INIT_WORK(&priv->reset_wq, rtl8180_restart);
5215 + INIT_WORK(&priv->rtl8180_hw_wakeup_wq, rtl8180_hw_wakeup);
5216 + INIT_WORK(&priv->ieee80211->ps_request_tx_ack_wq, rtl8180_rq_tx_ack);
5217 + INIT_WORK(&priv->ieee80211->hw_wakeup_wq, rtl8180_hw_wakeup);
5218 + INIT_WORK(&priv->ieee80211->hw_sleep_wq, rtl8180_hw_sleep);
5219 +#endif
5220 // INIT_WORK(&priv->ps_request_tx_ack_wq,(void(*)(void*))rtl8180_rq_tx_ack,dev);
5221 sema_init(&priv->wx_sem,1);
5222 sema_init(&priv->power_sem,1);
5223 @@ -2068,17 +2111,17 @@
5224 priv->ps_timer.data = (unsigned long)dev;
5225 priv->ps_timer.function = timer_hw_wakeup_wq;
5226  
5227 - //priv->ieee80211->func =
5228 + //priv->ieee80211->func =
5229 // kmalloc(sizeof(struct ieee80211_helper_functions),GFP_KERNEL);
5230 //memset(priv->ieee80211->func, 0,
5231 // sizeof(struct ieee80211_helper_functions));
5232 - priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
5233 + priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
5234 priv->ieee80211->iw_mode = IW_MODE_INFRA;
5235 - priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
5236 - IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
5237 + priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
5238 + IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
5239 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
5240 /*IEEE_SOFTMAC_BEACONS | */IEEE_SOFTMAC_SINGLE_QUEUE;
5241 -
5242 +
5243 priv->ieee80211->active_scan = 1;
5244 priv->ieee80211->rate = 110; //11 mbps
5245 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
5246 @@ -2100,51 +2143,51 @@
5247 priv->ieee80211->data_hard_resume = rtl8180_data_hard_resume;
5248 //priv->ieee80211->start_send_beacons = NULL;
5249 //priv->ieee80211->stop_send_beacons = NULL;
5250 -
5251 +
5252 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
5253 -
5254 +
5255 priv->card_8185 = 2;
5256 priv->phy_ver = 2;
5257 priv->card_type = USB;
5258 -
5259 +
5260 #if 0
5261 hw_version =( read_nic_dword(dev, TCR) & TCR_HWVERID_MASK)>>TCR_HWVERID_SHIFT;
5262 -
5263 +
5264 switch (hw_version){
5265 case HW_VERID_R8185_ABC:
5266 - DMESG("MAC controller is a RTL8185 b/g");
5267 + DMESG("MAC controller is a RTL8185 b/g");
5268 priv->card_8185 = 1;
5269 /* you should not find a card with 8225 PHY ver < C*/
5270 priv->phy_ver = 2;
5271 break;
5272 -
5273 +
5274 case HW_VERID_R8185_D:
5275 - DMESG("MAC controller is a RTL8185 b/g (V. D)");
5276 + DMESG("MAC controller is a RTL8185 b/g (V. D)");
5277 priv->card_8185 = 2;
5278 /* you should not find a card with 8225 PHY ver < C*/
5279 priv->phy_ver = 2;
5280 break;
5281 -
5282 +
5283 case HW_VERID_R8180_ABCD:
5284 DMESG("MAC controller is a RTL8180");
5285 priv->card_8185 = 0;
5286 break;
5287 -
5288 +
5289 case HW_VERID_R8180_F:
5290 DMESG("MAC controller is a RTL8180 (v. F)");
5291 priv->card_8185 = 0;
5292 break;
5293 -
5294 +
5295 default:
5296 DMESGW("MAC chip not recognized: version %x. Assuming RTL8180",hw_version);
5297 priv->card_8185 = 0;
5298 break;
5299 }
5300 -
5301 -
5302 +
5303 +
5304 /* you should not found any 8185 Ver B Card */
5305 priv->card_8185_Bversion = 0;
5306 -
5307 +
5308 config3 = read_nic_byte(dev, CONFIG3);
5309 if(config3 & 0x8){
5310 priv->card_type = CARDBUS;
5311 @@ -2162,13 +2205,13 @@
5312 priv->plcp_preamble_mode = 2;
5313  
5314  
5315 -
5316 +
5317 /* commented out just because we already do
5318 this when resetting the card
5319 andrea 20050924
5320 */
5321 #if 0
5322 -
5323 +
5324 u8 txcr, txreg50;
5325 u32 txreg54, txreg60;
5326  
5327 @@ -2204,8 +2247,8 @@
5328 // DMESG("<<txcr:%x>>", txcr);
5329  
5330 #endif
5331 -
5332 - /*the eeprom type is stored in RCR register bit #6 */
5333 +
5334 + /*the eeprom type is stored in RCR register bit #6 */
5335 if (RCR_9356SEL & read_nic_dword(dev, RCR)){
5336 priv->epromtype=EPROM_93c56;
5337 DMESG("Reported EEPROM chip is a 93c56 (2Kbit)");
5338 @@ -2213,58 +2256,67 @@
5339 priv->epromtype=EPROM_93c46;
5340 DMESG("Reported EEPROM chip is a 93c46 (1Kbit)");
5341 }
5342 -
5343 +
5344 dev->get_stats = rtl8180_stats;
5345 -
5346 +
5347 dev->dev_addr[0]=eprom_read(dev,MAC_ADR) & 0xff;
5348 dev->dev_addr[1]=(eprom_read(dev,MAC_ADR) & 0xff00)>>8;
5349 dev->dev_addr[2]=eprom_read(dev,MAC_ADR+1) & 0xff;
5350 dev->dev_addr[3]=(eprom_read(dev,MAC_ADR+1) & 0xff00)>>8;
5351 dev->dev_addr[4]=eprom_read(dev,MAC_ADR+2) & 0xff;
5352 dev->dev_addr[5]=(eprom_read(dev,MAC_ADR+2) & 0xff00)>>8;
5353 -
5354 +
5355 DMESG("Card MAC address is "MAC_FMT, MAC_ARG(dev->dev_addr));
5356 -
5357 +
5358 for(i=1,j=0; i<6; i+=2,j++){
5359 -
5360 +
5361 word = eprom_read(dev,EPROM_TXPW0 + j);
5362 priv->chtxpwr[i]=word & 0xf;
5363 priv->chtxpwr_ofdm[i]=(word & 0xf0)>>4;
5364 priv->chtxpwr[i+1]=(word & 0xf00)>>8;
5365 priv->chtxpwr_ofdm[i+1]=(word & 0xf000)>>12;
5366 }
5367 -
5368 +
5369 for(i=1,j=0; i<4; i+=2,j++){
5370 -
5371 +
5372 word = eprom_read(dev,EPROM_TXPW1 + j);
5373 priv->chtxpwr[i+6]=word & 0xf;
5374 priv->chtxpwr_ofdm[i+6]=(word & 0xf0)>>4;
5375 priv->chtxpwr[i+6+1]=(word & 0xf00)>>8;
5376 priv->chtxpwr_ofdm[i+6+1]=(word & 0xf000)>>12;
5377 }
5378 -
5379 +
5380 for(i=1,j=0; i<4; i+=2,j++){
5381 -
5382 +
5383 word = eprom_read(dev,EPROM_TXPW2 + j);
5384 priv->chtxpwr[i+6+4]=word & 0xf;
5385 priv->chtxpwr_ofdm[i+6+4]=(word & 0xf0)>>4;
5386 priv->chtxpwr[i+6+4+1]=(word & 0xf00)>>8;
5387 priv->chtxpwr_ofdm[i+6+4+1]=(word & 0xf000)>>12;
5388 }
5389 -
5390 -
5391 +
5392 +
5393 priv->rf_chip = 0xff & eprom_read(dev,EPROM_RFCHIPID);
5394 -
5395 +
5396 word = eprom_read(dev,EPROM_TXPW_BASE);
5397 priv->cck_txpwr_base = word & 0xf;
5398 priv->ofdm_txpwr_base = (word>>4) & 0xf;
5399 -
5400 +
5401 + priv->txpwr_max = 0;
5402 + for(i=1; i<15; i++)
5403 + {
5404 + if(priv->chtxpwr[i] > priv->txpwr_max) priv->txpwr_max = priv->chtxpwr[i];
5405 + if(priv->chtxpwr_ofdm[i] > priv->txpwr_max) priv->txpwr_max = priv->chtxpwr_ofdm[i];
5406 + priv->chtxpwr_orig[i] = priv->chtxpwr[i];
5407 + priv->chtxpwr_ofdm_orig[i] = priv->chtxpwr_ofdm[i];
5408 + }
5409 +
5410 /* check RF frontend chipset */
5411 -
5412 +
5413 switch (priv->rf_chip) {
5414 -
5415 +
5416 case EPROM_RFCHIPID_RTL8225U:
5417 -
5418 +
5419 DMESG("Card reports RF frontend Realtek 8225");
5420 DMESGW("This driver has EXPERIMENTAL support for this chipset.");
5421 DMESGW("use it with care and at your own risk and");
5422 @@ -2283,30 +2335,30 @@
5423 DMESG("This seems a legacy 1st version radio");
5424 }
5425 priv->rf_close = rtl8225_rf_close;
5426 -
5427 +
5428 priv->max_sens = RTL8225_RF_MAX_SENS;
5429 priv->sens = RTL8225_RF_DEF_SENS;
5430 break;
5431 -
5432 +
5433 default:
5434 DMESGW("Unknown RF module %x",priv->rf_chip);
5435 DMESGW("Exiting...");
5436 return -1;
5437 -
5438 +
5439 }
5440  
5441 InitSwLeds(dev);
5442 -
5443 +
5444 // DMESG("Energy threshold: %x",priv->cs_treshold);
5445 DMESG("PAPE from CONFIG2: %x",read_nic_byte(dev,CONFIG2)&0x7);
5446 //DMESG("CONFIG2: %x ECONFIG2: %x",read_nic_byte(dev,CONFIG2),eprom_read(dev,EPROM_CONFIG2));
5447 -
5448 - if(rtl8187_usb_initendpoints(dev)!=0){
5449 +
5450 + if(rtl8187_usb_initendpoints(dev)!=0){
5451 DMESG("Endopoints initialization failed");
5452 return -ENOMEM;
5453 }
5454 -#if 0
5455 - if (0!=alloc_rx_desc_ring(dev, priv->rxbuffersize, priv->rxringcount))
5456 +#if 0
5457 + if (0!=alloc_rx_desc_ring(dev, priv->rxbuffersize, priv->rxringcount))
5458 return -ENOMEM;
5459  
5460 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
5461 @@ -2320,16 +2372,16 @@
5462 if (0!=alloc_tx_desc_ring(dev, priv->txbuffsize, priv->txringcount,
5463 TX_LOWPRIORITY_RING_ADDR))
5464 return -ENOMEM;
5465 -
5466 -
5467 +
5468 +
5469 if (0!=alloc_tx_beacon_desc_ring(dev, priv->txbeaconcount))
5470 return -ENOMEM;
5471 #endif
5472 -
5473 +
5474  
5475 #ifdef DEBUG_EPROM
5476 dump_eprom(dev);
5477 -#endif
5478 +#endif
5479 return 0;
5480  
5481 }
5482 @@ -2349,7 +2401,7 @@
5483 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
5484  
5485 conf3 = read_nic_byte(dev, CONFIG3);
5486 - write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
5487 + write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
5488  
5489 write_nic_dword(dev, ANAPARAM2, a);
5490  
5491 @@ -2369,23 +2421,23 @@
5492  
5493 conf3 = read_nic_byte(dev, CONFIG3);
5494 write_nic_byte(dev, CONFIG3, conf3 | (1<<CONFIG3_ANAPARAM_W_SHIFT));
5495 -
5496 +
5497 write_nic_dword(dev, ANAPARAM, a);
5498  
5499 conf3 = read_nic_byte(dev, CONFIG3);
5500 write_nic_byte(dev, CONFIG3, conf3 &~(1<<CONFIG3_ANAPARAM_W_SHIFT));
5501  
5502 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
5503 -
5504 +
5505 }
5506  
5507  
5508 void rtl8185_tx_antenna(struct net_device *dev, u8 ant)
5509 {
5510 - write_nic_byte(dev, TX_ANTENNA, ant);
5511 + write_nic_byte(dev, TX_ANTENNA, ant);
5512 force_pci_posting(dev);
5513 mdelay(1);
5514 -}
5515 +}
5516  
5517  
5518 void rtl8187_write_phy(struct net_device *dev, u8 adr, u32 data)
5519 @@ -2393,26 +2445,26 @@
5520 //u8 phyr;
5521 u32 phyw;
5522 // int i;
5523 -
5524 +
5525 adr |= 0x80;
5526 -
5527 +
5528 phyw= ((data<<8) | adr);
5529 -
5530 -
5531 -
5532 - // Note that, we must write 0xff7c after 0x7d-0x7f to write BB register.
5533 +
5534 +
5535 +
5536 + // Note that, we must write 0xff7c after 0x7d-0x7f to write BB register.
5537 write_nic_byte(dev, 0x7f, ((phyw & 0xff000000) >> 24));
5538 write_nic_byte(dev, 0x7e, ((phyw & 0x00ff0000) >> 16));
5539 write_nic_byte(dev, 0x7d, ((phyw & 0x0000ff00) >> 8));
5540 write_nic_byte(dev, 0x7c, ((phyw & 0x000000ff) ));
5541  
5542 //read_nic_dword(dev, PHY_ADR);
5543 -#if 0
5544 +#if 0
5545 for(i=0;i<10;i++){
5546 write_nic_dword(dev, PHY_ADR, 0xffffff7f & phyw);
5547 phyr = read_nic_byte(dev, PHY_READ);
5548 if(phyr == (data&0xff)) break;
5549 -
5550 +
5551 }
5552 #endif
5553 /* this is ok to fail when we write AGC table. check for AGC table might be
5554 @@ -2442,26 +2494,26 @@
5555 struct r8180_priv *priv = ieee80211_priv(dev);
5556 //u32 anaparam;
5557 //u8 config3;
5558 -
5559 +
5560 //rtl8180_rtx_disable(dev);
5561 rtl8180_reset(dev);
5562  
5563 write_nic_byte(dev,0x85,0);
5564 write_nic_byte(dev,0x91,0);
5565 -
5566 +
5567 /* light blink! */
5568 write_nic_byte(dev,0x85,4);
5569 LedControl8187(dev, LED_CTL_POWER_ON);
5570 //write_nic_byte(dev,0x91,1);
5571 //write_nic_byte(dev,0x90,0);
5572 -
5573 +
5574 priv->irq_mask = 0xffff;
5575 /*
5576 priv->dma_poll_mask = 0;
5577 priv->dma_poll_mask|= (1<<TX_DMA_STOP_BEACON_SHIFT);
5578 -*/
5579 +*/
5580 // rtl8180_beacon_tx_disable(dev);
5581 -
5582 +
5583 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
5584 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
5585 write_nic_word(dev, MAC4, ((u32*)dev->dev_addr)[1] & 0xffff );
5586 @@ -2469,32 +2521,32 @@
5587 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
5588 rtl8180_update_msr(dev);
5589  
5590 -/*
5591 +/*
5592 rtl8180_set_mode(dev, EPROM_CMD_CONFIG);
5593 -
5594 +
5595 write_nic_word(dev,0xf4,0xffff);
5596 write_nic_byte(dev,
5597 - CONFIG1, (read_nic_byte(dev,CONFIG1) & 0x3f) | 0x80);
5598 + CONFIG1, (read_nic_byte(dev,CONFIG1) & 0x3f) | 0x80);
5599  
5600 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
5601 */
5602 - write_nic_dword(dev,INT_TIMEOUT,0);
5603 + write_nic_dword(dev,INT_TIMEOUT,0);
5604  
5605 #ifdef DEBUG_REGISTERS
5606 - rtl8180_dump_reg(dev);
5607 + rtl8180_dump_reg(dev);
5608 #endif
5609 -
5610 -
5611 - write_nic_byte(dev, WPA_CONFIG, 0);
5612 +
5613 +
5614 + write_nic_byte(dev, WPA_CONFIG, 0);
5615  
5616 write_nic_byte(dev, RATE_FALLBACK, 0x81);
5617 rtl8187_set_rate(dev);
5618 -
5619 - priv->rf_init(dev);
5620 +
5621 + priv->rf_init(dev);
5622  
5623 if(priv->rf_set_sens != NULL)
5624 - priv->rf_set_sens(dev,priv->sens);
5625 -
5626 + priv->rf_set_sens(dev,priv->sens);
5627 +
5628 write_nic_word(dev,0x5e,1);
5629  
5630 #if 1
5631 @@ -2510,13 +2562,13 @@
5632  
5633 //add for Led controll
5634 write_nic_byte(dev,0x85,4);
5635 -
5636 -
5637 +
5638 +
5639 rtl8180_irq_enable(dev);
5640 /*DMESG ("lfree %d",get_curr_tx_free_desc(dev,LOW_PRIORITY));
5641 -
5642 +
5643 DMESG ("nfree %d",get_curr_tx_free_desc(dev,NORM_PRIORITY));
5644 -
5645 +
5646 DMESG ("hfree %d",get_curr_tx_free_desc(dev,HI_PRIORITY));
5647 if(check_nic_enought_desc(dev,NORM_PRIORITY)) DMESG("NORM OK");
5648 if(check_nic_enought_desc(dev,HI_PRIORITY)) DMESG("HI OK");
5649 @@ -2534,7 +2586,7 @@
5650 {
5651 int i;
5652 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
5653 - u16 word;
5654 + u16 word;
5655 DMESG("Enabling beacon TX");
5656 //write_nic_byte(dev, 0x42,0xe6);// TCR
5657 //rtl8180_init_beacon(dev);
5658 @@ -2547,41 +2599,41 @@
5659 //write_nic_word(dev,0x7a,0);
5660 //write_nic_word(dev,0x7a,0x8000);
5661  
5662 -
5663 +
5664 word = read_nic_word(dev, BcnItv);
5665 word &= ~BcnItv_BcnItv; // clear Bcn_Itv
5666 write_nic_word(dev, BcnItv, word);
5667  
5668 - write_nic_word(dev, AtimWnd,
5669 + write_nic_word(dev, AtimWnd,
5670 read_nic_word(dev, AtimWnd) &~ AtimWnd_AtimWnd);
5671 -
5672 +
5673 word = read_nic_word(dev, BintrItv);
5674 word &= ~BintrItv_BintrItv;
5675 -
5676 - //word |= priv->ieee80211->beacon_interval *
5677 +
5678 + //word |= priv->ieee80211->beacon_interval *
5679 // ((priv->txbeaconcount > 1)?(priv->txbeaconcount-1):1);
5680 // FIXME:FIXME check if correct ^^ worked with 0x3e8;
5681 -
5682 +
5683 write_nic_word(dev, BintrItv, word);
5684 -
5685 +
5686 //write_nic_word(dev,0x2e,0xe002);
5687 //write_nic_dword(dev,0x30,0xb8c7832e);
5688 for(i=0; i<ETH_ALEN; i++)
5689 write_nic_byte(dev, BSSID+i, priv->ieee80211->beacon_cell_ssid[i]);
5690 -
5691 +
5692 // rtl8180_update_msr(dev);
5693  
5694 -
5695 +
5696 //write_nic_byte(dev,CONFIG4,3); /* !!!!!!!!!! */
5697 -
5698 +
5699 rtl8180_set_mode(dev, EPROM_CMD_NORMAL);
5700 -
5701 +
5702 rtl8180_irq_enable(dev);
5703 -
5704 +
5705 /* VV !!!!!!!!!! VV*/
5706 /*
5707 rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
5708 - write_nic_byte(dev,0x9d,0x00);
5709 + write_nic_byte(dev,0x9d,0x00);
5710 rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
5711 */
5712 }
5713 @@ -2592,7 +2644,7 @@
5714 static struct net_device_stats *rtl8180_stats(struct net_device *dev)
5715 {
5716 struct r8180_priv *priv = ieee80211_priv(dev);
5717 -
5718 +
5719 return &priv->ieee80211->stats;
5720 }
5721  
5722 @@ -2602,20 +2654,20 @@
5723 struct r8180_priv *priv = ieee80211_priv(dev);
5724  
5725 priv->up=1;
5726 -
5727 +
5728 //DMESG("Bringing up iface");
5729  
5730 rtl8180_adapter_start(dev);
5731  
5732 -
5733 +
5734 rtl8180_rx_enable(dev);
5735  
5736 rtl8180_tx_enable(dev);
5737 -
5738 +
5739 ieee80211_softmac_start_protocol(priv->ieee80211);
5740  
5741 //LedControl8187(dev, LED_CTL_SITE_SURVEY);
5742 -
5743 +
5744 ieee80211_reset_queue(priv->ieee80211);
5745 if(!netif_queue_stopped(dev))
5746 netif_start_queue(dev);
5747 @@ -2630,12 +2682,12 @@
5748 {
5749 struct r8180_priv *priv = ieee80211_priv(dev);
5750 int ret;
5751 -
5752 +
5753 down(&priv->wx_sem);
5754 ret = rtl8180_up(dev);
5755 up(&priv->wx_sem);
5756 return ret;
5757 -
5758 +
5759 }
5760  
5761  
5762 @@ -2644,7 +2696,7 @@
5763 struct r8180_priv *priv = ieee80211_priv(dev);
5764  
5765 if (priv->up == 1) return -1;
5766 -
5767 +
5768 return _rtl8180_up(dev);
5769 }
5770  
5771 @@ -2653,15 +2705,15 @@
5772 {
5773 struct r8180_priv *priv = ieee80211_priv(dev);
5774 int ret;
5775 -
5776 +
5777 down(&priv->wx_sem);
5778 -
5779 +
5780 ret = rtl8180_down(dev);
5781 -
5782 +
5783 LedControl8187(dev, LED_CTL_NO_LINK);
5784 -
5785 +
5786 up(&priv->wx_sem);
5787 -
5788 +
5789 return ret;
5790  
5791 }
5792 @@ -2671,18 +2723,18 @@
5793 struct r8180_priv *priv = ieee80211_priv(dev);
5794  
5795 if (priv->up == 0) return -1;
5796 -
5797 +
5798 priv->up=0;
5799  
5800 /* FIXME */
5801 if (!netif_queue_stopped(dev))
5802 netif_stop_queue(dev);
5803 -
5804 +
5805 rtl8180_rtx_disable(dev);
5806 rtl8180_irq_disable(dev);
5807  
5808 ieee80211_softmac_stop_protocol(priv->ieee80211);
5809 -
5810 +
5811 return 0;
5812 }
5813  
5814 @@ -2692,7 +2744,7 @@
5815 struct r8180_priv *priv = ieee80211_priv(dev);
5816  
5817 if (priv->up == 0) return ;
5818 -
5819 +
5820 ieee80211_softmac_stop_protocol(priv->ieee80211);
5821 sema_init(&priv->power_sem,1);
5822 //printk(KERN_WARNING "priv->power_semb %d!\n",priv->power_sem);
5823 @@ -2701,14 +2753,20 @@
5824 _rtl8180_up(dev);
5825 }
5826  
5827 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
5828 +void rtl8180_restart(struct work_struct *work)
5829 +{
5830 + struct r8180_priv *priv = container_of(work, struct r8180_priv, reset_wq);
5831 + struct net_device *dev = priv->dev;
5832 +#else
5833 void rtl8180_restart(struct net_device *dev)
5834 {
5835 struct r8180_priv *priv = ieee80211_priv(dev);
5836 -
5837 +#endif
5838 down(&priv->wx_sem);
5839 -
5840 +
5841 rtl8180_commit(dev);
5842 -
5843 +
5844 up(&priv->wx_sem);
5845 }
5846  
5847 @@ -2718,16 +2776,16 @@
5848 short promisc;
5849  
5850 //down(&priv->wx_sem);
5851 -
5852 +
5853 /* FIXME FIXME */
5854 -
5855 +
5856 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
5857 -
5858 +
5859 if (promisc != priv->promisc)
5860 // rtl8180_commit(dev);
5861 -
5862 +
5863 priv->promisc = promisc;
5864 -
5865 +
5866 //schedule_work(&priv->reset_wq);
5867 //up(&priv->wx_sem);
5868 }
5869 @@ -2737,15 +2795,15 @@
5870 {
5871 struct r8180_priv *priv = ieee80211_priv(dev);
5872 struct sockaddr *addr = mac;
5873 -
5874 +
5875 down(&priv->wx_sem);
5876 -
5877 +
5878 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
5879 -
5880 +
5881 schedule_work(&priv->reset_wq);
5882 -
5883 +
5884 up(&priv->wx_sem);
5885 -
5886 +
5887 return 0;
5888 }
5889  
5890 @@ -2758,8 +2816,8 @@
5891 int ret=-1;
5892  
5893 down(&priv->wx_sem);
5894 -
5895 -
5896 +
5897 +
5898 switch (cmd) {
5899 case RTL_IOCTL_WPA_SUPPLICANT:
5900 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
5901 @@ -2771,7 +2829,7 @@
5902 }
5903  
5904 up(&priv->wx_sem);
5905 -
5906 +
5907 return ret;
5908 }
5909  
5910 @@ -2792,9 +2850,9 @@
5911 //u32 *desc;
5912 u8 *desc;
5913 u8 signal,quality,rate;
5914 -
5915 +
5916 //DMESG("rtl8187_rx_isr");
5917 -
5918 +
5919 struct ieee80211_rx_stats stats = {
5920 .signal = 0,
5921 .noise = -98,
5922 @@ -2803,31 +2861,31 @@
5923 .freq = IEEE80211_24GHZ_BAND,
5924 };
5925  
5926 -
5927 +
5928 //DMESG("RX %d ",rx_urb->status);
5929 status = rx_urb->status;
5930 if(status == 0){
5931 -
5932 +
5933 len = rx_urb->actual_length;
5934 - // len = len - 4 - 15 - 1; /* CRC, DESC, SEPARATOR*/
5935 + // len = len - 4 - 15 - 1; /* CRC, DESC, SEPARATOR*/
5936 len -= 4*4;/* 4 dword and 4 byte CRC */
5937 -#if 0
5938 +#if 0
5939 desc = (u32*)(rx_urb->transfer_buffer + len);
5940 -
5941 +
5942 flen = desc[0] & 0xfff;
5943 -
5944 +
5945 if( flen <= rx_urb->actual_length){
5946 -
5947 +
5948 //stats.signal = (desc[1] & 0x7f00)>>8;
5949 //stats.noise = desc[1] &0xff;
5950 signal=(desc[1]& (0xff0000))>>16;
5951 signal=(signal&0xfe)>>1; // Modify by hikaru 6.6
5952 -
5953 +
5954 quality=(desc[1] & (0xff));
5955 -
5956 +
5957 rate=(desc[0] &((1<<23)|(1<<22)|(1<<21)|(1<<20)))>>20;
5958 - // printk(KERN_INFO "rate is %d!\n",rate);
5959 - stats.rate = rtl8180_rate2rate(rate);
5960 + // printk(KERN_INFO "rate is %d!\n",rate);
5961 + stats.rate = rtl8180_rate2rate(rate);
5962 // printk(KERN_INFO "stats.rate is %d!\n",stats.rate);
5963 //stats.rate = desc[0] >> 20 & 0xf;
5964 stats.mac_time[0] = desc[2];
5965 @@ -2835,35 +2893,35 @@
5966 #endif
5967  
5968 desc = rx_urb->transfer_buffer + len;
5969 -
5970 +
5971 flen = ((desc[1] & 0x0f) << 8) + (desc[0] & 0xff);
5972 -
5973 +
5974 if( flen <= rx_urb->actual_length){
5975 -
5976 +
5977 //stats.signal = (desc[1] & 0x7f00)>>8;
5978 //stats.noise = desc[1] &0xff;
5979 signal=(desc[6]& 0xfe)>>1;
5980 //signal=(signal&0xfe)>>1; // Modify by hikaru 6.6
5981 -
5982 +
5983 quality=desc[4] & 0xff;
5984 -
5985 +
5986 //rate=(desc[2] &((1<<7)|(1<<6)|(1<<5)|(1<<4)))>>4;
5987 rate=(desc[2] & 0xf0)>>4;
5988 - // printk(KERN_INFO "rate is %d!\n",rate);
5989 - stats.rate = rtl8180_rate2rate(rate);
5990 + // printk(KERN_INFO "rate is %d!\n",rate);
5991 + stats.rate = rtl8180_rate2rate(rate);
5992 // printk(KERN_INFO "stats.rate is %d!\n",stats.rate);
5993 //stats.rate = desc[0] >> 20 & 0xf;
5994 - stats.mac_time[0] = desc[8] + (desc[9]<<8) + (desc[10]<<16) + (desc[11]<<24);
5995 - stats.mac_time[1] = desc[12] + (desc[13]<<8) + (desc[14]<<16) + (desc[15]<<24);
5996 + stats.mac_time[0] = desc[8] + (desc[9]<<8) + (desc[10]<<16) + (desc[11]<<24);
5997 + stats.mac_time[1] = desc[12] + (desc[13]<<8) + (desc[14]<<16) + (desc[15]<<24);
5998 +
5999  
6000 -
6001 //calculate link quality begin
6002 - if(!rtl8180_IsWirelessBMode(stats.rate) )
6003 + if(!rtl8180_IsWirelessBMode(stats.rate) )
6004 { // OFDM rate.
6005 if(signal>90)
6006 signal=90;
6007 else if(signal<25)
6008 - signal=25;
6009 + signal=25;
6010 signal = (90-signal)*100/65;
6011 }
6012 else
6013 @@ -2871,7 +2929,7 @@
6014 if(signal>95)
6015 signal = 95;
6016 else if(signal<30)
6017 - signal = 30;
6018 + signal = 30;
6019 signal =(95-signal )*100/65;
6020 }
6021 priv->wstats.qual.level = signal;
6022 @@ -2879,30 +2937,35 @@
6023 if(quality > 64)
6024 priv ->wstats.qual.qual = 0;
6025 else
6026 - priv ->wstats.qual.qual = ((64-quality) * 100) / 64; // SQ value is the SIGNAL_QUALITY returned to IORequest,
6027 - //and this value only appear when STA is associated to AP or
6028 + priv ->wstats.qual.qual = ((64-quality) * 100) / 64; // SQ value is the SIGNAL_QUALITY returned to IORequest,
6029 + //and this value only appear when STA is associated to AP or
6030 // STA is in IBSS mode
6031 // printk(KERN_INFO "quality is %d!\n",priv->wstats.qual.qual);
6032 priv->wstats.qual.noise = 100 - priv ->wstats.qual.qual;
6033 priv->wstats.qual.updated = 7;
6034 - //calculate link quality end
6035 + if(priv->ieee80211->iw_mode == IW_MODE_MONITOR)
6036 + {
6037 + stats.signal = priv->wstats.qual.level;
6038 + stats.noise = priv->wstats.qual.noise;
6039 + }
6040 + //calculate link quality end
6041 skb = dev_alloc_skb(flen-4);
6042 - if(skb){
6043 + if(skb){
6044 memcpy(skb_put(skb,flen-4),
6045 rx_urb->transfer_buffer,flen -4);
6046 -
6047 +
6048 #ifdef DUMP_RX
6049 int i;
6050 for(i=0;i<flen-4;i++)
6051 printk("%2x ",((u8*)(rx_urb->transfer_buffer))[i]);
6052 printk("------RATE %x:w---------------\n",stats.rate);
6053 -
6054 +
6055 #endif
6056 priv->stats.rxok++;
6057 // priv->rxskb = skb;
6058 // priv->tempstats = &stats;
6059  
6060 - if(!ieee80211_rx(priv->ieee80211,
6061 + if(!ieee80211_rx(priv->ieee80211,
6062 skb, &stats))
6063 dev_kfree_skb_any(skb);
6064 }
6065 @@ -2913,7 +2976,7 @@
6066 }
6067  
6068 //LedControl8187(dev, LED_CTL_RX);
6069 -
6070 +
6071 if(status != -ENOENT)rtl8187_rx_urbsubmit(dev,rx_urb);
6072 else DMESG("RX process aborted due to explicit shutdown");
6073 }
6074 @@ -2931,20 +2994,20 @@
6075 struct r8180_priv *priv= NULL;
6076 struct usb_device *udev = interface_to_usbdev(intf);
6077  
6078 -printk(KERN_WARNING "===> rtl8187_usb_probe()\n");
6079 -
6080 +printk(KERN_WARNING "===> rtl8187_usb_probe()\n");
6081 +
6082 dev = alloc_ieee80211(sizeof(struct r8180_priv));
6083 -
6084 +
6085 SET_MODULE_OWNER(dev);
6086 - usb_set_intfdata(intf, dev);
6087 -
6088 + usb_set_intfdata(intf, dev);
6089 +
6090 SET_NETDEV_DEV(dev, &intf->dev);
6091  
6092 priv = ieee80211_priv(dev);
6093 priv->ieee80211 = netdev_priv(dev);
6094 -
6095 +
6096 priv->udev=udev;
6097 -
6098 +
6099 dev->open = rtl8180_open;
6100 dev->stop = rtl8180_close;
6101 //dev->hard_start_xmit = rtl8180_8023_hard_start_xmit;
6102 @@ -2953,41 +3016,46 @@
6103 dev->do_ioctl = rtl8180_ioctl;
6104 dev->set_multicast_list = r8180_set_multicast;
6105 dev->set_mac_address = r8180_set_mac_adr;
6106 +#if WIRELESS_EXT >= 12
6107 +#if WIRELESS_EXT < 17
6108 dev->get_wireless_stats = r8180_get_wireless_stats;
6109 +#endif
6110 + dev->wireless_handlers = (struct iw_handler_def *) &r8180_wx_handlers_def;
6111 +#endif
6112 dev->type=ARPHRD_ETHER;
6113 -
6114 +
6115 if (dev_alloc_name(dev, ifname) < 0){
6116 DMESG("Oops: devname already taken! Trying wlan%%d...\n");
6117 ifname = "wlan%d";
6118 dev_alloc_name(dev, ifname);
6119 }
6120 -
6121 +
6122 // dev->open=rtl8180_init;
6123 -
6124 - if(rtl8180_init(dev)!=0){
6125 +
6126 + if(rtl8180_init(dev)!=0){
6127 DMESG("Initialization failed");
6128 goto fail;
6129 }
6130 -
6131 +
6132 netif_carrier_off(dev);
6133 netif_stop_queue(dev);
6134 -
6135 +
6136 register_netdev(dev);
6137 -
6138 +
6139 rtl8180_proc_init_one(dev);
6140  
6141 -
6142 +
6143 DMESG("Driver probe completed\n");
6144 - return 0;
6145 + return 0;
6146 +
6147  
6148 -
6149 fail:
6150 free_ieee80211(dev);
6151 -
6152 +
6153 DMESG("wlan driver load failed\n");
6154 -
6155 +
6156 return -ENODEV;
6157 -
6158 +
6159 }
6160  
6161  
6162 @@ -2996,13 +3064,13 @@
6163 struct r8180_priv *priv;
6164 struct net_device *dev = usb_get_intfdata(intf);
6165 if(dev){
6166 -
6167 +
6168 unregister_netdev(dev);
6169 -
6170 +
6171 priv=ieee80211_priv(dev);
6172 -
6173 +
6174 rtl8180_proc_remove_one(dev);
6175 -
6176 +
6177 rtl8180_down(dev);
6178 priv->rf_close(dev);
6179 //rtl8180_rtx_disable(dev);
6180 @@ -3046,11 +3114,11 @@
6181 unsigned long flags;
6182 short enough_desc;
6183 struct r8180_priv *priv = (struct r8180_priv *)ieee80211_priv(dev);
6184 -
6185 +
6186 spin_lock_irqsave(&priv->tx_lock,flags);
6187 enough_desc = check_nic_enought_desc(dev,pri);
6188 - spin_unlock_irqrestore(&priv->tx_lock,flags);
6189 -
6190 + spin_unlock_irqrestore(&priv->tx_lock,flags);
6191 +
6192 if(enough_desc)
6193 ieee80211_wake_queue(priv->ieee80211);
6194 }
6195 diff -Naur r8187_orig/rtl8187/r8187.h r8187_rawtx/rtl8187/r8187.h
6196 --- r8187_orig/rtl8187/r8187.h 2007-12-05 04:22:20.000000000 +0100
6197 +++ r8187_rawtx/rtl8187/r8187.h 2007-05-16 21:51:38.000000000 +0200
6198 @@ -1,17 +1,17 @@
6199 -/*
6200 +/*
6201 This is part of rtl8187 OpenSource driver.
6202 - Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
6203 + Copyright (C) Andrea Merello 2004-2005 <andreamrl@tiscali.it>
6204 Released under the terms of GPL (General Public Licence)
6205 -
6206 - Parts of this driver are based on the GPL part of the
6207 +
6208 + Parts of this driver are based on the GPL part of the
6209 official realtek driver
6210 -
6211 - Parts of this driver are based on the rtl8180 driver skeleton
6212 +
6213 + Parts of this driver are based on the rtl8180 driver skeleton
6214 from Patric Schenke & Andres Salomon
6215 -
6216 +
6217 Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver
6218 -
6219 - We want to tanks the Authors of those projects and the Ndiswrapper
6220 +
6221 + We want to tanks the Authors of those projects and the Ndiswrapper
6222 project Authors.
6223 */
6224  
6225 @@ -26,7 +26,6 @@
6226  
6227 #include <linux/module.h>
6228 #include <linux/kernel.h>
6229 -#include <linux/config.h>
6230 #include <linux/init.h>
6231 #include <linux/ioport.h>
6232 #include <linux/sched.h>
6233 @@ -47,6 +46,12 @@
6234 #include <asm/io.h>
6235 #include <asm/semaphore.h>
6236  
6237 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
6238 +#include <linux/config.h>
6239 +#else
6240 +#include <linux/autoconf.h>
6241 +#endif
6242 +
6243 #include "ieee80211.h"
6244 #include "r8187_led.h"
6245 #include "r8180_hw.h"
6246 @@ -74,7 +79,7 @@
6247 {
6248 struct buffer *next;
6249 u32 *buf;
6250 -
6251 +
6252 } buffer;
6253  
6254 #if 0
6255 @@ -123,7 +128,7 @@
6256 unsigned long txdatapkt;
6257 unsigned long rxok;
6258 unsigned long rxretry;//retry number tony 20060601
6259 - unsigned long rxcrcerrmin;//crc error (0-500)
6260 + unsigned long rxcrcerrmin;//crc error (0-500)
6261 unsigned long rxcrcerrmid;//crc error (500-1000)
6262 unsigned long rxcrcerrmax;//crc error (>1000)
6263 unsigned long rxicverr;//ICV error
6264 @@ -142,7 +147,7 @@
6265 short epromtype;
6266 int irq;
6267 struct ieee80211_device *ieee80211;
6268 -
6269 +
6270 short card_8185; /* O: rtl8180, 1:rtl8185 V B/C, 2:rtl8185 V D */
6271 short card_8185_Bversion; /* if TCR reports card V B/C this discriminates */
6272 short phy_ver; /* meaningful for rtl8225 1:A 2:B 3:C */
6273 @@ -151,12 +156,12 @@
6274 short hw_plcp_len;
6275 short plcp_preamble_mode; // 0:auto 1:short 2:long
6276  
6277 -
6278 +
6279 // spinlock_t irq_lock;
6280 // spinlock_t irq_th_lock;
6281 spinlock_t tx_lock;
6282 spinlock_t ps_lock;
6283 -
6284 +
6285 u16 irq_mask;
6286 // short irq_enabled;
6287 struct net_device *dev;
6288 @@ -165,17 +170,20 @@
6289 short max_sens;
6290 u8 chtxpwr[15]; //channels from 1 to 14, 0 not used
6291 u8 chtxpwr_ofdm[15]; //channels from 1 to 14, 0 not used
6292 + u8 chtxpwr_orig[15]; //channels from 1 to 14, 0 not used
6293 + u8 chtxpwr_ofdm_orig[15]; //channels from 1 to 14, 0 not used
6294 u8 cck_txpwr_base;
6295 u8 ofdm_txpwr_base;
6296 + u8 txpwr_max;
6297 u8 challow[15]; //channels from 1 to 14, 0 not used
6298 u8 channel_plan; // it's the channel plan index
6299  
6300 short up;
6301 short crcmon; //if 1 allow bad crc frame reception in monitor mode
6302 -// short prism_hdr;
6303 + short prism_hdr;
6304 struct timer_list ps_timer;
6305 short PS_timeout;//when ps set on ,if tx timeout ,this will be set 1
6306 -
6307 +
6308 // struct timer_list scan_timer;
6309 /*short scanpending;
6310 short stopscan;*/
6311 @@ -185,7 +193,7 @@
6312 struct semaphore wx_sem;
6313 struct semaphore power_sem;
6314 // short hw_wep;
6315 -
6316 +
6317 // short digphy;
6318 // short antb;
6319 // short diversity;
6320 @@ -200,12 +208,12 @@
6321 void (*rf_wakeup)(struct net_device *dev);
6322 void (*rf_sleep)(struct net_device *dev);
6323 //short rate;
6324 - short promisc;
6325 + short promisc;
6326 /*stats*/
6327 struct Stats stats;
6328 struct iw_statistics wstats;
6329 struct proc_dir_entry *dir_dev;
6330 -
6331 +
6332 /*RX stuff*/
6333 // u32 *rxring;
6334 // u32 *rxringtail;
6335 @@ -213,20 +221,20 @@
6336 struct urb **rx_urb;
6337 struct tx_urb_context tx_context[MAX_TX_URB];
6338 short tx_urb_index;
6339 -
6340 +
6341 //struct buffer *rxbuffer;
6342 //struct buffer *rxbufferhead;
6343 //int rxringcount;
6344 //u16 rxbuffersize;
6345 -
6346 - //struct sk_buff *rx_skb;
6347 +
6348 + //struct sk_buff *rx_skb;
6349  
6350 //short rx_skb_complete;
6351  
6352 //u32 rx_prevlen;
6353 atomic_t tx_lp_pending;
6354 atomic_t tx_np_pending;
6355 -#if 0
6356 +#if 0
6357 /*TX stuff*/
6358 u32 *txlpring;
6359 u32 *txhpring;
6360 @@ -256,7 +264,7 @@
6361 struct urb *rxurb_task;
6362 // u8 dma_poll_mask;
6363 //short tx_suspend;
6364 -
6365 +
6366 /* adhoc/master mode stuff */
6367 #if 0
6368 u32 *txbeacontail;
6369 @@ -270,15 +278,20 @@
6370 //u16 master_beaconinterval;
6371 // u32 master_beaconsize;
6372 //u16 beacon_interval;
6373 -
6374 +
6375 u8 retry_data;
6376 u8 retry_rts;
6377 u16 rts;
6378 u8 ps_sleep_finish;//1, finish hw sleep ,0 finish hw wakeup
6379  
6380 -
6381 +
6382 struct work_struct reset_wq;
6383 struct work_struct rtl8180_hw_wakeup_wq;
6384 +// struct work_struct rtl8180_rq_tx_ack_wq;
6385 +// struct work_struct rtl8180_hw_sleep_wq;
6386 +
6387 + struct work_struct SwLed0WorkItemCallback_wq;
6388 +
6389 short ack_tx_to_ieee;
6390  
6391  
6392 @@ -292,15 +305,15 @@
6393 LED_STRATEGY_8187 LedStrategy;
6394 u8 PsrValue;
6395 struct work_struct Gpio0LedWorkItem;
6396 - struct work_struct SwLed0WorkItem;
6397 - struct work_struct SwLed1WorkItem;
6398 -
6399 + struct work_struct SwLed0WorkItem;
6400 + struct work_struct SwLed1WorkItem;
6401 +
6402 }r8180_priv;
6403  
6404  
6405 -typedef enum{
6406 +typedef enum{
6407 LOW_PRIORITY ,
6408 - NORM_PRIORITY
6409 + NORM_PRIORITY
6410 } priority_t;
6411  
6412  
6413 diff -Naur r8187_orig/rtl8187/r8187_led.c r8187_rawtx/rtl8187/r8187_led.c
6414 --- r8187_orig/rtl8187/r8187_led.c 2007-01-15 03:00:37.000000000 +0100
6415 +++ r8187_rawtx/rtl8187/r8187_led.c 2007-05-16 21:51:33.000000000 +0200
6416 @@ -3,35 +3,35 @@
6417  
6418 Module Name:
6419 r8187_led.c
6420 -
6421 +
6422 Abstract:
6423 RTL8187 LED control functions
6424 -
6425 +
6426 Major Change History:
6427 When Who What
6428 ---------- --------------- -------------------------------
6429 2006-09-07 Xiong Created
6430 -
6431 -Notes:
6432 -
6433 +
6434 +Notes:
6435 +
6436 --*/
6437  
6438 /*--------------------------Include File------------------------------------*/
6439 #include "r8180_hw.h"
6440 #include "r8187.h"
6441 -#include "r8180_93cx6.h"
6442 +#include "r8180_93cx6.h"
6443 #include "r8187_led.h"
6444  
6445  
6446 /**
6447 *
6448 -* Initialization function for Sw Leds controll.
6449 -*
6450 +* Initialization function for Sw Leds controll.
6451 +*
6452 * \param dev The net device for this driver.
6453 * \return void.
6454 *
6455 -* Note:
6456 -*
6457 +* Note:
6458 +*
6459 */
6460 void
6461 InitSwLeds(
6462 @@ -49,7 +49,7 @@
6463 DMESG("EEPROM Customer ID: %02X\n", priv->EEPROMCustomerID);
6464  
6465 if(priv->CustomerID == RT_CID_DEFAULT)
6466 - { // If we have not yet change priv->CustomerID in register,
6467 + { // If we have not yet change priv->CustomerID in register,
6468 // we initialzie it from that of EEPROM with proper translation, 2006.07.03, by rcnjko.
6469 switch(priv->EEPROMCustomerID)
6470 {
6471 @@ -57,19 +57,19 @@
6472 case EEPROM_CID_RSVD1:
6473 priv->CustomerID = RT_CID_DEFAULT;
6474 break;
6475 -
6476 +
6477 case EEPROM_CID_ALPHA0:
6478 priv->CustomerID = RT_CID_8187_ALPHA0;
6479 break;
6480 -
6481 +
6482 case EEPROM_CID_SERCOMM_PS:
6483 priv->CustomerID = RT_CID_8187_SERCOMM_PS;
6484 break;
6485 -
6486 +
6487 case EEPROM_CID_HW_LED:
6488 priv->CustomerID = RT_CID_8187_HW_LED;
6489 break;
6490 -
6491 +
6492 default:
6493 // Invalid value, so, we use default value instead.
6494 priv->CustomerID = RT_CID_DEFAULT;
6495 @@ -78,13 +78,13 @@
6496 }
6497 switch(priv->CustomerID)
6498 {
6499 - case RT_CID_DEFAULT:
6500 + case RT_CID_DEFAULT:
6501 priv->LedStrategy = SW_LED_MODE0;
6502 break;
6503 -
6504 +
6505 case RT_CID_8187_ALPHA0:
6506 priv->LedStrategy = SW_LED_MODE1;
6507 - break;
6508 + break;
6509  
6510 case RT_CID_8187_SERCOMM_PS:
6511 priv->LedStrategy = SW_LED_MODE3;
6512 @@ -98,27 +98,39 @@
6513 priv->LedStrategy = SW_LED_MODE0;
6514 break;
6515 }
6516 -
6517 - InitLed8187(dev,
6518 - &(priv->Gpio0Led),
6519 - LED_PIN_GPIO0,
6520 +
6521 + InitLed8187(dev,
6522 + &(priv->Gpio0Led),
6523 + LED_PIN_GPIO0,
6524 Gpio0LedBlinkTimerCallback);
6525 - INIT_WORK(&priv->Gpio0LedWorkItem,
6526 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
6527 + INIT_WORK(&priv->Gpio0LedWorkItem,
6528 (void(*)(void*))Gpio0LedWorkItemCallback, dev);
6529 +#else
6530 + INIT_WORK(&priv->Gpio0LedWorkItem, Gpio0LedWorkItemCallback);
6531 +#endif
6532  
6533 InitLed8187(dev,
6534 - &(priv->SwLed0),
6535 - LED_PIN_LED0,
6536 + &(priv->SwLed0),
6537 + LED_PIN_LED0,
6538 SwLed0BlinkTimerCallback);
6539 - INIT_WORK(&priv->SwLed0WorkItem,
6540 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
6541 + INIT_WORK(&priv->SwLed0WorkItem,
6542 (void(*)(void*))SwLed0WorkItemCallback, dev);
6543 +#else
6544 + INIT_WORK(&priv->SwLed0WorkItem, SwLed0WorkItemCallback);
6545 +#endif
6546  
6547 InitLed8187(dev,
6548 - &(priv->SwLed1),
6549 - LED_PIN_LED1,
6550 + &(priv->SwLed1),
6551 + LED_PIN_LED1,
6552 SwLed1BlinkTimerCallback);
6553 - INIT_WORK(&priv->SwLed1WorkItem,
6554 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
6555 + INIT_WORK(&priv->SwLed1WorkItem,
6556 (void(*)(void*))SwLed1WorkItemCallback, dev);
6557 +#else
6558 + INIT_WORK(&priv->SwLed1WorkItem, SwLed1WorkItemCallback);
6559 +#endif
6560 }
6561  
6562 void
6563 @@ -135,7 +147,7 @@
6564  
6565 void
6566 InitLed8187(
6567 - struct net_device *dev,
6568 + struct net_device *dev,
6569 PLED_8187 pLed,
6570 LED_PIN_8187 LedPin,
6571 void * BlinkCallBackFunc)
6572 @@ -157,7 +169,7 @@
6573  
6574 void
6575 DeInitLed8187(
6576 - struct net_device *dev,
6577 + struct net_device *dev,
6578 PLED_8187 pLed)
6579 {
6580 //PlatformCancelTimer(dev, &(pLed->BlinkTimer));
6581 @@ -178,10 +190,10 @@
6582 return;
6583  
6584 /*
6585 - if( priv->eRFPowerState != eRfOn &&
6586 - (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
6587 - LedAction == LED_CTL_SITE_SURVEY ||
6588 - LedAction == LED_CTL_LINK ||
6589 + if( priv->eRFPowerState != eRfOn &&
6590 + (LedAction == LED_CTL_TX || LedAction == LED_CTL_RX ||
6591 + LedAction == LED_CTL_SITE_SURVEY ||
6592 + LedAction == LED_CTL_LINK ||
6593 LedAction == LED_CTL_NO_LINK) )
6594 {
6595 return;
6596 @@ -213,7 +225,7 @@
6597  
6598  
6599 //
6600 -// Description:
6601 +// Description:
6602 // Implement each led action for SW_LED_MODE0.
6603 // This is default strategy.
6604 //
6605 @@ -261,7 +273,7 @@
6606 case LED_CTL_NO_LINK:
6607 pLed->CurrLedState = LED_OFF;
6608 break;
6609 -
6610 +
6611 case LED_CTL_POWER_ON:
6612 pLed->CurrLedState = LED_POWER_ON_BLINK;
6613 break;
6614 @@ -297,10 +309,10 @@
6615 {
6616 pLed->bLedBlinkInProgress = 1;
6617 if( pLed->bLedOn )
6618 - pLed->BlinkingLedState = LED_OFF;
6619 + pLed->BlinkingLedState = LED_OFF;
6620 else
6621 - pLed->BlinkingLedState = LED_ON;
6622 -
6623 + pLed->BlinkingLedState = LED_ON;
6624 +
6625 pLed->BlinkTimer.expires = jiffies + LED_BLINK_NORMAL_INTERVAL;
6626 add_timer(&(pLed->BlinkTimer));
6627 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
6628 @@ -312,10 +324,10 @@
6629 {
6630 pLed->bLedBlinkInProgress = 1;
6631 if( pLed->bLedOn )
6632 - pLed->BlinkingLedState = LED_OFF;
6633 + pLed->BlinkingLedState = LED_OFF;
6634 else
6635 pLed->BlinkingLedState = LED_ON;
6636 -
6637 +
6638 pLed->BlinkTimer.expires = jiffies + LED_BLINK_SLOWLY_INTERVAL;
6639 add_timer(&(pLed->BlinkTimer));
6640 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
6641 @@ -334,7 +346,7 @@
6642 }
6643  
6644 //
6645 -// Description:
6646 +// Description:
6647 // Implement each led action for SW_LED_MODE1.
6648 // For example, this is applied by ALPHA.
6649 //
6650 @@ -357,9 +369,9 @@
6651 pLed0->BlinkTimes = 2;
6652 pLed0->bLedBlinkInProgress = 1;
6653 if( pLed0->bLedOn )
6654 - pLed0->BlinkingLedState = LED_OFF;
6655 + pLed0->BlinkingLedState = LED_OFF;
6656 else
6657 - pLed0->BlinkingLedState = LED_ON;
6658 + pLed0->BlinkingLedState = LED_ON;
6659  
6660 pLed0->BlinkTimer.expires = jiffies + LED_BLINK_NORMAL_INTERVAL;
6661 add_timer(&(pLed0->BlinkTimer));
6662 @@ -382,7 +394,7 @@
6663 SwLedOff(dev, pLed0);
6664 }
6665 break;
6666 -
6667 +
6668 case LED_CTL_POWER_ON:
6669 pLed0->CurrLedState = LED_OFF;
6670 SwLedOff(dev, pLed0);
6671 @@ -407,7 +419,7 @@
6672 pLed0->BlinkTimes = 10;
6673 pLed0->bLedBlinkInProgress = 1;
6674 if( pLed0->bLedOn )
6675 - pLed0->BlinkingLedState = LED_OFF;
6676 + pLed0->BlinkingLedState = LED_OFF;
6677 else
6678 pLed0->BlinkingLedState = LED_ON;
6679  
6680 @@ -423,9 +435,9 @@
6681 }
6682  
6683 //
6684 -// Description:
6685 -// Implement each led action for SW_LED_MODE2,
6686 -// which is customized for AzWave 8187 minicard.
6687 +// Description:
6688 +// Implement each led action for SW_LED_MODE2,
6689 +// which is customized for AzWave 8187 minicard.
6690 // 2006.04.03, by rcnjko.
6691 //
6692 void
6693 @@ -450,9 +462,9 @@
6694 pLed->BlinkTimes = 2;
6695  
6696 if( pLed->bLedOn )
6697 - pLed->BlinkingLedState = LED_OFF;
6698 + pLed->BlinkingLedState = LED_OFF;
6699 else
6700 - pLed->BlinkingLedState = LED_ON;
6701 + pLed->BlinkingLedState = LED_ON;
6702  
6703 pLed->BlinkTimer.expires = jiffies + LED_BLINK_NORMAL_INTERVAL;
6704 add_timer(&(pLed->BlinkTimer));
6705 @@ -465,7 +477,7 @@
6706 {
6707 pLed->bLedBlinkInProgress = 1;
6708  
6709 - //if( dev->MgntInfo.mAssoc ||
6710 + //if( dev->MgntInfo.mAssoc ||
6711 // dev->MgntInfo.mIbss )
6712 //{
6713 pLed->CurrLedState = LED_SCAN_BLINK;
6714 @@ -486,7 +498,7 @@
6715 }
6716 else
6717 {
6718 - pLed->BlinkingLedState = LED_ON;
6719 + pLed->BlinkingLedState = LED_ON;
6720 pLed->BlinkTimer.expires = jiffies + LED_CM2_BLINK_OFF_INTERVAL;
6721 add_timer(&(pLed->BlinkTimer));
6722 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
6723 @@ -498,7 +510,7 @@
6724 {
6725 pLed->CurrLedState = LED_SCAN_BLINK;
6726 /*
6727 - if( dev->MgntInfo.mAssoc ||
6728 + if( dev->MgntInfo.mAssoc ||
6729 dev->MgntInfo.mIbss )
6730 {
6731 pLed->CurrLedState = LED_SCAN_BLINK;
6732 @@ -522,14 +534,14 @@
6733  
6734 if( pLed->bLedOn )
6735 {
6736 - pLed->BlinkingLedState = LED_OFF;
6737 + pLed->BlinkingLedState = LED_OFF;
6738 pLed->BlinkTimer.expires = jiffies + LED_CM2_BLINK_ON_INTERVAL;
6739 add_timer(&(pLed->BlinkTimer));
6740 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
6741 }
6742 else
6743 {
6744 - pLed->BlinkingLedState = LED_ON;
6745 + pLed->BlinkingLedState = LED_ON;
6746 pLed->BlinkTimer.expires = jiffies + LED_CM2_BLINK_OFF_INTERVAL;
6747 add_timer(&(pLed->BlinkTimer));
6748 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
6749 @@ -564,9 +576,9 @@
6750  
6751  
6752 //
6753 -// Description:
6754 -// Implement each led action for SW_LED_MODE3,
6755 -// which is customized for Sercomm Printer Server case.
6756 +// Description:
6757 +// Implement each led action for SW_LED_MODE3,
6758 +// which is customized for Sercomm Printer Server case.
6759 // 2006.04.21, by rcnjko.
6760 //
6761 void
6762 @@ -591,9 +603,9 @@
6763 pLed->BlinkTimes = 2;
6764  
6765 if( pLed->bLedOn )
6766 - pLed->BlinkingLedState = LED_OFF;
6767 + pLed->BlinkingLedState = LED_OFF;
6768 else
6769 - pLed->BlinkingLedState = LED_ON;
6770 + pLed->BlinkingLedState = LED_ON;
6771  
6772 pLed->BlinkTimer.expires = jiffies + LED_CM3_BLINK_INTERVAL;
6773 add_timer(&(pLed->BlinkTimer));
6774 @@ -610,9 +622,9 @@
6775 pLed->BlinkTimes = 10;
6776  
6777 if( pLed->bLedOn )
6778 - pLed->BlinkingLedState = LED_OFF;
6779 + pLed->BlinkingLedState = LED_OFF;
6780 else
6781 - pLed->BlinkingLedState = LED_ON;
6782 + pLed->BlinkingLedState = LED_ON;
6783  
6784 pLed->BlinkTimer.expires = jiffies + LED_CM3_BLINK_INTERVAL;
6785 add_timer(&(pLed->BlinkTimer));
6786 @@ -729,18 +741,21 @@
6787 }
6788 }
6789  
6790 -//
6791 +//
6792 // Callback fucntion of the workitem for SW LEDs.
6793 // 2006.03.01, by rcnjko.
6794 //
6795 -void
6796 -Gpio0LedWorkItemCallback(
6797 - void * Context
6798 - )
6799 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
6800 +void Gpio0LedWorkItemCallback(struct work_struct *work)
6801 +{
6802 + struct r8180_priv *priv = container_of(work, struct r8180_priv, Gpio0LedWorkItem);
6803 + struct net_device *dev = priv->dev;
6804 +#else
6805 +void Gpio0LedWorkItemCallback(struct net_device *dev)
6806 {
6807 - struct net_device *dev = (struct net_device *)Context;
6808 struct r8180_priv *priv = ieee80211_priv(dev);
6809 - PLED_8187 pLed = &(priv->Gpio0Led);
6810 +#endif
6811 + PLED_8187 pLed = &(priv->Gpio0Led);
6812  
6813 if(priv->LedStrategy == SW_LED_MODE2)
6814 SwLedCm2Blink(dev, pLed);
6815 @@ -750,27 +765,31 @@
6816 //LeaveCallbackOfRtWorkItem( &(usbdevice->Gpio0LedWorkItem) );
6817 }
6818  
6819 -void
6820 -SwLed0WorkItemCallback(
6821 - void * Context
6822 - )
6823 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
6824 +void SwLed0WorkItemCallback(struct work_struct *work)
6825 +{
6826 + struct r8180_priv *priv = container_of(work, struct r8180_priv, SwLed0WorkItem);
6827 + struct net_device *dev = priv->dev;
6828 +#else
6829 +void SwLed0WorkItemCallback(struct net_device *dev)
6830 {
6831 - struct net_device *dev = (struct net_device *)Context;
6832 struct r8180_priv *priv = ieee80211_priv(dev);
6833 -
6834 +#endif
6835 SwLedBlink(dev, &(priv->SwLed0));
6836  
6837 //LeaveCallbackOfRtWorkItem( &(usbdevice->SwLed0WorkItem) );
6838 }
6839  
6840 -void
6841 -SwLed1WorkItemCallback(
6842 - void * Context
6843 - )
6844 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
6845 +void SwLed1WorkItemCallback(struct work_struct *work)
6846 +{
6847 + struct r8180_priv *priv = container_of(work, struct r8180_priv, SwLed1WorkItem);
6848 + struct net_device *dev = priv->dev;
6849 +#else
6850 +void SwLed1WorkItemCallback(struct net_device *dev)
6851 {
6852 - struct net_device *dev = (struct net_device *)Context;
6853 struct r8180_priv *priv = ieee80211_priv(dev);
6854 -
6855 +#endif
6856 SwLedBlink(dev, &(priv->SwLed1));
6857  
6858 //LeaveCallbackOfRtWorkItem( &(usbdevice->SwLed1WorkItem) );
6859 @@ -782,19 +801,19 @@
6860 //
6861 void
6862 SwLedBlink(
6863 - struct net_device *dev,
6864 + struct net_device *dev,
6865 PLED_8187 pLed
6866 )
6867 {
6868 u8 bStopBlinking = 0;
6869  
6870 // Change LED according to BlinkingLedState specified.
6871 - if( pLed->BlinkingLedState == LED_ON )
6872 + if( pLed->BlinkingLedState == LED_ON )
6873 {
6874 SwLedOn(dev, pLed);
6875 //DMESG("Blinktimes (%d): turn on\n", pLed->BlinkTimes);
6876 - }
6877 - else
6878 + }
6879 + else
6880 {
6881 SwLedOff(dev, pLed);
6882 //DMESG("Blinktimes (%d): turn off\n", pLed->BlinkTimes);
6883 @@ -828,40 +847,40 @@
6884 }
6885  
6886 pLed->BlinkTimes = 0;
6887 - pLed->bLedBlinkInProgress = 0;
6888 + pLed->bLedBlinkInProgress = 0;
6889 }
6890 else
6891 {
6892 // Assign LED state to toggle.
6893 - if( pLed->BlinkingLedState == LED_ON )
6894 + if( pLed->BlinkingLedState == LED_ON )
6895 pLed->BlinkingLedState = LED_OFF;
6896 - else
6897 + else
6898 pLed->BlinkingLedState = LED_ON;
6899  
6900 - // Schedule a timer to toggle LED state.
6901 + // Schedule a timer to toggle LED state.
6902 switch( pLed->CurrLedState )
6903 {
6904 case LED_BLINK_NORMAL:
6905 pLed->BlinkTimer.expires = jiffies + LED_BLINK_NORMAL_INTERVAL;
6906 - add_timer(&(pLed->BlinkTimer));
6907 + add_timer(&(pLed->BlinkTimer));
6908 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
6909 break;
6910  
6911 case LED_BLINK_SLOWLY:
6912 pLed->BlinkTimer.expires = jiffies + LED_BLINK_SLOWLY_INTERVAL;
6913 - add_timer(&(pLed->BlinkTimer));
6914 + add_timer(&(pLed->BlinkTimer));
6915 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
6916 break;
6917  
6918 case LED_BLINK_CM3:
6919 pLed->BlinkTimer.expires = jiffies + LED_CM3_BLINK_INTERVAL;
6920 - add_timer(&(pLed->BlinkTimer));
6921 + add_timer(&(pLed->BlinkTimer));
6922 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_CM3_BLINK_INTERVAL);
6923 break;
6924  
6925 default:
6926 pLed->BlinkTimer.expires = jiffies + LED_BLINK_SLOWLY_INTERVAL;
6927 - add_timer(&(pLed->BlinkTimer));
6928 + add_timer(&(pLed->BlinkTimer));
6929 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
6930 break;
6931 }
6932 @@ -871,11 +890,11 @@
6933  
6934  
6935 //
6936 -// Implementation of LED blinking behavior for SwLedControlMode2.
6937 +// Implementation of LED blinking behavior for SwLedControlMode2.
6938 //
6939 void
6940 SwLedCm2Blink(
6941 - struct net_device *dev,
6942 + struct net_device *dev,
6943 PLED_8187 pLed
6944 )
6945 {
6946 @@ -884,12 +903,12 @@
6947 u8 bStopBlinking = 0;
6948  
6949 // Change LED according to BlinkingLedState specified.
6950 - if( pLed->BlinkingLedState == LED_ON )
6951 + if( pLed->BlinkingLedState == LED_ON )
6952 {
6953 SwLedOn(dev, pLed);
6954 //DMESG("Blinktimes (%d): turn on\n", pLed->BlinkTimes);
6955 - }
6956 - else
6957 + }
6958 + else
6959 {
6960 SwLedOff(dev, pLed);
6961 //DMESG("Blinktimes (%d): turn off\n", pLed->BlinkTimes);
6962 @@ -899,13 +918,13 @@
6963 pLed->BlinkTimes--;
6964 switch(pLed->CurrLedState)
6965 {
6966 - case LED_BLINK_NORMAL:
6967 + case LED_BLINK_NORMAL:
6968 if(pLed->BlinkTimes == 0)
6969 {
6970 bStopBlinking = 1;
6971 }
6972 break;
6973 -/* CM2 scan blink and no link blind now not be supported
6974 +/* CM2 scan blink and no link blind now not be supported
6975 case LED_SCAN_BLINK:
6976 if( (priv->mAssoc || priv->mIbss) && // Linked.
6977 (!priv->bScanInProgress) && // Not in scan stage.
6978 @@ -916,9 +935,9 @@
6979 break;
6980  
6981 case LED_NO_LINK_BLINK:
6982 - //Revised miniCard Ad-hoc mode "Slow Blink" by Isaiah 2006-08-03
6983 + //Revised miniCard Ad-hoc mode "Slow Blink" by Isaiah 2006-08-03
6984 //if( (priv->mAssoc || priv->mIbss) ) // Linked.
6985 - if( priv->mAssoc)
6986 + if( priv->mAssoc)
6987 {
6988 bStopBlinking = 1;
6989 }
6990 @@ -950,28 +969,28 @@
6991 }
6992 */
6993 pLed->BlinkTimes = 0;
6994 - pLed->bLedBlinkInProgress = 0;
6995 + pLed->bLedBlinkInProgress = 0;
6996 }
6997 else
6998 {
6999 // Assign LED state to toggle.
7000 - if( pLed->BlinkingLedState == LED_ON )
7001 + if( pLed->BlinkingLedState == LED_ON )
7002 pLed->BlinkingLedState = LED_OFF;
7003 - else
7004 + else
7005 pLed->BlinkingLedState = LED_ON;
7006  
7007 - // Schedule a timer to toggle LED state.
7008 + // Schedule a timer to toggle LED state.
7009 switch( pLed->CurrLedState )
7010 {
7011 case LED_BLINK_NORMAL:
7012 pLed->BlinkTimer.expires = jiffies + LED_BLINK_NORMAL_INTERVAL;
7013 - add_timer(&(pLed->BlinkTimer));
7014 + add_timer(&(pLed->BlinkTimer));
7015 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_BLINK_NORMAL_INTERVAL);
7016 break;
7017  
7018 case LED_BLINK_SLOWLY:
7019 pLed->BlinkTimer.expires = jiffies + LED_BLINK_SLOWLY_INTERVAL;
7020 - add_timer(&(pLed->BlinkTimer));
7021 + add_timer(&(pLed->BlinkTimer));
7022 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_BLINK_SLOWLY_INTERVAL);
7023 break;
7024  
7025 @@ -979,11 +998,11 @@
7026 case LED_NO_LINK_BLINK:
7027 if( pLed->bLedOn ) {
7028 pLed->BlinkTimer.expires = jiffies + LED_CM2_BLINK_ON_INTERVAL;
7029 - add_timer(&(pLed->BlinkTimer));
7030 + add_timer(&(pLed->BlinkTimer));
7031 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_CM2_BLINK_ON_INTERVAL);
7032 } else {
7033 pLed->BlinkTimer.expires = jiffies + LED_CM2_BLINK_OFF_INTERVAL;
7034 - add_timer(&(pLed->BlinkTimer));
7035 + add_timer(&(pLed->BlinkTimer));
7036 //PlatformSetTimer(dev, &(pLed->BlinkTimer), LED_CM2_BLINK_OFF_INTERVAL);
7037 }
7038 break;
7039 @@ -1000,7 +1019,7 @@
7040  
7041 void
7042 SwLedOn(
7043 - struct net_device *dev,
7044 + struct net_device *dev,
7045 PLED_8187 pLed
7046 )
7047 {
7048 @@ -1032,7 +1051,7 @@
7049  
7050 void
7051 SwLedOff(
7052 - struct net_device *dev,
7053 + struct net_device *dev,
7054 PLED_8187 pLed
7055 )
7056 {
7057 @@ -1060,5 +1079,5 @@
7058 }
7059  
7060 pLed->bLedOn = 0;
7061 -}
7062 +}
7063  
7064 diff -Naur r8187_orig/rtl8187/r8187_led.h r8187_rawtx/rtl8187/r8187_led.h
7065 --- r8187_orig/rtl8187/r8187_led.h 2007-01-15 03:00:37.000000000 +0100
7066 +++ r8187_rawtx/rtl8187/r8187_led.h 2007-05-16 21:51:38.000000000 +0200
7067 @@ -7,7 +7,7 @@
7068  
7069 Abstract:
7070 definitions and stuctures for rtl8187 led control.
7071 -
7072 +
7073 Major Change History:
7074 When Who What
7075 ---------- ------ ----------------------------------------------
7076 @@ -127,14 +127,14 @@
7077  
7078 void
7079 InitLed8187(
7080 - struct net_device *dev,
7081 + struct net_device *dev,
7082 PLED_8187 pLed,
7083 LED_PIN_8187 LedPin,
7084 void * BlinkCallBackFunc);
7085  
7086 void
7087 DeInitLed8187(
7088 - struct net_device *dev,
7089 + struct net_device *dev,
7090 PLED_8187 pLed);
7091  
7092 void
7093 @@ -188,42 +188,37 @@
7094 PLED_8187 pLed
7095 );
7096  
7097 -void
7098 -Gpio0LedWorkItemCallback(
7099 - void * Context
7100 - );
7101 -
7102 -void
7103 -SwLed0WorkItemCallback(
7104 - void * Context
7105 - );
7106 -
7107 -void
7108 -SwLed1WorkItemCallback(
7109 - void * Context
7110 - );
7111 +# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
7112 +void SwLed0WorkItemCallback(struct work_struct *work);
7113 +void SwLed1WorkItemCallback(struct work_struct *work);
7114 +void Gpio0LedWorkItemCallback(struct work_struct *work);
7115 +#else
7116 +void SwLed0WorkItemCallback(struct net_device *dev);
7117 +void SwLed1WorkItemCallback(struct net_device *dev);
7118 +void Gpio0LedWorkItemCallback(struct net_device *dev);
7119 +#endif
7120  
7121 void
7122 SwLedBlink(
7123 - struct net_device *dev,
7124 + struct net_device *dev,
7125 PLED_8187 pLed
7126 );
7127  
7128 void
7129 SwLedCm2Blink(
7130 - struct net_device *dev,
7131 + struct net_device *dev,
7132 PLED_8187 pLed
7133 );
7134  
7135 void
7136 SwLedOn(
7137 - struct net_device *dev,
7138 + struct net_device *dev,
7139 PLED_8187 pLed
7140 );
7141  
7142 void
7143 SwLedOff(
7144 - struct net_device *dev,
7145 + struct net_device *dev,
7146 PLED_8187 pLed
7147 );
7148  
7149 diff -Naur r8187_orig/symvers r8187_rawtx/symvers
7150 --- r8187_orig/symvers 1970-01-01 01:00:00.000000000 +0100
7151 +++ r8187_rawtx/symvers 2007-05-13 09:54:44.000000000 +0200
7152 @@ -0,0 +1,25 @@
7153 +#!/bin/sh
7154 +
7155 +cd rtl8187
7156 +
7157 +if [ -e Module.symvers ]
7158 +then
7159 + rm Module.symvers
7160 +fi
7161 +
7162 +if [ -e Modules.symvers ]
7163 +then
7164 + rm Modules.symvers
7165 +fi
7166 +
7167 +if [ -e ../ieee80211/Module.symvers ]
7168 +then
7169 + ln -sf ../ieee80211/Module.symvers ./
7170 +fi
7171 +
7172 +if [ -e ../ieee80211/Modules.symvers ]
7173 +then
7174 + ln -sf ../ieee80211/Modules.symvers ./
7175 +fi
7176 +
7177 +cd ..
7178 \ Kein Zeilenumbruch am Dateiende.