mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-12 13:55:32 +00:00
Code Issues Releases Wiki Activity

staging: rtl8723au: Remove P2P/WiFiDirect/WiFiDisplay code

Browse source 
Discussing with Johannes Berg and Larry Finger, we have concluded that
this code really should be handled through wpa_supplicant, and not in
the kernel.

Signed-off-by: Jes Sorensen <Jes.Sorensen@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Jes Sorensen 2014-04-15 19:43:35 +02:00 committed by Greg Kroah-Hartman
parent 91624933fd
commit 98fb81291d
24 changed files with 69 additions and 9308 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
drivers/staging/rtl8723au/Kconfig
View file

@ -19,14 +19,6 @@ config 8723AU_AP_MODE
will never be used as an AP, or the target system has limited memory,
"Y" should be selected.
config 8723AU_P2P
bool "Realtek RTL8723AU Peer-to-peer mode"
default y
---help---
This option enables peer-to-peer mode for the r8723au driver. Unless you
know that peer-to-peer (P2P) mode will never be used, or the target system has
limited memory, "Y" should be selected.
config 8723AU_BT_COEXIST
bool "Realtek RTL8723AU BlueTooth Coexistence"
default y

1
drivers/staging/rtl8723au/Makefile
View file

@ -8,7 +8,6 @@ r8723au-y := \
core/rtw_led.o \
core/rtw_mlme.o \
core/rtw_mlme_ext.o \
core/rtw_p2p.o \
core/rtw_pwrctrl.o \
core/rtw_recv.o \
core/rtw_security.o \

9
drivers/staging/rtl8723au/core/rtw_ap.c
View file

