skyfall/rtl8188eu
1
0
Fork 0
mirror of https://github.com/lwfinger/rtl8188eu.git synced 2024-11-22 04:23:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
rtl8188eu/core/rtw_p2p.c
Larry Finger 327817d32a rtl8188eu: Fix most sparse warnings other than endedness problems 
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
2013-06-03 14:52:18 -05:00

4790 lines
132 KiB
C
Raw Blame History

/******************************************************************************
*
* 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.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
*
*
******************************************************************************/
#define _RTW_P2P_C_
#include <drv_types.h>
#include <rtw_p2p.h>
#include <wifi.h>
#ifdef CONFIG_P2P
static int rtw_p2p_is_channel_list_ok( u8 desired_ch, u8* ch_list, u8 ch_cnt )
{
int found = 0, i = 0;
for ( i = 0; i < ch_cnt; i++ )
{
if ( ch_list[ i ] == desired_ch )
{
found = 1;
break;
}
}
return( found );
}
static int is_any_client_associated( _adapter *padapter)
{
_irqL irqL;
_list *phead, *plist;
int intFound = false;
struct sta_priv *pstapriv = &padapter->stapriv;
_enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
if ( rtw_end_of_queue_search(phead, plist) == true )
{
intFound = false;
}
else
{
intFound = true;
}
if ((intFound == false && pstapriv->asoc_list_cnt)
|| (intFound == true && !pstapriv->asoc_list_cnt)) {
DBG_88E("%s intFound:%d, asoc_list_cnt:%u mismatch\n", __func__
, intFound, pstapriv->asoc_list_cnt);
}
_exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
return( intFound );
}
static u32 go_add_group_info_attr(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
_irqL irqL;
_list *phead, *plist;
u32 len=0;
u16 attr_len = 0;
u8 tmplen, *pdata_attr, *pstart, *pcur;
struct sta_info *psta = NULL;
_adapter *padapter = pwdinfo->padapter;
struct sta_priv *pstapriv = &padapter->stapriv;
DBG_88E("%s\n", __func__);
pdata_attr = rtw_zmalloc(MAX_P2P_IE_LEN);
pstart = pdata_attr;
pcur = pdata_attr;
_enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
//look up sta asoc_queue
while ((rtw_end_of_queue_search(phead, plist)) == false)
{
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
if (psta->is_p2p_device)
{
tmplen = 0;
pcur++;
//P2P device address
_rtw_memcpy(pcur, psta->dev_addr, ETH_ALEN);
pcur += ETH_ALEN;
//P2P interface address
_rtw_memcpy(pcur, psta->hwaddr, ETH_ALEN);
pcur += ETH_ALEN;
*pcur = psta->dev_cap;
pcur++;
//*(u16*)(pcur) = cpu_to_be16(psta->config_methods);
RTW_PUT_BE16(pcur, psta->config_methods);
pcur += 2;
_rtw_memcpy(pcur, psta->primary_dev_type, 8);
pcur += 8;
*pcur = psta->num_of_secdev_type;
pcur++;
_rtw_memcpy(pcur, psta->secdev_types_list, psta->num_of_secdev_type*8);
pcur += psta->num_of_secdev_type*8;
if (psta->dev_name_len>0)
{
//*(u16*)(pcur) = cpu_to_be16( WPS_ATTR_DEVICE_NAME );
RTW_PUT_BE16(pcur, WPS_ATTR_DEVICE_NAME);
pcur += 2;
//*(u16*)(pcur) = cpu_to_be16( psta->dev_name_len );
RTW_PUT_BE16(pcur, psta->dev_name_len);
pcur += 2;
_rtw_memcpy(pcur, psta->dev_name, psta->dev_name_len);
pcur += psta->dev_name_len;
}
tmplen = (u8)(pcur-pstart);
*pstart = (tmplen-1);
attr_len += tmplen;
//pstart += tmplen;
pstart = pcur;
}
}
_exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
if (attr_len>0)
{
len = rtw_set_p2p_attr_content(pbuf, P2P_ATTR_GROUP_INFO, attr_len, pdata_attr);
}
rtw_mfree(pdata_attr, MAX_P2P_IE_LEN);
return len;
}
static void issue_group_disc_req(struct wifidirect_info *pwdinfo, u8 *da)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
_adapter *padapter = pwdinfo->padapter;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
unsigned char category = RTW_WLAN_CATEGORY_P2P;//P2P action frame
u32 p2poui = cpu_to_be32(P2POUI);
u8 oui_subtype = P2P_GO_DISC_REQUEST;
u8 dialogToken=0;
DBG_88E("[%s]\n", __func__);
if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
{
return;
}
//update attribute
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pwdinfo->interface_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pwdinfo->interface_addr, ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
SetFrameSubType(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
//Build P2P action frame header
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *) &(p2poui), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(oui_subtype), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(dialogToken), &(pattrib->pktlen));
//there is no IE in this P2P action frame
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
}
static void issue_p2p_devdisc_resp(struct wifidirect_info *pwdinfo, u8 *da, u8 status, u8 dialogToken)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
_adapter *padapter = pwdinfo->padapter;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
unsigned char category = RTW_WLAN_CATEGORY_PUBLIC;
u8 action = P2P_PUB_ACTION_ACTION;
u32 p2poui = cpu_to_be32(P2POUI);
u8 oui_subtype = P2P_DEVDISC_RESP;
u8 p2pie[8] = { 0x00 };
u32 p2pielen = 0;
DBG_88E("[%s]\n", __func__);
if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
{
return;
}
//update attribute
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pwdinfo->device_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pwdinfo->device_addr, ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
SetFrameSubType(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
//Build P2P public action frame header
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *) &(p2poui), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(oui_subtype), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(dialogToken), &(pattrib->pktlen));
//Build P2P IE
// P2P OUI
p2pielen = 0;
p2pie[ p2pielen++ ] = 0x50;
p2pie[ p2pielen++ ] = 0x6F;
p2pie[ p2pielen++ ] = 0x9A;
p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
// P2P_ATTR_STATUS
p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_STATUS, 1, &status);
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, p2pielen, p2pie, &pattrib->pktlen);
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
}
static void issue_p2p_provision_resp(struct wifidirect_info *pwdinfo, u8* raddr, u8* frame_body, u16 config_method)
{
_adapter *padapter = pwdinfo->padapter;
unsigned char category = RTW_WLAN_CATEGORY_PUBLIC;
u8 action = P2P_PUB_ACTION_ACTION;
u8 dialogToken = frame_body[7]; // The Dialog Token of provisioning discovery request frame.
u32 p2poui = cpu_to_be32(P2POUI);
u8 oui_subtype = P2P_PROVISION_DISC_RESP;
u8 wpsie[ 100 ] = { 0x00 };
u8 wpsielen = 0;
#ifdef CONFIG_WFD
u32 wfdielen = 0;
#endif //CONFIG_WFD
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
{
return;
}
//update attribute
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, raddr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, myid(&(padapter->eeprompriv)), ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
SetFrameSubType(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *) &(p2poui), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(oui_subtype), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(dialogToken), &(pattrib->pktlen));
wpsielen = 0;
// WPS OUI
RTW_PUT_BE32(wpsie, WPSOUI);
wpsielen += 4;
// Config Method
// Type:
RTW_PUT_BE16(wpsie + wpsielen, WPS_ATTR_CONF_METHOD);
wpsielen += 2;
// Length:
RTW_PUT_BE16(wpsie + wpsielen, 0x0002);
wpsielen += 2;
// Value:
RTW_PUT_BE16(wpsie + wpsielen, config_method);
wpsielen += 2;
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, wpsielen, (unsigned char *) wpsie, &pattrib->pktlen );
#ifdef CONFIG_WFD
wfdielen = build_provdisc_resp_wfd_ie(pwdinfo, pframe);
pframe += wfdielen;
pattrib->pktlen += wfdielen;
#endif //CONFIG_WFD
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
return;
}
static void issue_p2p_presence_resp(struct wifidirect_info *pwdinfo, u8 *da, u8 status, u8 dialogToken)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
struct rtw_ieee80211_hdr *pwlanhdr;
unsigned short *fctrl;
_adapter *padapter = pwdinfo->padapter;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
unsigned char category = RTW_WLAN_CATEGORY_P2P;//P2P action frame
u32 p2poui = cpu_to_be32(P2POUI);
u8 oui_subtype = P2P_PRESENCE_RESPONSE;
u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
u8 noa_attr_content[32] = { 0x00 };
u32 p2pielen = 0;
DBG_88E("[%s]\n", __func__);
if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
{
return;
}
//update attribute
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
_rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_ctl);
*(fctrl) = 0;
_rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr2, pwdinfo->interface_addr, ETH_ALEN);
_rtw_memcpy(pwlanhdr->addr3, pwdinfo->interface_addr, ETH_ALEN);
SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
pmlmeext->mgnt_seq++;
SetFrameSubType(pframe, WIFI_ACTION);
pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
//Build P2P action frame header
pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *) &(p2poui), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(oui_subtype), &(pattrib->pktlen));
pframe = rtw_set_fixed_ie(pframe, 1, &(dialogToken), &(pattrib->pktlen));
//Add P2P IE header
// P2P OUI
p2pielen = 0;
p2pie[ p2pielen++ ] = 0x50;
p2pie[ p2pielen++ ] = 0x6F;
p2pie[ p2pielen++ ] = 0x9A;
p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
//Add Status attribute in P2P IE
p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_STATUS, 1, &status);
//Add NoA attribute in P2P IE
noa_attr_content[0] = 0x1;//index
noa_attr_content[1] = 0x0;//CTWindow and OppPS Parameters
//todo: Notice of Absence Descriptor(s)
p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_NOA, 2, noa_attr_content);
pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, p2pielen, p2pie, &(pattrib->pktlen));
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
}
u32 build_beacon_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
u16 capability=0;
u32 len=0, p2pielen = 0;
// P2P OUI
p2pielen = 0;
p2pie[ p2pielen++ ] = 0x50;
p2pie[ p2pielen++ ] = 0x6F;
p2pie[ p2pielen++ ] = 0x9A;
p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
// According to the P2P Specification, the beacon frame should contain 3 P2P attributes
// 1. P2P Capability
// 2. P2P Device ID
// 3. Notice of Absence ( NOA )
// P2P Capability ATTR
// Type:
// Length:
// Value:
// Device Capability Bitmap, 1 byte
// Be able to participate in additional P2P Groups and
// support the P2P Invitation Procedure
// Group Capability Bitmap, 1 byte
capability = P2P_DEVCAP_INVITATION_PROC|P2P_DEVCAP_CLIENT_DISCOVERABILITY;
capability |= ((P2P_GRPCAP_GO | P2P_GRPCAP_INTRABSS) << 8);
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_PROVISIONING_ING))
capability |= (P2P_GRPCAP_GROUP_FORMATION<<8);
capability = cpu_to_le16(capability);
p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_CAPABILITY, 2, (u8*)&capability);
// P2P Device ID ATTR
p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_DEVICE_ID, ETH_ALEN, pwdinfo->device_addr);
// Notice of Absence ATTR
// Type:
// Length:
// Value:
//go_add_noa_attr(pwdinfo);
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, p2pielen, (unsigned char *) p2pie, &len);
return len;
}
#ifdef CONFIG_WFD
u32 build_beacon_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110812
// According to the WFD Specification, the beacon frame should contain 4 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID
// 3. Coupled Sink Information
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
if ( P2P_ROLE_GO == pwdinfo->role )
{
if ( is_any_client_associated( pwdinfo->padapter ) )
{
// WFD primary sink + WiFi Direct mode + WSD (WFD Service Discovery)
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_WSD );
}
else
{
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD (WFD Service Discovery)
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD );
}
}
else
{
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD );
}
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_probe_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110812
// According to the WFD Specification, the probe request frame should contain 4 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID
// 3. Coupled Sink Information
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
if ( 1 == pwdinfo->wfd_tdls_enable )
{
// WFD primary sink + available for WFD session + WiFi TDLS mode + WSC ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type |
WFD_DEVINFO_SESSION_AVAIL |
WFD_DEVINFO_WSD |
WFD_DEVINFO_PC_TDLS );
}
else
{
// WFD primary sink + available for WFD session + WiFi Direct mode + WSC ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type |
WFD_DEVINFO_SESSION_AVAIL |
WFD_DEVINFO_WSD );
}
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_probe_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf, u8 tunneled)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110812
// According to the WFD Specification, the probe response frame should contain 4 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID
// 3. Coupled Sink Information
// 4. WFD Session Information
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + available for WFD session + WiFi Direct mode
if ( true == pwdinfo->session_available )
{
if ( P2P_ROLE_GO == pwdinfo->role )
{
if ( is_any_client_associated( pwdinfo->padapter ) )
{
if ( pwdinfo->wfd_tdls_enable )
{
// WFD primary sink + TDLS mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, WFD_DEVINFO_PSINK | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT);
}
else
{
// WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, WFD_DEVINFO_PSINK | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT);
}
}
else
{
if ( pwdinfo->wfd_tdls_enable )
{
// WFD primary sink + available for WFD session + TDLS mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, WFD_DEVINFO_PSINK | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT);
}
else
{
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, WFD_DEVINFO_PSINK | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT);
}
}
}
else
{
if ( pwdinfo->wfd_tdls_enable )
{
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, WFD_DEVINFO_PSINK | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT);
}
else
{
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, WFD_DEVINFO_PSINK | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT);
}
}
}
else
{
if ( pwdinfo->wfd_tdls_enable )
{
RTW_PUT_BE16(wfdie + wfdielen, WFD_DEVINFO_PSINK | WFD_DEVINFO_WSD |WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT);
}
else
{
RTW_PUT_BE16(wfdie + wfdielen, WFD_DEVINFO_PSINK | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT);
}
}
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
// WFD Session Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_SESSION_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
wfdielen += 2;
// Todo: to add the list of WFD device info descriptor in WFD group.
}
#ifdef CONFIG_CONCURRENT_MODE
#ifdef CONFIG_TDLS
if ( ( tunneled == 0 ) && ( padapter->pbuddy_adapter->wdinfo.wfd_tdls_enable == 1 ) )
{
// Alternative MAC Address ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ALTER_MAC;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, ETH_ALEN );
wfdielen += 2;
// Value:
// Alternative MAC Address
_rtw_memcpy( wfdie + wfdielen, &padapter->pbuddy_adapter->eeprompriv.mac_addr[ 0 ], ETH_ALEN );
// This mac address is used to make the WFD session when TDLS is enable.
wfdielen += ETH_ALEN;
}
#endif // CONFIG_TDLS
#endif // CONFIG_CONCURRENT_MODE
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_assoc_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = NULL;
struct mlme_priv *pmlmepriv = NULL;
struct wifi_display_info *pwfd_info = NULL;
// WFD OUI
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE) || rtw_p2p_chk_state(pwdinfo, P2P_STATE_IDLE))
{
return 0;
}
padapter = pwdinfo->padapter;
pmlmepriv = &padapter->mlmepriv;
pwfd_info = padapter->wdinfo.wfd_info;
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110812
// According to the WFD Specification, the probe request frame should contain 4 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID
// 3. Coupled Sink Information
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD );
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_assoc_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110812
// According to the WFD Specification, the probe request frame should contain 4 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID
// 3. Coupled Sink Information
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD );
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_nego_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110825
// According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID ( Optional )
// 3. Local IP Adress ( Optional )
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL);
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_nego_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110825
// According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID ( Optional )
// 3. Local IP Adress ( Optional )
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL);
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_nego_confirm_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110825
// According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID ( Optional )
// 3. Local IP Adress ( Optional )
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL);
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_invitation_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110825
// According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID ( Optional )
// 3. Local IP Adress ( Optional )
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD );
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
if ( P2P_ROLE_GO == pwdinfo->role )
{
// WFD Session Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_SESSION_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
wfdielen += 2;
// Todo: to add the list of WFD device info descriptor in WFD group.
}
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_invitation_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110825
// According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID ( Optional )
// 3. Local IP Adress ( Optional )
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD );
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
if ( P2P_ROLE_GO == pwdinfo->role )
{
// WFD Session Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_SESSION_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
wfdielen += 2;
// Todo: to add the list of WFD device info descriptor in WFD group.
}
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_provdisc_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110825
// According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID ( Optional )
// 3. Local IP Adress ( Optional )
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD );
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
u32 build_provdisc_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
u32 len=0, wfdielen = 0;
_adapter *padapter = pwdinfo->padapter;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
// WFD OUI
wfdielen = 0;
wfdie[ wfdielen++ ] = 0x50;
wfdie[ wfdielen++ ] = 0x6F;
wfdie[ wfdielen++ ] = 0x9A;
wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
// Commented by Albert 20110825
// According to the WFD Specification, the provision discovery response frame should contain 3 WFD attributes
// 1. WFD Device Information
// 2. Associated BSSID ( Optional )
// 3. Local IP Adress ( Optional )
// WFD Device Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value1:
// WFD device information
// WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD );
wfdielen += 2;
// Value2:
// Session Management Control Port
// Default TCP port for RTSP messages is 554
RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
wfdielen += 2;
// Value3:
// WFD Device Maximum Throughput
// 300Mbps is the maximum throughput
RTW_PUT_BE16(wfdie + wfdielen, 300);
wfdielen += 2;
// Associated BSSID ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
wfdielen += 2;
// Value:
// Associated BSSID
if ( check_fwstate(pmlmepriv, _FW_LINKED) == true )
{
_rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
}
else
{
_rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
}
wfdielen += ETH_ALEN;
// Coupled Sink Information ATTR
// Type:
wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
// Length:
// Note: In the WFD specification, the size of length field is 2.
RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
wfdielen += 2;
// Value:
// Coupled Sink Status bitmap
// Not coupled/available for Coupling
wfdie[ wfdielen++ ] = 0;
// MAC Addr.
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
wfdie[ wfdielen++ ] = 0;
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
return len;
}
#endif //CONFIG_WFD
u32 build_probe_resp_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
u32 len=0, p2pielen = 0;
#ifdef CONFIG_INTEL_WIDI
u8 zero_array_check[L2SDTA_SERVICE_VE_LEN] = { 0x00 };
#endif //CONFIG_INTEL_WIDI
// P2P OUI
p2pielen = 0;
p2pie[ p2pielen++ ] = 0x50;
p2pie[ p2pielen++ ] = 0x6F;
p2pie[ p2pielen++ ] = 0x9A;
p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
// Commented by Albert 20100907
// According to the P2P Specification, the probe response frame should contain 5 P2P attributes
// 1. P2P Capability
// 2. Extended Listen Timing
// 3. Notice of Absence ( NOA ) ( Only GO needs this )
// 4. Device Info
// 5. Group Info ( Only GO need this )
// P2P Capability ATTR
// Type:
p2pie[ p2pielen++ ] = P2P_ATTR_CAPABILITY;
// Length:
//*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0x0002 );
RTW_PUT_LE16(p2pie + p2pielen, 0x0002);
p2pielen += 2;
// Value:
// Device Capability Bitmap, 1 byte
p2pie[ p2pielen++ ] = DMP_P2P_DEVCAP_SUPPORT;
// Group Capability Bitmap, 1 byte
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
p2pie[ p2pielen ] = (P2P_GRPCAP_GO | P2P_GRPCAP_INTRABSS);
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_PROVISIONING_ING))
p2pie[ p2pielen ] |= P2P_GRPCAP_GROUP_FORMATION;
p2pielen++;
}
else if ( rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) )
{
// Group Capability Bitmap, 1 byte
if ( pwdinfo->persistent_supported )
p2pie[ p2pielen++ ] = P2P_GRPCAP_PERSISTENT_GROUP | DMP_P2P_GRPCAP_SUPPORT;
else
p2pie[ p2pielen++ ] = DMP_P2P_GRPCAP_SUPPORT;
}
// Extended Listen Timing ATTR
// Type:
p2pie[ p2pielen++ ] = P2P_ATTR_EX_LISTEN_TIMING;
// Length:
//*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0x0004 );
RTW_PUT_LE16(p2pie + p2pielen, 0x0004);
p2pielen += 2;
// Value:
// Availability Period
//*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0xFFFF );
RTW_PUT_LE16(p2pie + p2pielen, 0xFFFF);
p2pielen += 2;
// Availability Interval
//*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0xFFFF );
RTW_PUT_LE16(p2pie + p2pielen, 0xFFFF);
p2pielen += 2;
// Notice of Absence ATTR
// Type:
// Length:
// Value:
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
//go_add_noa_attr(pwdinfo);
}
// Device Info ATTR
// Type:
p2pie[ p2pielen++ ] = P2P_ATTR_DEVICE_INFO;
// Length:
// 21 -> P2P Device Address (6bytes) + Config Methods (2bytes) + Primary Device Type (8bytes)
// + NumofSecondDevType (1byte) + WPS Device Name ID field (2bytes) + WPS Device Name Len field (2bytes)
//*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 21 + pwdinfo->device_name_len );
#ifdef CONFIG_INTEL_WIDI
if ( _rtw_memcmp( pwdinfo->padapter->mlmepriv.sa_ext, zero_array_check, L2SDTA_SERVICE_VE_LEN ) == false )
{
RTW_PUT_LE16(p2pie + p2pielen, 21 + 8 + pwdinfo->device_name_len);
}
else
#endif //CONFIG_INTEL_WIDI
RTW_PUT_LE16(p2pie + p2pielen, 21 + pwdinfo->device_name_len);
p2pielen += 2;
// Value:
// P2P Device Address
_rtw_memcpy( p2pie + p2pielen, pwdinfo->device_addr, ETH_ALEN );
p2pielen += ETH_ALEN;
// Config Method
// This field should be big endian. Noted by P2P specification.
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( pwdinfo->supported_wps_cm );
RTW_PUT_BE16(p2pie + p2pielen, pwdinfo->supported_wps_cm);
p2pielen += 2;
// Primary Device Type
// Category ID
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_CID_MULIT_MEDIA );
RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_CID_MULIT_MEDIA);
p2pielen += 2;
// OUI
//*(u32*) ( p2pie + p2pielen ) = cpu_to_be32( WPSOUI );
RTW_PUT_BE32(p2pie + p2pielen, WPSOUI);
p2pielen += 4;
// Sub Category ID
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_SCID_MEDIA_SERVER );
RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_SCID_MEDIA_SERVER);
p2pielen += 2;
// Number of Secondary Device Types
#ifdef CONFIG_INTEL_WIDI
if ( _rtw_memcmp( pwdinfo->padapter->mlmepriv.sa_ext, zero_array_check, L2SDTA_SERVICE_VE_LEN ) == false )
{
p2pie[ p2pielen++ ] = 0x01;
RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_CID_DISPLAYS);
p2pielen += 2;
RTW_PUT_BE32(p2pie + p2pielen, INTEL_DEV_TYPE_OUI);
p2pielen += 4;
RTW_PUT_BE16(p2pie + p2pielen, P2P_SCID_WIDI_CONSUMER_SINK);
p2pielen += 2;
}
else
#endif //CONFIG_INTEL_WIDI
p2pie[ p2pielen++ ] = 0x00; // No Secondary Device Type List
// Device Name
// Type:
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_ATTR_DEVICE_NAME );
RTW_PUT_BE16(p2pie + p2pielen, WPS_ATTR_DEVICE_NAME);
p2pielen += 2;
// Length:
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( pwdinfo->device_name_len );
RTW_PUT_BE16(p2pie + p2pielen, pwdinfo->device_name_len);
p2pielen += 2;
// Value:
_rtw_memcpy( p2pie + p2pielen, pwdinfo->device_name, pwdinfo->device_name_len );
p2pielen += pwdinfo->device_name_len;
// Group Info ATTR
// Type:
// Length:
// Value:
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
p2pielen += go_add_group_info_attr(pwdinfo, p2pie + p2pielen);
}
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, p2pielen, (unsigned char *) p2pie, &len);
return len;
}
u32 build_prov_disc_request_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf, u8* pssid, u8 ussidlen, u8* pdev_raddr )
{
u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
u32 len=0, p2pielen = 0;
// P2P OUI
p2pielen = 0;
p2pie[ p2pielen++ ] = 0x50;
p2pie[ p2pielen++ ] = 0x6F;
p2pie[ p2pielen++ ] = 0x9A;
p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
// Commented by Albert 20110301
// According to the P2P Specification, the provision discovery request frame should contain 3 P2P attributes
// 1. P2P Capability
// 2. Device Info
// 3. Group ID ( When joining an operating P2P Group )
// P2P Capability ATTR
// Type:
p2pie[ p2pielen++ ] = P2P_ATTR_CAPABILITY;
// Length:
//*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0x0002 );
RTW_PUT_LE16(p2pie + p2pielen, 0x0002);
p2pielen += 2;
// Value:
// Device Capability Bitmap, 1 byte
p2pie[ p2pielen++ ] = DMP_P2P_DEVCAP_SUPPORT;
// Group Capability Bitmap, 1 byte
if ( pwdinfo->persistent_supported )
p2pie[ p2pielen++ ] = P2P_GRPCAP_PERSISTENT_GROUP | DMP_P2P_GRPCAP_SUPPORT;
else
p2pie[ p2pielen++ ] = DMP_P2P_GRPCAP_SUPPORT;
// Device Info ATTR
// Type:
p2pie[ p2pielen++ ] = P2P_ATTR_DEVICE_INFO;
// Length:
// 21 -> P2P Device Address (6bytes) + Config Methods (2bytes) + Primary Device Type (8bytes)
// + NumofSecondDevType (1byte) + WPS Device Name ID field (2bytes) + WPS Device Name Len field (2bytes)
//*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 21 + pwdinfo->device_name_len );
RTW_PUT_LE16(p2pie + p2pielen, 21 + pwdinfo->device_name_len);
p2pielen += 2;
// Value:
// P2P Device Address
_rtw_memcpy( p2pie + p2pielen, pwdinfo->device_addr, ETH_ALEN );
p2pielen += ETH_ALEN;
// Config Method
// This field should be big endian. Noted by P2P specification.
if ( pwdinfo->ui_got_wps_info == P2P_GOT_WPSINFO_PBC )
{
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_CONFIG_METHOD_PBC );
RTW_PUT_BE16(p2pie + p2pielen, WPS_CONFIG_METHOD_PBC);
}
else
{
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_CONFIG_METHOD_DISPLAY );
RTW_PUT_BE16(p2pie + p2pielen, WPS_CONFIG_METHOD_DISPLAY);
}
p2pielen += 2;
// Primary Device Type
// Category ID
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_CID_MULIT_MEDIA );
RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_CID_MULIT_MEDIA);
p2pielen += 2;
// OUI
//*(u32*) ( p2pie + p2pielen ) = cpu_to_be32( WPSOUI );
RTW_PUT_BE32(p2pie + p2pielen, WPSOUI);
p2pielen += 4;
// Sub Category ID
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_SCID_MEDIA_SERVER );
RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_SCID_MEDIA_SERVER);
p2pielen += 2;
// Number of Secondary Device Types
p2pie[ p2pielen++ ] = 0x00; // No Secondary Device Type List
// Device Name
// Type:
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_ATTR_DEVICE_NAME );
RTW_PUT_BE16(p2pie + p2pielen, WPS_ATTR_DEVICE_NAME);
p2pielen += 2;
// Length:
//*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( pwdinfo->device_name_len );
RTW_PUT_BE16(p2pie + p2pielen, pwdinfo->device_name_len);
p2pielen += 2;
// Value:
_rtw_memcpy( p2pie + p2pielen, pwdinfo->device_name, pwdinfo->device_name_len );
p2pielen += pwdinfo->device_name_len;
if ( rtw_p2p_chk_role(pwdinfo, P2P_ROLE_CLIENT) )
{
// Added by Albert 2011/05/19
// In this case, the pdev_raddr is the device address of the group owner.
// P2P Group ID ATTR
// Type:
p2pie[ p2pielen++ ] = P2P_ATTR_GROUP_ID;
// Length:
//*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( ETH_ALEN + ussidlen );
RTW_PUT_LE16(p2pie + p2pielen, ETH_ALEN + ussidlen);
p2pielen += 2;
// Value:
_rtw_memcpy( p2pie + p2pielen, pdev_raddr, ETH_ALEN );
p2pielen += ETH_ALEN;
_rtw_memcpy( p2pie + p2pielen, pssid, ussidlen );
p2pielen += ussidlen;
}
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, p2pielen, (unsigned char *) p2pie, &len);
return len;
}
u32 build_assoc_resp_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf, u8 status_code)
{
u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
u32 len=0, p2pielen = 0;
// P2P OUI
p2pielen = 0;
p2pie[ p2pielen++ ] = 0x50;
p2pie[ p2pielen++ ] = 0x6F;
p2pie[ p2pielen++ ] = 0x9A;
p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
// According to the P2P Specification, the Association response frame should contain 2 P2P attributes
// 1. Status
// 2. Extended Listen Timing (optional)
// Status ATTR
p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_STATUS, 1, &status_code);
// Extended Listen Timing ATTR
// Type:
// Length:
// Value:
pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, p2pielen, (unsigned char *) p2pie, &len);
return len;
}
u32 build_deauth_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
{
u32 len=0;
return len;
}
u32 process_probe_req_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
{
u8 *p;
u32 ret=false;
u8 *p2pie;
u32 p2pielen = 0;
int ssid_len=0, rate_cnt = 0;
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SUPPORTEDRATES_IE_, (int *)&rate_cnt,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
if ( rate_cnt <= 4 )
{
int i, g_rate =0;
for ( i = 0; i < rate_cnt; i++ )
{
if ( ( ( *( p + 2 + i ) & 0xff ) != 0x02 ) &&
( ( *( p + 2 + i ) & 0xff ) != 0x04 ) &&
( ( *( p + 2 + i ) & 0xff ) != 0x0B ) &&
( ( *( p + 2 + i ) & 0xff ) != 0x16 ) )
{
g_rate = 1;
}
}
if ( g_rate == 0 )
{
// There is no OFDM rate included in SupportedRates IE of this probe request frame
// The driver should response this probe request.
return ret;
}
}
else
{
// rate_cnt > 4 means the SupportRates IE contains the OFDM rate because the count of CCK rates are 4.
// We should proceed the following check for this probe request.
}
// Added comments by Albert 20100906
// There are several items we should check here.
// 1. This probe request frame must contain the P2P IE. (Done)
// 2. This probe request frame must contain the wildcard SSID. (Done)
// 3. Wildcard BSSID. (Todo)
// 4. Destination Address. ( Done in mgt_dispatcher function )
// 5. Requested Device Type in WSC IE. (Todo)
// 6. Device ID attribute in P2P IE. (Todo)
p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SSID_IE_, (int *)&ssid_len,
len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
ssid_len &= 0xff; // Just last 1 byte is valid for ssid len of the probe request
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) || rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
if ((p2pie=rtw_get_p2p_ie( pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_ , len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_ , NULL, &p2pielen)))
{
if ( (p != NULL) && _rtw_memcmp( ( void * ) ( p+2 ), ( void * ) pwdinfo->p2p_wildcard_ssid , 7 ))
{
//todo:
//Check Requested Device Type attributes in WSC IE.
//Check Device ID attribute in P2P IE
ret = true;
}
else if ( (p != NULL) && ( ssid_len == 0 ) )
{
ret = true;
}
}
else
{
//non -p2p device
}
}
return ret;
}
u32 process_assoc_req_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pframe, uint len, struct sta_info *psta)
{
u8 status_code = P2P_STATUS_SUCCESS;
u8 *pbuf, *pattr_content=NULL;
u32 attr_contentlen = 0;
u16 cap_attr=0;
unsigned short frame_type, ie_offset=0;
u8 * ies;
u32 ies_len;
u8 * p2p_ie;
u32 p2p_ielen = 0;
if (!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
return P2P_STATUS_FAIL_REQUEST_UNABLE;
frame_type = GetFrameSubType(pframe);
if (frame_type == WIFI_ASSOCREQ)
{
ie_offset = _ASOCREQ_IE_OFFSET_;
}
else // WIFI_REASSOCREQ
{
ie_offset = _REASOCREQ_IE_OFFSET_;
}
ies = pframe + WLAN_HDR_A3_LEN + ie_offset;
ies_len = len - WLAN_HDR_A3_LEN - ie_offset;
p2p_ie = rtw_get_p2p_ie(ies , ies_len , NULL, &p2p_ielen);
if ( !p2p_ie )
{
DBG_88E( "[%s] P2P IE not Found!!\n", __func__ );
status_code = P2P_STATUS_FAIL_INVALID_PARAM;
}
else
{
DBG_88E( "[%s] P2P IE Found!!\n", __func__ );
}
while ( p2p_ie )
{
//Check P2P Capability ATTR
if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_CAPABILITY, (u8*)&cap_attr, (uint*) &attr_contentlen) )
{
DBG_88E( "[%s] Got P2P Capability Attr!!\n", __func__ );
cap_attr = le16_to_cpu(cap_attr);
psta->dev_cap = cap_attr&0xff;
}
//Check Extended Listen Timing ATTR
//Check P2P Device Info ATTR
if (rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_DEVICE_INFO, NULL, (uint*)&attr_contentlen))
{
DBG_88E( "[%s] Got P2P DEVICE INFO Attr!!\n", __func__ );
pattr_content = pbuf = rtw_zmalloc(attr_contentlen);
if (pattr_content)
{
u8 num_of_secdev_type;
u16 dev_name_len;
rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_DEVICE_INFO , pattr_content, (uint*)&attr_contentlen);
_rtw_memcpy(psta->dev_addr, pattr_content, ETH_ALEN);//P2P Device Address
pattr_content += ETH_ALEN;
_rtw_memcpy(&psta->config_methods, pattr_content, 2);//Config Methods
psta->config_methods = be16_to_cpu(psta->config_methods);
pattr_content += 2;
_rtw_memcpy(psta->primary_dev_type, pattr_content, 8);
pattr_content += 8;
num_of_secdev_type = *pattr_content;
pattr_content += 1;
if (num_of_secdev_type==0)
{
psta->num_of_secdev_type = 0;
}
else
{
u32 len;
psta->num_of_secdev_type = num_of_secdev_type;
len = (sizeof(psta->secdev_types_list)<(num_of_secdev_type*8)) ? (sizeof(psta->secdev_types_list)) : (num_of_secdev_type*8);
_rtw_memcpy(psta->secdev_types_list, pattr_content, len);
pattr_content += (num_of_secdev_type*8);
}
//dev_name_len = attr_contentlen - ETH_ALEN - 2 - 8 - 1 - (num_of_secdev_type*8);
psta->dev_name_len=0;
if (WPS_ATTR_DEVICE_NAME == be16_to_cpu(*(u16*)pattr_content))
{
dev_name_len = be16_to_cpu(*(u16*)(pattr_content+2));
psta->dev_name_len = (sizeof(psta->dev_name)<dev_name_len) ? sizeof(psta->dev_name):dev_name_len;
_rtw_memcpy(psta->dev_name, pattr_content+4, psta->dev_name_len);
}
rtw_mfree(pbuf, attr_contentlen);
}
}
//Get the next P2P IE
p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
}
return status_code;
}
u32 process_p2p_devdisc_req(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
{
u8 *frame_body;
u8 status, dialogToken;
struct sta_info *psta = NULL;
_adapter *padapter = pwdinfo->padapter;
struct sta_priv *pstapriv = &padapter->stapriv;
u8 *p2p_ie;
u32 p2p_ielen = 0;
frame_body = (unsigned char *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
dialogToken = frame_body[7];
status = P2P_STATUS_FAIL_UNKNOWN_P2PGROUP;
if ( (p2p_ie=rtw_get_p2p_ie( frame_body + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, NULL, &p2p_ielen)) )
{
u8 groupid[ 38 ] = { 0x00 };
u8 dev_addr[ETH_ALEN] = { 0x00 };
u32 attr_contentlen = 0;
if (rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GROUP_ID, groupid, &attr_contentlen))
{
if (_rtw_memcmp(pwdinfo->device_addr, groupid, ETH_ALEN) &&
_rtw_memcmp(pwdinfo->p2p_group_ssid, groupid+ETH_ALEN, pwdinfo->p2p_group_ssid_len))
{
attr_contentlen=0;
if (rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_DEVICE_ID, dev_addr, &attr_contentlen))
{
_irqL irqL;
_list *phead, *plist;
_enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
phead = &pstapriv->asoc_list;
plist = get_next(phead);
//look up sta asoc_queue
while ((rtw_end_of_queue_search(phead, plist)) == false)
{
psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
plist = get_next(plist);
if (psta->is_p2p_device && (psta->dev_cap&P2P_DEVCAP_CLIENT_DISCOVERABILITY) &&
_rtw_memcmp(psta->dev_addr, dev_addr, ETH_ALEN))
{
//_exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
//issue GO Discoverability Request
issue_group_disc_req(pwdinfo, psta->hwaddr);
//_enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
status = P2P_STATUS_SUCCESS;
break;
}
else
{
status = P2P_STATUS_FAIL_INFO_UNAVAILABLE;
}
}
_exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
}
else
{
status = P2P_STATUS_FAIL_INVALID_PARAM;
}
}
else
{
status = P2P_STATUS_FAIL_INVALID_PARAM;
}
}
}
//issue Device Discoverability Response
issue_p2p_devdisc_resp(pwdinfo, GetAddr2Ptr(pframe), status, dialogToken);
return (status==P2P_STATUS_SUCCESS) ? true:false;
}
u32 process_p2p_devdisc_resp(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
{
return true;
}
u8 process_p2p_provdisc_req(struct wifidirect_info *pwdinfo, u8 *pframe, uint len )
{
u8 *frame_body;
u8 *wpsie;
uint wps_ielen = 0, attr_contentlen = 0;
u16 uconfig_method = 0;
frame_body = (pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
if ( (wpsie=rtw_get_wps_ie( frame_body + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, NULL, &wps_ielen)) )
{
if ( rtw_get_wps_attr_content( wpsie, wps_ielen, WPS_ATTR_CONF_METHOD , ( u8* ) &uconfig_method, &attr_contentlen) )
{
uconfig_method = be16_to_cpu( uconfig_method );
switch ( uconfig_method )
{
case WPS_CM_DISPLYA:
{
_rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "dis", 3 );
break;
}
case WPS_CM_LABEL:
{
_rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "lab", 3 );
break;
}
case WPS_CM_PUSH_BUTTON:
{
_rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "pbc", 3 );
break;
}
case WPS_CM_KEYPAD:
{
_rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "pad", 3 );
break;
}
}
issue_p2p_provision_resp( pwdinfo, GetAddr2Ptr(pframe), frame_body, uconfig_method);
}
}
DBG_88E( "[%s] config method = %s\n", __func__, pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req );
return true;
}
u8 process_p2p_provdisc_resp(struct wifidirect_info *pwdinfo, u8 *pframe)
{
return true;
}
u8 rtw_p2p_get_peer_ch_list(struct wifidirect_info *pwdinfo, u8 *ch_content, u8 ch_cnt, u8 *peer_ch_list)
{
u8 i = 0, j = 0;
u8 temp = 0;
u8 ch_no = 0;
ch_content += 3;
ch_cnt -= 3;
while ( ch_cnt > 0)
{
ch_content += 1;
ch_cnt -= 1;
temp = *ch_content;
for ( i = 0 ; i < temp ; i++, j++ )
{
peer_ch_list[j] = *( ch_content + 1 + i );
}
ch_content += (temp + 1);
ch_cnt -= (temp + 1);
ch_no += temp ;
}
return ch_no;
}
u8 rtw_p2p_check_peer_oper_ch(struct mlme_ext_priv *pmlmeext, u8 ch)
{
u8 i = 0;
for ( i = 0; i < pmlmeext->max_chan_nums; i++ )
{
if ( pmlmeext->channel_set[ i ].ChannelNum == ch )
{
return _SUCCESS;
}
}
return _FAIL;
}
u8 rtw_p2p_ch_inclusion(struct mlme_ext_priv *pmlmeext, u8 *peer_ch_list, u8 peer_ch_num, u8 *ch_list_inclusioned)
{
int i = 0, j = 0, temp = 0;
u8 ch_no = 0;
for ( i = 0; i < peer_ch_num; i++ )
{
for ( j = temp; j < pmlmeext->max_chan_nums; j++ )
{
if ( *( peer_ch_list + i ) == pmlmeext->channel_set[ j ].ChannelNum )
{
ch_list_inclusioned[ ch_no++ ] = *( peer_ch_list + i );
temp = j;
break;
}
}
}
return ch_no;
}
u8 process_p2p_group_negotation_req( struct wifidirect_info *pwdinfo, u8 *pframe, uint len )
{
_adapter *padapter = pwdinfo->padapter;
u8 result = P2P_STATUS_SUCCESS;
u32 p2p_ielen = 0, wps_ielen = 0;
u8 * ies;
u32 ies_len;
u8 *p2p_ie;
u8 *wpsie;
u16 wps_devicepassword_id = 0x0000;
uint wps_devicepassword_id_len = 0;
#ifdef CONFIG_WFD
u8 wfd_ie[ 128 ] = { 0x00 };
u32 wfd_ielen = 0;
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
#endif // CONFIG_TDLS
#endif // CONFIG_WFD
#ifdef CONFIG_CONCURRENT_MODE
_adapter *pbuddy_adapter = pwdinfo->padapter->pbuddy_adapter;
struct wifidirect_info *pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
struct mlme_priv *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
#endif
if ( (wpsie=rtw_get_wps_ie( pframe + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, NULL, &wps_ielen)) )
{
// Commented by Kurt 20120113
// If some device wants to do p2p handshake without sending prov_disc_req
// We have to get peer_req_cm from here.
if (_rtw_memcmp( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "000", 3) )
{
rtw_get_wps_attr_content( wpsie, wps_ielen, WPS_ATTR_DEVICE_PWID, (u8*) &wps_devicepassword_id, &wps_devicepassword_id_len);
wps_devicepassword_id = be16_to_cpu( wps_devicepassword_id );
if ( wps_devicepassword_id == WPS_DPID_USER_SPEC )
{
_rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "dis", 3 );
}
else if ( wps_devicepassword_id == WPS_DPID_REGISTRAR_SPEC )
{
_rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "pad", 3 );
}
else
{
_rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "pbc", 3 );
}
}
}
else
{
DBG_88E( "[%s] WPS IE not Found!!\n", __func__ );
result = P2P_STATUS_FAIL_INCOMPATIBLE_PARAM;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
return( result );
}
if ( pwdinfo->ui_got_wps_info == P2P_NO_WPSINFO )
{
result = P2P_STATUS_FAIL_INFO_UNAVAILABLE;
rtw_p2p_set_state(pwdinfo, P2P_STATE_TX_INFOR_NOREADY);
return( result );
}
ies = pframe + _PUBLIC_ACTION_IE_OFFSET_;
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
if ( !p2p_ie )
{
DBG_88E( "[%s] P2P IE not Found!!\n", __func__ );
result = P2P_STATUS_FAIL_INCOMPATIBLE_PARAM;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
}
while ( p2p_ie )
{
u8 attr_content = 0x00;
u32 attr_contentlen = 0;
u8 ch_content[50] = { 0x00 };
uint ch_cnt = 0;
u8 peer_ch_list[50] = { 0x00 };
u8 peer_ch_num = 0;
u8 ch_list_inclusioned[50] = { 0x00 };
u8 ch_num_inclusioned = 0;
u16 cap_attr;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_ING);
//Check P2P Capability ATTR
if (rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CAPABILITY, (u8*)&cap_attr, (uint*)&attr_contentlen) )
{
cap_attr = le16_to_cpu(cap_attr);
#if defined(CONFIG_WFD) && defined(CONFIG_TDLS)
if (!(cap_attr & P2P_GRPCAP_INTRABSS) )
ptdlsinfo->ap_prohibited = true;
#endif //defined(CONFIG_WFD) && defined(CONFIG_TDLS)
}
if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GO_INTENT , &attr_content, &attr_contentlen) )
{
DBG_88E( "[%s] GO Intent = %d, tie = %d\n", __func__, attr_content >> 1, attr_content & 0x01 );
pwdinfo->peer_intent = attr_content; // include both intent and tie breaker values.
if ( pwdinfo->intent == ( pwdinfo->peer_intent >> 1 ) )
{
// Try to match the tie breaker value
if ( pwdinfo->intent == P2P_MAX_INTENT )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
result = P2P_STATUS_FAIL_BOTH_GOINTENT_15;
}
else
{
if ( attr_content & 0x01 )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
}
else
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
}
}
}
else if ( pwdinfo->intent > ( pwdinfo->peer_intent >> 1 ) )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
}
else
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
}
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
// Store the group id information.
_rtw_memcpy( pwdinfo->groupid_info.go_device_addr, pwdinfo->device_addr, ETH_ALEN );
_rtw_memcpy( pwdinfo->groupid_info.ssid, pwdinfo->nego_ssid, pwdinfo->nego_ssidlen );
}
}
attr_contentlen = 0;
if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_INTENTED_IF_ADDR, pwdinfo->p2p_peer_interface_addr, &attr_contentlen ) )
{
if ( attr_contentlen != ETH_ALEN )
{
_rtw_memset( pwdinfo->p2p_peer_interface_addr, 0x00, ETH_ALEN );
}
}
if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, ch_content, &ch_cnt) )
{
peer_ch_num = rtw_p2p_get_peer_ch_list(pwdinfo, ch_content, ch_cnt, peer_ch_list);
ch_num_inclusioned = rtw_p2p_ch_inclusion(&padapter->mlmeextpriv, peer_ch_list, peer_ch_num, ch_list_inclusioned);
if ( ch_num_inclusioned == 0)
{
DBG_88E( "[%s] No common channel in channel list!\n", __func__ );
result = P2P_STATUS_FAIL_NO_COMMON_CH;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
break;
}
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
if ( !rtw_p2p_is_channel_list_ok( pwdinfo->operating_channel,
ch_list_inclusioned, ch_num_inclusioned) )
{
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
{
DBG_88E( "[%s] desired channel NOT Found!\n", __func__ );
result = P2P_STATUS_FAIL_NO_COMMON_CH;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
break;
}
else
#endif //CONFIG_CONCURRENT_MODE
{
u8 operatingch_info[5] = { 0x00 }, peer_operating_ch = 0;
attr_contentlen = 0;
if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, operatingch_info, &attr_contentlen) )
{
peer_operating_ch = operatingch_info[4];
}
if ( rtw_p2p_is_channel_list_ok( peer_operating_ch,
ch_list_inclusioned, ch_num_inclusioned) )
{
/**
* Change our operating channel as peer's for compatibility.
*/
pwdinfo->operating_channel = peer_operating_ch;
DBG_88E( "[%s] Change op ch to %02x as peer's\n", __func__, pwdinfo->operating_channel);
}
else
{
// Take first channel of ch_list_inclusioned as operating channel
pwdinfo->operating_channel = ch_list_inclusioned[0];
DBG_88E( "[%s] Change op ch to %02x\n", __func__, pwdinfo->operating_channel);
}
}
}
}
}
//Get the next P2P IE
p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
}
#ifdef CONFIG_WFD
// Added by Albert 20110823
// Try to get the TCP port information when receiving the negotiation request.
if ( rtw_get_wfd_ie( pframe + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, wfd_ie, &wfd_ielen ) )
{
u8 attr_content[ 10 ] = { 0x00 };
u32 attr_contentlen = 0;
DBG_88E( "[%s] WFD IE Found!!\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 = RTW_GET_BE16( attr_content + 2 );
DBG_88E( "[%s] Peer PORT NUM = %d\n", __func__, pwdinfo->wfd_info->peer_rtsp_ctrlport );
}
}
#endif // CONFIG_WFD
return( result );
}
u8 process_p2p_group_negotation_resp( struct wifidirect_info *pwdinfo, u8 *pframe, uint len )
{
_adapter *padapter = pwdinfo->padapter;
u8 result = P2P_STATUS_SUCCESS;
u32 p2p_ielen, wps_ielen;
u8 * ies;
u32 ies_len;
u8 * p2p_ie;
#ifdef CONFIG_WFD
u8 wfd_ie[ 128 ] = { 0x00 };
u32 wfd_ielen = 0;
#ifdef CONFIG_TDLS
struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
#endif // CONFIG_TDLS
#endif // CONFIG_WFD
ies = pframe + _PUBLIC_ACTION_IE_OFFSET_;
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
// Be able to know which one is the P2P GO and which one is P2P client.
if ( rtw_get_wps_ie( ies, ies_len, NULL, &wps_ielen) )
{
}
else
{
DBG_88E( "[%s] WPS IE not Found!!\n", __func__ );
result = P2P_STATUS_FAIL_INCOMPATIBLE_PARAM;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
}
p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
if ( !p2p_ie )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
result = P2P_STATUS_FAIL_INCOMPATIBLE_PARAM;
}
else
{
u8 attr_content = 0x00;
u32 attr_contentlen = 0;
u8 operatingch_info[5] = { 0x00 };
uint ch_cnt = 0;
u8 ch_content[50] = { 0x00 };
u8 groupid[ 38 ];
u16 cap_attr;
u8 peer_ch_list[50] = { 0x00 };
u8 peer_ch_num = 0;
u8 ch_list_inclusioned[50] = { 0x00 };
u8 ch_num_inclusioned = 0;
while ( p2p_ie ) // Found the P2P IE.
{
//Check P2P Capability ATTR
if (rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CAPABILITY, (u8*)&cap_attr, (uint*)&attr_contentlen) )
{
cap_attr = le16_to_cpu(cap_attr);
#ifdef CONFIG_TDLS
if (!(cap_attr & P2P_GRPCAP_INTRABSS) )
ptdlsinfo->ap_prohibited = true;
#endif // CONFIG_TDLS
}
rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, &attr_content, &attr_contentlen);
if ( attr_contentlen == 1 )
{
DBG_88E( "[%s] Status = %d\n", __func__, attr_content );
if ( attr_content == P2P_STATUS_SUCCESS )
{
// Do nothing.
}
else
{
if ( P2P_STATUS_FAIL_INFO_UNAVAILABLE == attr_content ) {
rtw_p2p_set_state(pwdinfo, P2P_STATE_RX_INFOR_NOREADY);
} else {
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
}
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
result = attr_content;
break;
}
}
// Try to get the peer's interface address
attr_contentlen = 0;
if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_INTENTED_IF_ADDR, pwdinfo->p2p_peer_interface_addr, &attr_contentlen ) )
{
if ( attr_contentlen != ETH_ALEN )
{
_rtw_memset( pwdinfo->p2p_peer_interface_addr, 0x00, ETH_ALEN );
}
}
// Try to get the peer's intent and tie breaker value.
attr_content = 0x00;
attr_contentlen = 0;
if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GO_INTENT , &attr_content, &attr_contentlen) )
{
DBG_88E( "[%s] GO Intent = %d, tie = %d\n", __func__, attr_content >> 1, attr_content & 0x01 );
pwdinfo->peer_intent = attr_content; // include both intent and tie breaker values.
if ( pwdinfo->intent == ( pwdinfo->peer_intent >> 1 ) )
{
// Try to match the tie breaker value
if ( pwdinfo->intent == P2P_MAX_INTENT )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
result = P2P_STATUS_FAIL_BOTH_GOINTENT_15;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
}
else
{
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
if ( attr_content & 0x01 )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
}
else
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
}
}
}
else if ( pwdinfo->intent > ( pwdinfo->peer_intent >> 1 ) )
{
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
}
else
{
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
}
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
// Store the group id information.
_rtw_memcpy( pwdinfo->groupid_info.go_device_addr, pwdinfo->device_addr, ETH_ALEN );
_rtw_memcpy( pwdinfo->groupid_info.ssid, pwdinfo->nego_ssid, pwdinfo->nego_ssidlen );
}
}
// Try to get the operation channel information
attr_contentlen = 0;
if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, operatingch_info, &attr_contentlen))
{
DBG_88E( "[%s] Peer's operating channel = %d\n", __func__, operatingch_info[4] );
pwdinfo->peer_operating_ch = operatingch_info[4];
}
// Try to get the channel list information
if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, pwdinfo->channel_list_attr, &pwdinfo->channel_list_attr_len ) )
{
DBG_88E( "[%s] channel list attribute found, len = %d\n", __func__, pwdinfo->channel_list_attr_len );
peer_ch_num = rtw_p2p_get_peer_ch_list(pwdinfo, pwdinfo->channel_list_attr, pwdinfo->channel_list_attr_len, peer_ch_list);
ch_num_inclusioned = rtw_p2p_ch_inclusion(&padapter->mlmeextpriv, peer_ch_list, peer_ch_num, ch_list_inclusioned);
if ( ch_num_inclusioned == 0)
{
DBG_88E( "[%s] No common channel in channel list!\n", __func__ );
result = P2P_STATUS_FAIL_NO_COMMON_CH;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
break;
}
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
{
if ( !rtw_p2p_is_channel_list_ok( pwdinfo->operating_channel,
ch_list_inclusioned, ch_num_inclusioned) )
{
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
{
DBG_88E( "[%s] desired channel NOT Found!\n", __func__ );
result = P2P_STATUS_FAIL_NO_COMMON_CH;
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
break;
}
else
#endif //CONFIG_CONCURRENT_MODE
{
u8 operatingch_info[5] = { 0x00 }, peer_operating_ch = 0;
attr_contentlen = 0;
if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, operatingch_info, &attr_contentlen) )
{
peer_operating_ch = operatingch_info[4];
}
if ( rtw_p2p_is_channel_list_ok( peer_operating_ch,
ch_list_inclusioned, ch_num_inclusioned) )
{
/**
* Change our operating channel as peer's for compatibility.
*/
pwdinfo->operating_channel = peer_operating_ch;
DBG_88E( "[%s] Change op ch to %02x as peer's\n", __func__, pwdinfo->operating_channel);
}
else
{
// Take first channel of ch_list_inclusioned as operating channel
pwdinfo->operating_channel = ch_list_inclusioned[0];
DBG_88E( "[%s] Change op ch to %02x\n", __func__, pwdinfo->operating_channel);
}
}
}
}
}
else
{
DBG_88E( "[%s] channel list attribute not found!\n", __func__);
}
// Try to get the group id information if peer is GO
attr_contentlen = 0;
_rtw_memset( groupid, 0x00, 38 );
if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_GROUP_ID, groupid, &attr_contentlen) )
{
_rtw_memcpy( pwdinfo->groupid_info.go_device_addr, &groupid[0], ETH_ALEN );
_rtw_memcpy( pwdinfo->groupid_info.ssid, &groupid[6], attr_contentlen - ETH_ALEN );
}
//Get the next P2P IE
p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
}
}
#ifdef CONFIG_WFD
// Added by Albert 20111122
// Try to get the TCP port information when receiving the negotiation response.
if ( rtw_get_wfd_ie( pframe + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, wfd_ie, &wfd_ielen ) )
{
u8 attr_content[ 10 ] = { 0x00 };
u32 attr_contentlen = 0;
DBG_88E( "[%s] WFD IE Found!!\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 = RTW_GET_BE16( attr_content + 2 );
DBG_88E( "[%s] Peer PORT NUM = %d\n", __func__, pwdinfo->wfd_info->peer_rtsp_ctrlport );
}
}
#endif // CONFIG_WFD
return( result );
}
u8 process_p2p_group_negotation_confirm( struct wifidirect_info *pwdinfo, u8 *pframe, uint len )
{
u8 * ies;
u32 ies_len;
u8 * p2p_ie;
u32 p2p_ielen = 0;
u8 result = P2P_STATUS_SUCCESS;
ies = pframe + _PUBLIC_ACTION_IE_OFFSET_;
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
while ( p2p_ie ) // Found the P2P IE.
{
u8 attr_content = 0x00, operatingch_info[5] = { 0x00 };
u8 groupid[ 38 ] = { 0x00 };
u32 attr_contentlen = 0;
pwdinfo->negotiation_dialog_token = 1;
rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, &attr_content, &attr_contentlen);
if ( attr_contentlen == 1 )
{
DBG_88E( "[%s] Status = %d\n", __func__, attr_content );
result = attr_content;
if ( attr_content == P2P_STATUS_SUCCESS )
{
u8 bcancelled = 0;
_cancel_timer( &pwdinfo->restore_p2p_state_timer, &bcancelled );
// Commented by Albert 20100911
// Todo: Need to handle the case which both Intents are the same.
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
if ( ( pwdinfo->intent ) > ( pwdinfo->peer_intent >> 1 ) )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
}
else if ( ( pwdinfo->intent ) < ( pwdinfo->peer_intent >> 1 ) )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
}
else
{
// Have to compare the Tie Breaker
if ( pwdinfo->peer_intent & 0x01 )
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
}
else
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
}
}
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(pwdinfo->padapter , _FW_LINKED ) )
{
// Switch back to the AP channel soon.
_set_timer( &pwdinfo->ap_p2p_switch_timer, 100 );
}
#endif
}
else
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
break;
}
}
// Try to get the group id information
attr_contentlen = 0;
_rtw_memset( groupid, 0x00, 38 );
if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_GROUP_ID, groupid, &attr_contentlen) )
{
DBG_88E( "[%s] Ssid = %s, ssidlen = %zu\n", __func__, &groupid[ETH_ALEN], strlen(&groupid[ETH_ALEN]) );
_rtw_memcpy( pwdinfo->groupid_info.go_device_addr, &groupid[0], ETH_ALEN );
_rtw_memcpy( pwdinfo->groupid_info.ssid, &groupid[6], attr_contentlen - ETH_ALEN );
}
attr_contentlen = 0;
if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, operatingch_info, &attr_contentlen) )
{
DBG_88E( "[%s] Peer's operating channel = %d\n", __func__, operatingch_info[4] );
pwdinfo->peer_operating_ch = operatingch_info[4];
}
//Get the next P2P IE
p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
}
return( result );
}
u8 process_p2p_presence_req(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
{
u8 *frame_body;
u8 dialogToken=0;
u8 status = P2P_STATUS_SUCCESS;
frame_body = (unsigned char *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
dialogToken = frame_body[6];
//todo: check NoA attribute
issue_p2p_presence_resp(pwdinfo, GetAddr2Ptr(pframe), status, dialogToken);
return true;
}
void find_phase_handler( _adapter* padapter )
{
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
NDIS_802_11_SSID ssid;
_irqL irqL;
u8 _status = 0;
_func_enter_;
_rtw_memset((unsigned char*)&ssid, 0, sizeof(NDIS_802_11_SSID));
_rtw_memcpy(ssid.Ssid, pwdinfo->p2p_wildcard_ssid, P2P_WILDCARD_SSID_LEN );
ssid.SsidLength = P2P_WILDCARD_SSID_LEN;
rtw_p2p_set_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH);
_enter_critical_bh(&pmlmepriv->lock, &irqL);
_status = rtw_sitesurvey_cmd(padapter, &ssid, 1, NULL, 0);
_exit_critical_bh(&pmlmepriv->lock, &irqL);
_func_exit_;
}
void p2p_concurrent_handler( _adapter* padapter );
void restore_p2p_state_handler( _adapter* padapter )
{
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
_func_enter_;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING) || rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_FAIL))
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
}
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
{
_adapter *pbuddy_adapter = padapter->pbuddy_adapter;
struct mlme_priv *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ) || rtw_p2p_chk_state(pwdinfo, P2P_STATE_RX_PROVISION_DIS_RSP))
{
set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
issue_nulldata(pbuddy_adapter, NULL, 0, 3, 500);
}
}
#endif
rtw_p2p_set_state(pwdinfo, rtw_p2p_pre_state(pwdinfo));
if (rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE))
{
#ifdef CONFIG_CONCURRENT_MODE
p2p_concurrent_handler( padapter );
#else
// In the P2P client mode, the driver should not switch back to its listen channel
// because this P2P client should stay at the operating channel of P2P GO.
set_channel_bwmode( padapter, pwdinfo->listen_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
#endif
}
_func_exit_;
}
void pre_tx_invitereq_handler( _adapter* padapter )
{
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
u8 val8 = 1;
_func_enter_;
set_channel_bwmode(padapter, pwdinfo->invitereq_info.peer_ch, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
issue_probereq_p2p(padapter, NULL);
_set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
_func_exit_;
}
void pre_tx_provdisc_handler( _adapter* padapter )
{
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
u8 val8 = 1;
_func_enter_;
set_channel_bwmode(padapter, pwdinfo->tx_prov_disc_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
issue_probereq_p2p(padapter, NULL);
_set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
_func_exit_;
}
void pre_tx_negoreq_handler( _adapter* padapter )
{
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
u8 val8 = 1;
_func_enter_;
set_channel_bwmode(padapter, pwdinfo->nego_req_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
issue_probereq_p2p(padapter, NULL);
_set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
_func_exit_;
}
#ifdef CONFIG_CONCURRENT_MODE
void p2p_concurrent_handler( _adapter* padapter )
{
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
//_adapter *pbuddy_adapter = padapter->pbuddy_adapter;
//struct wifidirect_info *pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
//struct mlme_priv *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
//struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
u8 val8;
_func_enter_;
if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
{
PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
pwdinfo->operating_channel = pbuddy_mlmeext->cur_channel;
#ifdef CONFIG_IOCTL_CFG80211
DBG_88E("%s, switch ch back to buddy's cur_channel=%d\n", __func__, pbuddy_mlmeext->cur_channel);
set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
issue_nulldata(pbuddy_adapter, NULL, 0, 3, 500);
#else //CONFIG_IOCTL_CFG80211
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_IDLE))
{
// Now, the driver stays on the AP's channel.
// If the pwdinfo->ext_listen_period = 0, that means the P2P listen state is not available on listen channel.
if ( pwdinfo->ext_listen_period > 0 )
{
DBG_88E( "[%s] P2P_STATE_IDLE, ext_listen_period = %d\n", __func__, pwdinfo->ext_listen_period );
if ( pbuddy_mlmeext->cur_channel != pwdinfo->listen_channel )
{
// Will switch to listen channel so that need to send the NULL data with PW bit to AP.
issue_nulldata(pbuddy_adapter, NULL, 1, 3, 500);
set_channel_bwmode(padapter, pwdinfo->listen_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
}
rtw_p2p_set_state(pwdinfo, P2P_STATE_LISTEN);
val8 = 1;
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
// Todo: To check the value of pwdinfo->ext_listen_period is equal to 0 or not.
_set_timer( &pwdinfo->ap_p2p_switch_timer, pwdinfo->ext_listen_period );
}
}
else if ( rtw_p2p_chk_state(pwdinfo, P2P_STATE_LISTEN) ||
rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_FAIL) ||
( rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING) && pwdinfo->nego_req_info.benable == false ) ||
rtw_p2p_chk_state(pwdinfo, P2P_STATE_RX_PROVISION_DIS_REQ) )
{
// Now, the driver is in the listen state of P2P mode.
DBG_88E( "[%s] P2P_STATE_IDLE, ext_listen_interval = %d\n", __func__, pwdinfo->ext_listen_interval );
// Commented by Albert 2012/11/01
// If the AP's channel is the same as the listen channel, we should still be in the listen state
// Other P2P device is still able to find this device out even this device is in the AP's channel.
// So, configure this device to be able to receive the probe request frame and set it to listen state.
if ( pbuddy_mlmeext->cur_channel != pwdinfo->listen_channel )
{
set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
val8 = 0;
padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
rtw_p2p_set_state(pwdinfo, P2P_STATE_IDLE);
issue_nulldata(pbuddy_adapter, NULL, 0, 3, 500);
}
// Todo: To check the value of pwdinfo->ext_listen_interval is equal to 0 or not.
_set_timer( &pwdinfo->ap_p2p_switch_timer, pwdinfo->ext_listen_interval );
}
else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_OK))
{
// The driver had finished the P2P handshake successfully.
val8 = 0;
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
issue_nulldata(pbuddy_adapter, NULL, 0, 3, 500);
}
else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ))
{
val8 = 1;
set_channel_bwmode(padapter, pwdinfo->tx_prov_disc_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
issue_probereq_p2p(padapter, NULL);
_set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
}
else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING) && pwdinfo->nego_req_info.benable == true)
{
val8 = 1;
set_channel_bwmode(padapter, pwdinfo->nego_req_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
issue_probereq_p2p(padapter, NULL);
_set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
}
else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_INVITE_REQ ) && pwdinfo->invitereq_info.benable == true)
{
/*
val8 = 1;
set_channel_bwmode(padapter, , HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
issue_probereq_p2p(padapter, NULL);
_set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
*/
}
#endif //CONFIG_IOCTL_CFG80211
}
else
{
set_channel_bwmode( padapter, pwdinfo->listen_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
}
_func_exit_;
}
#endif
#ifdef CONFIG_IOCTL_CFG80211
static void ro_ch_handler( _adapter* padapter )
{
struct cfg80211_wifidirect_info *pcfg80211_wdinfo = &padapter->cfg80211_wdinfo;
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
_func_enter_;
{
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
{
PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
DBG_88E("%s, switch ch back to buddy's cur_channel=%d\n", __func__, pbuddy_mlmeext->cur_channel);
set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
pmlmeext->cur_channel = pbuddy_mlmeext->cur_channel;
}else
#endif //CONFIG_CONCURRENT_MODE
if ( pcfg80211_wdinfo->restore_channel != pmlmeext->cur_channel )
{
if ( !check_fwstate(&padapter->mlmepriv, _FW_LINKED ) )
pmlmeext->cur_channel = pcfg80211_wdinfo->restore_channel;
set_channel_bwmode(padapter, pmlmeext->cur_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HT_CHANNEL_WIDTH_20);
}
rtw_p2p_set_state(pwdinfo, rtw_p2p_pre_state(pwdinfo));
#ifdef CONFIG_DEBUG_CFG80211
DBG_88E("%s, role=%d, p2p_state=%d\n", __func__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo));
#endif
}
pcfg80211_wdinfo->is_ro_ch = false;
DBG_88E("cfg80211_remain_on_channel_expired\n");
cfg80211_remain_on_channel_expired(pcfg80211_wdinfo->remain_on_ch_dev,
pcfg80211_wdinfo->remain_on_ch_cookie,
&pcfg80211_wdinfo->remain_on_ch_channel,
pcfg80211_wdinfo->remain_on_ch_type, GFP_KERNEL);
_func_exit_;
}
static void ro_ch_timer_process (void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
struct rtw_wdev_priv *pwdev_priv = wdev_to_priv(adapter->rtw_wdev);
//printk("%s\n", __func__);
#ifdef CONFIG_CONCURRENT_MODE
ATOMIC_SET(&pwdev_priv->ro_ch_to, 1);
#endif
p2p_protocol_wk_cmd( adapter, P2P_RO_CH_WK);
}
static void rtw_cfg80211_adjust_p2pie_channel(_adapter *padapter, const u8 *frame_body, u32 len)
{
#ifdef CONFIG_CONCURRENT_MODE
u8 *ies, *p2p_ie;
u32 ies_len, p2p_ielen;
PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
ies = (u8*)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
while ( p2p_ie )
{
u32 attr_contentlen = 0;
u8 *pattr = NULL;
//Check P2P_ATTR_CH_LIST
if ((pattr=rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, (uint*)&attr_contentlen))!=NULL)
{
int i;
u32 num_of_ch;
u8 *pattr_temp = pattr + 3 ;
attr_contentlen -= 3;
while (attr_contentlen>0)
{
num_of_ch = *(pattr_temp+1);
for (i=0; i<num_of_ch; i++)
*(pattr_temp+2+i) = pbuddy_mlmeext->cur_channel;//forcing to the same channel
pattr_temp += (2+num_of_ch);
attr_contentlen -= (2+num_of_ch);
}
}
//Check P2P_ATTR_OPERATING_CH
attr_contentlen = 0;
pattr = NULL;
if ((pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, (uint*)&attr_contentlen))!=NULL)
{
*(pattr+4) = pbuddy_mlmeext->cur_channel;//forcing to the same channel
}
//Get the next P2P IE
p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
}
#endif
}
#ifdef CONFIG_WFD
void rtw_append_wfd_ie(_adapter *padapter, u8 *buf, u32* len)
{
unsigned char *frame_body;
u8 category, action, OUI_Subtype, dialogToken=0;
u32 wfdielen = 0;
struct rtw_wdev_priv *pwdev_priv = wdev_to_priv(padapter->rtw_wdev);
frame_body = (unsigned char *)(buf + sizeof(struct rtw_ieee80211_hdr_3addr));
category = frame_body[0];
if (category == RTW_WLAN_CATEGORY_PUBLIC)
{
action = frame_body[1];
if (action == ACT_PUBLIC_VENDOR
&& _rtw_memcmp(frame_body+2, P2P_OUI, 4) == true
)
{
OUI_Subtype = frame_body[6];
dialogToken = frame_body[7];
switch ( OUI_Subtype )//OUI Subtype
{
case P2P_GO_NEGO_REQ:
{
wfdielen = build_nego_req_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
(*len) += wfdielen;
break;
}
case P2P_GO_NEGO_RESP:
{
wfdielen = build_nego_resp_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
(*len) += wfdielen;
break;
}
case P2P_GO_NEGO_CONF:
{
wfdielen = build_nego_confirm_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
(*len) += wfdielen;
break;
}
case P2P_INVIT_REQ:
{
wfdielen = build_invitation_req_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
(*len) += wfdielen;
break;
}
case P2P_INVIT_RESP:
{
wfdielen = build_invitation_resp_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
(*len) += wfdielen;
break;
}
case P2P_DEVDISC_REQ:
break;
case P2P_DEVDISC_RESP:
break;
case P2P_PROVISION_DISC_REQ:
{
wfdielen = build_provdisc_req_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
(*len) += wfdielen;
break;
}
case P2P_PROVISION_DISC_RESP:
{
wfdielen = build_provdisc_resp_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
(*len) += wfdielen;
break;
}
default:
break;
}
}
}
else if (category == RTW_WLAN_CATEGORY_P2P)
{
OUI_Subtype = frame_body[5];
dialogToken = frame_body[6];
#ifdef CONFIG_DEBUG_CFG80211
DBG_88E("ACTION_CATEGORY_P2P: OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n",
cpu_to_be32( *( ( u32* ) ( frame_body + 1 ) ) ), OUI_Subtype, dialogToken);
#endif
switch (OUI_Subtype)
{
case P2P_NOTICE_OF_ABSENCE:
break;
case P2P_PRESENCE_REQUEST:
break;
case P2P_PRESENCE_RESPONSE:
break;
case P2P_GO_DISC_REQUEST:
break;
default:
break;
}
}
else
{
DBG_88E("%s, action frame category=%d\n", __func__, category);
//is_p2p_frame = (-1);
}
return;
}
#endif
int rtw_p2p_check_frames(_adapter *padapter, const u8 *buf, u32 len, u8 tx)
{
int is_p2p_frame = (-1);
unsigned char *frame_body;
u8 category, action, OUI_Subtype, dialogToken=0;
u8 *p2p_ie = NULL;
uint p2p_ielen = 0;
struct rtw_wdev_priv *pwdev_priv = wdev_to_priv(padapter->rtw_wdev);
frame_body = (unsigned char *)(buf + sizeof(struct rtw_ieee80211_hdr_3addr));
category = frame_body[0];
//just for check
if (category == RTW_WLAN_CATEGORY_PUBLIC)
{
action = frame_body[1];
if (action == ACT_PUBLIC_VENDOR
&& _rtw_memcmp(frame_body+2, P2P_OUI, 4) == true
)
{
OUI_Subtype = frame_body[6];
dialogToken = frame_body[7];
is_p2p_frame = OUI_Subtype;
#ifdef CONFIG_DEBUG_CFG80211
DBG_88E("ACTION_CATEGORY_PUBLIC: ACT_PUBLIC_VENDOR, OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n",
cpu_to_be32( *( ( u32* ) ( frame_body + 2 ) ) ), OUI_Subtype, dialogToken);
#endif
p2p_ie = rtw_get_p2p_ie(
(u8 *)buf+sizeof(struct rtw_ieee80211_hdr_3addr)+_PUBLIC_ACTION_IE_OFFSET_,
len-sizeof(struct rtw_ieee80211_hdr_3addr)-_PUBLIC_ACTION_IE_OFFSET_,
NULL, &p2p_ielen);
switch ( OUI_Subtype )//OUI Subtype
{
u8 *cont;
uint cont_len;
case P2P_GO_NEGO_REQ:
DBG_88E("RTW_%s:P2P_GO_NEGO_REQ, dialogToken=%d\n", (tx==true)?"Tx":"Rx", dialogToken);
if (tx)
{
#ifdef CONFIG_DRV_ISSUE_PROV_REQ // IOT FOR S2
if (pwdev_priv->provdisc_req_issued == false)
rtw_cfg80211_issue_p2p_provision_request(padapter, buf, len);
#endif //CONFIG_DRV_ISSUE_PROV_REQ
//pwdev_priv->provdisc_req_issued = false;
#ifdef CONFIG_CONCURRENT_MODE
if (check_buddy_fwstate(padapter, _FW_LINKED))
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
#endif
}
break;
case P2P_GO_NEGO_RESP:
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len);
DBG_88E("RTW_%s:P2P_GO_NEGO_RESP, dialogToken=%d, status:%d\n", (tx==true)?"Tx":"Rx", dialogToken, cont?*cont:-1);
if (!tx)
{
pwdev_priv->provdisc_req_issued = false;
}
#ifdef CONFIG_CONCURRENT_MODE
else
{
if (check_buddy_fwstate(padapter, _FW_LINKED))
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
}
#endif
break;
case P2P_GO_NEGO_CONF:
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len);
DBG_88E("RTW_%s:P2P_GO_NEGO_CONF, dialogToken=%d, status:%d\n", (tx==true)?"Tx":"Rx", dialogToken, cont?*cont:-1);
#ifdef CONFIG_CONCURRENT_MODE
if (tx)
{
if (check_buddy_fwstate(padapter, _FW_LINKED))
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
}
#endif
break;
case P2P_INVIT_REQ:
{
struct rtw_wdev_invit_info* invit_info = &pwdev_priv->invit_info;
int flags = -1;
int op_ch = 0;
if (tx)
{
#ifdef CONFIG_CONCURRENT_MODE
if (check_buddy_fwstate(padapter, _FW_LINKED))
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
#endif
}
if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_INVITATION_FLAGS, NULL, &cont_len)))
flags = *cont;
if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len)))
op_ch = *(cont+4);
if (invit_info->token != dialogToken)
rtw_wdev_invit_info_init(invit_info);
invit_info->token = dialogToken;
invit_info->flags = (flags==-1) ? 0x0 : flags;
invit_info->req_op_ch= op_ch;
DBG_88E("RTW_%s:P2P_INVIT_REQ, dialogToken=%d, flags:0x%02x, op_ch:%d\n", (tx==true)?"Tx":"Rx", dialogToken, flags, op_ch);
break;
}
case P2P_INVIT_RESP:
{
struct rtw_wdev_invit_info* invit_info = &pwdev_priv->invit_info;
int status = -1;
int op_ch = 0;
if (tx)
{
#ifdef CONFIG_CONCURRENT_MODE
if (check_buddy_fwstate(padapter, _FW_LINKED))
rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
#endif
}
if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len)))
status = *cont;
if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len)))
op_ch = *(cont+4);
if (invit_info->token != dialogToken) {
rtw_wdev_invit_info_init(invit_info);
} else {
invit_info->token = 0;
invit_info->status = (status==-1) ? 0xff : status;
invit_info->rsp_op_ch= op_ch;
}
DBG_88E("RTW_%s:P2P_INVIT_RESP, dialogToken=%d, status:%d, op_ch:%d\n", (tx==true)?"Tx":"Rx", dialogToken, status, op_ch);
break;
}
case P2P_DEVDISC_REQ:
DBG_88E("RTW_%s:P2P_DEVDISC_REQ, dialogToken=%d\n", (tx==true)?"Tx":"Rx", dialogToken);
break;
case P2P_DEVDISC_RESP:
cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len);
DBG_88E("RTW_%s:P2P_DEVDISC_RESP, dialogToken=%d, status:%d\n", (tx==true)?"Tx":"Rx", dialogToken, cont?*cont:-1);
break;
case P2P_PROVISION_DISC_REQ:
{
size_t frame_body_len = len - sizeof(struct rtw_ieee80211_hdr_3addr);
u8 *p2p_ie;
uint p2p_ielen = 0;
uint contentlen = 0;
DBG_88E("RTW_%s:P2P_PROVISION_DISC_REQ, dialogToken=%d\n", (tx==true)?"Tx":"Rx", dialogToken);
//if (tx)
{
pwdev_priv->provdisc_req_issued = false;
if ( (p2p_ie=rtw_get_p2p_ie( frame_body + _PUBLIC_ACTION_IE_OFFSET_, frame_body_len - _PUBLIC_ACTION_IE_OFFSET_, NULL, &p2p_ielen)))
{
if (rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_GROUP_ID, NULL, &contentlen))
{
pwdev_priv->provdisc_req_issued = false;//case: p2p_client join p2p GO
}
else
{
#ifdef CONFIG_DEBUG_CFG80211
DBG_88E("provdisc_req_issued is true\n");
#endif //CONFIG_DEBUG_CFG80211
pwdev_priv->provdisc_req_issued = true;//case: p2p_devices connection before Nego req.
}
}
}
}
break;
case P2P_PROVISION_DISC_RESP:
DBG_88E("RTW_%s:P2P_PROVISION_DISC_RESP, dialogToken=%d\n", (tx==true)?"Tx":"Rx", dialogToken);
break;
default:
DBG_88E("RTW_%s:OUI_Subtype=%d, dialogToken=%d\n", (tx==true)?"Tx":"Rx", OUI_Subtype, dialogToken);
break;
}
}
}
else if (category == RTW_WLAN_CATEGORY_P2P)
{
OUI_Subtype = frame_body[5];
dialogToken = frame_body[6];
#ifdef CONFIG_DEBUG_CFG80211
DBG_88E("ACTION_CATEGORY_P2P: OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n",
cpu_to_be32( *( ( u32* ) ( frame_body + 1 ) ) ), OUI_Subtype, dialogToken);
#endif
is_p2p_frame = OUI_Subtype;
switch (OUI_Subtype)
{
case P2P_NOTICE_OF_ABSENCE:
DBG_88E("RTW_%s:P2P_NOTICE_OF_ABSENCE, dialogToken=%d\n", (tx==true)?"TX":"RX", dialogToken);
break;
case P2P_PRESENCE_REQUEST:
DBG_88E("RTW_%s:P2P_PRESENCE_REQUEST, dialogToken=%d\n", (tx==true)?"TX":"RX", dialogToken);
break;
case P2P_PRESENCE_RESPONSE:
DBG_88E("RTW_%s:P2P_PRESENCE_RESPONSE, dialogToken=%d\n", (tx==true)?"TX":"RX", dialogToken);
break;
case P2P_GO_DISC_REQUEST:
DBG_88E("RTW_%s:P2P_GO_DISC_REQUEST, dialogToken=%d\n", (tx==true)?"TX":"RX", dialogToken);
break;
default:
DBG_88E("RTW_%s:OUI_Subtype=%d, dialogToken=%d\n", (tx==true)?"TX":"RX", OUI_Subtype, dialogToken);
break;
}
}
else
{
DBG_88E("RTW_%s:action frame category=%d\n", (tx==true)?"TX":"RX", category);
//is_p2p_frame = (-1);
}
return is_p2p_frame;
}
void rtw_init_cfg80211_wifidirect_info( _adapter* padapter)
{
struct cfg80211_wifidirect_info *pcfg80211_wdinfo = &padapter->cfg80211_wdinfo;
_rtw_memset(pcfg80211_wdinfo, 0x00, sizeof(struct cfg80211_wifidirect_info) );
_init_timer( &pcfg80211_wdinfo->remain_on_ch_timer, padapter->pnetdev, ro_ch_timer_process, padapter );
}
#endif //CONFIG_IOCTL_CFG80211
void p2p_protocol_wk_hdl(_adapter *padapter, int intCmdType)
{
struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
_func_enter_;
switch (intCmdType)
{
case P2P_FIND_PHASE_WK:
{
find_phase_handler( padapter );
break;
}
case P2P_RESTORE_STATE_WK:
{
restore_p2p_state_handler( padapter );
break;
}
case P2P_PRE_TX_PROVDISC_PROCESS_WK:
{
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
{
p2p_concurrent_handler( padapter );
}
else
{
pre_tx_provdisc_handler( padapter );
}
#else
pre_tx_provdisc_handler( padapter );
#endif
break;
}
case P2P_PRE_TX_INVITEREQ_PROCESS_WK:
{
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
{
p2p_concurrent_handler( padapter );
}
else
{
pre_tx_invitereq_handler( padapter );
}
#else
pre_tx_invitereq_handler( padapter );
#endif
break;
}
case P2P_PRE_TX_NEGOREQ_PROCESS_WK:
{
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
{
p2p_concurrent_handler( padapter );
}
else
{
pre_tx_negoreq_handler( padapter );
}
#else
pre_tx_negoreq_handler( padapter );
#endif
break;
}
#ifdef CONFIG_P2P
#ifdef CONFIG_CONCURRENT_MODE
case P2P_AP_P2P_CH_SWITCH_PROCESS_WK:
{
p2p_concurrent_handler( padapter );
break;
}
#endif
#endif
#ifdef CONFIG_IOCTL_CFG80211
case P2P_RO_CH_WK:
{
ro_ch_handler( padapter );
break;
}
#endif //CONFIG_IOCTL_CFG80211
}
_func_exit_;
}
#ifdef CONFIG_P2P_PS
void process_p2p_ps_ie(PADAPTER padapter, u8 *IEs, u32 IELength)
{
u8 * ies;
u32 ies_len;
u8 * p2p_ie;
u32 p2p_ielen = 0;
u8 noa_attr[MAX_P2P_IE_LEN] = { 0x00 };// NoA length should be n*(13) + 2
u32 attr_contentlen = 0;
struct wifidirect_info *pwdinfo = &( padapter->wdinfo );
u8 find_p2p = false, find_p2p_ps = false;
u8 noa_offset, noa_num, noa_index;
_func_enter_;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
{
return;
}
#ifdef CONFIG_CONCURRENT_MODE
if (padapter->iface_type != IFACE_PORT0)
return;
#endif
if (IELength <= _BEACON_IE_OFFSET_)
return;
ies = IEs + _BEACON_IE_OFFSET_;
ies_len = IELength - _BEACON_IE_OFFSET_;
p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen);
while (p2p_ie)
{
find_p2p = true;
// Get Notice of Absence IE.
if (rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_NOA, noa_attr, &attr_contentlen))
{
find_p2p_ps = true;
noa_index = noa_attr[0];
if ( (pwdinfo->p2p_ps_mode == P2P_PS_NONE) ||
(noa_index != pwdinfo->noa_index) )// if index change, driver should reconfigure related setting.
{
pwdinfo->noa_index = noa_index;
pwdinfo->opp_ps = noa_attr[1] >> 7;
pwdinfo->ctwindow = noa_attr[1] & 0x7F;
noa_offset = 2;
noa_num = 0;
// NoA length should be n*(13) + 2
if (attr_contentlen > 2)
{
while (noa_offset < attr_contentlen)
{
//_rtw_memcpy(&wifidirect_info->noa_count[noa_num], &noa_attr[noa_offset], 1);
pwdinfo->noa_count[noa_num] = noa_attr[noa_offset];
noa_offset += 1;
_rtw_memcpy(&pwdinfo->noa_duration[noa_num], &noa_attr[noa_offset], 4);
noa_offset += 4;
_rtw_memcpy(&pwdinfo->noa_interval[noa_num], &noa_attr[noa_offset], 4);
noa_offset += 4;
_rtw_memcpy(&pwdinfo->noa_start_time[noa_num], &noa_attr[noa_offset], 4);
noa_offset += 4;
noa_num++;
}
}
pwdinfo->noa_num = noa_num;
if ( pwdinfo->opp_ps == 1 )
{
pwdinfo->p2p_ps_mode = P2P_PS_CTWINDOW;
// driver should wait LPS for entering CTWindow
if (padapter->pwrctrlpriv.bFwCurrentInPSMode == true)
{
p2p_ps_wk_cmd(padapter, P2P_PS_ENABLE, 1);
}
}
else if ( pwdinfo->noa_num > 0 )
{
pwdinfo->p2p_ps_mode = P2P_PS_NOA;
p2p_ps_wk_cmd(padapter, P2P_PS_ENABLE, 1);
}
else if ( pwdinfo->p2p_ps_mode > P2P_PS_NONE)
{
p2p_ps_wk_cmd(padapter, P2P_PS_DISABLE, 1);
}
}
break; // find target, just break.
}
//Get the next P2P IE
p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
}
if (find_p2p == true)
{
if ( (pwdinfo->p2p_ps_mode > P2P_PS_NONE) && (find_p2p_ps == false) )
{
p2p_ps_wk_cmd(padapter, P2P_PS_DISABLE, 1);
}
}
_func_exit_;
}
void p2p_ps_wk_hdl(_adapter *padapter, u8 p2p_ps_state)
{
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
_func_enter_;
// Pre action for p2p state
switch (p2p_ps_state)
{
case P2P_PS_DISABLE:
pwdinfo->p2p_ps_state = p2p_ps_state;
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
pwdinfo->noa_index = 0;
pwdinfo->ctwindow = 0;
pwdinfo->opp_ps = 0;
pwdinfo->noa_num = 0;
pwdinfo->p2p_ps_mode = P2P_PS_NONE;
if (padapter->pwrctrlpriv.bFwCurrentInPSMode == true)
{
if (pwrpriv->smart_ps == 0)
{
pwrpriv->smart_ps = 2;
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&(padapter->pwrctrlpriv.pwr_mode)));
}
}
break;
case P2P_PS_ENABLE:
if (pwdinfo->p2p_ps_mode > P2P_PS_NONE) {
pwdinfo->p2p_ps_state = p2p_ps_state;
if ( pwdinfo->ctwindow > 0 )
{
if (pwrpriv->smart_ps != 0)
{
pwrpriv->smart_ps = 0;
DBG_88E("%s(): Enter CTW, change SmartPS\n", __func__);
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&(padapter->pwrctrlpriv.pwr_mode)));
}
}
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
}
break;
case P2P_PS_SCAN:
case P2P_PS_SCAN_DONE:
case P2P_PS_ALLSTASLEEP:
if (pwdinfo->p2p_ps_mode > P2P_PS_NONE) {
pwdinfo->p2p_ps_state = p2p_ps_state;
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
}
break;
default:
break;
}
_func_exit_;
}
u8 p2p_ps_wk_cmd(_adapter*padapter, u8 p2p_ps_state, u8 enqueue)
{
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;
_func_enter_;
if ( rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)
#ifdef CONFIG_CONCURRENT_MODE
|| (padapter->iface_type != IFACE_PORT0)
#endif
)
{
return res;
}
if (enqueue)
{
ph2c = (struct cmd_obj*)rtw_zmalloc(sizeof(struct cmd_obj));
if (ph2c==NULL){
res= _FAIL;
goto exit;
}
pdrvextra_cmd_parm = (struct drvextra_cmd_parm*)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
if (pdrvextra_cmd_parm==NULL){
rtw_mfree((unsigned char *)ph2c, sizeof(struct cmd_obj));
res= _FAIL;
goto exit;
}
pdrvextra_cmd_parm->ec_id = P2P_PS_WK_CID;
pdrvextra_cmd_parm->type_size = p2p_ps_state;
pdrvextra_cmd_parm->pbuf = NULL;
init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
res = rtw_enqueue_cmd(pcmdpriv, ph2c);
}
else
{
p2p_ps_wk_hdl(padapter, p2p_ps_state);
}
exit:
_func_exit_;
return res;
}
#endif // CONFIG_P2P_PS
static void reset_ch_sitesurvey_timer_process (void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
return;
DBG_88E( "[%s] In\n", __func__ );
// Reset the operation channel information
pwdinfo->rx_invitereq_info.operation_ch[0] = 0;
pwdinfo->rx_invitereq_info.scan_op_ch_only = 0;
}
static void reset_ch_sitesurvey_timer_process2 (void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
return;
DBG_88E( "[%s] In\n", __func__ );
// Reset the operation channel information
pwdinfo->p2p_info.operation_ch[0] = 0;
pwdinfo->p2p_info.scan_op_ch_only = 0;
}
static void restore_p2p_state_timer_process (void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
return;
p2p_protocol_wk_cmd( adapter, P2P_RESTORE_STATE_WK );
}
static void pre_tx_scan_timer_process (void *FunctionContext)
{
_adapter *adapter = (_adapter *) FunctionContext;
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
_irqL irqL;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
u8 _status = 0;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
return;
_enter_critical_bh(&pmlmepriv->lock, &irqL);
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ))
{
if ( true == pwdinfo->tx_prov_disc_info.benable ) // the provision discovery request frame is trigger to send or not
{
p2p_protocol_wk_cmd( adapter, P2P_PRE_TX_PROVDISC_PROCESS_WK );
//issue_probereq_p2p(adapter, NULL);
//_set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
}
}
else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING))
{
if ( true == pwdinfo->nego_req_info.benable )
{
p2p_protocol_wk_cmd( adapter, P2P_PRE_TX_NEGOREQ_PROCESS_WK );
}
}
else if ( rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_INVITE_REQ ) )
{
if ( true == pwdinfo->invitereq_info.benable )
{
p2p_protocol_wk_cmd( adapter, P2P_PRE_TX_INVITEREQ_PROCESS_WK );
}
}
else
{
DBG_88E( "[%s] p2p_state is %d, ignore!!\n", __func__, rtw_p2p_state(pwdinfo) );
}
_exit_critical_bh(&pmlmepriv->lock, &irqL);
}
static void find_phase_timer_process (void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
return;
adapter->wdinfo.find_phase_state_exchange_cnt++;
p2p_protocol_wk_cmd( adapter, P2P_FIND_PHASE_WK );
}
#ifdef CONFIG_CONCURRENT_MODE
void ap_p2p_switch_timer_process (void *FunctionContext)
{
_adapter *adapter = (_adapter *)FunctionContext;
struct wifidirect_info *pwdinfo = &adapter->wdinfo;
#ifdef CONFIG_IOCTL_CFG80211
struct rtw_wdev_priv *pwdev_priv = wdev_to_priv(adapter->rtw_wdev);
#endif
if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
return;
#ifdef CONFIG_IOCTL_CFG80211
ATOMIC_SET(&pwdev_priv->switch_ch_to, 1);
#endif
p2p_protocol_wk_cmd( adapter, P2P_AP_P2P_CH_SWITCH_PROCESS_WK );
}
#endif
void reset_global_wifidirect_info( _adapter* padapter )
{
struct wifidirect_info *pwdinfo;
pwdinfo = &padapter->wdinfo;
pwdinfo->persistent_supported = 0;
pwdinfo->session_available = true;
pwdinfo->wfd_tdls_enable = 0;
pwdinfo->wfd_tdls_weaksec = 0;
}
#ifdef CONFIG_WFD
int rtw_init_wifi_display_info(_adapter* padapter)
{
int res = _SUCCESS;
struct wifi_display_info *pwfd_info = &padapter->wfd_info;
// Used in P2P and TDLS
pwfd_info->rtsp_ctrlport = 554;
pwfd_info->peer_rtsp_ctrlport = 0; // Reset to 0
pwfd_info->wfd_enable = false;
pwfd_info->wfd_device_type = WFD_DEVINFO_PSINK;
pwfd_info->scan_result_type = SCAN_RESULT_P2P_ONLY;
// Used in P2P
pwfd_info->peer_session_avail = true;
pwfd_info->wfd_pc = false;
// Used in TDLS
_rtw_memset( pwfd_info->ip_address, 0x00, 4 );
_rtw_memset( pwfd_info->peer_ip_address, 0x00, 4 );
return res;
}
#endif //CONFIG_WFD
void rtw_init_wifidirect_timers(_adapter* padapter)
{
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
_init_timer( &pwdinfo->find_phase_timer, padapter->pnetdev, find_phase_timer_process, padapter );
_init_timer( &pwdinfo->restore_p2p_state_timer, padapter->pnetdev, restore_p2p_state_timer_process, padapter );
_init_timer( &pwdinfo->pre_tx_scan_timer, padapter->pnetdev, pre_tx_scan_timer_process, padapter );
_init_timer( &pwdinfo->reset_ch_sitesurvey, padapter->pnetdev, reset_ch_sitesurvey_timer_process, padapter );
_init_timer( &pwdinfo->reset_ch_sitesurvey2, padapter->pnetdev, reset_ch_sitesurvey_timer_process2, padapter );
#ifdef CONFIG_CONCURRENT_MODE
_init_timer( &pwdinfo->ap_p2p_switch_timer, padapter->pnetdev, ap_p2p_switch_timer_process, padapter );
#endif
}
void rtw_init_wifidirect_addrs(_adapter* padapter, u8 *dev_addr, u8 *iface_addr)
{
#ifdef CONFIG_P2P
struct wifidirect_info *pwdinfo = &padapter->wdinfo;
/*init device&interface address */
if (dev_addr) {
_rtw_memcpy(pwdinfo->device_addr, dev_addr, ETH_ALEN);
}
if (iface_addr) {
_rtw_memcpy(pwdinfo->interface_addr, iface_addr, ETH_ALEN);
}
#endif
}
void init_wifidirect_info( _adapter* padapter, enum P2P_ROLE role)
{
struct wifidirect_info *pwdinfo;
#ifdef CONFIG_WFD
struct wifi_display_info *pwfd_info = &padapter->wfd_info;
#endif
#ifdef CONFIG_CONCURRENT_MODE
_adapter *pbuddy_adapter = padapter->pbuddy_adapter;
struct wifidirect_info *pbuddy_wdinfo;
struct mlme_priv *pbuddy_mlmepriv;
struct mlme_ext_priv *pbuddy_mlmeext;
#endif
pwdinfo = &padapter->wdinfo;
pwdinfo->padapter = padapter;
// 1, 6, 11 are the social channel defined in the WiFi Direct specification.
pwdinfo->social_chan[0] = 1;
pwdinfo->social_chan[1] = 6;
pwdinfo->social_chan[2] = 11;
pwdinfo->social_chan[3] = 0; // channel 0 for scanning ending in site survey function.
#ifdef CONFIG_CONCURRENT_MODE
if (pbuddy_adapter) {
pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
}
if ( ( check_buddy_fwstate(padapter, _FW_LINKED ) == true ) &&
( ( pbuddy_mlmeext->cur_channel == 1) || ( pbuddy_mlmeext->cur_channel == 6 ) || ( pbuddy_mlmeext->cur_channel == 11 ) )
)
{
// Use the AP's channel as the listen channel
// This will avoid the channel switch between AP's channel and listen channel.
pwdinfo->listen_channel = pbuddy_mlmeext->cur_channel;
}
else
#endif //CONFIG_CONCURRENT_MODE
{
// Use the channel 11 as the listen channel
pwdinfo->listen_channel = 11;
}
if (role == P2P_ROLE_DEVICE)
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
#ifdef CONFIG_CONCURRENT_MODE
if ( check_buddy_fwstate(padapter, _FW_LINKED ) == true )
{
rtw_p2p_set_state(pwdinfo, P2P_STATE_IDLE);
}
else
#endif
{
rtw_p2p_set_state(pwdinfo, P2P_STATE_LISTEN);
}
pwdinfo->intent = 1;
rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_LISTEN);
}
else if (role == P2P_ROLE_CLIENT)
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
pwdinfo->intent = 1;
rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
}
else if (role == P2P_ROLE_GO)
{
rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
pwdinfo->intent = 15;
rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
}
// Use the OFDM rate in the P2P probe response frame. ( 6(B), 9(B), 12, 18, 24, 36, 48, 54 )
pwdinfo->support_rate[0] = 0x8c; // 6(B)
pwdinfo->support_rate[1] = 0x92; // 9(B)
pwdinfo->support_rate[2] = 0x18; // 12
pwdinfo->support_rate[3] = 0x24; // 18
pwdinfo->support_rate[4] = 0x30; // 24
pwdinfo->support_rate[5] = 0x48; // 36
pwdinfo->support_rate[6] = 0x60; // 48
pwdinfo->support_rate[7] = 0x6c; // 54
_rtw_memcpy( ( void* ) pwdinfo->p2p_wildcard_ssid, "DIRECT-", 7 );
_rtw_memset( pwdinfo->device_name, 0x00, WPS_MAX_DEVICE_NAME_LEN );
pwdinfo->device_name_len = 0;
_rtw_memset( &pwdinfo->invitereq_info, 0x00, sizeof( struct tx_invite_req_info ) );
pwdinfo->invitereq_info.token = 3; // Token used for P2P invitation request frame.
_rtw_memset( &pwdinfo->inviteresp_info, 0x00, sizeof( struct tx_invite_resp_info ) );
pwdinfo->inviteresp_info.token = 0;
pwdinfo->profileindex = 0;
_rtw_memset( &pwdinfo->profileinfo[ 0 ], 0x00, sizeof( struct profile_info ) * P2P_MAX_PERSISTENT_GROUP_NUM );
rtw_p2p_findphase_ex_set(pwdinfo, P2P_FINDPHASE_EX_NONE);
pwdinfo->listen_dwell = ( u8 ) (( rtw_get_current_time() % 3 ) + 1);
//DBG_88E( "[%s] listen_dwell time is %d00ms\n", __func__, pwdinfo->listen_dwell );
_rtw_memset( &pwdinfo->tx_prov_disc_info, 0x00, sizeof( struct tx_provdisc_req_info ) );
pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_NONE;
_rtw_memset( &pwdinfo->nego_req_info, 0x00, sizeof( struct tx_nego_req_info ) );
pwdinfo->device_password_id_for_nego = WPS_DPID_PBC;
pwdinfo->negotiation_dialog_token = 1;
_rtw_memset( pwdinfo->nego_ssid, 0x00, WLAN_SSID_MAXLEN );
pwdinfo->nego_ssidlen = 0;
pwdinfo->ui_got_wps_info = P2P_NO_WPSINFO;
#ifdef CONFIG_WFD
pwdinfo->supported_wps_cm = WPS_CONFIG_METHOD_DISPLAY | WPS_CONFIG_METHOD_PBC;
pwdinfo->wfd_info = pwfd_info;
#else
pwdinfo->supported_wps_cm = WPS_CONFIG_METHOD_DISPLAY | WPS_CONFIG_METHOD_PBC | WPS_CONFIG_METHOD_KEYPAD;
#endif //CONFIG_WFD
pwdinfo->channel_list_attr_len = 0;
_rtw_memset( pwdinfo->channel_list_attr, 0x00, 100 );
_rtw_memset( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, 0x00, 4 );
_rtw_memset( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, '0', 3 );
_rtw_memset( &pwdinfo->groupid_info, 0x00, sizeof( struct group_id_info ) );
#ifdef CONFIG_CONCURRENT_MODE
#ifdef CONFIG_IOCTL_CFG80211
pwdinfo->ext_listen_interval = 1000; //The interval to be available with legacy AP during p2p0-find/scan
pwdinfo->ext_listen_period = 3000; //The time period to be available for P2P during nego
#else //!CONFIG_IOCTL_CFG80211
//pwdinfo->ext_listen_interval = 3000;
//pwdinfo->ext_listen_period = 400;
pwdinfo->ext_listen_interval = 1000;
pwdinfo->ext_listen_period = 1000;
#endif //!CONFIG_IOCTL_CFG80211
#endif
pwdinfo->wfd_tdls_enable = 0;
_rtw_memset( pwdinfo->p2p_peer_interface_addr, 0x00, ETH_ALEN );
_rtw_memset( pwdinfo->p2p_peer_device_addr, 0x00, ETH_ALEN );
pwdinfo->rx_invitereq_info.operation_ch[0] = 0;
pwdinfo->rx_invitereq_info.operation_ch[1] = 0; // Used to indicate the scan end in site survey function
pwdinfo->rx_invitereq_info.scan_op_ch_only = 0;
pwdinfo->p2p_info.operation_ch[0] = 0;
pwdinfo->p2p_info.operation_ch[1] = 0; // Used to indicate the scan end in site survey function
pwdinfo->p2p_info.scan_op_ch_only = 0;
}
#ifdef CONFIG_DBG_P2P
char * p2p_role_str[] = {
"P2P_ROLE_DISABLE",
"P2P_ROLE_DEVICE",
"P2P_ROLE_CLIENT",
"P2P_ROLE_GO"
};
char * p2p_state_str[] = {
"P2P_STATE_NONE",
"P2P_STATE_IDLE",
"P2P_STATE_LISTEN",
"P2P_STATE_SCAN",
"P2P_STATE_FIND_PHASE_LISTEN",
"P2P_STATE_FIND_PHASE_SEARCH",
"P2P_STATE_TX_PROVISION_DIS_REQ",
"P2P_STATE_RX_PROVISION_DIS_RSP",
"P2P_STATE_RX_PROVISION_DIS_REQ",
"P2P_STATE_GONEGO_ING",
"P2P_STATE_GONEGO_OK",
"P2P_STATE_GONEGO_FAIL",
"P2P_STATE_RECV_INVITE_REQ_MATCH",
"P2P_STATE_PROVISIONING_ING",
"P2P_STATE_PROVISIONING_DONE",
"P2P_STATE_RECV_INVITE_REQ_DISMATCH",
"P2P_STATE_RECV_INVITE_REQ_GO"
};
void dbg_rtw_p2p_set_state(struct wifidirect_info *wdinfo, enum P2P_STATE state, const char *caller, int line)
{
if (!_rtw_p2p_chk_state(wdinfo, state)) {
enum P2P_STATE old_state = _rtw_p2p_state(wdinfo);
_rtw_p2p_set_state(wdinfo, state);
DBG_88E("[CONFIG_DBG_P2P]%s:%d set_state from %s to %s\n", caller, line
, p2p_state_str[old_state], p2p_state_str[_rtw_p2p_state(wdinfo)]
);
} else {
DBG_88E("[CONFIG_DBG_P2P]%s:%d set_state to same state %s\n", caller, line
, p2p_state_str[_rtw_p2p_state(wdinfo)]
);
}
}
void dbg_rtw_p2p_set_pre_state(struct wifidirect_info *wdinfo, enum P2P_STATE state, const char *caller, int line)
{
if (_rtw_p2p_pre_state(wdinfo) != state) {
enum P2P_STATE old_state = _rtw_p2p_pre_state(wdinfo);
_rtw_p2p_set_pre_state(wdinfo, state);
DBG_88E("[CONFIG_DBG_P2P]%s:%d set_pre_state from %s to %s\n", caller, line
, p2p_state_str[old_state], p2p_state_str[_rtw_p2p_pre_state(wdinfo)]
);
} else {
DBG_88E("[CONFIG_DBG_P2P]%s:%d set_pre_state to same state %s\n", caller, line
, p2p_state_str[_rtw_p2p_pre_state(wdinfo)]
);
}
}
void dbg_rtw_p2p_set_role(struct wifidirect_info *wdinfo, enum P2P_ROLE role, const char *caller, int line)
{
if (wdinfo->role != role) {
enum P2P_ROLE old_role = wdinfo->role;
_rtw_p2p_set_role(wdinfo, role);
DBG_88E("[CONFIG_DBG_P2P]%s:%d set_role from %s to %s\n", caller, line
, p2p_role_str[old_role], p2p_role_str[wdinfo->role]
);
} else {
DBG_88E("[CONFIG_DBG_P2P]%s:%d set_role to same role %s\n", caller, line
, p2p_role_str[wdinfo->role]
);
}
}
#endif //CONFIG_DBG_P2P
int rtw_p2p_enable(_adapter *padapter, enum P2P_ROLE role)
{
int ret = _SUCCESS;
struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
if (role == P2P_ROLE_DEVICE || role == P2P_ROLE_CLIENT|| role == P2P_ROLE_GO)
{
u8 channel, ch_offset;
u16 bwmode;
#ifdef CONFIG_CONCURRENT_MODE
_adapter *pbuddy_adapter = padapter->pbuddy_adapter;
struct wifidirect_info *pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
// Commented by Albert 2011/12/30
// The driver just supports 1 P2P group operation.
// So, this function will do nothing if the buddy adapter had enabled the P2P function.
if (!rtw_p2p_chk_state(pbuddy_wdinfo, P2P_STATE_NONE))
{
// The buddy adapter had enabled the P2P function.
return ret;
}
#endif //CONFIG_CONCURRENT_MODE
//leave IPS/Autosuspend
if (_FAIL == rtw_pwr_wakeup(padapter)) {
ret = _FAIL;
goto exit;
}
// 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
update_tx_basic_rate(padapter, WIRELESS_11AGN);
//Enable P2P function
init_wifidirect_info(padapter, role);
rtw_hal_set_odm_var(padapter,HAL_ODM_P2P_STATE,NULL,true);
#ifdef CONFIG_WFD
rtw_hal_set_odm_var(padapter,HAL_ODM_WIFI_DISPLAY_STATE,NULL,true);
#endif
}
else if (role == P2P_ROLE_DISABLE)
{
if (_FAIL == rtw_pwr_wakeup(padapter)) {
ret = _FAIL;
goto exit;
}
//Disable P2P function
if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
{
_cancel_timer_ex( &pwdinfo->find_phase_timer );
_cancel_timer_ex( &pwdinfo->restore_p2p_state_timer );
_cancel_timer_ex( &pwdinfo->pre_tx_scan_timer);
_cancel_timer_ex( &pwdinfo->reset_ch_sitesurvey);
_cancel_timer_ex( &pwdinfo->reset_ch_sitesurvey2);
reset_ch_sitesurvey_timer_process( padapter );
reset_ch_sitesurvey_timer_process2( padapter );
#ifdef CONFIG_CONCURRENT_MODE
_cancel_timer_ex( &pwdinfo->ap_p2p_switch_timer);
#endif
rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
rtw_p2p_set_role(pwdinfo, P2P_ROLE_DISABLE);
_rtw_memset(&pwdinfo->rx_prov_disc_info, 0x00, sizeof(struct rx_provdisc_req_info));
}
rtw_hal_set_odm_var(padapter,HAL_ODM_P2P_STATE,NULL,false);
#ifdef CONFIG_WFD
rtw_hal_set_odm_var(padapter,HAL_ODM_WIFI_DISPLAY_STATE,NULL,false);
#endif
//Restore to initial setting.
update_tx_basic_rate(padapter, padapter->registrypriv.wireless_mode);
}
exit:
return ret;
}
#endif //CONFIG_P2P
Reference in a new issue View git blame Copy permalink