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