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