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 rtllib
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 "rtllib.h"
15
16 #include <linux/random.h>
17 #include <linux/delay.h>
18 #include <linux/uaccess.h>
19 #include <linux/etherdevice.h>
20 #include <linux/ieee80211.h>
21
22 static void rtllib_sta_wakeup(struct rtllib_device *ieee, short nl);
23
rtllib_is_54g(struct rtllib_network * net)24 static short rtllib_is_54g(struct rtllib_network *net)
25 {
26 return (net->rates_ex_len > 0) || (net->rates_len > 4);
27 }
28
29 /* returns the total length needed for placing the RATE MFIE
30 * tag and the EXTENDED RATE MFIE tag if needed.
31 * It encludes two bytes per tag for the tag itself and its len
32 */
rtllib_MFIE_rate_len(struct rtllib_device * ieee)33 static unsigned int rtllib_MFIE_rate_len(struct rtllib_device *ieee)
34 {
35 unsigned int rate_len = 0;
36
37 rate_len = RTLLIB_CCK_RATE_LEN + 2;
38 rate_len += RTLLIB_OFDM_RATE_LEN + 2;
39
40 return rate_len;
41 }
42
43 /* place the MFIE rate, tag to the memory (double) pointed.
44 * Then it updates the pointer so that
45 * it points after the new MFIE tag added.
46 */
rtllib_mfie_brate(struct rtllib_device * ieee,u8 ** tag_p)47 static void rtllib_mfie_brate(struct rtllib_device *ieee, u8 **tag_p)
48 {
49 u8 *tag = *tag_p;
50
51 *tag++ = MFIE_TYPE_RATES;
52 *tag++ = 4;
53 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_1MB;
54 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_2MB;
55 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_5MB;
56 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_CCK_RATE_11MB;
57
58 /* We may add an option for custom rates that specific HW
59 * might support
60 */
61 *tag_p = tag;
62 }
63
rtllib_mfie_grate(struct rtllib_device * ieee,u8 ** tag_p)64 static void rtllib_mfie_grate(struct rtllib_device *ieee, u8 **tag_p)
65 {
66 u8 *tag = *tag_p;
67
68 *tag++ = MFIE_TYPE_RATES_EX;
69 *tag++ = 8;
70 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_6MB;
71 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_9MB;
72 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_12MB;
73 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_18MB;
74 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_24MB;
75 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_36MB;
76 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_48MB;
77 *tag++ = RTLLIB_BASIC_RATE_MASK | RTLLIB_OFDM_RATE_54MB;
78
79 /* We may add an option for custom rates that specific HW might
80 * support
81 */
82 *tag_p = tag;
83 }
84
rtllib_wmm_info(struct rtllib_device * ieee,u8 ** tag_p)85 static void rtllib_wmm_info(struct rtllib_device *ieee, u8 **tag_p)
86 {
87 u8 *tag = *tag_p;
88
89 *tag++ = MFIE_TYPE_GENERIC;
90 *tag++ = 7;
91 *tag++ = 0x00;
92 *tag++ = 0x50;
93 *tag++ = 0xf2;
94 *tag++ = 0x02;
95 *tag++ = 0x00;
96 *tag++ = 0x01;
97 *tag++ = MAX_SP_Len;
98 *tag_p = tag;
99 }
100
rtllib_turbo_info(struct rtllib_device * ieee,u8 ** tag_p)101 static void rtllib_turbo_info(struct rtllib_device *ieee, u8 **tag_p)
102 {
103 u8 *tag = *tag_p;
104
105 *tag++ = MFIE_TYPE_GENERIC;
106 *tag++ = 7;
107 *tag++ = 0x00;
108 *tag++ = 0xe0;
109 *tag++ = 0x4c;
110 *tag++ = 0x01;
111 *tag++ = 0x02;
112 *tag++ = 0x11;
113 *tag++ = 0x00;
114
115 *tag_p = tag;
116 netdev_alert(ieee->dev, "This is enable turbo mode IE process\n");
117 }
118
enqueue_mgmt(struct rtllib_device * ieee,struct sk_buff * skb)119 static void enqueue_mgmt(struct rtllib_device *ieee, struct sk_buff *skb)
120 {
121 int nh;
122
123 nh = (ieee->mgmt_queue_head + 1) % MGMT_QUEUE_NUM;
124
125 /* if the queue is full but we have newer frames then
126 * just overwrites the oldest.
127 *
128 * if (nh == ieee->mgmt_queue_tail)
129 * return -1;
130 */
131 ieee->mgmt_queue_head = nh;
132 ieee->mgmt_queue_ring[nh] = skb;
133 }
134
init_mgmt_queue(struct rtllib_device * ieee)135 static void init_mgmt_queue(struct rtllib_device *ieee)
136 {
137 ieee->mgmt_queue_tail = 0;
138 ieee->mgmt_queue_head = 0;
139 }
140
MgntQuery_TxRateExcludeCCKRates(struct rtllib_device * ieee)141 u8 MgntQuery_TxRateExcludeCCKRates(struct rtllib_device *ieee)
142 {
143 u16 i;
144 u8 query_rate = 0;
145 u8 basic_rate;
146
147 for (i = 0; i < ieee->current_network.rates_len; i++) {
148 basic_rate = ieee->current_network.rates[i] & 0x7F;
149 if (!rtllib_is_cck_rate(basic_rate)) {
150 if (query_rate == 0) {
151 query_rate = basic_rate;
152 } else {
153 if (basic_rate < query_rate)
154 query_rate = basic_rate;
155 }
156 }
157 }
158
159 if (query_rate == 0) {
160 query_rate = 12;
161 netdev_info(ieee->dev, "No basic_rate found!!\n");
162 }
163 return query_rate;
164 }
165
MgntQuery_MgntFrameTxRate(struct rtllib_device * ieee)166 static u8 MgntQuery_MgntFrameTxRate(struct rtllib_device *ieee)
167 {
168 struct rt_hi_throughput *ht_info = ieee->ht_info;
169 u8 rate;
170
171 if (ht_info->iot_action & HT_IOT_ACT_MGNT_USE_CCK_6M)
172 rate = 0x0c;
173 else
174 rate = ieee->basic_rate & 0x7f;
175
176 if (rate == 0)
177 rate = 0x02;
178
179 return rate;
180 }
181
softmac_mgmt_xmit(struct sk_buff * skb,struct rtllib_device * ieee)182 inline void softmac_mgmt_xmit(struct sk_buff *skb, struct rtllib_device *ieee)
183 {
184 unsigned long flags;
185 short single = ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE;
186 struct ieee80211_hdr_3addr *header =
187 (struct ieee80211_hdr_3addr *)skb->data;
188
189 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb + 8);
190
191 spin_lock_irqsave(&ieee->lock, flags);
192
193 /* called with 2nd param 0, no mgmt lock required */
194 rtllib_sta_wakeup(ieee, 0);
195
196 if (ieee80211_is_beacon(header->frame_control))
197 tcb_desc->queue_index = BEACON_QUEUE;
198 else
199 tcb_desc->queue_index = MGNT_QUEUE;
200
201 if (ieee->disable_mgnt_queue)
202 tcb_desc->queue_index = HIGH_QUEUE;
203
204 tcb_desc->data_rate = MgntQuery_MgntFrameTxRate(ieee);
205 tcb_desc->ratr_index = 7;
206 tcb_desc->tx_dis_rate_fallback = 1;
207 tcb_desc->tx_use_drv_assinged_rate = 1;
208 if (single) {
209 if (ieee->queue_stop) {
210 enqueue_mgmt(ieee, skb);
211 } else {
212 header->seq_ctrl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
213
214 if (ieee->seq_ctrl[0] == 0xFFF)
215 ieee->seq_ctrl[0] = 0;
216 else
217 ieee->seq_ctrl[0]++;
218
219 /* avoid watchdog triggers */
220 ieee->softmac_data_hard_start_xmit(skb, ieee->dev,
221 ieee->basic_rate);
222 }
223
224 spin_unlock_irqrestore(&ieee->lock, flags);
225 } else {
226 spin_unlock_irqrestore(&ieee->lock, flags);
227 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags);
228
229 header->seq_ctrl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
230
231 if (ieee->seq_ctrl[0] == 0xFFF)
232 ieee->seq_ctrl[0] = 0;
233 else
234 ieee->seq_ctrl[0]++;
235
236 /* check whether the managed packet queued greater than 5 */
237 if (!ieee->check_nic_enough_desc(ieee->dev,
238 tcb_desc->queue_index) ||
239 skb_queue_len(&ieee->skb_waitq[tcb_desc->queue_index]) ||
240 ieee->queue_stop) {
241 /* insert the skb packet to the management queue
242 *
243 * as for the completion function, it does not need
244 * to check it any more.
245 */
246 netdev_info(ieee->dev,
247 "%s():insert to waitqueue, queue_index:%d!\n",
248 __func__, tcb_desc->queue_index);
249 skb_queue_tail(&ieee->skb_waitq[tcb_desc->queue_index],
250 skb);
251 } else {
252 ieee->softmac_hard_start_xmit(skb, ieee->dev);
253 }
254 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags);
255 }
256 }
257
258 static inline void
softmac_ps_mgmt_xmit(struct sk_buff * skb,struct rtllib_device * ieee)259 softmac_ps_mgmt_xmit(struct sk_buff *skb,
260 struct rtllib_device *ieee)
261 {
262 short single = ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE;
263 struct ieee80211_hdr_3addr *header =
264 (struct ieee80211_hdr_3addr *)skb->data;
265 u16 fc, type, stype;
266 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb + 8);
267
268 fc = le16_to_cpu(header->frame_control);
269 type = WLAN_FC_GET_TYPE(fc);
270 stype = WLAN_FC_GET_STYPE(fc);
271
272 if (stype != IEEE80211_STYPE_PSPOLL)
273 tcb_desc->queue_index = MGNT_QUEUE;
274 else
275 tcb_desc->queue_index = HIGH_QUEUE;
276
277 if (ieee->disable_mgnt_queue)
278 tcb_desc->queue_index = HIGH_QUEUE;
279
280 tcb_desc->data_rate = MgntQuery_MgntFrameTxRate(ieee);
281 tcb_desc->ratr_index = 7;
282 tcb_desc->tx_dis_rate_fallback = 1;
283 tcb_desc->tx_use_drv_assinged_rate = 1;
284 if (single) {
285 if (type != RTLLIB_FTYPE_CTL) {
286 header->seq_ctrl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
287
288 if (ieee->seq_ctrl[0] == 0xFFF)
289 ieee->seq_ctrl[0] = 0;
290 else
291 ieee->seq_ctrl[0]++;
292 }
293 /* avoid watchdog triggers */
294 ieee->softmac_data_hard_start_xmit(skb, ieee->dev,
295 ieee->basic_rate);
296
297 } else {
298 if (type != RTLLIB_FTYPE_CTL) {
299 header->seq_ctrl = cpu_to_le16(ieee->seq_ctrl[0] << 4);
300
301 if (ieee->seq_ctrl[0] == 0xFFF)
302 ieee->seq_ctrl[0] = 0;
303 else
304 ieee->seq_ctrl[0]++;
305 }
306 ieee->softmac_hard_start_xmit(skb, ieee->dev);
307 }
308 }
309
rtllib_probe_req(struct rtllib_device * ieee)310 static inline struct sk_buff *rtllib_probe_req(struct rtllib_device *ieee)
311 {
312 unsigned int len, rate_len;
313 u8 *tag;
314 struct sk_buff *skb;
315 struct rtllib_probe_request *req;
316
317 len = ieee->current_network.ssid_len;
318
319 rate_len = rtllib_MFIE_rate_len(ieee);
320
321 skb = dev_alloc_skb(sizeof(struct rtllib_probe_request) +
322 2 + len + rate_len + ieee->tx_headroom);
323
324 if (!skb)
325 return NULL;
326
327 skb_reserve(skb, ieee->tx_headroom);
328
329 req = skb_put(skb, sizeof(struct rtllib_probe_request));
330 req->header.frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
331 req->header.duration_id = 0;
332
333 eth_broadcast_addr(req->header.addr1);
334 ether_addr_copy(req->header.addr2, ieee->dev->dev_addr);
335 eth_broadcast_addr(req->header.addr3);
336
337 tag = skb_put(skb, len + 2 + rate_len);
338
339 *tag++ = MFIE_TYPE_SSID;
340 *tag++ = len;
341 memcpy(tag, ieee->current_network.ssid, len);
342 tag += len;
343
344 rtllib_mfie_brate(ieee, &tag);
345 rtllib_mfie_grate(ieee, &tag);
346
347 return skb;
348 }
349
350 /* Enables network monitor mode, all rx packets will be received. */
rtllib_enable_net_monitor_mode(struct net_device * dev,bool init_state)351 void rtllib_enable_net_monitor_mode(struct net_device *dev,
352 bool init_state)
353 {
354 struct rtllib_device *ieee = netdev_priv_rsl(dev);
355
356 netdev_info(dev, "========>Enter Monitor Mode\n");
357
358 ieee->AllowAllDestAddrHandler(dev, true, !init_state);
359 }
360
361 /* Disables network monitor mode. Only packets destinated to
362 * us will be received.
363 */
rtllib_disable_net_monitor_mode(struct net_device * dev,bool init_state)364 void rtllib_disable_net_monitor_mode(struct net_device *dev,
365 bool init_state)
366 {
367 struct rtllib_device *ieee = netdev_priv_rsl(dev);
368
369 netdev_info(dev, "========>Exit Monitor Mode\n");
370
371 ieee->AllowAllDestAddrHandler(dev, false, !init_state);
372 }
373
rtllib_send_probe(struct rtllib_device * ieee)374 static void rtllib_send_probe(struct rtllib_device *ieee)
375 {
376 struct sk_buff *skb;
377
378 skb = rtllib_probe_req(ieee);
379 if (skb) {
380 softmac_mgmt_xmit(skb, ieee);
381 ieee->softmac_stats.tx_probe_rq++;
382 }
383 }
384
rtllib_send_probe_requests(struct rtllib_device * ieee)385 static void rtllib_send_probe_requests(struct rtllib_device *ieee)
386 {
387 if (ieee->softmac_features & IEEE_SOFTMAC_PROBERQ) {
388 rtllib_send_probe(ieee);
389 rtllib_send_probe(ieee);
390 }
391 }
392
393 /* this performs syncro scan blocking the caller until all channels
394 * in the allowed channel map has been checked.
395 */
rtllib_softmac_scan_syncro(struct rtllib_device * ieee)396 static void rtllib_softmac_scan_syncro(struct rtllib_device *ieee)
397 {
398 union iwreq_data wrqu;
399 short ch = 0;
400
401 ieee->be_scan_inprogress = true;
402
403 mutex_lock(&ieee->scan_mutex);
404
405 while (1) {
406 do {
407 ch++;
408 if (ch > MAX_CHANNEL_NUMBER)
409 goto out; /* scan completed */
410 } while (!ieee->active_channel_map[ch]);
411
412 /* this function can be called in two situations
413 * 1- We have switched to ad-hoc mode and we are
414 * performing a complete syncro scan before conclude
415 * there are no interesting cell and to create a
416 * new one. In this case the link state is
417 * MAC80211_NOLINK until we found an interesting cell.
418 * If so the ieee8021_new_net, called by the RX path
419 * will set the state to MAC80211_LINKED, so we stop
420 * scanning
421 * 2- We are linked and the root uses run iwlist scan.
422 * So we switch to MAC80211_LINKED_SCANNING to remember
423 * that we are still logically linked (not interested in
424 * new network events, despite for updating the net list,
425 * but we are temporarly 'unlinked' as the driver shall
426 * not filter RX frames and the channel is changing.
427 * So the only situation in which are interested is to check
428 * if the state become LINKED because of the #1 situation
429 */
430
431 if (ieee->link_state == MAC80211_LINKED)
432 goto out;
433 if (ieee->sync_scan_hurryup) {
434 netdev_info(ieee->dev,
435 "============>sync_scan_hurryup out\n");
436 goto out;
437 }
438
439 ieee->set_chan(ieee->dev, ch);
440 if (ieee->active_channel_map[ch] == 1)
441 rtllib_send_probe_requests(ieee);
442
443 /* this prevent excessive time wait when we
444 * need to wait for a syncro scan to end..
445 */
446 msleep_interruptible_rsl(RTLLIB_SOFTMAC_SCAN_TIME);
447 }
448 out:
449 ieee->actscanning = false;
450 ieee->sync_scan_hurryup = 0;
451
452 mutex_unlock(&ieee->scan_mutex);
453
454 ieee->be_scan_inprogress = false;
455
456 memset(&wrqu, 0, sizeof(wrqu));
457 wireless_send_event(ieee->dev, SIOCGIWSCAN, &wrqu, NULL);
458 }
459
rtllib_softmac_scan_wq(void * data)460 static void rtllib_softmac_scan_wq(void *data)
461 {
462 struct rtllib_device *ieee = container_of_dwork_rsl(data,
463 struct rtllib_device, softmac_scan_wq);
464 u8 last_channel = ieee->current_network.channel;
465
466 if (!ieee->ieee_up)
467 return;
468 if (rtllib_act_scanning(ieee, true))
469 return;
470
471 mutex_lock(&ieee->scan_mutex);
472
473 if (ieee->rf_power_state == rf_off) {
474 netdev_info(ieee->dev,
475 "======>%s():rf state is rf_off, return\n",
476 __func__);
477 goto out1;
478 }
479
480 do {
481 ieee->current_network.channel =
482 (ieee->current_network.channel + 1) %
483 MAX_CHANNEL_NUMBER;
484 if (ieee->scan_watch_dog++ > MAX_CHANNEL_NUMBER) {
485 if (!ieee->active_channel_map[ieee->current_network.channel])
486 ieee->current_network.channel = 6;
487 goto out; /* no good chans */
488 }
489 } while (!ieee->active_channel_map[ieee->current_network.channel]);
490
491 if (ieee->scanning_continue == 0)
492 goto out;
493
494 ieee->set_chan(ieee->dev, ieee->current_network.channel);
495
496 if (ieee->active_channel_map[ieee->current_network.channel] == 1)
497 rtllib_send_probe_requests(ieee);
498
499 schedule_delayed_work(&ieee->softmac_scan_wq,
500 msecs_to_jiffies(RTLLIB_SOFTMAC_SCAN_TIME));
501
502 mutex_unlock(&ieee->scan_mutex);
503 return;
504
505 out:
506 ieee->current_network.channel = last_channel;
507
508 out1:
509 ieee->actscanning = false;
510 ieee->scan_watch_dog = 0;
511 ieee->scanning_continue = 0;
512 mutex_unlock(&ieee->scan_mutex);
513 }
514
rtllib_softmac_stop_scan(struct rtllib_device * ieee)515 static void rtllib_softmac_stop_scan(struct rtllib_device *ieee)
516 {
517 mutex_lock(&ieee->scan_mutex);
518 ieee->scan_watch_dog = 0;
519 if (ieee->scanning_continue == 1) {
520 ieee->scanning_continue = 0;
521 ieee->actscanning = false;
522 mutex_unlock(&ieee->scan_mutex);
523 cancel_delayed_work_sync(&ieee->softmac_scan_wq);
524 } else {
525 mutex_unlock(&ieee->scan_mutex);
526 }
527 }
528
rtllib_stop_scan(struct rtllib_device * ieee)529 void rtllib_stop_scan(struct rtllib_device *ieee)
530 {
531 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN)
532 rtllib_softmac_stop_scan(ieee);
533 }
534 EXPORT_SYMBOL(rtllib_stop_scan);
535
rtllib_stop_scan_syncro(struct rtllib_device * ieee)536 void rtllib_stop_scan_syncro(struct rtllib_device *ieee)
537 {
538 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN)
539 ieee->sync_scan_hurryup = 1;
540 }
541 EXPORT_SYMBOL(rtllib_stop_scan_syncro);
542
rtllib_act_scanning(struct rtllib_device * ieee,bool sync_scan)543 bool rtllib_act_scanning(struct rtllib_device *ieee, bool sync_scan)
544 {
545 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN) {
546 if (sync_scan)
547 return ieee->be_scan_inprogress;
548 else
549 return ieee->actscanning || ieee->be_scan_inprogress;
550 } else {
551 return test_bit(STATUS_SCANNING, &ieee->status);
552 }
553 }
554 EXPORT_SYMBOL(rtllib_act_scanning);
555
556 /* called with ieee->lock held */
rtllib_start_scan(struct rtllib_device * ieee)557 static void rtllib_start_scan(struct rtllib_device *ieee)
558 {
559 ieee->rtllib_ips_leave_wq(ieee->dev);
560
561 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN) {
562 if (ieee->scanning_continue == 0) {
563 ieee->actscanning = true;
564 ieee->scanning_continue = 1;
565 schedule_delayed_work(&ieee->softmac_scan_wq, 0);
566 }
567 }
568 }
569
570 /* called with wx_mutex held */
rtllib_start_scan_syncro(struct rtllib_device * ieee)571 void rtllib_start_scan_syncro(struct rtllib_device *ieee)
572 {
573 ieee->sync_scan_hurryup = 0;
574 if (ieee->softmac_features & IEEE_SOFTMAC_SCAN)
575 rtllib_softmac_scan_syncro(ieee);
576 }
577 EXPORT_SYMBOL(rtllib_start_scan_syncro);
578
579 static inline struct sk_buff *
rtllib_authentication_req(struct rtllib_network * beacon,struct rtllib_device * ieee,int challengelen,u8 * daddr)580 rtllib_authentication_req(struct rtllib_network *beacon,
581 struct rtllib_device *ieee,
582 int challengelen, u8 *daddr)
583 {
584 struct sk_buff *skb;
585 struct rtllib_authentication *auth;
586 int len;
587
588 len = sizeof(struct rtllib_authentication) + challengelen +
589 ieee->tx_headroom + 4;
590 skb = dev_alloc_skb(len);
591
592 if (!skb)
593 return NULL;
594
595 skb_reserve(skb, ieee->tx_headroom);
596
597 auth = skb_put(skb, sizeof(struct rtllib_authentication));
598
599 auth->header.frame_control = cpu_to_le16(IEEE80211_STYPE_AUTH);
600 if (challengelen)
601 auth->header.frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
602
603 auth->header.duration_id = cpu_to_le16(0x013a);
604 ether_addr_copy(auth->header.addr1, beacon->bssid);
605 ether_addr_copy(auth->header.addr2, ieee->dev->dev_addr);
606 ether_addr_copy(auth->header.addr3, beacon->bssid);
607 if (ieee->auth_mode == 0)
608 auth->algorithm = WLAN_AUTH_OPEN;
609 else if (ieee->auth_mode == 1)
610 auth->algorithm = cpu_to_le16(WLAN_AUTH_SHARED_KEY);
611 else if (ieee->auth_mode == 2)
612 auth->algorithm = WLAN_AUTH_OPEN;
613 auth->transaction = cpu_to_le16(ieee->associate_seq);
614 ieee->associate_seq++;
615
616 auth->status = cpu_to_le16(WLAN_STATUS_SUCCESS);
617
618 return skb;
619 }
620
rtllib_null_func(struct rtllib_device * ieee,short pwr)621 static struct sk_buff *rtllib_null_func(struct rtllib_device *ieee, short pwr)
622 {
623 struct sk_buff *skb;
624 struct ieee80211_hdr_3addr *hdr;
625
626 skb = dev_alloc_skb(sizeof(struct ieee80211_hdr_3addr) + ieee->tx_headroom);
627 if (!skb)
628 return NULL;
629
630 skb_reserve(skb, ieee->tx_headroom);
631
632 hdr = skb_put(skb, sizeof(struct ieee80211_hdr_3addr));
633
634 ether_addr_copy(hdr->addr1, ieee->current_network.bssid);
635 ether_addr_copy(hdr->addr2, ieee->dev->dev_addr);
636 ether_addr_copy(hdr->addr3, ieee->current_network.bssid);
637
638 hdr->frame_control = cpu_to_le16(RTLLIB_FTYPE_DATA |
639 IEEE80211_STYPE_NULLFUNC | IEEE80211_FCTL_TODS |
640 (pwr ? IEEE80211_FCTL_PM : 0));
641
642 return skb;
643 }
644
rtllib_pspoll_func(struct rtllib_device * ieee)645 static struct sk_buff *rtllib_pspoll_func(struct rtllib_device *ieee)
646 {
647 struct sk_buff *skb;
648 struct ieee80211_pspoll *hdr;
649
650 skb = dev_alloc_skb(sizeof(struct ieee80211_pspoll) + ieee->tx_headroom);
651 if (!skb)
652 return NULL;
653
654 skb_reserve(skb, ieee->tx_headroom);
655
656 hdr = skb_put(skb, sizeof(struct ieee80211_pspoll));
657
658 ether_addr_copy(hdr->bssid, ieee->current_network.bssid);
659 ether_addr_copy(hdr->ta, ieee->dev->dev_addr);
660
661 hdr->aid = cpu_to_le16(ieee->assoc_id | 0xc000);
662 hdr->frame_control = cpu_to_le16(RTLLIB_FTYPE_CTL | IEEE80211_STYPE_PSPOLL |
663 IEEE80211_FCTL_PM);
664
665 return skb;
666 }
667
SecIsInPMKIDList(struct rtllib_device * ieee,u8 * bssid)668 static inline int SecIsInPMKIDList(struct rtllib_device *ieee, u8 *bssid)
669 {
670 int i = 0;
671
672 do {
673 if ((ieee->PMKIDList[i].used) &&
674 (memcmp(ieee->PMKIDList[i].Bssid, bssid, ETH_ALEN) == 0))
675 break;
676 i++;
677 } while (i < NUM_PMKID_CACHE);
678
679 if (i == NUM_PMKID_CACHE)
680 i = -1;
681 return i;
682 }
683
684 static inline struct sk_buff *
rtllib_association_req(struct rtllib_network * beacon,struct rtllib_device * ieee)685 rtllib_association_req(struct rtllib_network *beacon,
686 struct rtllib_device *ieee)
687 {
688 struct sk_buff *skb;
689 struct rtllib_assoc_request_frame *hdr;
690 u8 *tag, *ies;
691 int i;
692 u8 *ht_cap_buf = NULL;
693 u8 ht_cap_len = 0;
694 u8 *realtek_ie_buf = NULL;
695 u8 realtek_ie_len = 0;
696 int wpa_ie_len = ieee->wpa_ie_len;
697 int wps_ie_len = ieee->wps_ie_len;
698 unsigned int ckip_ie_len = 0;
699 unsigned int ccxrm_ie_len = 0;
700 unsigned int cxvernum_ie_len = 0;
701 struct lib80211_crypt_data *crypt;
702 int encrypt;
703 int PMKCacheIdx;
704
705 unsigned int rate_len = (beacon->rates_len ?
706 (beacon->rates_len + 2) : 0) +
707 (beacon->rates_ex_len ? (beacon->rates_ex_len) +
708 2 : 0);
709
710 unsigned int wmm_info_len = beacon->qos_data.supported ? 9 : 0;
711 unsigned int turbo_info_len = beacon->Turbo_Enable ? 9 : 0;
712
713 int len = 0;
714
715 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
716 if (crypt)
717 encrypt = crypt && crypt->ops &&
718 ((strcmp(crypt->ops->name, "R-WEP") == 0 ||
719 wpa_ie_len));
720 else
721 encrypt = 0;
722
723 if ((ieee->rtllib_ap_sec_type &&
724 (ieee->rtllib_ap_sec_type(ieee) & SEC_ALG_TKIP)) ||
725 ieee->bForcedBgMode) {
726 ieee->ht_info->enable_ht = 0;
727 ieee->mode = WIRELESS_MODE_G;
728 }
729
730 if (ieee->ht_info->current_ht_support && ieee->ht_info->enable_ht) {
731 ht_cap_buf = (u8 *)&ieee->ht_info->SelfHTCap;
732 ht_cap_len = sizeof(ieee->ht_info->SelfHTCap);
733 ht_construct_capability_element(ieee, ht_cap_buf, &ht_cap_len,
734 encrypt, true);
735 if (ieee->ht_info->current_rt2rt_aggregation) {
736 realtek_ie_buf = ieee->ht_info->sz_rt2rt_agg_buf;
737 realtek_ie_len =
738 sizeof(ieee->ht_info->sz_rt2rt_agg_buf);
739 ht_construct_rt2rt_agg_element(ieee, realtek_ie_buf,
740 &realtek_ie_len);
741 }
742 }
743
744 if (beacon->bCkipSupported)
745 ckip_ie_len = 30 + 2;
746 if (beacon->bCcxRmEnable)
747 ccxrm_ie_len = 6 + 2;
748 if (beacon->BssCcxVerNumber >= 2)
749 cxvernum_ie_len = 5 + 2;
750
751 PMKCacheIdx = SecIsInPMKIDList(ieee, ieee->current_network.bssid);
752 if (PMKCacheIdx >= 0) {
753 wpa_ie_len += 18;
754 netdev_info(ieee->dev, "[PMK cache]: WPA2 IE length: %x\n",
755 wpa_ie_len);
756 }
757 len = sizeof(struct rtllib_assoc_request_frame) + 2
758 + beacon->ssid_len
759 + rate_len
760 + wpa_ie_len
761 + wps_ie_len
762 + wmm_info_len
763 + turbo_info_len
764 + ht_cap_len
765 + realtek_ie_len
766 + ckip_ie_len
767 + ccxrm_ie_len
768 + cxvernum_ie_len
769 + ieee->tx_headroom;
770
771 skb = dev_alloc_skb(len);
772
773 if (!skb)
774 return NULL;
775
776 skb_reserve(skb, ieee->tx_headroom);
777
778 hdr = skb_put(skb, sizeof(struct rtllib_assoc_request_frame) + 2);
779
780 hdr->header.frame_control = cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ);
781 hdr->header.duration_id = cpu_to_le16(37);
782 ether_addr_copy(hdr->header.addr1, beacon->bssid);
783 ether_addr_copy(hdr->header.addr2, ieee->dev->dev_addr);
784 ether_addr_copy(hdr->header.addr3, beacon->bssid);
785
786 ether_addr_copy(ieee->ap_mac_addr, beacon->bssid);
787
788 hdr->capability = cpu_to_le16(WLAN_CAPABILITY_ESS);
789 if (beacon->capability & WLAN_CAPABILITY_PRIVACY)
790 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
791
792 if (beacon->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
793 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
794
795 if (beacon->capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
796 hdr->capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME);
797
798 hdr->listen_interval = cpu_to_le16(beacon->listen_interval);
799
800 hdr->info_element[0].id = MFIE_TYPE_SSID;
801
802 hdr->info_element[0].len = beacon->ssid_len;
803 skb_put_data(skb, beacon->ssid, beacon->ssid_len);
804
805 tag = skb_put(skb, rate_len);
806
807 if (beacon->rates_len) {
808 *tag++ = MFIE_TYPE_RATES;
809 *tag++ = beacon->rates_len;
810 for (i = 0; i < beacon->rates_len; i++)
811 *tag++ = beacon->rates[i];
812 }
813
814 if (beacon->rates_ex_len) {
815 *tag++ = MFIE_TYPE_RATES_EX;
816 *tag++ = beacon->rates_ex_len;
817 for (i = 0; i < beacon->rates_ex_len; i++)
818 *tag++ = beacon->rates_ex[i];
819 }
820
821 if (beacon->bCkipSupported) {
822 static const u8 AironetIeOui[] = {0x00, 0x01, 0x66};
823 u8 CcxAironetBuf[30];
824 struct octet_string osCcxAironetIE;
825
826 memset(CcxAironetBuf, 0, 30);
827 osCcxAironetIE.Octet = CcxAironetBuf;
828 osCcxAironetIE.Length = sizeof(CcxAironetBuf);
829 memcpy(osCcxAironetIE.Octet, AironetIeOui,
830 sizeof(AironetIeOui));
831
832 osCcxAironetIE.Octet[IE_CISCO_FLAG_POSITION] |=
833 (SUPPORT_CKIP_PK | SUPPORT_CKIP_MIC);
834 tag = skb_put(skb, ckip_ie_len);
835 *tag++ = MFIE_TYPE_AIRONET;
836 *tag++ = osCcxAironetIE.Length;
837 memcpy(tag, osCcxAironetIE.Octet, osCcxAironetIE.Length);
838 tag += osCcxAironetIE.Length;
839 }
840
841 if (beacon->bCcxRmEnable) {
842 static const u8 CcxRmCapBuf[] = {0x00, 0x40, 0x96, 0x01, 0x01,
843 0x00};
844 struct octet_string osCcxRmCap;
845
846 osCcxRmCap.Octet = (u8 *)CcxRmCapBuf;
847 osCcxRmCap.Length = sizeof(CcxRmCapBuf);
848 tag = skb_put(skb, ccxrm_ie_len);
849 *tag++ = MFIE_TYPE_GENERIC;
850 *tag++ = osCcxRmCap.Length;
851 memcpy(tag, osCcxRmCap.Octet, osCcxRmCap.Length);
852 tag += osCcxRmCap.Length;
853 }
854
855 if (beacon->BssCcxVerNumber >= 2) {
856 u8 CcxVerNumBuf[] = {0x00, 0x40, 0x96, 0x03, 0x00};
857 struct octet_string osCcxVerNum;
858
859 CcxVerNumBuf[4] = beacon->BssCcxVerNumber;
860 osCcxVerNum.Octet = CcxVerNumBuf;
861 osCcxVerNum.Length = sizeof(CcxVerNumBuf);
862 tag = skb_put(skb, cxvernum_ie_len);
863 *tag++ = MFIE_TYPE_GENERIC;
864 *tag++ = osCcxVerNum.Length;
865 memcpy(tag, osCcxVerNum.Octet, osCcxVerNum.Length);
866 tag += osCcxVerNum.Length;
867 }
868 if (ieee->ht_info->current_ht_support && ieee->ht_info->enable_ht) {
869 if (ieee->ht_info->peer_ht_spec_ver != HT_SPEC_VER_EWC) {
870 tag = skb_put(skb, ht_cap_len);
871 *tag++ = MFIE_TYPE_HT_CAP;
872 *tag++ = ht_cap_len - 2;
873 memcpy(tag, ht_cap_buf, ht_cap_len - 2);
874 tag += ht_cap_len - 2;
875 }
876 }
877
878 if (wpa_ie_len) {
879 skb_put_data(skb, ieee->wpa_ie, ieee->wpa_ie_len);
880
881 if (PMKCacheIdx >= 0) {
882 tag = skb_put(skb, 18);
883 *tag = 1;
884 *(tag + 1) = 0;
885 memcpy((tag + 2), &ieee->PMKIDList[PMKCacheIdx].PMKID,
886 16);
887 }
888 }
889 if (wmm_info_len) {
890 tag = skb_put(skb, wmm_info_len);
891 rtllib_wmm_info(ieee, &tag);
892 }
893
894 if (wps_ie_len && ieee->wps_ie)
895 skb_put_data(skb, ieee->wps_ie, wps_ie_len);
896
897 if (turbo_info_len) {
898 tag = skb_put(skb, turbo_info_len);
899 rtllib_turbo_info(ieee, &tag);
900 }
901
902 if (ieee->ht_info->current_ht_support && ieee->ht_info->enable_ht) {
903 if (ieee->ht_info->peer_ht_spec_ver == HT_SPEC_VER_EWC) {
904 tag = skb_put(skb, ht_cap_len);
905 *tag++ = MFIE_TYPE_GENERIC;
906 *tag++ = ht_cap_len - 2;
907 memcpy(tag, ht_cap_buf, ht_cap_len - 2);
908 tag += ht_cap_len - 2;
909 }
910
911 if (ieee->ht_info->current_rt2rt_aggregation) {
912 tag = skb_put(skb, realtek_ie_len);
913 *tag++ = MFIE_TYPE_GENERIC;
914 *tag++ = realtek_ie_len - 2;
915 memcpy(tag, realtek_ie_buf, realtek_ie_len - 2);
916 }
917 }
918
919 kfree(ieee->assocreq_ies);
920 ieee->assocreq_ies = NULL;
921 ies = &hdr->info_element[0].id;
922 ieee->assocreq_ies_len = (skb->data + skb->len) - ies;
923 ieee->assocreq_ies = kmemdup(ies, ieee->assocreq_ies_len, GFP_ATOMIC);
924 if (!ieee->assocreq_ies)
925 ieee->assocreq_ies_len = 0;
926
927 return skb;
928 }
929
rtllib_associate_abort(struct rtllib_device * ieee)930 static void rtllib_associate_abort(struct rtllib_device *ieee)
931 {
932 unsigned long flags;
933
934 spin_lock_irqsave(&ieee->lock, flags);
935
936 ieee->associate_seq++;
937
938 /* don't scan, and avoid to have the RX path possibily
939 * try again to associate. Even do not react to AUTH or
940 * ASSOC response. Just wait for the retry wq to be scheduled.
941 * Here we will check if there are good nets to associate
942 * with, so we retry or just get back to NO_LINK and scanning
943 */
944 if (ieee->link_state == RTLLIB_ASSOCIATING_AUTHENTICATING) {
945 netdev_dbg(ieee->dev, "Authentication failed\n");
946 ieee->softmac_stats.no_auth_rs++;
947 } else {
948 netdev_dbg(ieee->dev, "Association failed\n");
949 ieee->softmac_stats.no_ass_rs++;
950 }
951
952 ieee->link_state = RTLLIB_ASSOCIATING_RETRY;
953
954 schedule_delayed_work(&ieee->associate_retry_wq,
955 RTLLIB_SOFTMAC_ASSOC_RETRY_TIME);
956
957 spin_unlock_irqrestore(&ieee->lock, flags);
958 }
959
rtllib_associate_abort_cb(struct timer_list * t)960 static void rtllib_associate_abort_cb(struct timer_list *t)
961 {
962 struct rtllib_device *dev = from_timer(dev, t, associate_timer);
963
964 rtllib_associate_abort(dev);
965 }
966
rtllib_associate_step1(struct rtllib_device * ieee,u8 * daddr)967 static void rtllib_associate_step1(struct rtllib_device *ieee, u8 *daddr)
968 {
969 struct rtllib_network *beacon = &ieee->current_network;
970 struct sk_buff *skb;
971
972 netdev_dbg(ieee->dev, "Stopping scan\n");
973
974 ieee->softmac_stats.tx_auth_rq++;
975
976 skb = rtllib_authentication_req(beacon, ieee, 0, daddr);
977
978 if (!skb) {
979 rtllib_associate_abort(ieee);
980 } else {
981 ieee->link_state = RTLLIB_ASSOCIATING_AUTHENTICATING;
982 netdev_dbg(ieee->dev, "Sending authentication request\n");
983 softmac_mgmt_xmit(skb, ieee);
984 if (!timer_pending(&ieee->associate_timer)) {
985 ieee->associate_timer.expires = jiffies + (HZ / 2);
986 add_timer(&ieee->associate_timer);
987 }
988 }
989 }
990
rtllib_auth_challenge(struct rtllib_device * ieee,u8 * challenge,int chlen)991 static void rtllib_auth_challenge(struct rtllib_device *ieee, u8 *challenge,
992 int chlen)
993 {
994 u8 *c;
995 struct sk_buff *skb;
996 struct rtllib_network *beacon = &ieee->current_network;
997
998 ieee->associate_seq++;
999 ieee->softmac_stats.tx_auth_rq++;
1000
1001 skb = rtllib_authentication_req(beacon, ieee, chlen + 2, beacon->bssid);
1002
1003 if (!skb) {
1004 rtllib_associate_abort(ieee);
1005 } else {
1006 c = skb_put(skb, chlen + 2);
1007 *(c++) = MFIE_TYPE_CHALLENGE;
1008 *(c++) = chlen;
1009 memcpy(c, challenge, chlen);
1010
1011 netdev_dbg(ieee->dev,
1012 "Sending authentication challenge response\n");
1013
1014 rtllib_encrypt_fragment(ieee, skb,
1015 sizeof(struct ieee80211_hdr_3addr));
1016
1017 softmac_mgmt_xmit(skb, ieee);
1018 mod_timer(&ieee->associate_timer, jiffies + (HZ / 2));
1019 }
1020 kfree(challenge);
1021 }
1022
rtllib_associate_step2(struct rtllib_device * ieee)1023 static void rtllib_associate_step2(struct rtllib_device *ieee)
1024 {
1025 struct sk_buff *skb;
1026 struct rtllib_network *beacon = &ieee->current_network;
1027
1028 del_timer_sync(&ieee->associate_timer);
1029
1030 netdev_dbg(ieee->dev, "Sending association request\n");
1031
1032 ieee->softmac_stats.tx_ass_rq++;
1033 skb = rtllib_association_req(beacon, ieee);
1034 if (!skb) {
1035 rtllib_associate_abort(ieee);
1036 } else {
1037 softmac_mgmt_xmit(skb, ieee);
1038 mod_timer(&ieee->associate_timer, jiffies + (HZ / 2));
1039 }
1040 }
1041
rtllib_associate_complete_wq(void * data)1042 static void rtllib_associate_complete_wq(void *data)
1043 {
1044 struct rtllib_device *ieee = (struct rtllib_device *)
1045 container_of(data,
1046 struct rtllib_device,
1047 associate_complete_wq);
1048 struct rt_pwr_save_ctrl *psc = &ieee->pwr_save_ctrl;
1049
1050 netdev_info(ieee->dev, "Associated successfully with %pM\n",
1051 ieee->current_network.bssid);
1052 netdev_info(ieee->dev, "normal associate\n");
1053 notify_wx_assoc_event(ieee);
1054
1055 netif_carrier_on(ieee->dev);
1056 ieee->is_roaming = false;
1057 if (rtllib_is_54g(&ieee->current_network)) {
1058 ieee->rate = 108;
1059 netdev_info(ieee->dev, "Using G rates:%d\n", ieee->rate);
1060 } else {
1061 ieee->rate = 22;
1062 ieee->set_wireless_mode(ieee->dev, WIRELESS_MODE_B);
1063 netdev_info(ieee->dev, "Using B rates:%d\n", ieee->rate);
1064 }
1065 if (ieee->ht_info->current_ht_support && ieee->ht_info->enable_ht) {
1066 netdev_info(ieee->dev, "Successfully associated, ht enabled\n");
1067 ht_on_assoc_rsp(ieee);
1068 } else {
1069 netdev_info(ieee->dev,
1070 "Successfully associated, ht not enabled(%d, %d)\n",
1071 ieee->ht_info->current_ht_support,
1072 ieee->ht_info->enable_ht);
1073 memset(ieee->dot11ht_oper_rate_set, 0, 16);
1074 }
1075 ieee->link_detect_info.SlotNum = 2 * (1 +
1076 ieee->current_network.beacon_interval /
1077 500);
1078 if (ieee->link_detect_info.NumRecvBcnInPeriod == 0 ||
1079 ieee->link_detect_info.NumRecvDataInPeriod == 0) {
1080 ieee->link_detect_info.NumRecvBcnInPeriod = 1;
1081 ieee->link_detect_info.NumRecvDataInPeriod = 1;
1082 }
1083 psc->LpsIdleCount = 0;
1084 ieee->link_change(ieee->dev);
1085
1086 }
1087
rtllib_sta_send_associnfo(struct rtllib_device * ieee)1088 static void rtllib_sta_send_associnfo(struct rtllib_device *ieee)
1089 {
1090 }
1091
rtllib_associate_complete(struct rtllib_device * ieee)1092 static void rtllib_associate_complete(struct rtllib_device *ieee)
1093 {
1094 del_timer_sync(&ieee->associate_timer);
1095
1096 ieee->link_state = MAC80211_LINKED;
1097 rtllib_sta_send_associnfo(ieee);
1098
1099 schedule_work(&ieee->associate_complete_wq);
1100 }
1101
rtllib_associate_procedure_wq(void * data)1102 static void rtllib_associate_procedure_wq(void *data)
1103 {
1104 struct rtllib_device *ieee = container_of_dwork_rsl(data,
1105 struct rtllib_device,
1106 associate_procedure_wq);
1107 rtllib_stop_scan_syncro(ieee);
1108 ieee->rtllib_ips_leave(ieee->dev);
1109 mutex_lock(&ieee->wx_mutex);
1110
1111 rtllib_stop_scan(ieee);
1112 ht_set_connect_bw_mode(ieee, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT);
1113 if (ieee->rf_power_state == rf_off) {
1114 ieee->rtllib_ips_leave_wq(ieee->dev);
1115 mutex_unlock(&ieee->wx_mutex);
1116 return;
1117 }
1118 ieee->associate_seq = 1;
1119
1120 rtllib_associate_step1(ieee, ieee->current_network.bssid);
1121
1122 mutex_unlock(&ieee->wx_mutex);
1123 }
1124
rtllib_softmac_new_net(struct rtllib_device * ieee,struct rtllib_network * net)1125 inline void rtllib_softmac_new_net(struct rtllib_device *ieee,
1126 struct rtllib_network *net)
1127 {
1128 u8 tmp_ssid[IW_ESSID_MAX_SIZE + 1];
1129 int tmp_ssid_len = 0;
1130
1131 short apset, ssidset, ssidbroad, apmatch, ssidmatch;
1132
1133 /* we are interested in new only if we are not associated
1134 * and we are not associating / authenticating
1135 */
1136 if (ieee->link_state != MAC80211_NOLINK)
1137 return;
1138
1139 if ((ieee->iw_mode == IW_MODE_INFRA) && !(net->capability &
1140 WLAN_CAPABILITY_ESS))
1141 return;
1142
1143 if (ieee->iw_mode == IW_MODE_INFRA) {
1144 /* if the user specified the AP MAC, we need also the essid
1145 * This could be obtained by beacons or, if the network does not
1146 * broadcast it, it can be put manually.
1147 */
1148 apset = ieee->wap_set;
1149 ssidset = ieee->ssid_set;
1150 ssidbroad = !(net->ssid_len == 0 || net->ssid[0] == '\0');
1151 apmatch = (memcmp(ieee->current_network.bssid, net->bssid,
1152 ETH_ALEN) == 0);
1153 if (!ssidbroad) {
1154 ssidmatch = (ieee->current_network.ssid_len ==
1155 net->hidden_ssid_len) &&
1156 (!strncmp(ieee->current_network.ssid,
1157 net->hidden_ssid, net->hidden_ssid_len));
1158 if (net->hidden_ssid_len > 0) {
1159 strncpy(net->ssid, net->hidden_ssid,
1160 net->hidden_ssid_len);
1161 net->ssid_len = net->hidden_ssid_len;
1162 ssidbroad = 1;
1163 }
1164 } else {
1165 ssidmatch =
1166 (ieee->current_network.ssid_len == net->ssid_len) &&
1167 (!strncmp(ieee->current_network.ssid, net->ssid,
1168 net->ssid_len));
1169 }
1170
1171 /* if the user set the AP check if match.
1172 * if the network does not broadcast essid we check the
1173 * user supplied ANY essid
1174 * if the network does broadcast and the user does not set
1175 * essid it is OK
1176 * if the network does broadcast and the user did set essid
1177 * check if essid match
1178 * if the ap is not set, check that the user set the bssid
1179 * and the network does broadcast and that those two bssid match
1180 */
1181 if ((apset && apmatch &&
1182 ((ssidset && ssidbroad && ssidmatch) ||
1183 (ssidbroad && !ssidset) || (!ssidbroad && ssidset))) ||
1184 (!apset && ssidset && ssidbroad && ssidmatch) ||
1185 (ieee->is_roaming && ssidset && ssidbroad && ssidmatch)) {
1186 /* Save the essid so that if it is hidden, it is
1187 * replaced with the essid provided by the user.
1188 */
1189 if (!ssidbroad) {
1190 memcpy(tmp_ssid, ieee->current_network.ssid,
1191 ieee->current_network.ssid_len);
1192 tmp_ssid_len = ieee->current_network.ssid_len;
1193 }
1194 memcpy(&ieee->current_network, net,
1195 sizeof(ieee->current_network));
1196 if (!ssidbroad) {
1197 memcpy(ieee->current_network.ssid, tmp_ssid,
1198 tmp_ssid_len);
1199 ieee->current_network.ssid_len = tmp_ssid_len;
1200 }
1201 netdev_info(ieee->dev,
1202 "Linking with %s,channel:%d, qos:%d, myHT:%d, networkHT:%d, mode:%x cur_net.flags:0x%x\n",
1203 ieee->current_network.ssid,
1204 ieee->current_network.channel,
1205 ieee->current_network.qos_data.supported,
1206 ieee->ht_info->enable_ht,
1207 ieee->current_network.bssht.bd_support_ht,
1208 ieee->current_network.mode,
1209 ieee->current_network.flags);
1210
1211 if ((rtllib_act_scanning(ieee, false)) &&
1212 !(ieee->softmac_features & IEEE_SOFTMAC_SCAN))
1213 rtllib_stop_scan_syncro(ieee);
1214
1215 ht_reset_iot_setting(ieee->ht_info);
1216 ieee->wmm_acm = 0;
1217 if (ieee->iw_mode == IW_MODE_INFRA) {
1218 /* Join the network for the first time */
1219 ieee->AsocRetryCount = 0;
1220 if ((ieee->current_network.qos_data.supported == 1) &&
1221 ieee->current_network.bssht.bd_support_ht)
1222 ht_reset_self_and_save_peer_setting(ieee,
1223 &(ieee->current_network));
1224 else
1225 ieee->ht_info->current_ht_support = false;
1226
1227 ieee->link_state = RTLLIB_ASSOCIATING;
1228 schedule_delayed_work(&ieee->associate_procedure_wq, 0);
1229 } else {
1230 if (rtllib_is_54g(&ieee->current_network)) {
1231 ieee->rate = 108;
1232 ieee->set_wireless_mode(ieee->dev, WIRELESS_MODE_G);
1233 netdev_info(ieee->dev,
1234 "Using G rates\n");
1235 } else {
1236 ieee->rate = 22;
1237 ieee->set_wireless_mode(ieee->dev, WIRELESS_MODE_B);
1238 netdev_info(ieee->dev,
1239 "Using B rates\n");
1240 }
1241 memset(ieee->dot11ht_oper_rate_set, 0, 16);
1242 ieee->link_state = MAC80211_LINKED;
1243 }
1244 }
1245 }
1246 }
1247
rtllib_softmac_check_all_nets(struct rtllib_device * ieee)1248 static void rtllib_softmac_check_all_nets(struct rtllib_device *ieee)
1249 {
1250 unsigned long flags;
1251 struct rtllib_network *target;
1252
1253 spin_lock_irqsave(&ieee->lock, flags);
1254
1255 list_for_each_entry(target, &ieee->network_list, list) {
1256 /* if the state become different that NOLINK means
1257 * we had found what we are searching for
1258 */
1259
1260 if (ieee->link_state != MAC80211_NOLINK)
1261 break;
1262
1263 if (ieee->scan_age == 0 || time_after(target->last_scanned +
1264 ieee->scan_age, jiffies))
1265 rtllib_softmac_new_net(ieee, target);
1266 }
1267 spin_unlock_irqrestore(&ieee->lock, flags);
1268 }
1269
auth_parse(struct net_device * dev,struct sk_buff * skb,u8 ** challenge,int * chlen)1270 static inline int auth_parse(struct net_device *dev, struct sk_buff *skb,
1271 u8 **challenge, int *chlen)
1272 {
1273 struct rtllib_authentication *a;
1274 u8 *t;
1275
1276 if (skb->len < (sizeof(struct rtllib_authentication) -
1277 sizeof(struct rtllib_info_element))) {
1278 netdev_dbg(dev, "invalid len in auth resp: %d\n", skb->len);
1279 return -EINVAL;
1280 }
1281 *challenge = NULL;
1282 a = (struct rtllib_authentication *)skb->data;
1283 if (skb->len > (sizeof(struct rtllib_authentication) + 3)) {
1284 t = skb->data + sizeof(struct rtllib_authentication);
1285
1286 if (*(t++) == MFIE_TYPE_CHALLENGE) {
1287 *chlen = *(t++);
1288 *challenge = kmemdup(t, *chlen, GFP_ATOMIC);
1289 if (!*challenge)
1290 return -ENOMEM;
1291 }
1292 }
1293
1294 if (a->status) {
1295 netdev_dbg(dev, "auth_parse() failed\n");
1296 return -EINVAL;
1297 }
1298
1299 return 0;
1300 }
1301
assoc_parse(struct rtllib_device * ieee,struct sk_buff * skb,int * aid)1302 static inline u16 assoc_parse(struct rtllib_device *ieee, struct sk_buff *skb,
1303 int *aid)
1304 {
1305 struct rtllib_assoc_response_frame *response_head;
1306 u16 status_code;
1307
1308 if (skb->len < sizeof(struct rtllib_assoc_response_frame)) {
1309 netdev_dbg(ieee->dev, "Invalid len in auth resp: %d\n",
1310 skb->len);
1311 return 0xcafe;
1312 }
1313
1314 response_head = (struct rtllib_assoc_response_frame *)skb->data;
1315 *aid = le16_to_cpu(response_head->aid) & 0x3fff;
1316
1317 status_code = le16_to_cpu(response_head->status);
1318 if ((status_code == WLAN_STATUS_ASSOC_DENIED_RATES ||
1319 status_code == WLAN_STATUS_CAPS_UNSUPPORTED) &&
1320 ((ieee->mode == WIRELESS_MODE_G) &&
1321 (ieee->current_network.mode == WIRELESS_MODE_N_24G) &&
1322 (ieee->AsocRetryCount++ < (RT_ASOC_RETRY_LIMIT - 1)))) {
1323 ieee->ht_info->iot_action |= HT_IOT_ACT_PURE_N_MODE;
1324 } else {
1325 ieee->AsocRetryCount = 0;
1326 }
1327
1328 return le16_to_cpu(response_head->status);
1329 }
1330
rtllib_sta_ps_send_null_frame(struct rtllib_device * ieee,short pwr)1331 void rtllib_sta_ps_send_null_frame(struct rtllib_device *ieee, short pwr)
1332 {
1333 struct sk_buff *buf = rtllib_null_func(ieee, pwr);
1334
1335 if (buf)
1336 softmac_ps_mgmt_xmit(buf, ieee);
1337 }
1338 EXPORT_SYMBOL(rtllib_sta_ps_send_null_frame);
1339
rtllib_sta_ps_send_pspoll_frame(struct rtllib_device * ieee)1340 void rtllib_sta_ps_send_pspoll_frame(struct rtllib_device *ieee)
1341 {
1342 struct sk_buff *buf = rtllib_pspoll_func(ieee);
1343
1344 if (buf)
1345 softmac_ps_mgmt_xmit(buf, ieee);
1346 }
1347
rtllib_sta_ps_sleep(struct rtllib_device * ieee,u64 * time)1348 static short rtllib_sta_ps_sleep(struct rtllib_device *ieee, u64 *time)
1349 {
1350 int timeout;
1351 u8 dtim;
1352 struct rt_pwr_save_ctrl *psc = &ieee->pwr_save_ctrl;
1353
1354 if (ieee->LPSDelayCnt) {
1355 ieee->LPSDelayCnt--;
1356 return 0;
1357 }
1358
1359 dtim = ieee->current_network.dtim_data;
1360 if (!(dtim & RTLLIB_DTIM_VALID))
1361 return 0;
1362 timeout = ieee->current_network.beacon_interval;
1363 ieee->current_network.dtim_data = RTLLIB_DTIM_INVALID;
1364 /* there's no need to nofity AP that I find you buffered
1365 * with broadcast packet
1366 */
1367 if (dtim & (RTLLIB_DTIM_UCAST & ieee->ps))
1368 return 2;
1369
1370 if (!time_after(jiffies,
1371 dev_trans_start(ieee->dev) + msecs_to_jiffies(timeout)))
1372 return 0;
1373 if (!time_after(jiffies,
1374 ieee->last_rx_ps_time + msecs_to_jiffies(timeout)))
1375 return 0;
1376 if ((ieee->softmac_features & IEEE_SOFTMAC_SINGLE_QUEUE) &&
1377 (ieee->mgmt_queue_tail != ieee->mgmt_queue_head))
1378 return 0;
1379
1380 if (time) {
1381 if (ieee->bAwakePktSent) {
1382 psc->LPSAwakeIntvl = 1;
1383 } else {
1384 u8 MaxPeriod = 5;
1385
1386 if (psc->LPSAwakeIntvl == 0)
1387 psc->LPSAwakeIntvl = 1;
1388 psc->LPSAwakeIntvl = (psc->LPSAwakeIntvl >=
1389 MaxPeriod) ? MaxPeriod :
1390 (psc->LPSAwakeIntvl + 1);
1391 }
1392 {
1393 u8 LPSAwakeIntvl_tmp = 0;
1394 u8 period = ieee->current_network.dtim_period;
1395 u8 count = ieee->current_network.tim.tim_count;
1396
1397 if (count == 0) {
1398 if (psc->LPSAwakeIntvl > period)
1399 LPSAwakeIntvl_tmp = period +
1400 (psc->LPSAwakeIntvl -
1401 period) -
1402 ((psc->LPSAwakeIntvl - period) %
1403 period);
1404 else
1405 LPSAwakeIntvl_tmp = psc->LPSAwakeIntvl;
1406
1407 } else {
1408 if (psc->LPSAwakeIntvl >
1409 ieee->current_network.tim.tim_count)
1410 LPSAwakeIntvl_tmp = count +
1411 (psc->LPSAwakeIntvl - count) -
1412 ((psc->LPSAwakeIntvl - count) % period);
1413 else
1414 LPSAwakeIntvl_tmp = psc->LPSAwakeIntvl;
1415 }
1416
1417 *time = ieee->current_network.last_dtim_sta_time
1418 + msecs_to_jiffies(ieee->current_network.beacon_interval *
1419 LPSAwakeIntvl_tmp);
1420 }
1421 }
1422
1423 return 1;
1424 }
1425
rtllib_sta_ps(struct work_struct * work)1426 static inline void rtllib_sta_ps(struct work_struct *work)
1427 {
1428 struct rtllib_device *ieee;
1429 u64 time;
1430 short sleep;
1431 unsigned long flags, flags2;
1432
1433 ieee = container_of(work, struct rtllib_device, ps_task);
1434
1435 spin_lock_irqsave(&ieee->lock, flags);
1436
1437 if ((ieee->ps == RTLLIB_PS_DISABLED ||
1438 ieee->iw_mode != IW_MODE_INFRA ||
1439 ieee->link_state != MAC80211_LINKED)) {
1440 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
1441 rtllib_sta_wakeup(ieee, 1);
1442
1443 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
1444 }
1445 sleep = rtllib_sta_ps_sleep(ieee, &time);
1446 /* 2 wake, 1 sleep, 0 do nothing */
1447 if (sleep == 0)
1448 goto out;
1449 if (sleep == 1) {
1450 if (ieee->sta_sleep == LPS_IS_SLEEP) {
1451 ieee->enter_sleep_state(ieee->dev, time);
1452 } else if (ieee->sta_sleep == LPS_IS_WAKE) {
1453 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
1454
1455 if (ieee->ps_is_queue_empty(ieee->dev)) {
1456 ieee->sta_sleep = LPS_WAIT_NULL_DATA_SEND;
1457 ieee->ack_tx_to_ieee = 1;
1458 rtllib_sta_ps_send_null_frame(ieee, 1);
1459 ieee->ps_time = time;
1460 }
1461 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
1462 }
1463
1464 ieee->bAwakePktSent = false;
1465
1466 } else if (sleep == 2) {
1467 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
1468
1469 rtllib_sta_wakeup(ieee, 1);
1470
1471 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
1472 }
1473
1474 out:
1475 spin_unlock_irqrestore(&ieee->lock, flags);
1476 }
1477
rtllib_sta_wakeup(struct rtllib_device * ieee,short nl)1478 static void rtllib_sta_wakeup(struct rtllib_device *ieee, short nl)
1479 {
1480 if (ieee->sta_sleep == LPS_IS_WAKE) {
1481 if (nl) {
1482 if (ieee->ht_info->iot_action &
1483 HT_IOT_ACT_NULL_DATA_POWER_SAVING) {
1484 ieee->ack_tx_to_ieee = 1;
1485 rtllib_sta_ps_send_null_frame(ieee, 0);
1486 } else {
1487 ieee->ack_tx_to_ieee = 1;
1488 rtllib_sta_ps_send_pspoll_frame(ieee);
1489 }
1490 }
1491 return;
1492 }
1493
1494 if (ieee->sta_sleep == LPS_IS_SLEEP)
1495 ieee->sta_wake_up(ieee->dev);
1496 if (nl) {
1497 if (ieee->ht_info->iot_action &
1498 HT_IOT_ACT_NULL_DATA_POWER_SAVING) {
1499 ieee->ack_tx_to_ieee = 1;
1500 rtllib_sta_ps_send_null_frame(ieee, 0);
1501 } else {
1502 ieee->ack_tx_to_ieee = 1;
1503 ieee->polling = true;
1504 rtllib_sta_ps_send_pspoll_frame(ieee);
1505 }
1506
1507 } else {
1508 ieee->sta_sleep = LPS_IS_WAKE;
1509 ieee->polling = false;
1510 }
1511 }
1512
rtllib_ps_tx_ack(struct rtllib_device * ieee,short success)1513 void rtllib_ps_tx_ack(struct rtllib_device *ieee, short success)
1514 {
1515 unsigned long flags, flags2;
1516
1517 spin_lock_irqsave(&ieee->lock, flags);
1518
1519 if (ieee->sta_sleep == LPS_WAIT_NULL_DATA_SEND) {
1520 /* Null frame with PS bit set */
1521 if (success) {
1522 ieee->sta_sleep = LPS_IS_SLEEP;
1523 ieee->enter_sleep_state(ieee->dev, ieee->ps_time);
1524 }
1525 /* if the card report not success we can't be sure the AP
1526 * has not RXed so we can't assume the AP believe us awake
1527 */
1528 } else {/* 21112005 - tx again null without PS bit if lost */
1529
1530 if ((ieee->sta_sleep == LPS_IS_WAKE) && !success) {
1531 spin_lock_irqsave(&ieee->mgmt_tx_lock, flags2);
1532 if (ieee->ht_info->iot_action &
1533 HT_IOT_ACT_NULL_DATA_POWER_SAVING)
1534 rtllib_sta_ps_send_null_frame(ieee, 0);
1535 else
1536 rtllib_sta_ps_send_pspoll_frame(ieee);
1537 spin_unlock_irqrestore(&ieee->mgmt_tx_lock, flags2);
1538 }
1539 }
1540 spin_unlock_irqrestore(&ieee->lock, flags);
1541 }
1542 EXPORT_SYMBOL(rtllib_ps_tx_ack);
1543
rtllib_process_action(struct rtllib_device * ieee,struct sk_buff * skb)1544 static void rtllib_process_action(struct rtllib_device *ieee,
1545 struct sk_buff *skb)
1546 {
1547 u8 *act = skb->data + RTLLIB_3ADDR_LEN;
1548 u8 category = 0;
1549
1550 category = *act;
1551 act++;
1552 switch (category) {
1553 case ACT_CAT_BA:
1554 switch (*act) {
1555 case ACT_ADDBAREQ:
1556 rtllib_rx_ADDBAReq(ieee, skb);
1557 break;
1558 case ACT_ADDBARSP:
1559 rtllib_rx_ADDBARsp(ieee, skb);
1560 break;
1561 case ACT_DELBA:
1562 rtllib_rx_DELBA(ieee, skb);
1563 break;
1564 }
1565 break;
1566 default:
1567 break;
1568 }
1569 }
1570
1571 static inline int
rtllib_rx_assoc_resp(struct rtllib_device * ieee,struct sk_buff * skb,struct rtllib_rx_stats * rx_stats)1572 rtllib_rx_assoc_resp(struct rtllib_device *ieee, struct sk_buff *skb,
1573 struct rtllib_rx_stats *rx_stats)
1574 {
1575 u16 errcode;
1576 int aid;
1577 u8 *ies;
1578 struct rtllib_assoc_response_frame *assoc_resp;
1579 struct ieee80211_hdr_3addr *header = (struct ieee80211_hdr_3addr *)skb->data;
1580 u16 frame_ctl = le16_to_cpu(header->frame_control);
1581
1582 netdev_dbg(ieee->dev, "received [RE]ASSOCIATION RESPONSE (%d)\n",
1583 WLAN_FC_GET_STYPE(frame_ctl));
1584
1585 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&
1586 ieee->link_state == RTLLIB_ASSOCIATING_AUTHENTICATED &&
1587 (ieee->iw_mode == IW_MODE_INFRA)) {
1588 errcode = assoc_parse(ieee, skb, &aid);
1589 if (!errcode) {
1590 struct rtllib_network *network =
1591 kzalloc(sizeof(struct rtllib_network),
1592 GFP_ATOMIC);
1593
1594 if (!network)
1595 return 1;
1596 ieee->link_state = MAC80211_LINKED;
1597 ieee->assoc_id = aid;
1598 ieee->softmac_stats.rx_ass_ok++;
1599 /* station support qos */
1600 /* Let the register setting default with Legacy station */
1601 assoc_resp = (struct rtllib_assoc_response_frame *)skb->data;
1602 if (ieee->current_network.qos_data.supported == 1) {
1603 if (rtllib_parse_info_param(ieee, assoc_resp->info_element,
1604 rx_stats->len - sizeof(*assoc_resp),
1605 network, rx_stats)) {
1606 kfree(network);
1607 return 1;
1608 }
1609 memcpy(ieee->ht_info->PeerHTCapBuf,
1610 network->bssht.bd_ht_cap_buf,
1611 network->bssht.bd_ht_cap_len);
1612 memcpy(ieee->ht_info->PeerHTInfoBuf,
1613 network->bssht.bd_ht_info_buf,
1614 network->bssht.bd_ht_info_len);
1615 ieee->handle_assoc_response(ieee->dev,
1616 (struct rtllib_assoc_response_frame *)header, network);
1617 }
1618 kfree(network);
1619
1620 kfree(ieee->assocresp_ies);
1621 ieee->assocresp_ies = NULL;
1622 ies = &assoc_resp->info_element[0].id;
1623 ieee->assocresp_ies_len = (skb->data + skb->len) - ies;
1624 ieee->assocresp_ies = kmemdup(ies,
1625 ieee->assocresp_ies_len,
1626 GFP_ATOMIC);
1627 if (!ieee->assocresp_ies)
1628 ieee->assocresp_ies_len = 0;
1629
1630 rtllib_associate_complete(ieee);
1631 } else {
1632 /* aid could not been allocated */
1633 ieee->softmac_stats.rx_ass_err++;
1634 netdev_info(ieee->dev,
1635 "Association response status code 0x%x\n",
1636 errcode);
1637 if (ieee->AsocRetryCount < RT_ASOC_RETRY_LIMIT)
1638 schedule_delayed_work(&ieee->associate_procedure_wq, 0);
1639 else
1640 rtllib_associate_abort(ieee);
1641 }
1642 }
1643 return 0;
1644 }
1645
rtllib_rx_auth_resp(struct rtllib_device * ieee,struct sk_buff * skb)1646 static void rtllib_rx_auth_resp(struct rtllib_device *ieee, struct sk_buff *skb)
1647 {
1648 int errcode;
1649 u8 *challenge;
1650 int chlen = 0;
1651 bool bSupportNmode = true, bHalfSupportNmode = false;
1652
1653 errcode = auth_parse(ieee->dev, skb, &challenge, &chlen);
1654
1655 if (errcode) {
1656 ieee->softmac_stats.rx_auth_rs_err++;
1657 netdev_info(ieee->dev,
1658 "Authentication response status code %d", errcode);
1659 rtllib_associate_abort(ieee);
1660 return;
1661 }
1662
1663 if (ieee->open_wep || !challenge) {
1664 ieee->link_state = RTLLIB_ASSOCIATING_AUTHENTICATED;
1665 ieee->softmac_stats.rx_auth_rs_ok++;
1666 if (!(ieee->ht_info->iot_action & HT_IOT_ACT_PURE_N_MODE)) {
1667 if (!ieee->GetNmodeSupportBySecCfg(ieee->dev)) {
1668 if (is_ht_half_nmode_aps(ieee)) {
1669 bSupportNmode = true;
1670 bHalfSupportNmode = true;
1671 } else {
1672 bSupportNmode = false;
1673 bHalfSupportNmode = false;
1674 }
1675 }
1676 }
1677 /* Dummy wirless mode setting to avoid encryption issue */
1678 if (bSupportNmode) {
1679 ieee->set_wireless_mode(ieee->dev,
1680 ieee->current_network.mode);
1681 } else {
1682 /*TODO*/
1683 ieee->set_wireless_mode(ieee->dev, WIRELESS_MODE_G);
1684 }
1685
1686 if ((ieee->current_network.mode == WIRELESS_MODE_N_24G) &&
1687 bHalfSupportNmode) {
1688 netdev_info(ieee->dev, "======>enter half N mode\n");
1689 ieee->bHalfWirelessN24GMode = true;
1690 } else {
1691 ieee->bHalfWirelessN24GMode = false;
1692 }
1693 rtllib_associate_step2(ieee);
1694 } else {
1695 rtllib_auth_challenge(ieee, challenge, chlen);
1696 }
1697 }
1698
1699 static inline int
rtllib_rx_auth(struct rtllib_device * ieee,struct sk_buff * skb,struct rtllib_rx_stats * rx_stats)1700 rtllib_rx_auth(struct rtllib_device *ieee, struct sk_buff *skb,
1701 struct rtllib_rx_stats *rx_stats)
1702 {
1703 if (ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) {
1704 if (ieee->link_state == RTLLIB_ASSOCIATING_AUTHENTICATING &&
1705 (ieee->iw_mode == IW_MODE_INFRA)) {
1706 netdev_dbg(ieee->dev,
1707 "Received authentication response");
1708 rtllib_rx_auth_resp(ieee, skb);
1709 }
1710 }
1711 return 0;
1712 }
1713
1714 static inline int
rtllib_rx_deauth(struct rtllib_device * ieee,struct sk_buff * skb)1715 rtllib_rx_deauth(struct rtllib_device *ieee, struct sk_buff *skb)
1716 {
1717 struct ieee80211_hdr_3addr *header = (struct ieee80211_hdr_3addr *)skb->data;
1718 u16 frame_ctl;
1719
1720 if (memcmp(header->addr3, ieee->current_network.bssid, ETH_ALEN) != 0)
1721 return 0;
1722
1723 /* FIXME for now repeat all the association procedure
1724 * both for disassociation and deauthentication
1725 */
1726 if ((ieee->softmac_features & IEEE_SOFTMAC_ASSOCIATE) &&
1727 ieee->link_state == MAC80211_LINKED &&
1728 (ieee->iw_mode == IW_MODE_INFRA)) {
1729 frame_ctl = le16_to_cpu(header->frame_control);
1730 netdev_info(ieee->dev,
1731 "==========>received disassoc/deauth(%x) frame, reason code:%x\n",
1732 WLAN_FC_GET_STYPE(frame_ctl),
1733 ((struct rtllib_disassoc *)skb->data)->reason);
1734 ieee->link_state = RTLLIB_ASSOCIATING;
1735 ieee->softmac_stats.reassoc++;
1736 ieee->is_roaming = true;
1737 ieee->link_detect_info.bBusyTraffic = false;
1738 rtllib_disassociate(ieee);
1739 RemovePeerTS(ieee, header->addr2);
1740 if (!(ieee->rtllib_ap_sec_type(ieee) &
1741 (SEC_ALG_CCMP | SEC_ALG_TKIP)))
1742 schedule_delayed_work(
1743 &ieee->associate_procedure_wq, 5);
1744 }
1745 return 0;
1746 }
1747
rtllib_rx_frame_softmac(struct rtllib_device * ieee,struct sk_buff * skb,struct rtllib_rx_stats * rx_stats,u16 type,u16 stype)1748 inline int rtllib_rx_frame_softmac(struct rtllib_device *ieee,
1749 struct sk_buff *skb,
1750 struct rtllib_rx_stats *rx_stats, u16 type,
1751 u16 stype)
1752 {
1753 struct ieee80211_hdr_3addr *header = (struct ieee80211_hdr_3addr *)skb->data;
1754 u16 frame_ctl;
1755
1756 if (!ieee->proto_started)
1757 return 0;
1758
1759 frame_ctl = le16_to_cpu(header->frame_control);
1760 switch (WLAN_FC_GET_STYPE(frame_ctl)) {
1761 case IEEE80211_STYPE_ASSOC_RESP:
1762 case IEEE80211_STYPE_REASSOC_RESP:
1763 if (rtllib_rx_assoc_resp(ieee, skb, rx_stats) == 1)
1764 return 1;
1765 break;
1766 case IEEE80211_STYPE_ASSOC_REQ:
1767 case IEEE80211_STYPE_REASSOC_REQ:
1768 break;
1769 case IEEE80211_STYPE_AUTH:
1770 rtllib_rx_auth(ieee, skb, rx_stats);
1771 break;
1772 case IEEE80211_STYPE_DISASSOC:
1773 case IEEE80211_STYPE_DEAUTH:
1774 rtllib_rx_deauth(ieee, skb);
1775 break;
1776 case IEEE80211_STYPE_ACTION:
1777 rtllib_process_action(ieee, skb);
1778 break;
1779 default:
1780 return -1;
1781 }
1782 return 0;
1783 }
1784
1785 /* following are for a simpler TX queue management.
1786 * Instead of using netif_[stop/wake]_queue the driver
1787 * will use these two functions (plus a reset one), that
1788 * will internally use the kernel netif_* and takes
1789 * care of the ieee802.11 fragmentation.
1790 * So the driver receives a fragment per time and might
1791 * call the stop function when it wants to not
1792 * have enough room to TX an entire packet.
1793 * This might be useful if each fragment needs it's own
1794 * descriptor, thus just keep a total free memory > than
1795 * the max fragmentation threshold is not enough.. If the
1796 * ieee802.11 stack passed a TXB struct then you need
1797 * to keep N free descriptors where
1798 * N = MAX_PACKET_SIZE / MIN_FRAG_TRESHOLD
1799 * In this way you need just one and the 802.11 stack
1800 * will take care of buffering fragments and pass them to
1801 * the driver later, when it wakes the queue.
1802 */
rtllib_softmac_xmit(struct rtllib_txb * txb,struct rtllib_device * ieee)1803 void rtllib_softmac_xmit(struct rtllib_txb *txb, struct rtllib_device *ieee)
1804 {
1805 unsigned int queue_index = txb->queue_index;
1806 unsigned long flags;
1807 int i;
1808 struct cb_desc *tcb_desc = NULL;
1809 unsigned long queue_len = 0;
1810
1811 spin_lock_irqsave(&ieee->lock, flags);
1812
1813 /* called with 2nd parm 0, no tx mgmt lock required */
1814 rtllib_sta_wakeup(ieee, 0);
1815
1816 /* update the tx status */
1817 tcb_desc = (struct cb_desc *)(txb->fragments[0]->cb +
1818 MAX_DEV_ADDR_SIZE);
1819 if (tcb_desc->bMulticast)
1820 ieee->stats.multicast++;
1821
1822 /* if xmit available, just xmit it immediately, else just insert it to
1823 * the wait queue
1824 */
1825 for (i = 0; i < txb->nr_frags; i++) {
1826 queue_len = skb_queue_len(&ieee->skb_waitq[queue_index]);
1827 if ((queue_len != 0) ||
1828 (!ieee->check_nic_enough_desc(ieee->dev, queue_index)) ||
1829 (ieee->queue_stop)) {
1830 /* insert the skb packet to the wait queue
1831 * as for the completion function, it does not need
1832 * to check it any more.
1833 */
1834 if (queue_len < 200)
1835 skb_queue_tail(&ieee->skb_waitq[queue_index],
1836 txb->fragments[i]);
1837 else
1838 kfree_skb(txb->fragments[i]);
1839 } else {
1840 ieee->softmac_data_hard_start_xmit(txb->fragments[i],
1841 ieee->dev, ieee->rate);
1842 }
1843 }
1844
1845 rtllib_txb_free(txb);
1846
1847 spin_unlock_irqrestore(&ieee->lock, flags);
1848 }
1849
rtllib_reset_queue(struct rtllib_device * ieee)1850 void rtllib_reset_queue(struct rtllib_device *ieee)
1851 {
1852 unsigned long flags;
1853
1854 spin_lock_irqsave(&ieee->lock, flags);
1855 init_mgmt_queue(ieee);
1856 if (ieee->tx_pending.txb) {
1857 rtllib_txb_free(ieee->tx_pending.txb);
1858 ieee->tx_pending.txb = NULL;
1859 }
1860 ieee->queue_stop = 0;
1861 spin_unlock_irqrestore(&ieee->lock, flags);
1862 }
1863 EXPORT_SYMBOL(rtllib_reset_queue);
1864
rtllib_stop_all_queues(struct rtllib_device * ieee)1865 void rtllib_stop_all_queues(struct rtllib_device *ieee)
1866 {
1867 unsigned int i;
1868
1869 for (i = 0; i < ieee->dev->num_tx_queues; i++)
1870 txq_trans_cond_update(netdev_get_tx_queue(ieee->dev, i));
1871
1872 netif_tx_stop_all_queues(ieee->dev);
1873 }
1874
rtllib_wake_all_queues(struct rtllib_device * ieee)1875 void rtllib_wake_all_queues(struct rtllib_device *ieee)
1876 {
1877 netif_tx_wake_all_queues(ieee->dev);
1878 }
1879
1880 /* this is called only in user context, with wx_mutex held */
rtllib_start_bss(struct rtllib_device * ieee)1881 static void rtllib_start_bss(struct rtllib_device *ieee)
1882 {
1883 unsigned long flags;
1884
1885 /* check if we have already found the net we
1886 * are interested in (if any).
1887 * if not (we are disassociated and we are not
1888 * in associating / authenticating phase) start the background scanning.
1889 */
1890 rtllib_softmac_check_all_nets(ieee);
1891
1892 /* ensure no-one start an associating process (thus setting
1893 * the ieee->link_state to rtllib_ASSOCIATING) while we
1894 * have just checked it and we are going to enable scan.
1895 * The rtllib_new_net function is always called with
1896 * lock held (from both rtllib_softmac_check_all_nets and
1897 * the rx path), so we cannot be in the middle of such function
1898 */
1899 spin_lock_irqsave(&ieee->lock, flags);
1900
1901 if (ieee->link_state == MAC80211_NOLINK)
1902 rtllib_start_scan(ieee);
1903 spin_unlock_irqrestore(&ieee->lock, flags);
1904 }
1905
rtllib_link_change_wq(void * data)1906 static void rtllib_link_change_wq(void *data)
1907 {
1908 struct rtllib_device *ieee = container_of_dwork_rsl(data,
1909 struct rtllib_device, link_change_wq);
1910 ieee->link_change(ieee->dev);
1911 }
1912
1913 /* called only in userspace context */
rtllib_disassociate(struct rtllib_device * ieee)1914 void rtllib_disassociate(struct rtllib_device *ieee)
1915 {
1916 netif_carrier_off(ieee->dev);
1917 if (ieee->softmac_features & IEEE_SOFTMAC_TX_QUEUE)
1918 rtllib_reset_queue(ieee);
1919
1920 ieee->link_state = MAC80211_NOLINK;
1921 ieee->is_set_key = false;
1922 ieee->wap_set = 0;
1923
1924 schedule_delayed_work(&ieee->link_change_wq, 0);
1925
1926 notify_wx_assoc_event(ieee);
1927 }
1928
rtllib_associate_retry_wq(void * data)1929 static void rtllib_associate_retry_wq(void *data)
1930 {
1931 struct rtllib_device *ieee = container_of_dwork_rsl(data,
1932 struct rtllib_device, associate_retry_wq);
1933 unsigned long flags;
1934
1935 mutex_lock(&ieee->wx_mutex);
1936 if (!ieee->proto_started)
1937 goto exit;
1938
1939 if (ieee->link_state != RTLLIB_ASSOCIATING_RETRY)
1940 goto exit;
1941
1942 /* until we do not set the state to MAC80211_NOLINK
1943 * there are no possibility to have someone else trying
1944 * to start an association procedure (we get here with
1945 * ieee->link_state = RTLLIB_ASSOCIATING).
1946 * When we set the state to MAC80211_NOLINK it is possible
1947 * that the RX path run an attempt to associate, but
1948 * both rtllib_softmac_check_all_nets and the
1949 * RX path works with ieee->lock held so there are no
1950 * problems. If we are still disassociated then start a scan.
1951 * the lock here is necessary to ensure no one try to start
1952 * an association procedure when we have just checked the
1953 * state and we are going to start the scan.
1954 */
1955 ieee->beinretry = true;
1956 ieee->link_state = MAC80211_NOLINK;
1957
1958 rtllib_softmac_check_all_nets(ieee);
1959
1960 spin_lock_irqsave(&ieee->lock, flags);
1961
1962 if (ieee->link_state == MAC80211_NOLINK)
1963 rtllib_start_scan(ieee);
1964 spin_unlock_irqrestore(&ieee->lock, flags);
1965
1966 ieee->beinretry = false;
1967 exit:
1968 mutex_unlock(&ieee->wx_mutex);
1969 }
1970
rtllib_softmac_stop_protocol(struct rtllib_device * ieee)1971 void rtllib_softmac_stop_protocol(struct rtllib_device *ieee)
1972 {
1973 rtllib_stop_scan_syncro(ieee);
1974 mutex_lock(&ieee->wx_mutex);
1975 rtllib_stop_protocol(ieee);
1976 mutex_unlock(&ieee->wx_mutex);
1977 }
1978 EXPORT_SYMBOL(rtllib_softmac_stop_protocol);
1979
rtllib_stop_protocol(struct rtllib_device * ieee)1980 void rtllib_stop_protocol(struct rtllib_device *ieee)
1981 {
1982 if (!ieee->proto_started)
1983 return;
1984
1985 ieee->proto_started = 0;
1986 ieee->proto_stoppping = 1;
1987 ieee->rtllib_ips_leave(ieee->dev);
1988
1989 del_timer_sync(&ieee->associate_timer);
1990 mutex_unlock(&ieee->wx_mutex);
1991 cancel_delayed_work_sync(&ieee->associate_retry_wq);
1992 mutex_lock(&ieee->wx_mutex);
1993 cancel_delayed_work_sync(&ieee->link_change_wq);
1994 rtllib_stop_scan(ieee);
1995
1996 if (ieee->link_state <= RTLLIB_ASSOCIATING_AUTHENTICATED)
1997 ieee->link_state = MAC80211_NOLINK;
1998
1999 if (ieee->link_state == MAC80211_LINKED) {
2000 if (ieee->iw_mode == IW_MODE_INFRA)
2001 SendDisassociation(ieee, 1, WLAN_REASON_DEAUTH_LEAVING);
2002 rtllib_disassociate(ieee);
2003 }
2004
2005 RemoveAllTS(ieee);
2006 ieee->proto_stoppping = 0;
2007
2008 kfree(ieee->assocreq_ies);
2009 ieee->assocreq_ies = NULL;
2010 ieee->assocreq_ies_len = 0;
2011 kfree(ieee->assocresp_ies);
2012 ieee->assocresp_ies = NULL;
2013 ieee->assocresp_ies_len = 0;
2014 }
2015
rtllib_softmac_start_protocol(struct rtllib_device * ieee)2016 void rtllib_softmac_start_protocol(struct rtllib_device *ieee)
2017 {
2018 mutex_lock(&ieee->wx_mutex);
2019 rtllib_start_protocol(ieee);
2020 mutex_unlock(&ieee->wx_mutex);
2021 }
2022 EXPORT_SYMBOL(rtllib_softmac_start_protocol);
2023
rtllib_start_protocol(struct rtllib_device * ieee)2024 void rtllib_start_protocol(struct rtllib_device *ieee)
2025 {
2026 short ch = 0;
2027 int i = 0;
2028
2029 if (ieee->proto_started)
2030 return;
2031
2032 ieee->proto_started = 1;
2033
2034 if (ieee->current_network.channel == 0) {
2035 do {
2036 ch++;
2037 if (ch > MAX_CHANNEL_NUMBER)
2038 return; /* no channel found */
2039 } while (!ieee->active_channel_map[ch]);
2040 ieee->current_network.channel = ch;
2041 }
2042
2043 if (ieee->current_network.beacon_interval == 0)
2044 ieee->current_network.beacon_interval = 100;
2045
2046 for (i = 0; i < 17; i++) {
2047 ieee->last_rxseq_num[i] = -1;
2048 ieee->last_rxfrag_num[i] = -1;
2049 ieee->last_packet_time[i] = 0;
2050 }
2051
2052 ieee->wmm_acm = 0;
2053 /* if the user set the MAC of the ad-hoc cell and then
2054 * switch to managed mode, shall we make sure that association
2055 * attempts does not fail just because the user provide the essid
2056 * and the nic is still checking for the AP MAC ??
2057 */
2058 switch (ieee->iw_mode) {
2059 case IW_MODE_INFRA:
2060 rtllib_start_bss(ieee);
2061 break;
2062 }
2063 }
2064
rtllib_softmac_init(struct rtllib_device * ieee)2065 int rtllib_softmac_init(struct rtllib_device *ieee)
2066 {
2067 int i;
2068
2069 memset(&ieee->current_network, 0, sizeof(struct rtllib_network));
2070
2071 ieee->link_state = MAC80211_NOLINK;
2072 for (i = 0; i < 5; i++)
2073 ieee->seq_ctrl[i] = 0;
2074
2075 ieee->link_detect_info.SlotIndex = 0;
2076 ieee->link_detect_info.SlotNum = 2;
2077 ieee->link_detect_info.NumRecvBcnInPeriod = 0;
2078 ieee->link_detect_info.NumRecvDataInPeriod = 0;
2079 ieee->link_detect_info.num_tx_ok_in_period = 0;
2080 ieee->link_detect_info.num_rx_ok_in_period = 0;
2081 ieee->link_detect_info.NumRxUnicastOkInPeriod = 0;
2082 ieee->is_aggregate_frame = false;
2083 ieee->assoc_id = 0;
2084 ieee->queue_stop = 0;
2085 ieee->scanning_continue = 0;
2086 ieee->softmac_features = 0;
2087 ieee->wap_set = 0;
2088 ieee->ssid_set = 0;
2089 ieee->proto_started = 0;
2090 ieee->proto_stoppping = 0;
2091 ieee->basic_rate = RTLLIB_DEFAULT_BASIC_RATE;
2092 ieee->rate = 22;
2093 ieee->ps = RTLLIB_PS_DISABLED;
2094 ieee->sta_sleep = LPS_IS_WAKE;
2095
2096 ieee->reg_dot11ht_oper_rate_set[0] = 0xff;
2097 ieee->reg_dot11ht_oper_rate_set[1] = 0xff;
2098 ieee->reg_dot11ht_oper_rate_set[4] = 0x01;
2099
2100 ieee->reg_dot11tx_ht_oper_rate_set[0] = 0xff;
2101 ieee->reg_dot11tx_ht_oper_rate_set[1] = 0xff;
2102 ieee->reg_dot11tx_ht_oper_rate_set[4] = 0x01;
2103
2104 ieee->FirstIe_InScan = false;
2105 ieee->actscanning = false;
2106 ieee->beinretry = false;
2107 ieee->is_set_key = false;
2108 init_mgmt_queue(ieee);
2109
2110 ieee->tx_pending.txb = NULL;
2111
2112 timer_setup(&ieee->associate_timer, rtllib_associate_abort_cb, 0);
2113
2114 INIT_DELAYED_WORK(&ieee->link_change_wq, (void *)rtllib_link_change_wq);
2115 INIT_WORK(&ieee->associate_complete_wq, (void *)rtllib_associate_complete_wq);
2116 INIT_DELAYED_WORK(&ieee->associate_procedure_wq, (void *)rtllib_associate_procedure_wq);
2117 INIT_DELAYED_WORK(&ieee->softmac_scan_wq, (void *)rtllib_softmac_scan_wq);
2118 INIT_DELAYED_WORK(&ieee->associate_retry_wq, (void *)rtllib_associate_retry_wq);
2119 INIT_WORK(&ieee->wx_sync_scan_wq, (void *)rtllib_wx_sync_scan_wq);
2120
2121 mutex_init(&ieee->wx_mutex);
2122 mutex_init(&ieee->scan_mutex);
2123 mutex_init(&ieee->ips_mutex);
2124
2125 spin_lock_init(&ieee->mgmt_tx_lock);
2126 spin_lock_init(&ieee->beacon_lock);
2127
2128 INIT_WORK(&ieee->ps_task, rtllib_sta_ps);
2129
2130 return 0;
2131 }
2132
rtllib_softmac_free(struct rtllib_device * ieee)2133 void rtllib_softmac_free(struct rtllib_device *ieee)
2134 {
2135 del_timer_sync(&ieee->associate_timer);
2136
2137 cancel_delayed_work_sync(&ieee->associate_retry_wq);
2138 cancel_delayed_work_sync(&ieee->associate_procedure_wq);
2139 cancel_delayed_work_sync(&ieee->softmac_scan_wq);
2140 cancel_delayed_work_sync(&ieee->hw_wakeup_wq);
2141 cancel_delayed_work_sync(&ieee->hw_sleep_wq);
2142 cancel_delayed_work_sync(&ieee->link_change_wq);
2143 cancel_work_sync(&ieee->associate_complete_wq);
2144 cancel_work_sync(&ieee->ips_leave_wq);
2145 cancel_work_sync(&ieee->wx_sync_scan_wq);
2146 cancel_work_sync(&ieee->ps_task);
2147 }
2148
2149 static inline struct sk_buff *
rtllib_disauth_skb(struct rtllib_network * beacon,struct rtllib_device * ieee,u16 asRsn)2150 rtllib_disauth_skb(struct rtllib_network *beacon,
2151 struct rtllib_device *ieee, u16 asRsn)
2152 {
2153 struct sk_buff *skb;
2154 struct rtllib_disauth *disauth;
2155 int len = sizeof(struct rtllib_disauth) + ieee->tx_headroom;
2156
2157 skb = dev_alloc_skb(len);
2158 if (!skb)
2159 return NULL;
2160
2161 skb_reserve(skb, ieee->tx_headroom);
2162
2163 disauth = skb_put(skb, sizeof(struct rtllib_disauth));
2164 disauth->header.frame_control = cpu_to_le16(IEEE80211_STYPE_DEAUTH);
2165 disauth->header.duration_id = 0;
2166
2167 ether_addr_copy(disauth->header.addr1, beacon->bssid);
2168 ether_addr_copy(disauth->header.addr2, ieee->dev->dev_addr);
2169 ether_addr_copy(disauth->header.addr3, beacon->bssid);
2170
2171 disauth->reason = cpu_to_le16(asRsn);
2172 return skb;
2173 }
2174
2175 static inline struct sk_buff *
rtllib_disassociate_skb(struct rtllib_network * beacon,struct rtllib_device * ieee,u16 asRsn)2176 rtllib_disassociate_skb(struct rtllib_network *beacon,
2177 struct rtllib_device *ieee, u16 asRsn)
2178 {
2179 struct sk_buff *skb;
2180 struct rtllib_disassoc *disass;
2181 int len = sizeof(struct rtllib_disassoc) + ieee->tx_headroom;
2182
2183 skb = dev_alloc_skb(len);
2184
2185 if (!skb)
2186 return NULL;
2187
2188 skb_reserve(skb, ieee->tx_headroom);
2189
2190 disass = skb_put(skb, sizeof(struct rtllib_disassoc));
2191 disass->header.frame_control = cpu_to_le16(IEEE80211_STYPE_DISASSOC);
2192 disass->header.duration_id = 0;
2193
2194 ether_addr_copy(disass->header.addr1, beacon->bssid);
2195 ether_addr_copy(disass->header.addr2, ieee->dev->dev_addr);
2196 ether_addr_copy(disass->header.addr3, beacon->bssid);
2197
2198 disass->reason = cpu_to_le16(asRsn);
2199 return skb;
2200 }
2201
SendDisassociation(struct rtllib_device * ieee,bool deauth,u16 asRsn)2202 void SendDisassociation(struct rtllib_device *ieee, bool deauth, u16 asRsn)
2203 {
2204 struct rtllib_network *beacon = &ieee->current_network;
2205 struct sk_buff *skb;
2206
2207 if (deauth)
2208 skb = rtllib_disauth_skb(beacon, ieee, asRsn);
2209 else
2210 skb = rtllib_disassociate_skb(beacon, ieee, asRsn);
2211
2212 if (skb)
2213 softmac_mgmt_xmit(skb, ieee);
2214 }
2215
rtllib_ap_sec_type(struct rtllib_device * ieee)2216 u8 rtllib_ap_sec_type(struct rtllib_device *ieee)
2217 {
2218 static u8 ccmp_ie[4] = {0x00, 0x50, 0xf2, 0x04};
2219 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2220 int wpa_ie_len = ieee->wpa_ie_len;
2221 struct lib80211_crypt_data *crypt;
2222 int encrypt;
2223
2224 crypt = ieee->crypt_info.crypt[ieee->crypt_info.tx_keyidx];
2225 encrypt = (ieee->current_network.capability & WLAN_CAPABILITY_PRIVACY)
2226 || (crypt && crypt->ops && (strcmp(crypt->ops->name, "R-WEP") == 0));
2227
2228 /* simply judge */
2229 if (encrypt && (wpa_ie_len == 0)) {
2230 return SEC_ALG_WEP;
2231 } else if ((wpa_ie_len != 0)) {
2232 if (((ieee->wpa_ie[0] == 0xdd) &&
2233 (!memcmp(&ieee->wpa_ie[14], ccmp_ie, 4))) ||
2234 ((ieee->wpa_ie[0] == 0x30) &&
2235 (!memcmp(&ieee->wpa_ie[10], ccmp_rsn_ie, 4))))
2236 return SEC_ALG_CCMP;
2237 else
2238 return SEC_ALG_TKIP;
2239 } else {
2240 return SEC_ALG_NONE;
2241 }
2242 }
2243
rtllib_MlmeDisassociateRequest(struct rtllib_device * rtllib,u8 * asSta,u8 asRsn)2244 static void rtllib_MlmeDisassociateRequest(struct rtllib_device *rtllib,
2245 u8 *asSta, u8 asRsn)
2246 {
2247 u8 i;
2248 u8 op_mode;
2249
2250 RemovePeerTS(rtllib, asSta);
2251
2252 if (memcmp(rtllib->current_network.bssid, asSta, 6) == 0) {
2253 rtllib->link_state = MAC80211_NOLINK;
2254
2255 for (i = 0; i < 6; i++)
2256 rtllib->current_network.bssid[i] = 0x22;
2257 op_mode = RT_OP_MODE_NO_LINK;
2258 rtllib->op_mode = RT_OP_MODE_NO_LINK;
2259 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_MEDIA_STATUS,
2260 (u8 *)(&op_mode));
2261 rtllib_disassociate(rtllib);
2262
2263 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_BSSID,
2264 rtllib->current_network.bssid);
2265 }
2266 }
2267
rtllib_MgntDisconnectAP(struct rtllib_device * rtllib,u8 asRsn)2268 static void rtllib_MgntDisconnectAP(struct rtllib_device *rtllib, u8 asRsn)
2269 {
2270 bool bFilterOutNonAssociatedBSSID = false;
2271
2272 bFilterOutNonAssociatedBSSID = false;
2273 rtllib->SetHwRegHandler(rtllib->dev, HW_VAR_CECHK_BSSID,
2274 (u8 *)(&bFilterOutNonAssociatedBSSID));
2275 rtllib_MlmeDisassociateRequest(rtllib, rtllib->current_network.bssid,
2276 asRsn);
2277
2278 rtllib->link_state = MAC80211_NOLINK;
2279 }
2280
rtllib_MgntDisconnect(struct rtllib_device * rtllib,u8 asRsn)2281 bool rtllib_MgntDisconnect(struct rtllib_device *rtllib, u8 asRsn)
2282 {
2283 if (rtllib->ps != RTLLIB_PS_DISABLED)
2284 rtllib->sta_wake_up(rtllib->dev);
2285
2286 if (rtllib->link_state == MAC80211_LINKED) {
2287 if (rtllib->iw_mode == IW_MODE_INFRA)
2288 rtllib_MgntDisconnectAP(rtllib, asRsn);
2289 }
2290
2291 return true;
2292 }
2293 EXPORT_SYMBOL(rtllib_MgntDisconnect);
2294
notify_wx_assoc_event(struct rtllib_device * ieee)2295 void notify_wx_assoc_event(struct rtllib_device *ieee)
2296 {
2297 union iwreq_data wrqu;
2298
2299 if (ieee->cannot_notify)
2300 return;
2301
2302 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
2303 if (ieee->link_state == MAC80211_LINKED) {
2304 memcpy(wrqu.ap_addr.sa_data, ieee->current_network.bssid,
2305 ETH_ALEN);
2306 } else {
2307 netdev_info(ieee->dev, "%s(): Tell user space disconnected\n",
2308 __func__);
2309 eth_zero_addr(wrqu.ap_addr.sa_data);
2310 }
2311 wireless_send_event(ieee->dev, SIOCGIWAP, &wrqu, NULL);
2312 }
2313 EXPORT_SYMBOL(notify_wx_assoc_event);
2314