@ -659,9 +659,6 @@ static void start_bss_network(struct rtw_adapter *padapter, u8 *pbuf)
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
struct wlan_bssid_ex *pnetwork_mlmeext = &pmlmeinfo->network;
struct HT_info_element *pht_info = NULL;
#ifdef CONFIG_8723AU_P2P
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
#endif /* CONFIG_8723AU_P2P */
bcn_interval = (u16)pnetwork->Configuration.BeaconPeriod;
cur_channel = pnetwork->Configuration.DSConfig;
@ -773,12 +770,6 @@ static void start_bss_network(struct rtw_adapter *padapter, u8 *pbuf)
/* let pnetwork_mlmeext == pnetwork_mlme. */
memcpy(pnetwork_mlmeext, pnetwork, pnetwork->Length);
#ifdef CONFIG_8723AU_P2P
memcpy(pwdinfo->p2p_group_ssid, pnetwork->Ssid.ssid,
pnetwork->Ssid.ssid_len);
pwdinfo->p2p_group_ssid_len = pnetwork->Ssid.ssid_len;
#endif /* CONFIG_8723AU_P2P */
if (pmlmeext->bstart_bss) {
update_beacon23a(padapter, WLAN_EID_TIM, NULL, false);

58
drivers/staging/rtl8723au/core/rtw_cmd.c
View file

@ -527,12 +527,6 @@ u8 rtw_sitesurvey_cmd23a(struct rtw_adapter *padapter,
if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
rtw_lps_ctrl_wk_cmd23a(padapter, LPS_CTRL_SCAN, 1);
#ifdef CONFIG_8723AU_P2P
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
p2p_ps_wk_cmd23a(padapter, P2P_PS_SCAN, 1);
}
#endif /* CONFIG_8723AU_P2P */
ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
if (!ph2c)
return _FAIL;
@ -1354,48 +1348,6 @@ static void power_saving_wk_hdl(struct rtw_adapter *padapter, u8 *pbuf, int sz)
rtw_ps_processor23a(padapter);
}
#ifdef CONFIG_8723AU_P2P
u8 p2p_protocol_wk_cmd23a(struct rtw_adapter*padapter, int intCmdType)
{
struct cmd_obj *ph2c;
struct drvextra_cmd_parm *pdrvextra_cmd_parm;
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
u8 res = _SUCCESS;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
{
return res;
}
ph2c = kzalloc(sizeof(struct cmd_obj), GFP_ATOMIC);
if (!ph2c) {
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm = kzalloc(sizeof(struct drvextra_cmd_parm),
GFP_ATOMIC);
if (!pdrvextra_cmd_parm) {
kfree(ph2c);
res = _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = P2P_PROTO_WK_CID;
pdrvextra_cmd_parm->type_size = intCmdType; /* As the command tppe. */
pdrvextra_cmd_parm->pbuf = NULL; /* Must be NULL here */
init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm,
GEN_CMD_CODE(_Set_Drv_Extra));
res = rtw_enqueue_cmd23a(pcmdpriv, ph2c);
exit:
return res;
}
#endif /* CONFIG_8723AU_P2P */
u8 rtw_ps_cmd23a(struct rtw_adapter*padapter)
{
struct cmd_obj *ppscmd;
@ -1634,16 +1586,6 @@ u8 rtw_drvextra_cmd_hdl23a(struct rtw_adapter *padapter, unsigned char *pbuf)
case LPS_CTRL_WK_CID:
lps_ctrl_wk_hdl(padapter, (u8)pdrvextra_cmd->type_size);
break;
#ifdef CONFIG_8723AU_P2P
case P2P_PS_WK_CID:
p2p_ps_wk_hdl23a(padapter, pdrvextra_cmd->type_size);
break;
case P2P_PROTO_WK_CID:
/* Commented by Albert 2011/07/01 */
/* I used the type_size as the type command */
p2p_protocol_wk_hdl23a(padapter, pdrvextra_cmd->type_size);
break;
#endif /* CONFIG_8723AU_P2P */
#ifdef CONFIG_8723AU_AP_MODE
case CHECK_HIQ_WK_CID:
rtw_chk_hi_queue_hdl(padapter);

311
drivers/staging/rtl8723au/core/rtw_ieee80211.c
View file

@ -1227,9 +1227,6 @@ void dump_ies23a(u8 *buf, u32 buf_len) {
len = *(pos + 1);
DBG_8723A("%s ID:%u, LEN:%u\n", __func__, id, len);
#ifdef CONFIG_8723AU_P2P
dump_p2p_ie23a(pos, len);
#endif
dump_wps_ie23a(pos, len);
pos += (2 + len);
@ -1259,314 +1256,6 @@ void dump_wps_ie23a(u8 *ie, u32 ie_len) {
}
}
#ifdef CONFIG_8723AU_P2P
void dump_p2p_ie23a(u8 *ie, u32 ie_len) {
u8* pos = (u8*)ie;
u8 id;
u16 len;
u8 *p2p_ie;
uint p2p_ielen;
p2p_ie = rtw_get_p2p_ie23a(ie, ie_len, NULL, &p2p_ielen);
if (p2p_ie != ie || p2p_ielen == 0)
return;
pos += 6;
while (pos-ie < ie_len) {
id = *pos;
len = get_unaligned_le16(pos+1);
DBG_8723A("%s ID:%u, LEN:%u\n", __func__, id, len);
pos+= (3+len);
}
}
/**
* rtw_get_p2p_ie23a - Search P2P IE from a series of IEs
* @in_ie: Address of IEs to search
* @in_len: Length limit from in_ie
* @p2p_ie: If not NULL and P2P IE is found, P2P IE will be copied to the
* buf starting from p2p_ie
* @p2p_ielen: If not NULL and P2P IE is found, will set to the length of
* the entire P2P IE
*
* Returns: The address of the P2P IE found, or NULL
*/
u8 *rtw_get_p2p_ie23a(u8 *in_ie, int in_len, u8 *p2p_ie, uint *p2p_ielen)
{
uint cnt = 0;
u8 *p2p_ie_ptr;
u8 eid, p2p_oui[4]={0x50, 0x6F, 0x9A, 0x09};
if (p2p_ielen)
*p2p_ielen = 0;
while (cnt<in_len) {
eid = in_ie[cnt];
if ((in_len < 0) || (cnt > MAX_IE_SZ)) {
dump_stack();
return NULL;
}
if ((eid == WLAN_EID_VENDOR_SPECIFIC) &&
!memcmp(&in_ie[cnt + 2], p2p_oui, 4)) {
p2p_ie_ptr = in_ie + cnt;
if (p2p_ie != NULL) {
memcpy(p2p_ie, &in_ie[cnt],
in_ie[cnt + 1] + 2);
}
if (p2p_ielen != NULL) {
*p2p_ielen = in_ie[cnt + 1] + 2;
}
return p2p_ie_ptr;
break;
} else {
cnt += in_ie[cnt + 1] + 2; /* goto next */
}
}
return NULL;
}
/**
* rtw_get_p2p_attr23a - Search a specific P2P attribute from a given P2P IE
* @p2p_ie: Address of P2P IE to search
* @p2p_ielen: Length limit from p2p_ie
* @target_attr_id: The attribute ID of P2P attribute to search
* @buf_attr: If not NULL and the P2P attribute is found, P2P attribute will
* be copied to the buf starting from buf_attr
* @len_attr: If not NULL and the P2P attribute is found, will set to the
* length of the entire P2P attribute
*
* Returns: the address of the specific WPS attribute found, or NULL
*/
u8 *rtw_get_p2p_attr23a(u8 *p2p_ie, uint p2p_ielen, u8 target_attr_id,
u8 *buf_attr, u32 *len_attr)
{
u8 *attr_ptr = NULL;
u8 *target_attr_ptr = NULL;
u8 p2p_oui[4]={0x50, 0x6F, 0x9A, 0x09};
if (len_attr)
*len_attr = 0;
if (!p2p_ie || (p2p_ie[0] != WLAN_EID_VENDOR_SPECIFIC) ||
memcmp(p2p_ie + 2, p2p_oui, 4)) {
return attr_ptr;
}
/* 6 = 1(Element ID) + 1(Length) + 3 (OUI) + 1(OUI Type) */
attr_ptr = p2p_ie + 6; /* goto first attr */
while (attr_ptr - p2p_ie < p2p_ielen) {
/* 3 = 1(Attribute ID) + 2(Length) */
u8 attr_id = *attr_ptr;
u16 attr_data_len = get_unaligned_le16(attr_ptr + 1);
u16 attr_len = attr_data_len + 3;
/* DBG_8723A("%s attr_ptr:%p, id:%u, length:%u\n", __func__, attr_ptr, attr_id, attr_data_len); */
if (attr_id == target_attr_id) {
target_attr_ptr = attr_ptr;
if (buf_attr)
memcpy(buf_attr, attr_ptr, attr_len);
if (len_attr)
*len_attr = attr_len;
break;
} else {
attr_ptr += attr_len; /* goto next */
}
}
return target_attr_ptr;
}
/**
* rtw_get_p2p_attr23a_content - Search a specific P2P attribute content from
* a given P2P IE
* @p2p_ie: Address of P2P IE to search
* @p2p_ielen: Length limit from p2p_ie
* @target_attr_id: The attribute ID of P2P attribute to search
* @buf_content: If not NULL and the P2P attribute is found, P2P attribute
* content will be copied to the buf starting from buf_content
* @len_content: If not NULL and the P2P attribute is found, will set to the
* length of the P2P attribute content
*
* Returns: the address of the specific P2P attribute content found, or NULL
*/
u8 *rtw_get_p2p_attr23a_content(u8 *p2p_ie, uint p2p_ielen, u8 target_attr_id,
u8 *buf_content, uint *len_content)
{
u8 *attr_ptr;
u32 attr_len;
if (len_content)
*len_content = 0;
attr_ptr = rtw_get_p2p_attr23a(p2p_ie, p2p_ielen, target_attr_id,
NULL, &attr_len);
if (attr_ptr && attr_len) {
if (buf_content)
memcpy(buf_content, attr_ptr + 3, attr_len - 3);
if (len_content)
*len_content = attr_len - 3;
return attr_ptr+3;
}
return NULL;
}
u32 rtw_set_p2p_attr_content23a(u8 *pbuf, u8 attr_id, u16 attr_len, u8 *pdata_attr)
{
u32 a_len;
*pbuf = attr_id;
/* u16*)(pbuf + 1) = cpu_to_le16(attr_len); */
put_unaligned_le16(attr_len, pbuf + 1);
if (pdata_attr)
memcpy(pbuf + 3, pdata_attr, attr_len);
a_len = attr_len + 3;
return a_len;
}
static uint rtw_p2p_attr_remove(u8 *ie, uint ielen_ori, u8 attr_id)
{
u8 *target_attr;
u32 target_attr_len;
uint ielen = ielen_ori;
while(1) {
target_attr = rtw_get_p2p_attr23a(ie, ielen, attr_id, NULL,
&target_attr_len);
if (target_attr && target_attr_len) {
u8 *next_attr = target_attr+target_attr_len;
uint remain_len = ielen-(next_attr-ie);
/* dump_ies23a(ie, ielen); */
memset(target_attr, 0, target_attr_len);
memcpy(target_attr, next_attr, remain_len);
memset(target_attr+remain_len, 0, target_attr_len);
*(ie + 1) -= target_attr_len;
ielen -= target_attr_len;
} else {
/* if (index>0) */
/* dump_ies23a(ie, ielen); */
break;
}
}
return ielen;
}
void rtw_wlan_bssid_ex_remove_p2p_attr23a(struct wlan_bssid_ex *bss_ex, u8 attr_id)
{
u8 *p2p_ie;
uint p2p_ielen, p2p_ielen_ori;
if ((p2p_ie = rtw_get_p2p_ie23a(bss_ex->IEs + _FIXED_IE_LENGTH_,
bss_ex->IELength - _FIXED_IE_LENGTH_,
NULL, &p2p_ielen_ori))) {
p2p_ielen = rtw_p2p_attr_remove(p2p_ie, p2p_ielen_ori, attr_id);
if (p2p_ielen != p2p_ielen_ori) {
u8 *next_ie_ori = p2p_ie+p2p_ielen_ori;
u8 *next_ie = p2p_ie+p2p_ielen;
uint remain_len;
remain_len = bss_ex->IELength-(next_ie_ori-bss_ex->IEs);
memcpy(next_ie, next_ie_ori, remain_len);
memset(next_ie+remain_len, 0, p2p_ielen_ori-p2p_ielen);
bss_ex->IELength -= p2p_ielen_ori-p2p_ielen;
}
}
}
#endif /* CONFIG_8723AU_P2P */
#ifdef CONFIG_8723AU_P2P
int rtw_get_wfd_ie(u8 *in_ie, int in_len, u8 *wfd_ie, uint *wfd_ielen)
{
int match;
const u8 *ie;
match = 0;
if (in_len < 0)
return match;
ie = cfg80211_find_vendor_ie(0x506F9A, 0x0A, in_ie, in_len);
if (ie && (ie[1] <= (MAX_WFD_IE_LEN - 2))) {
if (wfd_ie) {
*wfd_ielen = ie[1] + 2;
memcpy(wfd_ie, ie, ie[1] + 2);
} else
if (wfd_ielen)
*wfd_ielen = 0;
match = 1;
}
return match;
}
/* attr_content: The output buffer, contains the "body field" of
WFD attribute. */
/* attr_contentlen: The data length of the "body field" of WFD
attribute. */
int rtw_get_wfd_attr_content(u8 *wfd_ie, uint wfd_ielen, u8 target_attr_id,
u8 *attr_content, uint *attr_contentlen)
{
int match;
uint cnt = 0;
u8 attr_id, wfd_oui[4] = {0x50, 0x6F, 0x9A, 0x0A};
match = false;
if ((wfd_ie[0] != WLAN_EID_VENDOR_SPECIFIC) ||
memcmp(wfd_ie + 2, wfd_oui, 4)) {
return match;
}
/* 1 (WFD IE) + 1 (Length) + 3 (OUI) + 1 (OUI Type) */
cnt = 6;
while (cnt < wfd_ielen) {
u16 attrlen = get_unaligned_be16(wfd_ie + cnt + 1);
attr_id = wfd_ie[cnt];
if (attr_id == target_attr_id) {
/* 3 -> 1 byte for attribute ID field, 2
bytes for length field */
if (attr_content)
memcpy(attr_content, &wfd_ie[cnt + 3], attrlen);
if (attr_contentlen)
*attr_contentlen = attrlen;
cnt += attrlen + 3;
match = true;
break;
} else {
cnt += attrlen + 3; /* goto next */
}
}
return match;
}
#endif /* CONFIG_8723AU_P2P */
/* Baron adds to avoid FreeBSD warning */
int ieee80211_is_empty_essid23a(const char *essid, int essid_len)

22
drivers/staging/rtl8723au/core/rtw_mlme.c
View file

@ -787,11 +787,6 @@ void rtw_surveydone_event_callback23a(struct rtw_adapter *adapter, u8 *pbuf)
spin_unlock_bh(&pmlmepriv->lock);
#ifdef CONFIG_8723AU_P2P
if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
p2p_ps_wk_cmd23a(adapter, P2P_PS_SCAN_DONE, 0);
#endif /* CONFIG_8723AU_P2P */
rtw_os_xmit_schedule23a(adapter);
if(pmlmeext->sitesurvey_res.bss_cnt == 0)
@ -956,10 +951,6 @@ void rtw_indicate_disconnect23a(struct rtw_adapter *padapter)
}
#ifdef CONFIG_8723AU_P2P
p2p_ps_wk_cmd23a(padapter, P2P_PS_DISABLE, 1);
#endif /* CONFIG_8723AU_P2P */
rtw_lps_ctrl_wk_cmd23a(padapter, LPS_CTRL_DISCONNECT, 1);
}
@ -1581,16 +1572,9 @@ void rtw_dynamic_check_timer_handler(unsigned long data)
rtw_dynamic_chk_wk_cmd23a(adapter);
if (pregistrypriv->wifi_spec == 1)
{
#ifdef CONFIG_8723AU_P2P
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
#endif
{
/* auto site survey */
rtw_auto_scan_handler(adapter);
}
if (pregistrypriv->wifi_spec == 1) {
/* auto site survey */
rtw_auto_scan_handler(adapter);
}
out:
mod_timer(&adapter->mlmepriv.dynamic_chk_timer,

3534
drivers/staging/rtl8723au/core/rtw_mlme_ext.c
View file

File diff suppressed because it is too large Load diff

4016
drivers/staging/rtl8723au/core/rtw_p2p.c
View file

File diff suppressed because it is too large Load diff

55
drivers/staging/rtl8723au/core/rtw_pwrctrl.c
View file

@ -109,33 +109,30 @@ static bool rtw_pwr_unassociated_idle(struct rtw_adapter *adapter)
struct rtw_adapter *buddy = adapter->pbuddy_adapter;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct xmit_priv *pxmit_priv = &adapter->xmitpriv;
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
bool ret = false;
if (time_after_eq(adapter->pwrctrlpriv.ips_deny_time, jiffies))
goto exit;
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)
|| check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
|| check_fwstate(pmlmepriv, WIFI_AP_STATE)
|| check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
|| !rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)
) {
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR) ||
check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS) ||
check_fwstate(pmlmepriv, WIFI_AP_STATE) ||
check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)){
goto exit;
}
/* consider buddy, if exist */
if (buddy) {
struct mlme_priv *b_pmlmepriv = &buddy->mlmepriv;
struct wifidirect_info *b_pwdinfo = &buddy->wdinfo;
if (check_fwstate(b_pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)
|| check_fwstate(b_pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
|| check_fwstate(b_pmlmepriv, WIFI_AP_STATE)
|| check_fwstate(b_pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
|| !rtw_p2p_chk_state(b_pwdinfo, P2P_STATE_NONE)
) {
if (check_fwstate(b_pmlmepriv,
WIFI_ASOC_STATE|WIFI_SITE_MONITOR) ||
check_fwstate(b_pmlmepriv,
WIFI_UNDER_LINKING|WIFI_UNDER_WPS) ||
check_fwstate(b_pmlmepriv, WIFI_AP_STATE) ||
check_fwstate(b_pmlmepriv,
WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)) {
goto exit;
}
}
@ -307,11 +304,6 @@ u8 PS_RDY_CHECK(struct rtw_adapter * padapter)
void rtw_set_ps_mode23a(struct rtw_adapter *padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
#ifdef CONFIG_8723AU_P2P
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
#endif /* CONFIG_8723AU_P2P */
RT_TRACE(_module_rtl871x_pwrctrl_c_, _drv_notice_,
("%s: PowerMode =%d Smart_PS =%d\n",
@ -334,17 +326,12 @@ void rtw_set_ps_mode23a(struct rtw_adapter *padapter, u8 ps_mode, u8 smart_ps, u
}
if (ps_mode == PS_MODE_ACTIVE) {
#ifdef CONFIG_8723AU_P2P
if (pwdinfo->opp_ps == 0)
#endif /* CONFIG_8723AU_P2P */
{
DBG_8723A("rtw_set_ps_mode23a: Leave 802.11 power save\n");
DBG_8723A("rtw_set_ps_mode23a: Leave 802.11 power save\n");
pwrpriv->pwr_mode = ps_mode;
rtw_set_rpwm23a(padapter, PS_STATE_S4);
rtl8723a_set_FwPwrMode_cmd(padapter, ps_mode);
pwrpriv->bFwCurrentInPSMode = false;
}
pwrpriv->pwr_mode = ps_mode;
rtw_set_rpwm23a(padapter, PS_STATE_S4);
rtl8723a_set_FwPwrMode_cmd(padapter, ps_mode);
pwrpriv->bFwCurrentInPSMode = false;
} else {
if (PS_RDY_CHECK(padapter)
#ifdef CONFIG_8723AU_BT_COEXIST
@ -359,12 +346,6 @@ void rtw_set_ps_mode23a(struct rtw_adapter *padapter, u8 ps_mode, u8 smart_ps, u
pwrpriv->bcn_ant_mode = bcn_ant_mode;
rtl8723a_set_FwPwrMode_cmd(padapter, ps_mode);
#ifdef CONFIG_8723AU_P2P
/* Set CTWindow after LPS */
if (pwdinfo->opp_ps == 1)
p2p_ps_wk_cmd23a(padapter, P2P_PS_ENABLE, 0);
#endif /* CONFIG_8723AU_P2P */
rtw_set_rpwm23a(padapter, PS_STATE_S2);
}
}
@ -464,10 +445,6 @@ void LeaveAllPowerSaveMode23a(struct rtw_adapter *Adapter)
/* DBG_8723A("%s.....\n", __func__); */
if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
{ /* connect */
#ifdef CONFIG_8723AU_P2P
p2p_ps_wk_cmd23a(Adapter, P2P_PS_DISABLE, enqueue);
#endif /* CONFIG_8723AU_P2P */
rtw_lps_ctrl_wk_cmd23a(Adapter, LPS_CTRL_LEAVE, enqueue);
}

35
drivers/staging/rtl8723au/core/rtw_wlan_util.c
View file

@ -498,32 +498,6 @@ void flush_all_cam_entry23a(struct rtw_adapter *padapter)
memset((u8 *)(pmlmeinfo->FW_sta_info), 0, sizeof(pmlmeinfo->FW_sta_info));
}
#if defined(CONFIG_8723AU_P2P) && defined(CONFIG_8723AU_P2P)
int WFD_info_handler(struct rtw_adapter *padapter, struct ndis_802_11_var_ies * pIE)
{
struct wifidirect_info *pwdinfo;
u8 wfd_ie[MAX_WFD_IE_LEN] = {0x00};
u32 wfd_ielen = 0;
pwdinfo = &padapter->wdinfo;
if (rtw_get_wfd_ie((u8 *) pIE, pIE->Length, wfd_ie, &wfd_ielen)) {
u8 attr_content[ 10 ] = { 0x00 };
u32 attr_contentlen = 0;
DBG_8723A("[%s] Found WFD IE\n", __func__);
rtw_get_wfd_attr_content(wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, attr_content, &attr_contentlen);
if (attr_contentlen) {
pwdinfo->wfd_info->peer_rtsp_ctrlport = get_unaligned_be16(attr_content + 2);
DBG_8723A("[%s] Peer PORT NUM = %d\n", __func__, pwdinfo->wfd_info->peer_rtsp_ctrlport);
return true;
}
} else {
DBG_8723A("[%s] NO WFD IE\n", __func__);
}
return _FAIL;
}
#endif
int WMM_param_handler23a(struct rtw_adapter *padapter, struct ndis_802_11_var_ies * pIE)
{
/* struct registry_priv *pregpriv = &padapter->registrypriv; */
@ -1371,15 +1345,6 @@ void set_sta_rate23a(struct rtw_adapter *padapter, struct sta_info *psta)
void update_tx_basic_rate23a(struct rtw_adapter *padapter, u8 wirelessmode)
{
unsigned char supported_rates[NDIS_802_11_LENGTH_RATES_EX];
#ifdef CONFIG_8723AU_P2P
struct wifidirect_info* pwdinfo = &padapter->wdinfo;
/* Added by Albert 2011/03/22 */
/* In the P2P mode, the driver should not support the b mode. */
/* So, the Tx packet shouldn't use the CCK rate */
if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
return;
#endif /* CONFIG_8723AU_P2P */
memset(supported_rates, 0, NDIS_802_11_LENGTH_RATES_EX);

73
drivers/staging/rtl8723au/hal/rtl8723a_cmd.c
View file

@ -776,76 +776,3 @@ void rtl8723a_set_BTCoex_AP_mode_FwRsvdPkt_cmd(struct rtw_adapter *padapter)
}
}
#endif
#ifdef CONFIG_8723AU_P2P
void rtl8723a_set_p2p_ps_offload_cmd(struct rtw_adapter *padapter, u8 p2p_ps_state)
{
struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
struct P2P_PS_Offload_t *p2p_ps_offload = &pHalData->p2p_ps_offload;
u8 i;
switch (p2p_ps_state) {
case P2P_PS_DISABLE:
DBG_8723A("P2P_PS_DISABLE \n");
memset(p2p_ps_offload, 0, 1);
break;
case P2P_PS_ENABLE:
DBG_8723A("P2P_PS_ENABLE \n");
/* update CTWindow value. */
if (pwdinfo->ctwindow > 0) {
p2p_ps_offload->CTWindow_En = 1;
rtw_write8(padapter, REG_P2P_CTWIN, pwdinfo->ctwindow);
}
/* hw only support 2 set of NoA */
for (i = 0; i < pwdinfo->noa_num; i++) {
/* To control the register setting for which NOA */
rtw_write8(padapter, REG_NOA_DESC_SEL, (i << 4));
if (i == 0)
p2p_ps_offload->NoA0_En = 1;
else
p2p_ps_offload->NoA1_En = 1;
/* config P2P NoA Descriptor Register */
rtw_write32(padapter, REG_NOA_DESC_DURATION, pwdinfo->noa_duration[i]);
rtw_write32(padapter, REG_NOA_DESC_INTERVAL, pwdinfo->noa_interval[i]);
rtw_write32(padapter, REG_NOA_DESC_START, pwdinfo->noa_start_time[i]);
rtw_write8(padapter, REG_NOA_DESC_COUNT, pwdinfo->noa_count[i]);
}
if ((pwdinfo->opp_ps == 1) || (pwdinfo->noa_num > 0)) {
/* rst p2p circuit */
rtw_write8(padapter, REG_DUAL_TSF_RST, BIT(4));
p2p_ps_offload->Offload_En = 1;
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO)) {
p2p_ps_offload->role = 1;
p2p_ps_offload->AllStaSleep = 0;
} else {
p2p_ps_offload->role = 0;
}
p2p_ps_offload->discovery = 0;
}
break;
case P2P_PS_SCAN:
DBG_8723A("P2P_PS_SCAN \n");
p2p_ps_offload->discovery = 1;
break;
case P2P_PS_SCAN_DONE:
DBG_8723A("P2P_PS_SCAN_DONE \n");
p2p_ps_offload->discovery = 0;
pwdinfo->p2p_ps_state = P2P_PS_ENABLE;
break;
default:
break;
}
FillH2CCmd(padapter, P2P_PS_OFFLOAD_EID, 1, (u8 *)p2p_ps_offload);
}
#endif /* CONFIG_8723AU_P2P */

7
drivers/staging/rtl8723au/hal/rtl8723a_dm.c
View file

@ -219,13 +219,6 @@ rtl8723a_HalDmWatchDog(
bFwCurrentInPSMode = Adapter->pwrctrlpriv.bFwCurrentInPSMode;
bFwPSAwake = rtl8723a_get_fwlps_rf_on(Adapter);
#ifdef CONFIG_8723AU_P2P
/* Fw is under p2p powersaving mode, driver should stop dynamic mechanism. */
/* modifed by thomas. 2011.06.11. */
if (Adapter->wdinfo.p2p_ps_mode)
bFwPSAwake = false;
#endif /* CONFIG_8723AU_P2P */
if ((hw_init_completed) && ((!bFwCurrentInPSMode) && bFwPSAwake)) {
/* Calculate Tx/Rx statistics. */
dm_CheckStatistics(Adapter);

11
drivers/staging/rtl8723au/include/drv_types.h
View file

@ -55,7 +55,6 @@ enum _NIC_VERSION {
#include <rtw_event.h>
#include <rtw_led.h>
#include <rtw_mlme_ext.h>
#include <rtw_p2p.h>
#include <rtw_ap.h>
#include "ioctl_cfg80211.h"
@ -258,13 +257,7 @@ struct rtw_adapter {
struct hostapd_priv *phostapdpriv;
#endif
struct cfg80211_wifidirect_info cfg80211_wdinfo;
u32 setband;
struct wifidirect_info wdinfo;
#ifdef CONFIG_8723AU_P2P
struct wifi_display_info wfd_info;
#endif /* CONFIG_8723AU_P2P */
void *HalData;
u32 hal_data_sz;
@ -316,10 +309,6 @@ struct rtw_adapter {
u8 bRxRSSIDisplay;
/* The driver will show the desired chan nor when this flag is 1. */
u8 bNotifyChannelChange;
#ifdef CONFIG_8723AU_P2P
/* driver will show current P2P status when the application reads it*/
u8 bShowGetP2PState;
#endif
struct rtw_adapter *pbuddy_adapter;
/* extend to support multi interface */

14
drivers/staging/rtl8723au/include/ieee80211.h
View file

@ -563,20 +563,6 @@ u8 *rtw_get_wps_attr_content23a(u8 *wps_ie, uint wps_ielen, u16 target_attr_id ,
void dump_ies23a(u8 *buf, u32 buf_len);
void dump_wps_ie23a(u8 *ie, u32 ie_len);
#ifdef CONFIG_8723AU_P2P
void dump_p2p_ie23a(u8 *ie, u32 ie_len);
u8 *rtw_get_p2p_ie23a(u8 *in_ie, int in_len, u8 *p2p_ie, uint *p2p_ielen);
u8 *rtw_get_p2p_attr23a(u8 *p2p_ie, uint p2p_ielen, u8 target_attr_id ,u8 *buf_attr, u32 *len_attr);
u8 *rtw_get_p2p_attr23a_content(u8 *p2p_ie, uint p2p_ielen, u8 target_attr_id ,u8 *buf_content, uint *len_content);
u32 rtw_set_p2p_attr_content23a(u8 *pbuf, u8 attr_id, u16 attr_len, u8 *pdata_attr);
void rtw_wlan_bssid_ex_remove_p2p_attr23a(struct wlan_bssid_ex *bss_ex, u8 attr_id);
#endif
#ifdef CONFIG_8723AU_P2P
int rtw_get_wfd_ie(u8 *in_ie, int in_len, u8 *wfd_ie, uint *wfd_ielen);
int rtw_get_wfd_attr_content(u8 *wfd_ie, uint wfd_ielen, u8 target_attr_id ,u8 *attr_content, uint *attr_contentlen);
#endif /* CONFIG_8723AU_P2P */
uint rtw_get_rateset_len23a(u8 *rateset);
struct registry_priv;

4
drivers/staging/rtl8723au/include/rtl8723a_cmd.h
View file

@ -151,10 +151,6 @@ u8 rtl8723a_set_rssi_cmd(struct rtw_adapter * padapter, u8 *param);
u8 rtl8723a_set_raid_cmd(struct rtw_adapter * padapter, u32 mask, u8 arg);
void rtl8723a_add_rateatid(struct rtw_adapter * padapter, u32 bitmap, u8 arg, u8 rssi_level);
#ifdef CONFIG_8723AU_P2P
void rtl8723a_set_p2p_ps_offload_cmd(struct rtw_adapter * padapter, u8 p2p_ps_state);
#endif /* CONFIG_8723AU_P2P */
void CheckFwRsvdPageContent23a(struct rtw_adapter *padapter);
#endif

5
drivers/staging/rtl8723au/include/rtl8723a_hal.h
View file

@ -424,11 +424,6 @@ struct hal_data_8723a {
bool bMACFuncEnable;
#ifdef CONFIG_8723AU_P2P
struct P2P_PS_Offload_t p2p_ps_offload;
#endif
/* */
/* For USB Interface HAL related */
/* */

3
drivers/staging/rtl8723au/include/rtw_cmd.h
View file

@ -106,9 +106,6 @@ u32 rtw_init_evt_priv23a (struct evt_priv *pevtpriv);
void rtw_free_evt_priv23a (struct evt_priv *pevtpriv);
void rtw_cmd_clr_isr23a(struct cmd_priv *pcmdpriv);
void rtw_evt_notify_isr(struct evt_priv *pevtpriv);
#ifdef CONFIG_8723AU_P2P
u8 p2p_protocol_wk_cmd23a(struct rtw_adapter*padapter, int intCmdType );
#endif /* CONFIG_8723AU_P2P */
enum rtw_drvextra_cmd_id
{

123
drivers/staging/rtl8723au/include/rtw_mlme.h
View file

@ -148,30 +148,6 @@ struct tx_invite_resp_info {
u8 token; /* Used to record the dialog token of p2p invitation request frame. */
};
#ifdef CONFIG_8723AU_P2P
struct wifi_display_info {
u16 wfd_enable; /* Enable/Disable the WFD function. */
u16 rtsp_ctrlport; /* TCP port number at which the this WFD device listens for RTSP messages */
u16 peer_rtsp_ctrlport; /* TCP port number at which the peer WFD device listens for RTSP messages */
/* This filed should be filled when receiving the gropu negotiation request */
u8 peer_session_avail; /* WFD session is available or not for the peer wfd device. */
/* This variable will be set when sending the provisioning discovery request to peer WFD device. */
/* And this variable will be reset when it is read by using the iwpriv p2p_get wfd_sa command. */
u8 ip_address[4];
u8 peer_ip_address[4];
u8 wfd_pc; /* WFD preferred connection */
/* 0 -> Prefer to use the P2P for WFD connection on peer side. */
/* 1 -> Prefer to use the TDLS for WFD connection on peer side. */
u8 wfd_device_type;/* WFD Device Type */
/* 0 -> WFD Source Device */
/* 1 -> WFD Primary Sink Device */
enum SCAN_RESULT_TYPE scan_result_type; /* Used when P2P is enable. This parameter will impact the scan result. */
};
#endif /* CONFIG_8723AU_P2P */
struct tx_provdisc_req_info {
u16 wps_config_method_request; /* Used when sending the provisioning request frame */
u16 peer_channel_num[2]; /* The channel number which the receiver stands. */
@ -203,102 +179,6 @@ struct scan_limit_info {
u8 operation_ch[2]; /* Store the operation channel of invitation request frame */
};
struct cfg80211_wifidirect_info {
struct timer_list remain_on_ch_timer;
u8 restore_channel;
struct ieee80211_channel remain_on_ch_channel;
enum nl80211_channel_type remain_on_ch_type;
u64 remain_on_ch_cookie;
bool is_ro_ch;
};
struct wifidirect_info {
struct rtw_adapter *padapter;
struct timer_list find_phase_timer;
struct timer_list restore_p2p_state_timer;
/* Used to do the scanning. After confirming the peer is availalble, the driver transmits the P2P frame to peer. */
struct timer_list pre_tx_scan_timer;
struct timer_list reset_ch_sitesurvey;
struct timer_list reset_ch_sitesurvey2; /* Just for resetting the scan limit function by using p2p nego */
struct tx_provdisc_req_info tx_prov_disc_info;
struct rx_provdisc_req_info rx_prov_disc_info;
struct tx_invite_req_info invitereq_info;
struct profile_info profileinfo[P2P_MAX_PERSISTENT_GROUP_NUM]; /* Store the profile information of persistent group */
struct tx_invite_resp_info inviteresp_info;
struct tx_nego_req_info nego_req_info;
struct group_id_info groupid_info; /* Store the group id information when doing the group negotiation handshake. */
struct scan_limit_info rx_invitereq_info; /* Used for get the limit scan channel from the Invitation procedure */
struct scan_limit_info p2p_info; /* Used for get the limit scan channel from the P2P negotiation handshake */
#ifdef CONFIG_8723AU_P2P
struct wifi_display_info *wfd_info;
#endif
enum P2P_ROLE role;
enum P2P_STATE pre_p2p_state;
enum P2P_STATE p2p_state;
u8 device_addr[ETH_ALEN]; /* The device address should be the mac address of this device. */
u8 interface_addr[ETH_ALEN];
u8 social_chan[4];
u8 listen_channel;
u8 operating_channel;
u8 listen_dwell; /* This value should be between 1 and 3 */
u8 support_rate[8];
u8 p2p_wildcard_ssid[P2P_WILDCARD_SSID_LEN];
u8 intent; /* should only include the intent value. */
u8 p2p_peer_interface_addr[ETH_ALEN];
u8 p2p_peer_device_addr[ETH_ALEN];
u8 peer_intent; /* Included the intent value and tie breaker value. */
u8 device_name[WPS_MAX_DEVICE_NAME_LEN]; /* Device name for displaying on searching device screen */
u8 device_name_len;
u8 profileindex; /* Used to point to the index of profileinfo array */
u8 peer_operating_ch;
u8 find_phase_state_exchange_cnt;
u16 device_password_id_for_nego; /* The device password ID for group negotation */
u8 negotiation_dialog_token;
/* SSID information for group negotitation */
u8 nego_ssid[IEEE80211_MAX_SSID_LEN];
u8 nego_ssidlen;
u8 p2p_group_ssid[IEEE80211_MAX_SSID_LEN];
u8 p2p_group_ssid_len;
u8 persistent_supported; /* Flag to know the persistent function should be supported or not. */
/* In the Sigma test, the Sigma will provide this enable from the sta_set_p2p CAPI. */
/* 0: disable */
/* 1: enable */
u8 session_available; /* Flag to set the WFD session available to enable or disable "by Sigma" */
/* In the Sigma test, the Sigma will disable the session available by using the sta_preset CAPI. */
/* 0: disable */
/* 1: enable */
u8 wfd_tdls_enable; /* Flag to enable or disable the TDLS by WFD Sigma */
/* 0: disable */
/* 1: enable */
u8 wfd_tdls_weaksec; /* Flag to enable or disable the weak security function for TDLS by WFD Sigma */
/* 0: disable */
/* In this case, the driver can't issue the tdsl setup request frame. */
/* 1: enable */
/* In this case, the driver can issue the tdls setup request frame */
/* even the current security is weak security. */
enum P2P_WPSINFO ui_got_wps_info; /* This field will store the WPS value (PIN value or PBC) that UI had got from the user. */
u16 supported_wps_cm; /* This field describes the WPS config method which this driver supported. */
/* The value should be the combination of config method defined in page104 of WPS v2.0 spec. */
uint channel_list_attr_len; /* This field will contain the length of body of P2P Channel List attribute of group negotitation response frame. */
u8 channel_list_attr[100]; /* This field will contain the body of P2P Channel List attribute of group negotitation response frame. */
/* We will use the channel_cnt and channel_list fields when constructing the group negotitation confirm frame. */
#ifdef CONFIG_8723AU_P2P
enum P2P_PS_MODE p2p_ps_mode; /* indicate p2p ps mode */
enum P2P_PS_STATE p2p_ps_state; /* indicate p2p ps state */
u8 noa_index; /* Identifies and instance of Notice of Absence timing. */
u8 ctwindow; /* Client traffic window. A period of time in TU after TBTT. */
u8 opp_ps; /* opportunistic power save. */
u8 noa_num; /* number of NoA descriptor in P2P IE. */
u8 noa_count[P2P_MAX_NOA_NUM]; /* Count for owner, Type of client. */
u32 noa_duration[P2P_MAX_NOA_NUM]; /* Max duration for owner, preferred or min acceptable duration for client. */
u32 noa_interval[P2P_MAX_NOA_NUM]; /* Length of interval for owner, preferred or max acceptable interval of client. */
u32 noa_start_time[P2P_MAX_NOA_NUM]; /* schedule expressed in terms of the lower 4 bytes of the TSF timer. */
#endif /* CONFIG_8723AU_P2P */
};
struct tdls_ss_record { /* signal strength record */
u8 macaddr[ETH_ALEN];
u8 RxPWDBAll;
@ -324,9 +204,6 @@ struct tdls_info {
u8 watchdog_count;
u8 dev_discovered; /* WFD_TDLS: for sigma test */
u8 enable;
#ifdef CONFIG_8723AU_P2P
struct wifi_display_info *wfd_info;
#endif
};
struct mlme_priv {

16
drivers/staging/rtl8723au/include/rtw_mlme_ext.h
View file

@ -519,10 +519,6 @@ unsigned char check_assoc_AP23a(u8 *pframe, uint len);
int WMM_param_handler23a(struct rtw_adapter *padapter,
struct ndis_802_11_var_ies *pIE);
#ifdef CONFIG_8723AU_P2P
int WFD_info_handler(struct rtw_adapter *padapter,
struct ndis_802_11_var_ies *pIE);
#endif
void WMMOnAssocRsp23a(struct rtw_adapter *padapter);
void HT_caps_handler23a(struct rtw_adapter *padapter,
@ -587,18 +583,6 @@ s32 dump_mgntframe23a_and_wait(struct rtw_adapter *padapter,
s32 dump_mgntframe23a_and_wait_ack23a(struct rtw_adapter *padapter,
struct xmit_frame *pmgntframe);
#ifdef CONFIG_8723AU_P2P
void issue_probersp23a_p2p23a(struct rtw_adapter *padapter, unsigned char *da);
void issue_p2p_provision_request23a(struct rtw_adapter *padapter, u8 *pssid,
u8 ussidlen, u8* pdev_raddr);
void issue_p2p_GO_request23a(struct rtw_adapter *padapter, u8* raddr);
void issue23a_probereq_p2p(struct rtw_adapter *padapter, u8 *da);
int issue23a_probereq_p2p_ex(struct rtw_adapter *adapter, u8 *da, int try_cnt,
int wait_ms);
void issue_p2p_invitation_response23a(struct rtw_adapter *padapter, u8* raddr,
u8 dialogToken, u8 success);
void issue_p2p_invitation_request23a(struct rtw_adapter *padapter, u8* raddr);
#endif /* CONFIG_8723AU_P2P */
void issue_beacon23a(struct rtw_adapter *padapter, int timeout_ms);
void issue_probersp23a(struct rtw_adapter *padapter, unsigned char *da,
u8 is_valid_p2p_probereq);

158
drivers/staging/rtl8723au/include/rtw_p2p.h
View file

@ -1,158 +0,0 @@
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
******************************************************************************/
#ifndef __RTW_P2P_H_
#define __RTW_P2P_H_
#include <drv_types.h>
u32 build_beacon_p2p_ie23a(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_probe_resp_p2p_ie23a(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_prov_disc_request_p2p_ie23a(struct wifidirect_info *pwdinfo, u8 *pbuf,
u8 *pssid, u8 ussidlen, u8 *pdev_raddr);
u32 build_assoc_resp_p2p_ie23a(struct wifidirect_info *pwdinfo, u8 *pbuf,
u8 status_code);
u32 build_deauth_p2p_ie23a(struct wifidirect_info *pwdinfo, u8 *pbuf);
#ifdef CONFIG_8723AU_P2P
u32 build_probe_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_probe_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf,
u8 tunneled);
u32 build_beacon_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_nego_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_nego_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_nego_confirm_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_invitation_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_invitation_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_assoc_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_assoc_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_provdisc_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
u32 build_provdisc_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf);
#endif /* CONFIG_8723AU_P2P */
u32 process_probe_req_p2p_ie23a(struct wifidirect_info *pwdinfo, u8 *pframe,
uint len);
u32 process_assoc_req_p2p_ie23a(struct wifidirect_info *pwdinfo, u8 *pframe,
uint len, struct sta_info *psta);
u32 process_p2p_devdisc_req23a(struct wifidirect_info *pwdinfo, u8 *pframe,
uint len);
u32 process_p2p_devdisc_resp23a(struct wifidirect_info *pwdinfo, u8 *pframe,
uint len);
u8 process_p2p_provdisc_req23a(struct wifidirect_info *pwdinfo, u8 *pframe,
uint len);
u8 process_p2p_provdisc_resp23a(struct wifidirect_info *pwdinfo, u8 *pframe);
u8 process_p2p_group_negotation_req23a(struct wifidirect_info *pwdinfo,
u8 *pframe, uint len);
u8 process_p2p_group_negotation_resp23a(struct wifidirect_info *pwdinfo,
u8 *pframe, uint len);
u8 process_p2p_group_negotation_confirm23a(struct wifidirect_info *pwdinfo,
u8 *pframe, uint len);
u8 process_p2p_presence_req23a(struct wifidirect_info *pwdinfo,
u8 *pframe, uint len);
void p2p_protocol_wk_hdl23a(struct rtw_adapter *padapter, int cmdtype);
#ifdef CONFIG_8723AU_P2P
void process_p2p_ps_ie23a(struct rtw_adapter *padapter, u8 *IEs, u32 IELength);
void p2p_ps_wk_hdl23a(struct rtw_adapter *padapter, u8 p2p_ps_state);
u8 p2p_ps_wk_cmd23a(struct rtw_adapter *padapter, u8 p2p_ps_state, u8 enqueue);
#endif /* CONFIG_8723AU_P2P */
void rtw_init_cfg80211_wifidirect_info(struct rtw_adapter *padapter);
int rtw_p2p_check_frames(struct rtw_adapter *padapter, const u8 *buf,
u32 len, u8 tx);
void rtw_append_wfd_ie(struct rtw_adapter *padapter, u8 *buf, u32 *len);
void reset_global_wifidirect_info23a(struct rtw_adapter *padapter);
int rtw_init_wifi_display_info(struct rtw_adapter *padapter);
void rtw_init_wifidirect_timers23a(struct rtw_adapter *padapter);
void rtw_init_wifidirect_addrs23a(struct rtw_adapter *padapter, u8 *dev_addr,
u8 *iface_addr);
void init_wifidirect_info23a(struct rtw_adapter *padapter, enum P2P_ROLE role);
int rtw_p2p_enable23a(struct rtw_adapter *padapter, enum P2P_ROLE role);
static inline void _rtw_p2p_set_state(struct wifidirect_info *wdinfo,
enum P2P_STATE state)
{
if (wdinfo->p2p_state != state) {
/* wdinfo->pre_p2p_state = wdinfo->p2p_state; */
wdinfo->p2p_state = state;
}
}
static inline void _rtw_p2p_set_pre_state(struct wifidirect_info *wdinfo,
enum P2P_STATE state)
{
if (wdinfo->pre_p2p_state != state)
wdinfo->pre_p2p_state = state;
}
static inline void _rtw_p2p_set_role(struct wifidirect_info *wdinfo,
enum P2P_ROLE role)
{
if (wdinfo->role != role)
wdinfo->role = role;
}
static inline int _rtw_p2p_state(struct wifidirect_info *wdinfo)
{
return wdinfo->p2p_state;
}
static inline int _rtw_p2p_pre_state(struct wifidirect_info *wdinfo)
{
return wdinfo->pre_p2p_state;
}
static inline int _rtw_p2p_role(struct wifidirect_info *wdinfo)
{
return wdinfo->role;
}
static inline bool _rtw_p2p_chk_state(struct wifidirect_info *wdinfo,
enum P2P_STATE state)
{
return wdinfo->p2p_state == state;
}
static inline bool _rtw_p2p_chk_role(struct wifidirect_info *wdinfo,
enum P2P_ROLE role)
{
return wdinfo->role == role;
}
#define rtw_p2p_set_state(wdinfo, state) _rtw_p2p_set_state(wdinfo, state)
#define rtw_p2p_set_pre_state(wdinfo, state) \
_rtw_p2p_set_pre_state(wdinfo, state)
#define rtw_p2p_set_role(wdinfo, role) _rtw_p2p_set_role(wdinfo, role)
#define rtw_p2p_state(wdinfo) _rtw_p2p_state(wdinfo)
#define rtw_p2p_pre_state(wdinfo) _rtw_p2p_pre_state(wdinfo)
#define rtw_p2p_role(wdinfo) _rtw_p2p_role(wdinfo)
#define rtw_p2p_chk_state(wdinfo, state) _rtw_p2p_chk_state(wdinfo, state)
#define rtw_p2p_chk_role(wdinfo, role) _rtw_p2p_chk_role(wdinfo, role)
#define rtw_p2p_findphase_ex_set(wdinfo, value) \
((wdinfo)->find_phase_state_exchange_cnt = (value))
/* is this find phase exchange for social channel scan? */
#define rtw_p2p_findphase_ex_is_social(wdinfo) \
((wdinfo)->find_phase_state_exchange_cnt >= \
P2P_FINDPHASE_EX_SOCIAL_FIRST)
/* should we need find phase exchange anymore? */
#define rtw_p2p_findphase_ex_is_needed(wdinfo) \
((wdinfo)->find_phase_state_exchange_cnt < P2P_FINDPHASE_EX_MAX && \
(wdinfo)->find_phase_state_exchange_cnt != P2P_FINDPHASE_EX_NONE)
#endif

17
drivers/staging/rtl8723au/include/wifi.h
View file

@ -636,23 +636,6 @@ enum P2P_PROTO_WK_ID {
P2P_RO_CH_WK = 6,
};
#ifdef CONFIG_8723AU_P2P
enum P2P_PS_STATE {
P2P_PS_DISABLE = 0,
P2P_PS_ENABLE = 1,
P2P_PS_SCAN = 2,
P2P_PS_SCAN_DONE = 3,
P2P_PS_ALLSTASLEEP = 4, /* for P2P GO */
};
enum P2P_PS_MODE {
P2P_PS_NONE = 0,
P2P_PS_CTWINDOW = 1,
P2P_PS_NOA = 2,
P2P_PS_MIX = 3, /* CTWindow and NoA */
};
#endif /* CONFIG_8723AU_P2P */
/* =====================WFD Section===================== */
/* For Wi-Fi Display */
#define WFD_ATTR_DEVICE_INFO 0x00

851
drivers/staging/rtl8723au/os_dep/ioctl_cfg80211.c
View file

File diff suppressed because it is too large Load diff

42
drivers/staging/rtl8723au/os_dep/os_intfs.c
View file

@ -455,9 +455,6 @@ static u8 rtw_init_default_value(struct rtw_adapter *padapter)
padapter->bWritePortCancel = false;
padapter->bRxRSSIDisplay = 0;
padapter->bNotifyChannelChange = 0;
#ifdef CONFIG_8723AU_P2P
padapter->bShowGetP2PState = 1;
#endif
return ret;
}
@ -520,17 +517,6 @@ u8 rtw_init_drv_sw23a(struct rtw_adapter *padapter)
goto exit;
}
#ifdef CONFIG_8723AU_P2P
rtw_init_wifidirect_timers23a(padapter);
init_wifidirect_info23a(padapter, P2P_ROLE_DISABLE);
reset_global_wifidirect_info23a(padapter);
rtw_init_cfg80211_wifidirect_info(padapter);
#ifdef CONFIG_8723AU_P2P
if (rtw_init_wifi_display_info(padapter) == _FAIL)
RT_TRACE(_module_os_intfs_c_, _drv_err_,
("\n Can't init init_wifi_display_info\n"));
#endif
#endif /* CONFIG_8723AU_P2P */
if (init_mlme_ext_priv23a(padapter) == _FAIL) {
RT_TRACE(_module_os_intfs_c_, _drv_err_,
@ -599,10 +585,6 @@ void rtw_cancel_all_timer23a(struct rtw_adapter *padapter)
del_timer_sync(&padapter->pwrctrlpriv.pwr_state_check_timer);
#ifdef CONFIG_8723AU_P2P
del_timer_sync(&padapter->cfg80211_wdinfo.remain_on_ch_timer);
#endif /* CONFIG_8723AU_P2P */
del_timer_sync(&padapter->mlmepriv.set_scan_deny_timer);
rtw_clear_scan_deny(padapter);
RT_TRACE(_module_os_intfs_c_, _drv_info_,
@ -615,26 +597,8 @@ void rtw_cancel_all_timer23a(struct rtw_adapter *padapter)
u8 rtw_free_drv_sw23a(struct rtw_adapter *padapter)
{
#ifdef CONFIG_8723AU_P2P
struct wifidirect_info *pwdinfo;
#endif
RT_TRACE(_module_os_intfs_c_, _drv_info_, ("==>rtw_free_drv_sw23a"));
/* we can call rtw_p2p_enable23a here, but:
* 1. rtw_p2p_enable23a may have IO operation
* 2. rtw_p2p_enable23a is bundled with wext interface
*/
#ifdef CONFIG_8723AU_P2P
pwdinfo = &padapter->wdinfo;
if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) {
del_timer_sync(&pwdinfo->find_phase_timer);
del_timer_sync(&pwdinfo->restore_p2p_state_timer);
del_timer_sync(&pwdinfo->pre_tx_scan_timer);
rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
}
#endif
free_mlme_ext_priv23a(&padapter->mlmeextpriv);
rtw_free_cmd_priv23a(&padapter->cmdpriv);
@ -945,12 +909,6 @@ static int netdev_close(struct net_device *pnetdev)
rtw_led_control(padapter, LED_CTL_POWER_OFF);
}
#ifdef CONFIG_8723AU_P2P
if (wdev_to_priv(padapter->rtw_wdev)->p2p_enabled)
wdev_to_priv(padapter->rtw_wdev)->p2p_enabled = false;
rtw_p2p_enable23a(padapter, P2P_ROLE_DISABLE);
#endif /* CONFIG_8723AU_P2P */
rtw_scan_abort23a(padapter);
/* set this at the end */
padapter->rtw_wdev->iftype = NL80211_IFTYPE_MONITOR;

4
drivers/staging/rtl8723au/os_dep/usb_intf.c
View file

@ -662,10 +662,6 @@ static struct rtw_adapter *rtw_usb_if1_init(struct dvobj_priv *dvobj,
/* set mac addr */
rtw_macaddr_cfg23a(padapter->eeprompriv.mac_addr);
#ifdef CONFIG_8723AU_P2P
rtw_init_wifidirect_addrs23a(padapter, padapter->eeprompriv.mac_addr,
padapter->eeprompriv.mac_addr);
#endif
DBG_8723A("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n",
padapter->bDriverStopped, padapter->bSurpriseRemoved,