1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#define _IOCTL_CFG80211_C_
16
17#include <drv_types.h>
18#include <rtw_debug.h>
19#include <linux/jiffies.h>
20
21#include <rtw_wifi_regd.h>
22
23#define RTW_MAX_MGMT_TX_CNT (8)
24
25#define RTW_SCAN_IE_LEN_MAX 2304
26#define RTW_MAX_REMAIN_ON_CHANNEL_DURATION 5000
27#define RTW_MAX_NUM_PMKIDS 4
28
29#define RTW_CH_MAX_2G_CHANNEL 14
30
31static const u32 rtw_cipher_suites[] = {
32 WLAN_CIPHER_SUITE_WEP40,
33 WLAN_CIPHER_SUITE_WEP104,
34 WLAN_CIPHER_SUITE_TKIP,
35 WLAN_CIPHER_SUITE_CCMP,
36 WLAN_CIPHER_SUITE_AES_CMAC,
37};
38
39#define RATETAB_ENT(_rate, _rateid, _flags) \
40 { \
41 .bitrate = (_rate), \
42 .hw_value = (_rateid), \
43 .flags = (_flags), \
44 }
45
46#define CHAN2G(_channel, _freq, _flags) { \
47 .band = NL80211_BAND_2GHZ, \
48 .center_freq = (_freq), \
49 .hw_value = (_channel), \
50 .flags = (_flags), \
51 .max_antenna_gain = 0, \
52 .max_power = 30, \
53}
54
55
56
57
58
59
60static const struct wiphy_wowlan_support wowlan_stub = {
61 .flags = WIPHY_WOWLAN_ANY,
62 .n_patterns = 0,
63 .pattern_max_len = 0,
64 .pattern_min_len = 0,
65 .max_pkt_offset = 0,
66};
67
68static struct ieee80211_rate rtw_rates[] = {
69 RATETAB_ENT(10, 0x1, 0),
70 RATETAB_ENT(20, 0x2, 0),
71 RATETAB_ENT(55, 0x4, 0),
72 RATETAB_ENT(110, 0x8, 0),
73 RATETAB_ENT(60, 0x10, 0),
74 RATETAB_ENT(90, 0x20, 0),
75 RATETAB_ENT(120, 0x40, 0),
76 RATETAB_ENT(180, 0x80, 0),
77 RATETAB_ENT(240, 0x100, 0),
78 RATETAB_ENT(360, 0x200, 0),
79 RATETAB_ENT(480, 0x400, 0),
80 RATETAB_ENT(540, 0x800, 0),
81};
82
83#define rtw_a_rates (rtw_rates + 4)
84#define RTW_A_RATES_NUM 8
85#define rtw_g_rates (rtw_rates + 0)
86#define RTW_G_RATES_NUM 12
87
88#define RTW_2G_CHANNELS_NUM 14
89#define RTW_5G_CHANNELS_NUM 37
90
91static struct ieee80211_channel rtw_2ghz_channels[] = {
92 CHAN2G(1, 2412, 0),
93 CHAN2G(2, 2417, 0),
94 CHAN2G(3, 2422, 0),
95 CHAN2G(4, 2427, 0),
96 CHAN2G(5, 2432, 0),
97 CHAN2G(6, 2437, 0),
98 CHAN2G(7, 2442, 0),
99 CHAN2G(8, 2447, 0),
100 CHAN2G(9, 2452, 0),
101 CHAN2G(10, 2457, 0),
102 CHAN2G(11, 2462, 0),
103 CHAN2G(12, 2467, 0),
104 CHAN2G(13, 2472, 0),
105 CHAN2G(14, 2484, 0),
106};
107
108static void rtw_2g_channels_init(struct ieee80211_channel *channels)
109{
110 memcpy((void*)channels, (void*)rtw_2ghz_channels,
111 sizeof(struct ieee80211_channel)*RTW_2G_CHANNELS_NUM
112 );
113}
114
115static void rtw_2g_rates_init(struct ieee80211_rate *rates)
116{
117 memcpy(rates, rtw_g_rates,
118 sizeof(struct ieee80211_rate)*RTW_G_RATES_NUM
119 );
120}
121
122static struct ieee80211_supported_band *rtw_spt_band_alloc(
123 enum nl80211_band band
124 )
125{
126 struct ieee80211_supported_band *spt_band = NULL;
127 int n_channels, n_bitrates;
128
129 if (band == NL80211_BAND_2GHZ)
130 {
131 n_channels = RTW_2G_CHANNELS_NUM;
132 n_bitrates = RTW_G_RATES_NUM;
133 }
134 else
135 {
136 goto exit;
137 }
138
139 spt_band = rtw_zmalloc(sizeof(struct ieee80211_supported_band) +
140 sizeof(struct ieee80211_channel) * n_channels +
141 sizeof(struct ieee80211_rate) * n_bitrates);
142 if (!spt_band)
143 goto exit;
144
145 spt_band->channels = (struct ieee80211_channel*)(((u8 *)spt_band)+sizeof(struct ieee80211_supported_band));
146 spt_band->bitrates = (struct ieee80211_rate*)(((u8 *)spt_band->channels)+sizeof(struct ieee80211_channel)*n_channels);
147 spt_band->band = band;
148 spt_band->n_channels = n_channels;
149 spt_band->n_bitrates = n_bitrates;
150
151 if (band == NL80211_BAND_2GHZ)
152 {
153 rtw_2g_channels_init(spt_band->channels);
154 rtw_2g_rates_init(spt_band->bitrates);
155 }
156
157
158
159exit:
160
161 return spt_band;
162}
163
164static void rtw_spt_band_free(struct ieee80211_supported_band *spt_band)
165{
166 u32 size = 0;
167
168 if (!spt_band)
169 return;
170
171 if (spt_band->band == NL80211_BAND_2GHZ)
172 {
173 size = sizeof(struct ieee80211_supported_band)
174 + sizeof(struct ieee80211_channel)*RTW_2G_CHANNELS_NUM
175 + sizeof(struct ieee80211_rate)*RTW_G_RATES_NUM;
176 }
177 kfree((u8 *)spt_band);
178}
179
180static const struct ieee80211_txrx_stypes
181rtw_cfg80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = {
182 [NL80211_IFTYPE_ADHOC] = {
183 .tx = 0xffff,
184 .rx = BIT(IEEE80211_STYPE_ACTION >> 4)
185 },
186 [NL80211_IFTYPE_STATION] = {
187 .tx = 0xffff,
188 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
189 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
190 },
191 [NL80211_IFTYPE_AP] = {
192 .tx = 0xffff,
193 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
194 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
195 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
196 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
197 BIT(IEEE80211_STYPE_AUTH >> 4) |
198 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
199 BIT(IEEE80211_STYPE_ACTION >> 4)
200 },
201 [NL80211_IFTYPE_AP_VLAN] = {
202
203 .tx = 0xffff,
204 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
205 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
206 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
207 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
208 BIT(IEEE80211_STYPE_AUTH >> 4) |
209 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
210 BIT(IEEE80211_STYPE_ACTION >> 4)
211 },
212 [NL80211_IFTYPE_P2P_CLIENT] = {
213 .tx = 0xffff,
214 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
215 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
216 },
217 [NL80211_IFTYPE_P2P_GO] = {
218 .tx = 0xffff,
219 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
220 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
221 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
222 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
223 BIT(IEEE80211_STYPE_AUTH >> 4) |
224 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
225 BIT(IEEE80211_STYPE_ACTION >> 4)
226 },
227};
228
229static int rtw_ieee80211_channel_to_frequency(int chan, int band)
230{
231
232
233 if (band == NL80211_BAND_2GHZ) {
234 if (chan == 14)
235 return 2484;
236 else if (chan < 14)
237 return 2407 + chan * 5;
238 }
239
240 return 0;
241}
242
243static u64 rtw_get_systime_us(void)
244{
245 struct timespec ts;
246 get_monotonic_boottime(&ts);
247 return ((u64)ts.tv_sec*1000000) + ts.tv_nsec / 1000;
248}
249
250#define MAX_BSSINFO_LEN 1000
251struct cfg80211_bss *rtw_cfg80211_inform_bss(struct adapter *padapter, struct wlan_network *pnetwork)
252{
253 struct ieee80211_channel *notify_channel;
254 struct cfg80211_bss *bss = NULL;
255
256 u16 channel;
257 u32 freq;
258 u64 notify_timestamp;
259 u16 notify_capability;
260 u16 notify_interval;
261 u8 *notify_ie;
262 size_t notify_ielen;
263 s32 notify_signal;
264 u8 *buf = NULL, *pbuf;
265 size_t len, bssinf_len = 0;
266 struct ieee80211_hdr *pwlanhdr;
267 __le16 *fctrl;
268 u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
269
270 struct wireless_dev *wdev = padapter->rtw_wdev;
271 struct wiphy *wiphy = wdev->wiphy;
272 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
273
274
275
276
277 bssinf_len = pnetwork->network.IELength+sizeof (struct ieee80211_hdr_3addr);
278 if (bssinf_len > MAX_BSSINFO_LEN) {
279 DBG_871X("%s IE Length too long > %d byte\n", __func__, MAX_BSSINFO_LEN);
280 goto exit;
281 }
282
283 {
284 u16 wapi_len = 0;
285
286 if (rtw_get_wapi_ie(pnetwork->network.IEs, pnetwork->network.IELength, NULL, &wapi_len)>0)
287 {
288 if (wapi_len > 0)
289 {
290 DBG_871X("%s, no support wapi!\n", __func__);
291 goto exit;
292 }
293 }
294 }
295
296
297
298 if (adapter_wdev_data(padapter)->scan_request != NULL)
299 {
300 u8 *psr = NULL, sr = 0;
301 struct ndis_802_11_ssid *pssid = &pnetwork->network.Ssid;
302 struct cfg80211_scan_request *request = adapter_wdev_data(padapter)->scan_request;
303 struct cfg80211_ssid *ssids = request->ssids;
304 u32 wpsielen = 0;
305 u8 *wpsie = NULL;
306
307 wpsie = rtw_get_wps_ie(pnetwork->network.IEs+_FIXED_IE_LENGTH_, pnetwork->network.IELength-_FIXED_IE_LENGTH_, NULL, &wpsielen);
308
309 if (wpsie && wpsielen>0)
310 psr = rtw_get_wps_attr_content(wpsie, wpsielen, WPS_ATTR_SELECTED_REGISTRAR, (u8 *)(&sr), NULL);
311
312 if (sr != 0)
313 {
314 if (request->n_ssids == 1 && request->n_channels == 1)
315 {
316 DBG_8192C("ssid =%s, len =%d\n", pssid->Ssid, pssid->SsidLength);
317
318 if (ssids[0].ssid_len == 0) {
319 }
320 else if (pssid->SsidLength == ssids[0].ssid_len &&
321 !memcmp(pssid->Ssid, ssids[0].ssid, ssids[0].ssid_len))
322 {
323 DBG_871X("%s, got sr and ssid match!\n", __func__);
324 }
325 else
326 {
327 if (psr != NULL)
328 *psr = 0;
329 }
330 }
331 }
332 }
333
334
335
336 channel = pnetwork->network.Configuration.DSConfig;
337 freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
338
339 notify_channel = ieee80211_get_channel(wiphy, freq);
340
341 notify_timestamp = rtw_get_systime_us();
342
343 notify_interval = le16_to_cpu(*(__le16 *)rtw_get_beacon_interval_from_ie(pnetwork->network.IEs));
344 notify_capability = le16_to_cpu(*(__le16 *)rtw_get_capability_from_ie(pnetwork->network.IEs));
345
346 notify_ie = pnetwork->network.IEs+_FIXED_IE_LENGTH_;
347 notify_ielen = pnetwork->network.IELength-_FIXED_IE_LENGTH_;
348
349
350 if (check_fwstate(pmlmepriv, _FW_LINKED) == true &&
351 is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) {
352 notify_signal = 100*translate_percentage_to_dbm(padapter->recvpriv.signal_strength);
353 } else {
354 notify_signal = 100*translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength);
355 }
356
357 buf = kzalloc(MAX_BSSINFO_LEN, GFP_ATOMIC);
358 if (!buf)
359 goto exit;
360 pbuf = buf;
361
362 pwlanhdr = (struct ieee80211_hdr *)pbuf;
363 fctrl = &(pwlanhdr->frame_control);
364 *(fctrl) = 0;
365
366 SetSeqNum(pwlanhdr, 0);
367
368
369 if (pnetwork->network.Reserved[0] == 1) {
370 memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
371 SetFrameSubType(pbuf, WIFI_BEACON);
372 } else {
373 memcpy(pwlanhdr->addr1, myid(&(padapter->eeprompriv)), ETH_ALEN);
374 SetFrameSubType(pbuf, WIFI_PROBERSP);
375 }
376
377 memcpy(pwlanhdr->addr2, pnetwork->network.MacAddress, ETH_ALEN);
378 memcpy(pwlanhdr->addr3, pnetwork->network.MacAddress, ETH_ALEN);
379
380
381 pbuf += sizeof(struct ieee80211_hdr_3addr);
382 len = sizeof (struct ieee80211_hdr_3addr);
383
384 memcpy(pbuf, pnetwork->network.IEs, pnetwork->network.IELength);
385 len += pnetwork->network.IELength;
386
387 *((__le64*)pbuf) = cpu_to_le64(notify_timestamp);
388
389 bss = cfg80211_inform_bss_frame(wiphy, notify_channel, (struct ieee80211_mgmt *)buf,
390 len, notify_signal, GFP_ATOMIC);
391
392 if (unlikely(!bss)) {
393 DBG_8192C(FUNC_ADPT_FMT" bss NULL\n", FUNC_ADPT_ARG(padapter));
394 goto exit;
395 }
396
397 cfg80211_put_bss(wiphy, bss);
398 kfree(buf);
399
400exit:
401 return bss;
402
403}
404
405
406
407
408
409
410
411int rtw_cfg80211_check_bss(struct adapter *padapter)
412{
413 struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network);
414 struct cfg80211_bss *bss = NULL;
415 struct ieee80211_channel *notify_channel = NULL;
416 u32 freq;
417
418 if (!(pnetwork) || !(padapter->rtw_wdev))
419 return false;
420
421 freq = rtw_ieee80211_channel_to_frequency(pnetwork->Configuration.DSConfig, NL80211_BAND_2GHZ);
422
423 notify_channel = ieee80211_get_channel(padapter->rtw_wdev->wiphy, freq);
424 bss = cfg80211_get_bss(padapter->rtw_wdev->wiphy, notify_channel,
425 pnetwork->MacAddress, pnetwork->Ssid.Ssid,
426 pnetwork->Ssid.SsidLength,
427 WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
428
429 cfg80211_put_bss(padapter->rtw_wdev->wiphy, bss);
430
431 return (bss!= NULL);
432}
433
434void rtw_cfg80211_ibss_indicate_connect(struct adapter *padapter)
435{
436 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
437 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
438 struct wireless_dev *pwdev = padapter->rtw_wdev;
439 struct wiphy *wiphy = pwdev->wiphy;
440 int freq = (int)cur_network->network.Configuration.DSConfig;
441 struct ieee80211_channel *chan;
442
443 DBG_871X(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
444 if (pwdev->iftype != NL80211_IFTYPE_ADHOC)
445 {
446 return;
447 }
448
449 if (!rtw_cfg80211_check_bss(padapter)) {
450 struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network);
451 struct wlan_network *scanned = pmlmepriv->cur_network_scanned;
452
453 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ==true)
454 {
455
456 memcpy(&cur_network->network, pnetwork, sizeof(struct wlan_bssid_ex));
457 if (!rtw_cfg80211_inform_bss(padapter, cur_network))
458 DBG_871X(FUNC_ADPT_FMT" inform fail !!\n", FUNC_ADPT_ARG(padapter));
459 else
460 DBG_871X(FUNC_ADPT_FMT" inform success !!\n", FUNC_ADPT_ARG(padapter));
461 }
462 else
463 {
464 if (scanned == NULL) {
465 rtw_warn_on(1);
466 return;
467 }
468 if (!memcmp(&(scanned->network.Ssid), &(pnetwork->Ssid), sizeof(struct ndis_802_11_ssid))
469 && !memcmp(scanned->network.MacAddress, pnetwork->MacAddress, sizeof(NDIS_802_11_MAC_ADDRESS))
470 ) {
471 if (!rtw_cfg80211_inform_bss(padapter, scanned)) {
472 DBG_871X(FUNC_ADPT_FMT" inform fail !!\n", FUNC_ADPT_ARG(padapter));
473 } else {
474
475 }
476 } else {
477 DBG_871X("scanned & pnetwork compare fail\n");
478 rtw_warn_on(1);
479 }
480 }
481
482 if (!rtw_cfg80211_check_bss(padapter))
483 DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" BSS not found !!\n", FUNC_ADPT_ARG(padapter));
484 }
485
486 chan = ieee80211_get_channel(wiphy, freq);
487 cfg80211_ibss_joined(padapter->pnetdev, cur_network->network.MacAddress, chan, GFP_ATOMIC);
488}
489
490void rtw_cfg80211_indicate_connect(struct adapter *padapter)
491{
492 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
493 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
494 struct wireless_dev *pwdev = padapter->rtw_wdev;
495
496 DBG_871X(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
497 if (pwdev->iftype != NL80211_IFTYPE_STATION
498 && pwdev->iftype != NL80211_IFTYPE_P2P_CLIENT
499 ) {
500 return;
501 }
502
503 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
504 return;
505
506 {
507 struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network);
508 struct wlan_network *scanned = pmlmepriv->cur_network_scanned;
509
510
511
512 if (scanned == NULL) {
513 rtw_warn_on(1);
514 goto check_bss;
515 }
516
517 if (!memcmp(scanned->network.MacAddress, pnetwork->MacAddress, sizeof(NDIS_802_11_MAC_ADDRESS))
518 && !memcmp(&(scanned->network.Ssid), &(pnetwork->Ssid), sizeof(struct ndis_802_11_ssid))
519 ) {
520 if (!rtw_cfg80211_inform_bss(padapter, scanned)) {
521 DBG_871X(FUNC_ADPT_FMT" inform fail !!\n", FUNC_ADPT_ARG(padapter));
522 } else {
523
524 }
525 } else {
526 DBG_871X("scanned: %s("MAC_FMT"), cur: %s("MAC_FMT")\n",
527 scanned->network.Ssid.Ssid, MAC_ARG(scanned->network.MacAddress),
528 pnetwork->Ssid.Ssid, MAC_ARG(pnetwork->MacAddress)
529 );
530 rtw_warn_on(1);
531 }
532 }
533
534check_bss:
535 if (!rtw_cfg80211_check_bss(padapter))
536 DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" BSS not found !!\n", FUNC_ADPT_ARG(padapter));
537
538 if (rtw_to_roam(padapter) > 0) {
539 struct wiphy *wiphy = pwdev->wiphy;
540 struct ieee80211_channel *notify_channel;
541 u32 freq;
542 u16 channel = cur_network->network.Configuration.DSConfig;
543 struct cfg80211_roam_info roam_info = {};
544
545 freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
546
547 notify_channel = ieee80211_get_channel(wiphy, freq);
548
549 DBG_871X(FUNC_ADPT_FMT" call cfg80211_roamed\n", FUNC_ADPT_ARG(padapter));
550 roam_info.channel = notify_channel;
551 roam_info.bssid = cur_network->network.MacAddress;
552 roam_info.req_ie =
553 pmlmepriv->assoc_req+sizeof(struct ieee80211_hdr_3addr)+2;
554 roam_info.req_ie_len =
555 pmlmepriv->assoc_req_len-sizeof(struct ieee80211_hdr_3addr)-2;
556 roam_info.resp_ie =
557 pmlmepriv->assoc_rsp+sizeof(struct ieee80211_hdr_3addr)+6;
558 roam_info.resp_ie_len =
559 pmlmepriv->assoc_rsp_len-sizeof(struct ieee80211_hdr_3addr)-6;
560 cfg80211_roamed(padapter->pnetdev, &roam_info, GFP_ATOMIC);
561 }
562 else
563 {
564 cfg80211_connect_result(padapter->pnetdev, cur_network->network.MacAddress
565 , pmlmepriv->assoc_req+sizeof(struct ieee80211_hdr_3addr)+2
566 , pmlmepriv->assoc_req_len-sizeof(struct ieee80211_hdr_3addr)-2
567 , pmlmepriv->assoc_rsp+sizeof(struct ieee80211_hdr_3addr)+6
568 , pmlmepriv->assoc_rsp_len-sizeof(struct ieee80211_hdr_3addr)-6
569 , WLAN_STATUS_SUCCESS, GFP_ATOMIC);
570 }
571}
572
573void rtw_cfg80211_indicate_disconnect(struct adapter *padapter)
574{
575 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
576 struct wireless_dev *pwdev = padapter->rtw_wdev;
577
578 DBG_871X(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
579
580 if (pwdev->iftype != NL80211_IFTYPE_STATION
581 && pwdev->iftype != NL80211_IFTYPE_P2P_CLIENT
582 ) {
583 return;
584 }
585
586 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
587 return;
588
589 if (!padapter->mlmepriv.not_indic_disco) {
590 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
591 cfg80211_disconnected(padapter->pnetdev, 0,
592 NULL, 0, true, GFP_ATOMIC);
593 } else {
594 cfg80211_connect_result(padapter->pnetdev, NULL, NULL, 0, NULL, 0,
595 WLAN_STATUS_UNSPECIFIED_FAILURE, GFP_ATOMIC);
596 }
597 }
598}
599
600
601static int rtw_cfg80211_ap_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
602{
603 int ret = 0;
604 u32 wep_key_idx, wep_key_len;
605 struct sta_info *psta = NULL, *pbcmc_sta = NULL;
606 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
607 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
608 struct security_priv* psecuritypriv =&(padapter->securitypriv);
609 struct sta_priv *pstapriv = &padapter->stapriv;
610
611 DBG_8192C("%s\n", __func__);
612
613 param->u.crypt.err = 0;
614 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
615
616 if (param_len != sizeof(struct ieee_param) + param->u.crypt.key_len)
617 {
618 ret = -EINVAL;
619 goto exit;
620 }
621
622 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
623 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
624 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
625 {
626 if (param->u.crypt.idx >= WEP_KEYS)
627 {
628 ret = -EINVAL;
629 goto exit;
630 }
631 }
632 else
633 {
634 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
635 if (!psta)
636 {
637
638 DBG_8192C("rtw_set_encryption(), sta has already been removed or never been added\n");
639 goto exit;
640 }
641 }
642
643 if (strcmp(param->u.crypt.alg, "none") == 0 && (psta == NULL))
644 {
645
646
647 DBG_8192C("clear default encryption keys, keyid =%d\n", param->u.crypt.idx);
648
649 goto exit;
650 }
651
652
653 if (strcmp(param->u.crypt.alg, "WEP") == 0 && (psta == NULL))
654 {
655 DBG_8192C("r871x_set_encryption, crypt.alg = WEP\n");
656
657 wep_key_idx = param->u.crypt.idx;
658 wep_key_len = param->u.crypt.key_len;
659
660 DBG_8192C("r871x_set_encryption, wep_key_idx =%d, len =%d\n", wep_key_idx, wep_key_len);
661
662 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len<= 0))
663 {
664 ret = -EINVAL;
665 goto exit;
666 }
667
668 if (wep_key_len > 0)
669 {
670 wep_key_len = wep_key_len <= 5 ? 5 : 13;
671 }
672
673 if (psecuritypriv->bWepDefaultKeyIdxSet == 0)
674 {
675
676
677 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
678 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
679 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
680 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
681
682 if (wep_key_len == 13)
683 {
684 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
685 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
686 }
687
688 psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
689 }
690
691 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), param->u.crypt.key, wep_key_len);
692
693 psecuritypriv->dot11DefKeylen[wep_key_idx] = wep_key_len;
694
695 rtw_ap_set_wep_key(padapter, param->u.crypt.key, wep_key_len, wep_key_idx, 1);
696
697 goto exit;
698
699 }
700
701
702 if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE))
703 {
704 if (param->u.crypt.set_tx == 0)
705 {
706 if (strcmp(param->u.crypt.alg, "WEP") == 0)
707 {
708 DBG_8192C("%s, set group_key, WEP\n", __func__);
709
710 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
711
712 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
713 if (param->u.crypt.key_len == 13)
714 {
715 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
716 }
717
718 }
719 else if (strcmp(param->u.crypt.alg, "TKIP") == 0)
720 {
721 DBG_8192C("%s, set group_key, TKIP\n", __func__);
722
723 psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
724
725 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
726
727
728
729 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
730 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
731
732 psecuritypriv->busetkipkey = true;
733
734 }
735 else if (strcmp(param->u.crypt.alg, "CCMP") == 0)
736 {
737 DBG_8192C("%s, set group_key, CCMP\n", __func__);
738
739 psecuritypriv->dot118021XGrpPrivacy = _AES_;
740
741 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
742 }
743 else
744 {
745 DBG_8192C("%s, set group_key, none\n", __func__);
746
747 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
748 }
749
750 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
751
752 psecuritypriv->binstallGrpkey = true;
753
754 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;
755
756 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
757
758 pbcmc_sta =rtw_get_bcmc_stainfo(padapter);
759 if (pbcmc_sta)
760 {
761 pbcmc_sta->ieee8021x_blocked = false;
762 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;
763 }
764
765 }
766
767 goto exit;
768
769 }
770
771 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta)
772 {
773 if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
774 {
775 if (param->u.crypt.set_tx == 1)
776 {
777 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
778
779 if (strcmp(param->u.crypt.alg, "WEP") == 0)
780 {
781 DBG_8192C("%s, set pairwise key, WEP\n", __func__);
782
783 psta->dot118021XPrivacy = _WEP40_;
784 if (param->u.crypt.key_len == 13)
785 {
786 psta->dot118021XPrivacy = _WEP104_;
787 }
788 }
789 else if (strcmp(param->u.crypt.alg, "TKIP") == 0)
790 {
791 DBG_8192C("%s, set pairwise key, TKIP\n", __func__);
792
793 psta->dot118021XPrivacy = _TKIP_;
794
795
796
797 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
798 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
799
800 psecuritypriv->busetkipkey = true;
801
802 }
803 else if (strcmp(param->u.crypt.alg, "CCMP") == 0)
804 {
805
806 DBG_8192C("%s, set pairwise key, CCMP\n", __func__);
807
808 psta->dot118021XPrivacy = _AES_;
809 }
810 else
811 {
812 DBG_8192C("%s, set pairwise key, none\n", __func__);
813
814 psta->dot118021XPrivacy = _NO_PRIVACY_;
815 }
816
817 rtw_ap_set_pairwise_key(padapter, psta);
818
819 psta->ieee8021x_blocked = false;
820
821 psta->bpairwise_key_installed = true;
822
823 }
824 else
825 {
826 if (strcmp(param->u.crypt.alg, "WEP") == 0)
827 {
828 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
829
830 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
831 if (param->u.crypt.key_len == 13)
832 {
833 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
834 }
835 }
836 else if (strcmp(param->u.crypt.alg, "TKIP") == 0)
837 {
838 psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
839
840 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
841
842
843
844 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
845 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
846
847 psecuritypriv->busetkipkey = true;
848
849 }
850 else if (strcmp(param->u.crypt.alg, "CCMP") == 0)
851 {
852 psecuritypriv->dot118021XGrpPrivacy = _AES_;
853
854 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
855 }
856 else
857 {
858 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
859 }
860
861 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
862
863 psecuritypriv->binstallGrpkey = true;
864
865 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;
866
867 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
868
869 pbcmc_sta =rtw_get_bcmc_stainfo(padapter);
870 if (pbcmc_sta)
871 {
872 pbcmc_sta->ieee8021x_blocked = false;
873 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;
874 }
875
876 }
877
878 }
879
880 }
881
882exit:
883
884 return ret;
885
886}
887
888static int rtw_cfg80211_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
889{
890 int ret = 0;
891 u32 wep_key_idx, wep_key_len;
892 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
893 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
894 struct security_priv *psecuritypriv = &padapter->securitypriv;
895
896 DBG_8192C("%s\n", __func__);
897
898 param->u.crypt.err = 0;
899 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
900
901 if (param_len < (u32) ((u8 *) param->u.crypt.key - (u8 *) param) + param->u.crypt.key_len)
902 {
903 ret = -EINVAL;
904 goto exit;
905 }
906
907 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
908 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
909 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff)
910 {
911 if (param->u.crypt.idx >= WEP_KEYS
912 || param->u.crypt.idx >= BIP_MAX_KEYID
913 )
914 {
915 ret = -EINVAL;
916 goto exit;
917 }
918 } else {
919 {
920 ret = -EINVAL;
921 goto exit;
922 }
923 }
924
925 if (strcmp(param->u.crypt.alg, "WEP") == 0)
926 {
927 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("wpa_set_encryption, crypt.alg = WEP\n"));
928 DBG_8192C("wpa_set_encryption, crypt.alg = WEP\n");
929
930 wep_key_idx = param->u.crypt.idx;
931 wep_key_len = param->u.crypt.key_len;
932
933 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0))
934 {
935 ret = -EINVAL;
936 goto exit;
937 }
938
939 if (psecuritypriv->bWepDefaultKeyIdxSet == 0)
940 {
941
942
943 wep_key_len = wep_key_len <= 5 ? 5 : 13;
944
945 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
946 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
947 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
948
949 if (wep_key_len == 13)
950 {
951 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
952 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
953 }
954
955 psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
956 }
957
958 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), param->u.crypt.key, wep_key_len);
959
960 psecuritypriv->dot11DefKeylen[wep_key_idx] = wep_key_len;
961
962 rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0, true);
963
964 goto exit;
965 }
966
967 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
968 {
969 struct sta_info * psta,*pbcmc_sta;
970 struct sta_priv * pstapriv = &padapter->stapriv;
971
972
973
974 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_MP_STATE) == true)
975 {
976 psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
977 if (psta == NULL) {
978
979 DBG_8192C("%s, : Obtain Sta_info fail\n", __func__);
980 }
981 else
982 {
983
984 if (strcmp(param->u.crypt.alg, "none") != 0)
985 psta->ieee8021x_blocked = false;
986
987
988 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled)||
989 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled))
990 {
991 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
992 }
993
994 if (param->u.crypt.set_tx == 1)
995 {
996
997 DBG_8192C("%s, : param->u.crypt.set_tx == 1\n", __func__);
998
999 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
1000
1001 if (strcmp(param->u.crypt.alg, "TKIP") == 0)
1002 {
1003
1004 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
1005 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
1006
1007 padapter->securitypriv.busetkipkey =false;
1008
1009 }
1010
1011
1012 DBG_871X(" ~~~~set sta key:unicastkey\n");
1013
1014 rtw_setstakey_cmd(padapter, psta, true, true);
1015 }
1016 else
1017 {
1018 if (strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0)
1019 {
1020 memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
1021 memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey,&(param->u.crypt.key[16]), 8);
1022 memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey,&(param->u.crypt.key[24]), 8);
1023 padapter->securitypriv.binstallGrpkey = true;
1024
1025 DBG_871X(" ~~~~set sta key:groupkey\n");
1026
1027 padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx;
1028 rtw_set_key(padapter,&padapter->securitypriv, param->u.crypt.idx, 1, true);
1029 }
1030 else if (strcmp(param->u.crypt.alg, "BIP") == 0)
1031 {
1032
1033
1034 memcpy(padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len>16 ?16:param->u.crypt.key_len));
1035
1036
1037
1038
1039 padapter->securitypriv.dot11wBIPKeyid = param->u.crypt.idx;
1040 padapter->securitypriv.binstallBIPkey = true;
1041 DBG_871X(" ~~~~set sta key:IGKT\n");
1042 }
1043 }
1044 }
1045
1046 pbcmc_sta =rtw_get_bcmc_stainfo(padapter);
1047 if (pbcmc_sta == NULL)
1048 {
1049
1050 }
1051 else
1052 {
1053
1054 if (strcmp(param->u.crypt.alg, "none") != 0)
1055 pbcmc_sta->ieee8021x_blocked = false;
1056
1057 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled)||
1058 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled))
1059 {
1060 pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
1061 }
1062 }
1063 }
1064 else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE))
1065 {
1066 }
1067 }
1068
1069exit:
1070
1071 DBG_8192C("%s, ret =%d\n", __func__, ret);
1072
1073 return ret;
1074}
1075
1076static int cfg80211_rtw_add_key(struct wiphy *wiphy, struct net_device *ndev,
1077 u8 key_index, bool pairwise, const u8 *mac_addr,
1078 struct key_params *params)
1079{
1080 char *alg_name;
1081 u32 param_len;
1082 struct ieee_param *param = NULL;
1083 int ret = 0;
1084 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
1085 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1086
1087 DBG_871X(FUNC_NDEV_FMT" adding key for %pM\n", FUNC_NDEV_ARG(ndev), mac_addr);
1088 DBG_871X("cipher = 0x%x\n", params->cipher);
1089 DBG_871X("key_len = 0x%x\n", params->key_len);
1090 DBG_871X("seq_len = 0x%x\n", params->seq_len);
1091 DBG_871X("key_index =%d\n", key_index);
1092 DBG_871X("pairwise =%d\n", pairwise);
1093
1094 param_len = sizeof(struct ieee_param) + params->key_len;
1095 param = rtw_malloc(param_len);
1096 if (param == NULL)
1097 return -1;
1098
1099 memset(param, 0, param_len);
1100
1101 param->cmd = IEEE_CMD_SET_ENCRYPTION;
1102 memset(param->sta_addr, 0xff, ETH_ALEN);
1103
1104 switch (params->cipher) {
1105 case IW_AUTH_CIPHER_NONE:
1106
1107
1108 alg_name = "none";
1109 break;
1110 case WLAN_CIPHER_SUITE_WEP40:
1111 case WLAN_CIPHER_SUITE_WEP104:
1112 alg_name = "WEP";
1113 break;
1114 case WLAN_CIPHER_SUITE_TKIP:
1115 alg_name = "TKIP";
1116 break;
1117 case WLAN_CIPHER_SUITE_CCMP:
1118 alg_name = "CCMP";
1119 break;
1120 case WLAN_CIPHER_SUITE_AES_CMAC:
1121 alg_name = "BIP";
1122 break;
1123 default:
1124 ret = -ENOTSUPP;
1125 goto addkey_end;
1126 }
1127
1128 strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
1129
1130
1131 if (!mac_addr || is_broadcast_ether_addr(mac_addr))
1132 {
1133 param->u.crypt.set_tx = 0;
1134 } else {
1135 param->u.crypt.set_tx = 1;
1136 }
1137
1138 param->u.crypt.idx = key_index;
1139
1140 if (params->seq_len && params->seq)
1141 {
1142 memcpy(param->u.crypt.seq, (u8 *)params->seq, params->seq_len);
1143 }
1144
1145 if (params->key_len && params->key)
1146 {
1147 param->u.crypt.key_len = params->key_len;
1148 memcpy(param->u.crypt.key, (u8 *)params->key, params->key_len);
1149 }
1150
1151 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true)
1152 {
1153 ret = rtw_cfg80211_set_encryption(ndev, param, param_len);
1154 }
1155 else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
1156 {
1157 if (mac_addr)
1158 memcpy(param->sta_addr, (void*)mac_addr, ETH_ALEN);
1159
1160 ret = rtw_cfg80211_ap_set_encryption(ndev, param, param_len);
1161 }
1162 else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true
1163 || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)
1164 {
1165
1166 ret = rtw_cfg80211_set_encryption(ndev, param, param_len);
1167 }
1168 else
1169 {
1170 DBG_8192C("error!\n");
1171
1172 }
1173
1174addkey_end:
1175 kfree((u8 *)param);
1176
1177 return ret;
1178
1179}
1180
1181static int cfg80211_rtw_get_key(struct wiphy *wiphy, struct net_device *ndev,
1182 u8 key_index, bool pairwise, const u8 *mac_addr,
1183 void *cookie,
1184 void (*callback)(void *cookie,
1185 struct key_params*))
1186{
1187 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
1188 return 0;
1189}
1190
1191static int cfg80211_rtw_del_key(struct wiphy *wiphy, struct net_device *ndev,
1192 u8 key_index, bool pairwise, const u8 *mac_addr)
1193{
1194 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
1195 struct security_priv *psecuritypriv = &padapter->securitypriv;
1196
1197 DBG_871X(FUNC_NDEV_FMT" key_index =%d\n", FUNC_NDEV_ARG(ndev), key_index);
1198
1199 if (key_index == psecuritypriv->dot11PrivacyKeyIndex)
1200 {
1201
1202 psecuritypriv->bWepDefaultKeyIdxSet = 0;
1203 }
1204
1205 return 0;
1206}
1207
1208static int cfg80211_rtw_set_default_key(struct wiphy *wiphy,
1209 struct net_device *ndev, u8 key_index
1210 , bool unicast, bool multicast
1211 )
1212{
1213 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
1214 struct security_priv *psecuritypriv = &padapter->securitypriv;
1215
1216 DBG_871X(FUNC_NDEV_FMT" key_index =%d, unicast =%d, multicast =%d\n",
1217 FUNC_NDEV_ARG(ndev), key_index, unicast, multicast);
1218
1219 if ((key_index < WEP_KEYS) && ((psecuritypriv->dot11PrivacyAlgrthm == _WEP40_) || (psecuritypriv->dot11PrivacyAlgrthm == _WEP104_)))
1220 {
1221 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
1222
1223 psecuritypriv->dot11PrivacyKeyIndex = key_index;
1224
1225 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
1226 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
1227 if (psecuritypriv->dot11DefKeylen[key_index] == 13)
1228 {
1229 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
1230 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
1231 }
1232
1233 psecuritypriv->bWepDefaultKeyIdxSet = 1;
1234 }
1235
1236 return 0;
1237
1238}
1239
1240static int cfg80211_rtw_get_station(struct wiphy *wiphy,
1241 struct net_device *ndev,
1242 const u8 *mac,
1243 struct station_info *sinfo)
1244{
1245 int ret = 0;
1246 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
1247 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1248 struct sta_info *psta = NULL;
1249 struct sta_priv *pstapriv = &padapter->stapriv;
1250
1251 sinfo->filled = 0;
1252
1253 if (!mac) {
1254 DBG_871X(FUNC_NDEV_FMT" mac ==%p\n", FUNC_NDEV_ARG(ndev), mac);
1255 ret = -ENOENT;
1256 goto exit;
1257 }
1258
1259 psta = rtw_get_stainfo(pstapriv, (u8 *)mac);
1260 if (psta == NULL) {
1261 DBG_8192C("%s, sta_info is null\n", __func__);
1262 ret = -ENOENT;
1263 goto exit;
1264 }
1265
1266#ifdef DEBUG_CFG80211
1267 DBG_871X(FUNC_NDEV_FMT" mac ="MAC_FMT"\n", FUNC_NDEV_ARG(ndev), MAC_ARG(mac));
1268#endif
1269
1270
1271 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
1272 && check_fwstate(pmlmepriv, _FW_LINKED)
1273 )
1274 {
1275 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1276
1277 if (memcmp((u8 *)mac, cur_network->network.MacAddress, ETH_ALEN)) {
1278 DBG_871X("%s, mismatch bssid ="MAC_FMT"\n", __func__, MAC_ARG(cur_network->network.MacAddress));
1279 ret = -ENOENT;
1280 goto exit;
1281 }
1282
1283 sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
1284 sinfo->signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);
1285
1286 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BITRATE);
1287 sinfo->txrate.legacy = rtw_get_cur_max_rate(padapter);
1288
1289 sinfo->filled |= BIT(NL80211_STA_INFO_RX_PACKETS);
1290 sinfo->rx_packets = sta_rx_data_pkts(psta);
1291
1292 sinfo->filled |= BIT(NL80211_STA_INFO_TX_PACKETS);
1293 sinfo->tx_packets = psta->sta_stats.tx_pkts;
1294
1295 }
1296
1297
1298 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)
1299 ||check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)
1300 ||check_fwstate(pmlmepriv, WIFI_AP_STATE))
1301 && check_fwstate(pmlmepriv, _FW_LINKED)
1302 )
1303 {
1304
1305 }
1306
1307exit:
1308 return ret;
1309}
1310
1311extern int netdev_open(struct net_device *pnetdev);
1312
1313static int cfg80211_rtw_change_iface(struct wiphy *wiphy,
1314 struct net_device *ndev,
1315 enum nl80211_iftype type,
1316 struct vif_params *params)
1317{
1318 enum nl80211_iftype old_type;
1319 enum NDIS_802_11_NETWORK_INFRASTRUCTURE networkType;
1320 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
1321 struct wireless_dev *rtw_wdev = padapter->rtw_wdev;
1322 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1323 int ret = 0;
1324 u8 change = false;
1325
1326 DBG_871X(FUNC_NDEV_FMT" type =%d\n", FUNC_NDEV_ARG(ndev), type);
1327
1328 if (adapter_to_dvobj(padapter)->processing_dev_remove == true)
1329 {
1330 ret = -EPERM;
1331 goto exit;
1332 }
1333
1334 {
1335 DBG_871X(FUNC_NDEV_FMT" call netdev_open\n", FUNC_NDEV_ARG(ndev));
1336 if (netdev_open(ndev) != 0) {
1337 DBG_871X(FUNC_NDEV_FMT" call netdev_open fail\n", FUNC_NDEV_ARG(ndev));
1338 ret = -EPERM;
1339 goto exit;
1340 }
1341 }
1342
1343 if (_FAIL == rtw_pwr_wakeup(padapter)) {
1344 DBG_871X(FUNC_NDEV_FMT" call rtw_pwr_wakeup fail\n", FUNC_NDEV_ARG(ndev));
1345 ret = -EPERM;
1346 goto exit;
1347 }
1348
1349 old_type = rtw_wdev->iftype;
1350 DBG_871X(FUNC_NDEV_FMT" old_iftype =%d, new_iftype =%d\n",
1351 FUNC_NDEV_ARG(ndev), old_type, type);
1352
1353 if (old_type != type)
1354 {
1355 change = true;
1356 pmlmeext->action_public_rxseq = 0xffff;
1357 pmlmeext->action_public_dialog_token = 0xff;
1358 }
1359
1360 switch (type) {
1361 case NL80211_IFTYPE_ADHOC:
1362 networkType = Ndis802_11IBSS;
1363 break;
1364 case NL80211_IFTYPE_STATION:
1365 networkType = Ndis802_11Infrastructure;
1366 break;
1367 case NL80211_IFTYPE_AP:
1368 networkType = Ndis802_11APMode;
1369 break;
1370 default:
1371 ret = -EOPNOTSUPP;
1372 goto exit;
1373 }
1374
1375 rtw_wdev->iftype = type;
1376
1377 if (rtw_set_802_11_infrastructure_mode(padapter, networkType) ==false)
1378 {
1379 rtw_wdev->iftype = old_type;
1380 ret = -EPERM;
1381 goto exit;
1382 }
1383
1384 rtw_setopmode_cmd(padapter, networkType, true);
1385
1386exit:
1387
1388 DBG_871X(FUNC_NDEV_FMT" ret:%d\n", FUNC_NDEV_ARG(ndev), ret);
1389 return ret;
1390}
1391
1392void rtw_cfg80211_indicate_scan_done(struct adapter *adapter, bool aborted)
1393{
1394 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(adapter);
1395 struct cfg80211_scan_info info = {
1396 .aborted = aborted
1397 };
1398
1399 spin_lock_bh(&pwdev_priv->scan_req_lock);
1400 if (pwdev_priv->scan_request != NULL) {
1401 #ifdef DEBUG_CFG80211
1402 DBG_871X("%s with scan req\n", __func__);
1403 #endif
1404
1405
1406 if (pwdev_priv->scan_request->wiphy != pwdev_priv->rtw_wdev->wiphy)
1407 {
1408 DBG_8192C("error wiphy compare\n");
1409 }
1410 else
1411 {
1412 cfg80211_scan_done(pwdev_priv->scan_request, &info);
1413 }
1414
1415 pwdev_priv->scan_request = NULL;
1416 } else {
1417 #ifdef DEBUG_CFG80211
1418 DBG_871X("%s without scan req\n", __func__);
1419 #endif
1420 }
1421 spin_unlock_bh(&pwdev_priv->scan_req_lock);
1422}
1423
1424void rtw_cfg80211_unlink_bss(struct adapter *padapter, struct wlan_network *pnetwork)
1425{
1426 struct wireless_dev *pwdev = padapter->rtw_wdev;
1427 struct wiphy *wiphy = pwdev->wiphy;
1428 struct cfg80211_bss *bss = NULL;
1429 struct wlan_bssid_ex select_network = pnetwork->network;
1430
1431 bss = cfg80211_get_bss(wiphy, NULL,
1432 select_network.MacAddress, select_network.Ssid.Ssid,
1433 select_network.Ssid.SsidLength, 0,
1434 0);
1435
1436 if (bss) {
1437 cfg80211_unlink_bss(wiphy, bss);
1438 DBG_8192C("%s(): cfg80211_unlink %s!! () ", __func__, select_network.Ssid.Ssid);
1439 cfg80211_put_bss(padapter->rtw_wdev->wiphy, bss);
1440 }
1441 return;
1442}
1443
1444void rtw_cfg80211_surveydone_event_callback(struct adapter *padapter)
1445{
1446 struct list_head *plist, *phead;
1447 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1448 struct __queue *queue = &(pmlmepriv->scanned_queue);
1449 struct wlan_network *pnetwork = NULL;
1450
1451#ifdef DEBUG_CFG80211
1452 DBG_8192C("%s\n", __func__);
1453#endif
1454
1455 spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
1456
1457 phead = get_list_head(queue);
1458 plist = get_next(phead);
1459
1460 while (1)
1461 {
1462 if (phead == plist)
1463 break;
1464
1465 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
1466
1467
1468 if (rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.Configuration.DSConfig) >= 0
1469 && rtw_mlme_band_check(padapter, pnetwork->network.Configuration.DSConfig) == true
1470 && true == rtw_validate_ssid(&(pnetwork->network.Ssid))
1471 )
1472 {
1473
1474 rtw_cfg80211_inform_bss(padapter, pnetwork);
1475 }
1476
1477 plist = get_next(plist);
1478
1479 }
1480
1481 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
1482}
1483
1484static int rtw_cfg80211_set_probe_req_wpsp2pie(struct adapter *padapter, char *buf, int len)
1485{
1486 int ret = 0;
1487 uint wps_ielen = 0;
1488 u8 *wps_ie;
1489 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1490
1491#ifdef DEBUG_CFG80211
1492 DBG_8192C("%s, ielen =%d\n", __func__, len);
1493#endif
1494
1495 if (len>0)
1496 {
1497 if ((wps_ie = rtw_get_wps_ie(buf, len, NULL, &wps_ielen)))
1498 {
1499 #ifdef DEBUG_CFG80211
1500 DBG_8192C("probe_req_wps_ielen =%d\n", wps_ielen);
1501 #endif
1502
1503 if (pmlmepriv->wps_probe_req_ie)
1504 {
1505 pmlmepriv->wps_probe_req_ie_len = 0;
1506 kfree(pmlmepriv->wps_probe_req_ie);
1507 pmlmepriv->wps_probe_req_ie = NULL;
1508 }
1509
1510 pmlmepriv->wps_probe_req_ie = rtw_malloc(wps_ielen);
1511 if (pmlmepriv->wps_probe_req_ie == NULL) {
1512 DBG_8192C("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
1513 return -EINVAL;
1514
1515 }
1516 memcpy(pmlmepriv->wps_probe_req_ie, wps_ie, wps_ielen);
1517 pmlmepriv->wps_probe_req_ie_len = wps_ielen;
1518 }
1519 }
1520
1521 return ret;
1522
1523}
1524
1525static int cfg80211_rtw_scan(struct wiphy *wiphy
1526 , struct cfg80211_scan_request *request)
1527{
1528 struct net_device *ndev = wdev_to_ndev(request->wdev);
1529 int i;
1530 u8 _status = false;
1531 int ret = 0;
1532 struct ndis_802_11_ssid ssid[RTW_SSID_SCAN_AMOUNT];
1533 struct rtw_ieee80211_channel ch[RTW_CHANNEL_SCAN_AMOUNT];
1534 u8 survey_times =3;
1535 u8 survey_times_for_one_ch =6;
1536 struct cfg80211_ssid *ssids = request->ssids;
1537 int j = 0;
1538 bool need_indicate_scan_done = false;
1539
1540 struct adapter *padapter;
1541 struct rtw_wdev_priv *pwdev_priv;
1542 struct mlme_priv *pmlmepriv;
1543
1544 if (ndev == NULL) {
1545 ret = -EINVAL;
1546 goto exit;
1547 }
1548
1549 padapter = (struct adapter *)rtw_netdev_priv(ndev);
1550 pwdev_priv = adapter_wdev_data(padapter);
1551 pmlmepriv = &padapter->mlmepriv;
1552
1553
1554 DBG_871X(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
1555
1556
1557 spin_lock_bh(&pwdev_priv->scan_req_lock);
1558 pwdev_priv->scan_request = request;
1559 spin_unlock_bh(&pwdev_priv->scan_req_lock);
1560
1561 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
1562 {
1563#ifdef DEBUG_CFG80211
1564 DBG_871X("%s under WIFI_AP_STATE\n", __func__);
1565#endif
1566
1567 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS|_FW_UNDER_SURVEY|_FW_UNDER_LINKING) == true)
1568 {
1569 DBG_8192C("%s, fwstate = 0x%x\n", __func__, pmlmepriv->fw_state);
1570
1571 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS))
1572 {
1573 DBG_8192C("AP mode process WPS\n");
1574 }
1575
1576 need_indicate_scan_done = true;
1577 goto check_need_indicate_scan_done;
1578 }
1579 }
1580
1581 rtw_ps_deny(padapter, PS_DENY_SCAN);
1582 if (_FAIL == rtw_pwr_wakeup(padapter)) {
1583 need_indicate_scan_done = true;
1584 goto check_need_indicate_scan_done;
1585 }
1586
1587 if (request->ie && request->ie_len>0)
1588 {
1589 rtw_cfg80211_set_probe_req_wpsp2pie(padapter, (u8 *)request->ie, request->ie_len);
1590 }
1591
1592 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) {
1593 DBG_8192C("%s, fwstate = 0x%x\n", __func__, pmlmepriv->fw_state);
1594 need_indicate_scan_done = true;
1595 goto check_need_indicate_scan_done;
1596 } else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
1597 DBG_8192C("%s, fwstate = 0x%x\n", __func__, pmlmepriv->fw_state);
1598 ret = -EBUSY;
1599 goto check_need_indicate_scan_done;
1600 }
1601
1602 if (pmlmepriv->LinkDetectInfo.bBusyTraffic == true)
1603 {
1604 static unsigned long lastscantime = 0;
1605 unsigned long passtime;
1606
1607 passtime = jiffies_to_msecs(jiffies - lastscantime);
1608 lastscantime = jiffies;
1609 if (passtime > 12000)
1610 {
1611 DBG_871X("%s: bBusyTraffic == true\n", __func__);
1612 need_indicate_scan_done = true;
1613 goto check_need_indicate_scan_done;
1614 }
1615 }
1616
1617 if (rtw_is_scan_deny(padapter)) {
1618 DBG_871X(FUNC_ADPT_FMT ": scan deny\n", FUNC_ADPT_ARG(padapter));
1619 need_indicate_scan_done = true;
1620 goto check_need_indicate_scan_done;
1621 }
1622
1623 memset(ssid, 0, sizeof(struct ndis_802_11_ssid)*RTW_SSID_SCAN_AMOUNT);
1624
1625 for (i = 0; i < request->n_ssids && i < RTW_SSID_SCAN_AMOUNT; i++) {
1626 #ifdef DEBUG_CFG80211
1627 DBG_8192C("ssid =%s, len =%d\n", ssids[i].ssid, ssids[i].ssid_len);
1628 #endif
1629 memcpy(ssid[i].Ssid, ssids[i].ssid, ssids[i].ssid_len);
1630 ssid[i].SsidLength = ssids[i].ssid_len;
1631 }
1632
1633
1634 memset(ch, 0, sizeof(struct rtw_ieee80211_channel)*RTW_CHANNEL_SCAN_AMOUNT);
1635 for (i = 0;i<request->n_channels && i<RTW_CHANNEL_SCAN_AMOUNT;i++) {
1636 #ifdef DEBUG_CFG80211
1637 DBG_871X(FUNC_ADPT_FMT CHAN_FMT"\n", FUNC_ADPT_ARG(padapter), CHAN_ARG(request->channels[i]));
1638 #endif
1639 ch[i].hw_value = request->channels[i]->hw_value;
1640 ch[i].flags = request->channels[i]->flags;
1641 }
1642
1643 spin_lock_bh(&pmlmepriv->lock);
1644 if (request->n_channels == 1) {
1645 for (i = 1;i<survey_times_for_one_ch;i++)
1646 memcpy(&ch[i], &ch[0], sizeof(struct rtw_ieee80211_channel));
1647 _status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, ch, survey_times_for_one_ch);
1648 } else if (request->n_channels <= 4) {
1649 for (j =request->n_channels-1;j>= 0;j--)
1650 for (i = 0;i<survey_times;i++)
1651 {
1652 memcpy(&ch[j*survey_times+i], &ch[j], sizeof(struct rtw_ieee80211_channel));
1653 }
1654 _status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, ch, survey_times * request->n_channels);
1655 } else {
1656 _status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, NULL, 0);
1657 }
1658 spin_unlock_bh(&pmlmepriv->lock);
1659
1660
1661 if (_status == false)
1662 {
1663 ret = -1;
1664 }
1665
1666check_need_indicate_scan_done:
1667 if (true == need_indicate_scan_done)
1668 {
1669 rtw_cfg80211_surveydone_event_callback(padapter);
1670 rtw_cfg80211_indicate_scan_done(padapter, false);
1671 }
1672
1673 rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
1674
1675exit:
1676 return ret;
1677
1678}
1679
1680static int cfg80211_rtw_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1681{
1682 DBG_8192C("%s\n", __func__);
1683 return 0;
1684}
1685
1686
1687
1688static int rtw_cfg80211_set_wpa_version(struct security_priv *psecuritypriv, u32 wpa_version)
1689{
1690 DBG_8192C("%s, wpa_version =%d\n", __func__, wpa_version);
1691
1692 if (!wpa_version) {
1693 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
1694 return 0;
1695 }
1696
1697
1698 if (wpa_version & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
1699 {
1700 psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPAPSK;
1701 }
1702
1703 return 0;
1704
1705}
1706
1707static int rtw_cfg80211_set_auth_type(struct security_priv *psecuritypriv,
1708 enum nl80211_auth_type sme_auth_type)
1709{
1710 DBG_8192C("%s, nl80211_auth_type =%d\n", __func__, sme_auth_type);
1711
1712
1713 switch (sme_auth_type) {
1714 case NL80211_AUTHTYPE_AUTOMATIC:
1715
1716 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
1717
1718 break;
1719 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1720
1721 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1722
1723 if (psecuritypriv->ndisauthtype>Ndis802_11AuthModeWPA)
1724 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
1725
1726 break;
1727 case NL80211_AUTHTYPE_SHARED_KEY:
1728
1729 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
1730
1731 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
1732
1733
1734 break;
1735 default:
1736 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1737
1738 }
1739
1740 return 0;
1741
1742}
1743
1744static int rtw_cfg80211_set_cipher(struct security_priv *psecuritypriv, u32 cipher, bool ucast)
1745{
1746 u32 ndisencryptstatus = Ndis802_11EncryptionDisabled;
1747
1748 u32 *profile_cipher = ucast ? &psecuritypriv->dot11PrivacyAlgrthm :
1749 &psecuritypriv->dot118021XGrpPrivacy;
1750
1751 DBG_8192C("%s, ucast =%d, cipher = 0x%x\n", __func__, ucast, cipher);
1752
1753
1754 if (!cipher) {
1755 *profile_cipher = _NO_PRIVACY_;
1756 psecuritypriv->ndisencryptstatus = ndisencryptstatus;
1757 return 0;
1758 }
1759
1760 switch (cipher) {
1761 case IW_AUTH_CIPHER_NONE:
1762 *profile_cipher = _NO_PRIVACY_;
1763 ndisencryptstatus = Ndis802_11EncryptionDisabled;
1764 break;
1765 case WLAN_CIPHER_SUITE_WEP40:
1766 *profile_cipher = _WEP40_;
1767 ndisencryptstatus = Ndis802_11Encryption1Enabled;
1768 break;
1769 case WLAN_CIPHER_SUITE_WEP104:
1770 *profile_cipher = _WEP104_;
1771 ndisencryptstatus = Ndis802_11Encryption1Enabled;
1772 break;
1773 case WLAN_CIPHER_SUITE_TKIP:
1774 *profile_cipher = _TKIP_;
1775 ndisencryptstatus = Ndis802_11Encryption2Enabled;
1776 break;
1777 case WLAN_CIPHER_SUITE_CCMP:
1778 *profile_cipher = _AES_;
1779 ndisencryptstatus = Ndis802_11Encryption3Enabled;
1780 break;
1781 default:
1782 DBG_8192C("Unsupported cipher: 0x%x\n", cipher);
1783 return -ENOTSUPP;
1784 }
1785
1786 if (ucast)
1787 {
1788 psecuritypriv->ndisencryptstatus = ndisencryptstatus;
1789
1790
1791
1792 }
1793
1794 return 0;
1795}
1796
1797static int rtw_cfg80211_set_key_mgt(struct security_priv *psecuritypriv, u32 key_mgt)
1798{
1799 DBG_8192C("%s, key_mgt = 0x%x\n", __func__, key_mgt);
1800
1801 if (key_mgt == WLAN_AKM_SUITE_8021X)
1802
1803 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
1804 else if (key_mgt == WLAN_AKM_SUITE_PSK) {
1805 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
1806 }
1807 else {
1808 DBG_8192C("Invalid key mgt: 0x%x\n", key_mgt);
1809
1810 }
1811
1812 return 0;
1813}
1814
1815static int rtw_cfg80211_set_wpa_ie(struct adapter *padapter, u8 *pie, size_t ielen)
1816{
1817 u8 *buf = NULL, *pos = NULL;
1818 int group_cipher = 0, pairwise_cipher = 0;
1819 int ret = 0;
1820 int wpa_ielen = 0;
1821 int wpa2_ielen = 0;
1822 u8 *pwpa, *pwpa2;
1823 u8 null_addr[]= {0, 0, 0, 0, 0, 0};
1824
1825 if (pie == NULL || !ielen) {
1826
1827 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
1828 goto exit;
1829 }
1830
1831 if (ielen > MAX_WPA_IE_LEN+MAX_WPS_IE_LEN+MAX_P2P_IE_LEN) {
1832 ret = -EINVAL;
1833 goto exit;
1834 }
1835
1836 buf = rtw_zmalloc(ielen);
1837 if (buf == NULL) {
1838 ret = -ENOMEM;
1839 goto exit;
1840 }
1841
1842 memcpy(buf, pie , ielen);
1843
1844
1845 {
1846 int i;
1847 DBG_8192C("set wpa_ie(length:%zu):\n", ielen);
1848 for (i = 0;i<ielen;i =i+8)
1849 DBG_8192C("0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x\n", buf[i], buf[i+1], buf[i+2], buf[i+3], buf[i+4], buf[i+5], buf[i+6], buf[i+7]);
1850 }
1851
1852 pos = buf;
1853 if (ielen < RSN_HEADER_LEN) {
1854 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("Ie len too short %d\n", ielen));
1855 ret = -1;
1856 goto exit;
1857 }
1858
1859 pwpa = rtw_get_wpa_ie(buf, &wpa_ielen, ielen);
1860 if (pwpa && wpa_ielen>0)
1861 {
1862 if (rtw_parse_wpa_ie(pwpa, wpa_ielen+2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS)
1863 {
1864 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
1865 padapter->securitypriv.ndisauthtype =Ndis802_11AuthModeWPAPSK;
1866 memcpy(padapter->securitypriv.supplicant_ie, &pwpa[0], wpa_ielen+2);
1867
1868 DBG_8192C("got wpa_ie, wpa_ielen:%u\n", wpa_ielen);
1869 }
1870 }
1871
1872 pwpa2 = rtw_get_wpa2_ie(buf, &wpa2_ielen, ielen);
1873 if (pwpa2 && wpa2_ielen>0)
1874 {
1875 if (rtw_parse_wpa2_ie(pwpa2, wpa2_ielen+2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS)
1876 {
1877 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
1878 padapter->securitypriv.ndisauthtype =Ndis802_11AuthModeWPA2PSK;
1879 memcpy(padapter->securitypriv.supplicant_ie, &pwpa2[0], wpa2_ielen+2);
1880
1881 DBG_8192C("got wpa2_ie, wpa2_ielen:%u\n", wpa2_ielen);
1882 }
1883 }
1884
1885 if (group_cipher == 0)
1886 {
1887 group_cipher = WPA_CIPHER_NONE;
1888 }
1889 if (pairwise_cipher == 0)
1890 {
1891 pairwise_cipher = WPA_CIPHER_NONE;
1892 }
1893
1894 switch (group_cipher)
1895 {
1896 case WPA_CIPHER_NONE:
1897 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1898 padapter->securitypriv.ndisencryptstatus =Ndis802_11EncryptionDisabled;
1899 break;
1900 case WPA_CIPHER_WEP40:
1901 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
1902 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1903 break;
1904 case WPA_CIPHER_TKIP:
1905 padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_;
1906 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
1907 break;
1908 case WPA_CIPHER_CCMP:
1909 padapter->securitypriv.dot118021XGrpPrivacy = _AES_;
1910 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
1911 break;
1912 case WPA_CIPHER_WEP104:
1913 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
1914 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1915 break;
1916 }
1917
1918 switch (pairwise_cipher)
1919 {
1920 case WPA_CIPHER_NONE:
1921 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1922 padapter->securitypriv.ndisencryptstatus =Ndis802_11EncryptionDisabled;
1923 break;
1924 case WPA_CIPHER_WEP40:
1925 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
1926 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1927 break;
1928 case WPA_CIPHER_TKIP:
1929 padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_;
1930 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
1931 break;
1932 case WPA_CIPHER_CCMP:
1933 padapter->securitypriv.dot11PrivacyAlgrthm = _AES_;
1934 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
1935 break;
1936 case WPA_CIPHER_WEP104:
1937 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
1938 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1939 break;
1940 }
1941
1942 {
1943 uint wps_ielen;
1944 u8 *wps_ie;
1945
1946 wps_ie = rtw_get_wps_ie(buf, ielen, NULL, &wps_ielen);
1947 if (wps_ie && wps_ielen > 0) {
1948 DBG_8192C("got wps_ie, wps_ielen:%u\n", wps_ielen);
1949 padapter->securitypriv.wps_ie_len = wps_ielen<MAX_WPS_IE_LEN?wps_ielen:MAX_WPS_IE_LEN;
1950 memcpy(padapter->securitypriv.wps_ie, wps_ie, padapter->securitypriv.wps_ie_len);
1951 set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
1952 } else {
1953 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
1954 }
1955 }
1956
1957
1958 if (padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_
1959 || padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_WTMIC_
1960 || padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)
1961
1962
1963 rtw_hal_set_hwreg(padapter, HW_VAR_OFF_RCR_AM, null_addr);
1964
1965 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1966 ("rtw_set_wpa_ie: pairwise_cipher = 0x%08x padapter->securitypriv.ndisencryptstatus =%d padapter->securitypriv.ndisauthtype =%d\n",
1967 pairwise_cipher, padapter->securitypriv.ndisencryptstatus, padapter->securitypriv.ndisauthtype));
1968
1969exit:
1970 kfree(buf);
1971 if (ret)
1972 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
1973 return ret;
1974}
1975
1976static int cfg80211_rtw_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
1977 struct cfg80211_ibss_params *params)
1978{
1979 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
1980 struct ndis_802_11_ssid ndis_ssid;
1981 struct security_priv *psecuritypriv = &padapter->securitypriv;
1982 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1983 int ret = 0;
1984
1985 if (_FAIL == rtw_pwr_wakeup(padapter)) {
1986 ret = -EPERM;
1987 goto exit;
1988 }
1989
1990 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1991 ret = -EPERM;
1992 goto exit;
1993 }
1994
1995 if (!params->ssid || !params->ssid_len)
1996 {
1997 ret = -EINVAL;
1998 goto exit;
1999 }
2000
2001 if (params->ssid_len > IW_ESSID_MAX_SIZE) {
2002
2003 ret = -E2BIG;
2004 goto exit;
2005 }
2006
2007 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
2008 ndis_ssid.SsidLength = params->ssid_len;
2009 memcpy(ndis_ssid.Ssid, (u8 *)params->ssid, params->ssid_len);
2010
2011
2012
2013 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
2014 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
2015 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
2016 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
2017 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
2018
2019 ret = rtw_cfg80211_set_auth_type(psecuritypriv, NL80211_AUTHTYPE_OPEN_SYSTEM);
2020 rtw_set_802_11_authentication_mode(padapter, psecuritypriv->ndisauthtype);
2021
2022 if (rtw_set_802_11_ssid(padapter, &ndis_ssid) == false)
2023 {
2024 ret = -1;
2025 goto exit;
2026 }
2027
2028exit:
2029 return ret;
2030}
2031
2032static int cfg80211_rtw_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
2033{
2034 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2035 struct wireless_dev *rtw_wdev = padapter->rtw_wdev;
2036 enum nl80211_iftype old_type;
2037 int ret = 0;
2038
2039 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2040
2041 padapter->mlmepriv.not_indic_disco = true;
2042
2043 old_type = rtw_wdev->iftype;
2044
2045 rtw_set_to_roam(padapter, 0);
2046
2047 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED))
2048 {
2049 rtw_scan_abort(padapter);
2050 LeaveAllPowerSaveMode(padapter);
2051
2052 rtw_wdev->iftype = NL80211_IFTYPE_STATION;
2053
2054 if (rtw_set_802_11_infrastructure_mode(padapter, Ndis802_11Infrastructure) ==false)
2055 {
2056 rtw_wdev->iftype = old_type;
2057 ret = -EPERM;
2058 goto leave_ibss;
2059 }
2060 rtw_setopmode_cmd(padapter, Ndis802_11Infrastructure, true);
2061 }
2062
2063leave_ibss:
2064 padapter->mlmepriv.not_indic_disco = false;
2065
2066 return 0;
2067}
2068
2069static int cfg80211_rtw_connect(struct wiphy *wiphy, struct net_device *ndev,
2070 struct cfg80211_connect_params *sme)
2071{
2072 int ret = 0;
2073 enum NDIS_802_11_AUTHENTICATION_MODE authmode;
2074 struct ndis_802_11_ssid ndis_ssid;
2075 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2076 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2077 struct security_priv *psecuritypriv = &padapter->securitypriv;
2078
2079 padapter->mlmepriv.not_indic_disco = true;
2080
2081 DBG_871X("=>"FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2082 DBG_871X("privacy =%d, key =%p, key_len =%d, key_idx =%d\n",
2083 sme->privacy, sme->key, sme->key_len, sme->key_idx);
2084
2085
2086 if (adapter_wdev_data(padapter)->block == true)
2087 {
2088 ret = -EBUSY;
2089 DBG_871X("%s wdev_priv.block is set\n", __func__);
2090 goto exit;
2091 }
2092
2093 rtw_ps_deny(padapter, PS_DENY_JOIN);
2094 if (_FAIL == rtw_pwr_wakeup(padapter)) {
2095 ret = -EPERM;
2096 goto exit;
2097 }
2098
2099 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
2100 ret = -EPERM;
2101 goto exit;
2102 }
2103
2104 if (!sme->ssid || !sme->ssid_len)
2105 {
2106 ret = -EINVAL;
2107 goto exit;
2108 }
2109
2110 if (sme->ssid_len > IW_ESSID_MAX_SIZE) {
2111
2112 ret = -E2BIG;
2113 goto exit;
2114 }
2115
2116 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
2117 ndis_ssid.SsidLength = sme->ssid_len;
2118 memcpy(ndis_ssid.Ssid, (u8 *)sme->ssid, sme->ssid_len);
2119
2120 DBG_8192C("ssid =%s, len =%zu\n", ndis_ssid.Ssid, sme->ssid_len);
2121
2122
2123 if (sme->bssid)
2124 DBG_8192C("bssid ="MAC_FMT"\n", MAC_ARG(sme->bssid));
2125
2126
2127 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
2128 ret = -EBUSY;
2129 DBG_8192C("%s, fw_state = 0x%x, goto exit\n", __func__, pmlmepriv->fw_state);
2130 goto exit;
2131 }
2132 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) {
2133 rtw_scan_abort(padapter);
2134 }
2135
2136 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
2137 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
2138 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
2139 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
2140 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
2141
2142 ret = rtw_cfg80211_set_wpa_version(psecuritypriv, sme->crypto.wpa_versions);
2143 if (ret < 0)
2144 goto exit;
2145
2146 ret = rtw_cfg80211_set_auth_type(psecuritypriv, sme->auth_type);
2147
2148 if (ret < 0)
2149 goto exit;
2150
2151 DBG_8192C("%s, ie_len =%zu\n", __func__, sme->ie_len);
2152
2153 ret = rtw_cfg80211_set_wpa_ie(padapter, (u8 *)sme->ie, sme->ie_len);
2154 if (ret < 0)
2155 goto exit;
2156
2157 if (sme->crypto.n_ciphers_pairwise) {
2158 ret = rtw_cfg80211_set_cipher(psecuritypriv, sme->crypto.ciphers_pairwise[0], true);
2159 if (ret < 0)
2160 goto exit;
2161 }
2162
2163
2164 if ((psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_Shared
2165 || psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_Auto) && sme->key
2166 )
2167 {
2168 u32 wep_key_idx, wep_key_len, wep_total_len;
2169 struct ndis_802_11_wep *pwep = NULL;
2170 DBG_871X("%s(): Shared/Auto WEP\n", __func__);
2171
2172 wep_key_idx = sme->key_idx;
2173 wep_key_len = sme->key_len;
2174
2175 if (sme->key_idx > WEP_KEYS) {
2176 ret = -EINVAL;
2177 goto exit;
2178 }
2179
2180 if (wep_key_len > 0)
2181 {
2182 wep_key_len = wep_key_len <= 5 ? 5 : 13;
2183 wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, KeyMaterial);
2184 pwep = rtw_malloc(wep_total_len);
2185 if (pwep == NULL) {
2186 DBG_871X(" wpa_set_encryption: pwep allocate fail !!!\n");
2187 ret = -ENOMEM;
2188 goto exit;
2189 }
2190
2191 memset(pwep, 0, wep_total_len);
2192
2193 pwep->KeyLength = wep_key_len;
2194 pwep->Length = wep_total_len;
2195
2196 if (wep_key_len == 13)
2197 {
2198 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
2199 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
2200 }
2201 }
2202 else {
2203 ret = -EINVAL;
2204 goto exit;
2205 }
2206
2207 pwep->KeyIndex = wep_key_idx;
2208 pwep->KeyIndex |= 0x80000000;
2209
2210 memcpy(pwep->KeyMaterial, (void *)sme->key, pwep->KeyLength);
2211
2212 if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL)
2213 {
2214 ret = -EOPNOTSUPP ;
2215 }
2216
2217 kfree((u8 *)pwep);
2218
2219 if (ret < 0)
2220 goto exit;
2221 }
2222
2223 ret = rtw_cfg80211_set_cipher(psecuritypriv, sme->crypto.cipher_group, false);
2224 if (ret < 0)
2225 return ret;
2226
2227 if (sme->crypto.n_akm_suites) {
2228 ret = rtw_cfg80211_set_key_mgt(psecuritypriv, sme->crypto.akm_suites[0]);
2229 if (ret < 0)
2230 goto exit;
2231 }
2232
2233 authmode = psecuritypriv->ndisauthtype;
2234 rtw_set_802_11_authentication_mode(padapter, authmode);
2235
2236
2237
2238 if (rtw_set_802_11_connect(padapter, (u8 *)sme->bssid, &ndis_ssid) == false) {
2239 ret = -1;
2240 goto exit;
2241 }
2242
2243 DBG_8192C("set ssid:dot11AuthAlgrthm =%d, dot11PrivacyAlgrthm =%d, dot118021XGrpPrivacy =%d\n", psecuritypriv->dot11AuthAlgrthm, psecuritypriv->dot11PrivacyAlgrthm, psecuritypriv->dot118021XGrpPrivacy);
2244
2245exit:
2246
2247 rtw_ps_deny_cancel(padapter, PS_DENY_JOIN);
2248
2249 DBG_8192C("<=%s, ret %d\n", __func__, ret);
2250
2251 padapter->mlmepriv.not_indic_disco = false;
2252
2253 return ret;
2254}
2255
2256static int cfg80211_rtw_disconnect(struct wiphy *wiphy, struct net_device *ndev,
2257 u16 reason_code)
2258{
2259 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2260
2261 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2262
2263 padapter->mlmepriv.not_indic_disco = true;
2264
2265 rtw_set_to_roam(padapter, 0);
2266
2267 rtw_scan_abort(padapter);
2268 LeaveAllPowerSaveMode(padapter);
2269 rtw_disassoc_cmd(padapter, 500, false);
2270
2271 DBG_871X("%s...call rtw_indicate_disconnect\n", __func__);
2272
2273 rtw_indicate_disconnect(padapter);
2274
2275 rtw_free_assoc_resources(padapter, 1);
2276 rtw_pwr_wakeup(padapter);
2277
2278 padapter->mlmepriv.not_indic_disco = false;
2279
2280 DBG_871X(FUNC_NDEV_FMT" return 0\n", FUNC_NDEV_ARG(ndev));
2281 return 0;
2282}
2283
2284static int cfg80211_rtw_set_txpower(struct wiphy *wiphy,
2285 struct wireless_dev *wdev,
2286 enum nl80211_tx_power_setting type, int mbm)
2287{
2288 DBG_8192C("%s\n", __func__);
2289 return 0;
2290}
2291
2292static int cfg80211_rtw_get_txpower(struct wiphy *wiphy,
2293 struct wireless_dev *wdev,
2294 int *dbm)
2295{
2296 DBG_8192C("%s\n", __func__);
2297
2298 *dbm = (12);
2299
2300 return 0;
2301}
2302
2303inline bool rtw_cfg80211_pwr_mgmt(struct adapter *adapter)
2304{
2305 struct rtw_wdev_priv *rtw_wdev_priv = adapter_wdev_data(adapter);
2306 return rtw_wdev_priv->power_mgmt;
2307}
2308
2309static int cfg80211_rtw_set_power_mgmt(struct wiphy *wiphy,
2310 struct net_device *ndev,
2311 bool enabled, int timeout)
2312{
2313 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2314 struct rtw_wdev_priv *rtw_wdev_priv = adapter_wdev_data(padapter);
2315
2316 DBG_871X(FUNC_NDEV_FMT" enabled:%u, timeout:%d\n", FUNC_NDEV_ARG(ndev),
2317 enabled, timeout);
2318
2319 rtw_wdev_priv->power_mgmt = enabled;
2320
2321 if (!enabled)
2322 LPS_Leave(padapter, "CFG80211_PWRMGMT");
2323
2324 return 0;
2325}
2326
2327static int cfg80211_rtw_set_pmksa(struct wiphy *wiphy,
2328 struct net_device *ndev,
2329 struct cfg80211_pmksa *pmksa)
2330{
2331 u8 index, blInserted = false;
2332 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2333 struct security_priv *psecuritypriv = &padapter->securitypriv;
2334 u8 strZeroMacAddress[ ETH_ALEN ] = { 0x00 };
2335
2336 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2337
2338 if (!memcmp((u8 *)pmksa->bssid, strZeroMacAddress, ETH_ALEN))
2339 {
2340 return -EINVAL;
2341 }
2342
2343 blInserted = false;
2344
2345
2346 for (index = 0 ; index<NUM_PMKID_CACHE; index++)
2347 {
2348 if (!memcmp(psecuritypriv->PMKIDList[index].Bssid, (u8 *)pmksa->bssid, ETH_ALEN))
2349 {
2350 DBG_871X(FUNC_NDEV_FMT" BSSID exists in the PMKList.\n", FUNC_NDEV_ARG(ndev));
2351
2352 memcpy(psecuritypriv->PMKIDList[index].PMKID, (u8 *)pmksa->pmkid, WLAN_PMKID_LEN);
2353 psecuritypriv->PMKIDList[index].bUsed = true;
2354 psecuritypriv->PMKIDIndex = index+1;
2355 blInserted = true;
2356 break;
2357 }
2358 }
2359
2360 if (!blInserted)
2361 {
2362
2363 DBG_871X(FUNC_NDEV_FMT" Use the new entry index = %d for this PMKID.\n",
2364 FUNC_NDEV_ARG(ndev), psecuritypriv->PMKIDIndex);
2365
2366 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].Bssid, (u8 *)pmksa->bssid, ETH_ALEN);
2367 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].PMKID, (u8 *)pmksa->pmkid, WLAN_PMKID_LEN);
2368
2369 psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].bUsed = true;
2370 psecuritypriv->PMKIDIndex++ ;
2371 if (psecuritypriv->PMKIDIndex == 16)
2372 {
2373 psecuritypriv->PMKIDIndex = 0;
2374 }
2375 }
2376
2377 return 0;
2378}
2379
2380static int cfg80211_rtw_del_pmksa(struct wiphy *wiphy,
2381 struct net_device *ndev,
2382 struct cfg80211_pmksa *pmksa)
2383{
2384 u8 index, bMatched = false;
2385 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2386 struct security_priv *psecuritypriv = &padapter->securitypriv;
2387
2388 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2389
2390 for (index = 0 ; index<NUM_PMKID_CACHE; index++)
2391 {
2392 if (!memcmp(psecuritypriv->PMKIDList[index].Bssid, (u8 *)pmksa->bssid, ETH_ALEN))
2393 {
2394 memset(psecuritypriv->PMKIDList[index].Bssid, 0x00, ETH_ALEN);
2395 memset(psecuritypriv->PMKIDList[index].PMKID, 0x00, WLAN_PMKID_LEN);
2396 psecuritypriv->PMKIDList[index].bUsed = false;
2397 bMatched = true;
2398 break;
2399 }
2400 }
2401
2402 if (false == bMatched)
2403 {
2404 DBG_871X(FUNC_NDEV_FMT" do not have matched BSSID\n"
2405 , FUNC_NDEV_ARG(ndev));
2406 return -EINVAL;
2407 }
2408
2409 return 0;
2410}
2411
2412static int cfg80211_rtw_flush_pmksa(struct wiphy *wiphy,
2413 struct net_device *ndev)
2414{
2415 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2416 struct security_priv *psecuritypriv = &padapter->securitypriv;
2417
2418 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2419
2420 memset(&psecuritypriv->PMKIDList[ 0 ], 0x00, sizeof(RT_PMKID_LIST) * NUM_PMKID_CACHE);
2421 psecuritypriv->PMKIDIndex = 0;
2422
2423 return 0;
2424}
2425
2426void rtw_cfg80211_indicate_sta_assoc(struct adapter *padapter, u8 *pmgmt_frame, uint frame_len)
2427{
2428 struct net_device *ndev = padapter->pnetdev;
2429
2430 DBG_871X(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
2431
2432 {
2433 struct station_info sinfo;
2434 u8 ie_offset;
2435 if (GetFrameSubType(pmgmt_frame) == WIFI_ASSOCREQ)
2436 ie_offset = _ASOCREQ_IE_OFFSET_;
2437 else
2438 ie_offset = _REASOCREQ_IE_OFFSET_;
2439
2440 sinfo.filled = 0;
2441 sinfo.assoc_req_ies = pmgmt_frame + WLAN_HDR_A3_LEN + ie_offset;
2442 sinfo.assoc_req_ies_len = frame_len - WLAN_HDR_A3_LEN - ie_offset;
2443 cfg80211_new_sta(ndev, GetAddr2Ptr(pmgmt_frame), &sinfo, GFP_ATOMIC);
2444 }
2445}
2446
2447void rtw_cfg80211_indicate_sta_disassoc(struct adapter *padapter, unsigned char *da, unsigned short reason)
2448{
2449 struct net_device *ndev = padapter->pnetdev;
2450
2451 DBG_871X(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
2452
2453 cfg80211_del_sta(ndev, da, GFP_ATOMIC);
2454}
2455
2456static int rtw_cfg80211_monitor_if_open(struct net_device *ndev)
2457{
2458 int ret = 0;
2459
2460 DBG_8192C("%s\n", __func__);
2461
2462 return ret;
2463}
2464
2465static int rtw_cfg80211_monitor_if_close(struct net_device *ndev)
2466{
2467 int ret = 0;
2468
2469 DBG_8192C("%s\n", __func__);
2470
2471 return ret;
2472}
2473
2474static int rtw_cfg80211_monitor_if_xmit_entry(struct sk_buff *skb, struct net_device *ndev)
2475{
2476 int ret = 0;
2477 int rtap_len;
2478 int qos_len = 0;
2479 int dot11_hdr_len = 24;
2480 int snap_len = 6;
2481 unsigned char *pdata;
2482 u16 frame_control;
2483 unsigned char src_mac_addr[6];
2484 unsigned char dst_mac_addr[6];
2485 struct ieee80211_hdr *dot11_hdr;
2486 struct ieee80211_radiotap_header *rtap_hdr;
2487 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2488
2489 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2490
2491 if (!skb)
2492 goto fail;
2493
2494 rtw_mstat_update(MSTAT_TYPE_SKB, MSTAT_ALLOC_SUCCESS, skb->truesize);
2495
2496 if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
2497 goto fail;
2498
2499 rtap_hdr = (struct ieee80211_radiotap_header *)skb->data;
2500 if (unlikely(rtap_hdr->it_version))
2501 goto fail;
2502
2503 rtap_len = ieee80211_get_radiotap_len(skb->data);
2504 if (unlikely(skb->len < rtap_len))
2505 goto fail;
2506
2507 if (rtap_len != 14)
2508 {
2509 DBG_8192C("radiotap len (should be 14): %d\n", rtap_len);
2510 goto fail;
2511 }
2512
2513
2514 skb_pull(skb, rtap_len);
2515
2516 dot11_hdr = (struct ieee80211_hdr *)skb->data;
2517 frame_control = le16_to_cpu(dot11_hdr->frame_control);
2518
2519 if ((frame_control & RTW_IEEE80211_FCTL_FTYPE) == RTW_IEEE80211_FTYPE_DATA) {
2520
2521
2522
2523 if (frame_control & 0x0080)
2524 qos_len = 2;
2525 if ((frame_control & 0x0300) == 0x0300)
2526 dot11_hdr_len += 6;
2527
2528 memcpy(dst_mac_addr, dot11_hdr->addr1, sizeof(dst_mac_addr));
2529 memcpy(src_mac_addr, dot11_hdr->addr2, sizeof(src_mac_addr));
2530
2531
2532
2533
2534 skb_pull(skb, dot11_hdr_len + qos_len + snap_len - sizeof(src_mac_addr) * 2);
2535 pdata = (unsigned char*)skb->data;
2536 memcpy(pdata, dst_mac_addr, sizeof(dst_mac_addr));
2537 memcpy(pdata + sizeof(dst_mac_addr), src_mac_addr, sizeof(src_mac_addr));
2538
2539 DBG_8192C("should be eapol packet\n");
2540
2541
2542 ret = _rtw_xmit_entry(skb, padapter->pnetdev);
2543
2544 return ret;
2545
2546 }
2547 else if ((frame_control & (RTW_IEEE80211_FCTL_FTYPE|RTW_IEEE80211_FCTL_STYPE))
2548 == (RTW_IEEE80211_FTYPE_MGMT|RTW_IEEE80211_STYPE_ACTION)
2549 )
2550 {
2551
2552 struct xmit_frame *pmgntframe;
2553 struct pkt_attrib *pattrib;
2554 unsigned char *pframe;
2555
2556
2557 struct ieee80211_hdr *pwlanhdr;
2558 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
2559 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
2560 u8 *buf = skb->data;
2561 u32 len = skb->len;
2562 u8 category, action;
2563
2564 if (rtw_action_frame_parse(buf, len, &category, &action) == false) {
2565 DBG_8192C(FUNC_NDEV_FMT" frame_control:0x%x\n", FUNC_NDEV_ARG(ndev),
2566 le16_to_cpu(((struct ieee80211_hdr_3addr *)buf)->frame_control));
2567 goto fail;
2568 }
2569
2570 DBG_8192C("RTW_Tx:da ="MAC_FMT" via "FUNC_NDEV_FMT"\n",
2571 MAC_ARG(GetAddr1Ptr(buf)), FUNC_NDEV_ARG(ndev));
2572 if (category == RTW_WLAN_CATEGORY_PUBLIC)
2573 DBG_871X("RTW_Tx:%s\n", action_public_str(action));
2574 else
2575 DBG_871X("RTW_Tx:category(%u), action(%u)\n", category, action);
2576
2577
2578 if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
2579 {
2580 goto fail;
2581 }
2582
2583
2584 pattrib = &pmgntframe->attrib;
2585 update_mgntframe_attrib(padapter, pattrib);
2586 pattrib->retry_ctrl = false;
2587
2588 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
2589
2590 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
2591
2592 memcpy(pframe, (void*)buf, len);
2593 pattrib->pktlen = len;
2594
2595 pwlanhdr = (struct ieee80211_hdr *)pframe;
2596
2597 pmlmeext->mgnt_seq = GetSequence(pwlanhdr);
2598 pattrib->seqnum = pmlmeext->mgnt_seq;
2599 pmlmeext->mgnt_seq++;
2600
2601
2602 pattrib->last_txcmdsz = pattrib->pktlen;
2603
2604 dump_mgntframe(padapter, pmgntframe);
2605
2606 }
2607 else
2608 {
2609 DBG_8192C("frame_control = 0x%x\n", frame_control & (RTW_IEEE80211_FCTL_FTYPE|RTW_IEEE80211_FCTL_STYPE));
2610 }
2611
2612
2613fail:
2614
2615 dev_kfree_skb_any(skb);
2616
2617 return 0;
2618
2619}
2620
2621static int rtw_cfg80211_monitor_if_set_mac_address(struct net_device *ndev, void *addr)
2622{
2623 int ret = 0;
2624
2625 DBG_8192C("%s\n", __func__);
2626
2627 return ret;
2628}
2629
2630static const struct net_device_ops rtw_cfg80211_monitor_if_ops = {
2631 .ndo_open = rtw_cfg80211_monitor_if_open,
2632 .ndo_stop = rtw_cfg80211_monitor_if_close,
2633 .ndo_start_xmit = rtw_cfg80211_monitor_if_xmit_entry,
2634 .ndo_set_mac_address = rtw_cfg80211_monitor_if_set_mac_address,
2635};
2636
2637static int rtw_cfg80211_add_monitor_if (struct adapter *padapter, char *name, struct net_device **ndev)
2638{
2639 int ret = 0;
2640 struct net_device* mon_ndev = NULL;
2641 struct wireless_dev* mon_wdev = NULL;
2642 struct rtw_netdev_priv_indicator *pnpi;
2643 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
2644
2645 if (!name) {
2646 DBG_871X(FUNC_ADPT_FMT" without specific name\n", FUNC_ADPT_ARG(padapter));
2647 ret = -EINVAL;
2648 goto out;
2649 }
2650
2651 if (pwdev_priv->pmon_ndev) {
2652 DBG_871X(FUNC_ADPT_FMT" monitor interface exist: "NDEV_FMT"\n",
2653 FUNC_ADPT_ARG(padapter), NDEV_ARG(pwdev_priv->pmon_ndev));
2654 ret = -EBUSY;
2655 goto out;
2656 }
2657
2658 mon_ndev = alloc_etherdev(sizeof(struct rtw_netdev_priv_indicator));
2659 if (!mon_ndev) {
2660 DBG_871X(FUNC_ADPT_FMT" allocate ndev fail\n", FUNC_ADPT_ARG(padapter));
2661 ret = -ENOMEM;
2662 goto out;
2663 }
2664
2665 mon_ndev->type = ARPHRD_IEEE80211_RADIOTAP;
2666 strncpy(mon_ndev->name, name, IFNAMSIZ);
2667 mon_ndev->name[IFNAMSIZ - 1] = 0;
2668 mon_ndev->needs_free_netdev = true;
2669 mon_ndev->priv_destructor = rtw_ndev_destructor;
2670
2671 mon_ndev->netdev_ops = &rtw_cfg80211_monitor_if_ops;
2672
2673 pnpi = netdev_priv(mon_ndev);
2674 pnpi->priv = padapter;
2675 pnpi->sizeof_priv = sizeof(struct adapter);
2676
2677
2678 mon_wdev = rtw_zmalloc(sizeof(struct wireless_dev));
2679 if (!mon_wdev) {
2680 DBG_871X(FUNC_ADPT_FMT" allocate mon_wdev fail\n", FUNC_ADPT_ARG(padapter));
2681 ret = -ENOMEM;
2682 goto out;
2683 }
2684
2685 mon_wdev->wiphy = padapter->rtw_wdev->wiphy;
2686 mon_wdev->netdev = mon_ndev;
2687 mon_wdev->iftype = NL80211_IFTYPE_MONITOR;
2688 mon_ndev->ieee80211_ptr = mon_wdev;
2689
2690 ret = register_netdevice(mon_ndev);
2691 if (ret) {
2692 goto out;
2693 }
2694
2695 *ndev = pwdev_priv->pmon_ndev = mon_ndev;
2696 memcpy(pwdev_priv->ifname_mon, name, IFNAMSIZ+1);
2697
2698out:
2699 if (ret && mon_wdev) {
2700 kfree((u8 *)mon_wdev);
2701 mon_wdev = NULL;
2702 }
2703
2704 if (ret && mon_ndev) {
2705 free_netdev(mon_ndev);
2706 *ndev = mon_ndev = NULL;
2707 }
2708
2709 return ret;
2710}
2711
2712static struct wireless_dev *
2713 cfg80211_rtw_add_virtual_intf(
2714 struct wiphy *wiphy,
2715 const char *name,
2716 unsigned char name_assign_type,
2717 enum nl80211_iftype type, struct vif_params *params)
2718{
2719 int ret = 0;
2720 struct net_device* ndev = NULL;
2721 struct adapter *padapter = wiphy_to_adapter(wiphy);
2722
2723 DBG_871X(FUNC_ADPT_FMT " wiphy:%s, name:%s, type:%d\n",
2724 FUNC_ADPT_ARG(padapter), wiphy_name(wiphy), name, type);
2725
2726 switch (type) {
2727 case NL80211_IFTYPE_ADHOC:
2728 case NL80211_IFTYPE_AP_VLAN:
2729 case NL80211_IFTYPE_WDS:
2730 case NL80211_IFTYPE_MESH_POINT:
2731 ret = -ENODEV;
2732 break;
2733 case NL80211_IFTYPE_MONITOR:
2734 ret = rtw_cfg80211_add_monitor_if(padapter, (char *)name, &ndev);
2735 break;
2736 case NL80211_IFTYPE_P2P_CLIENT:
2737 case NL80211_IFTYPE_STATION:
2738 ret = -ENODEV;
2739 break;
2740 case NL80211_IFTYPE_P2P_GO:
2741 case NL80211_IFTYPE_AP:
2742 ret = -ENODEV;
2743 break;
2744 default:
2745 ret = -ENODEV;
2746 DBG_871X("Unsupported interface type\n");
2747 break;
2748 }
2749
2750 DBG_871X(FUNC_ADPT_FMT" ndev:%p, ret:%d\n", FUNC_ADPT_ARG(padapter), ndev, ret);
2751
2752 return ndev ? ndev->ieee80211_ptr : ERR_PTR(ret);
2753}
2754
2755static int cfg80211_rtw_del_virtual_intf(struct wiphy *wiphy,
2756 struct wireless_dev *wdev
2757)
2758{
2759 struct net_device *ndev = wdev_to_ndev(wdev);
2760 int ret = 0;
2761 struct adapter *adapter;
2762 struct rtw_wdev_priv *pwdev_priv;
2763
2764 if (!ndev) {
2765 ret = -EINVAL;
2766 goto exit;
2767 }
2768
2769 adapter = (struct adapter *)rtw_netdev_priv(ndev);
2770 pwdev_priv = adapter_wdev_data(adapter);
2771
2772 unregister_netdevice(ndev);
2773
2774 if (ndev == pwdev_priv->pmon_ndev) {
2775 pwdev_priv->pmon_ndev = NULL;
2776 pwdev_priv->ifname_mon[0] = '\0';
2777 DBG_871X(FUNC_NDEV_FMT" remove monitor interface\n", FUNC_NDEV_ARG(ndev));
2778 }
2779
2780exit:
2781 return ret;
2782}
2783
2784static int rtw_add_beacon(struct adapter *adapter, const u8 *head, size_t head_len, const u8 *tail, size_t tail_len)
2785{
2786 int ret = 0;
2787 u8 *pbuf = NULL;
2788 uint len, wps_ielen = 0;
2789 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
2790
2791 DBG_8192C("%s beacon_head_len =%zu, beacon_tail_len =%zu\n", __func__, head_len, tail_len);
2792
2793 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2794 return -EINVAL;
2795
2796 if (head_len<24)
2797 return -EINVAL;
2798
2799 pbuf = rtw_zmalloc(head_len+tail_len);
2800 if (!pbuf)
2801 return -ENOMEM;
2802
2803 memcpy(pbuf, (void *)head+24, head_len-24);
2804 memcpy(pbuf+head_len-24, (void *)tail, tail_len);
2805
2806 len = head_len+tail_len-24;
2807
2808
2809 if (rtw_get_wps_ie(pbuf+_FIXED_IE_LENGTH_, len-_FIXED_IE_LENGTH_, NULL, &wps_ielen))
2810 DBG_8192C("add bcn, wps_ielen =%d\n", wps_ielen);
2811
2812
2813 rtw_ies_remove_ie(pbuf, &len, _BEACON_IE_OFFSET_, _VENDOR_SPECIFIC_IE_, P2P_OUI, 4);
2814 rtw_ies_remove_ie(pbuf, &len, _BEACON_IE_OFFSET_, _VENDOR_SPECIFIC_IE_, WFD_OUI, 4);
2815
2816 if (rtw_check_beacon_data(adapter, pbuf, len) == _SUCCESS)
2817 {
2818 ret = 0;
2819 }
2820 else
2821 {
2822 ret = -EINVAL;
2823 }
2824
2825
2826 kfree(pbuf);
2827
2828 return ret;
2829}
2830
2831static int cfg80211_rtw_start_ap(struct wiphy *wiphy, struct net_device *ndev,
2832 struct cfg80211_ap_settings *settings)
2833{
2834 int ret = 0;
2835 struct adapter *adapter = (struct adapter *)rtw_netdev_priv(ndev);
2836
2837 DBG_871X(FUNC_NDEV_FMT" hidden_ssid:%d, auth_type:%d\n", FUNC_NDEV_ARG(ndev),
2838 settings->hidden_ssid, settings->auth_type);
2839
2840 ret = rtw_add_beacon(adapter, settings->beacon.head, settings->beacon.head_len,
2841 settings->beacon.tail, settings->beacon.tail_len);
2842
2843 adapter->mlmeextpriv.mlmext_info.hidden_ssid_mode = settings->hidden_ssid;
2844
2845 if (settings->ssid && settings->ssid_len) {
2846 struct wlan_bssid_ex *pbss_network = &adapter->mlmepriv.cur_network.network;
2847 struct wlan_bssid_ex *pbss_network_ext = &adapter->mlmeextpriv.mlmext_info.network;
2848
2849 memcpy(pbss_network->Ssid.Ssid, (void *)settings->ssid, settings->ssid_len);
2850 pbss_network->Ssid.SsidLength = settings->ssid_len;
2851 memcpy(pbss_network_ext->Ssid.Ssid, (void *)settings->ssid, settings->ssid_len);
2852 pbss_network_ext->Ssid.SsidLength = settings->ssid_len;
2853 }
2854
2855 return ret;
2856}
2857
2858static int cfg80211_rtw_change_beacon(struct wiphy *wiphy, struct net_device *ndev,
2859 struct cfg80211_beacon_data *info)
2860{
2861 int ret = 0;
2862 struct adapter *adapter = (struct adapter *)rtw_netdev_priv(ndev);
2863
2864 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2865
2866 ret = rtw_add_beacon(adapter, info->head, info->head_len, info->tail, info->tail_len);
2867
2868 return ret;
2869}
2870
2871static int cfg80211_rtw_stop_ap(struct wiphy *wiphy, struct net_device *ndev)
2872{
2873 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2874 return 0;
2875}
2876
2877static int cfg80211_rtw_add_station(struct wiphy *wiphy, struct net_device *ndev,
2878 const u8 *mac,
2879 struct station_parameters *params)
2880{
2881 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2882
2883 return 0;
2884}
2885
2886static int cfg80211_rtw_del_station(struct wiphy *wiphy, struct net_device *ndev,
2887 struct station_del_parameters *params)
2888{
2889 int ret = 0;
2890 struct list_head *phead, *plist;
2891 u8 updated = false;
2892 struct sta_info *psta = NULL;
2893 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
2894 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2895 struct sta_priv *pstapriv = &padapter->stapriv;
2896 const u8 *mac = params->mac;
2897
2898 DBG_871X("+"FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2899
2900 if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)) != true)
2901 {
2902 DBG_8192C("%s, fw_state != FW_LINKED|WIFI_AP_STATE\n", __func__);
2903 return -EINVAL;
2904 }
2905
2906
2907 if (!mac)
2908 {
2909 DBG_8192C("flush all sta, and cam_entry\n");
2910
2911 flush_all_cam_entry(padapter);
2912
2913 ret = rtw_sta_flush(padapter);
2914
2915 return ret;
2916 }
2917
2918
2919 DBG_8192C("free sta macaddr =" MAC_FMT "\n", MAC_ARG(mac));
2920
2921 if (mac[0] == 0xff && mac[1] == 0xff &&
2922 mac[2] == 0xff && mac[3] == 0xff &&
2923 mac[4] == 0xff && mac[5] == 0xff)
2924 {
2925 return -EINVAL;
2926 }
2927
2928
2929 spin_lock_bh(&pstapriv->asoc_list_lock);
2930
2931 phead = &pstapriv->asoc_list;
2932 plist = get_next(phead);
2933
2934
2935 while (phead != plist)
2936 {
2937 psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
2938
2939 plist = get_next(plist);
2940
2941 if (!memcmp((u8 *)mac, psta->hwaddr, ETH_ALEN))
2942 {
2943 if (psta->dot8021xalg == 1 && psta->bpairwise_key_installed == false)
2944 {
2945 DBG_8192C("%s, sta's dot8021xalg = 1 and key_installed = false\n", __func__);
2946 }
2947 else
2948 {
2949 DBG_8192C("free psta =%p, aid =%d\n", psta, psta->aid);
2950
2951 list_del_init(&psta->asoc_list);
2952 pstapriv->asoc_list_cnt--;
2953
2954 updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
2955
2956 psta = NULL;
2957
2958 break;
2959 }
2960
2961 }
2962
2963 }
2964
2965 spin_unlock_bh(&pstapriv->asoc_list_lock);
2966
2967 associated_clients_update(padapter, updated);
2968
2969 DBG_871X("-"FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2970
2971 return ret;
2972
2973}
2974
2975static int cfg80211_rtw_change_station(struct wiphy *wiphy, struct net_device *ndev,
2976 const u8 *mac, struct station_parameters *params)
2977{
2978 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2979
2980 return 0;
2981}
2982
2983static struct sta_info *rtw_sta_info_get_by_idx(const int idx, struct sta_priv *pstapriv)
2984
2985{
2986 struct list_head *phead, *plist;
2987 struct sta_info *psta = NULL;
2988 int i = 0;
2989
2990 phead = &pstapriv->asoc_list;
2991 plist = get_next(phead);
2992
2993
2994 while (phead != plist)
2995 {
2996 if (idx == i) psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
2997 plist = get_next(plist);
2998 i++;
2999 }
3000 return psta;
3001}
3002
3003static int cfg80211_rtw_dump_station(struct wiphy *wiphy, struct net_device *ndev,
3004 int idx, u8 *mac, struct station_info *sinfo)
3005{
3006
3007 int ret = 0;
3008 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(ndev);
3009 struct sta_info *psta = NULL;
3010 struct sta_priv *pstapriv = &padapter->stapriv;
3011 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
3012
3013 spin_lock_bh(&pstapriv->asoc_list_lock);
3014 psta = rtw_sta_info_get_by_idx(idx, pstapriv);
3015 spin_unlock_bh(&pstapriv->asoc_list_lock);
3016 if (NULL == psta)
3017 {
3018 DBG_871X("Station is not found\n");
3019 ret = -ENOENT;
3020 goto exit;
3021 }
3022 memcpy(mac, psta->hwaddr, ETH_ALEN);
3023 sinfo->filled = BIT(NL80211_STA_INFO_SIGNAL);
3024 sinfo->signal = psta->rssi;
3025
3026exit:
3027 return ret;
3028}
3029
3030static int cfg80211_rtw_change_bss(struct wiphy *wiphy, struct net_device *ndev,
3031 struct bss_parameters *params)
3032{
3033 DBG_871X(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
3034 return 0;
3035}
3036
3037void rtw_cfg80211_rx_action(struct adapter *adapter, u8 *frame, uint frame_len, const char*msg)
3038{
3039 s32 freq;
3040 int channel;
3041 u8 category, action;
3042
3043 channel = rtw_get_oper_ch(adapter);
3044
3045 rtw_action_frame_parse(frame, frame_len, &category, &action);
3046
3047 DBG_8192C("RTW_Rx:cur_ch =%d\n", channel);
3048 if (msg)
3049 DBG_871X("RTW_Rx:%s\n", msg);
3050 else
3051 DBG_871X("RTW_Rx:category(%u), action(%u)\n", category, action);
3052
3053 freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
3054
3055 rtw_cfg80211_rx_mgmt(adapter, freq, 0, frame, frame_len, GFP_ATOMIC);
3056}
3057
3058static int _cfg80211_rtw_mgmt_tx(struct adapter *padapter, u8 tx_ch, const u8 *buf, size_t len)
3059{
3060 struct xmit_frame *pmgntframe;
3061 struct pkt_attrib *pattrib;
3062 unsigned char *pframe;
3063 int ret = _FAIL;
3064 bool ack = true;
3065 struct ieee80211_hdr *pwlanhdr;
3066 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
3067 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
3068
3069 rtw_set_scan_deny(padapter, 1000);
3070
3071 rtw_scan_abort(padapter);
3072 if (tx_ch != rtw_get_oper_ch(padapter)) {
3073 if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED))
3074 pmlmeext->cur_channel = tx_ch;
3075 set_channel_bwmode(padapter, tx_ch, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3076 }
3077
3078
3079 if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
3080 {
3081
3082 ret = _FAIL;
3083 goto exit;
3084 }
3085
3086
3087 pattrib = &pmgntframe->attrib;
3088 update_mgntframe_attrib(padapter, pattrib);
3089 pattrib->retry_ctrl = false;
3090
3091 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
3092
3093 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
3094
3095 memcpy(pframe, (void*)buf, len);
3096 pattrib->pktlen = len;
3097
3098 pwlanhdr = (struct ieee80211_hdr *)pframe;
3099
3100 pmlmeext->mgnt_seq = GetSequence(pwlanhdr);
3101 pattrib->seqnum = pmlmeext->mgnt_seq;
3102 pmlmeext->mgnt_seq++;
3103
3104 pattrib->last_txcmdsz = pattrib->pktlen;
3105
3106 if (dump_mgntframe_and_wait_ack(padapter, pmgntframe) != _SUCCESS)
3107 {
3108 ack = false;
3109 ret = _FAIL;
3110
3111 #ifdef DEBUG_CFG80211
3112 DBG_8192C("%s, ack == _FAIL\n", __func__);
3113 #endif
3114 }
3115 else
3116 {
3117
3118 msleep(50);
3119
3120 #ifdef DEBUG_CFG80211
3121 DBG_8192C("%s, ack =%d, ok!\n", __func__, ack);
3122 #endif
3123 ret = _SUCCESS;
3124 }
3125
3126exit:
3127
3128 #ifdef DEBUG_CFG80211
3129 DBG_8192C("%s, ret =%d\n", __func__, ret);
3130 #endif
3131
3132 return ret;
3133
3134}
3135
3136static int cfg80211_rtw_mgmt_tx(struct wiphy *wiphy,
3137 struct wireless_dev *wdev,
3138 struct cfg80211_mgmt_tx_params *params,
3139 u64 *cookie)
3140{
3141 struct net_device *ndev = wdev_to_ndev(wdev);
3142 struct ieee80211_channel *chan = params->chan;
3143 const u8 *buf = params->buf;
3144 size_t len = params->len;
3145 int ret = 0;
3146 int tx_ret;
3147 u32 dump_limit = RTW_MAX_MGMT_TX_CNT;
3148 u32 dump_cnt = 0;
3149 bool ack = true;
3150 u8 tx_ch = (u8)ieee80211_frequency_to_channel(chan->center_freq);
3151 u8 category, action;
3152 int type = (-1);
3153 struct adapter *padapter;
3154 struct rtw_wdev_priv *pwdev_priv;
3155
3156 if (ndev == NULL) {
3157 ret = -EINVAL;
3158 goto exit;
3159 }
3160
3161 padapter = (struct adapter *)rtw_netdev_priv(ndev);
3162 pwdev_priv = adapter_wdev_data(padapter);
3163
3164
3165 *cookie = (unsigned long) buf;
3166
3167#ifdef DEBUG_CFG80211
3168 DBG_871X(FUNC_ADPT_FMT" len =%zu, ch =%d"
3169 "\n", FUNC_ADPT_ARG(padapter),
3170 len, tx_ch
3171 );
3172#endif
3173
3174
3175 rtw_cfg80211_mgmt_tx_status(padapter, *cookie, buf, len, ack, GFP_KERNEL);
3176
3177 if (rtw_action_frame_parse(buf, len, &category, &action) == false) {
3178 DBG_8192C(FUNC_ADPT_FMT" frame_control:0x%x\n", FUNC_ADPT_ARG(padapter),
3179 le16_to_cpu(((struct ieee80211_hdr_3addr *)buf)->frame_control));
3180 goto exit;
3181 }
3182
3183 DBG_8192C("RTW_Tx:tx_ch =%d, da ="MAC_FMT"\n", tx_ch, MAC_ARG(GetAddr1Ptr(buf)));
3184 if (category == RTW_WLAN_CATEGORY_PUBLIC)
3185 DBG_871X("RTW_Tx:%s\n", action_public_str(action));
3186 else
3187 DBG_871X("RTW_Tx:category(%u), action(%u)\n", category, action);
3188
3189 rtw_ps_deny(padapter, PS_DENY_MGNT_TX);
3190 if (_FAIL == rtw_pwr_wakeup(padapter)) {
3191 ret = -EFAULT;
3192 goto cancel_ps_deny;
3193 }
3194
3195 do {
3196 dump_cnt++;
3197 tx_ret = _cfg80211_rtw_mgmt_tx(padapter, tx_ch, buf, len);
3198 } while (dump_cnt < dump_limit && tx_ret != _SUCCESS);
3199
3200 if (tx_ret != _SUCCESS || dump_cnt > 1) {
3201 DBG_871X(FUNC_ADPT_FMT" %s (%d/%d)\n", FUNC_ADPT_ARG(padapter),
3202 tx_ret == _SUCCESS?"OK":"FAIL", dump_cnt, dump_limit);
3203 }
3204
3205 switch (type) {
3206 case P2P_GO_NEGO_CONF:
3207 rtw_clear_scan_deny(padapter);
3208 break;
3209 case P2P_INVIT_RESP:
3210 if (pwdev_priv->invit_info.flags & BIT(0)
3211 && pwdev_priv->invit_info.status == 0)
3212 {
3213 DBG_871X(FUNC_ADPT_FMT" agree with invitation of persistent group\n",
3214 FUNC_ADPT_ARG(padapter));
3215 rtw_set_scan_deny(padapter, 5000);
3216 rtw_pwr_wakeup_ex(padapter, 5000);
3217 rtw_clear_scan_deny(padapter);
3218 }
3219 break;
3220 }
3221
3222cancel_ps_deny:
3223 rtw_ps_deny_cancel(padapter, PS_DENY_MGNT_TX);
3224exit:
3225 return ret;
3226}
3227
3228static void cfg80211_rtw_mgmt_frame_register(struct wiphy *wiphy,
3229 struct wireless_dev *wdev,
3230 u16 frame_type, bool reg)
3231{
3232 struct net_device *ndev = wdev_to_ndev(wdev);
3233 struct adapter *adapter;
3234
3235 if (ndev == NULL)
3236 goto exit;
3237
3238 adapter = (struct adapter *)rtw_netdev_priv(ndev);
3239
3240#ifdef DEBUG_CFG80211
3241 DBG_871X(FUNC_ADPT_FMT" frame_type:%x, reg:%d\n", FUNC_ADPT_ARG(adapter),
3242 frame_type, reg);
3243#endif
3244
3245 if (frame_type != (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ))
3246 return;
3247exit:
3248 return;
3249}
3250
3251#if defined(CONFIG_PNO_SUPPORT)
3252static int cfg80211_rtw_sched_scan_start(struct wiphy *wiphy,
3253 struct net_device *dev,
3254 struct cfg80211_sched_scan_request *request) {
3255
3256 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
3257 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3258 u8 ret;
3259
3260 if (padapter->bup == false) {
3261 DBG_871X("%s: net device is down.\n", __func__);
3262 return -EIO;
3263 }
3264
3265 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true ||
3266 check_fwstate(pmlmepriv, _FW_LINKED) == true ||
3267 check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
3268 DBG_871X("%s: device is busy.\n", __func__);
3269 rtw_scan_abort(padapter);
3270 }
3271
3272 if (request == NULL) {
3273 DBG_871X("%s: invalid cfg80211_requests parameters.\n", __func__);
3274 return -EINVAL;
3275 }
3276
3277 ret = rtw_android_cfg80211_pno_setup(dev, request->ssids,
3278 request->n_ssids, request->interval);
3279
3280 if (ret < 0) {
3281 DBG_871X("%s ret: %d\n", __func__, ret);
3282 goto exit;
3283 }
3284
3285 ret = rtw_android_pno_enable(dev, true);
3286 if (ret < 0) {
3287 DBG_871X("%s ret: %d\n", __func__, ret);
3288 goto exit;
3289 }
3290exit:
3291 return ret;
3292}
3293
3294static int cfg80211_rtw_sched_scan_stop(struct wiphy *wiphy,
3295 struct net_device *dev) {
3296 return rtw_android_pno_enable(dev, false);
3297}
3298#endif
3299
3300static void rtw_cfg80211_init_ht_capab(struct ieee80211_sta_ht_cap *ht_cap, enum nl80211_band band, u8 rf_type)
3301{
3302
3303#define MAX_BIT_RATE_40MHZ_MCS15 300
3304#define MAX_BIT_RATE_40MHZ_MCS7 150
3305
3306 ht_cap->ht_supported = true;
3307
3308 ht_cap->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
3309 IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_SGI_20 |
3310 IEEE80211_HT_CAP_DSSSCCK40 | IEEE80211_HT_CAP_MAX_AMSDU;
3311
3312
3313
3314
3315
3316 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3317
3318
3319 ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
3320
3321 ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333 if (rf_type == RF_1T1R)
3334 {
3335 ht_cap->mcs.rx_mask[0] = 0xFF;
3336 ht_cap->mcs.rx_mask[1] = 0x00;
3337 ht_cap->mcs.rx_mask[4] = 0x01;
3338
3339 ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS7);
3340 }
3341 else if ((rf_type == RF_1T2R) || (rf_type ==RF_2T2R))
3342 {
3343 ht_cap->mcs.rx_mask[0] = 0xFF;
3344 ht_cap->mcs.rx_mask[1] = 0xFF;
3345 ht_cap->mcs.rx_mask[4] = 0x01;
3346
3347 ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS15);
3348 }
3349 else
3350 {
3351 DBG_8192C("%s, error rf_type =%d\n", __func__, rf_type);
3352 }
3353
3354}
3355
3356void rtw_cfg80211_init_wiphy(struct adapter *padapter)
3357{
3358 u8 rf_type;
3359 struct ieee80211_supported_band *bands;
3360 struct wireless_dev *pwdev = padapter->rtw_wdev;
3361 struct wiphy *wiphy = pwdev->wiphy;
3362
3363 rtw_hal_get_hwreg(padapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
3364
3365 DBG_8192C("%s:rf_type =%d\n", __func__, rf_type);
3366
3367 {
3368 bands = wiphy->bands[NL80211_BAND_2GHZ];
3369 if (bands)
3370 rtw_cfg80211_init_ht_capab(&bands->ht_cap, NL80211_BAND_2GHZ, rf_type);
3371 }
3372
3373
3374 rtw_regd_init(padapter, rtw_reg_notifier);
3375
3376
3377 memcpy(wiphy->perm_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
3378
3379}
3380
3381static void rtw_cfg80211_preinit_wiphy(struct adapter *padapter, struct wiphy *wiphy)
3382{
3383
3384 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
3385
3386 wiphy->max_scan_ssids = RTW_SSID_SCAN_AMOUNT;
3387 wiphy->max_scan_ie_len = RTW_SCAN_IE_LEN_MAX;
3388 wiphy->max_num_pmkids = RTW_MAX_NUM_PMKIDS;
3389
3390 wiphy->max_remain_on_channel_duration = RTW_MAX_REMAIN_ON_CHANNEL_DURATION;
3391
3392 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION)
3393 | BIT(NL80211_IFTYPE_ADHOC)
3394 | BIT(NL80211_IFTYPE_AP)
3395 | BIT(NL80211_IFTYPE_MONITOR)
3396 ;
3397
3398 wiphy->mgmt_stypes = rtw_cfg80211_default_mgmt_stypes;
3399
3400 wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR);
3401
3402 wiphy->cipher_suites = rtw_cipher_suites;
3403 wiphy->n_cipher_suites = ARRAY_SIZE(rtw_cipher_suites);
3404
3405
3406 wiphy->bands[NL80211_BAND_2GHZ] = rtw_spt_band_alloc(NL80211_BAND_2GHZ);
3407
3408 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3409 wiphy->flags |= WIPHY_FLAG_OFFCHAN_TX | WIPHY_FLAG_HAVE_AP_SME;
3410
3411#if defined(CONFIG_PM)
3412 wiphy->max_sched_scan_reqs = 1;
3413#ifdef CONFIG_PNO_SUPPORT
3414 wiphy->max_sched_scan_ssids = MAX_PNO_LIST_COUNT;
3415#endif
3416#endif
3417
3418#if defined(CONFIG_PM)
3419 wiphy->wowlan = &wowlan_stub;
3420#endif
3421
3422 if (padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE)
3423 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
3424 else
3425 wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
3426}
3427
3428static struct cfg80211_ops rtw_cfg80211_ops = {
3429 .change_virtual_intf = cfg80211_rtw_change_iface,
3430 .add_key = cfg80211_rtw_add_key,
3431 .get_key = cfg80211_rtw_get_key,
3432 .del_key = cfg80211_rtw_del_key,
3433 .set_default_key = cfg80211_rtw_set_default_key,
3434 .get_station = cfg80211_rtw_get_station,
3435 .scan = cfg80211_rtw_scan,
3436 .set_wiphy_params = cfg80211_rtw_set_wiphy_params,
3437 .connect = cfg80211_rtw_connect,
3438 .disconnect = cfg80211_rtw_disconnect,
3439 .join_ibss = cfg80211_rtw_join_ibss,
3440 .leave_ibss = cfg80211_rtw_leave_ibss,
3441 .set_tx_power = cfg80211_rtw_set_txpower,
3442 .get_tx_power = cfg80211_rtw_get_txpower,
3443 .set_power_mgmt = cfg80211_rtw_set_power_mgmt,
3444 .set_pmksa = cfg80211_rtw_set_pmksa,
3445 .del_pmksa = cfg80211_rtw_del_pmksa,
3446 .flush_pmksa = cfg80211_rtw_flush_pmksa,
3447
3448 .add_virtual_intf = cfg80211_rtw_add_virtual_intf,
3449 .del_virtual_intf = cfg80211_rtw_del_virtual_intf,
3450
3451 .start_ap = cfg80211_rtw_start_ap,
3452 .change_beacon = cfg80211_rtw_change_beacon,
3453 .stop_ap = cfg80211_rtw_stop_ap,
3454
3455 .add_station = cfg80211_rtw_add_station,
3456 .del_station = cfg80211_rtw_del_station,
3457 .change_station = cfg80211_rtw_change_station,
3458 .dump_station = cfg80211_rtw_dump_station,
3459 .change_bss = cfg80211_rtw_change_bss,
3460
3461 .mgmt_tx = cfg80211_rtw_mgmt_tx,
3462 .mgmt_frame_register = cfg80211_rtw_mgmt_frame_register,
3463
3464#if defined(CONFIG_PNO_SUPPORT)
3465 .sched_scan_start = cfg80211_rtw_sched_scan_start,
3466 .sched_scan_stop = cfg80211_rtw_sched_scan_stop,
3467#endif
3468};
3469
3470int rtw_wdev_alloc(struct adapter *padapter, struct device *dev)
3471{
3472 int ret = 0;
3473 struct wiphy *wiphy;
3474 struct wireless_dev *wdev;
3475 struct rtw_wdev_priv *pwdev_priv;
3476 struct net_device *pnetdev = padapter->pnetdev;
3477
3478 DBG_8192C("%s(padapter =%p)\n", __func__, padapter);
3479
3480
3481 wiphy = wiphy_new(&rtw_cfg80211_ops, sizeof(struct adapter *));
3482 if (!wiphy) {
3483 DBG_8192C("Couldn't allocate wiphy device\n");
3484 ret = -ENOMEM;
3485 goto exit;
3486 }
3487 set_wiphy_dev(wiphy, dev);
3488 *((struct adapter **)wiphy_priv(wiphy)) = padapter;
3489 rtw_cfg80211_preinit_wiphy(padapter, wiphy);
3490
3491 ret = wiphy_register(wiphy);
3492 if (ret < 0) {
3493 DBG_8192C("Couldn't register wiphy device\n");
3494 goto free_wiphy;
3495 }
3496
3497
3498 wdev = rtw_zmalloc(sizeof(struct wireless_dev));
3499 if (!wdev) {
3500 DBG_8192C("Couldn't allocate wireless device\n");
3501 ret = -ENOMEM;
3502 goto unregister_wiphy;
3503 }
3504 wdev->wiphy = wiphy;
3505 wdev->netdev = pnetdev;
3506
3507 wdev->iftype = NL80211_IFTYPE_STATION;
3508
3509
3510 padapter->rtw_wdev = wdev;
3511 pnetdev->ieee80211_ptr = wdev;
3512
3513
3514 pwdev_priv = adapter_wdev_data(padapter);
3515 pwdev_priv->rtw_wdev = wdev;
3516 pwdev_priv->pmon_ndev = NULL;
3517 pwdev_priv->ifname_mon[0] = '\0';
3518 pwdev_priv->padapter = padapter;
3519 pwdev_priv->scan_request = NULL;
3520 spin_lock_init(&pwdev_priv->scan_req_lock);
3521
3522 pwdev_priv->p2p_enabled = false;
3523 pwdev_priv->provdisc_req_issued = false;
3524 rtw_wdev_invit_info_init(&pwdev_priv->invit_info);
3525 rtw_wdev_nego_info_init(&pwdev_priv->nego_info);
3526
3527 pwdev_priv->bandroid_scan = false;
3528
3529 if (padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE)
3530 pwdev_priv->power_mgmt = true;
3531 else
3532 pwdev_priv->power_mgmt = false;
3533
3534 return ret;
3535
3536unregister_wiphy:
3537 wiphy_unregister(wiphy);
3538 free_wiphy:
3539 wiphy_free(wiphy);
3540exit:
3541 return ret;
3542
3543}
3544
3545void rtw_wdev_free(struct wireless_dev *wdev)
3546{
3547 DBG_8192C("%s(wdev =%p)\n", __func__, wdev);
3548
3549 if (!wdev)
3550 return;
3551
3552 rtw_spt_band_free(wdev->wiphy->bands[NL80211_BAND_2GHZ]);
3553
3554 wiphy_free(wdev->wiphy);
3555
3556 kfree((u8 *)wdev);
3557}
3558
3559void rtw_wdev_unregister(struct wireless_dev *wdev)
3560{
3561 struct net_device *ndev;
3562 struct adapter *adapter;
3563 struct rtw_wdev_priv *pwdev_priv;
3564
3565 DBG_8192C("%s(wdev =%p)\n", __func__, wdev);
3566
3567 if (!wdev)
3568 return;
3569
3570 if (!(ndev = wdev_to_ndev(wdev)))
3571 return;
3572
3573 adapter = (struct adapter *)rtw_netdev_priv(ndev);
3574 pwdev_priv = adapter_wdev_data(adapter);
3575
3576 rtw_cfg80211_indicate_scan_done(adapter, true);
3577
3578 if (pwdev_priv->pmon_ndev) {
3579 DBG_8192C("%s, unregister monitor interface\n", __func__);
3580 unregister_netdev(pwdev_priv->pmon_ndev);
3581 }
3582
3583 wiphy_unregister(wdev->wiphy);
3584}
3585
