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