]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/staging/rtl8187se/ieee80211/ieee80211_softmac.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging: __FUNCTION__ is gcc-specific, use __func__
[net-next-2.6.git] / drivers / staging / rtl8187se / ieee80211 / ieee80211_softmac.c
CommitLineData
c8d86be3
GKH		 1/* IEEE 802.11 SoftMAC layer
2 * Copyright (c) 2005 Andrea Merello <andreamrl@tiscali.it>
3 *
4 * Mostly extracted from the rtl8180-sa2400 driver for the
5 * in-kernel generic ieee802.11 stack.
6 *
7 * Few lines might be stolen from other part of the ieee80211
8 * stack. Copyright who own it's copyright
9 *
10 * WPA code stolen from the ipw2200 driver.
11 * Copyright who own it's copyright.
12 *
13 * released under the GPL
14 */
15
16
17#include "ieee80211.h"
18
19#include <linux/random.h>
20#include <linux/delay.h>
21#include <linux/version.h>
22#include <asm/uaccess.h>
23
24#ifdef ENABLE_DOT11D
25#include "dot11d.h"
26#endif
27u8 rsn_authen_cipher_suite[16][4] = {
28 {0x00,0x0F,0xAC,0x00}, //Use group key, //Reserved
29 {0x00,0x0F,0xAC,0x01}, //WEP-40 //RSNA default
30 {0x00,0x0F,0xAC,0x02}, //TKIP //NONE //{used just as default}
31 {0x00,0x0F,0xAC,0x03}, //WRAP-historical
32 {0x00,0x0F,0xAC,0x04}, //CCMP
33 {0x00,0x0F,0xAC,0x05}, //WEP-104
34};
35
36short ieee80211_is_54g(struct ieee80211_network net)
37{
38 return ((net.rates_ex_len > 0) || (net.rates_len > 4));
39}
40
41short ieee80211_is_shortslot(struct ieee80211_network net)
42{
43 return (net.capability & WLAN_CAPABILITY_SHORT_SLOT);
44}
45
46/* returns the total length needed for pleacing the RATE MFIE
47 * tag and the EXTENDED RATE MFIE tag if needed.
48 * It encludes two bytes per tag for the tag itself and its len
49 */
50unsigned int ieee80211_MFIE_rate_len(struct ieee80211_device *ieee)
51{
52 unsigned int rate_len = 0;
53
54 if (ieee->modulation & IEEE80211_CCK_MODULATION)
55 rate_len = IEEE80211_CCK_RATE_LEN + 2;
56
57 if (ieee->modulation & IEEE80211_OFDM_MODULATION)
58
59 rate_len += IEEE80211_OFDM_RATE_LEN + 2;
60
61 return rate_len;
62}
63
64/* pleace the MFIE rate, tag to the memory (double) poined.
65 * Then it updates the pointer so that
66 * it points after the new MFIE tag added.
67 */
68void ieee80211_MFIE_Brate(struct ieee80211_device *ieee, u8 **tag_p)
69{
70 u8 *tag = *tag_p;
71
72 if (ieee->modulation & IEEE80211_CCK_MODULATION){
73 *tag++ = MFIE_TYPE_RATES;
74 *tag++ = 4;
75 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
76 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
77 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_5MB;
78 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_11MB;
79 }
80
81 /* We may add an option for custom rates that specific HW might support */
82 *tag_p = tag;
83}
84
85void ieee80211_MFIE_Grate(struct ieee80211_device *ieee, u8 **tag_p)
86{
87 u8 *tag = *tag_p;
88
89 if (ieee->modulation & IEEE80211_OFDM_MODULATION){
90
91 *tag++ = MFIE_TYPE_RATES_EX;
92 *tag++ = 8;
93 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_6MB;
94 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_9MB;
95 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_12MB;
96 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_18MB;
97 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_24MB;
98 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_36MB;
99 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_48MB;
100 *tag++ = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_54MB;
101
102 }
103
104 /* We may add an option for custom rates that specific HW might support */
105 *tag_p = tag;
106}
107
108
109void ieee80211_WMM_Info(struct ieee80211_device *ieee, u8 **tag_p) {
110 u8 *tag = *tag_p;
111
112 *tag++ = MFIE_TYPE_GENERIC; //0
113 *tag++ = 7;
114 *tag++ = 0x00;
115 *tag++ = 0x50;
116 *tag++ = 0xf2;
117 *tag++ = 0x02;//5
118 *tag++ = 0x00;
119 *tag++ = 0x01;
120#ifdef SUPPORT_USPD
121 if(ieee->current_network.wmm_info & 0x80) {
122 *tag++ = 0x0f|MAX_SP_Len;
123 } else {
124 *tag++ = MAX_SP_Len;
125 }
126#else
127 *tag++ = MAX_SP_Len;
128#endif
129 *tag_p = tag;
130}
131
132#ifdef THOMAS_TURBO
133void ieee80211_TURBO_Info(struct ieee80211_device *ieee, u8 **tag_p) {
134 u8 *tag = *tag_p;
135
136 *tag++ = MFIE_TYPE_GENERIC; //0
137 *tag++ = 7;
138 *tag++ = 0x00;
139 *tag++ = 0xe0;
140 *tag++ = 0x4c;
141 *tag++ = 0x01;//5
142 *tag++ = 0x02;
143 *tag++ = 0x11;
144 *tag++ = 0x00;
145
146 *tag_p = tag;
147 printk(KERN_ALERT "This is enable turbo mode IE process\n");
148}
149#endif
150
151void enqueue_mgmt(struct ieee80211_device *ieee, struct sk_buff *skb)
152{
153 int nh;
154 nh = (ieee->mgmt_queue_head +1) % MGMT_QUEUE_NUM;
155
156/*
157 * if the queue is full but we have newer frames then
158 * just overwrites the oldest.
159 *
160 * if (nh == ieee->mgmt_queue_tail)
161 * return -1;
162 */
163 ieee->mgmt_queue_head = nh;
164 ieee->mgmt_queue_ring[nh] = skb;
165
166 //return 0;
167}
168
169struct sk_buff *dequeue_mgmt(struct ieee80211_device *ieee)
170{
171 struct sk_buff *ret;
172
173 if(ieee->mgmt_queue_tail == ieee->mgmt_queue_head)
174 return NULL;
175
176 ret = ieee->mgmt_queue_ring[ieee->mgmt_queue_tail];
177
178 ieee->mgmt_queue_tail =
179 (ieee->mgmt_queue_tail+1) % MGMT_QUEUE_NUM;
180
181 return ret;
182}
183
184void init_mgmt_queue(struct ieee80211_device *ieee)
185{
186 ieee->mgmt_queue_tail = ieee->mgmt_queue_head = 0;
187}
188
189
190void ieee80211_sta_wakeup(struct ieee80211_device *ieee, short nl);
191
192inline void softmac_mgmt_xmit(struct sk_buff *skb, struct ieee80211_device *ieee)
193{
194 unsigned long flags;
195 short single = ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE;
196 struct ieee80211_hdr_3addr *header=
197 (struct ieee80211_hdr_3addr *) skb->data;
198
199
200 spin_lock_irqsave(&ieee->lock, flags);
201
202 /* called with 2nd param 0, no mgmt lock required */
203 ieee80211_sta_wakeup(ieee,0);
204
205 if(single){
206 if(ieee->queue_stop){
207
208 enqueue_mgmt(ieee,skb);
209 }else{
210 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0]<<4);
211
212 if (ieee->seq_ctrl[0] == 0xFFF)
213 ieee->seq_ctrl[0] = 0;
214 else
215 ieee->seq_ctrl[0]++;
216
217 /* avoid watchdog triggers */
218 ieee->dev->trans_start = jiffies;
219 ieee->softmac_data_hard_start_xmit(skb,ieee->dev,ieee->basic_rate);
220 }
221
222 spin_unlock_irqrestore(&ieee->lock, flags);
223 }else{
224 spin_unlock_irqrestore(&ieee->lock, flags);
225 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags);
226
227 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
228
229 if (ieee->seq_ctrl[0] == 0xFFF)
230 ieee->seq_ctrl[0] = 0;
231 else
232 ieee->seq_ctrl[0]++;
233
234 /* avoid watchdog triggers */
235 ieee->dev->trans_start = jiffies;
236 ieee->softmac_hard_start_xmit(skb,ieee->dev);
237
238 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags);
239 }
240}
241
242
243inline void softmac_ps_mgmt_xmit(struct sk_buff *skb, struct ieee80211_device *ieee)
244{
245
246 short single = ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE;
247 struct ieee80211_hdr_3addr *header =
248 (struct ieee80211_hdr_3addr *) skb->data;
249
250
251 if(single){
252
253 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
254
255 if (ieee->seq_ctrl[0] == 0xFFF)
256 ieee->seq_ctrl[0] = 0;
257 else
258 ieee->seq_ctrl[0]++;
259
260 /* avoid watchdog triggers */
261 ieee->dev->trans_start = jiffies;
262 ieee->softmac_data_hard_start_xmit(skb,ieee->dev,ieee->basic_rate);
263
264 }else{
265
266 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
267
268 if (ieee->seq_ctrl[0] == 0xFFF)
269 ieee->seq_ctrl[0] = 0;
270 else
271 ieee->seq_ctrl[0]++;
272
273 /* avoid watchdog triggers */
274 ieee->dev->trans_start = jiffies;
275 ieee->softmac_hard_start_xmit(skb,ieee->dev);
276
277 }
278// dev_kfree_skb_any(skb);//edit by thomas
279}
280//by amy for power save
281inline struct sk_buff *ieee80211_disassociate_skb(
282 struct ieee80211_network *beacon,
283 struct ieee80211_device *ieee,
284 u8 asRsn)
285{
286 struct sk_buff *skb;
287 struct ieee80211_disassoc_frame *disass;
288
289 skb = dev_alloc_skb(sizeof(struct ieee80211_disassoc_frame));
290 if (!skb)
291 return NULL;
292
293 disass = (struct ieee80211_disassoc_frame *) skb_put(skb,sizeof(struct ieee80211_disassoc_frame));
294 disass->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_DISASSOC);
295 disass->header.duration_id = 0;
296
297 memcpy(disass->header.addr1, beacon->bssid, ETH_ALEN);
298 memcpy(disass->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
299 memcpy(disass->header.addr3, beacon->bssid, ETH_ALEN);
300
301 disass->reasoncode = asRsn;
302 return skb;
303}
304void
305SendDisassociation(
306 struct ieee80211_device *ieee,
307 u8* asSta,
308 u8 asRsn
309)
310{
311 struct ieee80211_network *beacon = &ieee->current_network;
312 struct sk_buff *skb;
313 skb = ieee80211_disassociate_skb(beacon,ieee,asRsn);
314 if (skb){
315 softmac_mgmt_xmit(skb, ieee);
316 //dev_kfree_skb_any(skb);//edit by thomas
317 }
318}
319
320//by amy for power save
321inline struct sk_buff *ieee80211_probe_req(struct ieee80211_device *ieee)
322{
323 unsigned int len,rate_len;
324 u8 *tag;
325 struct sk_buff *skb;
326 struct ieee80211_probe_request *req;
327
328#ifdef _RTL8187_EXT_PATCH_
329 short extMore = 0;
330 if(ieee->ext_patch_ieee80211_probe_req_1)
331 extMore = ieee->ext_patch_ieee80211_probe_req_1(ieee);
332#endif
333
334 len = ieee->current_network.ssid_len;
335
336 rate_len = ieee80211_MFIE_rate_len(ieee);
337
338#ifdef _RTL8187_EXT_PATCH_
339 if(!extMore)
340#endif
341 skb = dev_alloc_skb(sizeof(struct ieee80211_probe_request) +
342 2 + len + rate_len);
343#ifdef _RTL8187_EXT_PATCH_
344 else
345 skb = dev_alloc_skb(sizeof(struct ieee80211_probe_request) +
346 2 + len + rate_len+128); // MESHID + CAP
347#endif
348
349 if (!skb)
350 return NULL;
351
352 req = (struct ieee80211_probe_request *) skb_put(skb,sizeof(struct ieee80211_probe_request));
353 req->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
354 req->header.duration_id = 0; //FIXME: is this OK ?
355
356 memset(req->header.addr1, 0xff, ETH_ALEN);
357 memcpy(req->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
358 memset(req->header.addr3, 0xff, ETH_ALEN);
359
360 tag = (u8 *) skb_put(skb,len+2+rate_len);
361
362 *tag++ = MFIE_TYPE_SSID;
363 *tag++ = len;
364 memcpy(tag, ieee->current_network.ssid, len);
365 tag += len;
366 ieee80211_MFIE_Brate(ieee,&tag);
367 ieee80211_MFIE_Grate(ieee,&tag);
368
369#ifdef _RTL8187_EXT_PATCH_
370 if(extMore)
371 ieee->ext_patch_ieee80211_probe_req_2(ieee, skb, tag);
372#endif
373 return skb;
374}
375
376struct sk_buff *ieee80211_get_beacon_(struct ieee80211_device *ieee);
377
378//#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
379//void ext_ieee80211_send_beacon_wq(struct work_struct *work)
380//{
381// struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, ext_send_beacon_wq);
382//#else
383void ext_ieee80211_send_beacon_wq(struct ieee80211_device *ieee)
384{
385//#endif
386
387 struct sk_buff *skb;
388
389 //unsigned long flags;
390
391 skb = ieee80211_get_beacon_(ieee);
392
393 if (skb){
394 softmac_mgmt_xmit(skb, ieee);
395 ieee->softmac_stats.tx_beacons++;
396 dev_kfree_skb_any(skb);//edit by thomas
397 }
398
399
400 //printk(KERN_WARNING "[1] beacon sending!\n");
401 ieee->beacon_timer.expires = jiffies +
402 (MSECS( ieee->current_network.beacon_interval -5));
403
404 //spin_lock_irqsave(&ieee->beacon_lock,flags);
405 if(ieee->beacon_txing)
406 add_timer(&ieee->beacon_timer);
407 //spin_unlock_irqrestore(&ieee->beacon_lock,flags);
408}
409
410void ieee80211_send_beacon(struct ieee80211_device *ieee)
411{
412 struct sk_buff *skb;
413
414 //unsigned long flags;
415
416 skb = ieee80211_get_beacon_(ieee);
417
418 if (skb){
419 softmac_mgmt_xmit(skb, ieee);
420 ieee->softmac_stats.tx_beacons++;
421 dev_kfree_skb_any(skb);//edit by thomas
422 }
423
424 //printk(KERN_WARNING "[1] beacon sending!\n");
425 ieee->beacon_timer.expires = jiffies +
426 (MSECS( ieee->current_network.beacon_interval -5));
427
428 //spin_lock_irqsave(&ieee->beacon_lock,flags);
429 if(ieee->beacon_txing)
430 add_timer(&ieee->beacon_timer);
431 //spin_unlock_irqrestore(&ieee->beacon_lock,flags);
432}
433
434
435void ieee80211_send_beacon_cb(unsigned long _ieee)
436{
437 struct ieee80211_device *ieee =
438 (struct ieee80211_device *) _ieee;
439 unsigned long flags;
440
441 spin_lock_irqsave(&ieee->beacon_lock, flags);
442 ieee80211_send_beacon(ieee);
443 spin_unlock_irqrestore(&ieee->beacon_lock, flags);
444}
445
446#ifdef _RTL8187_EXT_PATCH_
447
448inline struct sk_buff *ieee80211_probe_req_with_SSID(struct ieee80211_device *ieee, char *ssid, int len_ssid)
449{
450 unsigned int len,rate_len;
451 u8 *tag;
452 struct sk_buff *skb;
453 struct ieee80211_probe_request *req;
454
455#ifdef _RTL8187_EXT_PATCH_
456 short extMore = 0;
457 if(ieee->ext_patch_ieee80211_probe_req_1)
458 extMore = ieee->ext_patch_ieee80211_probe_req_1(ieee);
459#endif
460
461 len = len_ssid;
462
463 rate_len = ieee80211_MFIE_rate_len(ieee);
464
465#ifdef _RTL8187_EXT_PATCH_
466 if(!extMore)
467#endif
468 skb = dev_alloc_skb(sizeof(struct ieee80211_probe_request) +
469 2 + len + rate_len);
470#ifdef _RTL8187_EXT_PATCH_
471 else
472 skb = dev_alloc_skb(sizeof(struct ieee80211_probe_request) +
473 2 + len + rate_len+128); // MESHID + CAP
474#endif
475
476 if (!skb)
477 return NULL;
478
479 req = (struct ieee80211_probe_request *) skb_put(skb,sizeof(struct ieee80211_probe_request));
480 req->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
481 req->header.duration_id = 0; //FIXME: is this OK ?
482
483 memset(req->header.addr1, 0xff, ETH_ALEN);
484 memcpy(req->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
485 memset(req->header.addr3, 0xff, ETH_ALEN);
486
487 tag = (u8 *) skb_put(skb,len+2+rate_len);
488
489 *tag++ = MFIE_TYPE_SSID;
490 *tag++ = len;
491 if(len)
492 {
493 memcpy(tag, ssid, len);
494 tag += len;
495 }
496
497 ieee80211_MFIE_Brate(ieee,&tag);
498 ieee80211_MFIE_Grate(ieee,&tag);
499
500#ifdef _RTL8187_EXT_PATCH_
501 if(extMore)
502 ieee->ext_patch_ieee80211_probe_req_2(ieee, skb, tag);
503#endif
504 return skb;
505}
506
507#endif // _RTL8187_EXT_PATCH_
508
509
510void ieee80211_send_probe(struct ieee80211_device *ieee)
511{
512 struct sk_buff *skb;
513
514#ifdef _RTL8187_EXT_PATCH_
515 if(ieee->iw_mode == ieee->iw_ext_mode)
516 skb = ieee80211_probe_req_with_SSID(ieee, NULL, 0);
517 else
518#endif
519 skb = ieee80211_probe_req(ieee);
520 if (skb){
521 softmac_mgmt_xmit(skb, ieee);
522 ieee->softmac_stats.tx_probe_rq++;
523 //dev_kfree_skb_any(skb);//edit by thomas
524 }
525}
526
527void ieee80211_send_probe_requests(struct ieee80211_device *ieee)
528{
529 if (ieee->active_scan && (ieee->softmac_features & IEEE_SOFTMAC_PROBERQ)){
530 ieee80211_send_probe(ieee);
531 ieee80211_send_probe(ieee);
532 }
533}
534
535/* this performs syncro scan blocking the caller until all channels
536 * in the allowed channel map has been checked.
537 */
538void ieee80211_softmac_scan_syncro(struct ieee80211_device *ieee)
539{
540 short ch = 0;
541#ifdef ENABLE_DOT11D
542 u8 channel_map[MAX_CHANNEL_NUMBER+1];
543 memcpy(channel_map, GET_DOT11D_INFO(ieee)->channel_map, MAX_CHANNEL_NUMBER+1);
544#endif
545 down(&ieee->scan_sem);
546// printk("==================> Sync scan\n");
547// dump_chnl_map(channel_map);
548
549 while(1)
550 {
551
552 do{
553 ch++;
554 if (ch > MAX_CHANNEL_NUMBER)
555 goto out; /* scan completed */
556
557#ifdef ENABLE_DOT11D
558 }while(!channel_map[ch]);
559#else
560 }while(!ieee->channel_map[ch]);
561#endif
562 /* this fuction can be called in two situations
563 * 1- We have switched to ad-hoc mode and we are
564 * performing a complete syncro scan before conclude
565 * there are no interesting cell and to create a
566 * new one. In this case the link state is
567 * IEEE80211_NOLINK until we found an interesting cell.
568 * If so the ieee8021_new_net, called by the RX path
569 * will set the state to IEEE80211_LINKED, so we stop
570 * scanning
571 * 2- We are linked and the root uses run iwlist scan.
572 * So we switch to IEEE80211_LINKED_SCANNING to remember
573 * that we are still logically linked (not interested in
574 * new network events, despite for updating the net list,
575 * but we are temporarly 'unlinked' as the driver shall
576 * not filter RX frames and the channel is changing.
577 * So the only situation in witch are interested is to check
578 * if the state become LINKED because of the #1 situation
579 */
580
581 if (ieee->state == IEEE80211_LINKED)
582 goto out;
583
584 ieee->set_chan(ieee->dev, ch);
585// printk("=====>channel=%d ",ch);
586#ifdef ENABLE_DOT11D
587 if(channel_map[ch] == 1)
588#endif
589 {
590// printk("====send probe request\n");
591 ieee80211_send_probe_requests(ieee);
592 }
593 /* this prevent excessive time wait when we
594 * need to wait for a syncro scan to end..
595 */
596 if (ieee->sync_scan_hurryup)
597 goto out;
598
599
600 msleep_interruptible_rtl(IEEE80211_SOFTMAC_SCAN_TIME);
601
602 }
603out:
604 ieee->sync_scan_hurryup = 0;
605 up(&ieee->scan_sem);
606#ifdef ENABLE_DOT11D
607 if(IS_DOT11D_ENABLE(ieee))
608 DOT11D_ScanComplete(ieee);
609#endif
610}
611
612void ieee80211_softmac_ips_scan_syncro(struct ieee80211_device *ieee)
613{
614 int ch;
615 unsigned int watch_dog = 0;
616#ifdef ENABLE_DOT11D
617 u8 channel_map[MAX_CHANNEL_NUMBER+1];
618 memcpy(channel_map, GET_DOT11D_INFO(ieee)->channel_map, MAX_CHANNEL_NUMBER+1);
619#endif
620 down(&ieee->scan_sem);
621 ch = ieee->current_network.channel;
622// if(ieee->sync_scan_hurryup)
623// {
624
625// printk("stop scan sync\n");
626// goto out;
627// }
628// printk("=======hh===============>ips scan\n");
629 while(1)
630 {
631 /* this fuction can be called in two situations
632 * 1- We have switched to ad-hoc mode and we are
633 * performing a complete syncro scan before conclude
634 * there are no interesting cell and to create a
635 * new one. In this case the link state is
636 * IEEE80211_NOLINK until we found an interesting cell.
637 * If so the ieee8021_new_net, called by the RX path
638 * will set the state to IEEE80211_LINKED, so we stop
639 * scanning
640 * 2- We are linked and the root uses run iwlist scan.
641 * So we switch to IEEE80211_LINKED_SCANNING to remember
642 * that we are still logically linked (not interested in
643 * new network events, despite for updating the net list,
644 * but we are temporarly 'unlinked' as the driver shall
645 * not filter RX frames and the channel is changing.
646 * So the only situation in witch are interested is to check
647 * if the state become LINKED because of the #1 situation
648 */
649 if (ieee->state == IEEE80211_LINKED)
650 {
651 goto out;
652 }
653#ifdef ENABLE_DOT11D
654 if(channel_map[ieee->current_network.channel] > 0)
655#endif
656 {
657 ieee->set_chan(ieee->dev, ieee->current_network.channel);
658// printk("======>channel=%d ",ieee->current_network.channel);
659 }
660#ifdef ENABLE_DOT11D
661 if(channel_map[ieee->current_network.channel] == 1)
662#endif
663 {
664// printk("====send probe request\n");
665 ieee80211_send_probe_requests(ieee);
666 }
667 /* this prevent excessive time wait when we
668 * need to wait for a syncro scan to end..
669 */
670// if (ieee->sync_scan_hurryup)
671// goto out;
672
673 msleep_interruptible_rtl(IEEE80211_SOFTMAC_SCAN_TIME);
674
675 do{
676 if (watch_dog++ >= MAX_CHANNEL_NUMBER)
677 // if (++watch_dog >= 15);//MAX_CHANNEL_NUMBER) //YJ,modified,080630
678 goto out; /* scan completed */
679
680 ieee->current_network.channel = (ieee->current_network.channel + 1)%MAX_CHANNEL_NUMBER;
681#ifdef ENABLE_DOT11D
682 }while(!channel_map[ieee->current_network.channel]);
683#else
684 }while(!ieee->channel_map[ieee->current_network.channel]);
685#endif
686 }
687out:
688 //ieee->sync_scan_hurryup = 0;
689 //ieee->set_chan(ieee->dev, ch);
690 //ieee->current_network.channel = ch;
691 ieee->actscanning = false;
692 up(&ieee->scan_sem);
693#ifdef ENABLE_DOT11D
694 if(IS_DOT11D_ENABLE(ieee))
695 DOT11D_ScanComplete(ieee);
696#endif
697}
698
699
700#if 0
701/* called both by wq with ieee->lock held */
702void ieee80211_softmac_scan(struct ieee80211_device *ieee)
703{
704 short watchdog = 0;
705
706 do{
707 ieee->current_network.channel =
708 (ieee->current_network.channel + 1) % MAX_CHANNEL_NUMBER;
709 if (watchdog++ > MAX_CHANNEL_NUMBER)
710 return; /* no good chans */
711
712 }while(!ieee->channel_map[ieee->current_network.channel]);
713
714
715 schedule_work(&ieee->softmac_scan_wq);
716}
717#endif
718#ifdef ENABLE_IPS
719#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
720void ieee80211_softmac_scan_wq(struct work_struct *work)
721{
722 struct delayed_work *dwork = container_of(work, struct delayed_work, work);
723 struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, softmac_scan_wq);
724#else
725void ieee80211_softmac_scan_wq(struct ieee80211_device *ieee)
726{
727#endif
728 static short watchdog = 0;
729#ifdef ENABLE_DOT11D
730 u8 channel_map[MAX_CHANNEL_NUMBER+1];
731 memcpy(channel_map, GET_DOT11D_INFO(ieee)->channel_map, MAX_CHANNEL_NUMBER+1);
732#endif
733// printk("ieee80211_softmac_scan_wq ENABLE_IPS\n");
d599edca 734// printk("in %s\n",__func__);
c8d86be3
GKH		 735 down(&ieee->scan_sem);
736
737 do{
738 ieee->current_network.channel =
739 (ieee->current_network.channel + 1) % MAX_CHANNEL_NUMBER;
740 if (watchdog++ > MAX_CHANNEL_NUMBER)
741 goto out; /* no good chans */
742
743#ifdef ENABLE_DOT11D
744 }while(!channel_map[ieee->current_network.channel]);
745#else
746 }while(!ieee->channel_map[ieee->current_network.channel]);
747#endif
748
749 //printk("current_network.channel:%d\n", ieee->current_network.channel);
750 if (ieee->scanning == 0 )
751 {
752 printk("error out, scanning = 0\n");
753 goto out;
754 }
755 ieee->set_chan(ieee->dev, ieee->current_network.channel);
756#ifdef ENABLE_DOT11D
757 if(channel_map[ieee->current_network.channel] == 1)
758#endif
759 ieee80211_send_probe_requests(ieee);
760
761 queue_delayed_work(ieee->wq, &ieee->softmac_scan_wq, IEEE80211_SOFTMAC_SCAN_TIME);
762 up(&ieee->scan_sem);
763 return;
764out:
765 ieee->actscanning = false;
766 watchdog = 0;
767 ieee->scanning = 0;
768 up(&ieee->scan_sem);
769
770#ifdef ENABLE_DOT11D
771 if(IS_DOT11D_ENABLE(ieee))
772 DOT11D_ScanComplete(ieee);
773#endif
774 return;
775}
776#else
777#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
778void ieee80211_softmac_scan_wq(struct work_struct *work)
779{
780 struct delayed_work *dwork = container_of(work, struct delayed_work, work);
781 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, softmac_scan_wq);
782#else
783void ieee80211_softmac_scan_wq(struct ieee80211_device *ieee)
784{
785#endif
786
787 short watchdog = 0;
788#ifdef ENABLE_DOT11D
789 u8 channel_map[MAX_CHANNEL_NUMBER+1];
790 memcpy(channel_map, GET_DOT11D_INFO(ieee)->channel_map, MAX_CHANNEL_NUMBER+1);
791#endif
792// printk("enter scan wq,watchdog is %d\n",watchdog);
793 down(&ieee->scan_sem);
794
795 do{
796 ieee->current_network.channel =
797 (ieee->current_network.channel + 1) % MAX_CHANNEL_NUMBER;
798 if (watchdog++ > MAX_CHANNEL_NUMBER)
799 goto out; /* no good chans */
800
801#ifdef ENABLE_DOT11D
802 }while(!channel_map[ieee->current_network.channel]);
803#else
804 }while(!ieee->channel_map[ieee->current_network.channel]);
805#endif
806
807// printk("current_network.channel:%d\n", ieee->current_network.channel);
808 if (ieee->scanning == 0 )
809 {
810 printk("error out, scanning = 0\n");
811 goto out;
812 }
813 ieee->set_chan(ieee->dev, ieee->current_network.channel);
814#ifdef ENABLE_DOT11D
815 if(channel_map[ieee->current_network.channel] == 1)
816#endif
817 ieee80211_send_probe_requests(ieee);
818
819 queue_delayed_work(ieee->wq, &ieee->softmac_scan_wq, IEEE80211_SOFTMAC_SCAN_TIME);
820out:
821 up(&ieee->scan_sem);
822#ifdef ENABLE_DOT11D
823 if(IS_DOT11D_ENABLE(ieee))
824 DOT11D_ScanComplete(ieee);
825#endif
826}
827
828#endif
829#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
830void ieee80211_softmac_scan_cb(unsigned long _dev)
831{
832 unsigned long flags;
833 struct ieee80211_device *ieee = (struct ieee80211_device *)_dev;
834
835 spin_lock_irqsave(&ieee->lock, flags);
836 ieee80211_softmac_scan(ieee);
837 spin_unlock_irqrestore(&ieee->lock, flags);
838}
839#endif
840
841
842void ieee80211_beacons_start(struct ieee80211_device *ieee)
843{
844 unsigned long flags;
845
846 spin_lock_irqsave(&ieee->beacon_lock,flags);
847
848 ieee->beacon_txing = 1;
849 ieee80211_send_beacon(ieee);
850
851 spin_unlock_irqrestore(&ieee->beacon_lock,flags);
852}
853
854void ieee80211_beacons_stop(struct ieee80211_device *ieee)
855{
856 unsigned long flags;
857
858 spin_lock_irqsave(&ieee->beacon_lock,flags);
859
860 ieee->beacon_txing = 0;
861 del_timer_sync(&ieee->beacon_timer);
862
863 spin_unlock_irqrestore(&ieee->beacon_lock,flags);
864
865}
866
867
868void ieee80211_stop_send_beacons(struct ieee80211_device *ieee)
869{
870 if(ieee->stop_send_beacons)
871 ieee->stop_send_beacons(ieee->dev);
872 if (ieee->softmac_features & IEEE_SOFTMAC_BEACONS)
873 ieee80211_beacons_stop(ieee);
874}
875
876
877void ieee80211_start_send_beacons(struct ieee80211_device *ieee)
878{
879 if(ieee->start_send_beacons)
880 ieee->start_send_beacons(ieee->dev);
881 if(ieee->softmac_features & IEEE_SOFTMAC_BEACONS)
882 ieee80211_beacons_start(ieee);
883}
884
885
886void ieee80211_softmac_stop_scan(struct ieee80211_device *ieee)
887{
888// unsigned long flags;
889
890 //ieee->sync_scan_hurryup = 1;
891
892 down(&ieee->scan_sem);
893// spin_lock_irqsave(&ieee->lock, flags);
894
895 if (ieee->scanning == 1){
896 ieee->scanning = 0;
897 //del_timer_sync(&ieee->scan_timer);
898 cancel_delayed_work(&ieee->softmac_scan_wq);
899 }
900
901// spin_unlock_irqrestore(&ieee->lock, flags);
902 up(&ieee->scan_sem);
903}
904
905void ieee80211_stop_scan(struct ieee80211_device *ieee)
906{
907 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN)
908 ieee80211_softmac_stop_scan(ieee);
909 else
910 ieee->stop_scan(ieee->dev);
911}
912
913/* called with ieee->lock held */
914void ieee80211_start_scan(struct ieee80211_device *ieee)
915{
916#ifdef ENABLE_DOT11D
917 if(IS_DOT11D_ENABLE(ieee) )
918 {
919 if(IS_COUNTRY_IE_VALID(ieee))
920 {
921 RESET_CIE_WATCHDOG(ieee);
922 }
923 }
924#endif
925 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN){
926 if (ieee->scanning == 0)
927 {
928 ieee->scanning = 1;
929 //ieee80211_softmac_scan(ieee);
930 // queue_work(ieee->wq, &ieee->softmac_scan_wq);
931 //care this,1203,2007,by lawrence
932#if 1
933 queue_delayed_work(ieee->wq, &ieee->softmac_scan_wq,0);
934#endif
935 }
936 }else
937 ieee->start_scan(ieee->dev);
938
939}
940
941/* called with wx_sem held */
942void ieee80211_start_scan_syncro(struct ieee80211_device *ieee)
943{
944#ifdef ENABLE_DOT11D
945 if(IS_DOT11D_ENABLE(ieee) )
946 {
947 if(IS_COUNTRY_IE_VALID(ieee))
948 {
949 RESET_CIE_WATCHDOG(ieee);
950 }
951 }
952#endif
953 ieee->sync_scan_hurryup = 0;
954
955 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN)
956 ieee80211_softmac_scan_syncro(ieee);
957 else
958 ieee->scan_syncro(ieee->dev);
959
960}
961
962inline struct sk_buff *ieee80211_authentication_req(struct ieee80211_network *beacon,
963 struct ieee80211_device *ieee, int challengelen)
964{
965 struct sk_buff *skb;
966 struct ieee80211_authentication *auth;
967
968 skb = dev_alloc_skb(sizeof(struct ieee80211_authentication) + challengelen);
969
970 if (!skb) return NULL;
971
972 auth = (struct ieee80211_authentication *)
973 skb_put(skb, sizeof(struct ieee80211_authentication));
974
975 auth->header.frame_ctl = IEEE80211_STYPE_AUTH;
976 if (challengelen) auth->header.frame_ctl |= IEEE80211_FCTL_WEP;
977
978 auth->header.duration_id = 0x013a; //FIXME
979
980 memcpy(auth->header.addr1, beacon->bssid, ETH_ALEN);
981 memcpy(auth->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
982 memcpy(auth->header.addr3, beacon->bssid, ETH_ALEN);
983
984 auth->algorithm = ieee->open_wep ? WLAN_AUTH_OPEN : WLAN_AUTH_SHARED_KEY;
985
986 auth->transaction = cpu_to_le16(ieee->associate_seq);
987 ieee->associate_seq++;
988
989 auth->status = cpu_to_le16(WLAN_STATUS_SUCCESS);
990
991 return skb;
992
993}
994
995static struct sk_buff* ieee80211_probe_resp(struct ieee80211_device *ieee, u8 *dest)
996{
997 u8 *tag;
998 int beacon_size;
999 struct ieee80211_probe_response *beacon_buf;
1000 struct sk_buff *skb;
1001 int encrypt;
1002 int atim_len,erp_len;
1003 struct ieee80211_crypt_data* crypt;
1004
1005 char *ssid = ieee->current_network.ssid;
1006 int ssid_len = ieee->current_network.ssid_len;
1007 int rate_len = ieee->current_network.rates_len+2;
1008 int rate_ex_len = ieee->current_network.rates_ex_len;
1009 int wpa_ie_len = ieee->wpa_ie_len;
1010 if(rate_ex_len > 0) rate_ex_len+=2;
1011
1012 if(ieee->current_network.capability & WLAN_CAPABILITY_IBSS)
1013 atim_len = 4;
1014 else
1015 atim_len = 0;
1016
1017 if(ieee80211_is_54g(ieee->current_network))
1018 erp_len = 3;
1019 else
1020 erp_len = 0;
1021
1022 beacon_size = sizeof(struct ieee80211_probe_response)+
1023 ssid_len
1024 +3 //channel
1025 +rate_len
1026 +rate_ex_len
1027 +atim_len
1028 +wpa_ie_len
1029 +erp_len;
1030
1031 skb = dev_alloc_skb(beacon_size);
1032
1033 if (!skb)
1034 return NULL;
1035
1036 beacon_buf = (struct ieee80211_probe_response*) skb_put(skb, beacon_size);
1037
1038 memcpy (beacon_buf->header.addr1, dest,ETH_ALEN);
1039 memcpy (beacon_buf->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1040 memcpy (beacon_buf->header.addr3, ieee->current_network.bssid, ETH_ALEN);
1041
1042 beacon_buf->header.duration_id = 0; //FIXME
1043 beacon_buf->beacon_interval =
1044 cpu_to_le16(ieee->current_network.beacon_interval);
1045 beacon_buf->capability =
1046 cpu_to_le16(ieee->current_network.capability & WLAN_CAPABILITY_IBSS);
1047
1048 if(ieee->short_slot && (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_SLOT))
1049 cpu_to_le16((beacon_buf->capability |= WLAN_CAPABILITY_SHORT_SLOT));
1050
1051 crypt = ieee->crypt[ieee->tx_keyidx];
1052
1053 encrypt = ieee->host_encrypt && crypt && crypt->ops &&
1054 ((0 == strcmp(crypt->ops->name, "WEP")) || wpa_ie_len);
1055
1056 if (encrypt)
1057 beacon_buf->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
1058
1059
1060 beacon_buf->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_PROBE_RESP);
1061
1062 beacon_buf->info_element.id = MFIE_TYPE_SSID;
1063 beacon_buf->info_element.len = ssid_len;
1064
1065 tag = (u8*) beacon_buf->info_element.data;
1066
1067 memcpy(tag, ssid, ssid_len);
1068
1069 tag += ssid_len;
1070
1071 *(tag++) = MFIE_TYPE_RATES;
1072 *(tag++) = rate_len-2;
1073 memcpy(tag,ieee->current_network.rates,rate_len-2);
1074 tag+=rate_len-2;
1075
1076 *(tag++) = MFIE_TYPE_DS_SET;
1077 *(tag++) = 1;
1078 *(tag++) = ieee->current_network.channel;
1079
1080 if(atim_len){
1081 *(tag++) = MFIE_TYPE_IBSS_SET;
1082 *(tag++) = 2;
1083 *((u16*)(tag)) = cpu_to_le16(ieee->current_network.atim_window);
1084 tag+=2;
1085 }
1086
1087 if(erp_len){
1088 *(tag++) = MFIE_TYPE_ERP;
1089 *(tag++) = 1;
1090 *(tag++) = 0;
1091 }
1092
1093 if(rate_ex_len){
1094 *(tag++) = MFIE_TYPE_RATES_EX;
1095 *(tag++) = rate_ex_len-2;
1096 memcpy(tag,ieee->current_network.rates_ex,rate_ex_len-2);
1097 tag+=rate_ex_len-2;
1098 }
1099
1100 if (wpa_ie_len)
1101 {
1102 if (ieee->iw_mode == IW_MODE_ADHOC)
1103 {//as Windows will set pairwise key same as the group key which is not allowed in Linux, so set this for IOT issue. WB 2008.07.07
1104 memcpy(&ieee->wpa_ie[14], &ieee->wpa_ie[8], 4);
1105 }
1106
1107 memcpy(tag, ieee->wpa_ie, ieee->wpa_ie_len);
1108 }
1109
1110 skb->dev = ieee->dev;
1111 return skb;
1112}
1113#ifdef _RTL8187_EXT_PATCH_
1114struct sk_buff* ieee80211_ext_probe_resp_by_net(struct ieee80211_device *ieee, u8 *dest, struct ieee80211_network *net)
1115{
1116 u8 *tag;
1117 int beacon_size;
1118 struct ieee80211_probe_response *beacon_buf;
1119 struct sk_buff *skb;
1120 int encrypt;
1121 int atim_len,erp_len;
1122 struct ieee80211_crypt_data* crypt;
1123 u8 broadcast_addr[] = {0xff,0xff,0xff,0xff,0xff,0xff};
1124 int wpa_ie_len = ieee->wpa_ie_len;
1125 char *ssid = net->ssid;
1126 int ssid_len = net->ssid_len;
1127
1128 int rate_len = ieee->current_network.rates_len+2;
1129 int rate_ex_len = ieee->current_network.rates_ex_len;
1130 if(rate_ex_len > 0) rate_ex_len+=2;
1131
1132 if( ieee->meshScanMode&4)
1133 ieee->current_network.channel = ieee->ext_patch_ieee80211_ext_stop_scan_wq_set_channel(ieee);
1134 if( ieee->meshScanMode&6)
1135 {
1136
1137#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
1138 queue_work(ieee->wq, &ieee->ext_stop_scan_wq);
1139#else
1140 schedule_task(&ieee->ext_stop_scan_wq);
1141#endif
1142 }
1143 if(ieee->current_network.capability & WLAN_CAPABILITY_IBSS) // use current_network here
1144 atim_len = 4;
1145 else
1146 atim_len = 0;
1147
1148 if(ieee80211_is_54g(*net))
1149 erp_len = 3;
1150 else
1151 erp_len = 0;
1152
1153 beacon_size = sizeof(struct ieee80211_probe_response)+
1154 ssid_len
1155 +3 //channel
1156 +rate_len
1157 +rate_ex_len
1158 +atim_len
1159 +erp_len;
1160//b
1161 skb = dev_alloc_skb(beacon_size+196);
1162
1163 if (!skb)
1164 return NULL;
1165
1166 beacon_buf = (struct ieee80211_probe_response*) skb_put(skb, beacon_size);
1167
1168 memcpy (beacon_buf->header.addr1, dest,ETH_ALEN);
1169 memcpy (beacon_buf->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1170 memcpy (beacon_buf->header.addr3, ieee->current_network.bssid, ETH_ALEN);
1171
1172 beacon_buf->header.duration_id = 0; //FIXME
1173
1174 beacon_buf->beacon_interval =
1175 cpu_to_le16(ieee->current_network.beacon_interval); // use current_network here
1176 beacon_buf->capability =
1177 cpu_to_le16(ieee->current_network.capability & WLAN_CAPABILITY_IBSS);
1178
1179 if(ieee->short_slot && (ieee->current_network.capability & WLAN_CAPABILITY_SHORT_SLOT))
1180 cpu_to_le16((beacon_buf->capability |= WLAN_CAPABILITY_SHORT_SLOT));
1181
1182 crypt = ieee->crypt[ieee->tx_keyidx];
1183
1184 encrypt = ieee->host_encrypt && crypt && crypt->ops &&
1185 ((0 == strcmp(crypt->ops->name, "WEP"))||wpa_ie_len);
1186
1187 if (encrypt)
1188 beacon_buf->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
1189
1190
1191 beacon_buf->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_PROBE_RESP);
1192
1193 beacon_buf->info_element.id = MFIE_TYPE_SSID;
1194 beacon_buf->info_element.len = ssid_len;
1195
1196 tag = (u8*) beacon_buf->info_element.data;
1197
1198 // brocad cast / probe rsp
1199 if(memcmp(dest, broadcast_addr, ETH_ALEN ))
1200 memcpy(tag, ssid, ssid_len);
1201 else
1202 ssid_len=0;
1203
1204 tag += ssid_len;
1205
1206//get_bssrate_set(priv, _SUPPORTEDRATES_IE_, &pbssrate, &bssrate_len);
1207//pbuf = set_ie(pbuf, _SUPPORTEDRATES_IE_, bssrate_len, pbssrate, &frlen);
1208
1209 *(tag++) = MFIE_TYPE_RATES;
1210 *(tag++) = rate_len-2;
1211 memcpy(tag,ieee->current_network.rates,rate_len-2);
1212 tag+=rate_len-2;
1213
1214 *(tag++) = MFIE_TYPE_DS_SET;
1215 *(tag++) = 1;
1216 *(tag++) = ieee->current_network.channel; // use current_network here
1217
1218
1219 if(atim_len){
1220 *(tag++) = MFIE_TYPE_IBSS_SET;
1221 *(tag++) = 2;
1222 *((u16*)(tag)) = cpu_to_le16(ieee->current_network.atim_window); // use current_network here
1223 tag+=2;
1224 }
1225
1226 if(erp_len){
1227 *(tag++) = MFIE_TYPE_ERP;
1228 *(tag++) = 1;
1229 *(tag++) = 0;
1230 }
1231
1232 if(rate_ex_len){
1233 *(tag++) = MFIE_TYPE_RATES_EX;
1234 *(tag++) = rate_ex_len-2;
1235 memcpy(tag,ieee->current_network.rates_ex,rate_ex_len-2);
1236 tag+=rate_ex_len-2;
1237 }
1238 if (wpa_ie_len)
1239 memcpy(tag, ieee->wpa_ie, ieee->wpa_ie_len);
1240
1241 skb->dev = ieee->dev;
1242 return skb;
1243}
1244#endif // _RTL8187_EXT_PATCH_
1245
1246struct sk_buff* ieee80211_assoc_resp(struct ieee80211_device *ieee, u8 *dest)
1247{
1248 struct sk_buff *skb;
1249 u8* tag;
1250
1251 struct ieee80211_crypt_data* crypt;
1252 struct ieee80211_assoc_response_frame *assoc;
1253 short encrypt;
1254
1255 unsigned int rate_len = ieee80211_MFIE_rate_len(ieee);
1256 int len = sizeof(struct ieee80211_assoc_response_frame) + rate_len;
1257
1258 skb = dev_alloc_skb(len);
1259
1260 if (!skb)
1261 return NULL;
1262
1263 assoc = (struct ieee80211_assoc_response_frame *)
1264 skb_put(skb,sizeof(struct ieee80211_assoc_response_frame));
1265
1266 assoc->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP);
1267 memcpy(assoc->header.addr1, dest,ETH_ALEN);
1268 memcpy(assoc->header.addr3, ieee->dev->dev_addr, ETH_ALEN);
1269 memcpy(assoc->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1270 assoc->capability = cpu_to_le16(ieee->iw_mode == IW_MODE_MASTER ?
1271 WLAN_CAPABILITY_BSS : WLAN_CAPABILITY_IBSS);
1272
1273
1274 if(ieee->short_slot)
1275 assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT);
1276
1277 if (ieee->host_encrypt)
1278 crypt = ieee->crypt[ieee->tx_keyidx];
1279 else crypt = NULL;
1280
1281 encrypt = ( crypt && crypt->ops);
1282
1283 if (encrypt)
1284 assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
1285
1286 assoc->status = 0;
1287 assoc->aid = cpu_to_le16(ieee->assoc_id);
1288 if (ieee->assoc_id == 0x2007) ieee->assoc_id=0;
1289 else ieee->assoc_id++;
1290
1291 tag = (u8*) skb_put(skb, rate_len);
1292
1293 ieee80211_MFIE_Brate(ieee, &tag);
1294 ieee80211_MFIE_Grate(ieee, &tag);
1295
1296 return skb;
1297}
1298
1299struct sk_buff* ieee80211_auth_resp(struct ieee80211_device *ieee,int status, u8 *dest)
1300{
1301 struct sk_buff *skb;
1302 struct ieee80211_authentication *auth;
1303
1304 skb = dev_alloc_skb(sizeof(struct ieee80211_authentication)+1);
1305
1306 if (!skb)
1307 return NULL;
1308
1309 skb->len = sizeof(struct ieee80211_authentication);
1310
1311 auth = (struct ieee80211_authentication *)skb->data;
1312
1313 auth->status = cpu_to_le16(status);
1314 auth->transaction = cpu_to_le16(2);
1315 auth->algorithm = cpu_to_le16(WLAN_AUTH_OPEN);
1316
1317#ifdef _RTL8187_EXT_PATCH_
1318 if(ieee->iw_mode == ieee->iw_ext_mode)
1319 memcpy(auth->header.addr3, dest, ETH_ALEN);
1320#else
1321 memcpy(auth->header.addr3, ieee->dev->dev_addr, ETH_ALEN);
1322#endif
1323 memcpy(auth->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1324 memcpy(auth->header.addr1, dest, ETH_ALEN);
1325 auth->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_AUTH);
1326 return skb;
1327
1328
1329}
1330
1331struct sk_buff* ieee80211_null_func(struct ieee80211_device *ieee,short pwr)
1332{
1333 struct sk_buff *skb;
1334 struct ieee80211_hdr_3addr* hdr;
1335
1336 skb = dev_alloc_skb(sizeof(struct ieee80211_hdr_3addr));
1337
1338 if (!skb)
1339 return NULL;
1340
1341 hdr = (struct ieee80211_hdr_3addr*)skb_put(skb,sizeof(struct ieee80211_hdr_3addr));
1342
1343 memcpy(hdr->addr1, ieee->current_network.bssid, ETH_ALEN);
1344 memcpy(hdr->addr2, ieee->dev->dev_addr, ETH_ALEN);
1345 memcpy(hdr->addr3, ieee->current_network.bssid, ETH_ALEN);
1346
1347 hdr->frame_ctl = cpu_to_le16(IEEE80211_FTYPE_DATA |
1348 IEEE80211_STYPE_NULLFUNC | IEEE80211_FCTL_TODS |
1349 (pwr ? IEEE80211_FCTL_PM:0));
1350
1351 return skb;
1352
1353
1354}
1355
1356
1357void ieee80211_resp_to_assoc_rq(struct ieee80211_device *ieee, u8* dest)
1358{
1359 struct sk_buff *buf = ieee80211_assoc_resp(ieee, dest);
1360
1361 if (buf){
1362 softmac_mgmt_xmit(buf, ieee);
1363 dev_kfree_skb_any(buf);//edit by thomas
1364 }
1365}
1366
1367
1368void ieee80211_resp_to_auth(struct ieee80211_device *ieee, int s, u8* dest)
1369{
1370 struct sk_buff *buf = ieee80211_auth_resp(ieee, s, dest);
1371
1372 if (buf){
1373 softmac_mgmt_xmit(buf, ieee);
1374 dev_kfree_skb_any(buf);//edit by thomas
1375 }
1376}
1377
1378
1379void ieee80211_resp_to_probe(struct ieee80211_device *ieee, u8 *dest)
1380{
1381
1382 struct sk_buff *buf = ieee80211_probe_resp(ieee, dest);
1383
1384 if (buf) {
1385 softmac_mgmt_xmit(buf, ieee);
1386 dev_kfree_skb_any(buf);//edit by thomas
1387 }
1388}
1389
1390
1391inline struct sk_buff *ieee80211_association_req(struct ieee80211_network *beacon,struct ieee80211_device *ieee)
1392{
1393 struct sk_buff *skb;
1394 //unsigned long flags;
1395
1396 struct ieee80211_assoc_request_frame *hdr;
1397 u8 *tag;
1398 //short info_addr = 0;
1399 //int i;
1400 //u16 suite_count = 0;
1401 //u8 suit_select = 0;
1402 unsigned int wpa_len = beacon->wpa_ie_len;
1403 //struct net_device *dev = ieee->dev;
1404 //union iwreq_data wrqu;
1405 //u8 *buff;
1406 //u8 *p;
1407#if 1
1408 // for testing purpose
1409 unsigned int rsn_len = beacon->rsn_ie_len;
1410#else
1411 unsigned int rsn_len = beacon->rsn_ie_len - 4;
1412#endif
1413 unsigned int rate_len = ieee80211_MFIE_rate_len(ieee);
1414 unsigned int wmm_info_len = beacon->QoS_Enable?9:0;
1415#ifdef THOMAS_TURBO
1416 unsigned int turbo_info_len = beacon->Turbo_Enable?9:0;
1417#endif
1418
1419 u8 encry_proto = ieee->wpax_type_notify & 0xff;
1420 //u8 pairwise_type = (ieee->wpax_type_notify >> 8) & 0xff;
1421 //u8 authen_type = (ieee->wpax_type_notify >> 16) & 0xff;
1422
1423 int len = 0;
1424
1425 //[0] Notify type of encryption: WPA/WPA2
1426 //[1] pair wise type
1427 //[2] authen type
1428 if(ieee->wpax_type_set) {
1429 if (IEEE_PROTO_WPA == encry_proto) {
1430 rsn_len = 0;
1431 } else if (IEEE_PROTO_RSN == encry_proto) {
1432 wpa_len = 0;
1433 }
1434 }
1435#ifdef THOMAS_TURBO
1436 len = sizeof(struct ieee80211_assoc_request_frame)+
1437 + beacon->ssid_len//essid tagged val
1438 + rate_len//rates tagged val
1439 + wpa_len
1440 + rsn_len
1441 + wmm_info_len
1442 + turbo_info_len;
1443#else
1444 len = sizeof(struct ieee80211_assoc_request_frame)+
1445 + beacon->ssid_len//essid tagged val
1446 + rate_len//rates tagged val
1447 + wpa_len
1448 + rsn_len
1449 + wmm_info_len;
1450#endif
1451
1452#ifdef _RTL8187_EXT_PATCH_
1453 if(ieee->iw_mode == ieee->iw_ext_mode)
1454 skb = dev_alloc_skb(len+256); // stanley
1455 else
1456#endif
1457 skb = dev_alloc_skb(len);
1458
1459 if (!skb)
1460 return NULL;
1461
1462 hdr = (struct ieee80211_assoc_request_frame *)
1463 skb_put(skb, sizeof(struct ieee80211_assoc_request_frame));
1464
1465
1466 hdr->header.frame_ctl = IEEE80211_STYPE_ASSOC_REQ;
1467 hdr->header.duration_id= 37; //FIXME
1468 memcpy(hdr->header.addr1, beacon->bssid, ETH_ALEN);
1469 memcpy(hdr->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1470 memcpy(hdr->header.addr3, beacon->bssid, ETH_ALEN);
1471 memcpy(ieee->ap_mac_addr, beacon->bssid, ETH_ALEN);//for HW security, John
1472
1473 hdr->capability = cpu_to_le16(WLAN_CAPABILITY_BSS);
1474 if (beacon->capability & WLAN_CAPABILITY_PRIVACY )
1475 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
1476 if (beacon->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
1477 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
1478
1479 if(ieee->short_slot)
1480 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT);
1481
1482#ifdef _RTL8187_EXT_PATCH_
1483 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_association_req_1)
1484 ieee->ext_patch_ieee80211_association_req_1(hdr);
1485#endif
1486
1487 hdr->listen_interval = 0xa; //FIXME
1488
1489 hdr->info_element.id = MFIE_TYPE_SSID;
1490
1491 hdr->info_element.len = beacon->ssid_len;
1492 tag = skb_put(skb, beacon->ssid_len);
1493 memcpy(tag, beacon->ssid, beacon->ssid_len);
1494
1495 tag = skb_put(skb, rate_len);
1496
1497 ieee80211_MFIE_Brate(ieee, &tag);
1498 ieee80211_MFIE_Grate(ieee, &tag);
1499
1500 //add rsn==0 condition for ap's mix security mode(wpa+wpa2), john2007.8.9
1501 //choose AES encryption as default algorithm while using mixed mode
1502#if 0
1503 if(rsn_len == 0){
1504
1505 tag = skb_put(skb,wpa_len);
1506
1507 if(wpa_len) {
1508
1509
1510 //{add by david. 2006.8.31
1511 //fix linksys compatibility bug
1512 //}
1513 if(wpa_len > 24) {//22+2, mean include the capability
1514 beacon->wpa_ie[wpa_len - 2] = 0;
1515 }
1516 //multicast cipher OUI
1517 if( beacon->wpa_ie[11]==0x2 ){ //0x0050f202 is the oui of tkip
1518 ieee->broadcast_key_type = KEY_TYPE_TKIP;
1519 }
1520 else if( beacon->wpa_ie[11]==0x4 ){//0x0050f204 is the oui of ccmp
1521 ieee->broadcast_key_type = KEY_TYPE_CCMP;
1522 }
1523 //unicast cipher OUI
1524 if( beacon->wpa_ie[14]==0
1525 && beacon->wpa_ie[15]==0x50
1526 && beacon->wpa_ie[16]==0xf2
1527 && beacon->wpa_ie[17]==0x2 ){ //0x0050f202 is the oui of tkip
1528 ieee->pairwise_key_type = KEY_TYPE_TKIP;
1529 }
1530
1531 else if( beacon->wpa_ie[14]==0
1532 && beacon->wpa_ie[15]==0x50
1533 && beacon->wpa_ie[16]==0xf2
1534 && beacon->wpa_ie[17]==0x4 ){//0x0050f204 is the oui of ccmp
1535 ieee->pairwise_key_type = KEY_TYPE_CCMP;
1536 }
1537 //indicate the wpa_ie content to WPA_SUPPLICANT
1538 buff = kmalloc(IW_CUSTOM_MAX, GFP_ATOMIC);
1539 memset(buff, 0, IW_CUSTOM_MAX);
1540 p=buff;
1541 p += sprintf(p, "ASSOCINFO(ReqIEs=");
1542 for(i=0;i<wpa_len;i++){
1543 p += sprintf(p, "%02x", beacon->wpa_ie[i]);
1544 }
1545 p += sprintf(p, ")");
1546 memset(&wrqu, 0, sizeof(wrqu) );
1547 wrqu.data.length = p - buff;
1548
1549 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buff);
1550 memcpy(tag,beacon->wpa_ie,wpa_len);
1551 }
1552
1553 }
1554
1555 if(rsn_len > 22) {
1556
1557 if( beacon->rsn_ie[4]==0x0 &&
1558 beacon->rsn_ie[5]==0xf &&
1559 beacon->rsn_ie[6]==0xac){
1560
1561 switch(beacon->rsn_ie[7]){
1562 case 0x1:
1563 ieee->broadcast_key_type = KEY_TYPE_WEP40;
1564 break;
1565 case 0x2:
1566 ieee->broadcast_key_type = KEY_TYPE_TKIP;
1567 break;
1568 case 0x4:
1569 ieee->broadcast_key_type = KEY_TYPE_CCMP;
1570 break;
1571 case 0x5:
1572 ieee->broadcast_key_type = KEY_TYPE_WEP104;
1573 break;
1574 default:
1575 printk("fault suite type in RSN broadcast key\n");
1576 break;
1577 }
1578 }
1579
1580 if( beacon->rsn_ie[10]==0x0 &&
1581 beacon->rsn_ie[11]==0xf &&
1582 beacon->rsn_ie[12]==0xac){
1583 if(beacon->rsn_ie[8]==1){//not mixed mode
1584 switch(beacon->rsn_ie[13]){
1585 case 0x2:
1586 ieee->pairwise_key_type = KEY_TYPE_TKIP;
1587 break;
1588 case 0x4:
1589 ieee->pairwise_key_type = KEY_TYPE_CCMP;
1590 break;
1591 default:
1592 printk("fault suite type in RSN pairwise key\n");
1593 break;
1594 }
1595 }
1596 else if(beacon->rsn_ie[8]==2){//mixed mode
1597 ieee->pairwise_key_type = KEY_TYPE_CCMP;
1598 }
1599 }
1600
1601
1602
1603 tag = skb_put(skb,22);
1604 memcpy(tag,(beacon->rsn_ie + info_addr),8);
1605 tag[1] = 20;
1606 tag += 8;
1607 info_addr += 8;
1608
1609 spin_lock_irqsave(&ieee->wpax_suitlist_lock,flags);
1610 for (i = 0; i < 2; i++) {
1611 tag[0] = 1;
1612 tag[1] = 0;
1613 tag += 2;
1614 suite_count = beacon->rsn_ie[info_addr] + \
1615 (beacon->rsn_ie[info_addr + 1] << 8);
1616 info_addr += 2;
1617 if(1 == suite_count) {
1618 memcpy(tag,(beacon->rsn_ie + info_addr),4);
1619 info_addr += 4;
1620 } else {
1621 // if the wpax_type_notify has been set by the application,
1622 // just use it, otherwise just use the default one.
1623 if(ieee->wpax_type_set) {
1624 suit_select = ((0 == i) ? pairwise_type:authen_type)&0x0f ;
1625 memcpy(tag,rsn_authen_cipher_suite[suit_select],4);
1626 } else {
1627 //default set as ccmp, or none authentication
1628 if(i == 0) {
1629 memcpy(tag,rsn_authen_cipher_suite[4],4);
1630 } else {
1631 memcpy(tag,rsn_authen_cipher_suite[2],4);
1632 }
1633
1634 }
1635
1636 info_addr += (suite_count * 4);
1637 }
1638 tag += 4;
1639 }
1640 spin_unlock_irqrestore(&ieee->wpax_suitlist_lock,flags);
1641
1642 tag[0] = 0;
1643 tag[1] = beacon->rsn_ie[info_addr+1];
1644
1645 } else {
1646 tag = skb_put(skb,rsn_len);
1647 if(rsn_len) {
1648
1649
1650 if( beacon->rsn_ie[4]==0x0 &&
1651 beacon->rsn_ie[5]==0xf &&
1652 beacon->rsn_ie[6]==0xac){
1653 switch(beacon->rsn_ie[7]){
1654 case 0x1:
1655 ieee->broadcast_key_type = KEY_TYPE_WEP40;
1656 break;
1657 case 0x2:
1658 ieee->broadcast_key_type = KEY_TYPE_TKIP;
1659 break;
1660 case 0x4:
1661 ieee->broadcast_key_type = KEY_TYPE_CCMP;
1662 break;
1663 case 0x5:
1664 ieee->broadcast_key_type = KEY_TYPE_WEP104;
1665 break;
1666 default:
1667 printk("fault suite type in RSN broadcast key\n");
1668 break;
1669 }
1670 }
1671 if( beacon->rsn_ie[10]==0x0 &&
1672 beacon->rsn_ie[11]==0xf &&
1673 beacon->rsn_ie[12]==0xac){
1674 if(beacon->rsn_ie[8]==1){//not mixed mode
1675 switch(beacon->rsn_ie[13]){
1676 case 0x2:
1677 ieee->pairwise_key_type = KEY_TYPE_TKIP;
1678 break;
1679 case 0x4:
1680 ieee->pairwise_key_type = KEY_TYPE_CCMP;
1681 break;
1682 default:
1683 printk("fault suite type in RSN pairwise key\n");
1684 break;
1685 }
1686
1687 }
1688 else if(beacon->rsn_ie[8]==2){//mixed mode
1689 ieee->pairwise_key_type = KEY_TYPE_CCMP;
1690 }
1691 }
1692
1693
1694 beacon->rsn_ie[rsn_len - 2] = 0;
1695 memcpy(tag,beacon->rsn_ie,rsn_len);
1696 }
1697 }
1698#else
1699 tag = skb_put(skb,ieee->wpa_ie_len);
1700 memcpy(tag,ieee->wpa_ie,ieee->wpa_ie_len);
1701#endif
1702 tag = skb_put(skb,wmm_info_len);
1703 if(wmm_info_len) {
1704 ieee80211_WMM_Info(ieee, &tag);
1705 }
1706#ifdef THOMAS_TURBO
1707 tag = skb_put(skb,turbo_info_len);
1708 if(turbo_info_len) {
1709 ieee80211_TURBO_Info(ieee, &tag);
1710 }
1711#endif
1712
1713#ifdef _RTL8187_EXT_PATCH_
1714 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_association_req_2)
1715 ieee->ext_patch_ieee80211_association_req_2(ieee, beacon, skb);
1716#endif
1717
1718 return skb;
1719}
1720
1721void ieee80211_associate_abort(struct ieee80211_device *ieee)
1722{
1723
1724 unsigned long flags;
1725 spin_lock_irqsave(&ieee->lock, flags);
1726
1727 ieee->associate_seq++;
1728
1729 /* don't scan, and avoid to have the RX path possibily
1730 * try again to associate. Even do not react to AUTH or
1731 * ASSOC response. Just wait for the retry wq to be scheduled.
1732 * Here we will check if there are good nets to associate
1733 * with, so we retry or just get back to NO_LINK and scanning
1734 */
1735 if (ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATING){
1736 IEEE80211_DEBUG_MGMT("Authentication failed\n");
1737 ieee->softmac_stats.no_auth_rs++;
1738 }else{
1739 IEEE80211_DEBUG_MGMT("Association failed\n");
1740 ieee->softmac_stats.no_ass_rs++;
1741 }
1742
1743 ieee->state = IEEE80211_ASSOCIATING_RETRY;
1744
1745 queue_delayed_work(ieee->wq, &ieee->associate_retry_wq,IEEE80211_SOFTMAC_ASSOC_RETRY_TIME);
1746
1747 spin_unlock_irqrestore(&ieee->lock, flags);
1748}
1749
1750void ieee80211_associate_abort_cb(unsigned long dev)
1751{
1752 ieee80211_associate_abort((struct ieee80211_device *) dev);
1753}
1754
1755
1756void ieee80211_associate_step1(struct ieee80211_device *ieee)
1757{
1758 struct ieee80211_network *beacon = &ieee->current_network;
1759 struct sk_buff *skb;
1760
1761 IEEE80211_DEBUG_MGMT("Stopping scan\n");
1762 ieee->softmac_stats.tx_auth_rq++;
1763 skb=ieee80211_authentication_req(beacon, ieee, 0);
1764#ifdef _RTL8187_EXT_PATCH_
1765 if(ieee->iw_mode == ieee->iw_ext_mode ) {
1766 if(skb)
1767 softmac_mgmt_xmit(skb, ieee);
1768 return;
1769 }else
1770#endif
1771 if (!skb){
1772
1773 ieee80211_associate_abort(ieee);
1774 }
1775 else{
1776 ieee->state = IEEE80211_ASSOCIATING_AUTHENTICATING ;
1777 IEEE80211_DEBUG_MGMT("Sending authentication request\n");
1778 //printk("---Sending authentication request\n");
1779 softmac_mgmt_xmit(skb, ieee);
1780 //BUGON when you try to add_timer twice, using mod_timer may be better, john0709
1781 if(!timer_pending(&ieee->associate_timer)){
1782 ieee->associate_timer.expires = jiffies + (HZ / 2);
1783 add_timer(&ieee->associate_timer);
1784 }
1785 //If call dev_kfree_skb_any,a warning will ocur....
1786 //KERNEL: assertion (!atomic_read(&skb->users)) failed at net/core/dev.c (1708)
1787 //So ... 1204 by lawrence.
d599edca 1788 //printk("\nIn %s,line %d call kfree skb.",__func__,__LINE__);
c8d86be3
GKH		 1789 //dev_kfree_skb_any(skb);//edit by thomas
1790 }
1791}
1792
1793void ieee80211_auth_challenge(struct ieee80211_device *ieee, u8 *challenge, int chlen)
1794{
1795 u8 *c;
1796 struct sk_buff *skb;
1797 struct ieee80211_network *beacon = &ieee->current_network;
1798// int hlen = sizeof(struct ieee80211_authentication);
1799 del_timer_sync(&ieee->associate_timer);
1800 ieee->associate_seq++;
1801 ieee->softmac_stats.tx_auth_rq++;
1802
1803 skb = ieee80211_authentication_req(beacon, ieee, chlen+2);
1804 if (!skb)
1805 ieee80211_associate_abort(ieee);
1806 else{
1807 c = skb_put(skb, chlen+2);
1808 *(c++) = MFIE_TYPE_CHALLENGE;
1809 *(c++) = chlen;
1810 memcpy(c, challenge, chlen);
1811
1812 IEEE80211_DEBUG_MGMT("Sending authentication challenge response\n");
1813
1814 ieee80211_encrypt_fragment(ieee, skb, sizeof(struct ieee80211_hdr_3addr ));
1815
1816 softmac_mgmt_xmit(skb, ieee);
1817 if (!timer_pending(&ieee->associate_timer)){
1818 //printk("=========>add timer again, to crash\n");
1819 ieee->associate_timer.expires = jiffies + (HZ / 2);
1820 add_timer(&ieee->associate_timer);
1821 }
1822 dev_kfree_skb_any(skb);//edit by thomas
1823 }
1824 kfree(challenge);
1825}
1826
1827#ifdef _RTL8187_EXT_PATCH_
1828
1829// based on ieee80211_assoc_resp
1830struct sk_buff* ieee80211_assoc_resp_by_net(struct ieee80211_device *ieee, u8 *dest, unsigned short status, struct ieee80211_network *pstat, int pkt_type)
1831{
1832 struct sk_buff *skb;
1833 u8* tag;
1834
1835 struct ieee80211_crypt_data* crypt;
1836 struct ieee80211_assoc_response_frame *assoc;
1837 short encrypt;
1838
1839 unsigned int rate_len = ieee80211_MFIE_rate_len(ieee);
1840 int len = sizeof(struct ieee80211_assoc_response_frame) + rate_len;
1841
1842 if(ieee->iw_mode == ieee->iw_ext_mode)
1843 skb = dev_alloc_skb(len+256); // stanley
1844 else
1845 skb = dev_alloc_skb(len);
1846
1847 if (!skb)
1848 return NULL;
1849
1850 assoc = (struct ieee80211_assoc_response_frame *)
1851 skb_put(skb,sizeof(struct ieee80211_assoc_response_frame));
1852
1853 assoc->header.frame_ctl = cpu_to_le16(pkt_type);
1854
1855 memcpy(assoc->header.addr1, dest,ETH_ALEN);
1856 memcpy(assoc->header.addr3, ieee->dev->dev_addr, ETH_ALEN);
1857 memcpy(assoc->header.addr2, ieee->dev->dev_addr, ETH_ALEN);
1858 assoc->capability = cpu_to_le16(ieee->iw_mode == IW_MODE_MASTER ?
1859 WLAN_CAPABILITY_BSS : WLAN_CAPABILITY_IBSS);
1860
1861 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_assoc_resp_by_net_1)
1862 ieee->ext_patch_ieee80211_assoc_resp_by_net_1(assoc);
1863
1864 if(ieee->short_slot)
1865 assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT);
1866
1867 if (ieee->host_encrypt)
1868 crypt = ieee->crypt[ieee->tx_keyidx];
1869 else crypt = NULL;
1870
1871 encrypt = ( crypt && crypt->ops);
1872
1873 if (encrypt)
1874 assoc->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
1875
1876 assoc->status = 0;
1877 assoc->aid = cpu_to_le16(ieee->assoc_id);
1878 if (ieee->assoc_id == 0x2007) ieee->assoc_id=0;
1879 else ieee->assoc_id++;
1880
1881 assoc->info_element.id = 230; // Stanley, an unused id (just a hot fix)
1882 assoc->info_element.len = 0;
1883
1884 tag = (u8*) skb_put(skb, rate_len);
1885
1886 ieee80211_MFIE_Brate(ieee, &tag);
1887 ieee80211_MFIE_Grate(ieee, &tag);
1888
1889 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_assoc_resp_by_net_2)
1890 ieee->ext_patch_ieee80211_assoc_resp_by_net_2(ieee, pstat, pkt_type, skb);
1891
1892 return skb;
1893}
1894
1895// based on ieee80211_resp_to_assoc_rq
1896void ieee80211_ext_issue_assoc_rsp(struct ieee80211_device *ieee, u8 *dest, unsigned short status, struct ieee80211_network *pstat, int pkt_type)
1897{
1898 struct sk_buff *buf = ieee80211_assoc_resp_by_net(ieee, dest, status, pstat, pkt_type);
1899
1900 if (buf)
1901 softmac_mgmt_xmit(buf, ieee);
1902}
1903
1904// based on ieee80211_associate_step2
1905void ieee80211_ext_issue_assoc_req(struct ieee80211_device *ieee, struct ieee80211_network *pstat)
1906{
1907
1908 struct sk_buff* skb;
1909
1910 // printk("@@@@@ ieee80211_ext_issue_assoc_req on channel: %d\n", ieee->current_network.channel);
1911
1912 ieee->softmac_stats.tx_ass_rq++;
1913 skb=ieee80211_association_req(pstat, ieee);
1914 if (skb)
1915 softmac_mgmt_xmit(skb, ieee);
1916}
1917
1918void ieee80211_ext_issue_disassoc(struct ieee80211_device *ieee, struct ieee80211_network *pstat, int reason, unsigned char extReason)
1919{
1920 // do nothing
1921 // printk("@@@@@ ieee80211_ext_issue_disassoc\n");
1922 return;
1923}
1924#endif // _RTL8187_EXT_PATCH_
1925
1926void ieee80211_associate_step2(struct ieee80211_device *ieee)
1927{
1928 struct sk_buff* skb;
1929 struct ieee80211_network *beacon = &ieee->current_network;
1930
1931 del_timer_sync(&ieee->associate_timer);
1932
1933 IEEE80211_DEBUG_MGMT("Sending association request\n");
1934 ieee->softmac_stats.tx_ass_rq++;
1935 skb=ieee80211_association_req(beacon, ieee);
1936 if (!skb)
1937 ieee80211_associate_abort(ieee);
1938 else{
1939 softmac_mgmt_xmit(skb, ieee);
1940 if (!timer_pending(&ieee->associate_timer)){
1941 ieee->associate_timer.expires = jiffies + (HZ / 2);
1942 add_timer(&ieee->associate_timer);
1943 }
1944 //dev_kfree_skb_any(skb);//edit by thomas
1945 }
1946}
1947
1948#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
1949void ieee80211_associate_complete_wq(struct work_struct *work)
1950{
1951 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, associate_complete_wq);
1952#else
1953void ieee80211_associate_complete_wq(struct ieee80211_device *ieee)
1954{
1955#endif
1956 printk(KERN_INFO "Associated successfully\n");
1957 if(ieee80211_is_54g(ieee->current_network) &&
1958 (ieee->modulation & IEEE80211_OFDM_MODULATION)){
1959
1960 ieee->rate = 540;
1961 printk(KERN_INFO"Using G rates\n");
1962 }else{
1963 ieee->rate = 110;
1964 printk(KERN_INFO"Using B rates\n");
1965 }
1966 ieee->link_change(ieee->dev);
1967 notify_wx_assoc_event(ieee);
1968 if (ieee->data_hard_resume)
1969 ieee->data_hard_resume(ieee->dev);
1970 netif_carrier_on(ieee->dev);
1971}
1972
1973void ieee80211_associate_complete(struct ieee80211_device *ieee)
1974{
1975 int i;
1976 del_timer_sync(&ieee->associate_timer);
1977
1978 for(i = 0; i < 6; i++) {
1979 //ieee->seq_ctrl[i] = 0;
1980 }
1981 ieee->state = IEEE80211_LINKED;
1982 IEEE80211_DEBUG_MGMT("Successfully associated\n");
1983
1984 queue_work(ieee->wq, &ieee->associate_complete_wq);
1985}
1986
1987#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
1988void ieee80211_associate_procedure_wq(struct work_struct *work)
1989{
1990 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, associate_procedure_wq);
1991#else
1992void ieee80211_associate_procedure_wq(struct ieee80211_device *ieee)
1993{
1994#endif
1995 ieee->sync_scan_hurryup = 1;
1996 down(&ieee->wx_sem);
1997
1998 if (ieee->data_hard_stop)
1999 ieee->data_hard_stop(ieee->dev);
2000
2001 ieee80211_stop_scan(ieee);
2002 ieee->set_chan(ieee->dev, ieee->current_network.channel);
2003
2004 ieee->associate_seq = 1;
2005 ieee80211_associate_step1(ieee);
2006
2007 up(&ieee->wx_sem);
2008}
2009#ifdef _RTL8187_EXT_PATCH_
2010// based on ieee80211_associate_procedure_wq
2011
2012#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2013void ieee80211_ext_stop_scan_wq(struct work_struct *work)
2014{
2015 struct ieee80211_device *ieee = container_of(work, struct ieee80211_device, ext_stop_scan_wq);
2016#else
2017void ieee80211_ext_stop_scan_wq(struct ieee80211_device *ieee)
2018{
2019#endif
2020 if (ieee->scanning == 0)
2021 {
2022 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_ext_stop_scan_wq_set_channel
2023 && ( ieee->current_network.channel == ieee->ext_patch_ieee80211_ext_stop_scan_wq_set_channel(ieee) ) )
2024 return;
2025 }
2026
2027 ieee->sync_scan_hurryup = 1;
2028
2029 down(&ieee->wx_sem);
2030
2031 // printk("@@@@@@@@@@ ieee80211_ext_stop_scan_wq\n");
2032 if (ieee->data_hard_stop)
2033 ieee->data_hard_stop(ieee->dev);
2034
2035 ieee80211_stop_scan(ieee);
2036
2037 // set channel
2038 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_ext_stop_scan_wq_set_channel)
2039 ieee->set_chan(ieee->dev, ieee->ext_patch_ieee80211_ext_stop_scan_wq_set_channel(ieee));
2040 else
2041 ieee->set_chan(ieee->dev, ieee->current_network.channel);
2042 //
2043 up(&ieee->wx_sem);
2044}
2045
2046
2047void ieee80211_ext_send_11s_beacon(struct ieee80211_device *ieee)
2048{
2049 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
2050 queue_work(ieee->wq, &ieee->ext_send_beacon_wq);
2051 #else
2052 schedule_task(&ieee->ext_send_beacon_wq);
2053 #endif
2054
2055}
2056
2057#endif // _RTL8187_EXT_PATCH_
2058
2059inline void ieee80211_softmac_new_net(struct ieee80211_device *ieee, struct ieee80211_network *net)
2060{
2061 u8 tmp_ssid[IW_ESSID_MAX_SIZE+1];
2062 int tmp_ssid_len = 0;
2063
2064 short apset,ssidset,ssidbroad,apmatch,ssidmatch;
2065
2066 /* we are interested in new new only if we are not associated
2067 * and we are not associating / authenticating
2068 */
2069 if (ieee->state != IEEE80211_NOLINK)
2070 return;
2071
2072 if ((ieee->iw_mode == IW_MODE_INFRA) && !(net->capability & WLAN_CAPABILITY_BSS))
2073 return;
2074
2075 if ((ieee->iw_mode == IW_MODE_ADHOC) && !(net->capability & WLAN_CAPABILITY_IBSS))
2076 return;
2077
2078
2079 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC){
2080 /* if the user specified the AP MAC, we need also the essid
2081 * This could be obtained by beacons or, if the network does not
2082 * broadcast it, it can be put manually.
2083 */
2084 apset = ieee->wap_set;//(memcmp(ieee->current_network.bssid, zero,ETH_ALEN)!=0 );
2085 ssidset = ieee->ssid_set;//ieee->current_network.ssid[0] != '\0';
2086 ssidbroad = !(net->ssid_len == 0 || net->ssid[0]== '\0');
2087 apmatch = (memcmp(ieee->current_network.bssid, net->bssid, ETH_ALEN)==0);
2088
2089 if(ieee->current_network.ssid_len != net->ssid_len)
2090 ssidmatch = 0;
2091 else
2092 ssidmatch = (0==strncmp(ieee->current_network.ssid, net->ssid, net->ssid_len));
2093
2094 //printk("cur: %s, %d, net:%s, %d\n", ieee->current_network.ssid, ieee->current_network.ssid_len, net->ssid, net->ssid_len);
2095 //printk("apset=%d apmatch=%d ssidset=%d ssidbroad=%d ssidmatch=%d\n",apset,apmatch,ssidset,ssidbroad,ssidmatch);
2096
2097 if ( /* if the user set the AP check if match.
2098 * if the network does not broadcast essid we check the user supplyed ANY essid
2099 * if the network does broadcast and the user does not set essid it is OK
2100 * if the network does broadcast and the user did set essid chech if essid match
2101 */
2102 ( apset && apmatch &&
2103 ((ssidset && ssidbroad && ssidmatch) || (ssidbroad && !ssidset) || (!ssidbroad && ssidset)) ) ||
2104 /* if the ap is not set, check that the user set the bssid
2105 * and the network does bradcast and that those two bssid matches
2106 */
2107 (!apset && ssidset && ssidbroad && ssidmatch)
2108 ){
2109
2110
2111 /* if the essid is hidden replace it with the
2112 * essid provided by the user.
2113 */
2114 if (!ssidbroad){
2115 strncpy(tmp_ssid, ieee->current_network.ssid, IW_ESSID_MAX_SIZE);
2116 tmp_ssid_len = ieee->current_network.ssid_len;
2117 }
2118 memcpy(&ieee->current_network, net, sizeof(struct ieee80211_network));
2119
2120 if (!ssidbroad){
2121 strncpy(ieee->current_network.ssid, tmp_ssid, IW_ESSID_MAX_SIZE);
2122 ieee->current_network.ssid_len = tmp_ssid_len;
2123 }
2124 printk(KERN_INFO"Linking with %s: channel is %d\n",ieee->current_network.ssid,ieee->current_network.channel);
2125
2126 if (ieee->iw_mode == IW_MODE_INFRA){
2127 ieee->state = IEEE80211_ASSOCIATING;
2128 ieee->beinretry = false;
2129 queue_work(ieee->wq, &ieee->associate_procedure_wq);
2130 }else{
2131 if(ieee80211_is_54g(ieee->current_network) &&
2132 (ieee->modulation & IEEE80211_OFDM_MODULATION)){
2133 ieee->rate = 540;
2134 printk(KERN_INFO"Using G rates\n");
2135 }else{
2136 ieee->rate = 110;
2137 printk(KERN_INFO"Using B rates\n");
2138 }
2139 ieee->state = IEEE80211_LINKED;
2140 ieee->beinretry = false;
2141 }
2142
2143 }
2144 }
2145
2146}
2147
2148void ieee80211_softmac_check_all_nets(struct ieee80211_device *ieee)
2149{
2150 unsigned long flags;
2151 struct ieee80211_network *target;
2152
2153 spin_lock_irqsave(&ieee->lock, flags);
2154 list_for_each_entry(target, &ieee->network_list, list) {
2155
2156 /* if the state become different that NOLINK means
2157 * we had found what we are searching for
2158 */
2159
2160 if (ieee->state != IEEE80211_NOLINK)
2161 break;
2162
2163 if (ieee->scan_age == 0 || time_after(target->last_scanned + ieee->scan_age, jiffies))
2164 ieee80211_softmac_new_net(ieee, target);
2165 }
2166
2167 spin_unlock_irqrestore(&ieee->lock, flags);
2168
2169}
2170
2171
2172static inline u16 auth_parse(struct sk_buff *skb, u8** challenge, int *chlen)
2173{
2174 struct ieee80211_authentication *a;
2175 u8 *t;
2176 if (skb->len < (sizeof(struct ieee80211_authentication)-sizeof(struct ieee80211_info_element))){
2177 IEEE80211_DEBUG_MGMT("invalid len in auth resp: %d\n",skb->len);
2178 return 0xcafe;
2179 }
2180 *challenge = NULL;
2181 a = (struct ieee80211_authentication*) skb->data;
2182 if(skb->len > (sizeof(struct ieee80211_authentication) +3)){
2183 t = skb->data + sizeof(struct ieee80211_authentication);
2184
2185 if(*(t++) == MFIE_TYPE_CHALLENGE){
2186 *chlen = *(t++);
2187 *challenge = (u8*)kmalloc(*chlen, GFP_ATOMIC);
2188 memcpy(*challenge, t, *chlen);
2189 }
2190 }
2191
2192 return cpu_to_le16(a->status);
2193
2194}
2195
2196
2197int auth_rq_parse(struct sk_buff *skb,u8* dest)
2198{
2199 struct ieee80211_authentication *a;
2200
2201 if (skb->len < (sizeof(struct ieee80211_authentication)-sizeof(struct ieee80211_info_element))){
2202 IEEE80211_DEBUG_MGMT("invalid len in auth request: %d\n",skb->len);
2203 return -1;
2204 }
2205 a = (struct ieee80211_authentication*) skb->data;
2206
2207 memcpy(dest,a->header.addr2, ETH_ALEN);
2208
2209 if (le16_to_cpu(a->algorithm) != WLAN_AUTH_OPEN)
2210 return WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG;
2211
2212 return WLAN_STATUS_SUCCESS;
2213}
2214
2215static short probe_rq_parse(struct ieee80211_device *ieee, struct sk_buff *skb, u8 *src)
2216{
2217 u8 *tag;
2218 u8 *skbend;
2219 u8 *ssid=NULL;
2220 u8 ssidlen = 0;
2221
2222 struct ieee80211_hdr_3addr *header =
2223 (struct ieee80211_hdr_3addr *) skb->data;
2224
2225 if (skb->len < sizeof (struct ieee80211_hdr_3addr ))
2226 return -1; /* corrupted */
2227
2228 memcpy(src,header->addr2, ETH_ALEN);
2229
2230 skbend = (u8*)skb->data + skb->len;
2231
2232 tag = skb->data + sizeof (struct ieee80211_hdr_3addr );
2233
2234 while (tag+1 < skbend){
2235 if (*tag == 0){
2236 ssid = tag+2;
2237 ssidlen = *(tag+1);
2238 break;
2239 }
2240 tag++; /* point to the len field */
2241 tag = tag + *(tag); /* point to the last data byte of the tag */
2242 tag++; /* point to the next tag */
2243 }
2244
2245 //IEEE80211DMESG("Card MAC address is "MACSTR, MAC2STR(src));
2246 if (ssidlen == 0) return 1;
2247
2248 if (!ssid) return 1; /* ssid not found in tagged param */
2249 return (!strncmp(ssid, ieee->current_network.ssid, ssidlen));
2250
2251}
2252
2253int assoc_rq_parse(struct sk_buff *skb,u8* dest)
2254{
2255 struct ieee80211_assoc_request_frame *a;
2256
2257 if (skb->len < (sizeof(struct ieee80211_assoc_request_frame) -
2258 sizeof(struct ieee80211_info_element))) {
2259
2260 IEEE80211_DEBUG_MGMT("invalid len in auth request:%d \n", skb->len);
2261 return -1;
2262 }
2263
2264 a = (struct ieee80211_assoc_request_frame*) skb->data;
2265
2266 memcpy(dest,a->header.addr2,ETH_ALEN);
2267
2268 return 0;
2269}
2270
2271static inline u16 assoc_parse(struct sk_buff *skb, int *aid)
2272{
2273 struct ieee80211_assoc_response_frame *a;
2274 if (skb->len < sizeof(struct ieee80211_assoc_response_frame)){
2275 IEEE80211_DEBUG_MGMT("invalid len in auth resp: %d\n", skb->len);
2276 return 0xcafe;
2277 }
2278
2279 a = (struct ieee80211_assoc_response_frame*) skb->data;
2280 *aid = le16_to_cpu(a->aid) & 0x3fff;
2281 return le16_to_cpu(a->status);
2282}
2283
2284static inline void
2285ieee80211_rx_probe_rq(struct ieee80211_device *ieee, struct sk_buff *skb)
2286{
2287 u8 dest[ETH_ALEN];
2288
2289 //IEEE80211DMESG("Rx probe");
2290 ieee->softmac_stats.rx_probe_rq++;
2291 //DMESG("Dest is "MACSTR, MAC2STR(dest));
2292 if (probe_rq_parse(ieee, skb, dest)){
2293 //IEEE80211DMESG("Was for me!");
2294 ieee->softmac_stats.tx_probe_rs++;
2295 ieee80211_resp_to_probe(ieee, dest);
2296 }
2297}
2298
2299inline void
2300ieee80211_rx_auth_rq(struct ieee80211_device *ieee, struct sk_buff *skb)
2301{
2302 u8 dest[ETH_ALEN];
2303 int status;
2304 //IEEE80211DMESG("Rx probe");
2305 ieee->softmac_stats.rx_auth_rq++;
2306
2307 if ((status = auth_rq_parse(skb, dest))!= -1){
2308 ieee80211_resp_to_auth(ieee, status, dest);
2309 }
2310 //DMESG("Dest is "MACSTR, MAC2STR(dest));
2311
2312}
2313
2314 inline void
2315ieee80211_rx_assoc_rq(struct ieee80211_device *ieee, struct sk_buff *skb)
2316{
2317
2318 u8 dest[ETH_ALEN];
2319 //unsigned long flags;
2320
2321 ieee->softmac_stats.rx_ass_rq++;
2322 if (assoc_rq_parse(skb,dest) != -1){
2323 ieee80211_resp_to_assoc_rq(ieee, dest);
2324 }
2325
2326 printk(KERN_INFO"New client associated: "MAC_FMT"\n", MAC_ARG(dest));
2327 //FIXME
2328 #if 0
2329 spin_lock_irqsave(&ieee->lock,flags);
2330 add_associate(ieee,dest);
2331 spin_unlock_irqrestore(&ieee->lock,flags);
2332 #endif
2333}
2334
2335
2336
2337void ieee80211_sta_ps_send_null_frame(struct ieee80211_device *ieee, short pwr)
2338{
2339
2340 struct sk_buff *buf = ieee80211_null_func(ieee, pwr);
2341
2342 if (buf)
2343 softmac_ps_mgmt_xmit(buf, ieee);
2344
2345}
2346
2347
2348short ieee80211_sta_ps_sleep(struct ieee80211_device *ieee, u32 *time_h, u32 *time_l)
2349{
2350#if 0
2351 int timeout = ieee->ps_timeout;
2352#else
2353 int timeout = 0;
2354#endif
2355 u8 dtim;
2356 /*if(ieee->ps == IEEE80211_PS_DISABLED ||
2357 ieee->iw_mode != IW_MODE_INFRA ||
2358 ieee->state != IEEE80211_LINKED)
2359
2360 return 0;
2361 */
2362 dtim = ieee->current_network.dtim_data;
2363 //printk("DTIM\n");
2364
2365 if(!(dtim & IEEE80211_DTIM_VALID))
2366 return 0;
2367 else
2368 timeout = ieee->current_network.beacon_interval;
2369
2370 //printk("VALID\n");
2371 ieee->current_network.dtim_data = IEEE80211_DTIM_INVALID;
2372
2373 if(dtim & ((IEEE80211_DTIM_UCAST | IEEE80211_DTIM_MBCAST)& ieee->ps))
2374 return 2;
2375
2376 if(!time_after(jiffies, ieee->dev->trans_start + MSECS(timeout)))
2377 return 0;
2378
2379 if(!time_after(jiffies, ieee->last_rx_ps_time + MSECS(timeout)))
2380 return 0;
2381
2382 if((ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE ) &&
2383 (ieee->mgmt_queue_tail != ieee->mgmt_queue_head))
2384 return 0;
2385#if 0
2386 if(time_l){
2387 *time_l = ieee->current_network.last_dtim_sta_time[0]
2388 + (ieee->current_network.beacon_interval
2389 * ieee->current_network.dtim_period) * 1000;
2390 }
2391#else
2392 if(time_l){
2393 *time_l = ieee->current_network.last_dtim_sta_time[0]
2394 + MSECS((ieee->current_network.beacon_interval));
2395 //* ieee->current_network.dtim_period));
2396 //printk("beacon_interval:%x, dtim_period:%x, totol to Msecs:%x, HZ:%x\n", ieee->current_network.beacon_interval, ieee->current_network.dtim_period, MSECS(((ieee->current_network.beacon_interval * ieee->current_network.dtim_period))), HZ);
2397 }
2398
2399#endif
2400 if(time_h){
2401 *time_h = ieee->current_network.last_dtim_sta_time[1];
2402 if(time_l && *time_l < ieee->current_network.last_dtim_sta_time[0])
2403 *time_h += 1;
2404 }
2405
2406 return 1;
2407
2408
2409}
2410
2411inline void ieee80211_sta_ps(struct ieee80211_device *ieee)
2412{
2413
2414 u32 th,tl;
2415 short sleep;
2416
2417 unsigned long flags,flags2;
2418
2419 spin_lock_irqsave(&ieee->lock, flags);
2420
2421 if((ieee->ps == IEEE80211_PS_DISABLED ||
2422
2423 ieee->iw_mode != IW_MODE_INFRA ||
2424 ieee->state != IEEE80211_LINKED)){
2425
2426 //#warning CHECK_LOCK_HERE
2427 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
2428
2429 ieee80211_sta_wakeup(ieee, 1);
2430
2431 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
2432 }
2433
2434 sleep = ieee80211_sta_ps_sleep(ieee,&th, &tl);
d599edca 2435// printk("===>%s,%d[2 wake, 1 sleep, 0 do nothing], ieee->sta_sleep = %d\n",__func__, sleep,ieee->sta_sleep);
c8d86be3
GKH		 2436 /* 2 wake, 1 sleep, 0 do nothing */
2437 if(sleep == 0)
2438 goto out;
2439
2440 if(sleep == 1){
2441
2442 if(ieee->sta_sleep == 1)
2443 ieee->enter_sleep_state(ieee->dev,th,tl);
2444
2445 else if(ieee->sta_sleep == 0){
2446 // printk("send null 1\n");
2447 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
2448
2449 if(ieee->ps_is_queue_empty(ieee->dev)){
2450
2451
2452 ieee->sta_sleep = 2;
2453
2454 ieee->ps_request_tx_ack(ieee->dev);
2455
2456 ieee80211_sta_ps_send_null_frame(ieee,1);
2457
2458 ieee->ps_th = th;
2459 ieee->ps_tl = tl;
2460 }
2461 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
2462
2463 }
2464
2465
2466 }else if(sleep == 2){
2467//#warning CHECK_LOCK_HERE
2468 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
2469
2470 // printk("send wakeup packet\n");
2471 ieee80211_sta_wakeup(ieee,1);
2472
2473 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
2474 }
2475
2476out:
2477 spin_unlock_irqrestore(&ieee->lock, flags);
2478
2479}
2480
2481void ieee80211_sta_wakeup(struct ieee80211_device *ieee, short nl)
2482{
2483 if(ieee->sta_sleep == 0){
2484 if(nl){
2485 // printk("Warning: driver is probably failing to report TX ps error\n");
2486 ieee->ps_request_tx_ack(ieee->dev);
2487 ieee80211_sta_ps_send_null_frame(ieee, 0);
2488 }
2489 return;
2490
2491 }
2492
2493 if(ieee->sta_sleep == 1)
2494 ieee->sta_wake_up(ieee->dev);
2495
2496 ieee->sta_sleep = 0;
2497
2498 if(nl){
2499 ieee->ps_request_tx_ack(ieee->dev);
2500 ieee80211_sta_ps_send_null_frame(ieee, 0);
2501 }
2502}
2503
2504void ieee80211_ps_tx_ack(struct ieee80211_device *ieee, short success)
2505{
2506 unsigned long flags,flags2;
2507
2508 spin_lock_irqsave(&ieee->lock, flags);
2509 if(ieee->sta_sleep == 2){
2510 /* Null frame with PS bit set */
2511 if(success){
2512
d599edca 2513 // printk("==================> %s::enter sleep state\n",__func__);
c8d86be3
GKH		 2514 ieee->sta_sleep = 1;
2515 ieee->enter_sleep_state(ieee->dev,ieee->ps_th,ieee->ps_tl);
2516 }
2517 /* if the card report not success we can't be sure the AP
2518 * has not RXed so we can't assume the AP believe us awake
2519 */
2520 }
2521 /* 21112005 - tx again null without PS bit if lost */
2522 else {
2523
2524 if((ieee->sta_sleep == 0) && !success){
2525 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
2526 ieee80211_sta_ps_send_null_frame(ieee, 0);
2527 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
2528 }
2529 }
2530 spin_unlock_irqrestore(&ieee->lock, flags);
2531}
2532
2533inline int
2534ieee80211_rx_frame_softmac(struct ieee80211_device *ieee, struct sk_buff *skb,
2535 struct ieee80211_rx_stats *rx_stats, u16 type,
2536 u16 stype)
2537{
2538 struct ieee80211_hdr_3addr *header = (struct ieee80211_hdr_3addr *) skb->data;
2539 u16 errcode;
2540 u8* challenge=NULL;
2541 int chlen=0;
2542 int aid=0;
2543 struct ieee80211_assoc_response_frame *assoc_resp;
2544 struct ieee80211_info_element *info_element;
2545
2546 if(!ieee->proto_started)
2547 return 0;
2548
2549 if(ieee->sta_sleep || (ieee->ps != IEEE80211_PS_DISABLED &&
2550 ieee->iw_mode == IW_MODE_INFRA &&
2551 ieee->state == IEEE80211_LINKED))
2552
2553 tasklet_schedule(&ieee->ps_task);
2554
2555 if(WLAN_FC_GET_STYPE(header->frame_ctl) != IEEE80211_STYPE_PROBE_RESP &&
2556 WLAN_FC_GET_STYPE(header->frame_ctl) != IEEE80211_STYPE_BEACON)
2557 ieee->last_rx_ps_time = jiffies;
2558
2559 switch (WLAN_FC_GET_STYPE(header->frame_ctl)) {
2560
2561 case IEEE80211_STYPE_ASSOC_RESP:
2562 case IEEE80211_STYPE_REASSOC_RESP:
2563
2564 IEEE80211_DEBUG_MGMT("received [RE]ASSOCIATION RESPONSE (%d)\n",
2565 WLAN_FC_GET_STYPE(header->frame_ctl));
2566 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&
2567 ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATED &&
2568 ieee->iw_mode == IW_MODE_INFRA){
2569 if (0 == (errcode=assoc_parse(skb, &aid))){
2570 u16 left;
2571
2572 ieee->state=IEEE80211_LINKED;
2573 ieee->assoc_id = aid;
2574 ieee->softmac_stats.rx_ass_ok++;
2575
2576 //printk(KERN_WARNING "nic_type = %s", (rx_stats->nic_type == 1)?"rtl8187":"rtl8187B");
2577 if(1 == rx_stats->nic_type) //card type is 8187
2578 {
2579 goto associate_complete;
2580 }
2581 assoc_resp = (struct ieee80211_assoc_response_frame*)skb->data;
2582 info_element = &assoc_resp->info_element;
2583 left = skb->len - ((void*)info_element - (void*)assoc_resp);
2584
2585 while (left >= sizeof(struct ieee80211_info_element_hdr)) {
2586 if (sizeof(struct ieee80211_info_element_hdr) + info_element->len > left) {
2587 printk(KERN_WARNING "[re]associate reeponse error!");
2588 return 1;
2589 }
2590 switch (info_element->id) {
2591 case MFIE_TYPE_GENERIC:
2592 IEEE80211_DEBUG_SCAN("MFIE_TYPE_GENERIC: %d bytes\n", info_element->len);
2593 if (info_element->len >= 8 &&
2594 info_element->data[0] == 0x00 &&
2595 info_element->data[1] == 0x50 &&
2596 info_element->data[2] == 0xf2 &&
2597 info_element->data[3] == 0x02 &&
2598 info_element->data[4] == 0x01) {
2599 // Not care about version at present.
2600 //WMM Parameter Element
2601 memcpy(ieee->current_network.wmm_param,(u8*)(info_element->data\
2602 + 8),(info_element->len - 8));
2603
2604 if (((ieee->current_network.wmm_info^info_element->data[6])& \
2605 0x0f)||(!ieee->init_wmmparam_flag)) {
2606 //refresh paramete element for current network
2607 // update the register parameter for hardware
2608 ieee->init_wmmparam_flag = 1;
2609 queue_work(ieee->wq, &ieee->wmm_param_update_wq);
2610
2611 }
2612 //update info_element for current network
2613 ieee->current_network.wmm_info = info_element->data[6];
2614 }
2615 break;
2616 default:
2617 //nothing to do at present!!!
2618 break;
2619 }
2620
2621 left -= sizeof(struct ieee80211_info_element_hdr) +
2622 info_element->len;
2623 info_element = (struct ieee80211_info_element *)
2624 &info_element->data[info_element->len];
2625 }
2626 if(!ieee->init_wmmparam_flag) //legacy AP, reset the AC_xx_param register
2627 {
2628 queue_work(ieee->wq,&ieee->wmm_param_update_wq);
2629 ieee->init_wmmparam_flag = 1;//indicate AC_xx_param upated since last associate
2630 }
2631associate_complete:
2632 ieee80211_associate_complete(ieee);
2633 }else{
2634 ieee->softmac_stats.rx_ass_err++;
2635 IEEE80211_DEBUG_MGMT(
2636 "Association response status code 0x%x\n",
2637 errcode);
2638 ieee80211_associate_abort(ieee);
2639 }
2640 }
2641#ifdef _RTL8187_EXT_PATCH_
2642 else if ((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_rx_frame_softmac_on_assoc_rsp)
2643 {
2644 ieee->ext_patch_ieee80211_rx_frame_softmac_on_assoc_rsp(ieee, skb);
2645 }
2646#endif
2647 break;
2648
2649 case IEEE80211_STYPE_ASSOC_REQ:
2650 case IEEE80211_STYPE_REASSOC_REQ:
2651
2652 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&
2653 ieee->iw_mode == IW_MODE_MASTER)
2654
2655 ieee80211_rx_assoc_rq(ieee, skb);
2656#ifdef _RTL8187_EXT_PATCH_
2657 else if ((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_rx_frame_softmac_on_assoc_req)
2658 {
2659 ieee->ext_patch_ieee80211_rx_frame_softmac_on_assoc_req(ieee, skb);
2660 }
2661#endif
2662 break;
2663
2664 case IEEE80211_STYPE_AUTH:
2665
2666#ifdef _RTL8187_EXT_PATCH_
2667printk("IEEE80211_STYPE_AUTH\n");
2668 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_rx_frame_softmac_on_auth)
2669 if( ieee->ext_patch_ieee80211_rx_frame_softmac_on_auth(ieee, skb, rx_stats) );
2670#endif
2671 if (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE){
2672 if (ieee->state == IEEE80211_ASSOCIATING_AUTHENTICATING &&
2673 ieee->iw_mode == IW_MODE_INFRA){
2674
2675 IEEE80211_DEBUG_MGMT("Received authentication response");
2676
2677 if (0 == (errcode=auth_parse(skb, &challenge, &chlen))){
2678 if(ieee->open_wep || !challenge){
2679 ieee->state = IEEE80211_ASSOCIATING_AUTHENTICATED;
2680 ieee->softmac_stats.rx_auth_rs_ok++;
2681
2682 ieee80211_associate_step2(ieee);
2683 }else{
2684 ieee80211_auth_challenge(ieee, challenge, chlen);
2685 }
2686 }else{
2687 ieee->softmac_stats.rx_auth_rs_err++;
2688 IEEE80211_DEBUG_MGMT("Authentication respose status code 0x%x",errcode);
2689 ieee80211_associate_abort(ieee);
2690 }
2691
2692 }else if (ieee->iw_mode == IW_MODE_MASTER){
2693 ieee80211_rx_auth_rq(ieee, skb);
2694 }
2695 }
2696 break;
2697
2698 case IEEE80211_STYPE_PROBE_REQ:
2699
2700 if ((ieee->softmac_features & IEEE_SOFTMAC_PROBERS) &&
2701 ((ieee->iw_mode == IW_MODE_ADHOC ||
2702 ieee->iw_mode == IW_MODE_MASTER) &&
2703 ieee->state == IEEE80211_LINKED))
2704
2705 ieee80211_rx_probe_rq(ieee, skb);
2706 break;
2707
2708 case IEEE80211_STYPE_DISASSOC:
2709 case IEEE80211_STYPE_DEAUTH:
2710#ifdef _RTL8187_EXT_PATCH_
2711printk("IEEE80211_STYPE_DEAUTH\n");
2712 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_rx_frame_softmac_on_deauth)
2713 if( ieee->ext_patch_ieee80211_rx_frame_softmac_on_deauth(ieee, skb, rx_stats) ) ;
2714#endif
2715 /* FIXME for now repeat all the association procedure
2716 * both for disassociation and deauthentication
2717 */
2718 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&
2719 (ieee->state == IEEE80211_LINKED) &&
2720 (ieee->iw_mode == IW_MODE_INFRA) &&
2721 (!memcmp(header->addr2,ieee->current_network.bssid,ETH_ALEN))){
2722 ieee->state = IEEE80211_ASSOCIATING;
2723 ieee->softmac_stats.reassoc++;
2724
2725 //notify_wx_assoc_event(ieee); //YJ,del,080828, do not notify os here
2726 queue_work(ieee->wq, &ieee->associate_procedure_wq);
2727 }
2728
2729 break;
2730
2731 default:
2732 return -1;
2733 break;
2734 }
2735
2736 //dev_kfree_skb_any(skb);
2737 return 0;
2738}
2739
2740
2741
2742/* following are for a simplier TX queue management.
2743 * Instead of using netif_[stop/wake]_queue the driver
2744 * will uses these two function (plus a reset one), that
2745 * will internally uses the kernel netif_* and takes
2746 * care of the ieee802.11 fragmentation.
2747 * So the driver receives a fragment per time and might
2748 * call the stop function when it want without take care
2749 * to have enought room to TX an entire packet.
2750 * This might be useful if each fragment need it's own
2751 * descriptor, thus just keep a total free memory > than
2752 * the max fragmentation treshold is not enought.. If the
2753 * ieee802.11 stack passed a TXB struct then you needed
2754 * to keep N free descriptors where
2755 * N = MAX_PACKET_SIZE / MIN_FRAG_TRESHOLD
2756 * In this way you need just one and the 802.11 stack
2757 * will take care of buffering fragments and pass them to
2758 * to the driver later, when it wakes the queue.
2759 */
2760
2761void ieee80211_softmac_xmit(struct ieee80211_txb *txb, struct ieee80211_device *ieee)
2762{
2763
2764
2765 unsigned long flags;
2766 int i;
2767#ifdef _RTL8187_EXT_PATCH_
2768 int rate = ieee->rate;
2769#endif
2770
2771 spin_lock_irqsave(&ieee->lock,flags);
2772 #if 0
2773 if(ieee->queue_stop){
2774 IEEE80211DMESG("EE: IEEE hard_start_xmit invoked when kernel queue should be stopped");
2775 netif_stop_queue(ieee->dev);
2776 ieee->ieee_stats.swtxstop++;
2777 //dev_kfree_skb_any(skb);
2778 err = 1;
2779 goto exit;
2780 }
2781
2782 ieee->stats.tx_bytes+=skb->len;
2783
2784
2785 txb=ieee80211_skb_to_txb(ieee,skb);
2786
2787
2788 if(txb==NULL){
2789 IEEE80211DMESG("WW: IEEE stack failed to provide txb");
2790 //dev_kfree_skb_any(skb);
2791 err = 1;
2792 goto exit;
2793 }
2794 #endif
2795
2796#ifdef _RTL8187_EXT_PATCH_
2797 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_ieee80211_softmac_xmit_get_rate && txb->nr_frags)
2798 {
2799 rate = ieee->ext_patch_ieee80211_softmac_xmit_get_rate(ieee, txb->fragments[0]);
2800 }
2801#endif
2802 /* called with 2nd parm 0, no tx mgmt lock required */
2803 ieee80211_sta_wakeup(ieee,0);
2804
2805 for(i = 0; i < txb->nr_frags; i++) {
2806
2807 if (ieee->queue_stop){
2808 ieee->tx_pending.txb = txb;
2809 ieee->tx_pending.frag = i;
2810 goto exit;
2811 }else{
2812 ieee->softmac_data_hard_start_xmit(
2813 txb->fragments[i],
2814#ifdef _RTL8187_EXT_PATCH_
2815 ieee->dev, rate);
2816#else
2817 ieee->dev,ieee->rate);
2818#endif
2819 //(i+1)<txb->nr_frags);
2820 ieee->stats.tx_packets++;
2821 ieee->stats.tx_bytes += txb->fragments[i]->len;
2822 ieee->dev->trans_start = jiffies;
2823 }
2824 }
2825
2826 ieee80211_txb_free(txb);
2827
2828 exit:
2829 spin_unlock_irqrestore(&ieee->lock,flags);
2830
2831}
2832
2833/* called with ieee->lock acquired */
2834void ieee80211_resume_tx(struct ieee80211_device *ieee)
2835{
2836 int i;
2837 for(i = ieee->tx_pending.frag; i < ieee->tx_pending.txb->nr_frags; i++) {
2838
2839 if (ieee->queue_stop){
2840 ieee->tx_pending.frag = i;
2841 return;
2842 }else{
2843
2844 ieee->softmac_data_hard_start_xmit(
2845 ieee->tx_pending.txb->fragments[i],
2846 ieee->dev,ieee->rate);
2847 //(i+1)<ieee->tx_pending.txb->nr_frags);
2848 ieee->stats.tx_packets++;
2849 ieee->dev->trans_start = jiffies;
2850 }
2851 }
2852
2853
2854 ieee80211_txb_free(ieee->tx_pending.txb);
2855 ieee->tx_pending.txb = NULL;
2856}
2857
2858
2859void ieee80211_reset_queue(struct ieee80211_device *ieee)
2860{
2861 unsigned long flags;
2862
2863 spin_lock_irqsave(&ieee->lock,flags);
2864 init_mgmt_queue(ieee);
2865 if (ieee->tx_pending.txb){
2866 ieee80211_txb_free(ieee->tx_pending.txb);
2867 ieee->tx_pending.txb = NULL;
2868 }
2869 ieee->queue_stop = 0;
2870 spin_unlock_irqrestore(&ieee->lock,flags);
2871
2872}
2873
2874void ieee80211_wake_queue(struct ieee80211_device *ieee)
2875{
2876
2877 unsigned long flags;
2878 struct sk_buff *skb;
2879 struct ieee80211_hdr_3addr *header;
2880
2881 spin_lock_irqsave(&ieee->lock,flags);
2882 if (! ieee->queue_stop) goto exit;
2883
2884 ieee->queue_stop = 0;
2885
2886 if(ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE){
2887 while (!ieee->queue_stop && (skb = dequeue_mgmt(ieee))){
2888
2889 header = (struct ieee80211_hdr_3addr *) skb->data;
2890
2891 header->seq_ctl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
2892
2893 if (ieee->seq_ctrl[0] == 0xFFF)
2894 ieee->seq_ctrl[0] = 0;
2895 else
2896 ieee->seq_ctrl[0]++;
2897
2898 //printk(KERN_ALERT "ieee80211_wake_queue \n");
2899 ieee->softmac_data_hard_start_xmit(skb,ieee->dev,ieee->basic_rate);
2900 dev_kfree_skb_any(skb);//edit by thomas
2901 }
2902 }
2903 if (!ieee->queue_stop && ieee->tx_pending.txb)
2904 ieee80211_resume_tx(ieee);
2905
2906 if (!ieee->queue_stop && netif_queue_stopped(ieee->dev)){
2907 ieee->softmac_stats.swtxawake++;
2908 netif_wake_queue(ieee->dev);
2909 }
2910
2911exit :
2912 spin_unlock_irqrestore(&ieee->lock,flags);
2913}
2914
2915
2916void ieee80211_stop_queue(struct ieee80211_device *ieee)
2917{
2918 //unsigned long flags;
2919 //spin_lock_irqsave(&ieee->lock,flags);
2920
2921 if (! netif_queue_stopped(ieee->dev)){
2922 netif_stop_queue(ieee->dev);
2923 ieee->softmac_stats.swtxstop++;
2924 }
2925 ieee->queue_stop = 1;
2926 //spin_unlock_irqrestore(&ieee->lock,flags);
2927
2928}
2929
2930
2931inline void ieee80211_randomize_cell(struct ieee80211_device *ieee)
2932{
2933
2934 get_random_bytes(ieee->current_network.bssid, ETH_ALEN);
2935
2936 /* an IBSS cell address must have the two less significant
2937 * bits of the first byte = 2
2938 */
2939 ieee->current_network.bssid[0] &= ~0x01;
2940 ieee->current_network.bssid[0] |= 0x02;
2941}
2942
2943/* called in user context only */
2944void ieee80211_start_master_bss(struct ieee80211_device *ieee)
2945{
2946 ieee->assoc_id = 1;
2947
2948 if (ieee->current_network.ssid_len == 0){
2949 strncpy(ieee->current_network.ssid,
2950 IEEE80211_DEFAULT_TX_ESSID,
2951 IW_ESSID_MAX_SIZE);
2952
2953 ieee->current_network.ssid_len = strlen(IEEE80211_DEFAULT_TX_ESSID);
2954 ieee->ssid_set = 1;
2955 }
2956
2957 memcpy(ieee->current_network.bssid, ieee->dev->dev_addr, ETH_ALEN);
2958
2959 ieee->set_chan(ieee->dev, ieee->current_network.channel);
2960 ieee->state = IEEE80211_LINKED;
2961 ieee->link_change(ieee->dev);
2962 notify_wx_assoc_event(ieee);
2963
2964 if (ieee->data_hard_resume)
2965 ieee->data_hard_resume(ieee->dev);
2966
2967 netif_carrier_on(ieee->dev);
2968}
2969
2970void ieee80211_start_monitor_mode(struct ieee80211_device *ieee)
2971{
2972 if(ieee->raw_tx){
2973
2974 if (ieee->data_hard_resume)
2975 ieee->data_hard_resume(ieee->dev);
2976
2977 netif_carrier_on(ieee->dev);
2978 }
2979}
2980#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
2981void ieee80211_start_ibss_wq(struct work_struct *work)
2982{
2983 struct delayed_work *dwork = container_of(work, struct delayed_work, work);
2984 struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, start_ibss_wq);
2985#else
2986void ieee80211_start_ibss_wq(struct ieee80211_device *ieee)
2987{
2988#endif
2989
2990 /* iwconfig mode ad-hoc will schedule this and return
2991 * on the other hand this will block further iwconfig SET
2992 * operations because of the wx_sem hold.
2993 * Anyway some most set operations set a flag to speed-up
2994 * (abort) this wq (when syncro scanning) before sleeping
2995 * on the semaphore
2996 */
2997
2998 down(&ieee->wx_sem);
2999
3000
3001 if (ieee->current_network.ssid_len == 0){
3002 strcpy(ieee->current_network.ssid,IEEE80211_DEFAULT_TX_ESSID);
3003 ieee->current_network.ssid_len = strlen(IEEE80211_DEFAULT_TX_ESSID);
3004 ieee->ssid_set = 1;
3005 }
3006
3007 /* check if we have this cell in our network list */
3008 ieee80211_softmac_check_all_nets(ieee);
3009
3010#ifdef ENABLE_DOT11D
3011 if(ieee->state == IEEE80211_NOLINK)
3012 ieee->current_network.channel = 10;
3013#endif
3014 /* if not then the state is not linked. Maybe the user swithced to
3015 * ad-hoc mode just after being in monitor mode, or just after
3016 * being very few time in managed mode (so the card have had no
3017 * time to scan all the chans..) or we have just run up the iface
3018 * after setting ad-hoc mode. So we have to give another try..
3019 * Here, in ibss mode, should be safe to do this without extra care
3020 * (in bss mode we had to make sure no-one tryed to associate when
3021 * we had just checked the ieee->state and we was going to start the
3022 * scan) beacause in ibss mode the ieee80211_new_net function, when
3023 * finds a good net, just set the ieee->state to IEEE80211_LINKED,
3024 * so, at worst, we waste a bit of time to initiate an unneeded syncro
3025 * scan, that will stop at the first round because it sees the state
3026 * associated.
3027 */
3028 if (ieee->state == IEEE80211_NOLINK)
3029 ieee80211_start_scan_syncro(ieee);
3030
3031 /* the network definitively is not here.. create a new cell */
3032 if (ieee->state == IEEE80211_NOLINK){
3033 printk("creating new IBSS cell\n");
3034 if(!ieee->wap_set)
3035 ieee80211_randomize_cell(ieee);
3036
3037 if(ieee->modulation & IEEE80211_CCK_MODULATION){
3038
3039 ieee->current_network.rates_len = 4;
3040
3041 ieee->current_network.rates[0] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
3042 ieee->current_network.rates[1] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
3043 ieee->current_network.rates[2] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_5MB;
3044 ieee->current_network.rates[3] = IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_11MB;
3045
3046 }else
3047 ieee->current_network.rates_len = 0;
3048
3049 if(ieee->modulation & IEEE80211_OFDM_MODULATION){
3050 ieee->current_network.rates_ex_len = 8;
3051
3052 ieee->current_network.rates_ex[0] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_6MB;
3053 ieee->current_network.rates_ex[1] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_9MB;
3054 ieee->current_network.rates_ex[2] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_12MB;
3055 ieee->current_network.rates_ex[3] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_18MB;
3056 ieee->current_network.rates_ex[4] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_24MB;
3057 ieee->current_network.rates_ex[5] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_36MB;
3058 ieee->current_network.rates_ex[6] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_48MB;
3059 ieee->current_network.rates_ex[7] = IEEE80211_BASIC_RATE_MASK | IEEE80211_OFDM_RATE_54MB;
3060
3061 ieee->rate = 540;
3062 }else{
3063 ieee->current_network.rates_ex_len = 0;
3064 ieee->rate = 110;
3065 }
3066
3067 // By default, WMM function will be disabled in IBSS mode
3068 ieee->current_network.QoS_Enable = 0;
3069
3070 ieee->current_network.atim_window = 0;
3071 ieee->current_network.capability = WLAN_CAPABILITY_IBSS;
3072 if(ieee->short_slot)
3073 ieee->current_network.capability |= WLAN_CAPABILITY_SHORT_SLOT;
3074
3075 }
3076
3077 ieee->state = IEEE80211_LINKED;
3078 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3079 ieee->link_change(ieee->dev);
3080
3081 notify_wx_assoc_event(ieee);
3082
3083 ieee80211_start_send_beacons(ieee);
3084 printk(KERN_WARNING "after sending beacon packet!\n");
3085
3086 if (ieee->data_hard_resume)
3087 ieee->data_hard_resume(ieee->dev);
3088
3089 netif_carrier_on(ieee->dev);
3090
3091 up(&ieee->wx_sem);
3092}
3093inline void ieee80211_start_ibss(struct ieee80211_device *ieee)
3094{
3095 queue_delayed_work(ieee->wq, &ieee->start_ibss_wq, 100);
3096}
3097
3098/* this is called only in user context, with wx_sem held */
3099void ieee80211_start_bss(struct ieee80211_device *ieee)
3100{
3101 unsigned long flags;
3102#ifdef ENABLE_DOT11D
3103 //
3104 // Ref: 802.11d 11.1.3.3
3105 // STA shall not start a BSS unless properly formed Beacon frame including a Country IE.
3106 //
3107 if(IS_DOT11D_ENABLE(ieee) && !IS_COUNTRY_IE_VALID(ieee))
3108 {
3109 if(! ieee->bGlobalDomain)
3110 {
3111 return;
3112 }
3113 }
3114#endif
3115 /* check if we have already found the net we
3116 * are interested in (if any).
3117 * if not (we are disassociated and we are not
3118 * in associating / authenticating phase) start the background scanning.
3119 */
3120 ieee80211_softmac_check_all_nets(ieee);
3121
3122 /* ensure no-one start an associating process (thus setting
3123 * the ieee->state to ieee80211_ASSOCIATING) while we
3124 * have just cheked it and we are going to enable scan.
3125 * The ieee80211_new_net function is always called with
3126 * lock held (from both ieee80211_softmac_check_all_nets and
3127 * the rx path), so we cannot be in the middle of such function
3128 */
3129 spin_lock_irqsave(&ieee->lock, flags);
3130
3131//#ifdef ENABLE_IPS
3132// printk("start bss ENABLE_IPS\n");
3133//#else
3134 if (ieee->state == IEEE80211_NOLINK){
3135 ieee->actscanning = true;
3136 ieee80211_start_scan(ieee);
3137 }
3138//#endif
3139 spin_unlock_irqrestore(&ieee->lock, flags);
3140}
3141
3142/* called only in userspace context */
3143void ieee80211_disassociate(struct ieee80211_device *ieee)
3144{
3145 netif_carrier_off(ieee->dev);
3146
3147 if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)
3148 ieee80211_reset_queue(ieee);
3149
3150 if (ieee->data_hard_stop)
3151 ieee->data_hard_stop(ieee->dev);
3152
3153#ifdef ENABLE_DOT11D
3154 if(IS_DOT11D_ENABLE(ieee))
3155 Dot11d_Reset(ieee);
3156#endif
3157 ieee->state = IEEE80211_NOLINK;
3158 ieee->link_change(ieee->dev);
3159 notify_wx_assoc_event(ieee);
3160
3161}
3162#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
3163void ieee80211_associate_retry_wq(struct work_struct *work)
3164{
3165 struct delayed_work *dwork = container_of(work, struct delayed_work, work);
3166 struct ieee80211_device *ieee = container_of(dwork, struct ieee80211_device, associate_retry_wq);
3167#else
3168void ieee80211_associate_retry_wq(struct ieee80211_device *ieee)
3169{
3170#endif
3171 unsigned long flags;
3172 down(&ieee->wx_sem);
3173 if(!ieee->proto_started)
3174 goto exit;
3175 if(ieee->state != IEEE80211_ASSOCIATING_RETRY)
3176 goto exit;
3177 /* until we do not set the state to IEEE80211_NOLINK
3178 * there are no possibility to have someone else trying
3179 * to start an association procdure (we get here with
3180 * ieee->state = IEEE80211_ASSOCIATING).
3181 * When we set the state to IEEE80211_NOLINK it is possible
3182 * that the RX path run an attempt to associate, but
3183 * both ieee80211_softmac_check_all_nets and the
3184 * RX path works with ieee->lock held so there are no
3185 * problems. If we are still disassociated then start a scan.
3186 * the lock here is necessary to ensure no one try to start
3187 * an association procedure when we have just checked the
3188 * state and we are going to start the scan.
3189 */
3190 ieee->state = IEEE80211_NOLINK;
3191 ieee->beinretry = true;
3192 ieee80211_softmac_check_all_nets(ieee);
3193
3194 spin_lock_irqsave(&ieee->lock, flags);
3195
3196 if(ieee->state == IEEE80211_NOLINK){
3197 ieee->beinretry = false;
3198 ieee->actscanning = true;
3199 ieee80211_start_scan(ieee);
3200 }
3201 //YJ,add,080828, notify os here
3202 if(ieee->state == IEEE80211_NOLINK)
3203 {
3204 notify_wx_assoc_event(ieee);
3205 }
3206 //YJ,add,080828,end
3207 spin_unlock_irqrestore(&ieee->lock, flags);
3208
3209exit:
3210 up(&ieee->wx_sem);
3211}
3212
3213struct sk_buff *ieee80211_get_beacon_(struct ieee80211_device *ieee)
3214{
3215 u8 broadcast_addr[] = {0xff,0xff,0xff,0xff,0xff,0xff};
3216
3217 struct sk_buff *skb = NULL;
3218 struct ieee80211_probe_response *b;
3219
3220//rz
3221#ifdef _RTL8187_EXT_PATCH_
3222 if((ieee->iw_mode == ieee->iw_ext_mode) && ieee->ext_patch_get_beacon_get_probersp )
3223 skb = ieee->ext_patch_get_beacon_get_probersp(ieee, broadcast_addr, &(ieee->current_network));
3224 else
3225 skb = ieee80211_probe_resp(ieee, broadcast_addr);
3226#else
3227 skb = ieee80211_probe_resp(ieee, broadcast_addr);
3228#endif
3229//
3230 if (!skb)
3231 return NULL;
3232
3233 b = (struct ieee80211_probe_response *) skb->data;
3234 b->header.frame_ctl = cpu_to_le16(IEEE80211_STYPE_BEACON);
3235
3236 return skb;
3237
3238}
3239
3240struct sk_buff *ieee80211_get_beacon(struct ieee80211_device *ieee)
3241{
3242 struct sk_buff *skb;
3243 struct ieee80211_probe_response *b;
3244
3245 skb = ieee80211_get_beacon_(ieee);
3246 if(!skb)
3247 return NULL;
3248
3249 b = (struct ieee80211_probe_response *) skb->data;
3250 b->header.seq_ctrl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
3251
3252 if (ieee->seq_ctrl[0] == 0xFFF)
3253 ieee->seq_ctrl[0] = 0;
3254 else
3255 ieee->seq_ctrl[0]++;
3256
3257 return skb;
3258}
3259
3260void ieee80211_softmac_stop_protocol(struct ieee80211_device *ieee)
3261{
3262 ieee->sync_scan_hurryup = 1;
3263 down(&ieee->wx_sem);
3264 ieee80211_stop_protocol(ieee);
3265 up(&ieee->wx_sem);
3266}
3267
3268
3269void ieee80211_stop_protocol(struct ieee80211_device *ieee)
3270{
3271 if (!ieee->proto_started)
3272 return;
3273
3274 ieee->proto_started = 0;
3275
3276#ifdef _RTL8187_EXT_PATCH_
3277 if(ieee->ext_patch_ieee80211_stop_protocol)
3278 ieee->ext_patch_ieee80211_stop_protocol(ieee);
3279//if call queue_delayed_work,can call this,or do nothing..
3280//edit by lawrence,20071118
3281#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3282// cancel_delayed_work(&ieee->ext_stop_scan_wq);
3283// cancel_delayed_work(&ieee->ext_send_beacon_wq);
3284#endif
3285#endif // _RTL8187_EXT_PATCH_
3286
3287 ieee80211_stop_send_beacons(ieee);
3288 if((ieee->iw_mode == IW_MODE_INFRA)&&(ieee->state == IEEE80211_LINKED)) {
3289 SendDisassociation(ieee,NULL,WLAN_REASON_DISASSOC_STA_HAS_LEFT);
3290 }
3291 del_timer_sync(&ieee->associate_timer);
3292 cancel_delayed_work(&ieee->associate_retry_wq);
3293 cancel_delayed_work(&ieee->start_ibss_wq);
3294 ieee80211_stop_scan(ieee);
3295
3296 ieee80211_disassociate(ieee);
3297}
3298
3299void ieee80211_softmac_start_protocol(struct ieee80211_device *ieee)
3300{
3301 ieee->sync_scan_hurryup = 0;
3302 down(&ieee->wx_sem);
3303 ieee80211_start_protocol(ieee);
3304 up(&ieee->wx_sem);
3305}
3306
3307void ieee80211_start_protocol(struct ieee80211_device *ieee)
3308{
3309 short ch = 0;
3310 int i = 0;
3311
3312 if (ieee->proto_started)
3313 return;
3314
3315 ieee->proto_started = 1;
3316
3317 if (ieee->current_network.channel == 0){
3318 do{
3319 ch++;
3320 if (ch > MAX_CHANNEL_NUMBER)
3321 return; /* no channel found */
3322
3323#ifdef ENABLE_DOT11D
3324 }while(!GET_DOT11D_INFO(ieee)->channel_map[ch]);
3325#else
3326 }while(!ieee->channel_map[ch]);
3327#endif
3328
3329 ieee->current_network.channel = ch;
3330 }
3331
3332 if (ieee->current_network.beacon_interval == 0)
3333 ieee->current_network.beacon_interval = 100;
3334 ieee->set_chan(ieee->dev,ieee->current_network.channel);
3335
3336 for(i = 0; i < 17; i++) {
3337 ieee->last_rxseq_num[i] = -1;
3338 ieee->last_rxfrag_num[i] = -1;
3339 ieee->last_packet_time[i] = 0;
3340 }
3341
3342 ieee->init_wmmparam_flag = 0;//reinitialize AC_xx_PARAM registers.
3343
3344
3345 /* if the user set the MAC of the ad-hoc cell and then
3346 * switch to managed mode, shall we make sure that association
3347 * attempts does not fail just because the user provide the essid
3348 * and the nic is still checking for the AP MAC ??
3349 */
3350 switch (ieee->iw_mode) {
3351 case IW_MODE_AUTO:
3352 ieee->iw_mode = IW_MODE_INFRA;
3353 //not set break here intentionly
3354 case IW_MODE_INFRA:
3355 ieee80211_start_bss(ieee);
3356 break;
3357
3358 case IW_MODE_ADHOC:
3359 ieee80211_start_ibss(ieee);
3360 break;
3361
3362 case IW_MODE_MASTER:
3363 ieee80211_start_master_bss(ieee);
3364 break;
3365
3366 case IW_MODE_MONITOR:
3367 ieee80211_start_monitor_mode(ieee);
3368 break;
3369
3370 default:
3371#ifdef _RTL8187_EXT_PATCH_
3372 if((ieee->iw_mode == ieee->iw_ext_mode) &&\
3373 ieee->ext_patch_ieee80211_start_protocol &&\
3374 ieee->ext_patch_ieee80211_start_protocol(ieee)) {
3375#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3376 queue_work(ieee->wq, &ieee->ext_stop_scan_wq);
3377#endif
3378 // By default, WMM function will be disabled in
3379 // EXTENSION mode
3380 ieee->current_network.QoS_Enable = 0;
3381
3382 if(ieee->modulation & IEEE80211_CCK_MODULATION){
3383 ieee->current_network.rates_len = 4;
3384 ieee->current_network.rates[0] = \
3385 IEEE80211_BASIC_RATE_MASK | \
3386 IEEE80211_CCK_RATE_1MB;
3387 ieee->current_network.rates[1] = \
3388 IEEE80211_BASIC_RATE_MASK |\
3389 IEEE80211_CCK_RATE_2MB;
3390 ieee->current_network.rates[2] = \
3391 IEEE80211_BASIC_RATE_MASK |\
3392 IEEE80211_CCK_RATE_5MB;
3393 ieee->current_network.rates[3] = \
3394 IEEE80211_BASIC_RATE_MASK |\
3395 IEEE80211_CCK_RATE_11MB;
3396 }else
3397 ieee->current_network.rates_len = 0;
3398
3399 if(ieee->modulation & IEEE80211_OFDM_MODULATION){
3400 ieee->current_network.rates_ex_len = 8;
3401 ieee->current_network.rates_ex[0] = \
3402 IEEE80211_BASIC_RATE_MASK |\
3403 IEEE80211_OFDM_RATE_6MB;
3404 ieee->current_network.rates_ex[1] = \
3405 IEEE80211_BASIC_RATE_MASK |\
3406 IEEE80211_OFDM_RATE_9MB;
3407 ieee->current_network.rates_ex[2] = \
3408 IEEE80211_BASIC_RATE_MASK |\
3409 IEEE80211_OFDM_RATE_12MB;
3410 ieee->current_network.rates_ex[3] = \
3411 IEEE80211_BASIC_RATE_MASK | \
3412 IEEE80211_OFDM_RATE_18MB;
3413 ieee->current_network.rates_ex[4] =\
3414 IEEE80211_BASIC_RATE_MASK |\
3415 IEEE80211_OFDM_RATE_24MB;
3416 ieee->current_network.rates_ex[5] =\
3417 IEEE80211_BASIC_RATE_MASK |\
3418 IEEE80211_OFDM_RATE_36MB;
3419 ieee->current_network.rates_ex[6] = \
3420 IEEE80211_BASIC_RATE_MASK |\
3421 IEEE80211_OFDM_RATE_48MB;
3422 ieee->current_network.rates_ex[7] =\
3423 IEEE80211_BASIC_RATE_MASK |\
3424 IEEE80211_OFDM_RATE_54MB;
3425 ieee->rate = 540;
3426 }else{
3427 ieee->current_network.rates_ex_len = 0;
3428 ieee->rate = 110;
3429 }
3430
3431 /*
3432 spin_lock_irqsave(&ieee->lock, flags);
3433 if (ieee->state == IEEE80211_NOLINK)
3434 ieee80211_start_scan(ieee);
3435 // ieee->set_chan(ieee->dev, 8);
3436
3437 spin_unlock_irqrestore(&ieee->lock, flags);
3438 */
3439 memcpy(ieee->current_network.bssid, ieee->dev->dev_addr,\
3440 ETH_ALEN);
3441 ieee->link_change(ieee->dev);
3442 notify_wx_assoc_event(ieee);
3443
3444 if (ieee->data_hard_resume)
3445 ieee->data_hard_resume(ieee->dev);
3446
3447 netif_carrier_on(ieee->dev);
3448 } else {
3449 ieee->iw_mode = IW_MODE_INFRA;
3450 ieee80211_start_bss(ieee);
3451 }
3452#else
3453 ieee->iw_mode = IW_MODE_INFRA;
3454 ieee80211_start_bss(ieee);
3455
3456#endif
3457 break;
3458 }
3459}
3460
3461
3462#define DRV_NAME "Ieee80211"
3463void ieee80211_softmac_init(struct ieee80211_device *ieee)
3464{
3465 int i;
3466 memset(&ieee->current_network, 0, sizeof(struct ieee80211_network));
3467
3468 ieee->state = IEEE80211_NOLINK;
3469 ieee->sync_scan_hurryup = 0;
3470 for(i = 0; i < 5; i++) {
3471 ieee->seq_ctrl[i] = 0;
3472 }
3473
3474 ieee->assoc_id = 0;
3475 ieee->queue_stop = 0;
3476 ieee->scanning = 0;
3477 ieee->softmac_features = 0; //so IEEE2100-like driver are happy
3478 ieee->wap_set = 0;
3479 ieee->ssid_set = 0;
3480 ieee->proto_started = 0;
3481 ieee->basic_rate = IEEE80211_DEFAULT_BASIC_RATE;
3482 ieee->rate = 3;
3483//#ifdef ENABLE_LPS
3484 ieee->ps = IEEE80211_PS_MBCAST|IEEE80211_PS_UNICAST;
3485//#else
3486// ieee->ps = IEEE80211_PS_DISABLED;
3487//#endif
3488 ieee->sta_sleep = 0;
3489//by amy
3490 ieee->bInactivePs = false;
3491 ieee->actscanning = false;
3492 ieee->ListenInterval = 2;
3493 ieee->NumRxDataInPeriod = 0; //YJ,add,080828
3494 ieee->NumRxBcnInPeriod = 0; //YJ,add,080828
3495 ieee->NumRxOkTotal = 0;//+by amy 080312
3496 ieee->NumRxUnicast = 0;//YJ,add,080828,for keep alive
3497 ieee->beinretry = false;
3498 ieee->bHwRadioOff = false;
3499//by amy
3500#ifdef _RTL8187_EXT_PATCH_
3501 ieee->iw_ext_mode = 999;
3502#endif
3503
3504 init_mgmt_queue(ieee);
3505#if 0
3506 init_timer(&ieee->scan_timer);
3507 ieee->scan_timer.data = (unsigned long)ieee;
3508 ieee->scan_timer.function = ieee80211_softmac_scan_cb;
3509#endif
3510 ieee->tx_pending.txb = NULL;
3511
3512 init_timer(&ieee->associate_timer);
3513 ieee->associate_timer.data = (unsigned long)ieee;
3514 ieee->associate_timer.function = ieee80211_associate_abort_cb;
3515
3516 init_timer(&ieee->beacon_timer);
3517 ieee->beacon_timer.data = (unsigned long) ieee;
3518 ieee->beacon_timer.function = ieee80211_send_beacon_cb;
3519
3520#ifdef PF_SYNCTHREAD
3521 ieee->wq = create_workqueue(DRV_NAME,0);
3522#else
3523 ieee->wq = create_workqueue(DRV_NAME);
3524#endif
3525#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)//added by lawrence,070702
3526 INIT_DELAYED_WORK(&ieee->start_ibss_wq,(void*) ieee80211_start_ibss_wq);
3527 INIT_WORK(&ieee->associate_complete_wq,(void*) ieee80211_associate_complete_wq);
3528 INIT_WORK(&ieee->associate_procedure_wq,(void*) ieee80211_associate_procedure_wq);
3529 INIT_DELAYED_WORK(&ieee->softmac_scan_wq,(void*) ieee80211_softmac_scan_wq);
3530 INIT_DELAYED_WORK(&ieee->associate_retry_wq,(void*) ieee80211_associate_retry_wq);
3531 INIT_WORK(&ieee->wx_sync_scan_wq,(void*) ieee80211_wx_sync_scan_wq);
3532// INIT_WORK(&ieee->watch_dog_wq,(void*) ieee80211_watch_dog_wq);
3533//added by lawrence,20071118
3534#ifdef _RTL8187_EXT_PATCH_
3535 INIT_WORK(&ieee->ext_stop_scan_wq,(void*) ieee80211_ext_stop_scan_wq);
3536 //INIT_WORK(&ieee->ext_send_beacon_wq,(void*) ieee80211_beacons_start,ieee);
3537 INIT_WORK(&ieee->ext_send_beacon_wq,(void*) ext_ieee80211_send_beacon_wq);
3538#endif //_RTL8187_EXT_PATCH_
3539#else
3540 INIT_WORK(&ieee->start_ibss_wq,(void*) ieee80211_start_ibss_wq,ieee);
3541 INIT_WORK(&ieee->associate_retry_wq,(void*) ieee80211_associate_retry_wq,ieee);
3542 INIT_WORK(&ieee->associate_complete_wq,(void*) ieee80211_associate_complete_wq,ieee);
3543 INIT_WORK(&ieee->associate_procedure_wq,(void*) ieee80211_associate_procedure_wq,ieee);
3544 INIT_WORK(&ieee->softmac_scan_wq,(void*) ieee80211_softmac_scan_wq,ieee);
3545 INIT_WORK(&ieee->wx_sync_scan_wq,(void*) ieee80211_wx_sync_scan_wq,ieee);
3546// INIT_WORK(&ieee->watch_dog_wq,(void*) ieee80211_watch_dog_wq,ieee);
3547#ifdef _RTL8187_EXT_PATCH_
3548 INIT_WORK(&ieee->ext_stop_scan_wq,(void*) ieee80211_ext_stop_scan_wq,ieee);
3549 //INIT_WORK(&ieee->ext_send_beacon_wq,(void*) ieee80211_beacons_start,ieee);
3550 INIT_WORK(&ieee->ext_send_beacon_wq,(void*) ext_ieee80211_send_beacon_wq,ieee);
3551#endif
3552#endif
3553 sema_init(&ieee->wx_sem, 1);
3554 sema_init(&ieee->scan_sem, 1);
3555
3556 spin_lock_init(&ieee->mgmt_tx_lock);
3557 spin_lock_init(&ieee->beacon_lock);
3558
3559 tasklet_init(&ieee->ps_task,
3560 (void(*)(unsigned long)) ieee80211_sta_ps,
3561 (unsigned long)ieee);
3562#ifdef ENABLE_DOT11D
3563 ieee->pDot11dInfo = kmalloc(sizeof(RT_DOT11D_INFO), GFP_ATOMIC);
3564#endif
3565}
3566
3567void ieee80211_softmac_free(struct ieee80211_device *ieee)
3568{
3569 down(&ieee->wx_sem);
3570
3571 del_timer_sync(&ieee->associate_timer);
3572 cancel_delayed_work(&ieee->associate_retry_wq);
3573
3574
3575 //add for RF power on power of by lizhaoming 080512
3576 cancel_delayed_work(&ieee->GPIOChangeRFWorkItem);
3577
3578#ifdef _RTL8187_EXT_PATCH_
3579 cancel_delayed_work(&ieee->ext_stop_scan_wq);
3580 cancel_delayed_work(&ieee->ext_send_beacon_wq);
3581#endif
3582 destroy_workqueue(ieee->wq);
3583#ifdef ENABLE_DOT11D
3584 if(NULL != ieee->pDot11dInfo)
3585 kfree(ieee->pDot11dInfo);
3586#endif
3587 up(&ieee->wx_sem);
3588}
3589
3590/********************************************************
3591 * Start of WPA code. *
3592 * this is stolen from the ipw2200 driver *
3593 ********************************************************/
3594
3595
3596static int ieee80211_wpa_enable(struct ieee80211_device *ieee, int value)
3597{
3598 /* This is called when wpa_supplicant loads and closes the driver
3599 * interface. */
3600 printk("%s WPA\n",value ? "enabling" : "disabling");
3601 ieee->wpa_enabled = value;
3602 return 0;
3603}
3604
3605
3606void ieee80211_wpa_assoc_frame(struct ieee80211_device *ieee, char *wpa_ie, int wpa_ie_len)
3607{
3608 /* make sure WPA is enabled */
3609 ieee80211_wpa_enable(ieee, 1);
3610
3611 ieee80211_disassociate(ieee);
3612}
3613
3614
3615static int ieee80211_wpa_mlme(struct ieee80211_device *ieee, int command, int reason)
3616{
3617
3618 int ret = 0;
3619
3620 switch (command) {
3621 case IEEE_MLME_STA_DEAUTH:
3622 // silently ignore
3623 break;
3624
3625 case IEEE_MLME_STA_DISASSOC:
3626 ieee80211_disassociate(ieee);
3627 break;
3628
3629 default:
3630 printk("Unknown MLME request: %d\n", command);
3631 ret = -EOPNOTSUPP;
3632 }
3633
3634 return ret;
3635}
3636
3637
3638static int ieee80211_wpa_set_wpa_ie(struct ieee80211_device *ieee,
3639 struct ieee_param *param, int plen)
3640{
3641 u8 *buf;
3642
3643 if (param->u.wpa_ie.len > MAX_WPA_IE_LEN ||
3644 (param->u.wpa_ie.len && param->u.wpa_ie.data == NULL))
3645 return -EINVAL;
3646
3647 if (param->u.wpa_ie.len) {
3648 buf = kmalloc(param->u.wpa_ie.len, GFP_KERNEL);
3649 if (buf == NULL)
3650 return -ENOMEM;
3651
3652 memcpy(buf, param->u.wpa_ie.data, param->u.wpa_ie.len);
3653 kfree(ieee->wpa_ie);
3654 ieee->wpa_ie = buf;
3655 ieee->wpa_ie_len = param->u.wpa_ie.len;
3656 } else {
3657 kfree(ieee->wpa_ie);
3658 ieee->wpa_ie = NULL;
3659 ieee->wpa_ie_len = 0;
3660 }
3661
3662 ieee80211_wpa_assoc_frame(ieee, ieee->wpa_ie, ieee->wpa_ie_len);
3663 return 0;
3664}
3665
3666#define AUTH_ALG_OPEN_SYSTEM 0x1
3667#define AUTH_ALG_SHARED_KEY 0x2
3668
3669static int ieee80211_wpa_set_auth_algs(struct ieee80211_device *ieee, int value)
3670{
3671
3672 struct ieee80211_security sec = {
3673 .flags = SEC_AUTH_MODE,
3674 };
3675 int ret = 0;
3676
3677 if (value & AUTH_ALG_SHARED_KEY) {
3678 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
3679 ieee->open_wep = 0;
3680 } else {
3681 sec.auth_mode = WLAN_AUTH_OPEN;
3682 ieee->open_wep = 1;
3683 }
3684
3685 if (ieee->set_security)
3686 ieee->set_security(ieee->dev, &sec);
3687 else
3688 ret = -EOPNOTSUPP;
3689
3690 return ret;
3691}
3692
3693static int ieee80211_wpa_set_param(struct ieee80211_device *ieee, u8 name, u32 value)
3694{
3695 int ret=0;
3696 unsigned long flags;
3697
3698 switch (name) {
3699 case IEEE_PARAM_WPA_ENABLED:
3700 ret = ieee80211_wpa_enable(ieee, value);
3701 break;
3702
3703 case IEEE_PARAM_TKIP_COUNTERMEASURES:
3704 ieee->tkip_countermeasures=value;
3705 break;
3706
3707 case IEEE_PARAM_DROP_UNENCRYPTED: {
3708 /* HACK:
3709 *
3710 * wpa_supplicant calls set_wpa_enabled when the driver
3711 * is loaded and unloaded, regardless of if WPA is being
3712 * used. No other calls are made which can be used to
3713 * determine if encryption will be used or not prior to
3714 * association being expected. If encryption is not being
3715 * used, drop_unencrypted is set to false, else true -- we
3716 * can use this to determine if the CAP_PRIVACY_ON bit should
3717 * be set.
3718 */
3719 struct ieee80211_security sec = {
3720 .flags = SEC_ENABLED,
3721 .enabled = value,
3722 };
3723 ieee->drop_unencrypted = value;
3724 /* We only change SEC_LEVEL for open mode. Others
3725 * are set by ipw_wpa_set_encryption.
3726 */
3727 if (!value) {
3728 sec.flags |= SEC_LEVEL;
3729 sec.level = SEC_LEVEL_0;
3730 }
3731 else {
3732 sec.flags |= SEC_LEVEL;
3733 sec.level = SEC_LEVEL_1;
3734 }
3735 if (ieee->set_security)
3736 ieee->set_security(ieee->dev, &sec);
3737 break;
3738 }
3739
3740 case IEEE_PARAM_PRIVACY_INVOKED:
3741 ieee->privacy_invoked=value;
3742 break;
3743
3744 case IEEE_PARAM_AUTH_ALGS:
3745 ret = ieee80211_wpa_set_auth_algs(ieee, value);
3746 break;
3747
3748 case IEEE_PARAM_IEEE_802_1X:
3749 ieee->ieee802_1x=value;
3750 break;
3751 case IEEE_PARAM_WPAX_SELECT:
3752 // added for WPA2 mixed mode
3753 //printk(KERN_WARNING "------------------------>wpax value = %x\n", value);
3754 spin_lock_irqsave(&ieee->wpax_suitlist_lock,flags);
3755 ieee->wpax_type_set = 1;
3756 ieee->wpax_type_notify = value;
3757 spin_unlock_irqrestore(&ieee->wpax_suitlist_lock,flags);
3758 break;
3759
3760 default:
3761 printk("Unknown WPA param: %d\n",name);
3762 ret = -EOPNOTSUPP;
3763 }
3764
3765 return ret;
3766}
3767
3768/* implementation borrowed from hostap driver */
3769
3770static int ieee80211_wpa_set_encryption(struct ieee80211_device *ieee,
3771 struct ieee_param *param, int param_len)
3772{
3773 int ret = 0;
3774
3775 struct ieee80211_crypto_ops *ops;
3776 struct ieee80211_crypt_data **crypt;
3777
3778 struct ieee80211_security sec = {
3779 .flags = 0,
3780 };
3781
3782 param->u.crypt.err = 0;
3783 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
3784
3785 if (param_len !=
3786 (int) ((char *) param->u.crypt.key - (char *) param) +
3787 param->u.crypt.key_len) {
3788 printk("Len mismatch %d, %d\n", param_len,
3789 param->u.crypt.key_len);
3790 return -EINVAL;
3791 }
3792 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
3793 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
3794 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
3795 if (param->u.crypt.idx >= WEP_KEYS)
3796 return -EINVAL;
3797 crypt = &ieee->crypt[param->u.crypt.idx];
3798 } else {
3799 return -EINVAL;
3800 }
3801
3802 if (strcmp(param->u.crypt.alg, "none") == 0) {
3803 if (crypt) {
3804 sec.enabled = 0;
3805 // FIXME FIXME
3806 //sec.encrypt = 0;
3807 sec.level = SEC_LEVEL_0;
3808 sec.flags |= SEC_ENABLED | SEC_LEVEL;
3809 ieee80211_crypt_delayed_deinit(ieee, crypt);
3810 }
3811 goto done;
3812 }
3813 sec.enabled = 1;
3814// FIXME FIXME
3815// sec.encrypt = 1;
3816 sec.flags |= SEC_ENABLED;
3817
3818 /* IPW HW cannot build TKIP MIC, host decryption still needed. */
3819 if (!(ieee->host_encrypt || ieee->host_decrypt) &&
3820 strcmp(param->u.crypt.alg, "TKIP"))
3821 goto skip_host_crypt;
3822
3823 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
3824 if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) {
3825 request_module("ieee80211_crypt_wep");
3826 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
3827 } else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) {
3828 request_module("ieee80211_crypt_tkip");
3829 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
3830 } else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) {
3831 request_module("ieee80211_crypt_ccmp");
3832 ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
3833 }
3834 if (ops == NULL) {
3835 printk("unknown crypto alg '%s'\n", param->u.crypt.alg);
3836 param->u.crypt.err = IEEE_CRYPT_ERR_UNKNOWN_ALG;
3837 ret = -EINVAL;
3838 goto done;
3839 }
3840
3841 if (*crypt == NULL || (*crypt)->ops != ops) {
3842 struct ieee80211_crypt_data *new_crypt;
3843
3844 ieee80211_crypt_delayed_deinit(ieee, crypt);
3845
3846 new_crypt = (struct ieee80211_crypt_data *)
3847 kmalloc(sizeof(*new_crypt), GFP_KERNEL);
3848 if (new_crypt == NULL) {
3849 ret = -ENOMEM;
3850 goto done;
3851 }
3852 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
3853 new_crypt->ops = ops;
3854 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
3855 new_crypt->priv =
3856 new_crypt->ops->init(param->u.crypt.idx);
3857
3858 if (new_crypt->priv == NULL) {
3859 kfree(new_crypt);
3860 param->u.crypt.err = IEEE_CRYPT_ERR_CRYPT_INIT_FAILED;
3861 ret = -EINVAL;
3862 goto done;
3863 }
3864
3865 *crypt = new_crypt;
3866 }
3867
3868 if (param->u.crypt.key_len > 0 && (*crypt)->ops->set_key &&
3869 (*crypt)->ops->set_key(param->u.crypt.key,
3870 param->u.crypt.key_len, param->u.crypt.seq,
3871 (*crypt)->priv) < 0) {
3872 printk("key setting failed\n");
3873 param->u.crypt.err = IEEE_CRYPT_ERR_KEY_SET_FAILED;
3874 ret = -EINVAL;
3875 goto done;
3876 }
3877
3878 skip_host_crypt:
3879 if (param->u.crypt.set_tx) {
3880 ieee->tx_keyidx = param->u.crypt.idx;
3881 sec.active_key = param->u.crypt.idx;
3882 sec.flags |= SEC_ACTIVE_KEY;
3883 } else
3884 sec.flags &= ~SEC_ACTIVE_KEY;
3885
3886 if (param->u.crypt.alg != NULL) {
3887 memcpy(sec.keys[param->u.crypt.idx],
3888 param->u.crypt.key,
3889 param->u.crypt.key_len);
3890 sec.key_sizes[param->u.crypt.idx] = param->u.crypt.key_len;
3891 sec.flags |= (1 << param->u.crypt.idx);
3892
3893 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
3894 sec.flags |= SEC_LEVEL;
3895 sec.level = SEC_LEVEL_1;
3896 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
3897 sec.flags |= SEC_LEVEL;
3898 sec.level = SEC_LEVEL_2;
3899 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
3900 sec.flags |= SEC_LEVEL;
3901 sec.level = SEC_LEVEL_3;
3902 }
3903 }
3904 done:
3905 if (ieee->set_security)
3906 ieee->set_security(ieee->dev, &sec);
3907
3908 /* Do not reset port if card is in Managed mode since resetting will
3909 * generate new IEEE 802.11 authentication which may end up in looping
3910 * with IEEE 802.1X. If your hardware requires a reset after WEP
3911 * configuration (for example... Prism2), implement the reset_port in
3912 * the callbacks structures used to initialize the 802.11 stack. */
3913 if (ieee->reset_on_keychange &&
3914 ieee->iw_mode != IW_MODE_INFRA &&
3915 ieee->reset_port &&
3916 ieee->reset_port(ieee->dev)) {
3917 printk("reset_port failed\n");
3918 param->u.crypt.err = IEEE_CRYPT_ERR_CARD_CONF_FAILED;
3919 return -EINVAL;
3920 }
3921
3922 return ret;
3923}
3924
3925int ieee80211_wpa_supplicant_ioctl(struct ieee80211_device *ieee, struct iw_point *p)
3926{
3927 struct ieee_param *param;
3928 int ret=0;
3929
3930 down(&ieee->wx_sem);
3931 //IEEE_DEBUG_INFO("wpa_supplicant: len=%d\n", p->length);
3932
3933 if (p->length < sizeof(struct ieee_param) || !p->pointer){
3934 ret = -EINVAL;
3935 goto out;
3936 }
3937
3938 param = (struct ieee_param *)kmalloc(p->length, GFP_KERNEL);
3939 if (param == NULL){
3940 ret = -ENOMEM;
3941 goto out;
3942 }
3943 if (copy_from_user(param, p->pointer, p->length)) {
3944 kfree(param);
3945 ret = -EFAULT;
3946 goto out;
3947 }
3948
3949 switch (param->cmd) {
3950
3951 case IEEE_CMD_SET_WPA_PARAM:
3952 ret = ieee80211_wpa_set_param(ieee, param->u.wpa_param.name,
3953 param->u.wpa_param.value);
3954 break;
3955
3956 case IEEE_CMD_SET_WPA_IE:
3957 ret = ieee80211_wpa_set_wpa_ie(ieee, param, p->length);
3958 break;
3959
3960 case IEEE_CMD_SET_ENCRYPTION:
3961 ret = ieee80211_wpa_set_encryption(ieee, param, p->length);
3962 break;
3963
3964 case IEEE_CMD_MLME:
3965 ret = ieee80211_wpa_mlme(ieee, param->u.mlme.command,
3966 param->u.mlme.reason_code);
3967 break;
3968
3969 default:
3970 printk("Unknown WPA supplicant request: %d\n",param->cmd);
3971 ret = -EOPNOTSUPP;
3972 break;
3973 }
3974
3975 if (ret == 0 && copy_to_user(p->pointer, param, p->length))
3976 ret = -EFAULT;
3977
3978 kfree(param);
3979out:
3980 up(&ieee->wx_sem);
3981
3982 return ret;
3983}
3984
3985void notify_wx_assoc_event(struct ieee80211_device *ieee)
3986{
3987 union iwreq_data wrqu;
3988 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3989 if (ieee->state == IEEE80211_LINKED)
3990 memcpy(wrqu.ap_addr.sa_data, ieee->current_network.bssid, ETH_ALEN);
3991 else
3992 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
3993 wireless_send_event(ieee->dev, SIOCGIWAP, &wrqu, NULL);
3994}
3995
3996
3997#if 0
3998EXPORT_SYMBOL(ieee80211_get_beacon);
3999EXPORT_SYMBOL(ieee80211_wake_queue);
4000EXPORT_SYMBOL(ieee80211_stop_queue);
4001EXPORT_SYMBOL(ieee80211_reset_queue);
4002EXPORT_SYMBOL(ieee80211_softmac_stop_protocol);
4003EXPORT_SYMBOL(ieee80211_softmac_start_protocol);
4004EXPORT_SYMBOL(ieee80211_is_shortslot);
4005EXPORT_SYMBOL(ieee80211_is_54g);
4006EXPORT_SYMBOL(ieee80211_wpa_supplicant_ioctl);
4007EXPORT_SYMBOL(ieee80211_ps_tx_ack);
4008EXPORT_SYMBOL(ieee80211_start_protocol);
4009EXPORT_SYMBOL(ieee80211_stop_protocol);
4010EXPORT_SYMBOL(notify_wx_assoc_event);
4011EXPORT_SYMBOL(ieee80211_stop_send_beacons);
4012EXPORT_SYMBOL(SendDisassociation);
4013EXPORT_SYMBOL(ieee80211_disassociate);
4014EXPORT_SYMBOL(ieee80211_start_scan);
4015EXPORT_SYMBOL(ieee80211_softmac_ips_scan_syncro);
4016#ifdef _RTL8187_EXT_PATCH_
4017EXPORT_SYMBOL(ieee80211_ext_issue_assoc_req);
4018EXPORT_SYMBOL(ieee80211_ext_issue_disassoc);
4019EXPORT_SYMBOL(ieee80211_ext_issue_assoc_rsp);
4020EXPORT_SYMBOL(softmac_mgmt_xmit);
4021EXPORT_SYMBOL(ieee80211_ext_probe_resp_by_net);
4022EXPORT_SYMBOL(ieee80211_start_scan);
4023EXPORT_SYMBOL(ieee80211_stop_scan);
4024EXPORT_SYMBOL(ieee80211_ext_send_11s_beacon);
4025EXPORT_SYMBOL(ieee80211_rx_auth_rq);
4026EXPORT_SYMBOL(ieee80211_associate_step1);
4027#endif // _RTL8187_EXT_PATCH_
4028EXPORT_SYMBOL(ieee80211_sta_ps_send_null_frame);
4029#endif
Clone of davem's net-next-2.6 tree