1 /******************************************************************************
3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 ******************************************************************************/
15 #define _IOCTL_CFG80211_C_
17 #include <osdep_service.h>
18 #include <drv_types.h>
19 #include <xmit_osdep.h>
21 #include "ioctl_cfg80211.h"
23 #define RTW_MAX_MGMT_TX_CNT 8
25 #define RTW_MAX_REMAIN_ON_CHANNEL_DURATION 65535 /* ms */
26 #define RTW_MAX_NUM_PMKIDS 4
28 static const u32 rtw_cipher_suites[] = {
29 WLAN_CIPHER_SUITE_WEP40,
30 WLAN_CIPHER_SUITE_WEP104,
31 WLAN_CIPHER_SUITE_TKIP,
32 WLAN_CIPHER_SUITE_CCMP,
35 #define RATETAB_ENT(_rate, _rateid, _flags) { \
37 .hw_value = (_rateid), \
41 #define CHAN2G(_channel, _freq, _flags) { \
42 .band = IEEE80211_BAND_2GHZ, \
43 .center_freq = (_freq), \
44 .hw_value = (_channel), \
46 .max_antenna_gain = 0, \
50 #define CHAN5G(_channel, _flags) { \
51 .band = IEEE80211_BAND_5GHZ, \
52 .center_freq = 5000 + (5 * (_channel)), \
53 .hw_value = (_channel), \
55 .max_antenna_gain = 0, \
59 static struct ieee80211_rate rtw_rates[] = {
60 RATETAB_ENT(10, 0x1, 0),
61 RATETAB_ENT(20, 0x2, 0),
62 RATETAB_ENT(55, 0x4, 0),
63 RATETAB_ENT(110, 0x8, 0),
64 RATETAB_ENT(60, 0x10, 0),
65 RATETAB_ENT(90, 0x20, 0),
66 RATETAB_ENT(120, 0x40, 0),
67 RATETAB_ENT(180, 0x80, 0),
68 RATETAB_ENT(240, 0x100, 0),
69 RATETAB_ENT(360, 0x200, 0),
70 RATETAB_ENT(480, 0x400, 0),
71 RATETAB_ENT(540, 0x800, 0),
74 #define rtw_a_rates (rtw_rates + 4)
75 #define RTW_A_RATES_NUM 8
76 #define rtw_g_rates (rtw_rates + 0)
77 #define RTW_G_RATES_NUM 12
79 #define RTW_2G_CHANNELS_NUM 14
80 #define RTW_5G_CHANNELS_NUM 37
82 static struct ieee80211_channel rtw_2ghz_channels[] = {
99 static struct ieee80211_channel rtw_5ghz_a_channels[] = {
100 CHAN5G(34, 0), CHAN5G(36, 0),
101 CHAN5G(38, 0), CHAN5G(40, 0),
102 CHAN5G(42, 0), CHAN5G(44, 0),
103 CHAN5G(46, 0), CHAN5G(48, 0),
104 CHAN5G(52, 0), CHAN5G(56, 0),
105 CHAN5G(60, 0), CHAN5G(64, 0),
106 CHAN5G(100, 0), CHAN5G(104, 0),
107 CHAN5G(108, 0), CHAN5G(112, 0),
108 CHAN5G(116, 0), CHAN5G(120, 0),
109 CHAN5G(124, 0), CHAN5G(128, 0),
110 CHAN5G(132, 0), CHAN5G(136, 0),
111 CHAN5G(140, 0), CHAN5G(149, 0),
112 CHAN5G(153, 0), CHAN5G(157, 0),
113 CHAN5G(161, 0), CHAN5G(165, 0),
114 CHAN5G(184, 0), CHAN5G(188, 0),
115 CHAN5G(192, 0), CHAN5G(196, 0),
116 CHAN5G(200, 0), CHAN5G(204, 0),
117 CHAN5G(208, 0), CHAN5G(212, 0),
121 static void rtw_2g_channels_init(struct ieee80211_channel *channels)
123 memcpy((void *)channels, (void *)rtw_2ghz_channels,
124 sizeof(struct ieee80211_channel) * RTW_2G_CHANNELS_NUM);
127 static void rtw_5g_channels_init(struct ieee80211_channel *channels)
129 memcpy((void *)channels, (void *)rtw_5ghz_a_channels,
130 sizeof(struct ieee80211_channel) * RTW_5G_CHANNELS_NUM);
133 static void rtw_2g_rates_init(struct ieee80211_rate *rates)
135 memcpy(rates, rtw_g_rates,
136 sizeof(struct ieee80211_rate) * RTW_G_RATES_NUM);
139 static void rtw_5g_rates_init(struct ieee80211_rate *rates)
141 memcpy(rates, rtw_a_rates,
142 sizeof(struct ieee80211_rate) * RTW_A_RATES_NUM);
145 static struct ieee80211_supported_band *
146 rtw_spt_band_alloc(enum ieee80211_band band)
148 struct ieee80211_supported_band *spt_band = NULL;
149 int n_channels, n_bitrates;
151 if (band == IEEE80211_BAND_2GHZ) {
152 n_channels = RTW_2G_CHANNELS_NUM;
153 n_bitrates = RTW_G_RATES_NUM;
154 } else if (band == IEEE80211_BAND_5GHZ) {
155 n_channels = RTW_5G_CHANNELS_NUM;
156 n_bitrates = RTW_A_RATES_NUM;
160 spt_band = kzalloc(sizeof(struct ieee80211_supported_band) +
161 sizeof(struct ieee80211_channel) * n_channels +
162 sizeof(struct ieee80211_rate) * n_bitrates,
168 (struct ieee80211_channel *)(((u8 *) spt_band) +
170 ieee80211_supported_band));
172 (struct ieee80211_rate *)(((u8 *) spt_band->channels) +
173 sizeof(struct ieee80211_channel) *
175 spt_band->band = band;
176 spt_band->n_channels = n_channels;
177 spt_band->n_bitrates = n_bitrates;
179 if (band == IEEE80211_BAND_2GHZ) {
180 rtw_2g_channels_init(spt_band->channels);
181 rtw_2g_rates_init(spt_band->bitrates);
182 } else if (band == IEEE80211_BAND_5GHZ) {
183 rtw_5g_channels_init(spt_band->channels);
184 rtw_5g_rates_init(spt_band->bitrates);
187 /* spt_band.ht_cap */
193 static const struct ieee80211_txrx_stypes
194 rtw_cfg80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = {
195 [NL80211_IFTYPE_ADHOC] = {
197 .rx = BIT(IEEE80211_STYPE_ACTION >> 4)
199 [NL80211_IFTYPE_STATION] = {
201 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
202 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
204 [NL80211_IFTYPE_AP] = {
206 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
207 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
208 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
209 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
210 BIT(IEEE80211_STYPE_AUTH >> 4) |
211 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
212 BIT(IEEE80211_STYPE_ACTION >> 4)
214 [NL80211_IFTYPE_AP_VLAN] = {
217 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
218 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
219 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
220 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
221 BIT(IEEE80211_STYPE_AUTH >> 4) |
222 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
223 BIT(IEEE80211_STYPE_ACTION >> 4)
225 [NL80211_IFTYPE_P2P_CLIENT] = {
227 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
228 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
230 [NL80211_IFTYPE_P2P_GO] = {
232 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
233 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
234 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
235 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
236 BIT(IEEE80211_STYPE_AUTH >> 4) |
237 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
238 BIT(IEEE80211_STYPE_ACTION >> 4)
242 static int rtw_cfg80211_inform_bss(struct rtw_adapter *padapter,
243 struct wlan_network *pnetwork)
246 struct ieee80211_channel *notify_channel;
247 struct cfg80211_bss *bss;
253 struct wireless_dev *wdev = padapter->rtw_wdev;
254 struct wiphy *wiphy = wdev->wiphy;
255 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
257 channel = pnetwork->network.DSConfig;
258 if (channel <= RTW_CH_MAX_2G_CHANNEL)
259 freq = ieee80211_channel_to_frequency(channel,
260 IEEE80211_BAND_2GHZ);
262 freq = ieee80211_channel_to_frequency(channel,
263 IEEE80211_BAND_5GHZ);
265 notify_channel = ieee80211_get_channel(wiphy, freq);
267 notify_ie = pnetwork->network.IEs;
268 notify_ielen = pnetwork->network.IELength;
270 /* We've set wiphy's signal_type as CFG80211_SIGNAL_TYPE_MBM:
271 * signal strength in mBm (100*dBm)
273 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
274 is_same_network23a(&pmlmepriv->cur_network.network,
275 &pnetwork->network)) {
276 notify_signal = 100 * translate_percentage_to_dbm(padapter->recvpriv.signal_strength); /* dbm */
278 notify_signal = 100 * translate_percentage_to_dbm(
279 pnetwork->network.SignalStrength); /* dbm */
282 bss = cfg80211_inform_bss(wiphy, notify_channel,
283 CFG80211_BSS_FTYPE_UNKNOWN,
284 pnetwork->network.MacAddress,
285 pnetwork->network.tsf,
286 pnetwork->network.capability,
287 pnetwork->network.beacon_interval,
288 notify_ie, notify_ielen,
289 notify_signal, GFP_ATOMIC);
291 if (unlikely(!bss)) {
292 DBG_8723A("rtw_cfg80211_inform_bss error\n");
296 cfg80211_put_bss(wiphy, bss);
301 void rtw_cfg80211_indicate_connect(struct rtw_adapter *padapter)
303 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
304 struct wlan_network *cur_network = &pmlmepriv->cur_network;
305 struct wireless_dev *pwdev = padapter->rtw_wdev;
307 DBG_8723A("%s(padapter =%p)\n", __func__, padapter);
309 if (pwdev->iftype != NL80211_IFTYPE_STATION &&
310 pwdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
313 if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
316 if (padapter->mlmepriv.to_roaming > 0) {
317 struct wiphy *wiphy = pwdev->wiphy;
318 struct ieee80211_channel *notify_channel;
320 u16 channel = cur_network->network.DSConfig;
322 if (channel <= RTW_CH_MAX_2G_CHANNEL)
324 ieee80211_channel_to_frequency(channel,
325 IEEE80211_BAND_2GHZ);
328 ieee80211_channel_to_frequency(channel,
329 IEEE80211_BAND_5GHZ);
331 notify_channel = ieee80211_get_channel(wiphy, freq);
333 DBG_8723A("%s call cfg80211_roamed\n", __func__);
334 cfg80211_roamed(padapter->pnetdev, notify_channel,
335 cur_network->network.MacAddress,
336 pmlmepriv->assoc_req +
337 sizeof(struct ieee80211_hdr_3addr) + 2,
338 pmlmepriv->assoc_req_len -
339 sizeof(struct ieee80211_hdr_3addr) - 2,
340 pmlmepriv->assoc_rsp +
341 sizeof(struct ieee80211_hdr_3addr) + 6,
342 pmlmepriv->assoc_rsp_len -
343 sizeof(struct ieee80211_hdr_3addr) - 6,
346 cfg80211_connect_result(padapter->pnetdev,
347 cur_network->network.MacAddress,
348 pmlmepriv->assoc_req +
349 sizeof(struct ieee80211_hdr_3addr) + 2,
350 pmlmepriv->assoc_req_len -
351 sizeof(struct ieee80211_hdr_3addr) - 2,
352 pmlmepriv->assoc_rsp +
353 sizeof(struct ieee80211_hdr_3addr) + 6,
354 pmlmepriv->assoc_rsp_len -
355 sizeof(struct ieee80211_hdr_3addr) - 6,
356 WLAN_STATUS_SUCCESS, GFP_ATOMIC);
360 void rtw_cfg80211_indicate_disconnect(struct rtw_adapter *padapter)
362 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
363 struct wireless_dev *pwdev = padapter->rtw_wdev;
365 DBG_8723A("%s(padapter =%p)\n", __func__, padapter);
367 if (pwdev->iftype != NL80211_IFTYPE_STATION &&
368 pwdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
371 if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
374 if (!padapter->mlmepriv.not_indic_disco) {
375 if (check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING)) {
376 cfg80211_connect_result(padapter->pnetdev, NULL, NULL,
378 WLAN_STATUS_UNSPECIFIED_FAILURE,
381 cfg80211_disconnected(padapter->pnetdev, 0, NULL,
387 #ifdef CONFIG_8723AU_AP_MODE
388 static int set_pairwise_key(struct rtw_adapter *padapter, struct sta_info *psta)
390 struct cmd_obj *ph2c;
391 struct set_stakey_parm *psetstakey_para;
392 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
395 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
401 psetstakey_para = kzalloc(sizeof(struct set_stakey_parm), GFP_KERNEL);
402 if (psetstakey_para == NULL) {
408 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
410 psetstakey_para->algorithm = psta->dot118021XPrivacy;
412 ether_addr_copy(psetstakey_para->addr, psta->hwaddr);
414 memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16);
416 res = rtw_enqueue_cmd23a(pcmdpriv, ph2c);
422 static int set_group_key(struct rtw_adapter *padapter, struct key_params *parms,
425 struct cmd_obj *pcmd;
426 struct setkey_parm *psetkeyparm;
427 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
430 DBG_8723A("%s\n", __func__);
437 pcmd = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
442 psetkeyparm = kzalloc(sizeof(struct setkey_parm), GFP_KERNEL);
449 psetkeyparm->keyid = keyid;
451 padapter->mlmepriv.key_mask |= BIT(psetkeyparm->keyid);
453 psetkeyparm->algorithm = alg;
455 psetkeyparm->set_tx = 1;
457 memcpy(&psetkeyparm->key, parms->key, parms->key_len);
459 pcmd->cmdcode = _SetKey_CMD_;
460 pcmd->parmbuf = (u8 *) psetkeyparm;
461 pcmd->cmdsz = (sizeof(struct setkey_parm));
465 res = rtw_enqueue_cmd23a(pcmdpriv, pcmd);
471 static int rtw_cfg80211_ap_set_encryption(struct net_device *dev, u8 key_index,
472 int set_tx, const u8 *sta_addr,
473 struct key_params *keyparms)
476 struct sta_info *psta = NULL, *pbcmc_sta = NULL;
477 struct rtw_adapter *padapter = netdev_priv(dev);
478 struct security_priv *psecuritypriv = &padapter->securitypriv;
479 struct sta_priv *pstapriv = &padapter->stapriv;
481 DBG_8723A("%s\n", __func__);
483 if (!is_broadcast_ether_addr(sta_addr)) {
484 psta = rtw_get_stainfo23a(pstapriv, sta_addr);
487 DBG_8723A("rtw_set_encryption(), sta has already "
488 "been removed or never been added\n");
493 key_len = keyparms->key_len;
495 if (!psta && (keyparms->cipher == WLAN_CIPHER_SUITE_WEP40 ||
496 keyparms->cipher == WLAN_CIPHER_SUITE_WEP104)) {
497 DBG_8723A("r871x_set_encryption, crypt.alg = WEP\n");
499 DBG_8723A("r871x_set_encryption, wep_key_idx =%d, len =%d\n",
502 if (psecuritypriv->bWepDefaultKeyIdxSet == 0) {
503 /* wep default key has not been set, so use
504 this key index as default key. */
506 psecuritypriv->ndisencryptstatus =
507 Ndis802_11Encryption1Enabled;
508 psecuritypriv->dot11PrivacyAlgrthm = keyparms->cipher;
509 psecuritypriv->dot118021XGrpPrivacy = keyparms->cipher;
511 psecuritypriv->dot11PrivacyKeyIndex = key_index;
514 memcpy(&psecuritypriv->wep_key[key_index].key,
515 keyparms->key, key_len);
517 psecuritypriv->wep_key[key_index].keylen = key_len;
519 set_group_key(padapter, keyparms, keyparms->cipher, key_index);
524 if (!psta) { /* group key */
525 if (set_tx == 0) { /* group key */
526 if (keyparms->cipher == WLAN_CIPHER_SUITE_WEP40 ||
527 keyparms->cipher == WLAN_CIPHER_SUITE_WEP104) {
528 DBG_8723A("%s, set group_key, WEP\n", __func__);
530 memcpy(psecuritypriv->
531 dot118021XGrpKey[key_index].skey,
532 keyparms->key, key_len);
534 psecuritypriv->dot118021XGrpPrivacy =
536 } else if (keyparms->cipher == WLAN_CIPHER_SUITE_TKIP) {
537 DBG_8723A("%s, set group_key, TKIP\n",
540 psecuritypriv->dot118021XGrpPrivacy =
541 WLAN_CIPHER_SUITE_TKIP;
543 memcpy(psecuritypriv->
544 dot118021XGrpKey[key_index].skey,
546 (key_len > 16 ? 16 : key_len));
549 memcpy(psecuritypriv->
550 dot118021XGrptxmickey[key_index].skey,
551 &keyparms->key[16], 8);
552 memcpy(psecuritypriv->
553 dot118021XGrprxmickey[key_index].skey,
554 &keyparms->key[24], 8);
556 psecuritypriv->busetkipkey = 1;
558 } else if (keyparms->cipher == WLAN_CIPHER_SUITE_CCMP) {
559 DBG_8723A("%s, set group_key, CCMP\n",
562 psecuritypriv->dot118021XGrpPrivacy =
563 WLAN_CIPHER_SUITE_CCMP;
565 memcpy(psecuritypriv->
566 dot118021XGrpKey[key_index].skey,
568 (key_len > 16 ? 16 : key_len));
570 DBG_8723A("%s, set group_key, none\n",
573 psecuritypriv->dot118021XGrpPrivacy = 0;
576 psecuritypriv->dot118021XGrpKeyid = key_index;
578 psecuritypriv->binstallGrpkey = 1;
580 psecuritypriv->dot11PrivacyAlgrthm =
581 psecuritypriv->dot118021XGrpPrivacy;
583 set_group_key(padapter, keyparms,
584 psecuritypriv->dot118021XGrpPrivacy,
587 pbcmc_sta = rtw_get_bcmc_stainfo23a(padapter);
589 pbcmc_sta->ieee8021x_blocked = false;
590 /* rx will use bmc_sta's dot118021XPrivacy */
591 pbcmc_sta->dot118021XPrivacy =
592 psecuritypriv->dot118021XGrpPrivacy;
601 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) {
605 memcpy(psta->dot118021x_UncstKey.skey,
606 keyparms->key, (key_len > 16 ? 16 : key_len));
608 if (keyparms->cipher == WLAN_CIPHER_SUITE_WEP40 ||
609 keyparms->cipher == WLAN_CIPHER_SUITE_WEP104) {
610 DBG_8723A("%s, set pairwise key, WEP\n",
613 psecuritypriv->dot118021XGrpPrivacy =
615 } else if (keyparms->cipher == WLAN_CIPHER_SUITE_TKIP) {
616 DBG_8723A("%s, set pairwise key, TKIP\n",
619 psta->dot118021XPrivacy =
620 WLAN_CIPHER_SUITE_TKIP;
623 memcpy(psta->dot11tkiptxmickey.skey,
624 &keyparms->key[16], 8);
625 memcpy(psta->dot11tkiprxmickey.skey,
626 &keyparms->key[24], 8);
628 psecuritypriv->busetkipkey = 1;
630 } else if (keyparms->cipher == WLAN_CIPHER_SUITE_CCMP) {
631 DBG_8723A("%s, set pairwise key, CCMP\n",
634 psta->dot118021XPrivacy =
635 WLAN_CIPHER_SUITE_CCMP;
637 DBG_8723A("%s, set pairwise key, none\n",
640 psta->dot118021XPrivacy = 0;
643 set_pairwise_key(padapter, psta);
645 psta->ieee8021x_blocked = false;
647 psta->bpairwise_key_installed = true;
648 } else { /* group key??? */
649 if (keyparms->cipher == WLAN_CIPHER_SUITE_WEP40 ||
650 keyparms->cipher == WLAN_CIPHER_SUITE_WEP104) {
651 memcpy(psecuritypriv->
652 dot118021XGrpKey[key_index].skey,
653 keyparms->key, key_len);
655 psecuritypriv->dot118021XGrpPrivacy =
657 } else if (keyparms->cipher == WLAN_CIPHER_SUITE_TKIP) {
658 psecuritypriv->dot118021XGrpPrivacy =
659 WLAN_CIPHER_SUITE_TKIP;
661 memcpy(psecuritypriv->
662 dot118021XGrpKey[key_index].skey,
664 (key_len > 16 ? 16 : key_len));
667 memcpy(psecuritypriv->
668 dot118021XGrptxmickey[key_index].skey,
669 &keyparms->key[16], 8);
670 memcpy(psecuritypriv->
671 dot118021XGrprxmickey[key_index].skey,
672 &keyparms->key[24], 8);
674 psecuritypriv->busetkipkey = 1;
675 } else if (keyparms->cipher == WLAN_CIPHER_SUITE_CCMP) {
676 psecuritypriv->dot118021XGrpPrivacy =
677 WLAN_CIPHER_SUITE_CCMP;
679 memcpy(psecuritypriv->
680 dot118021XGrpKey[key_index].skey,
682 (key_len > 16 ? 16 : key_len));
684 psecuritypriv->dot118021XGrpPrivacy = 0;
687 psecuritypriv->dot118021XGrpKeyid = key_index;
689 psecuritypriv->binstallGrpkey = 1;
691 psecuritypriv->dot11PrivacyAlgrthm =
692 psecuritypriv->dot118021XGrpPrivacy;
694 set_group_key(padapter, keyparms,
695 psecuritypriv->dot118021XGrpPrivacy,
698 pbcmc_sta = rtw_get_bcmc_stainfo23a(padapter);
700 /* rx will use bmc_sta's
702 pbcmc_sta->ieee8021x_blocked = false;
703 pbcmc_sta->dot118021XPrivacy =
704 psecuritypriv->dot118021XGrpPrivacy;
715 static int rtw_cfg80211_set_encryption(struct net_device *dev, u8 key_index,
716 int set_tx, const u8 *sta_addr,
717 struct key_params *keyparms)
721 struct rtw_adapter *padapter = netdev_priv(dev);
722 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
723 struct security_priv *psecuritypriv = &padapter->securitypriv;
725 DBG_8723A("%s\n", __func__);
727 key_len = keyparms->key_len;
729 if (keyparms->cipher == WLAN_CIPHER_SUITE_WEP40 ||
730 keyparms->cipher == WLAN_CIPHER_SUITE_WEP104) {
731 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_,
732 ("wpa_set_encryption, crypt.alg = WEP\n"));
733 DBG_8723A("wpa_set_encryption, crypt.alg = WEP\n");
735 if (psecuritypriv->bWepDefaultKeyIdxSet == 0) {
736 /* wep default key has not been set, so use this
737 key index as default key. */
739 psecuritypriv->ndisencryptstatus =
740 Ndis802_11Encryption1Enabled;
741 psecuritypriv->dot11PrivacyAlgrthm = keyparms->cipher;
742 psecuritypriv->dot118021XGrpPrivacy = keyparms->cipher;
744 psecuritypriv->dot11PrivacyKeyIndex = key_index;
747 memcpy(&psecuritypriv->wep_key[key_index].key,
748 keyparms->key, key_len);
750 psecuritypriv->wep_key[key_index].keylen = key_len;
752 rtw_set_key23a(padapter, psecuritypriv, key_index, 0);
757 if (padapter->securitypriv.dot11AuthAlgrthm ==
758 dot11AuthAlgrthm_8021X) { /* 802_1x */
759 struct sta_info *psta, *pbcmc_sta;
760 struct sta_priv *pstapriv = &padapter->stapriv;
762 if (check_fwstate(pmlmepriv,
763 WIFI_STATION_STATE | WIFI_MP_STATE)) {
765 psta = rtw_get_stainfo23a(pstapriv, get_bssid(pmlmepriv));
767 DBG_8723A("%s, : Obtain Sta_info fail\n",
770 /* Jeff: don't disable ieee8021x_blocked
771 while clearing key */
772 if (keyparms->cipher != IW_AUTH_CIPHER_NONE &&
773 keyparms->cipher != 0)
774 psta->ieee8021x_blocked = false;
776 if ((padapter->securitypriv.ndisencryptstatus ==
777 Ndis802_11Encryption2Enabled) ||
778 (padapter->securitypriv.ndisencryptstatus ==
779 Ndis802_11Encryption3Enabled)) {
780 psta->dot118021XPrivacy =
781 padapter->securitypriv.
787 DBG_8723A("%s, : set_tx == 1\n",
790 memcpy(psta->dot118021x_UncstKey.skey,
792 (key_len > 16 ? 16 : key_len));
794 if (keyparms->cipher ==
795 WLAN_CIPHER_SUITE_TKIP) {
796 memcpy(psta->dot11tkiptxmickey.
798 &keyparms->key[16], 8);
799 memcpy(psta->dot11tkiprxmickey.
801 &keyparms->key[24], 8);
803 padapter->securitypriv.
806 DBG_8723A(" ~~~~set sta key:unicastkey\n");
808 rtw_setstakey_cmd23a(padapter,
809 (unsigned char *)psta,
811 } else { /* group key */
812 memcpy(padapter->securitypriv.
813 dot118021XGrpKey[key_index].skey,
815 (key_len > 16 ? 16 : key_len));
816 memcpy(padapter->securitypriv.
817 dot118021XGrptxmickey[key_index].
818 skey, &keyparms->key[16], 8);
819 memcpy(padapter->securitypriv.
820 dot118021XGrprxmickey[key_index].
821 skey, &keyparms->key[24], 8);
822 padapter->securitypriv.binstallGrpkey =
825 (" ~~~~set sta key:groupkey\n");
827 padapter->securitypriv.
828 dot118021XGrpKeyid = key_index;
830 rtw_set_key23a(padapter,
831 &padapter->securitypriv,
836 pbcmc_sta = rtw_get_bcmc_stainfo23a(padapter);
838 /* Jeff: don't disable ieee8021x_blocked
839 while clearing key */
840 if (keyparms->cipher != IW_AUTH_CIPHER_NONE &&
841 keyparms->cipher != 0)
842 pbcmc_sta->ieee8021x_blocked = false;
844 if ((padapter->securitypriv.ndisencryptstatus ==
845 Ndis802_11Encryption2Enabled) ||
846 (padapter->securitypriv.ndisencryptstatus ==
847 Ndis802_11Encryption3Enabled)) {
848 pbcmc_sta->dot118021XPrivacy =
849 padapter->securitypriv.
858 DBG_8723A("%s, ret =%d\n", __func__, ret);
865 static int cfg80211_rtw_add_key(struct wiphy *wiphy, struct net_device *ndev,
866 u8 key_index, bool pairwise,
867 const u8 *mac_addr, struct key_params *params)
870 struct wireless_dev *rtw_wdev = wiphy_to_wdev(wiphy);
871 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
872 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
873 u8 sta_addr[ETH_ALEN];
875 DBG_8723A("%s(%s): adding key for %pM\n", __func__, ndev->name,
877 DBG_8723A("cipher = 0x%x\n", params->cipher);
878 DBG_8723A("key_len = 0x%x\n", params->key_len);
879 DBG_8723A("seq_len = 0x%x\n", params->seq_len);
880 DBG_8723A("key_index =%d\n", key_index);
881 DBG_8723A("pairwise =%d\n", pairwise);
883 switch (params->cipher) {
884 case IW_AUTH_CIPHER_NONE:
885 case WLAN_CIPHER_SUITE_WEP40:
886 if (params->key_len != WLAN_KEY_LEN_WEP40) {
890 case WLAN_CIPHER_SUITE_WEP104:
891 if (params->key_len != WLAN_KEY_LEN_WEP104) {
895 case WLAN_CIPHER_SUITE_TKIP:
896 case WLAN_CIPHER_SUITE_CCMP:
903 if (key_index >= WEP_KEYS || params->key_len < 0) {
908 eth_broadcast_addr(sta_addr);
910 if (!mac_addr || is_broadcast_ether_addr(mac_addr))
911 set_tx = 0; /* for wpa/wpa2 group key */
913 set_tx = 1; /* for wpa/wpa2 pairwise key */
915 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
916 ret = rtw_cfg80211_set_encryption(ndev, key_index, set_tx,
918 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
919 #ifdef CONFIG_8723AU_AP_MODE
921 ether_addr_copy(sta_addr, mac_addr);
923 ret = rtw_cfg80211_ap_set_encryption(ndev, key_index, set_tx,
927 DBG_8723A("error! fw_state = 0x%x, iftype =%d\n",
928 pmlmepriv->fw_state, rtw_wdev->iftype);
937 cfg80211_rtw_get_key(struct wiphy *wiphy, struct net_device *ndev,
938 u8 key_index, bool pairwise, const u8 *mac_addr,
940 void (*callback) (void *cookie, struct key_params *))
942 DBG_8723A("%s(%s)\n", __func__, ndev->name);
946 static int cfg80211_rtw_del_key(struct wiphy *wiphy, struct net_device *ndev,
947 u8 key_index, bool pairwise,
950 struct rtw_adapter *padapter = netdev_priv(ndev);
951 struct security_priv *psecuritypriv = &padapter->securitypriv;
953 DBG_8723A("%s(%s): key_index =%d\n", __func__, ndev->name, key_index);
955 if (key_index == psecuritypriv->dot11PrivacyKeyIndex) {
956 /* clear the flag of wep default key set. */
957 psecuritypriv->bWepDefaultKeyIdxSet = 0;
963 static int cfg80211_rtw_set_default_key(struct wiphy *wiphy,
964 struct net_device *ndev, u8 key_index,
965 bool unicast, bool multicast)
967 struct rtw_adapter *padapter = netdev_priv(ndev);
968 struct security_priv *psecuritypriv = &padapter->securitypriv;
970 DBG_8723A("%s(%s): key_index =%d, unicast =%d, multicast =%d.\n",
971 __func__, ndev->name, key_index, unicast, multicast);
973 if (key_index < NUM_WEP_KEYS &&
974 (psecuritypriv->dot11PrivacyAlgrthm == WLAN_CIPHER_SUITE_WEP40 ||
975 psecuritypriv->dot11PrivacyAlgrthm == WLAN_CIPHER_SUITE_WEP104)) {
976 /* set wep default key */
977 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
979 psecuritypriv->dot11PrivacyKeyIndex = key_index;
981 psecuritypriv->dot11PrivacyAlgrthm = WLAN_CIPHER_SUITE_WEP40;
982 psecuritypriv->dot118021XGrpPrivacy = WLAN_CIPHER_SUITE_WEP40;
983 if (psecuritypriv->wep_key[key_index].keylen == 13) {
984 psecuritypriv->dot11PrivacyAlgrthm =
985 WLAN_CIPHER_SUITE_WEP104;
986 psecuritypriv->dot118021XGrpPrivacy =
987 WLAN_CIPHER_SUITE_WEP104;
990 /* set the flag to represent that wep default key
992 psecuritypriv->bWepDefaultKeyIdxSet = 1;
998 static u16 rtw_get_cur_max_rate(struct rtw_adapter *adapter)
1002 u16 rate = 0, max_rate = 0;
1003 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
1004 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
1005 struct registry_priv *pregistrypriv = &adapter->registrypriv;
1006 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1007 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
1008 struct ieee80211_ht_cap *pht_capie;
1010 u8 bw_40MHz = 0, short_GI_20 = 0, short_GI_40 = 0;
1013 p = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY,
1014 pcur_bss->IEs, pcur_bss->IELength);
1015 if (p && p[1] > 0) {
1016 pht_capie = (struct ieee80211_ht_cap *)(p + 2);
1018 memcpy(&mcs_rate, &pht_capie->mcs, 2);
1020 /* bw_40MHz = (pht_capie->cap_info&
1021 IEEE80211_HT_CAP_SUP_WIDTH_20_40) ? 1:0; */
1022 /* cur_bwmod is updated by beacon, pmlmeinfo is
1023 updated by association response */
1024 bw_40MHz = (pmlmeext->cur_bwmode &&
1025 (pmlmeinfo->HT_info.ht_param &
1026 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) ? 1:0;
1028 /* short_GI = (pht_capie->cap_info & (IEEE80211_HT_CAP
1029 _SGI_20|IEEE80211_HT_CAP_SGI_40)) ? 1 : 0; */
1030 short_GI_20 = (pmlmeinfo->ht_cap.cap_info &
1031 cpu_to_le16(IEEE80211_HT_CAP_SGI_20)) ? 1:0;
1032 short_GI_40 = (pmlmeinfo->ht_cap.cap_info &
1033 cpu_to_le16(IEEE80211_HT_CAP_SGI_40)) ? 1:0;
1035 rf_type = rtl8723a_get_rf_type(adapter);
1036 max_rate = rtw_mcs_rate23a(rf_type, bw_40MHz &
1037 pregistrypriv->cbw40_enable,
1038 short_GI_20, short_GI_40,
1039 &pmlmeinfo->ht_cap.mcs);
1041 while (pcur_bss->SupportedRates[i] != 0 &&
1042 pcur_bss->SupportedRates[i] != 0xFF) {
1043 rate = pcur_bss->SupportedRates[i] & 0x7F;
1049 max_rate = max_rate * 10 / 2;
1055 static int cfg80211_rtw_get_station(struct wiphy *wiphy,
1056 struct net_device *ndev,
1057 const u8 *mac, struct station_info *sinfo)
1060 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
1061 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1062 struct sta_info *psta = NULL;
1063 struct sta_priv *pstapriv = &padapter->stapriv;
1068 DBG_8723A("%s(%s): mac ==%p\n", __func__, ndev->name, mac);
1073 psta = rtw_get_stainfo23a(pstapriv, mac);
1075 DBG_8723A("%s, sta_info is null\n", __func__);
1079 DBG_8723A("%s(%s): mac =" MAC_FMT "\n", __func__, ndev->name,
1082 /* for infra./P2PClient mode */
1083 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) &&
1084 check_fwstate(pmlmepriv, _FW_LINKED)) {
1085 struct wlan_network *cur_network = &pmlmepriv->cur_network;
1087 if (!ether_addr_equal(mac, cur_network->network.MacAddress)) {
1088 DBG_8723A("%s, mismatch bssid =" MAC_FMT "\n", __func__,
1089 MAC_ARG(cur_network->network.MacAddress));
1094 sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
1095 sinfo->signal = translate_percentage_to_dbm(padapter->recvpriv.
1098 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BITRATE);
1099 sinfo->txrate.legacy = rtw_get_cur_max_rate(padapter);
1101 sinfo->filled |= BIT(NL80211_STA_INFO_RX_PACKETS);
1102 sinfo->rx_packets = sta_rx_data_pkts(psta);
1104 sinfo->filled |= BIT(NL80211_STA_INFO_TX_PACKETS);
1105 sinfo->tx_packets = psta->sta_stats.tx_pkts;
1108 /* for Ad-Hoc/AP mode */
1109 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) ||
1110 check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
1111 check_fwstate(pmlmepriv, WIFI_AP_STATE)) &&
1112 check_fwstate(pmlmepriv, _FW_LINKED)
1114 /* TODO: should acquire station info... */
1121 static int cfg80211_infrastructure_mode(struct rtw_adapter *padapter,
1122 enum nl80211_iftype ifmode)
1124 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1125 struct wlan_network *cur_network = &pmlmepriv->cur_network;
1126 enum nl80211_iftype old_mode;
1128 old_mode = cur_network->network.ifmode;
1130 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_notice_,
1131 ("+%s: old =%d new =%d fw_state = 0x%08x\n", __func__,
1132 old_mode, ifmode, get_fwstate(pmlmepriv)));
1134 if (old_mode != ifmode) {
1135 spin_lock_bh(&pmlmepriv->lock);
1137 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1140 if (old_mode == NL80211_IFTYPE_AP ||
1141 old_mode == NL80211_IFTYPE_P2P_GO) {
1142 /* change to other mode from Ndis802_11APMode */
1143 cur_network->join_res = -1;
1145 #ifdef CONFIG_8723AU_AP_MODE
1146 stop_ap_mode23a(padapter);
1150 if (check_fwstate(pmlmepriv, _FW_LINKED) ||
1151 old_mode == NL80211_IFTYPE_ADHOC)
1152 rtw_disassoc_cmd23a(padapter, 0, true);
1154 if (check_fwstate(pmlmepriv, _FW_LINKED) ||
1155 check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))
1156 rtw_free_assoc_resources23a(padapter, 1);
1158 if (old_mode == NL80211_IFTYPE_STATION ||
1159 old_mode == NL80211_IFTYPE_P2P_CLIENT ||
1160 old_mode == NL80211_IFTYPE_ADHOC) {
1161 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1162 /* will clr Linked_state; before this function,
1163 we must have chked whether issue
1164 dis-assoc_cmd or not */
1165 rtw_indicate_disconnect23a(padapter);
1169 cur_network->network.ifmode = ifmode;
1171 _clr_fwstate_(pmlmepriv, ~WIFI_NULL_STATE);
1174 case NL80211_IFTYPE_ADHOC:
1175 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
1178 case NL80211_IFTYPE_P2P_CLIENT:
1179 case NL80211_IFTYPE_STATION:
1180 set_fwstate(pmlmepriv, WIFI_STATION_STATE);
1183 case NL80211_IFTYPE_P2P_GO:
1184 case NL80211_IFTYPE_AP:
1185 set_fwstate(pmlmepriv, WIFI_AP_STATE);
1186 #ifdef CONFIG_8723AU_AP_MODE
1187 start_ap_mode23a(padapter);
1188 /* rtw_indicate_connect23a(padapter); */
1196 /* SecClearAllKeys(adapter); */
1198 /* RT_TRACE(COMP_OID_SET, DBG_LOUD,
1199 ("set_infrastructure: fw_state:%x after changing mode\n", */
1200 /* get_fwstate(pmlmepriv))); */
1202 spin_unlock_bh(&pmlmepriv->lock);
1208 static int cfg80211_rtw_change_iface(struct wiphy *wiphy,
1209 struct net_device *ndev,
1210 enum nl80211_iftype type, u32 *flags,
1211 struct vif_params *params)
1213 enum nl80211_iftype old_type;
1214 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
1215 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1216 struct wireless_dev *rtw_wdev = wiphy_to_wdev(wiphy);
1219 DBG_8723A("%s(%s): call netdev_open23a\n", __func__, ndev->name);
1221 old_type = rtw_wdev->iftype;
1222 DBG_8723A("%s(%s): old_iftype =%d, new_iftype =%d\n",
1223 __func__, ndev->name, old_type, type);
1225 if (old_type != type) {
1226 pmlmeext->action_public_rxseq = 0xffff;
1227 pmlmeext->action_public_dialog_token = 0xff;
1231 case NL80211_IFTYPE_ADHOC:
1232 case NL80211_IFTYPE_P2P_CLIENT:
1233 case NL80211_IFTYPE_STATION:
1234 case NL80211_IFTYPE_P2P_GO:
1235 case NL80211_IFTYPE_AP:
1236 case NL80211_IFTYPE_UNSPECIFIED:
1242 rtw_wdev->iftype = type;
1244 if (cfg80211_infrastructure_mode(padapter, type) != _SUCCESS) {
1245 rtw_wdev->iftype = old_type;
1250 rtw_setopmode_cmd23a(padapter, type);
1256 void rtw_cfg80211_indicate_scan_done(struct rtw_wdev_priv *pwdev_priv,
1259 spin_lock_bh(&pwdev_priv->scan_req_lock);
1260 if (pwdev_priv->scan_request != NULL) {
1261 DBG_8723A("%s with scan req\n", __func__);
1263 if (pwdev_priv->scan_request->wiphy !=
1264 pwdev_priv->rtw_wdev->wiphy)
1265 DBG_8723A("error wiphy compare\n");
1267 cfg80211_scan_done(pwdev_priv->scan_request, aborted);
1269 pwdev_priv->scan_request = NULL;
1271 DBG_8723A("%s without scan req\n", __func__);
1273 spin_unlock_bh(&pwdev_priv->scan_req_lock);
1276 void rtw_cfg80211_surveydone_event_callback(struct rtw_adapter *padapter)
1278 struct list_head *plist, *phead, *ptmp;
1279 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1280 struct rtw_queue *queue = &pmlmepriv->scanned_queue;
1281 struct wlan_network *pnetwork;
1283 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1285 phead = get_list_head(queue);
1287 list_for_each_safe(plist, ptmp, phead) {
1288 pnetwork = container_of(plist, struct wlan_network, list);
1290 /* report network only if the current channel set
1291 contains the channel to which this network belongs */
1292 if (rtw_ch_set_search_ch23a
1293 (padapter->mlmeextpriv.channel_set,
1294 pnetwork->network.DSConfig) >= 0)
1295 rtw_cfg80211_inform_bss(padapter, pnetwork);
1298 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1300 /* call this after other things have been done */
1301 rtw_cfg80211_indicate_scan_done(wdev_to_priv(padapter->rtw_wdev),
1305 static int rtw_cfg80211_set_probe_req_wpsp2pie(struct rtw_adapter *padapter,
1310 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1312 DBG_8723A("%s, ielen =%d\n", __func__, len);
1315 wps_ie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1316 WLAN_OUI_TYPE_MICROSOFT_WPS,
1319 DBG_8723A("probe_req_wps_ielen =%d\n", wps_ie[1]);
1321 if (pmlmepriv->wps_probe_req_ie) {
1322 pmlmepriv->wps_probe_req_ie_len = 0;
1323 kfree(pmlmepriv->wps_probe_req_ie);
1324 pmlmepriv->wps_probe_req_ie = NULL;
1327 pmlmepriv->wps_probe_req_ie = kmemdup(wps_ie, wps_ie[1],
1329 if (pmlmepriv->wps_probe_req_ie == NULL) {
1330 DBG_8723A("%s()-%d: kmalloc() ERROR!\n",
1331 __func__, __LINE__);
1334 pmlmepriv->wps_probe_req_ie_len = wps_ie[1];
1341 static int cfg80211_rtw_scan(struct wiphy *wiphy,
1342 struct cfg80211_scan_request *request)
1347 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
1348 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1349 struct cfg80211_ssid ssid[RTW_SSID_SCAN_AMOUNT];
1350 struct rtw_ieee80211_channel ch[RTW_CHANNEL_SCAN_AMOUNT];
1351 struct rtw_wdev_priv *pwdev_priv = wdev_to_priv(padapter->rtw_wdev);
1352 struct cfg80211_ssid *ssids = request->ssids;
1353 bool need_indicate_scan_done = false;
1355 DBG_8723A("%s(%s)\n", __func__, padapter->pnetdev->name);
1357 spin_lock_bh(&pwdev_priv->scan_req_lock);
1358 pwdev_priv->scan_request = request;
1359 spin_unlock_bh(&pwdev_priv->scan_req_lock);
1361 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1362 DBG_8723A("%s under WIFI_AP_STATE\n", __func__);
1363 /* need_indicate_scan_done = true; */
1364 /* goto check_need_indicate_scan_done; */
1367 if (rtw_pwr_wakeup(padapter) == _FAIL) {
1368 need_indicate_scan_done = true;
1369 goto check_need_indicate_scan_done;
1372 if (request->ie && request->ie_len > 0) {
1373 rtw_cfg80211_set_probe_req_wpsp2pie(padapter,
1378 if (pmlmepriv->LinkDetectInfo.bBusyTraffic == true) {
1379 DBG_8723A("%s, bBusyTraffic == true\n", __func__);
1380 need_indicate_scan_done = true;
1381 goto check_need_indicate_scan_done;
1383 if (rtw_is_scan_deny(padapter)) {
1384 DBG_8723A("%s(%s): scan deny\n", __func__,
1385 padapter->pnetdev->name);
1386 need_indicate_scan_done = true;
1387 goto check_need_indicate_scan_done;
1390 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING) ==
1392 DBG_8723A("%s, fwstate = 0x%x\n", __func__, pmlmepriv->fw_state);
1393 need_indicate_scan_done = true;
1394 goto check_need_indicate_scan_done;
1397 memset(ssid, 0, sizeof(struct cfg80211_ssid) * RTW_SSID_SCAN_AMOUNT);
1398 /* parsing request ssids, n_ssids */
1399 for (i = 0; i < request->n_ssids && i < RTW_SSID_SCAN_AMOUNT; i++) {
1400 DBG_8723A("ssid =%s, len =%d\n", ssids[i].ssid,
1402 memcpy(ssid[i].ssid, ssids[i].ssid, ssids[i].ssid_len);
1403 ssid[i].ssid_len = ssids[i].ssid_len;
1406 /* parsing channels, n_channels */
1408 sizeof(struct rtw_ieee80211_channel) * RTW_CHANNEL_SCAN_AMOUNT);
1410 if (request->n_channels == 1) {
1411 for (i = 0; i < request->n_channels &&
1412 i < RTW_CHANNEL_SCAN_AMOUNT; i++) {
1413 DBG_8723A("%s:(%s):" CHAN_FMT "\n",
1414 __func__, padapter->pnetdev->name,
1415 CHAN_ARG(request->channels[i]));
1416 ch[i].hw_value = request->channels[i]->hw_value;
1417 ch[i].flags = request->channels[i]->flags;
1421 spin_lock_bh(&pmlmepriv->lock);
1422 if (request->n_channels == 1) {
1423 memcpy(&ch[1], &ch[0], sizeof(struct rtw_ieee80211_channel));
1424 memcpy(&ch[2], &ch[0], sizeof(struct rtw_ieee80211_channel));
1425 _status = rtw_sitesurvey_cmd23a(padapter, ssid,
1426 RTW_SSID_SCAN_AMOUNT, ch, 3);
1428 _status = rtw_sitesurvey_cmd23a(padapter, ssid,
1429 RTW_SSID_SCAN_AMOUNT, NULL, 0);
1431 spin_unlock_bh(&pmlmepriv->lock);
1433 if (_status == false)
1436 check_need_indicate_scan_done:
1437 if (need_indicate_scan_done)
1438 rtw_cfg80211_surveydone_event_callback(padapter);
1442 static int cfg80211_rtw_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1444 DBG_8723A("%s\n", __func__);
1448 static int cfg80211_rtw_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
1449 struct cfg80211_ibss_params *params)
1451 DBG_8723A("%s(%s)\n", __func__, ndev->name);
1455 static int cfg80211_rtw_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
1457 DBG_8723A("%s(%s)\n", __func__, ndev->name);
1461 static int rtw_cfg80211_set_wpa_version(struct security_priv *psecuritypriv,
1464 DBG_8723A("%s, wpa_version =%d\n", __func__, wpa_version);
1467 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
1471 if (wpa_version & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
1472 psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPAPSK;
1475 if (wpa_version & NL80211_WPA_VERSION_2)
1477 psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPA2PSK;
1484 static int rtw_cfg80211_set_auth_type(struct security_priv *psecuritypriv,
1485 enum nl80211_auth_type sme_auth_type)
1487 DBG_8723A("%s, nl80211_auth_type =%d\n", __func__, sme_auth_type);
1489 switch (sme_auth_type) {
1490 case NL80211_AUTHTYPE_AUTOMATIC:
1491 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
1494 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1495 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1497 if (psecuritypriv->ndisauthtype > Ndis802_11AuthModeWPA)
1498 psecuritypriv->dot11AuthAlgrthm =
1499 dot11AuthAlgrthm_8021X;
1501 case NL80211_AUTHTYPE_SHARED_KEY:
1502 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
1504 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
1507 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1508 /* return -ENOTSUPP; */
1514 static int rtw_cfg80211_set_cipher(struct security_priv *psecuritypriv,
1515 u32 cipher, bool ucast)
1517 u32 ndisencryptstatus = Ndis802_11EncryptionDisabled;
1519 u32 *profile_cipher = ucast ? &psecuritypriv->dot11PrivacyAlgrthm :
1520 &psecuritypriv->dot118021XGrpPrivacy;
1522 DBG_8723A("%s, ucast =%d, cipher = 0x%x\n", __func__, ucast, cipher);
1525 *profile_cipher = 0;
1526 psecuritypriv->ndisencryptstatus = ndisencryptstatus;
1531 case IW_AUTH_CIPHER_NONE:
1532 *profile_cipher = 0;
1533 ndisencryptstatus = Ndis802_11EncryptionDisabled;
1535 case WLAN_CIPHER_SUITE_WEP40:
1536 *profile_cipher = WLAN_CIPHER_SUITE_WEP40;
1537 ndisencryptstatus = Ndis802_11Encryption1Enabled;
1539 case WLAN_CIPHER_SUITE_WEP104:
1540 *profile_cipher = WLAN_CIPHER_SUITE_WEP104;
1541 ndisencryptstatus = Ndis802_11Encryption1Enabled;
1543 case WLAN_CIPHER_SUITE_TKIP:
1544 *profile_cipher = WLAN_CIPHER_SUITE_TKIP;
1545 ndisencryptstatus = Ndis802_11Encryption2Enabled;
1547 case WLAN_CIPHER_SUITE_CCMP:
1548 *profile_cipher = WLAN_CIPHER_SUITE_CCMP;
1549 ndisencryptstatus = Ndis802_11Encryption3Enabled;
1552 DBG_8723A("Unsupported cipher: 0x%x\n", cipher);
1557 psecuritypriv->ndisencryptstatus = ndisencryptstatus;
1562 static int rtw_cfg80211_set_key_mgt(struct security_priv *psecuritypriv,
1565 DBG_8723A("%s, key_mgt = 0x%x\n", __func__, key_mgt);
1567 if (key_mgt == WLAN_AKM_SUITE_8021X)
1568 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
1569 else if (key_mgt == WLAN_AKM_SUITE_PSK)
1570 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
1572 DBG_8723A("Invalid key mgt: 0x%x\n", key_mgt);
1577 static int rtw_cfg80211_set_wpa_ie(struct rtw_adapter *padapter, const u8 *pie,
1581 int group_cipher = 0, pairwise_cipher = 0;
1583 const u8 *pwpa, *pwpa2;
1586 if (!pie || !ielen) {
1587 /* Treat this as normal case, but need to clear
1589 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
1592 if (ielen > MAX_WPA_IE_LEN + MAX_WPS_IE_LEN + MAX_P2P_IE_LEN) {
1598 DBG_8723A("set wpa_ie(length:%zu):\n", ielen);
1599 for (i = 0; i < ielen; i = i + 8)
1600 DBG_8723A("0x%.2x 0x%.2x 0x%.2x 0x%.2x "
1601 "0x%.2x 0x%.2x 0x%.2x 0x%.2x\n",
1602 pie[i], pie[i + 1], pie[i + 2], pie[i + 3],
1603 pie[i + 4], pie[i + 5], pie[i + 6], pie[i + 7]);
1604 if (ielen < RSN_HEADER_LEN) {
1605 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_,
1606 ("Ie len too short %d\n", (int)ielen));
1611 pwpa = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1612 WLAN_OUI_TYPE_MICROSOFT_WPA,
1614 if (pwpa && pwpa[1] > 0) {
1615 if (rtw_parse_wpa_ie23a(pwpa, pwpa[1] + 2, &group_cipher,
1616 &pairwise_cipher, NULL) == _SUCCESS) {
1617 padapter->securitypriv.dot11AuthAlgrthm =
1618 dot11AuthAlgrthm_8021X;
1619 padapter->securitypriv.ndisauthtype =
1620 Ndis802_11AuthModeWPAPSK;
1621 memcpy(padapter->securitypriv.supplicant_ie, pwpa,
1624 DBG_8723A("got wpa_ie, wpa_ielen:%u\n", pwpa[1]);
1628 pwpa2 = cfg80211_find_ie(WLAN_EID_RSN, pie, ielen);
1629 if (pwpa2 && pwpa2[1] > 0) {
1630 if (rtw_parse_wpa2_ie23a (pwpa2, pwpa2[1] + 2, &group_cipher,
1631 &pairwise_cipher, NULL) == _SUCCESS) {
1632 padapter->securitypriv.dot11AuthAlgrthm =
1633 dot11AuthAlgrthm_8021X;
1634 padapter->securitypriv.ndisauthtype =
1635 Ndis802_11AuthModeWPA2PSK;
1636 memcpy(padapter->securitypriv.supplicant_ie, pwpa2,
1639 DBG_8723A("got wpa2_ie, wpa2_ielen:%u\n", pwpa2[1]);
1643 if (group_cipher == 0) {
1644 group_cipher = WPA_CIPHER_NONE;
1646 if (pairwise_cipher == 0) {
1647 pairwise_cipher = WPA_CIPHER_NONE;
1650 switch (group_cipher) {
1651 case WPA_CIPHER_NONE:
1652 padapter->securitypriv.dot118021XGrpPrivacy = 0;
1653 padapter->securitypriv.ndisencryptstatus =
1654 Ndis802_11EncryptionDisabled;
1656 case WPA_CIPHER_WEP40:
1657 padapter->securitypriv.dot118021XGrpPrivacy = WLAN_CIPHER_SUITE_WEP40;
1658 padapter->securitypriv.ndisencryptstatus =
1659 Ndis802_11Encryption1Enabled;
1661 case WPA_CIPHER_TKIP:
1662 padapter->securitypriv.dot118021XGrpPrivacy = WLAN_CIPHER_SUITE_TKIP;
1663 padapter->securitypriv.ndisencryptstatus =
1664 Ndis802_11Encryption2Enabled;
1666 case WPA_CIPHER_CCMP:
1667 padapter->securitypriv.dot118021XGrpPrivacy = WLAN_CIPHER_SUITE_CCMP;
1668 padapter->securitypriv.ndisencryptstatus =
1669 Ndis802_11Encryption3Enabled;
1671 case WPA_CIPHER_WEP104:
1672 padapter->securitypriv.dot118021XGrpPrivacy = WLAN_CIPHER_SUITE_WEP104;
1673 padapter->securitypriv.ndisencryptstatus =
1674 Ndis802_11Encryption1Enabled;
1678 switch (pairwise_cipher) {
1679 case WPA_CIPHER_NONE:
1680 padapter->securitypriv.dot11PrivacyAlgrthm = 0;
1681 padapter->securitypriv.ndisencryptstatus =
1682 Ndis802_11EncryptionDisabled;
1684 case WPA_CIPHER_WEP40:
1685 padapter->securitypriv.dot11PrivacyAlgrthm = WLAN_CIPHER_SUITE_WEP40;
1686 padapter->securitypriv.ndisencryptstatus =
1687 Ndis802_11Encryption1Enabled;
1689 case WPA_CIPHER_TKIP:
1690 padapter->securitypriv.dot11PrivacyAlgrthm = WLAN_CIPHER_SUITE_TKIP;
1691 padapter->securitypriv.ndisencryptstatus =
1692 Ndis802_11Encryption2Enabled;
1694 case WPA_CIPHER_CCMP:
1695 padapter->securitypriv.dot11PrivacyAlgrthm = WLAN_CIPHER_SUITE_CCMP;
1696 padapter->securitypriv.ndisencryptstatus =
1697 Ndis802_11Encryption3Enabled;
1699 case WPA_CIPHER_WEP104:
1700 padapter->securitypriv.dot11PrivacyAlgrthm = WLAN_CIPHER_SUITE_WEP104;
1701 padapter->securitypriv.ndisencryptstatus =
1702 Ndis802_11Encryption1Enabled;
1706 wps_ie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1707 WLAN_OUI_TYPE_MICROSOFT_WPS,
1709 if (wps_ie && wps_ie[1] > 0) {
1710 DBG_8723A("got wps_ie, wps_ielen:%u\n", wps_ie[1]);
1711 padapter->securitypriv.wps_ie_len = wps_ie[1];
1712 memcpy(padapter->securitypriv.wps_ie, wps_ie,
1713 padapter->securitypriv.wps_ie_len);
1714 set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
1716 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
1719 /* TKIP and AES disallow multicast packets until installing group key */
1720 if (padapter->securitypriv.dot11PrivacyAlgrthm ==
1721 WLAN_CIPHER_SUITE_TKIP ||
1722 padapter->securitypriv.dot11PrivacyAlgrthm ==
1723 WLAN_CIPHER_SUITE_CCMP)
1724 /* WPS open need to enable multicast */
1725 /* check_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS) == true)*/
1726 rtl8723a_off_rcr_am(padapter);
1728 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1729 ("rtw_set_wpa_ie: pairwise_cipher = 0x%08x padapter->"
1730 "securitypriv.ndisencryptstatus =%d padapter->"
1731 "securitypriv.ndisauthtype =%d\n", pairwise_cipher,
1732 padapter->securitypriv.ndisencryptstatus,
1733 padapter->securitypriv.ndisauthtype));
1737 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
1741 static int rtw_cfg80211_add_wep(struct rtw_adapter *padapter,
1742 struct rtw_wep_key *wep, u8 keyid)
1745 struct security_priv *psecuritypriv = &padapter->securitypriv;
1747 if (keyid >= NUM_WEP_KEYS) {
1748 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
1749 ("%s:keyid>4 =>fail\n", __func__));
1754 switch (wep->keylen) {
1755 case WLAN_KEY_LEN_WEP40:
1756 psecuritypriv->dot11PrivacyAlgrthm = WLAN_CIPHER_SUITE_WEP40;
1757 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1758 ("%s:wep->KeyLength = 5\n", __func__));
1760 case WLAN_KEY_LEN_WEP104:
1761 psecuritypriv->dot11PrivacyAlgrthm = WLAN_CIPHER_SUITE_WEP104;
1762 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1763 ("%s:wep->KeyLength = 13\n", __func__));
1766 psecuritypriv->dot11PrivacyAlgrthm = 0;
1767 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1768 ("%s:wep->KeyLength!= 5 or 13\n", __func__));
1773 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1774 ("%s:before memcpy, wep->KeyLength = 0x%x keyid =%x\n",
1775 __func__, wep->keylen, keyid));
1777 memcpy(&psecuritypriv->wep_key[keyid], wep, sizeof(struct rtw_wep_key));
1779 psecuritypriv->dot11PrivacyKeyIndex = keyid;
1781 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1782 ("%s:security key material : "
1783 "%x %x %x %x %x %x %x %x %x %x %x %x %x\n", __func__,
1784 psecuritypriv->wep_key[keyid].key[0],
1785 psecuritypriv->wep_key[keyid].key[1],
1786 psecuritypriv->wep_key[keyid].key[2],
1787 psecuritypriv->wep_key[keyid].key[3],
1788 psecuritypriv->wep_key[keyid].key[4],
1789 psecuritypriv->wep_key[keyid].key[5],
1790 psecuritypriv->wep_key[keyid].key[6],
1791 psecuritypriv->wep_key[keyid].key[7],
1792 psecuritypriv->wep_key[keyid].key[8],
1793 psecuritypriv->wep_key[keyid].key[9],
1794 psecuritypriv->wep_key[keyid].key[10],
1795 psecuritypriv->wep_key[keyid].key[11],
1796 psecuritypriv->wep_key[keyid].key[12]));
1798 res = rtw_set_key23a(padapter, psecuritypriv, keyid, 1);
1805 static int rtw_set_ssid(struct rtw_adapter *padapter,
1806 struct wlan_network *newnetwork)
1808 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1809 struct wlan_network *pnetwork = &pmlmepriv->cur_network;
1810 int status = _SUCCESS;
1813 DBG_8723A_LEVEL(_drv_always_, "set ssid [%s] fw_state = 0x%08x\n",
1814 newnetwork->network.Ssid.ssid, get_fwstate(pmlmepriv));
1816 if (padapter->hw_init_completed == false) {
1817 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
1818 ("set_ssid: hw_init_completed == false =>exit!!!\n"));
1823 spin_lock_bh(&pmlmepriv->lock);
1825 DBG_8723A("Set SSID under fw_state = 0x%08x\n", get_fwstate(pmlmepriv));
1826 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
1827 goto handle_tkip_countermeasure;
1829 if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE)) {
1830 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1831 ("set_ssid: _FW_LINKED||WIFI_ADHOC_MASTER_STATE\n"));
1833 if (pmlmepriv->assoc_ssid.ssid_len ==
1834 newnetwork->network.Ssid.ssid_len &&
1835 !memcmp(&pmlmepriv->assoc_ssid.ssid,
1836 newnetwork->network.Ssid.ssid,
1837 newnetwork->network.Ssid.ssid_len)) {
1838 if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1839 RT_TRACE(_module_rtl871x_ioctl_set_c_,
1840 _drv_err_, ("New SSID is same SSID, "
1841 "fw_state = 0x%08x\n",
1842 get_fwstate(pmlmepriv)));
1844 if (rtw_is_same_ibss23a(padapter, pnetwork)) {
1846 * it means driver is in
1847 * WIFI_ADHOC_MASTER_STATE, we needn't
1850 goto release_mlme_lock;
1854 * if in WIFI_ADHOC_MASTER_STATE |
1855 * WIFI_ADHOC_STATE, create bss or
1858 rtw_disassoc_cmd23a(padapter, 0, true);
1860 if (check_fwstate(pmlmepriv, _FW_LINKED))
1861 rtw_indicate_disconnect23a(padapter);
1863 rtw_free_assoc_resources23a(padapter, 1);
1865 if (check_fwstate(pmlmepriv,
1866 WIFI_ADHOC_MASTER_STATE)) {
1867 _clr_fwstate_(pmlmepriv,
1868 WIFI_ADHOC_MASTER_STATE);
1869 set_fwstate(pmlmepriv,
1873 rtw_lps_ctrl_wk_cmd23a(padapter,
1874 LPS_CTRL_JOINBSS, 1);
1877 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1878 ("Set SSID not the same ssid\n"));
1879 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1880 ("set_ssid =[%s] len = 0x%x\n",
1881 newnetwork->network.Ssid.ssid,
1882 newnetwork->network.Ssid.ssid_len));
1883 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_info_,
1884 ("assoc_ssid =[%s] len = 0x%x\n",
1885 pmlmepriv->assoc_ssid.ssid,
1886 pmlmepriv->assoc_ssid.ssid_len));
1888 rtw_disassoc_cmd23a(padapter, 0, true);
1890 if (check_fwstate(pmlmepriv, _FW_LINKED))
1891 rtw_indicate_disconnect23a(padapter);
1893 rtw_free_assoc_resources23a(padapter, 1);
1895 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
1896 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
1897 set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
1902 handle_tkip_countermeasure:
1904 if (padapter->securitypriv.btkip_countermeasure == true) {
1908 padapter->securitypriv.btkip_countermeasure_time) >
1910 padapter->securitypriv.btkip_countermeasure = false;
1911 padapter->securitypriv.btkip_countermeasure_time = 0;
1914 goto release_mlme_lock;
1918 memcpy(&pmlmepriv->assoc_ssid, &newnetwork->network.Ssid,
1919 sizeof(struct cfg80211_ssid));
1921 pmlmepriv->assoc_by_bssid = false;
1923 pmlmepriv->to_join = true;
1925 if (!check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
1926 pmlmepriv->cur_network.join_res = -2;
1928 status = rtw_do_join_network(padapter, newnetwork);
1929 if (status == _SUCCESS) {
1930 pmlmepriv->to_join = false;
1932 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1933 /* switch to ADHOC_MASTER */
1934 status = rtw_do_join_adhoc(padapter);
1935 if (status != _SUCCESS)
1936 goto release_mlme_lock;
1938 /* can't associate ; reset under-linking */
1939 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1941 pmlmepriv->to_join = false;
1946 spin_unlock_bh(&pmlmepriv->lock);
1949 RT_TRACE(_module_rtl871x_ioctl_set_c_, _drv_err_,
1950 ("-%s: status =%d\n", __func__, status));
1955 static int cfg80211_rtw_connect(struct wiphy *wiphy, struct net_device *ndev,
1956 struct cfg80211_connect_params *sme)
1959 struct list_head *phead, *plist, *ptmp;
1960 struct wlan_network *pnetwork = NULL;
1961 /* u8 matched_by_bssid = false; */
1962 /* u8 matched_by_ssid = false; */
1964 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
1965 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1966 struct security_priv *psecuritypriv = &padapter->securitypriv;
1967 struct rtw_queue *queue = &pmlmepriv->scanned_queue;
1969 DBG_8723A("=>" "%s(%s)\n", __func__, ndev->name);
1970 DBG_8723A("privacy =%d, key =%p, key_len =%d, key_idx =%d\n",
1971 sme->privacy, sme->key, sme->key_len, sme->key_idx);
1973 if (_FAIL == rtw_pwr_wakeup(padapter)) {
1978 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1983 if (!sme->ssid || !sme->ssid_len ||
1984 sme->ssid_len > IEEE80211_MAX_SSID_LEN) {
1989 DBG_8723A("ssid =%s, len =%zu\n", sme->ssid, sme->ssid_len);
1992 DBG_8723A("bssid =" MAC_FMT "\n", MAC_ARG(sme->bssid));
1994 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
1996 DBG_8723A("%s, fw_state = 0x%x, goto exit\n", __func__,
1997 pmlmepriv->fw_state);
2000 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
2001 rtw_scan_abort23a(padapter);
2004 spin_lock_bh(&queue->lock);
2006 phead = get_list_head(queue);
2008 list_for_each_safe(plist, ptmp, phead) {
2009 pnetwork = container_of(plist, struct wlan_network, list);
2012 if (!ether_addr_equal(pnetwork->network.MacAddress,
2017 if (sme->ssid && sme->ssid_len) {
2018 if (pnetwork->network.Ssid.ssid_len != sme->ssid_len ||
2019 memcmp(pnetwork->network.Ssid.ssid, sme->ssid,
2025 if (ether_addr_equal(pnetwork->network.MacAddress,
2027 DBG_8723A("matched by bssid\n");
2032 } else if (sme->ssid && sme->ssid_len) {
2033 if (!memcmp(pnetwork->network.Ssid.ssid,
2034 sme->ssid, sme->ssid_len) &&
2035 pnetwork->network.Ssid.ssid_len == sme->ssid_len) {
2036 DBG_8723A("matched by ssid\n");
2044 spin_unlock_bh(&queue->lock);
2046 if (!matched || !pnetwork) {
2048 DBG_8723A("connect, matched == false, goto exit\n");
2052 if (cfg80211_infrastructure_mode(
2053 padapter, pnetwork->network.ifmode) != _SUCCESS) {
2058 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
2059 psecuritypriv->dot11PrivacyAlgrthm = 0;
2060 psecuritypriv->dot118021XGrpPrivacy = 0;
2061 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
2062 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
2064 ret = rtw_cfg80211_set_wpa_version(psecuritypriv,
2065 sme->crypto.wpa_versions);
2069 ret = rtw_cfg80211_set_auth_type(psecuritypriv, sme->auth_type);
2074 DBG_8723A("%s, ie_len =%zu\n", __func__, sme->ie_len);
2076 ret = rtw_cfg80211_set_wpa_ie(padapter, sme->ie, sme->ie_len);
2080 if (sme->crypto.n_ciphers_pairwise) {
2081 ret = rtw_cfg80211_set_cipher(psecuritypriv,
2082 sme->crypto.ciphers_pairwise[0],
2088 /* For WEP Shared auth */
2089 if ((psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_Shared ||
2090 psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_Auto) &&
2092 struct rtw_wep_key wep_key;
2093 u8 wep_key_idx, wep_key_len;
2094 DBG_8723A("%s(): Shared/Auto WEP\n", __func__);
2096 wep_key_idx = sme->key_idx;
2097 wep_key_len = sme->key_len;
2099 if (wep_key_idx > WEP_KEYS || !wep_key_len ||
2100 wep_key_len > WLAN_KEY_LEN_WEP104) {
2105 wep_key_len = wep_key_len <= 5 ? 5 : 13;
2107 memset(&wep_key, 0, sizeof(struct rtw_wep_key));
2109 wep_key.keylen = wep_key_len;
2111 if (wep_key_len == 13) {
2112 padapter->securitypriv.dot11PrivacyAlgrthm =
2113 WLAN_CIPHER_SUITE_WEP104;
2114 padapter->securitypriv.dot118021XGrpPrivacy =
2115 WLAN_CIPHER_SUITE_WEP104;
2117 padapter->securitypriv.dot11PrivacyAlgrthm =
2118 WLAN_CIPHER_SUITE_WEP40;
2119 padapter->securitypriv.dot118021XGrpPrivacy =
2120 WLAN_CIPHER_SUITE_WEP40;
2123 memcpy(wep_key.key, (void *)sme->key, wep_key.keylen);
2125 if (rtw_cfg80211_add_wep(padapter, &wep_key, wep_key_idx) !=
2133 ret = rtw_cfg80211_set_cipher(psecuritypriv,
2134 sme->crypto.cipher_group, false);
2138 if (sme->crypto.n_akm_suites) {
2139 ret = rtw_cfg80211_set_key_mgt(psecuritypriv,
2140 sme->crypto.akm_suites[0]);
2145 if (psecuritypriv->ndisauthtype > 3)
2146 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
2148 if (rtw_set_auth23a(padapter, psecuritypriv) != _SUCCESS) {
2153 /* rtw_set_802_11_encryption_mode(padapter,
2154 padapter->securitypriv.ndisencryptstatus); */
2156 if (rtw_set_ssid(padapter, pnetwork) != _SUCCESS) {
2161 DBG_8723A("set ssid:dot11AuthAlgrthm =%d, dot11PrivacyAlgrthm =%d, "
2162 "dot118021XGrpPrivacy =%d\n", psecuritypriv->dot11AuthAlgrthm,
2163 psecuritypriv->dot11PrivacyAlgrthm,
2164 psecuritypriv->dot118021XGrpPrivacy);
2168 DBG_8723A("<=%s, ret %d\n", __func__, ret);
2173 static int cfg80211_rtw_disconnect(struct wiphy *wiphy, struct net_device *ndev,
2176 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
2178 DBG_8723A("%s(%s)\n", __func__, ndev->name);
2180 rtw_set_roaming(padapter, 0);
2182 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
2183 rtw_scan_abort23a(padapter);
2184 LeaveAllPowerSaveMode23a(padapter);
2185 rtw_disassoc_cmd23a(padapter, 500, false);
2187 DBG_8723A("%s...call rtw_indicate_disconnect23a\n", __func__);
2189 padapter->mlmepriv.not_indic_disco = true;
2190 rtw_indicate_disconnect23a(padapter);
2191 padapter->mlmepriv.not_indic_disco = false;
2193 rtw_free_assoc_resources23a(padapter, 1);
2199 static int cfg80211_rtw_set_txpower(struct wiphy *wiphy,
2200 struct wireless_dev *wdev,
2201 enum nl80211_tx_power_setting type, int mbm)
2203 DBG_8723A("%s\n", __func__);
2207 static int cfg80211_rtw_get_txpower(struct wiphy *wiphy,
2208 struct wireless_dev *wdev, int *dbm)
2210 DBG_8723A("%s\n", __func__);
2215 inline bool rtw_cfg80211_pwr_mgmt(struct rtw_adapter *adapter)
2217 struct rtw_wdev_priv *rtw_wdev_priv = wdev_to_priv(adapter->rtw_wdev);
2218 return rtw_wdev_priv->power_mgmt;
2221 static int cfg80211_rtw_set_power_mgmt(struct wiphy *wiphy,
2222 struct net_device *ndev,
2223 bool enabled, int timeout)
2225 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
2226 struct rtw_wdev_priv *rtw_wdev_priv = wdev_to_priv(padapter->rtw_wdev);
2228 DBG_8723A("%s(%s): enabled:%u, timeout:%d\n",
2229 __func__, ndev->name, enabled, timeout);
2231 rtw_wdev_priv->power_mgmt = enabled;
2234 LPS_Leave23a(padapter);
2239 static int cfg80211_rtw_set_pmksa(struct wiphy *wiphy,
2240 struct net_device *netdev,
2241 struct cfg80211_pmksa *pmksa)
2243 u8 index, blInserted = false;
2244 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
2245 struct security_priv *psecuritypriv = &padapter->securitypriv;
2247 DBG_8723A("%s(%s)\n", __func__, netdev->name);
2249 if (is_zero_ether_addr(pmksa->bssid))
2254 /* overwrite PMKID */
2255 for (index = 0; index < NUM_PMKID_CACHE; index++) {
2256 if (ether_addr_equal(psecuritypriv->PMKIDList[index].Bssid,
2258 /* BSSID is matched, the same AP => rewrite with
2260 DBG_8723A("%s(%s): BSSID exists in the PMKList.\n",
2261 __func__, netdev->name);
2263 memcpy(psecuritypriv->PMKIDList[index].PMKID,
2264 pmksa->pmkid, WLAN_PMKID_LEN);
2265 psecuritypriv->PMKIDList[index].bUsed = true;
2266 psecuritypriv->PMKIDIndex = index + 1;
2273 /* Find a new entry */
2274 DBG_8723A("%s(%s): Use new entry index = %d for this PMKID\n",
2275 __func__, netdev->name, psecuritypriv->PMKIDIndex);
2278 psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].
2279 Bssid, pmksa->bssid);
2280 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].
2281 PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2283 psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].bUsed =
2285 psecuritypriv->PMKIDIndex++;
2286 if (psecuritypriv->PMKIDIndex == 16) {
2287 psecuritypriv->PMKIDIndex = 0;
2294 static int cfg80211_rtw_del_pmksa(struct wiphy *wiphy,
2295 struct net_device *netdev,
2296 struct cfg80211_pmksa *pmksa)
2298 u8 index, bMatched = false;
2299 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
2300 struct security_priv *psecuritypriv = &padapter->securitypriv;
2302 DBG_8723A("%s(%s)\n", __func__, netdev->name);
2304 for (index = 0; index < NUM_PMKID_CACHE; index++) {
2305 if (ether_addr_equal(psecuritypriv->PMKIDList[index].Bssid,
2307 /* BSSID is matched, the same AP => Remove this PMKID
2308 information and reset it. */
2309 eth_zero_addr(psecuritypriv->PMKIDList[index].Bssid);
2310 memset(psecuritypriv->PMKIDList[index].PMKID, 0x00,
2312 psecuritypriv->PMKIDList[index].bUsed = false;
2318 if (false == bMatched) {
2319 DBG_8723A("%s(%s): do not have matched BSSID\n", __func__,
2327 static int cfg80211_rtw_flush_pmksa(struct wiphy *wiphy,
2328 struct net_device *netdev)
2330 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
2331 struct security_priv *psecuritypriv = &padapter->securitypriv;
2333 DBG_8723A("%s(%s)\n", __func__, netdev->name);
2335 memset(&psecuritypriv->PMKIDList[0], 0x00,
2336 sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);
2337 psecuritypriv->PMKIDIndex = 0;
2342 #ifdef CONFIG_8723AU_AP_MODE
2343 void rtw_cfg80211_indicate_sta_assoc(struct rtw_adapter *padapter,
2344 u8 *pmgmt_frame, uint frame_len)
2348 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2349 struct net_device *ndev = padapter->pnetdev;
2351 DBG_8723A("%s(padapter =%p,%s)\n", __func__, padapter, ndev->name);
2353 #if defined(RTW_USE_CFG80211_STA_EVENT)
2355 struct station_info sinfo;
2358 if (ieee80211_is_assoc_req(hdr->frame_control))
2359 ie_offset = offsetof(struct ieee80211_mgmt,
2360 u.assoc_req.variable);
2361 else /* WIFI_REASSOCREQ */
2362 ie_offset = offsetof(struct ieee80211_mgmt,
2363 u.reassoc_req.variable);
2366 sinfo.assoc_req_ies = pmgmt_frame + ie_offset;
2367 sinfo.assoc_req_ies_len = frame_len - ie_offset;
2368 cfg80211_new_sta(ndev, hdr->addr2, &sinfo, GFP_ATOMIC);
2370 #else /* defined(RTW_USE_CFG80211_STA_EVENT) */
2371 channel = pmlmeext->cur_channel;
2372 if (channel <= RTW_CH_MAX_2G_CHANNEL)
2373 freq = ieee80211_channel_to_frequency(channel,
2374 IEEE80211_BAND_2GHZ);
2376 freq = ieee80211_channel_to_frequency(channel,
2377 IEEE80211_BAND_5GHZ);
2379 cfg80211_rx_mgmt(padapter->rtw_wdev, freq, 0, pmgmt_frame, frame_len,
2381 #endif /* defined(RTW_USE_CFG80211_STA_EVENT) */
2384 void rtw_cfg80211_indicate_sta_disassoc(struct rtw_adapter *padapter,
2386 unsigned short reason)
2391 struct ieee80211_mgmt mgmt;
2392 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2393 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2394 struct net_device *ndev = padapter->pnetdev;
2396 DBG_8723A("%s(padapter =%p,%s)\n", __func__, padapter, ndev->name);
2398 memset(&mgmt, 0, sizeof(struct ieee80211_mgmt));
2400 #if defined(RTW_USE_CFG80211_STA_EVENT)
2401 cfg80211_del_sta(ndev, da, GFP_ATOMIC);
2402 #else /* defined(RTW_USE_CFG80211_STA_EVENT) */
2403 channel = pmlmeext->cur_channel;
2404 if (channel <= RTW_CH_MAX_2G_CHANNEL)
2405 freq = ieee80211_channel_to_frequency(channel,
2406 IEEE80211_BAND_2GHZ);
2408 freq = ieee80211_channel_to_frequency(channel,
2409 IEEE80211_BAND_5GHZ);
2411 mgmt.frame_control =
2412 cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_DEAUTH);
2414 ether_addr_copy(mgmt.da, myid(&padapter->eeprompriv));
2415 ether_addr_copy(mgmt.sa, da);
2416 ether_addr_copy(mgmt.bssid, get_my_bssid23a(&pmlmeinfo->network));
2418 mgmt.seq_ctrl = cpu_to_le16(IEEE80211_SN_TO_SEQ(pmlmeext->mgnt_seq));
2419 pmlmeext->mgnt_seq++;
2421 mgmt.u.disassoc.reason_code = cpu_to_le16(reason);
2423 frame_len = sizeof(struct ieee80211_hdr_3addr) + 2;
2425 cfg80211_rx_mgmt(padapter->rtw_wdev, freq, 0, (u8 *)&mgmt, frame_len,
2427 #endif /* defined(RTW_USE_CFG80211_STA_EVENT) */
2430 static int rtw_cfg80211_monitor_if_open(struct net_device *ndev)
2432 DBG_8723A("%s\n", __func__);
2437 static int rtw_cfg80211_monitor_if_close(struct net_device *ndev)
2439 DBG_8723A("%s\n", __func__);
2444 static int rtw_cfg80211_monitor_if_xmit_entry(struct sk_buff *skb,
2445 struct net_device *ndev)
2450 int dot11_hdr_len = 24;
2452 unsigned char *pdata;
2453 unsigned char src_mac_addr[6];
2454 unsigned char dst_mac_addr[6];
2455 struct ieee80211_hdr *dot11_hdr;
2456 struct ieee80211_radiotap_header *rtap_hdr;
2457 struct rtw_adapter *padapter = netdev_priv(ndev);
2459 DBG_8723A("%s(%s)\n", __func__, ndev->name);
2461 if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
2464 rtap_hdr = (struct ieee80211_radiotap_header *)skb->data;
2465 if (unlikely(rtap_hdr->it_version))
2468 rtap_len = ieee80211_get_radiotap_len(skb->data);
2469 if (unlikely(skb->len < rtap_len))
2472 if (rtap_len != 14) {
2473 DBG_8723A("radiotap len (should be 14): %d\n", rtap_len);
2477 /* Skip the ratio tap header */
2478 skb_pull(skb, rtap_len);
2480 dot11_hdr = (struct ieee80211_hdr *)skb->data;
2481 /* Check if the QoS bit is set */
2482 if (ieee80211_is_data(dot11_hdr->frame_control)) {
2483 /* Check if this ia a Wireless Distribution System (WDS) frame
2484 * which has 4 MAC addresses
2486 if (ieee80211_is_data_qos(dot11_hdr->frame_control))
2487 qos_len = IEEE80211_QOS_CTL_LEN;
2488 if (ieee80211_has_a4(dot11_hdr->frame_control))
2491 memcpy(dst_mac_addr, dot11_hdr->addr1, sizeof(dst_mac_addr));
2492 memcpy(src_mac_addr, dot11_hdr->addr2, sizeof(src_mac_addr));
2495 * Skip the 802.11 header, QoS (if any) and SNAP,
2496 * but leave spaces for two MAC addresses
2498 skb_pull(skb, dot11_hdr_len + qos_len + snap_len -
2500 pdata = (unsigned char *)skb->data;
2501 ether_addr_copy(pdata, dst_mac_addr);
2502 ether_addr_copy(pdata + ETH_ALEN, src_mac_addr);
2504 DBG_8723A("should be eapol packet\n");
2506 /* Use the real net device to transmit the packet */
2507 ret = rtw_xmit23a_entry23a(skb, padapter->pnetdev);
2511 } else if (ieee80211_is_action(dot11_hdr->frame_control)) {
2512 struct ieee80211_mgmt *mgmt;
2513 /* only for action frames */
2514 struct xmit_frame *pmgntframe;
2515 struct pkt_attrib *pattrib;
2516 unsigned char *pframe;
2517 /* u8 category, action, OUI_Subtype, dialogToken = 0; */
2518 /* unsigned char *frame_body; */
2519 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2520 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2522 u8 category, action;
2524 mgmt = (struct ieee80211_mgmt *)dot11_hdr;
2526 DBG_8723A("RTW_Tx:da =" MAC_FMT " via %s(%s)\n",
2527 MAC_ARG(mgmt->da), __func__, ndev->name);
2528 category = mgmt->u.action.category;
2529 action = mgmt->u.action.u.wme_action.action_code;
2530 DBG_8723A("RTW_Tx:category(%u), action(%u)\n",
2533 /* starting alloc mgmt frame to dump it */
2534 pmgntframe = alloc_mgtxmitframe23a(pxmitpriv);
2535 if (pmgntframe == NULL)
2538 /* update attribute */
2539 pattrib = &pmgntframe->attrib;
2540 update_mgntframe_attrib23a(padapter, pattrib);
2541 pattrib->retry_ctrl = false;
2543 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
2545 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
2547 memcpy(pframe, skb->data, len);
2548 pattrib->pktlen = len;
2550 /* update seq number */
2551 pmlmeext->mgnt_seq = le16_to_cpu(dot11_hdr->seq_ctrl) >> 4;
2552 pattrib->seqnum = pmlmeext->mgnt_seq;
2553 pmlmeext->mgnt_seq++;
2555 pattrib->last_txcmdsz = pattrib->pktlen;
2557 dump_mgntframe23a(padapter, pmgntframe);
2568 rtw_cfg80211_monitor_if_set_mac_address(struct net_device *ndev, void *addr)
2570 DBG_8723A("%s\n", __func__);
2575 static const struct net_device_ops rtw_cfg80211_monitor_if_ops = {
2576 .ndo_open = rtw_cfg80211_monitor_if_open,
2577 .ndo_stop = rtw_cfg80211_monitor_if_close,
2578 .ndo_start_xmit = rtw_cfg80211_monitor_if_xmit_entry,
2579 .ndo_set_mac_address = rtw_cfg80211_monitor_if_set_mac_address,
2582 static int rtw_cfg80211_add_monitor_if(struct rtw_adapter *padapter, char *name,
2583 unsigned char name_assign_type,
2584 struct net_device **ndev)
2587 struct net_device *mon_ndev = NULL;
2588 struct wireless_dev *mon_wdev = NULL;
2589 struct rtw_wdev_priv *pwdev_priv = wdev_to_priv(padapter->rtw_wdev);
2592 DBG_8723A("%s(%s): without specific name\n",
2593 __func__, padapter->pnetdev->name);
2598 if (pwdev_priv->pmon_ndev) {
2599 DBG_8723A("%s(%s): monitor interface exist: %s\n", __func__,
2600 padapter->pnetdev->name, pwdev_priv->pmon_ndev->name);
2605 mon_ndev = alloc_etherdev(sizeof(struct rtw_adapter));
2607 DBG_8723A("%s(%s): allocate ndev fail\n", __func__,
2608 padapter->pnetdev->name);
2613 mon_ndev->type = ARPHRD_IEEE80211_RADIOTAP;
2614 strncpy(mon_ndev->name, name, IFNAMSIZ);
2615 mon_ndev->name[IFNAMSIZ - 1] = 0;
2616 mon_ndev->name_assign_type = name_assign_type;
2617 mon_ndev->destructor = rtw_ndev_destructor;
2619 mon_ndev->netdev_ops = &rtw_cfg80211_monitor_if_ops;
2622 mon_wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
2624 DBG_8723A("%s(%s): allocate mon_wdev fail\n", __func__,
2625 padapter->pnetdev->name);
2630 mon_wdev->wiphy = padapter->rtw_wdev->wiphy;
2631 mon_wdev->netdev = mon_ndev;
2632 mon_wdev->iftype = NL80211_IFTYPE_MONITOR;
2633 mon_ndev->ieee80211_ptr = mon_wdev;
2635 ret = register_netdevice(mon_ndev);
2640 *ndev = pwdev_priv->pmon_ndev = mon_ndev;
2641 memcpy(pwdev_priv->ifname_mon, name, IFNAMSIZ + 1);
2649 if (ret && mon_ndev) {
2650 free_netdev(mon_ndev);
2651 *ndev = mon_ndev = NULL;
2657 static struct wireless_dev *
2658 cfg80211_rtw_add_virtual_intf(struct wiphy *wiphy, const char *name,
2659 unsigned char name_assign_type,
2660 enum nl80211_iftype type, u32 *flags,
2661 struct vif_params *params)
2664 struct net_device *ndev = NULL;
2665 struct rtw_adapter *padapter = wiphy_to_adapter(wiphy);
2667 DBG_8723A("%s(%s): wiphy:%s, name:%s, type:%d\n", __func__,
2668 padapter->pnetdev->name, wiphy_name(wiphy), name, type);
2671 case NL80211_IFTYPE_ADHOC:
2672 case NL80211_IFTYPE_AP_VLAN:
2673 case NL80211_IFTYPE_WDS:
2674 case NL80211_IFTYPE_MESH_POINT:
2677 case NL80211_IFTYPE_MONITOR:
2679 rtw_cfg80211_add_monitor_if(padapter, (char *)name,
2680 name_assign_type, &ndev);
2683 case NL80211_IFTYPE_P2P_CLIENT:
2684 case NL80211_IFTYPE_STATION:
2688 case NL80211_IFTYPE_P2P_GO:
2689 case NL80211_IFTYPE_AP:
2694 DBG_8723A("Unsupported interface type\n");
2698 DBG_8723A("%s(%s): ndev:%p, ret:%d\n", __func__,
2699 padapter->pnetdev->name,
2702 return ndev ? ndev->ieee80211_ptr : ERR_PTR(ret);
2705 static int cfg80211_rtw_del_virtual_intf(struct wiphy *wiphy,
2706 struct wireless_dev *wdev)
2708 struct rtw_wdev_priv *pwdev_priv =
2709 (struct rtw_wdev_priv *)wiphy_priv(wiphy);
2710 struct net_device *ndev;
2711 ndev = wdev ? wdev->netdev : NULL;
2716 unregister_netdevice(ndev);
2718 if (ndev == pwdev_priv->pmon_ndev) {
2719 pwdev_priv->pmon_ndev = NULL;
2720 pwdev_priv->ifname_mon[0] = '\0';
2721 DBG_8723A("%s(%s): remove monitor interface\n",
2722 __func__, ndev->name);
2729 static int rtw_add_beacon(struct rtw_adapter *adapter, const u8 *head,
2730 size_t head_len, const u8 *tail, size_t tail_len)
2734 uint len, ielen, wps_ielen = 0;
2735 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
2736 struct wlan_bssid_ex *bss = &pmlmepriv->cur_network.network;
2737 const struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)head;
2738 struct ieee80211_mgmt *tmpmgmt;
2739 /* struct sta_priv *pstapriv = &padapter->stapriv; */
2741 DBG_8723A("%s beacon_head_len =%zu, beacon_tail_len =%zu\n",
2742 __func__, head_len, tail_len);
2744 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
2747 if (head_len < offsetof(struct ieee80211_mgmt, u.beacon.variable))
2750 pbuf = kzalloc(head_len + tail_len, GFP_KERNEL);
2753 tmpmgmt = (struct ieee80211_mgmt *)pbuf;
2755 bss->beacon_interval = get_unaligned_le16(&mgmt->u.beacon.beacon_int);
2756 bss->capability = get_unaligned_le16(&mgmt->u.beacon.capab_info);
2757 bss->tsf = get_unaligned_le64(&mgmt->u.beacon.timestamp);
2759 /* 24 = beacon header len. */
2760 memcpy(pbuf, (void *)head, head_len);
2761 memcpy(pbuf + head_len, (void *)tail, tail_len);
2763 len = head_len + tail_len;
2764 ielen = len - offsetof(struct ieee80211_mgmt, u.beacon.variable);
2765 /* check wps ie if inclued */
2766 if (cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
2767 WLAN_OUI_TYPE_MICROSOFT_WPS,
2768 tmpmgmt->u.beacon.variable, ielen))
2769 DBG_8723A("add bcn, wps_ielen =%d\n", wps_ielen);
2771 /* pbss_network->IEs will not include p2p_ie, wfd ie */
2772 rtw_ies_remove_ie23a(tmpmgmt->u.beacon.variable, &ielen, 0,
2773 WLAN_EID_VENDOR_SPECIFIC, P2P_OUI23A, 4);
2774 rtw_ies_remove_ie23a(tmpmgmt->u.beacon.variable, &ielen, 0,
2775 WLAN_EID_VENDOR_SPECIFIC, WFD_OUI23A, 4);
2777 len = ielen + offsetof(struct ieee80211_mgmt, u.beacon.variable);
2778 if (rtw_check_beacon_data23a(adapter, tmpmgmt, len) == _SUCCESS) {
2789 static int cfg80211_rtw_start_ap(struct wiphy *wiphy, struct net_device *ndev,
2790 struct cfg80211_ap_settings *settings)
2793 struct rtw_adapter *adapter = wiphy_to_adapter(wiphy);
2795 DBG_8723A("%s(%s): hidden_ssid:%d, auth_type:%d\n",
2796 __func__, ndev->name, settings->hidden_ssid,
2797 settings->auth_type);
2799 ret = rtw_add_beacon(adapter, settings->beacon.head,
2800 settings->beacon.head_len, settings->beacon.tail,
2801 settings->beacon.tail_len);
2803 adapter->mlmeextpriv.mlmext_info.hidden_ssid_mode =
2804 settings->hidden_ssid;
2806 if (settings->ssid && settings->ssid_len) {
2807 struct wlan_bssid_ex *pbss_network =
2808 &adapter->mlmepriv.cur_network.network;
2809 struct wlan_bssid_ex *pbss_network_ext =
2810 &adapter->mlmeextpriv.mlmext_info.network;
2812 memcpy(pbss_network->Ssid.ssid, (void *)settings->ssid,
2813 settings->ssid_len);
2814 pbss_network->Ssid.ssid_len = settings->ssid_len;
2815 memcpy(pbss_network_ext->Ssid.ssid, (void *)settings->ssid,
2816 settings->ssid_len);
2817 pbss_network_ext->Ssid.ssid_len = settings->ssid_len;
2823 static int cfg80211_rtw_change_beacon(struct wiphy *wiphy,
2824 struct net_device *ndev,
2825 struct cfg80211_beacon_data *info)
2828 struct rtw_adapter *adapter = wiphy_to_adapter(wiphy);
2830 DBG_8723A("%s(%s)\n", __func__, ndev->name);
2832 ret = rtw_add_beacon(adapter, info->head, info->head_len, info->tail,
2838 static int cfg80211_rtw_stop_ap(struct wiphy *wiphy, struct net_device *ndev)
2840 DBG_8723A("%s(%s)\n", __func__, ndev->name);
2844 static int cfg80211_rtw_add_station(struct wiphy *wiphy,
2845 struct net_device *ndev, const u8 *mac,
2846 struct station_parameters *params)
2848 DBG_8723A("%s(%s)\n", __func__, ndev->name);
2853 static int cfg80211_rtw_del_station(struct wiphy *wiphy,
2854 struct net_device *ndev,
2855 struct station_del_parameters *params)
2857 const u8 *mac = params->mac;
2859 struct list_head *phead, *plist, *ptmp;
2861 struct sta_info *psta;
2862 struct rtw_adapter *padapter = netdev_priv(ndev);
2863 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2864 struct sta_priv *pstapriv = &padapter->stapriv;
2866 DBG_8723A("+%s(%s)\n", __func__, ndev->name);
2868 if (check_fwstate(pmlmepriv, (_FW_LINKED | WIFI_AP_STATE)) != true) {
2869 DBG_8723A("%s, fw_state != FW_LINKED|WIFI_AP_STATE\n",
2875 DBG_8723A("flush all sta, and cam_entry\n");
2877 flush_all_cam_entry23a(padapter); /* clear CAM */
2879 ret = rtw_sta_flush23a(padapter);
2884 DBG_8723A("free sta macaddr =" MAC_FMT "\n", MAC_ARG(mac));
2886 if (is_broadcast_ether_addr(mac))
2889 spin_lock_bh(&pstapriv->asoc_list_lock);
2891 phead = &pstapriv->asoc_list;
2893 /* check asoc_queue */
2894 list_for_each_safe(plist, ptmp, phead) {
2895 psta = container_of(plist, struct sta_info, asoc_list);
2897 if (ether_addr_equal(mac, psta->hwaddr)) {
2898 if (psta->dot8021xalg == 1 &&
2899 psta->bpairwise_key_installed == false) {
2900 DBG_8723A("%s, sta's dot8021xalg = 1 and "
2901 "key_installed = false\n", __func__);
2903 DBG_8723A("free psta =%p, aid =%d\n", psta,
2906 list_del_init(&psta->asoc_list);
2907 pstapriv->asoc_list_cnt--;
2909 /* spin_unlock_bh(&pstapriv->asoc_list_lock); */
2911 ap_free_sta23a(padapter, psta, true,
2912 WLAN_REASON_DEAUTH_LEAVING);
2913 /* spin_lock_bh(&pstapriv->asoc_list_lock); */
2922 spin_unlock_bh(&pstapriv->asoc_list_lock);
2924 associated_clients_update23a(padapter, updated);
2926 DBG_8723A("-%s(%s)\n", __func__, ndev->name);
2931 static int cfg80211_rtw_change_station(struct wiphy *wiphy,
2932 struct net_device *ndev, const u8 *mac,
2933 struct station_parameters *params)
2935 DBG_8723A("%s(%s)\n", __func__, ndev->name);
2939 static int cfg80211_rtw_dump_station(struct wiphy *wiphy,
2940 struct net_device *ndev, int idx, u8 *mac,
2941 struct station_info *sinfo)
2943 DBG_8723A("%s(%s)\n", __func__, ndev->name);
2945 /* TODO: dump scanned queue */
2950 static int cfg80211_rtw_change_bss(struct wiphy *wiphy, struct net_device *ndev,
2951 struct bss_parameters *params)
2953 DBG_8723A("%s(%s)\n", __func__, ndev->name);
2956 #endif /* CONFIG_8723AU_AP_MODE */
2958 static int _cfg80211_rtw_mgmt_tx(struct rtw_adapter *padapter, u8 tx_ch,
2959 const u8 *buf, size_t len)
2961 struct xmit_frame *pmgntframe;
2962 struct pkt_attrib *pattrib;
2963 unsigned char *pframe;
2965 struct ieee80211_hdr *pwlanhdr;
2966 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2967 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2969 if (_FAIL == rtw_pwr_wakeup(padapter)) {
2974 rtw_set_scan_deny(padapter, 1000);
2976 rtw_scan_abort23a(padapter);
2978 if (tx_ch != rtw_get_oper_ch23a(padapter)) {
2979 if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED))
2980 pmlmeext->cur_channel = tx_ch;
2981 set_channel_bwmode23a(padapter, tx_ch,
2982 HAL_PRIME_CHNL_OFFSET_DONT_CARE,
2983 HT_CHANNEL_WIDTH_20);
2986 /* starting alloc mgmt frame to dump it */
2987 pmgntframe = alloc_mgtxmitframe23a(pxmitpriv);
2989 /* ret = -ENOMEM; */
2994 /* update attribute */
2995 pattrib = &pmgntframe->attrib;
2996 update_mgntframe_attrib23a(padapter, pattrib);
2997 pattrib->retry_ctrl = false;
2999 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
3001 pframe = (u8 *) (pmgntframe->buf_addr) + TXDESC_OFFSET;
3003 memcpy(pframe, (void *)buf, len);
3004 pattrib->pktlen = len;
3006 pwlanhdr = (struct ieee80211_hdr *)pframe;
3007 /* update seq number */
3008 pmlmeext->mgnt_seq = le16_to_cpu(pwlanhdr->seq_ctrl) >> 4;
3009 pattrib->seqnum = pmlmeext->mgnt_seq;
3010 pmlmeext->mgnt_seq++;
3012 pattrib->last_txcmdsz = pattrib->pktlen;
3014 ret = dump_mgntframe23a_and_wait_ack23a(padapter, pmgntframe);
3016 if (ret != _SUCCESS)
3017 DBG_8723A("%s, ack == false\n", __func__);
3019 DBG_8723A("%s, ack == true\n", __func__);
3023 DBG_8723A("%s, ret =%d\n", __func__, ret);
3028 static int cfg80211_rtw_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
3029 struct cfg80211_mgmt_tx_params *params,
3032 struct rtw_adapter *padapter =
3033 (struct rtw_adapter *)wiphy_to_adapter(wiphy);
3036 u32 dump_limit = RTW_MAX_MGMT_TX_CNT;
3039 u8 category, action;
3040 unsigned long start = jiffies;
3041 size_t len = params->len;
3042 struct ieee80211_channel *chan = params->chan;
3043 const u8 *buf = params->buf;
3044 struct ieee80211_mgmt *hdr = (struct ieee80211_mgmt *)buf;
3045 u8 tx_ch = (u8) ieee80211_frequency_to_channel(chan->center_freq);
3047 if (!ieee80211_is_action(hdr->frame_control))
3050 /* cookie generation */
3051 *cookie = (unsigned long)buf;
3053 DBG_8723A("%s(%s): len =%zu, ch =%d\n", __func__,
3054 padapter->pnetdev->name, len, tx_ch);
3056 /* indicate ack before issue frame to avoid racing with rsp frame */
3057 cfg80211_mgmt_tx_status(padapter->rtw_wdev, *cookie, buf, len, ack,
3060 DBG_8723A("RTW_Tx:tx_ch =%d, da =" MAC_FMT "\n", tx_ch,
3062 category = hdr->u.action.category;
3063 action = hdr->u.action.u.wme_action.action_code;
3064 DBG_8723A("RTW_Tx:category(%u), action(%u)\n", category, action);
3068 tx_ret = _cfg80211_rtw_mgmt_tx(padapter, tx_ch, buf, len);
3069 } while (dump_cnt < dump_limit && tx_ret != _SUCCESS);
3071 if (tx_ret != _SUCCESS || dump_cnt > 1) {
3072 DBG_8723A("%s(%s): %s (%d/%d) in %d ms\n",
3073 __func__, padapter->pnetdev->name,
3074 tx_ret == _SUCCESS ? "OK" : "FAIL", dump_cnt,
3075 dump_limit, jiffies_to_msecs(jiffies - start));
3081 static void cfg80211_rtw_mgmt_frame_register(struct wiphy *wiphy,
3082 struct wireless_dev *wdev,
3083 u16 frame_type, bool reg)
3085 if (frame_type != (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ))
3091 static struct cfg80211_ops rtw_cfg80211_ops = {
3092 .change_virtual_intf = cfg80211_rtw_change_iface,
3093 .add_key = cfg80211_rtw_add_key,
3094 .get_key = cfg80211_rtw_get_key,
3095 .del_key = cfg80211_rtw_del_key,
3096 .set_default_key = cfg80211_rtw_set_default_key,
3097 .get_station = cfg80211_rtw_get_station,
3098 .scan = cfg80211_rtw_scan,
3099 .set_wiphy_params = cfg80211_rtw_set_wiphy_params,
3100 .connect = cfg80211_rtw_connect,
3101 .disconnect = cfg80211_rtw_disconnect,
3102 .join_ibss = cfg80211_rtw_join_ibss,
3103 .leave_ibss = cfg80211_rtw_leave_ibss,
3104 .set_tx_power = cfg80211_rtw_set_txpower,
3105 .get_tx_power = cfg80211_rtw_get_txpower,
3106 .set_power_mgmt = cfg80211_rtw_set_power_mgmt,
3107 .set_pmksa = cfg80211_rtw_set_pmksa,
3108 .del_pmksa = cfg80211_rtw_del_pmksa,
3109 .flush_pmksa = cfg80211_rtw_flush_pmksa,
3111 #ifdef CONFIG_8723AU_AP_MODE
3112 .add_virtual_intf = cfg80211_rtw_add_virtual_intf,
3113 .del_virtual_intf = cfg80211_rtw_del_virtual_intf,
3115 .start_ap = cfg80211_rtw_start_ap,
3116 .change_beacon = cfg80211_rtw_change_beacon,
3117 .stop_ap = cfg80211_rtw_stop_ap,
3119 .add_station = cfg80211_rtw_add_station,
3120 .del_station = cfg80211_rtw_del_station,
3121 .change_station = cfg80211_rtw_change_station,
3122 .dump_station = cfg80211_rtw_dump_station,
3123 .change_bss = cfg80211_rtw_change_bss,
3124 #endif /* CONFIG_8723AU_AP_MODE */
3126 .mgmt_tx = cfg80211_rtw_mgmt_tx,
3127 .mgmt_frame_register = cfg80211_rtw_mgmt_frame_register,
3130 static void rtw_cfg80211_init_ht_capab(struct ieee80211_sta_ht_cap *ht_cap,
3131 enum ieee80211_band band, u8 rf_type)
3134 #define MAX_BIT_RATE_40MHZ_MCS15 300 /* Mbps */
3135 #define MAX_BIT_RATE_40MHZ_MCS7 150 /* Mbps */
3137 ht_cap->ht_supported = true;
3139 ht_cap->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
3140 IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_SGI_20 |
3141 IEEE80211_HT_CAP_DSSSCCK40 | IEEE80211_HT_CAP_MAX_AMSDU;
3144 *Maximum length of AMPDU that the STA can receive.
3145 *Length = 2 ^ (13 + max_ampdu_length_exp) - 1 (octets)
3147 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3149 /*Minimum MPDU start spacing , */
3150 ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
3152 ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
3155 *hw->wiphy->bands[IEEE80211_BAND_2GHZ]
3158 *if rx_ant = 1 rx_mask[0]= 0xff;==>MCS0-MCS7
3159 *if rx_ant = 2 rx_mask[1]= 0xff;==>MCS8-MCS15
3160 *if rx_ant >= 3 rx_mask[2]= 0xff;
3161 *if BW_40 rx_mask[4]= 0x01;
3162 *highest supported RX rate
3164 if (rf_type == RF_1T1R) {
3165 ht_cap->mcs.rx_mask[0] = 0xFF;
3166 ht_cap->mcs.rx_mask[1] = 0x00;
3167 ht_cap->mcs.rx_mask[4] = 0x01;
3169 ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS7);
3170 } else if ((rf_type == RF_1T2R) || (rf_type == RF_2T2R)) {
3171 ht_cap->mcs.rx_mask[0] = 0xFF;
3172 ht_cap->mcs.rx_mask[1] = 0xFF;
3173 ht_cap->mcs.rx_mask[4] = 0x01;
3175 ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS15);
3177 DBG_8723A("%s, error rf_type =%d\n", __func__, rf_type);
3182 void rtw_cfg80211_init_wiphy(struct rtw_adapter *padapter)
3185 struct ieee80211_supported_band *bands;
3186 struct wireless_dev *pwdev = padapter->rtw_wdev;
3187 struct wiphy *wiphy = pwdev->wiphy;
3189 rf_type = rtl8723a_get_rf_type(padapter);
3191 DBG_8723A("%s:rf_type =%d\n", __func__, rf_type);
3193 /* if (padapter->registrypriv.wireless_mode & WIRELESS_11G) */
3195 bands = wiphy->bands[IEEE80211_BAND_2GHZ];
3197 rtw_cfg80211_init_ht_capab(&bands->ht_cap,
3198 IEEE80211_BAND_2GHZ,
3202 /* if (padapter->registrypriv.wireless_mode & WIRELESS_11A) */
3204 bands = wiphy->bands[IEEE80211_BAND_5GHZ];
3206 rtw_cfg80211_init_ht_capab(&bands->ht_cap,
3207 IEEE80211_BAND_5GHZ,
3212 static void rtw_cfg80211_preinit_wiphy(struct rtw_adapter *padapter,
3213 struct wiphy *wiphy)
3215 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
3217 wiphy->max_scan_ssids = RTW_SSID_SCAN_AMOUNT;
3218 wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
3219 wiphy->max_num_pmkids = RTW_MAX_NUM_PMKIDS;
3221 wiphy->max_remain_on_channel_duration =
3222 RTW_MAX_REMAIN_ON_CHANNEL_DURATION;
3224 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3225 BIT(NL80211_IFTYPE_ADHOC) |
3226 #ifdef CONFIG_8723AU_AP_MODE
3227 BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_MONITOR) |
3231 #ifdef CONFIG_8723AU_AP_MODE
3232 wiphy->mgmt_stypes = rtw_cfg80211_default_mgmt_stypes;
3233 #endif /* CONFIG_8723AU_AP_MODE */
3235 wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR);
3238 wiphy->iface_combinations = &rtw_combinations;
3239 wiphy->n_iface_combinations = 1;
3242 wiphy->cipher_suites = rtw_cipher_suites;
3243 wiphy->n_cipher_suites = ARRAY_SIZE(rtw_cipher_suites);
3245 /* if (padapter->registrypriv.wireless_mode & WIRELESS_11G) */
3246 wiphy->bands[IEEE80211_BAND_2GHZ] =
3247 rtw_spt_band_alloc(IEEE80211_BAND_2GHZ);
3248 /* if (padapter->registrypriv.wireless_mode & WIRELESS_11A) */
3249 wiphy->bands[IEEE80211_BAND_5GHZ] =
3250 rtw_spt_band_alloc(IEEE80211_BAND_5GHZ);
3252 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3253 wiphy->flags |= WIPHY_FLAG_OFFCHAN_TX | WIPHY_FLAG_HAVE_AP_SME;
3255 if (padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE)
3256 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
3258 wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
3261 int rtw_wdev_alloc(struct rtw_adapter *padapter, struct device *dev)
3264 struct wiphy *wiphy;
3265 struct wireless_dev *wdev;
3266 struct rtw_wdev_priv *pwdev_priv;
3267 struct net_device *pnetdev = padapter->pnetdev;
3269 DBG_8723A("%s(padapter =%p)\n", __func__, padapter);
3272 wiphy = wiphy_new(&rtw_cfg80211_ops, sizeof(struct rtw_wdev_priv));
3274 DBG_8723A("Couldn't allocate wiphy device\n");
3280 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
3282 DBG_8723A("Couldn't allocate wireless device\n");
3287 set_wiphy_dev(wiphy, dev);
3288 rtw_cfg80211_preinit_wiphy(padapter, wiphy);
3290 ret = wiphy_register(wiphy);
3292 DBG_8723A("Couldn't register wiphy device\n");
3296 wdev->wiphy = wiphy;
3297 wdev->netdev = pnetdev;
3298 /* wdev->iftype = NL80211_IFTYPE_STATION; */
3299 /* for rtw_setopmode_cmd23a() in cfg80211_rtw_change_iface() */
3300 wdev->iftype = NL80211_IFTYPE_MONITOR;
3301 padapter->rtw_wdev = wdev;
3302 pnetdev->ieee80211_ptr = wdev;
3304 /* init pwdev_priv */
3305 pwdev_priv = wdev_to_priv(wdev);
3306 pwdev_priv->rtw_wdev = wdev;
3307 pwdev_priv->pmon_ndev = NULL;
3308 pwdev_priv->ifname_mon[0] = '\0';
3309 pwdev_priv->padapter = padapter;
3310 pwdev_priv->scan_request = NULL;
3311 spin_lock_init(&pwdev_priv->scan_req_lock);
3313 pwdev_priv->p2p_enabled = false;
3315 if (padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE)
3316 pwdev_priv->power_mgmt = true;
3318 pwdev_priv->power_mgmt = false;
3329 void rtw_wdev_free(struct wireless_dev *wdev)
3331 DBG_8723A("%s(wdev =%p)\n", __func__, wdev);
3336 kfree(wdev->wiphy->bands[IEEE80211_BAND_2GHZ]);
3337 kfree(wdev->wiphy->bands[IEEE80211_BAND_5GHZ]);
3339 wiphy_free(wdev->wiphy);
3344 void rtw_wdev_unregister(struct wireless_dev *wdev)
3346 struct rtw_wdev_priv *pwdev_priv;
3348 DBG_8723A("%s(wdev =%p)\n", __func__, wdev);
3353 pwdev_priv = wdev_to_priv(wdev);
3355 rtw_cfg80211_indicate_scan_done(pwdev_priv, true);
3357 if (pwdev_priv->pmon_ndev) {
3358 DBG_8723A("%s, unregister monitor interface\n", __func__);
3359 unregister_netdev(pwdev_priv->pmon_ndev);
3362 wiphy_unregister(wdev->wiphy);