1 /******************************************************************************
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
22 #include <drv_types.h>
26 int rtw_p2p_is_channel_list_ok( u8 desired_ch, u8* ch_list, u8 ch_cnt )
30 for( i = 0; i < ch_cnt; i++ )
32 if ( ch_list[ i ] == desired_ch )
41 int is_any_client_associated(_adapter *padapter)
43 return padapter->stapriv.asoc_list_cnt ? _TRUE : _FALSE;
46 static u32 go_add_group_info_attr(struct wifidirect_info *pwdinfo, u8 *pbuf)
52 u8 tmplen, *pdata_attr, *pstart, *pcur;
53 struct sta_info *psta = NULL;
54 _adapter *padapter = pwdinfo->padapter;
55 struct sta_priv *pstapriv = &padapter->stapriv;
57 DBG_871X("%s\n", __FUNCTION__);
59 pdata_attr = rtw_zmalloc(MAX_P2P_IE_LEN);
61 if(NULL == pdata_attr){
62 DBG_871X("%s pdata_attr malloc failed \n", __FUNCTION__);
69 _enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
70 phead = &pstapriv->asoc_list;
71 plist = get_next(phead);
73 //look up sta asoc_queue
74 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
76 psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
78 plist = get_next(plist);
81 if(psta->is_p2p_device)
88 _rtw_memcpy(pcur, psta->dev_addr, ETH_ALEN);
91 //P2P interface address
92 _rtw_memcpy(pcur, psta->hwaddr, ETH_ALEN);
95 *pcur = psta->dev_cap;
98 //*(u16*)(pcur) = cpu_to_be16(psta->config_methods);
99 RTW_PUT_BE16(pcur, psta->config_methods);
102 _rtw_memcpy(pcur, psta->primary_dev_type, 8);
105 *pcur = psta->num_of_secdev_type;
108 _rtw_memcpy(pcur, psta->secdev_types_list, psta->num_of_secdev_type*8);
109 pcur += psta->num_of_secdev_type*8;
111 if(psta->dev_name_len>0)
113 //*(u16*)(pcur) = cpu_to_be16( WPS_ATTR_DEVICE_NAME );
114 RTW_PUT_BE16(pcur, WPS_ATTR_DEVICE_NAME);
117 //*(u16*)(pcur) = cpu_to_be16( psta->dev_name_len );
118 RTW_PUT_BE16(pcur, psta->dev_name_len);
121 _rtw_memcpy(pcur, psta->dev_name, psta->dev_name_len);
122 pcur += psta->dev_name_len;
126 tmplen = (u8)(pcur-pstart);
128 *pstart = (tmplen-1);
139 _exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
143 len = rtw_set_p2p_attr_content(pbuf, P2P_ATTR_GROUP_INFO, attr_len, pdata_attr);
146 rtw_mfree(pdata_attr, MAX_P2P_IE_LEN);
153 static void issue_group_disc_req(struct wifidirect_info *pwdinfo, u8 *da)
155 struct xmit_frame *pmgntframe;
156 struct pkt_attrib *pattrib;
157 unsigned char *pframe;
158 struct rtw_ieee80211_hdr *pwlanhdr;
159 unsigned short *fctrl;
160 _adapter *padapter = pwdinfo->padapter;
161 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
162 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
163 unsigned char category = RTW_WLAN_CATEGORY_P2P;//P2P action frame
164 u32 p2poui = cpu_to_be32(P2POUI);
165 u8 oui_subtype = P2P_GO_DISC_REQUEST;
168 DBG_871X("[%s]\n", __FUNCTION__);
170 if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
176 pattrib = &pmgntframe->attrib;
177 update_mgntframe_attrib(padapter, pattrib);
179 _rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
181 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
182 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
184 fctrl = &(pwlanhdr->frame_ctl);
187 _rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
188 _rtw_memcpy(pwlanhdr->addr2, pwdinfo->interface_addr, ETH_ALEN);
189 _rtw_memcpy(pwlanhdr->addr3, pwdinfo->interface_addr, ETH_ALEN);
191 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
192 pmlmeext->mgnt_seq++;
193 SetFrameSubType(pframe, WIFI_ACTION);
195 pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
196 pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
198 //Build P2P action frame header
199 pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
200 pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *) &(p2poui), &(pattrib->pktlen));
201 pframe = rtw_set_fixed_ie(pframe, 1, &(oui_subtype), &(pattrib->pktlen));
202 pframe = rtw_set_fixed_ie(pframe, 1, &(dialogToken), &(pattrib->pktlen));
204 //there is no IE in this P2P action frame
206 pattrib->last_txcmdsz = pattrib->pktlen;
208 dump_mgntframe(padapter, pmgntframe);
212 static void issue_p2p_devdisc_resp(struct wifidirect_info *pwdinfo, u8 *da, u8 status, u8 dialogToken)
214 struct xmit_frame *pmgntframe;
215 struct pkt_attrib *pattrib;
216 unsigned char *pframe;
217 struct rtw_ieee80211_hdr *pwlanhdr;
218 unsigned short *fctrl;
219 _adapter *padapter = pwdinfo->padapter;
220 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
221 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
222 unsigned char category = RTW_WLAN_CATEGORY_PUBLIC;
223 u8 action = P2P_PUB_ACTION_ACTION;
224 u32 p2poui = cpu_to_be32(P2POUI);
225 u8 oui_subtype = P2P_DEVDISC_RESP;
226 u8 p2pie[8] = { 0x00 };
229 DBG_871X("[%s]\n", __FUNCTION__);
231 if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
237 pattrib = &pmgntframe->attrib;
238 update_mgntframe_attrib(padapter, pattrib);
240 _rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
242 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
243 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
245 fctrl = &(pwlanhdr->frame_ctl);
248 _rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
249 _rtw_memcpy(pwlanhdr->addr2, pwdinfo->device_addr, ETH_ALEN);
250 _rtw_memcpy(pwlanhdr->addr3, pwdinfo->device_addr, ETH_ALEN);
252 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
253 pmlmeext->mgnt_seq++;
254 SetFrameSubType(pframe, WIFI_ACTION);
256 pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
257 pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
259 //Build P2P public action frame header
260 pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
261 pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
262 pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *) &(p2poui), &(pattrib->pktlen));
263 pframe = rtw_set_fixed_ie(pframe, 1, &(oui_subtype), &(pattrib->pktlen));
264 pframe = rtw_set_fixed_ie(pframe, 1, &(dialogToken), &(pattrib->pktlen));
270 p2pie[ p2pielen++ ] = 0x50;
271 p2pie[ p2pielen++ ] = 0x6F;
272 p2pie[ p2pielen++ ] = 0x9A;
273 p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
276 p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_STATUS, 1, &status);
278 pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, p2pielen, p2pie, &pattrib->pktlen);
280 pattrib->last_txcmdsz = pattrib->pktlen;
282 dump_mgntframe(padapter, pmgntframe);
286 static void issue_p2p_provision_resp(struct wifidirect_info *pwdinfo, u8* raddr, u8* frame_body, u16 config_method)
288 _adapter *padapter = pwdinfo->padapter;
289 unsigned char category = RTW_WLAN_CATEGORY_PUBLIC;
290 u8 action = P2P_PUB_ACTION_ACTION;
291 u8 dialogToken = frame_body[7]; // The Dialog Token of provisioning discovery request frame.
292 u32 p2poui = cpu_to_be32(P2POUI);
293 u8 oui_subtype = P2P_PROVISION_DISC_RESP;
294 u8 wpsie[ 100 ] = { 0x00 };
300 struct xmit_frame *pmgntframe;
301 struct pkt_attrib *pattrib;
302 unsigned char *pframe;
303 struct rtw_ieee80211_hdr *pwlanhdr;
304 unsigned short *fctrl;
305 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
306 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
307 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
310 if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
316 pattrib = &pmgntframe->attrib;
317 update_mgntframe_attrib(padapter, pattrib);
319 _rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
321 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
322 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
324 fctrl = &(pwlanhdr->frame_ctl);
327 _rtw_memcpy(pwlanhdr->addr1, raddr, ETH_ALEN);
328 _rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
329 _rtw_memcpy(pwlanhdr->addr3, myid(&(padapter->eeprompriv)), ETH_ALEN);
331 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
332 pmlmeext->mgnt_seq++;
333 SetFrameSubType(pframe, WIFI_ACTION);
335 pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
336 pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
338 pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
339 pframe = rtw_set_fixed_ie(pframe, 1, &(action), &(pattrib->pktlen));
340 pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *) &(p2poui), &(pattrib->pktlen));
341 pframe = rtw_set_fixed_ie(pframe, 1, &(oui_subtype), &(pattrib->pktlen));
342 pframe = rtw_set_fixed_ie(pframe, 1, &(dialogToken), &(pattrib->pktlen));
346 //*(u32*) ( wpsie ) = cpu_to_be32( WPSOUI );
347 RTW_PUT_BE32(wpsie, WPSOUI);
353 *(u16*) ( wpsie + wpsielen ) = cpu_to_be16( WPS_ATTR_VER1 );
357 *(u16*) ( wpsie + wpsielen ) = cpu_to_be16( 0x0001 );
361 wpsie[wpsielen++] = WPS_VERSION_1; // Version 1.0
366 //*(u16*) ( wpsie + wpsielen ) = cpu_to_be16( WPS_ATTR_CONF_METHOD );
367 RTW_PUT_BE16(wpsie + wpsielen, WPS_ATTR_CONF_METHOD);
371 //*(u16*) ( wpsie + wpsielen ) = cpu_to_be16( 0x0002 );
372 RTW_PUT_BE16(wpsie + wpsielen, 0x0002);
376 //*(u16*) ( wpsie + wpsielen ) = cpu_to_be16( config_method );
377 RTW_PUT_BE16(wpsie + wpsielen, config_method);
380 pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, wpsielen, (unsigned char *) wpsie, &pattrib->pktlen );
383 wfdielen = build_provdisc_resp_wfd_ie(pwdinfo, pframe);
385 pattrib->pktlen += wfdielen;
388 pattrib->last_txcmdsz = pattrib->pktlen;
390 dump_mgntframe(padapter, pmgntframe);
396 static void issue_p2p_presence_resp(struct wifidirect_info *pwdinfo, u8 *da, u8 status, u8 dialogToken)
398 struct xmit_frame *pmgntframe;
399 struct pkt_attrib *pattrib;
400 unsigned char *pframe;
401 struct rtw_ieee80211_hdr *pwlanhdr;
402 unsigned short *fctrl;
403 _adapter *padapter = pwdinfo->padapter;
404 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
405 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
406 unsigned char category = RTW_WLAN_CATEGORY_P2P;//P2P action frame
407 u32 p2poui = cpu_to_be32(P2POUI);
408 u8 oui_subtype = P2P_PRESENCE_RESPONSE;
409 u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
410 u8 noa_attr_content[32] = { 0x00 };
413 DBG_871X("[%s]\n", __FUNCTION__);
415 if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
421 pattrib = &pmgntframe->attrib;
422 update_mgntframe_attrib(padapter, pattrib);
424 _rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
426 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
427 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
429 fctrl = &(pwlanhdr->frame_ctl);
432 _rtw_memcpy(pwlanhdr->addr1, da, ETH_ALEN);
433 _rtw_memcpy(pwlanhdr->addr2, pwdinfo->interface_addr, ETH_ALEN);
434 _rtw_memcpy(pwlanhdr->addr3, pwdinfo->interface_addr, ETH_ALEN);
436 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
437 pmlmeext->mgnt_seq++;
438 SetFrameSubType(pframe, WIFI_ACTION);
440 pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
441 pattrib->pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
443 //Build P2P action frame header
444 pframe = rtw_set_fixed_ie(pframe, 1, &(category), &(pattrib->pktlen));
445 pframe = rtw_set_fixed_ie(pframe, 4, (unsigned char *) &(p2poui), &(pattrib->pktlen));
446 pframe = rtw_set_fixed_ie(pframe, 1, &(oui_subtype), &(pattrib->pktlen));
447 pframe = rtw_set_fixed_ie(pframe, 1, &(dialogToken), &(pattrib->pktlen));
453 p2pie[ p2pielen++ ] = 0x50;
454 p2pie[ p2pielen++ ] = 0x6F;
455 p2pie[ p2pielen++ ] = 0x9A;
456 p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
458 //Add Status attribute in P2P IE
459 p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_STATUS, 1, &status);
461 //Add NoA attribute in P2P IE
462 noa_attr_content[0] = 0x1;//index
463 noa_attr_content[1] = 0x0;//CTWindow and OppPS Parameters
465 //todo: Notice of Absence Descriptor(s)
467 p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_NOA, 2, noa_attr_content);
471 pframe = rtw_set_ie(pframe, _VENDOR_SPECIFIC_IE_, p2pielen, p2pie, &(pattrib->pktlen));
474 pattrib->last_txcmdsz = pattrib->pktlen;
476 dump_mgntframe(padapter, pmgntframe);
480 u32 build_beacon_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
482 u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
484 u32 len=0, p2pielen = 0;
489 p2pie[ p2pielen++ ] = 0x50;
490 p2pie[ p2pielen++ ] = 0x6F;
491 p2pie[ p2pielen++ ] = 0x9A;
492 p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
495 // According to the P2P Specification, the beacon frame should contain 3 P2P attributes
498 // 3. Notice of Absence ( NOA )
500 // P2P Capability ATTR
504 // Device Capability Bitmap, 1 byte
505 // Be able to participate in additional P2P Groups and
506 // support the P2P Invitation Procedure
507 // Group Capability Bitmap, 1 byte
508 capability = P2P_DEVCAP_INVITATION_PROC|P2P_DEVCAP_CLIENT_DISCOVERABILITY;
509 capability |= ((P2P_GRPCAP_GO | P2P_GRPCAP_INTRABSS) << 8);
510 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_PROVISIONING_ING))
511 capability |= (P2P_GRPCAP_GROUP_FORMATION<<8);
513 capability = cpu_to_le16(capability);
515 p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_CAPABILITY, 2, (u8*)&capability);
518 // P2P Device ID ATTR
519 p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_DEVICE_ID, ETH_ALEN, pwdinfo->device_addr);
522 // Notice of Absence ATTR
527 //go_add_noa_attr(pwdinfo);
530 pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, p2pielen, (unsigned char *) p2pie, &len);
538 u32 build_beacon_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
540 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
542 u32 len=0, wfdielen = 0;
543 _adapter *padapter = pwdinfo->padapter;
544 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
545 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
549 wfdie[ wfdielen++ ] = 0x50;
550 wfdie[ wfdielen++ ] = 0x6F;
551 wfdie[ wfdielen++ ] = 0x9A;
552 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
554 // Commented by Albert 20110812
555 // According to the WFD Specification, the beacon frame should contain 4 WFD attributes
556 // 1. WFD Device Information
557 // 2. Associated BSSID
558 // 3. Coupled Sink Information
561 // WFD Device Information ATTR
563 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
566 // Note: In the WFD specification, the size of length field is 2.
567 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
571 // WFD device information
573 if ( P2P_ROLE_GO == pwdinfo->role )
575 if ( is_any_client_associated( pwdinfo->padapter ) )
577 // WFD primary sink + WiFi Direct mode + WSD (WFD Service Discovery)
578 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD;
579 RTW_PUT_BE16(wfdie + wfdielen, val16);
583 // WFD primary sink + available for WFD session + WiFi Direct mode + WSD (WFD Service Discovery)
584 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
585 RTW_PUT_BE16(wfdie + wfdielen, val16);
591 // WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
592 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
593 RTW_PUT_BE16(wfdie + wfdielen, val16);
599 // Session Management Control Port
600 // Default TCP port for RTSP messages is 554
601 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
605 // WFD Device Maximum Throughput
606 // 300Mbps is the maximum throughput
607 RTW_PUT_BE16(wfdie + wfdielen, 300);
610 // Associated BSSID ATTR
612 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
615 // Note: In the WFD specification, the size of length field is 2.
616 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
621 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
623 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
627 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
630 wfdielen += ETH_ALEN;
632 // Coupled Sink Information ATTR
634 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
637 // Note: In the WFD specification, the size of length field is 2.
638 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
642 // Coupled Sink Status bitmap
643 // Not coupled/available for Coupling
644 wfdie[ wfdielen++ ] = 0;
646 wfdie[ wfdielen++ ] = 0;
647 wfdie[ wfdielen++ ] = 0;
648 wfdie[ wfdielen++ ] = 0;
649 wfdie[ wfdielen++ ] = 0;
650 wfdie[ wfdielen++ ] = 0;
651 wfdie[ wfdielen++ ] = 0;
653 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
659 u32 build_probe_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
661 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
663 u32 len=0, wfdielen = 0;
664 _adapter *padapter = pwdinfo->padapter;
665 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
666 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
670 wfdie[ wfdielen++ ] = 0x50;
671 wfdie[ wfdielen++ ] = 0x6F;
672 wfdie[ wfdielen++ ] = 0x9A;
673 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
675 // Commented by Albert 20110812
676 // According to the WFD Specification, the probe request frame should contain 4 WFD attributes
677 // 1. WFD Device Information
678 // 2. Associated BSSID
679 // 3. Coupled Sink Information
682 // WFD Device Information ATTR
684 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
687 // Note: In the WFD specification, the size of length field is 2.
688 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
692 // WFD device information
694 if ( 1 == pwdinfo->wfd_tdls_enable )
696 // WFD primary sink + available for WFD session + WiFi TDLS mode + WSC ( WFD Service Discovery )
697 val16 = pwfd_info->wfd_device_type |
698 WFD_DEVINFO_SESSION_AVAIL |
701 RTW_PUT_BE16(wfdie + wfdielen, val16 );
705 // WFD primary sink + available for WFD session + WiFi Direct mode + WSC ( WFD Service Discovery )
706 val16 = pwfd_info->wfd_device_type |
707 WFD_DEVINFO_SESSION_AVAIL |
709 RTW_PUT_BE16(wfdie + wfdielen, val16 );
715 // Session Management Control Port
716 // Default TCP port for RTSP messages is 554
717 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
721 // WFD Device Maximum Throughput
722 // 300Mbps is the maximum throughput
723 RTW_PUT_BE16(wfdie + wfdielen, 300);
726 // Associated BSSID ATTR
728 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
731 // Note: In the WFD specification, the size of length field is 2.
732 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
737 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
739 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
743 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
746 wfdielen += ETH_ALEN;
748 // Coupled Sink Information ATTR
750 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
753 // Note: In the WFD specification, the size of length field is 2.
754 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
758 // Coupled Sink Status bitmap
759 // Not coupled/available for Coupling
760 wfdie[ wfdielen++ ] = 0;
762 wfdie[ wfdielen++ ] = 0;
763 wfdie[ wfdielen++ ] = 0;
764 wfdie[ wfdielen++ ] = 0;
765 wfdie[ wfdielen++ ] = 0;
766 wfdie[ wfdielen++ ] = 0;
767 wfdie[ wfdielen++ ] = 0;
769 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
775 u32 build_probe_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf, u8 tunneled)
777 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
778 u32 len=0, wfdielen = 0;
779 _adapter *padapter = pwdinfo->padapter;
780 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
781 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
785 wfdie[ wfdielen++ ] = 0x50;
786 wfdie[ wfdielen++ ] = 0x6F;
787 wfdie[ wfdielen++ ] = 0x9A;
788 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
790 // Commented by Albert 20110812
791 // According to the WFD Specification, the probe response frame should contain 4 WFD attributes
792 // 1. WFD Device Information
793 // 2. Associated BSSID
794 // 3. Coupled Sink Information
795 // 4. WFD Session Information
798 // WFD Device Information ATTR
800 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
803 // Note: In the WFD specification, the size of length field is 2.
804 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
808 // WFD device information
809 // WFD primary sink + available for WFD session + WiFi Direct mode
811 if ( _TRUE == pwdinfo->session_available )
813 if ( P2P_ROLE_GO == pwdinfo->role )
815 if ( is_any_client_associated( pwdinfo->padapter ) )
817 if ( pwdinfo->wfd_tdls_enable )
819 // TDLS mode + WSD ( WFD Service Discovery )
820 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT);
824 // WiFi Direct mode + WSD ( WFD Service Discovery )
825 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT);
830 if ( pwdinfo->wfd_tdls_enable )
832 // available for WFD session + TDLS mode + WSD ( WFD Service Discovery )
833 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT);
837 // available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
838 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT);
844 if ( pwdinfo->wfd_tdls_enable )
846 // available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
847 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT);
852 // available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
853 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT);
859 if ( pwdinfo->wfd_tdls_enable )
861 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_WSD |WFD_DEVINFO_PC_TDLS | WFD_DEVINFO_HDCP_SUPPORT);
865 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_HDCP_SUPPORT);
873 // Session Management Control Port
874 // Default TCP port for RTSP messages is 554
875 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
879 // WFD Device Maximum Throughput
880 // 300Mbps is the maximum throughput
881 RTW_PUT_BE16(wfdie + wfdielen, 300);
884 // Associated BSSID ATTR
886 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
889 // Note: In the WFD specification, the size of length field is 2.
890 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
895 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
897 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
901 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
904 wfdielen += ETH_ALEN;
906 // Coupled Sink Information ATTR
908 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
911 // Note: In the WFD specification, the size of length field is 2.
912 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
916 // Coupled Sink Status bitmap
917 // Not coupled/available for Coupling
918 wfdie[ wfdielen++ ] = 0;
920 wfdie[ wfdielen++ ] = 0;
921 wfdie[ wfdielen++ ] = 0;
922 wfdie[ wfdielen++ ] = 0;
923 wfdie[ wfdielen++ ] = 0;
924 wfdie[ wfdielen++ ] = 0;
925 wfdie[ wfdielen++ ] = 0;
927 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
929 // WFD Session Information ATTR
931 wfdie[ wfdielen++ ] = WFD_ATTR_SESSION_INFO;
934 // Note: In the WFD specification, the size of length field is 2.
935 RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
938 // Todo: to add the list of WFD device info descriptor in WFD group.
941 #ifdef CONFIG_CONCURRENT_MODE
943 if ( ( tunneled == 0 ) && ( padapter->pbuddy_adapter->wdinfo.wfd_tdls_enable == 1 ) )
945 // Alternative MAC Address ATTR
947 wfdie[ wfdielen++ ] = WFD_ATTR_ALTER_MAC;
950 // Note: In the WFD specification, the size of length field is 2.
951 RTW_PUT_BE16(wfdie + wfdielen, ETH_ALEN );
955 // Alternative MAC Address
956 _rtw_memcpy( wfdie + wfdielen, &padapter->pbuddy_adapter->eeprompriv.mac_addr[ 0 ], ETH_ALEN );
957 // This mac address is used to make the WFD session when TDLS is enable.
959 wfdielen += ETH_ALEN;
961 #endif // CONFIG_TDLS
962 #endif // CONFIG_CONCURRENT_MODE
964 pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
970 u32 build_assoc_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
972 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
974 u32 len=0, wfdielen = 0;
975 _adapter *padapter = NULL;
976 struct mlme_priv *pmlmepriv = NULL;
977 struct wifi_display_info *pwfd_info = NULL;
980 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE) || rtw_p2p_chk_state(pwdinfo, P2P_STATE_IDLE))
985 padapter = pwdinfo->padapter;
986 pmlmepriv = &padapter->mlmepriv;
987 pwfd_info = padapter->wdinfo.wfd_info;
990 wfdie[ wfdielen++ ] = 0x50;
991 wfdie[ wfdielen++ ] = 0x6F;
992 wfdie[ wfdielen++ ] = 0x9A;
993 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
995 // Commented by Albert 20110812
996 // According to the WFD Specification, the probe request frame should contain 4 WFD attributes
997 // 1. WFD Device Information
998 // 2. Associated BSSID
999 // 3. Coupled Sink Information
1002 // WFD Device Information ATTR
1004 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1007 // Note: In the WFD specification, the size of length field is 2.
1008 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1012 // WFD device information
1013 // WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
1014 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
1015 RTW_PUT_BE16(wfdie + wfdielen, val16);
1019 // Session Management Control Port
1020 // Default TCP port for RTSP messages is 554
1021 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1025 // WFD Device Maximum Throughput
1026 // 300Mbps is the maximum throughput
1027 RTW_PUT_BE16(wfdie + wfdielen, 300);
1030 // Associated BSSID ATTR
1032 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1035 // Note: In the WFD specification, the size of length field is 2.
1036 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1041 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1043 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1047 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1050 wfdielen += ETH_ALEN;
1052 // Coupled Sink Information ATTR
1054 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1057 // Note: In the WFD specification, the size of length field is 2.
1058 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1062 // Coupled Sink Status bitmap
1063 // Not coupled/available for Coupling
1064 wfdie[ wfdielen++ ] = 0;
1066 wfdie[ wfdielen++ ] = 0;
1067 wfdie[ wfdielen++ ] = 0;
1068 wfdie[ wfdielen++ ] = 0;
1069 wfdie[ wfdielen++ ] = 0;
1070 wfdie[ wfdielen++ ] = 0;
1071 wfdie[ wfdielen++ ] = 0;
1073 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1079 u32 build_assoc_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1081 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
1082 u32 len=0, wfdielen = 0;
1084 _adapter *padapter = pwdinfo->padapter;
1085 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1086 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
1090 wfdie[ wfdielen++ ] = 0x50;
1091 wfdie[ wfdielen++ ] = 0x6F;
1092 wfdie[ wfdielen++ ] = 0x9A;
1093 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
1095 // Commented by Albert 20110812
1096 // According to the WFD Specification, the probe request frame should contain 4 WFD attributes
1097 // 1. WFD Device Information
1098 // 2. Associated BSSID
1099 // 3. Coupled Sink Information
1102 // WFD Device Information ATTR
1104 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1107 // Note: In the WFD specification, the size of length field is 2.
1108 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1112 // WFD device information
1113 // WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
1114 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
1115 RTW_PUT_BE16(wfdie + wfdielen, val16);
1119 // Session Management Control Port
1120 // Default TCP port for RTSP messages is 554
1121 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1125 // WFD Device Maximum Throughput
1126 // 300Mbps is the maximum throughput
1127 RTW_PUT_BE16(wfdie + wfdielen, 300);
1130 // Associated BSSID ATTR
1132 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1135 // Note: In the WFD specification, the size of length field is 2.
1136 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1141 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1143 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1147 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1150 wfdielen += ETH_ALEN;
1152 // Coupled Sink Information ATTR
1154 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1157 // Note: In the WFD specification, the size of length field is 2.
1158 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1162 // Coupled Sink Status bitmap
1163 // Not coupled/available for Coupling
1164 wfdie[ wfdielen++ ] = 0;
1166 wfdie[ wfdielen++ ] = 0;
1167 wfdie[ wfdielen++ ] = 0;
1168 wfdie[ wfdielen++ ] = 0;
1169 wfdie[ wfdielen++ ] = 0;
1170 wfdie[ wfdielen++ ] = 0;
1171 wfdie[ wfdielen++ ] = 0;
1173 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1179 u32 build_nego_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1181 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
1182 u32 len=0, wfdielen = 0;
1184 _adapter *padapter = pwdinfo->padapter;
1185 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1186 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
1190 wfdie[ wfdielen++ ] = 0x50;
1191 wfdie[ wfdielen++ ] = 0x6F;
1192 wfdie[ wfdielen++ ] = 0x9A;
1193 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
1195 // Commented by Albert 20110825
1196 // According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes
1197 // 1. WFD Device Information
1198 // 2. Associated BSSID ( Optional )
1199 // 3. Local IP Adress ( Optional )
1202 // WFD Device Information ATTR
1204 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1207 // Note: In the WFD specification, the size of length field is 2.
1208 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1212 // WFD device information
1213 // WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available
1214 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL;
1215 RTW_PUT_BE16(wfdie + wfdielen, val16);
1219 // Session Management Control Port
1220 // Default TCP port for RTSP messages is 554
1221 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1225 // WFD Device Maximum Throughput
1226 // 300Mbps is the maximum throughput
1227 RTW_PUT_BE16(wfdie + wfdielen, 300);
1230 // Associated BSSID ATTR
1232 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1235 // Note: In the WFD specification, the size of length field is 2.
1236 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1241 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1243 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1247 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1250 wfdielen += ETH_ALEN;
1252 // Coupled Sink Information ATTR
1254 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1257 // Note: In the WFD specification, the size of length field is 2.
1258 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1262 // Coupled Sink Status bitmap
1263 // Not coupled/available for Coupling
1264 wfdie[ wfdielen++ ] = 0;
1266 wfdie[ wfdielen++ ] = 0;
1267 wfdie[ wfdielen++ ] = 0;
1268 wfdie[ wfdielen++ ] = 0;
1269 wfdie[ wfdielen++ ] = 0;
1270 wfdie[ wfdielen++ ] = 0;
1271 wfdie[ wfdielen++ ] = 0;
1273 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1279 u32 build_nego_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1281 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
1282 u32 len=0, wfdielen = 0;
1284 _adapter *padapter = pwdinfo->padapter;
1285 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1286 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
1290 wfdie[ wfdielen++ ] = 0x50;
1291 wfdie[ wfdielen++ ] = 0x6F;
1292 wfdie[ wfdielen++ ] = 0x9A;
1293 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
1295 // Commented by Albert 20110825
1296 // According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes
1297 // 1. WFD Device Information
1298 // 2. Associated BSSID ( Optional )
1299 // 3. Local IP Adress ( Optional )
1302 // WFD Device Information ATTR
1304 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1307 // Note: In the WFD specification, the size of length field is 2.
1308 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1312 // WFD device information
1313 // WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available
1314 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL;
1315 RTW_PUT_BE16(wfdie + wfdielen, val16);
1319 // Session Management Control Port
1320 // Default TCP port for RTSP messages is 554
1321 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1325 // WFD Device Maximum Throughput
1326 // 300Mbps is the maximum throughput
1327 RTW_PUT_BE16(wfdie + wfdielen, 300);
1330 // Associated BSSID ATTR
1332 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1335 // Note: In the WFD specification, the size of length field is 2.
1336 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1341 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1343 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1347 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1350 wfdielen += ETH_ALEN;
1352 // Coupled Sink Information ATTR
1354 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1357 // Note: In the WFD specification, the size of length field is 2.
1358 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1362 // Coupled Sink Status bitmap
1363 // Not coupled/available for Coupling
1364 wfdie[ wfdielen++ ] = 0;
1366 wfdie[ wfdielen++ ] = 0;
1367 wfdie[ wfdielen++ ] = 0;
1368 wfdie[ wfdielen++ ] = 0;
1369 wfdie[ wfdielen++ ] = 0;
1370 wfdie[ wfdielen++ ] = 0;
1371 wfdie[ wfdielen++ ] = 0;
1374 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1380 u32 build_nego_confirm_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1382 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
1383 u32 len=0, wfdielen = 0;
1385 _adapter *padapter = pwdinfo->padapter;
1386 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1387 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
1391 wfdie[ wfdielen++ ] = 0x50;
1392 wfdie[ wfdielen++ ] = 0x6F;
1393 wfdie[ wfdielen++ ] = 0x9A;
1394 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
1396 // Commented by Albert 20110825
1397 // According to the WFD Specification, the negotiation request frame should contain 3 WFD attributes
1398 // 1. WFD Device Information
1399 // 2. Associated BSSID ( Optional )
1400 // 3. Local IP Adress ( Optional )
1403 // WFD Device Information ATTR
1405 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1408 // Note: In the WFD specification, the size of length field is 2.
1409 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1413 // WFD device information
1414 // WFD primary sink + WiFi Direct mode + WSD ( WFD Service Discovery ) + WFD Session Available
1415 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_WSD | WFD_DEVINFO_SESSION_AVAIL;
1416 RTW_PUT_BE16(wfdie + wfdielen, val16);
1420 // Session Management Control Port
1421 // Default TCP port for RTSP messages is 554
1422 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1426 // WFD Device Maximum Throughput
1427 // 300Mbps is the maximum throughput
1428 RTW_PUT_BE16(wfdie + wfdielen, 300);
1431 // Associated BSSID ATTR
1433 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1436 // Note: In the WFD specification, the size of length field is 2.
1437 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1442 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1444 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1448 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1451 wfdielen += ETH_ALEN;
1453 // Coupled Sink Information ATTR
1455 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1458 // Note: In the WFD specification, the size of length field is 2.
1459 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1463 // Coupled Sink Status bitmap
1464 // Not coupled/available for Coupling
1465 wfdie[ wfdielen++ ] = 0;
1467 wfdie[ wfdielen++ ] = 0;
1468 wfdie[ wfdielen++ ] = 0;
1469 wfdie[ wfdielen++ ] = 0;
1470 wfdie[ wfdielen++ ] = 0;
1471 wfdie[ wfdielen++ ] = 0;
1472 wfdie[ wfdielen++ ] = 0;
1475 pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1481 u32 build_invitation_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1483 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
1484 u32 len=0, wfdielen = 0;
1486 _adapter *padapter = pwdinfo->padapter;
1487 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1488 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
1492 wfdie[ wfdielen++ ] = 0x50;
1493 wfdie[ wfdielen++ ] = 0x6F;
1494 wfdie[ wfdielen++ ] = 0x9A;
1495 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
1497 // Commented by Albert 20110825
1498 // According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes
1499 // 1. WFD Device Information
1500 // 2. Associated BSSID ( Optional )
1501 // 3. Local IP Adress ( Optional )
1504 // WFD Device Information ATTR
1506 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1509 // Note: In the WFD specification, the size of length field is 2.
1510 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1514 // WFD device information
1515 // WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
1516 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
1517 RTW_PUT_BE16(wfdie + wfdielen, val16);
1521 // Session Management Control Port
1522 // Default TCP port for RTSP messages is 554
1523 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1527 // WFD Device Maximum Throughput
1528 // 300Mbps is the maximum throughput
1529 RTW_PUT_BE16(wfdie + wfdielen, 300);
1532 // Associated BSSID ATTR
1534 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1537 // Note: In the WFD specification, the size of length field is 2.
1538 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1543 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1545 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1549 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1552 wfdielen += ETH_ALEN;
1554 // Coupled Sink Information ATTR
1556 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1559 // Note: In the WFD specification, the size of length field is 2.
1560 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1564 // Coupled Sink Status bitmap
1565 // Not coupled/available for Coupling
1566 wfdie[ wfdielen++ ] = 0;
1568 wfdie[ wfdielen++ ] = 0;
1569 wfdie[ wfdielen++ ] = 0;
1570 wfdie[ wfdielen++ ] = 0;
1571 wfdie[ wfdielen++ ] = 0;
1572 wfdie[ wfdielen++ ] = 0;
1573 wfdie[ wfdielen++ ] = 0;
1575 if ( P2P_ROLE_GO == pwdinfo->role )
1577 // WFD Session Information ATTR
1579 wfdie[ wfdielen++ ] = WFD_ATTR_SESSION_INFO;
1582 // Note: In the WFD specification, the size of length field is 2.
1583 RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
1586 // Todo: to add the list of WFD device info descriptor in WFD group.
1590 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1596 u32 build_invitation_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1598 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
1600 u32 len=0, wfdielen = 0;
1601 _adapter *padapter = pwdinfo->padapter;
1602 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1603 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
1607 wfdie[ wfdielen++ ] = 0x50;
1608 wfdie[ wfdielen++ ] = 0x6F;
1609 wfdie[ wfdielen++ ] = 0x9A;
1610 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
1612 // Commented by Albert 20110825
1613 // According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes
1614 // 1. WFD Device Information
1615 // 2. Associated BSSID ( Optional )
1616 // 3. Local IP Adress ( Optional )
1619 // WFD Device Information ATTR
1621 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1624 // Note: In the WFD specification, the size of length field is 2.
1625 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1629 // WFD device information
1630 // WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
1631 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
1632 RTW_PUT_BE16(wfdie + wfdielen, val16);
1636 // Session Management Control Port
1637 // Default TCP port for RTSP messages is 554
1638 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1642 // WFD Device Maximum Throughput
1643 // 300Mbps is the maximum throughput
1644 RTW_PUT_BE16(wfdie + wfdielen, 300);
1647 // Associated BSSID ATTR
1649 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1652 // Note: In the WFD specification, the size of length field is 2.
1653 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1658 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1660 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1664 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1667 wfdielen += ETH_ALEN;
1669 // Coupled Sink Information ATTR
1671 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1674 // Note: In the WFD specification, the size of length field is 2.
1675 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1679 // Coupled Sink Status bitmap
1680 // Not coupled/available for Coupling
1681 wfdie[ wfdielen++ ] = 0;
1683 wfdie[ wfdielen++ ] = 0;
1684 wfdie[ wfdielen++ ] = 0;
1685 wfdie[ wfdielen++ ] = 0;
1686 wfdie[ wfdielen++ ] = 0;
1687 wfdie[ wfdielen++ ] = 0;
1688 wfdie[ wfdielen++ ] = 0;
1690 if ( P2P_ROLE_GO == pwdinfo->role )
1692 // WFD Session Information ATTR
1694 wfdie[ wfdielen++ ] = WFD_ATTR_SESSION_INFO;
1697 // Note: In the WFD specification, the size of length field is 2.
1698 RTW_PUT_BE16(wfdie + wfdielen, 0x0000);
1701 // Todo: to add the list of WFD device info descriptor in WFD group.
1705 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1711 u32 build_provdisc_req_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1713 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
1714 u32 len=0, wfdielen = 0;
1716 _adapter *padapter = pwdinfo->padapter;
1717 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1718 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
1722 wfdie[ wfdielen++ ] = 0x50;
1723 wfdie[ wfdielen++ ] = 0x6F;
1724 wfdie[ wfdielen++ ] = 0x9A;
1725 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
1727 // Commented by Albert 20110825
1728 // According to the WFD Specification, the provision discovery request frame should contain 3 WFD attributes
1729 // 1. WFD Device Information
1730 // 2. Associated BSSID ( Optional )
1731 // 3. Local IP Adress ( Optional )
1734 // WFD Device Information ATTR
1736 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1739 // Note: In the WFD specification, the size of length field is 2.
1740 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1744 // WFD device information
1745 // WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
1746 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
1747 RTW_PUT_BE16(wfdie + wfdielen, val16);
1751 // Session Management Control Port
1752 // Default TCP port for RTSP messages is 554
1753 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1757 // WFD Device Maximum Throughput
1758 // 300Mbps is the maximum throughput
1759 RTW_PUT_BE16(wfdie + wfdielen, 300);
1762 // Associated BSSID ATTR
1764 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1767 // Note: In the WFD specification, the size of length field is 2.
1768 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1773 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1775 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1779 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1782 wfdielen += ETH_ALEN;
1784 // Coupled Sink Information ATTR
1786 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1789 // Note: In the WFD specification, the size of length field is 2.
1790 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1794 // Coupled Sink Status bitmap
1795 // Not coupled/available for Coupling
1796 wfdie[ wfdielen++ ] = 0;
1798 wfdie[ wfdielen++ ] = 0;
1799 wfdie[ wfdielen++ ] = 0;
1800 wfdie[ wfdielen++ ] = 0;
1801 wfdie[ wfdielen++ ] = 0;
1802 wfdie[ wfdielen++ ] = 0;
1803 wfdie[ wfdielen++ ] = 0;
1806 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1812 u32 build_provdisc_resp_wfd_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1814 u8 wfdie[ MAX_WFD_IE_LEN] = { 0x00 };
1815 u32 len=0, wfdielen = 0;
1817 _adapter *padapter = pwdinfo->padapter;
1818 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1819 struct wifi_display_info* pwfd_info = padapter->wdinfo.wfd_info;
1823 wfdie[ wfdielen++ ] = 0x50;
1824 wfdie[ wfdielen++ ] = 0x6F;
1825 wfdie[ wfdielen++ ] = 0x9A;
1826 wfdie[ wfdielen++ ] = 0x0A; // WFA WFD v1.0
1828 // Commented by Albert 20110825
1829 // According to the WFD Specification, the provision discovery response frame should contain 3 WFD attributes
1830 // 1. WFD Device Information
1831 // 2. Associated BSSID ( Optional )
1832 // 3. Local IP Adress ( Optional )
1835 // WFD Device Information ATTR
1837 wfdie[ wfdielen++ ] = WFD_ATTR_DEVICE_INFO;
1840 // Note: In the WFD specification, the size of length field is 2.
1841 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1845 // WFD device information
1846 // WFD primary sink + available for WFD session + WiFi Direct mode + WSD ( WFD Service Discovery )
1847 val16 = pwfd_info->wfd_device_type | WFD_DEVINFO_SESSION_AVAIL | WFD_DEVINFO_WSD;
1848 RTW_PUT_BE16(wfdie + wfdielen, val16);
1852 // Session Management Control Port
1853 // Default TCP port for RTSP messages is 554
1854 RTW_PUT_BE16(wfdie + wfdielen, pwfd_info->rtsp_ctrlport );
1858 // WFD Device Maximum Throughput
1859 // 300Mbps is the maximum throughput
1860 RTW_PUT_BE16(wfdie + wfdielen, 300);
1863 // Associated BSSID ATTR
1865 wfdie[ wfdielen++ ] = WFD_ATTR_ASSOC_BSSID;
1868 // Note: In the WFD specification, the size of length field is 2.
1869 RTW_PUT_BE16(wfdie + wfdielen, 0x0006);
1874 if ( check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE )
1876 _rtw_memcpy( wfdie + wfdielen, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN );
1880 _rtw_memset( wfdie + wfdielen, 0x00, ETH_ALEN );
1883 wfdielen += ETH_ALEN;
1885 // Coupled Sink Information ATTR
1887 wfdie[ wfdielen++ ] = WFD_ATTR_COUPLED_SINK_INFO;
1890 // Note: In the WFD specification, the size of length field is 2.
1891 RTW_PUT_BE16(wfdie + wfdielen, 0x0007);
1895 // Coupled Sink Status bitmap
1896 // Not coupled/available for Coupling
1897 wfdie[ wfdielen++ ] = 0;
1899 wfdie[ wfdielen++ ] = 0;
1900 wfdie[ wfdielen++ ] = 0;
1901 wfdie[ wfdielen++ ] = 0;
1902 wfdie[ wfdielen++ ] = 0;
1903 wfdie[ wfdielen++ ] = 0;
1904 wfdie[ wfdielen++ ] = 0;
1906 rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, wfdielen, (unsigned char *) wfdie, &len);
1915 u32 build_probe_resp_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
1917 u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
1918 u32 len=0, p2pielen = 0;
1919 #ifdef CONFIG_INTEL_WIDI
1920 struct mlme_priv *pmlmepriv = &(pwdinfo->padapter->mlmepriv);
1921 u8 zero_array_check[L2SDTA_SERVICE_VE_LEN] = { 0x00 };
1922 u8 widi_version = 0, i = 0;
1924 if( _rtw_memcmp( pmlmepriv->sa_ext, zero_array_check, L2SDTA_SERVICE_VE_LEN ) == _FALSE )
1928 else if( pmlmepriv->num_p2p_sdt != 0 )
1932 #endif //CONFIG_INTEL_WIDI
1936 p2pie[ p2pielen++ ] = 0x50;
1937 p2pie[ p2pielen++ ] = 0x6F;
1938 p2pie[ p2pielen++ ] = 0x9A;
1939 p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
1941 // Commented by Albert 20100907
1942 // According to the P2P Specification, the probe response frame should contain 5 P2P attributes
1943 // 1. P2P Capability
1944 // 2. Extended Listen Timing
1945 // 3. Notice of Absence ( NOA ) ( Only GO needs this )
1947 // 5. Group Info ( Only GO need this )
1949 // P2P Capability ATTR
1951 p2pie[ p2pielen++ ] = P2P_ATTR_CAPABILITY;
1954 //*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0x0002 );
1955 RTW_PUT_LE16(p2pie + p2pielen, 0x0002);
1959 // Device Capability Bitmap, 1 byte
1960 p2pie[ p2pielen++ ] = DMP_P2P_DEVCAP_SUPPORT;
1962 // Group Capability Bitmap, 1 byte
1963 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
1965 p2pie[ p2pielen ] = (P2P_GRPCAP_GO | P2P_GRPCAP_INTRABSS);
1967 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_PROVISIONING_ING))
1968 p2pie[ p2pielen ] |= P2P_GRPCAP_GROUP_FORMATION;
1972 else if ( rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) )
1974 // Group Capability Bitmap, 1 byte
1975 if ( pwdinfo->persistent_supported )
1976 p2pie[ p2pielen++ ] = P2P_GRPCAP_PERSISTENT_GROUP | DMP_P2P_GRPCAP_SUPPORT;
1978 p2pie[ p2pielen++ ] = DMP_P2P_GRPCAP_SUPPORT;
1981 // Extended Listen Timing ATTR
1983 p2pie[ p2pielen++ ] = P2P_ATTR_EX_LISTEN_TIMING;
1986 //*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0x0004 );
1987 RTW_PUT_LE16(p2pie + p2pielen, 0x0004);
1991 // Availability Period
1992 //*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0xFFFF );
1993 RTW_PUT_LE16(p2pie + p2pielen, 0xFFFF);
1996 // Availability Interval
1997 //*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0xFFFF );
1998 RTW_PUT_LE16(p2pie + p2pielen, 0xFFFF);
2002 // Notice of Absence ATTR
2006 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
2008 //go_add_noa_attr(pwdinfo);
2013 p2pie[ p2pielen++ ] = P2P_ATTR_DEVICE_INFO;
2016 // 21 -> P2P Device Address (6bytes) + Config Methods (2bytes) + Primary Device Type (8bytes)
2017 // + NumofSecondDevType (1byte) + WPS Device Name ID field (2bytes) + WPS Device Name Len field (2bytes)
2018 //*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 21 + pwdinfo->device_name_len );
2019 #ifdef CONFIG_INTEL_WIDI
2020 if( widi_version == 35 )
2022 RTW_PUT_LE16(p2pie + p2pielen, 21 + 8 + pwdinfo->device_name_len);
2024 else if( widi_version == 40 )
2026 RTW_PUT_LE16(p2pie + p2pielen, 21 + 8 * pmlmepriv->num_p2p_sdt + pwdinfo->device_name_len);
2029 #endif //CONFIG_INTEL_WIDI
2030 RTW_PUT_LE16(p2pie + p2pielen, 21 + pwdinfo->device_name_len);
2034 // P2P Device Address
2035 _rtw_memcpy( p2pie + p2pielen, pwdinfo->device_addr, ETH_ALEN );
2036 p2pielen += ETH_ALEN;
2039 // This field should be big endian. Noted by P2P specification.
2040 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( pwdinfo->supported_wps_cm );
2041 RTW_PUT_BE16(p2pie + p2pielen, pwdinfo->supported_wps_cm);
2044 #ifdef CONFIG_INTEL_WIDI
2045 if( widi_version == 40 )
2047 // Primary Device Type
2049 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_CID_MULIT_MEDIA );
2050 RTW_PUT_BE16(p2pie + p2pielen, pmlmepriv->p2p_pdt_cid );
2054 //*(u32*) ( p2pie + p2pielen ) = cpu_to_be32( WPSOUI );
2055 RTW_PUT_BE32(p2pie + p2pielen, WPSOUI);
2059 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_SCID_MEDIA_SERVER );
2060 RTW_PUT_BE16(p2pie + p2pielen, pmlmepriv->p2p_pdt_scid);
2064 #endif //CONFIG_INTEL_WIDI
2066 // Primary Device Type
2068 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_CID_MULIT_MEDIA );
2069 RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_CID_MULIT_MEDIA);
2073 //*(u32*) ( p2pie + p2pielen ) = cpu_to_be32( WPSOUI );
2074 RTW_PUT_BE32(p2pie + p2pielen, WPSOUI);
2078 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_SCID_MEDIA_SERVER );
2079 RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_SCID_MEDIA_SERVER);
2083 // Number of Secondary Device Types
2084 #ifdef CONFIG_INTEL_WIDI
2085 if( widi_version == 35 )
2087 p2pie[ p2pielen++ ] = 0x01;
2089 RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_CID_DISPLAYS);
2092 RTW_PUT_BE32(p2pie + p2pielen, INTEL_DEV_TYPE_OUI);
2095 RTW_PUT_BE16(p2pie + p2pielen, P2P_SCID_WIDI_CONSUMER_SINK);
2098 else if( widi_version == 40 )
2100 p2pie[ p2pielen++ ] = pmlmepriv->num_p2p_sdt;
2101 for( ; i < pmlmepriv->num_p2p_sdt; i++ )
2103 RTW_PUT_BE16(p2pie + p2pielen, pmlmepriv->p2p_sdt_cid[i]);
2106 RTW_PUT_BE32(p2pie + p2pielen, INTEL_DEV_TYPE_OUI);
2109 RTW_PUT_BE16(p2pie + p2pielen, pmlmepriv->p2p_sdt_scid[i]);
2114 #endif //CONFIG_INTEL_WIDI
2115 p2pie[ p2pielen++ ] = 0x00; // No Secondary Device Type List
2119 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_ATTR_DEVICE_NAME );
2120 RTW_PUT_BE16(p2pie + p2pielen, WPS_ATTR_DEVICE_NAME);
2124 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( pwdinfo->device_name_len );
2125 RTW_PUT_BE16(p2pie + p2pielen, pwdinfo->device_name_len);
2129 _rtw_memcpy( p2pie + p2pielen, pwdinfo->device_name, pwdinfo->device_name_len );
2130 p2pielen += pwdinfo->device_name_len;
2136 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
2138 p2pielen += go_add_group_info_attr(pwdinfo, p2pie + p2pielen);
2142 pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, p2pielen, (unsigned char *) p2pie, &len);
2149 u32 build_prov_disc_request_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf, u8* pssid, u8 ussidlen, u8* pdev_raddr )
2151 u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
2152 u32 len=0, p2pielen = 0;
2156 p2pie[ p2pielen++ ] = 0x50;
2157 p2pie[ p2pielen++ ] = 0x6F;
2158 p2pie[ p2pielen++ ] = 0x9A;
2159 p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
2161 // Commented by Albert 20110301
2162 // According to the P2P Specification, the provision discovery request frame should contain 3 P2P attributes
2163 // 1. P2P Capability
2165 // 3. Group ID ( When joining an operating P2P Group )
2167 // P2P Capability ATTR
2169 p2pie[ p2pielen++ ] = P2P_ATTR_CAPABILITY;
2172 //*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 0x0002 );
2173 RTW_PUT_LE16(p2pie + p2pielen, 0x0002);
2177 // Device Capability Bitmap, 1 byte
2178 p2pie[ p2pielen++ ] = DMP_P2P_DEVCAP_SUPPORT;
2180 // Group Capability Bitmap, 1 byte
2181 if ( pwdinfo->persistent_supported )
2182 p2pie[ p2pielen++ ] = P2P_GRPCAP_PERSISTENT_GROUP | DMP_P2P_GRPCAP_SUPPORT;
2184 p2pie[ p2pielen++ ] = DMP_P2P_GRPCAP_SUPPORT;
2189 p2pie[ p2pielen++ ] = P2P_ATTR_DEVICE_INFO;
2192 // 21 -> P2P Device Address (6bytes) + Config Methods (2bytes) + Primary Device Type (8bytes)
2193 // + NumofSecondDevType (1byte) + WPS Device Name ID field (2bytes) + WPS Device Name Len field (2bytes)
2194 //*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( 21 + pwdinfo->device_name_len );
2195 RTW_PUT_LE16(p2pie + p2pielen, 21 + pwdinfo->device_name_len);
2199 // P2P Device Address
2200 _rtw_memcpy( p2pie + p2pielen, pwdinfo->device_addr, ETH_ALEN );
2201 p2pielen += ETH_ALEN;
2204 // This field should be big endian. Noted by P2P specification.
2205 if ( pwdinfo->ui_got_wps_info == P2P_GOT_WPSINFO_PBC )
2207 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_CONFIG_METHOD_PBC );
2208 RTW_PUT_BE16(p2pie + p2pielen, WPS_CONFIG_METHOD_PBC);
2212 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_CONFIG_METHOD_DISPLAY );
2213 RTW_PUT_BE16(p2pie + p2pielen, WPS_CONFIG_METHOD_DISPLAY);
2218 // Primary Device Type
2220 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_CID_MULIT_MEDIA );
2221 RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_CID_MULIT_MEDIA);
2225 //*(u32*) ( p2pie + p2pielen ) = cpu_to_be32( WPSOUI );
2226 RTW_PUT_BE32(p2pie + p2pielen, WPSOUI);
2230 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_PDT_SCID_MEDIA_SERVER );
2231 RTW_PUT_BE16(p2pie + p2pielen, WPS_PDT_SCID_MEDIA_SERVER);
2234 // Number of Secondary Device Types
2235 p2pie[ p2pielen++ ] = 0x00; // No Secondary Device Type List
2239 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( WPS_ATTR_DEVICE_NAME );
2240 RTW_PUT_BE16(p2pie + p2pielen, WPS_ATTR_DEVICE_NAME);
2244 //*(u16*) ( p2pie + p2pielen ) = cpu_to_be16( pwdinfo->device_name_len );
2245 RTW_PUT_BE16(p2pie + p2pielen, pwdinfo->device_name_len);
2249 _rtw_memcpy( p2pie + p2pielen, pwdinfo->device_name, pwdinfo->device_name_len );
2250 p2pielen += pwdinfo->device_name_len;
2252 if ( rtw_p2p_chk_role(pwdinfo, P2P_ROLE_CLIENT) )
2254 // Added by Albert 2011/05/19
2255 // In this case, the pdev_raddr is the device address of the group owner.
2257 // P2P Group ID ATTR
2259 p2pie[ p2pielen++ ] = P2P_ATTR_GROUP_ID;
2262 //*(u16*) ( p2pie + p2pielen ) = cpu_to_le16( ETH_ALEN + ussidlen );
2263 RTW_PUT_LE16(p2pie + p2pielen, ETH_ALEN + ussidlen);
2267 _rtw_memcpy( p2pie + p2pielen, pdev_raddr, ETH_ALEN );
2268 p2pielen += ETH_ALEN;
2270 _rtw_memcpy( p2pie + p2pielen, pssid, ussidlen );
2271 p2pielen += ussidlen;
2275 pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, p2pielen, (unsigned char *) p2pie, &len);
2283 u32 build_assoc_resp_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf, u8 status_code)
2285 u8 p2pie[ MAX_P2P_IE_LEN] = { 0x00 };
2286 u32 len=0, p2pielen = 0;
2290 p2pie[ p2pielen++ ] = 0x50;
2291 p2pie[ p2pielen++ ] = 0x6F;
2292 p2pie[ p2pielen++ ] = 0x9A;
2293 p2pie[ p2pielen++ ] = 0x09; // WFA P2P v1.0
2295 // According to the P2P Specification, the Association response frame should contain 2 P2P attributes
2297 // 2. Extended Listen Timing (optional)
2301 p2pielen += rtw_set_p2p_attr_content(&p2pie[p2pielen], P2P_ATTR_STATUS, 1, &status_code);
2304 // Extended Listen Timing ATTR
2310 pbuf = rtw_set_ie(pbuf, _VENDOR_SPECIFIC_IE_, p2pielen, (unsigned char *) p2pie, &len);
2316 u32 build_deauth_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pbuf)
2323 u32 process_probe_req_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
2329 int ssid_len=0, rate_cnt = 0;
2331 p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SUPPORTEDRATES_IE_, (int *)&rate_cnt,
2332 len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
2334 if ( rate_cnt <= 4 )
2338 for( i = 0; i < rate_cnt; i++ )
2340 if ( ( ( *( p + 2 + i ) & 0xff ) != 0x02 ) &&
2341 ( ( *( p + 2 + i ) & 0xff ) != 0x04 ) &&
2342 ( ( *( p + 2 + i ) & 0xff ) != 0x0B ) &&
2343 ( ( *( p + 2 + i ) & 0xff ) != 0x16 ) )
2351 // There is no OFDM rate included in SupportedRates IE of this probe request frame
2352 // The driver should response this probe request.
2358 // rate_cnt > 4 means the SupportRates IE contains the OFDM rate because the count of CCK rates are 4.
2359 // We should proceed the following check for this probe request.
2362 // Added comments by Albert 20100906
2363 // There are several items we should check here.
2364 // 1. This probe request frame must contain the P2P IE. (Done)
2365 // 2. This probe request frame must contain the wildcard SSID. (Done)
2366 // 3. Wildcard BSSID. (Todo)
2367 // 4. Destination Address. ( Done in mgt_dispatcher function )
2368 // 5. Requested Device Type in WSC IE. (Todo)
2369 // 6. Device ID attribute in P2P IE. (Todo)
2371 p = rtw_get_ie(pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_, _SSID_IE_, (int *)&ssid_len,
2372 len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_);
2374 ssid_len &= 0xff; // Just last 1 byte is valid for ssid len of the probe request
2375 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE) || rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
2377 if((p2pie=rtw_get_p2p_ie( pframe + WLAN_HDR_A3_LEN + _PROBEREQ_IE_OFFSET_ , len - WLAN_HDR_A3_LEN - _PROBEREQ_IE_OFFSET_ , NULL, &p2pielen)))
2379 if ( (p != NULL) && _rtw_memcmp( ( void * ) ( p+2 ), ( void * ) pwdinfo->p2p_wildcard_ssid , 7 ))
2382 //Check Requested Device Type attributes in WSC IE.
2383 //Check Device ID attribute in P2P IE
2387 else if ( (p != NULL) && ( ssid_len == 0 ) )
2404 u32 process_assoc_req_p2p_ie(struct wifidirect_info *pwdinfo, u8 *pframe, uint len, struct sta_info *psta)
2406 u8 status_code = P2P_STATUS_SUCCESS;
2407 u8 *pbuf, *pattr_content=NULL;
2408 u32 attr_contentlen = 0;
2410 unsigned short frame_type, ie_offset=0;
2416 if(!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
2417 return P2P_STATUS_FAIL_REQUEST_UNABLE;
2419 frame_type = GetFrameSubType(pframe);
2420 if (frame_type == WIFI_ASSOCREQ)
2422 ie_offset = _ASOCREQ_IE_OFFSET_;
2424 else // WIFI_REASSOCREQ
2426 ie_offset = _REASOCREQ_IE_OFFSET_;
2429 ies = pframe + WLAN_HDR_A3_LEN + ie_offset;
2430 ies_len = len - WLAN_HDR_A3_LEN - ie_offset;
2432 p2p_ie = rtw_get_p2p_ie(ies , ies_len , NULL, &p2p_ielen);
2436 DBG_8192C( "[%s] P2P IE not Found!!\n", __FUNCTION__ );
2437 status_code = P2P_STATUS_FAIL_INVALID_PARAM;
2441 DBG_8192C( "[%s] P2P IE Found!!\n", __FUNCTION__ );
2446 //Check P2P Capability ATTR
2447 if( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_CAPABILITY, (u8*)&cap_attr, (uint*) &attr_contentlen) )
2449 DBG_8192C( "[%s] Got P2P Capability Attr!!\n", __FUNCTION__ );
2450 cap_attr = le16_to_cpu(cap_attr);
2451 psta->dev_cap = cap_attr&0xff;
2454 //Check Extended Listen Timing ATTR
2457 //Check P2P Device Info ATTR
2458 if(rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_DEVICE_INFO, NULL, (uint*)&attr_contentlen))
2460 DBG_8192C( "[%s] Got P2P DEVICE INFO Attr!!\n", __FUNCTION__ );
2461 pattr_content = pbuf = rtw_zmalloc(attr_contentlen);
2464 u8 num_of_secdev_type;
2468 rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_DEVICE_INFO , pattr_content, (uint*)&attr_contentlen);
2470 _rtw_memcpy(psta->dev_addr, pattr_content, ETH_ALEN);//P2P Device Address
2472 pattr_content += ETH_ALEN;
2474 _rtw_memcpy(&psta->config_methods, pattr_content, 2);//Config Methods
2475 psta->config_methods = be16_to_cpu(psta->config_methods);
2479 _rtw_memcpy(psta->primary_dev_type, pattr_content, 8);
2483 num_of_secdev_type = *pattr_content;
2486 if(num_of_secdev_type==0)
2488 psta->num_of_secdev_type = 0;
2494 psta->num_of_secdev_type = num_of_secdev_type;
2496 len = (sizeof(psta->secdev_types_list)<(num_of_secdev_type*8)) ? (sizeof(psta->secdev_types_list)) : (num_of_secdev_type*8);
2498 _rtw_memcpy(psta->secdev_types_list, pattr_content, len);
2500 pattr_content += (num_of_secdev_type*8);
2504 //dev_name_len = attr_contentlen - ETH_ALEN - 2 - 8 - 1 - (num_of_secdev_type*8);
2505 psta->dev_name_len=0;
2506 if(WPS_ATTR_DEVICE_NAME == be16_to_cpu(*(u16*)pattr_content))
2508 dev_name_len = be16_to_cpu(*(u16*)(pattr_content+2));
2510 psta->dev_name_len = (sizeof(psta->dev_name)<dev_name_len) ? sizeof(psta->dev_name):dev_name_len;
2512 _rtw_memcpy(psta->dev_name, pattr_content+4, psta->dev_name_len);
2515 rtw_mfree(pbuf, attr_contentlen);
2521 //Get the next P2P IE
2522 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
2530 u32 process_p2p_devdisc_req(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
2533 u8 status, dialogToken;
2534 struct sta_info *psta = NULL;
2535 _adapter *padapter = pwdinfo->padapter;
2536 struct sta_priv *pstapriv = &padapter->stapriv;
2540 frame_body = (unsigned char *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
2542 dialogToken = frame_body[7];
2543 status = P2P_STATUS_FAIL_UNKNOWN_P2PGROUP;
2545 if ( (p2p_ie=rtw_get_p2p_ie( frame_body + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, NULL, &p2p_ielen)) )
2547 u8 groupid[ 38 ] = { 0x00 };
2548 u8 dev_addr[ETH_ALEN] = { 0x00 };
2549 u32 attr_contentlen = 0;
2551 if(rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GROUP_ID, groupid, &attr_contentlen))
2553 if(_rtw_memcmp(pwdinfo->device_addr, groupid, ETH_ALEN) &&
2554 _rtw_memcmp(pwdinfo->p2p_group_ssid, groupid+ETH_ALEN, pwdinfo->p2p_group_ssid_len))
2557 if(rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_DEVICE_ID, dev_addr, &attr_contentlen))
2560 _list *phead, *plist;
2562 _enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
2563 phead = &pstapriv->asoc_list;
2564 plist = get_next(phead);
2566 //look up sta asoc_queue
2567 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE)
2569 psta = LIST_CONTAINOR(plist, struct sta_info, asoc_list);
2571 plist = get_next(plist);
2573 if(psta->is_p2p_device && (psta->dev_cap&P2P_DEVCAP_CLIENT_DISCOVERABILITY) &&
2574 _rtw_memcmp(psta->dev_addr, dev_addr, ETH_ALEN))
2577 //_exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
2578 //issue GO Discoverability Request
2579 issue_group_disc_req(pwdinfo, psta->hwaddr);
2580 //_enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
2582 status = P2P_STATUS_SUCCESS;
2588 status = P2P_STATUS_FAIL_INFO_UNAVAILABLE;
2592 _exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
2597 status = P2P_STATUS_FAIL_INVALID_PARAM;
2603 status = P2P_STATUS_FAIL_INVALID_PARAM;
2611 //issue Device Discoverability Response
2612 issue_p2p_devdisc_resp(pwdinfo, GetAddr2Ptr(pframe), status, dialogToken);
2615 return (status==P2P_STATUS_SUCCESS) ? _TRUE:_FALSE;
2619 u32 process_p2p_devdisc_resp(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
2624 u8 process_p2p_provdisc_req(struct wifidirect_info *pwdinfo, u8 *pframe, uint len )
2628 uint wps_ielen = 0, attr_contentlen = 0;
2629 u16 uconfig_method = 0;
2632 frame_body = (pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
2634 if ( (wpsie=rtw_get_wps_ie( frame_body + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, NULL, &wps_ielen)) )
2636 if ( rtw_get_wps_attr_content( wpsie, wps_ielen, WPS_ATTR_CONF_METHOD , ( u8* ) &uconfig_method, &attr_contentlen) )
2638 uconfig_method = be16_to_cpu( uconfig_method );
2639 switch( uconfig_method )
2641 case WPS_CM_DISPLYA:
2643 _rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "dis", 3 );
2648 _rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "lab", 3 );
2651 case WPS_CM_PUSH_BUTTON:
2653 _rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "pbc", 3 );
2658 _rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "pad", 3 );
2662 issue_p2p_provision_resp( pwdinfo, GetAddr2Ptr(pframe), frame_body, uconfig_method);
2665 DBG_871X( "[%s] config method = %s\n", __FUNCTION__, pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req );
2670 u8 process_p2p_provdisc_resp(struct wifidirect_info *pwdinfo, u8 *pframe)
2676 u8 rtw_p2p_get_peer_ch_list(struct wifidirect_info *pwdinfo, u8 *ch_content, u8 ch_cnt, u8 *peer_ch_list)
2689 for( i = 0 ; i < temp ; i++, j++ )
2691 peer_ch_list[j] = *( ch_content + 1 + i );
2693 ch_content += (temp + 1);
2694 ch_cnt -= (temp + 1);
2701 u8 rtw_p2p_check_peer_oper_ch(struct mlme_ext_priv *pmlmeext, u8 ch)
2705 for( i = 0; i < pmlmeext->max_chan_nums; i++ )
2707 if ( pmlmeext->channel_set[ i ].ChannelNum == ch )
2716 u8 rtw_p2p_ch_inclusion(struct mlme_ext_priv *pmlmeext, u8 *peer_ch_list, u8 peer_ch_num, u8 *ch_list_inclusioned)
2718 int i = 0, j = 0, temp = 0;
2721 for( i = 0; i < peer_ch_num; i++ )
2723 for( j = temp; j < pmlmeext->max_chan_nums; j++ )
2725 if( *( peer_ch_list + i ) == pmlmeext->channel_set[ j ].ChannelNum )
2727 ch_list_inclusioned[ ch_no++ ] = *( peer_ch_list + i );
2737 u8 process_p2p_group_negotation_req( struct wifidirect_info *pwdinfo, u8 *pframe, uint len )
2739 _adapter *padapter = pwdinfo->padapter;
2740 u8 result = P2P_STATUS_SUCCESS;
2741 u32 p2p_ielen = 0, wps_ielen = 0;
2746 u16 wps_devicepassword_id = 0x0000;
2747 uint wps_devicepassword_id_len = 0;
2749 u8 wfd_ie[ 128 ] = { 0x00 };
2752 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
2753 #endif // CONFIG_TDLS
2754 #endif // CONFIG_WFD
2755 #ifdef CONFIG_CONCURRENT_MODE
2756 _adapter *pbuddy_adapter = pwdinfo->padapter->pbuddy_adapter;
2757 struct wifidirect_info *pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
2758 struct mlme_priv *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
2759 struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
2762 if ( (wpsie=rtw_get_wps_ie( pframe + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, NULL, &wps_ielen)) )
2764 // Commented by Kurt 20120113
2765 // If some device wants to do p2p handshake without sending prov_disc_req
2766 // We have to get peer_req_cm from here.
2767 if(_rtw_memcmp( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "000", 3) )
2769 rtw_get_wps_attr_content( wpsie, wps_ielen, WPS_ATTR_DEVICE_PWID, (u8*) &wps_devicepassword_id, &wps_devicepassword_id_len);
2770 wps_devicepassword_id = be16_to_cpu( wps_devicepassword_id );
2772 if ( wps_devicepassword_id == WPS_DPID_USER_SPEC )
2774 _rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "dis", 3 );
2776 else if ( wps_devicepassword_id == WPS_DPID_REGISTRAR_SPEC )
2778 _rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "pad", 3 );
2782 _rtw_memcpy( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, "pbc", 3 );
2788 DBG_871X( "[%s] WPS IE not Found!!\n", __FUNCTION__ );
2789 result = P2P_STATUS_FAIL_INCOMPATIBLE_PARAM;
2790 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
2794 if ( pwdinfo->ui_got_wps_info == P2P_NO_WPSINFO )
2796 result = P2P_STATUS_FAIL_INFO_UNAVAILABLE;
2797 rtw_p2p_set_state(pwdinfo, P2P_STATE_TX_INFOR_NOREADY);
2801 ies = pframe + _PUBLIC_ACTION_IE_OFFSET_;
2802 ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
2804 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
2808 DBG_871X( "[%s] P2P IE not Found!!\n", __FUNCTION__ );
2809 result = P2P_STATUS_FAIL_INCOMPATIBLE_PARAM;
2810 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
2815 u8 attr_content = 0x00;
2816 u32 attr_contentlen = 0;
2817 u8 ch_content[100] = { 0x00 };
2819 u8 peer_ch_list[100] = { 0x00 };
2821 u8 ch_list_inclusioned[100] = { 0x00 };
2822 u8 ch_num_inclusioned = 0;
2825 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_ING);
2827 //Check P2P Capability ATTR
2828 if(rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CAPABILITY, (u8*)&cap_attr, (uint*)&attr_contentlen) )
2830 cap_attr = le16_to_cpu(cap_attr);
2832 #if defined(CONFIG_WFD) && defined(CONFIG_TDLS)
2833 if(!(cap_attr & P2P_GRPCAP_INTRABSS) )
2834 ptdlsinfo->ap_prohibited = _TRUE;
2835 #endif //defined(CONFIG_WFD) && defined(CONFIG_TDLS)
2838 if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GO_INTENT , &attr_content, &attr_contentlen) )
2840 DBG_871X( "[%s] GO Intent = %d, tie = %d\n", __FUNCTION__, attr_content >> 1, attr_content & 0x01 );
2841 pwdinfo->peer_intent = attr_content; // include both intent and tie breaker values.
2843 if ( pwdinfo->intent == ( pwdinfo->peer_intent >> 1 ) )
2845 // Try to match the tie breaker value
2846 if ( pwdinfo->intent == P2P_MAX_INTENT )
2848 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
2849 result = P2P_STATUS_FAIL_BOTH_GOINTENT_15;
2853 if ( attr_content & 0x01 )
2855 rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
2859 rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
2863 else if ( pwdinfo->intent > ( pwdinfo->peer_intent >> 1 ) )
2865 rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
2869 rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
2872 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
2874 // Store the group id information.
2875 _rtw_memcpy( pwdinfo->groupid_info.go_device_addr, pwdinfo->device_addr, ETH_ALEN );
2876 _rtw_memcpy( pwdinfo->groupid_info.ssid, pwdinfo->nego_ssid, pwdinfo->nego_ssidlen );
2881 attr_contentlen = 0;
2882 if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_INTENTED_IF_ADDR, pwdinfo->p2p_peer_interface_addr, &attr_contentlen ) )
2884 if ( attr_contentlen != ETH_ALEN )
2886 _rtw_memset( pwdinfo->p2p_peer_interface_addr, 0x00, ETH_ALEN );
2890 if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, ch_content, &ch_cnt) )
2892 peer_ch_num = rtw_p2p_get_peer_ch_list(pwdinfo, ch_content, ch_cnt, peer_ch_list);
2893 ch_num_inclusioned = rtw_p2p_ch_inclusion(&padapter->mlmeextpriv, peer_ch_list, peer_ch_num, ch_list_inclusioned);
2895 if( ch_num_inclusioned == 0)
2897 DBG_871X( "[%s] No common channel in channel list!\n", __FUNCTION__ );
2898 result = P2P_STATUS_FAIL_NO_COMMON_CH;
2899 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
2903 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
2905 if ( !rtw_p2p_is_channel_list_ok( pwdinfo->operating_channel,
2906 ch_list_inclusioned, ch_num_inclusioned) )
2908 #ifdef CONFIG_CONCURRENT_MODE
2909 if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
2911 DBG_871X( "[%s] desired channel NOT Found!\n", __FUNCTION__ );
2912 result = P2P_STATUS_FAIL_NO_COMMON_CH;
2913 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
2917 #endif //CONFIG_CONCURRENT_MODE
2919 u8 operatingch_info[5] = { 0x00 }, peer_operating_ch = 0;
2920 attr_contentlen = 0;
2922 if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, operatingch_info, &attr_contentlen) )
2924 peer_operating_ch = operatingch_info[4];
2927 if ( rtw_p2p_is_channel_list_ok( peer_operating_ch,
2928 ch_list_inclusioned, ch_num_inclusioned) )
2931 * Change our operating channel as peer's for compatibility.
2933 pwdinfo->operating_channel = peer_operating_ch;
2934 DBG_871X( "[%s] Change op ch to %02x as peer's\n", __FUNCTION__, pwdinfo->operating_channel);
2938 // Take first channel of ch_list_inclusioned as operating channel
2939 pwdinfo->operating_channel = ch_list_inclusioned[0];
2940 DBG_871X( "[%s] Change op ch to %02x\n", __FUNCTION__, pwdinfo->operating_channel);
2948 //Get the next P2P IE
2949 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
2953 // Added by Albert 20110823
2954 // Try to get the TCP port information when receiving the negotiation request.
2955 if ( rtw_get_wfd_ie( pframe + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, wfd_ie, &wfd_ielen ) )
2957 u8 attr_content[ 10 ] = { 0x00 };
2958 u32 attr_contentlen = 0;
2960 DBG_871X( "[%s] WFD IE Found!!\n", __FUNCTION__ );
2961 rtw_get_wfd_attr_content( wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, attr_content, &attr_contentlen);
2962 if ( attr_contentlen )
2964 pwdinfo->wfd_info->peer_rtsp_ctrlport = RTW_GET_BE16( attr_content + 2 );
2965 DBG_871X( "[%s] Peer PORT NUM = %d\n", __FUNCTION__, pwdinfo->wfd_info->peer_rtsp_ctrlport );
2968 #endif // CONFIG_WFD
2973 u8 process_p2p_group_negotation_resp( struct wifidirect_info *pwdinfo, u8 *pframe, uint len )
2975 _adapter *padapter = pwdinfo->padapter;
2976 u8 result = P2P_STATUS_SUCCESS;
2977 u32 p2p_ielen, wps_ielen;
2982 u8 wfd_ie[ 128 ] = { 0x00 };
2985 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
2986 #endif // CONFIG_TDLS
2987 #endif // CONFIG_WFD
2989 ies = pframe + _PUBLIC_ACTION_IE_OFFSET_;
2990 ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
2992 // Be able to know which one is the P2P GO and which one is P2P client.
2994 if ( rtw_get_wps_ie( ies, ies_len, NULL, &wps_ielen) )
3000 DBG_871X( "[%s] WPS IE not Found!!\n", __FUNCTION__ );
3001 result = P2P_STATUS_FAIL_INCOMPATIBLE_PARAM;
3002 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
3005 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
3008 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
3009 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
3010 result = P2P_STATUS_FAIL_INCOMPATIBLE_PARAM;
3015 u8 attr_content = 0x00;
3016 u32 attr_contentlen = 0;
3017 u8 operatingch_info[5] = { 0x00 };
3019 u8 ch_content[100] = { 0x00 };
3022 u8 peer_ch_list[100] = { 0x00 };
3024 u8 ch_list_inclusioned[100] = { 0x00 };
3025 u8 ch_num_inclusioned = 0;
3027 while ( p2p_ie ) // Found the P2P IE.
3030 //Check P2P Capability ATTR
3031 if(rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CAPABILITY, (u8*)&cap_attr, (uint*)&attr_contentlen) )
3033 cap_attr = le16_to_cpu(cap_attr);
3035 if(!(cap_attr & P2P_GRPCAP_INTRABSS) )
3036 ptdlsinfo->ap_prohibited = _TRUE;
3037 #endif // CONFIG_TDLS
3040 rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, &attr_content, &attr_contentlen);
3041 if ( attr_contentlen == 1 )
3043 DBG_871X( "[%s] Status = %d\n", __FUNCTION__, attr_content );
3044 if ( attr_content == P2P_STATUS_SUCCESS )
3050 if ( P2P_STATUS_FAIL_INFO_UNAVAILABLE == attr_content ) {
3051 rtw_p2p_set_state(pwdinfo, P2P_STATE_RX_INFOR_NOREADY);
3053 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
3055 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
3056 result = attr_content;
3061 // Try to get the peer's interface address
3062 attr_contentlen = 0;
3063 if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_INTENTED_IF_ADDR, pwdinfo->p2p_peer_interface_addr, &attr_contentlen ) )
3065 if ( attr_contentlen != ETH_ALEN )
3067 _rtw_memset( pwdinfo->p2p_peer_interface_addr, 0x00, ETH_ALEN );
3071 // Try to get the peer's intent and tie breaker value.
3072 attr_content = 0x00;
3073 attr_contentlen = 0;
3074 if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GO_INTENT , &attr_content, &attr_contentlen) )
3076 DBG_871X( "[%s] GO Intent = %d, tie = %d\n", __FUNCTION__, attr_content >> 1, attr_content & 0x01 );
3077 pwdinfo->peer_intent = attr_content; // include both intent and tie breaker values.
3079 if ( pwdinfo->intent == ( pwdinfo->peer_intent >> 1 ) )
3081 // Try to match the tie breaker value
3082 if ( pwdinfo->intent == P2P_MAX_INTENT )
3084 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
3085 result = P2P_STATUS_FAIL_BOTH_GOINTENT_15;
3086 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
3090 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
3091 rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
3092 if ( attr_content & 0x01 )
3094 rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
3098 rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
3102 else if ( pwdinfo->intent > ( pwdinfo->peer_intent >> 1 ) )
3104 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
3105 rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
3106 rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
3110 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
3111 rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
3112 rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
3115 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
3117 // Store the group id information.
3118 _rtw_memcpy( pwdinfo->groupid_info.go_device_addr, pwdinfo->device_addr, ETH_ALEN );
3119 _rtw_memcpy( pwdinfo->groupid_info.ssid, pwdinfo->nego_ssid, pwdinfo->nego_ssidlen );
3124 // Try to get the operation channel information
3126 attr_contentlen = 0;
3127 if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, operatingch_info, &attr_contentlen))
3129 DBG_871X( "[%s] Peer's operating channel = %d\n", __FUNCTION__, operatingch_info[4] );
3130 pwdinfo->peer_operating_ch = operatingch_info[4];
3133 // Try to get the channel list information
3134 if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, pwdinfo->channel_list_attr, &pwdinfo->channel_list_attr_len ) )
3136 DBG_871X( "[%s] channel list attribute found, len = %d\n", __FUNCTION__, pwdinfo->channel_list_attr_len );
3138 peer_ch_num = rtw_p2p_get_peer_ch_list(pwdinfo, pwdinfo->channel_list_attr, pwdinfo->channel_list_attr_len, peer_ch_list);
3139 ch_num_inclusioned = rtw_p2p_ch_inclusion(&padapter->mlmeextpriv, peer_ch_list, peer_ch_num, ch_list_inclusioned);
3141 if( ch_num_inclusioned == 0)
3143 DBG_871X( "[%s] No common channel in channel list!\n", __FUNCTION__ );
3144 result = P2P_STATUS_FAIL_NO_COMMON_CH;
3145 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
3149 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO))
3151 if ( !rtw_p2p_is_channel_list_ok( pwdinfo->operating_channel,
3152 ch_list_inclusioned, ch_num_inclusioned) )
3154 #ifdef CONFIG_CONCURRENT_MODE
3155 if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
3157 DBG_871X( "[%s] desired channel NOT Found!\n", __FUNCTION__ );
3158 result = P2P_STATUS_FAIL_NO_COMMON_CH;
3159 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
3163 #endif //CONFIG_CONCURRENT_MODE
3165 u8 operatingch_info[5] = { 0x00 }, peer_operating_ch = 0;
3166 attr_contentlen = 0;
3168 if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, operatingch_info, &attr_contentlen) )
3170 peer_operating_ch = operatingch_info[4];
3173 if ( rtw_p2p_is_channel_list_ok( peer_operating_ch,
3174 ch_list_inclusioned, ch_num_inclusioned) )
3177 * Change our operating channel as peer's for compatibility.
3179 pwdinfo->operating_channel = peer_operating_ch;
3180 DBG_871X( "[%s] Change op ch to %02x as peer's\n", __FUNCTION__, pwdinfo->operating_channel);
3184 // Take first channel of ch_list_inclusioned as operating channel
3185 pwdinfo->operating_channel = ch_list_inclusioned[0];
3186 DBG_871X( "[%s] Change op ch to %02x\n", __FUNCTION__, pwdinfo->operating_channel);
3196 DBG_871X( "[%s] channel list attribute not found!\n", __FUNCTION__);
3199 // Try to get the group id information if peer is GO
3200 attr_contentlen = 0;
3201 _rtw_memset( groupid, 0x00, 38 );
3202 if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_GROUP_ID, groupid, &attr_contentlen) )
3204 _rtw_memcpy( pwdinfo->groupid_info.go_device_addr, &groupid[0], ETH_ALEN );
3205 _rtw_memcpy( pwdinfo->groupid_info.ssid, &groupid[6], attr_contentlen - ETH_ALEN );
3208 //Get the next P2P IE
3209 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
3215 // Added by Albert 20111122
3216 // Try to get the TCP port information when receiving the negotiation response.
3217 if ( rtw_get_wfd_ie( pframe + _PUBLIC_ACTION_IE_OFFSET_, len - _PUBLIC_ACTION_IE_OFFSET_, wfd_ie, &wfd_ielen ) )
3219 u8 attr_content[ 10 ] = { 0x00 };
3220 u32 attr_contentlen = 0;
3222 DBG_8192C( "[%s] WFD IE Found!!\n", __FUNCTION__ );
3223 rtw_get_wfd_attr_content( wfd_ie, wfd_ielen, WFD_ATTR_DEVICE_INFO, attr_content, &attr_contentlen);
3224 if ( attr_contentlen )
3226 pwdinfo->wfd_info->peer_rtsp_ctrlport = RTW_GET_BE16( attr_content + 2 );
3227 DBG_8192C( "[%s] Peer PORT NUM = %d\n", __FUNCTION__, pwdinfo->wfd_info->peer_rtsp_ctrlport );
3230 #endif // CONFIG_WFD
3236 u8 process_p2p_group_negotation_confirm( struct wifidirect_info *pwdinfo, u8 *pframe, uint len )
3242 u8 result = P2P_STATUS_SUCCESS;
3243 ies = pframe + _PUBLIC_ACTION_IE_OFFSET_;
3244 ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
3246 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
3247 while ( p2p_ie ) // Found the P2P IE.
3249 u8 attr_content = 0x00, operatingch_info[5] = { 0x00 };
3250 u8 groupid[ 38 ] = { 0x00 };
3251 u32 attr_contentlen = 0;
3253 pwdinfo->negotiation_dialog_token = 1;
3254 rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, &attr_content, &attr_contentlen);
3255 if ( attr_contentlen == 1 )
3257 DBG_871X( "[%s] Status = %d\n", __FUNCTION__, attr_content );
3258 result = attr_content;
3260 if ( attr_content == P2P_STATUS_SUCCESS )
3264 _cancel_timer( &pwdinfo->restore_p2p_state_timer, &bcancelled );
3266 // Commented by Albert 20100911
3267 // Todo: Need to handle the case which both Intents are the same.
3268 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
3269 rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
3270 if ( ( pwdinfo->intent ) > ( pwdinfo->peer_intent >> 1 ) )
3272 rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
3274 else if ( ( pwdinfo->intent ) < ( pwdinfo->peer_intent >> 1 ) )
3276 rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
3280 // Have to compare the Tie Breaker
3281 if ( pwdinfo->peer_intent & 0x01 )
3283 rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
3287 rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
3291 #ifdef CONFIG_CONCURRENT_MODE
3292 if ( check_buddy_fwstate(pwdinfo->padapter , _FW_LINKED ) )
3294 // Switch back to the AP channel soon.
3295 _set_timer( &pwdinfo->ap_p2p_switch_timer, 100 );
3301 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
3302 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_FAIL);
3307 // Try to get the group id information
3308 attr_contentlen = 0;
3309 _rtw_memset( groupid, 0x00, 38 );
3310 if ( rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_GROUP_ID, groupid, &attr_contentlen) )
3312 DBG_871X( "[%s] Ssid = %s, ssidlen = %zu\n", __FUNCTION__, &groupid[ETH_ALEN], strlen(&groupid[ETH_ALEN]) );
3313 _rtw_memcpy( pwdinfo->groupid_info.go_device_addr, &groupid[0], ETH_ALEN );
3314 _rtw_memcpy( pwdinfo->groupid_info.ssid, &groupid[6], attr_contentlen - ETH_ALEN );
3317 attr_contentlen = 0;
3318 if ( rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, operatingch_info, &attr_contentlen) )
3320 DBG_871X( "[%s] Peer's operating channel = %d\n", __FUNCTION__, operatingch_info[4] );
3321 pwdinfo->peer_operating_ch = operatingch_info[4];
3324 //Get the next P2P IE
3325 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
3332 u8 process_p2p_presence_req(struct wifidirect_info *pwdinfo, u8 *pframe, uint len)
3336 u8 status = P2P_STATUS_SUCCESS;
3338 frame_body = (unsigned char *)(pframe + sizeof(struct rtw_ieee80211_hdr_3addr));
3340 dialogToken = frame_body[6];
3342 //todo: check NoA attribute
3344 issue_p2p_presence_resp(pwdinfo, GetAddr2Ptr(pframe), status, dialogToken);
3349 void find_phase_handler( _adapter* padapter )
3351 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
3352 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3353 NDIS_802_11_SSID ssid;
3359 _rtw_memset((unsigned char*)&ssid, 0, sizeof(NDIS_802_11_SSID));
3360 _rtw_memcpy(ssid.Ssid, pwdinfo->p2p_wildcard_ssid, P2P_WILDCARD_SSID_LEN );
3361 ssid.SsidLength = P2P_WILDCARD_SSID_LEN;
3363 rtw_p2p_set_state(pwdinfo, P2P_STATE_FIND_PHASE_SEARCH);
3365 _enter_critical_bh(&pmlmepriv->lock, &irqL);
3366 _status = rtw_sitesurvey_cmd(padapter, &ssid, 1, NULL, 0);
3367 _exit_critical_bh(&pmlmepriv->lock, &irqL);
3373 void p2p_concurrent_handler( _adapter* padapter );
3375 void restore_p2p_state_handler( _adapter* padapter )
3377 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
3378 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3382 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING) || rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_FAIL))
3384 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
3387 #ifdef CONFIG_CONCURRENT_MODE
3388 if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
3390 _adapter *pbuddy_adapter = padapter->pbuddy_adapter;
3391 struct mlme_priv *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
3392 struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
3394 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ) || rtw_p2p_chk_state(pwdinfo, P2P_STATE_RX_PROVISION_DIS_RSP))
3396 set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
3398 issue_nulldata(pbuddy_adapter, NULL, 0, 3, 500);
3403 rtw_p2p_set_state(pwdinfo, rtw_p2p_pre_state(pwdinfo));
3405 if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DEVICE))
3407 #ifdef CONFIG_CONCURRENT_MODE
3408 p2p_concurrent_handler( padapter );
3410 // In the P2P client mode, the driver should not switch back to its listen channel
3411 // because this P2P client should stay at the operating channel of P2P GO.
3412 set_channel_bwmode( padapter, pwdinfo->listen_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3418 void pre_tx_invitereq_handler( _adapter* padapter )
3420 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
3424 set_channel_bwmode(padapter, pwdinfo->invitereq_info.peer_ch, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3425 padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3426 issue_probereq_p2p(padapter, NULL);
3427 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
3432 void pre_tx_provdisc_handler( _adapter* padapter )
3434 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
3438 set_channel_bwmode(padapter, pwdinfo->tx_prov_disc_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3439 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3440 issue_probereq_p2p(padapter, NULL);
3441 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
3446 void pre_tx_negoreq_handler( _adapter* padapter )
3448 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
3452 set_channel_bwmode(padapter, pwdinfo->nego_req_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3453 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3454 issue_probereq_p2p(padapter, NULL);
3455 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
3460 #ifdef CONFIG_CONCURRENT_MODE
3461 void p2p_concurrent_handler( _adapter* padapter )
3463 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
3464 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
3465 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3466 //_adapter *pbuddy_adapter = padapter->pbuddy_adapter;
3467 //struct wifidirect_info *pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
3468 //struct mlme_priv *pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
3469 //struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
3473 if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
3475 PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
3476 struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
3478 pwdinfo->operating_channel = pbuddy_mlmeext->cur_channel;
3480 if( pwdinfo->driver_interface == DRIVER_CFG80211 )
3482 DBG_871X("%s, switch ch back to buddy's cur_channel=%d\n", __func__, pbuddy_mlmeext->cur_channel);
3484 set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
3486 issue_nulldata(pbuddy_adapter, NULL, 0, 3, 500);
3488 else if( pwdinfo->driver_interface == DRIVER_WEXT )
3490 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_IDLE))
3492 // Now, the driver stays on the AP's channel.
3493 // If the pwdinfo->ext_listen_period = 0, that means the P2P listen state is not available on listen channel.
3494 if ( pwdinfo->ext_listen_period > 0 )
3496 DBG_8192C( "[%s] P2P_STATE_IDLE, ext_listen_period = %d\n", __FUNCTION__, pwdinfo->ext_listen_period );
3498 if ( pbuddy_mlmeext->cur_channel != pwdinfo->listen_channel )
3500 // Will switch to listen channel so that need to send the NULL data with PW bit to AP.
3501 issue_nulldata(pbuddy_adapter, NULL, 1, 3, 500);
3502 set_channel_bwmode(padapter, pwdinfo->listen_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3505 rtw_p2p_set_state(pwdinfo, P2P_STATE_LISTEN);
3506 if(!check_buddy_mlmeinfo_state(padapter, WIFI_FW_AP_STATE) &&
3507 !(pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
3510 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3512 // Todo: To check the value of pwdinfo->ext_listen_period is equal to 0 or not.
3513 _set_timer( &pwdinfo->ap_p2p_switch_timer, pwdinfo->ext_listen_period );
3516 else if ( rtw_p2p_chk_state(pwdinfo, P2P_STATE_LISTEN) ||
3517 rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_FAIL) ||
3518 ( rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING) && pwdinfo->nego_req_info.benable == _FALSE ) ||
3519 rtw_p2p_chk_state(pwdinfo, P2P_STATE_RX_PROVISION_DIS_REQ) )
3521 // Now, the driver is in the listen state of P2P mode.
3522 DBG_8192C( "[%s] P2P_STATE_IDLE, ext_listen_interval = %d\n", __FUNCTION__, pwdinfo->ext_listen_interval );
3524 // Commented by Albert 2012/11/01
3525 // If the AP's channel is the same as the listen channel, we should still be in the listen state
3526 // Other P2P device is still able to find this device out even this device is in the AP's channel.
3527 // So, configure this device to be able to receive the probe request frame and set it to listen state.
3528 if ( pbuddy_mlmeext->cur_channel != pwdinfo->listen_channel )
3530 set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
3531 if(!check_buddy_mlmeinfo_state(padapter, WIFI_FW_AP_STATE) &&!(pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
3534 padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3536 rtw_p2p_set_state(pwdinfo, P2P_STATE_IDLE);
3537 issue_nulldata(pbuddy_adapter, NULL, 0, 3, 500);
3540 // Todo: To check the value of pwdinfo->ext_listen_interval is equal to 0 or not.
3541 _set_timer( &pwdinfo->ap_p2p_switch_timer, pwdinfo->ext_listen_interval );
3543 else if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_OK))
3545 // The driver had finished the P2P handshake successfully.
3547 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3548 set_channel_bwmode(padapter, pbuddy_mlmeext->cur_channel, pbuddy_mlmeext->cur_ch_offset, pbuddy_mlmeext->cur_bwmode);
3549 issue_nulldata(pbuddy_adapter, NULL, 0, 3, 500);
3551 else if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ))
3554 set_channel_bwmode(padapter, pwdinfo->tx_prov_disc_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3555 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3556 issue_probereq_p2p(padapter, NULL);
3557 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
3559 else if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING) && pwdinfo->nego_req_info.benable == _TRUE)
3562 set_channel_bwmode(padapter, pwdinfo->nego_req_info.peer_channel_num[0], HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3563 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3564 issue_probereq_p2p(padapter, NULL);
3565 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
3567 else if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_INVITE_REQ ) && pwdinfo->invitereq_info.benable == _TRUE)
3571 set_channel_bwmode(padapter, , HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3572 rtw_hal_set_hwreg(padapter, HW_VAR_MLME_SITESURVEY, (u8 *)(&val8));
3573 issue_probereq_p2p(padapter, NULL);
3574 _set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
3581 set_channel_bwmode( padapter, pwdinfo->listen_channel, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
3588 #ifdef CONFIG_IOCTL_CFG80211
3589 static void ro_ch_handler(_adapter *padapter)
3591 struct cfg80211_wifidirect_info *pcfg80211_wdinfo = &padapter->cfg80211_wdinfo;
3592 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
3593 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3597 if (rtw_get_ch_setting_union(padapter, &ch, &bw, &offset) != 0) {
3599 DBG_871X(FUNC_ADPT_FMT" back to linked/linking union - ch:%u, bw:%u, offset:%u\n",
3600 FUNC_ADPT_ARG(padapter), ch, bw, offset);
3602 else if (adapter_wdev_data(padapter)->p2p_enabled && pwdinfo->listen_channel) {
3603 ch = pwdinfo->listen_channel;
3604 bw = CHANNEL_WIDTH_20;
3605 offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
3607 DBG_871X(FUNC_ADPT_FMT" back to listen ch - ch:%u, bw:%u, offset:%u\n",
3608 FUNC_ADPT_ARG(padapter), ch, bw, offset);
3611 ch = pcfg80211_wdinfo->restore_channel;
3612 bw = CHANNEL_WIDTH_20;
3613 offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
3615 DBG_871X(FUNC_ADPT_FMT" back to restore ch - ch:%u, bw:%u, offset:%u\n",
3616 FUNC_ADPT_ARG(padapter), ch, bw, offset);
3619 set_channel_bwmode(padapter, ch, offset, bw);
3621 rtw_p2p_set_state(pwdinfo, rtw_p2p_pre_state(pwdinfo));
3622 #ifdef CONFIG_DEBUG_CFG80211
3623 DBG_871X("%s, role=%d, p2p_state=%d\n", __func__, rtw_p2p_role(pwdinfo), rtw_p2p_state(pwdinfo));
3626 pcfg80211_wdinfo->is_ro_ch = _FALSE;
3627 pcfg80211_wdinfo->last_ro_ch_time = rtw_get_current_time();
3629 DBG_871X("cfg80211_remain_on_channel_expired cookie:0x%llx, ch=%d, bw=%d, offset=%d\n",
3630 pcfg80211_wdinfo->remain_on_ch_cookie,
3631 rtw_get_oper_ch(padapter), rtw_get_oper_bw(padapter), rtw_get_oper_choffset(padapter));
3633 rtw_cfg80211_remain_on_channel_expired(padapter,
3634 pcfg80211_wdinfo->remain_on_ch_cookie,
3635 &pcfg80211_wdinfo->remain_on_ch_channel,
3636 pcfg80211_wdinfo->remain_on_ch_type, GFP_KERNEL);
3641 static void ro_ch_timer_process (void *FunctionContext)
3643 _adapter *adapter = (_adapter *)FunctionContext;
3644 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(adapter);
3646 //printk("%s \n", __FUNCTION__);
3648 #ifdef CONFIG_CONCURRENT_MODE
3649 ATOMIC_SET(&pwdev_priv->ro_ch_to, 1);
3652 p2p_protocol_wk_cmd( adapter, P2P_RO_CH_WK);
3655 static void rtw_change_p2pie_op_ch(_adapter *padapter, const u8 *frame_body, u32 len, u8 ch)
3658 u32 ies_len, p2p_ielen;
3659 PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
3660 struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
3662 ies = (u8*)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
3663 ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
3665 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
3668 u32 attr_contentlen = 0;
3671 //Check P2P_ATTR_OPERATING_CH
3672 attr_contentlen = 0;
3674 if((pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, (uint*)&attr_contentlen))!=NULL)
3679 //Get the next P2P IE
3680 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
3684 static void rtw_change_p2pie_ch_list(_adapter *padapter, const u8 *frame_body, u32 len, u8 ch)
3687 u32 ies_len, p2p_ielen;
3688 PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
3689 struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
3691 ies = (u8*)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
3692 ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
3694 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
3697 u32 attr_contentlen = 0;
3700 //Check P2P_ATTR_CH_LIST
3701 if ((pattr=rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, (uint*)&attr_contentlen))!=NULL) {
3704 u8 *pattr_temp = pattr + 3 ;
3706 attr_contentlen -= 3;
3708 while (attr_contentlen>0) {
3709 num_of_ch = *(pattr_temp+1);
3711 for(i=0; i<num_of_ch; i++)
3712 *(pattr_temp+2+i) = ch;
3714 pattr_temp += (2+num_of_ch);
3715 attr_contentlen -= (2+num_of_ch);
3719 //Get the next P2P IE
3720 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
3724 static bool rtw_chk_p2pie_ch_list_with_buddy(_adapter *padapter, const u8 *frame_body, u32 len)
3727 #ifdef CONFIG_CONCURRENT_MODE
3729 u32 ies_len, p2p_ielen;
3730 PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
3731 struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
3732 u8 buddy_ch = pbuddy_mlmeext->cur_channel;
3734 ies = (u8*)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
3735 ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
3737 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
3740 u32 attr_contentlen = 0;
3743 //Check P2P_ATTR_CH_LIST
3744 if ((pattr=rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, (uint*)&attr_contentlen))!=NULL) {
3747 u8 *pattr_temp = pattr + 3 ;
3749 attr_contentlen -= 3;
3751 while (attr_contentlen>0) {
3752 num_of_ch = *(pattr_temp+1);
3754 for(i=0; i<num_of_ch; i++) {
3755 if (*(pattr_temp+2+i) == buddy_ch) {
3756 DBG_871X(FUNC_ADPT_FMT" ch_list fit buddy_ch:%u\n", FUNC_ADPT_ARG(padapter), buddy_ch);
3762 pattr_temp += (2+num_of_ch);
3763 attr_contentlen -= (2+num_of_ch);
3767 //Get the next P2P IE
3768 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
3774 static bool rtw_chk_p2pie_op_ch_with_buddy(_adapter *padapter, const u8 *frame_body, u32 len)
3777 #ifdef CONFIG_CONCURRENT_MODE
3779 u32 ies_len, p2p_ielen;
3780 PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
3781 struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
3782 u8 buddy_ch = pbuddy_mlmeext->cur_channel;
3784 ies = (u8*)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
3785 ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
3787 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
3790 u32 attr_contentlen = 0;
3793 //Check P2P_ATTR_OPERATING_CH
3794 attr_contentlen = 0;
3796 if((pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, (uint*)&attr_contentlen))!=NULL) {
3797 if (*(pattr+4) == buddy_ch) {
3798 DBG_871X(FUNC_ADPT_FMT" op_ch fit buddy_ch:%u\n", FUNC_ADPT_ARG(padapter), buddy_ch);
3804 //Get the next P2P IE
3805 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
3811 static void rtw_cfg80211_adjust_p2pie_channel(_adapter *padapter, const u8 *frame_body, u32 len)
3813 #ifdef CONFIG_CONCURRENT_MODE
3815 u32 ies_len, p2p_ielen;
3816 PADAPTER pbuddy_adapter = padapter->pbuddy_adapter;
3817 struct mlme_ext_priv *pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
3819 ies = (u8*)(frame_body + _PUBLIC_ACTION_IE_OFFSET_);
3820 ies_len = len - _PUBLIC_ACTION_IE_OFFSET_;
3822 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen );
3826 u32 attr_contentlen = 0;
3829 //Check P2P_ATTR_CH_LIST
3830 if((pattr=rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, (uint*)&attr_contentlen))!=NULL)
3834 u8 *pattr_temp = pattr + 3 ;
3836 attr_contentlen -= 3;
3838 while(attr_contentlen>0)
3840 num_of_ch = *(pattr_temp+1);
3842 for(i=0; i<num_of_ch; i++)
3843 *(pattr_temp+2+i) = pbuddy_mlmeext->cur_channel;//forcing to the same channel
3845 pattr_temp += (2+num_of_ch);
3846 attr_contentlen -= (2+num_of_ch);
3850 //Check P2P_ATTR_OPERATING_CH
3851 attr_contentlen = 0;
3853 if((pattr = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, (uint*)&attr_contentlen))!=NULL)
3855 *(pattr+4) = pbuddy_mlmeext->cur_channel;//forcing to the same channel
3858 //Get the next P2P IE
3859 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
3867 void rtw_append_wfd_ie(_adapter *padapter, u8 *buf, u32* len)
3869 unsigned char *frame_body;
3870 u8 category, action, OUI_Subtype, dialogToken=0;
3872 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
3874 frame_body = (unsigned char *)(buf + sizeof(struct rtw_ieee80211_hdr_3addr));
3875 category = frame_body[0];
3877 if(category == RTW_WLAN_CATEGORY_PUBLIC)
3879 action = frame_body[1];
3880 if (action == ACT_PUBLIC_VENDOR
3881 && _rtw_memcmp(frame_body+2, P2P_OUI, 4) == _TRUE
3884 OUI_Subtype = frame_body[6];
3885 dialogToken = frame_body[7];
3886 switch( OUI_Subtype )//OUI Subtype
3888 case P2P_GO_NEGO_REQ:
3890 wfdielen = build_nego_req_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
3894 case P2P_GO_NEGO_RESP:
3896 wfdielen = build_nego_resp_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
3900 case P2P_GO_NEGO_CONF:
3902 wfdielen = build_nego_confirm_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
3908 wfdielen = build_invitation_req_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
3912 case P2P_INVIT_RESP:
3914 wfdielen = build_invitation_resp_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
3918 case P2P_DEVDISC_REQ:
3920 case P2P_DEVDISC_RESP:
3923 case P2P_PROVISION_DISC_REQ:
3925 wfdielen = build_provdisc_req_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
3929 case P2P_PROVISION_DISC_RESP:
3931 wfdielen = build_provdisc_resp_wfd_ie( &padapter->wdinfo, buf + ( *len ) );
3943 else if(category == RTW_WLAN_CATEGORY_P2P)
3945 OUI_Subtype = frame_body[5];
3946 dialogToken = frame_body[6];
3948 #ifdef CONFIG_DEBUG_CFG80211
3949 DBG_871X("ACTION_CATEGORY_P2P: OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n",
3950 cpu_to_be32( *( ( u32* ) ( frame_body + 1 ) ) ), OUI_Subtype, dialogToken);
3955 case P2P_NOTICE_OF_ABSENCE:
3958 case P2P_PRESENCE_REQUEST:
3961 case P2P_PRESENCE_RESPONSE:
3964 case P2P_GO_DISC_REQUEST:
3975 DBG_871X("%s, action frame category=%d\n", __func__, category);
3976 //is_p2p_frame = (-1);
3983 u8 *dump_p2p_attr_ch_list(u8 *p2p_ie, uint p2p_ielen, u8 *buf, u32 buf_len)
3985 uint attr_contentlen = 0;
3990 bool continuous = _FALSE;
3992 if ((pattr=rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_CH_LIST, NULL, &attr_contentlen))!=NULL) {
3995 u8 *pattr_temp = pattr + 3 ;
3997 attr_contentlen -= 3;
3999 _rtw_memset(ch_list, 0, 40);
4001 while (attr_contentlen>0) {
4002 num_of_ch = *(pattr_temp+1);
4004 for(i=0; i<num_of_ch; i++) {
4005 for (j=0;j<ch_cnt;j++) {
4006 if (ch_list[j] == *(pattr_temp+2+i))
4010 ch_list[ch_cnt++] = *(pattr_temp+2+i);
4014 pattr_temp += (2+num_of_ch);
4015 attr_contentlen -= (2+num_of_ch);
4018 for (j=0;j<ch_cnt;j++) {
4020 w_sz += snprintf(buf+w_sz, buf_len-w_sz, "%u", ch_list[j]);
4021 } else if (ch_list[j] - ch_list[j-1] != 1) {
4022 w_sz += snprintf(buf+w_sz, buf_len-w_sz, ", %u", ch_list[j]);
4023 } else if (j != ch_cnt-1 && ch_list[j+1] - ch_list[j] == 1) {
4026 w_sz += snprintf(buf+w_sz, buf_len-w_sz, "-%u", ch_list[j]);
4034 * return _TRUE if requester is GO, _FALSE if responder is GO
4036 bool rtw_p2p_nego_intent_compare(u8 req, u8 resp)
4038 if (req>>1 == resp >>1)
4039 return req&0x01 ? _TRUE : _FALSE;
4040 else if (req>>1 > resp>>1)
4046 int rtw_p2p_check_frames(_adapter *padapter, const u8 *buf, u32 len, u8 tx)
4048 int is_p2p_frame = (-1);
4049 unsigned char *frame_body;
4050 u8 category, action, OUI_Subtype, dialogToken=0;
4053 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
4055 u8 ch_list_buf[128] = {'\0'};
4060 frame_body = (unsigned char *)(buf + sizeof(struct rtw_ieee80211_hdr_3addr));
4061 category = frame_body[0];
4063 if(category == RTW_WLAN_CATEGORY_PUBLIC)
4065 action = frame_body[1];
4066 if (action == ACT_PUBLIC_VENDOR
4067 && _rtw_memcmp(frame_body+2, P2P_OUI, 4) == _TRUE
4070 OUI_Subtype = frame_body[6];
4071 dialogToken = frame_body[7];
4072 is_p2p_frame = OUI_Subtype;
4073 #ifdef CONFIG_DEBUG_CFG80211
4074 DBG_871X("ACTION_CATEGORY_PUBLIC: ACT_PUBLIC_VENDOR, OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n",
4075 cpu_to_be32( *( ( u32* ) ( frame_body + 2 ) ) ), OUI_Subtype, dialogToken);
4078 p2p_ie = rtw_get_p2p_ie(
4079 (u8 *)buf+sizeof(struct rtw_ieee80211_hdr_3addr)+_PUBLIC_ACTION_IE_OFFSET_,
4080 len-sizeof(struct rtw_ieee80211_hdr_3addr)-_PUBLIC_ACTION_IE_OFFSET_,
4083 switch( OUI_Subtype )//OUI Subtype
4087 case P2P_GO_NEGO_REQ:
4089 struct rtw_wdev_nego_info* nego_info = &pwdev_priv->nego_info;
4092 #ifdef CONFIG_DRV_ISSUE_PROV_REQ // IOT FOR S2
4093 if(pwdev_priv->provdisc_req_issued == _FALSE)
4094 rtw_cfg80211_issue_p2p_provision_request(padapter, buf, len);
4095 #endif //CONFIG_DRV_ISSUE_PROV_REQ
4097 //pwdev_priv->provdisc_req_issued = _FALSE;
4099 #if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
4100 if(check_buddy_fwstate(padapter, _FW_LINKED))
4101 rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
4105 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len)))
4107 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_LISTEN_CH, NULL, &cont_len)))
4108 listen_ch = *(cont+4);
4109 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GO_INTENT, NULL, &cont_len)))
4112 if (nego_info->token != dialogToken)
4113 rtw_wdev_nego_info_init(nego_info);
4115 _rtw_memcpy(nego_info->peer_mac, tx ? GetAddr1Ptr(buf) : GetAddr2Ptr(buf), ETH_ALEN);
4116 nego_info->active = tx ? 1 : 0;
4117 nego_info->token = dialogToken;
4118 nego_info->req_op_ch = op_ch;
4119 nego_info->req_listen_ch = listen_ch;
4120 nego_info->req_intent = intent;
4121 nego_info->state = 0;
4123 dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
4124 DBG_871X("RTW_%s:P2P_GO_NEGO_REQ, dialogToken=%d, intent:%u%s, listen_ch:%d, op_ch:%d, ch_list:%s\n",
4125 (tx==_TRUE)?"Tx":"Rx", dialogToken, (intent>>1), intent&0x1 ? "+" : "-", listen_ch, op_ch, ch_list_buf);
4128 #if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
4129 if(check_buddy_fwstate(padapter, _FW_LINKED)
4130 && rtw_chk_p2pie_ch_list_with_buddy(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr)) == _FALSE)
4132 DBG_871X(FUNC_ADPT_FMT" ch_list has no intersect with buddy\n", FUNC_ADPT_ARG(padapter));
4133 rtw_change_p2pie_ch_list(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr), 0);
4140 case P2P_GO_NEGO_RESP:
4142 struct rtw_wdev_nego_info* nego_info = &pwdev_priv->nego_info;
4145 #if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
4146 if(check_buddy_fwstate(padapter, _FW_LINKED))
4147 rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
4151 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len)))
4153 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_GO_INTENT, NULL, &cont_len)))
4155 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len)))
4158 if (nego_info->token == dialogToken && nego_info->state == 0
4159 && _rtw_memcmp(nego_info->peer_mac, tx ? GetAddr1Ptr(buf) : GetAddr2Ptr(buf), ETH_ALEN) == _TRUE
4161 nego_info->status = (status==-1) ? 0xff : status;
4162 nego_info->rsp_op_ch= op_ch;
4163 nego_info->rsp_intent = intent;
4164 nego_info->state = 1;
4166 nego_info->token = 0; /* init */
4169 dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
4170 DBG_871X("RTW_%s:P2P_GO_NEGO_RESP, dialogToken=%d, intent:%u%s, status:%d, op_ch:%d, ch_list:%s\n",
4171 (tx==_TRUE)?"Tx":"Rx", dialogToken, (intent>>1), intent&0x1 ? "+" : "-", status, op_ch, ch_list_buf);
4174 pwdev_priv->provdisc_req_issued = _FALSE;
4175 #if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
4176 if(check_buddy_fwstate(padapter, _FW_LINKED)
4177 && rtw_chk_p2pie_ch_list_with_buddy(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr)) == _FALSE)
4179 DBG_871X(FUNC_ADPT_FMT" ch_list has no intersect with buddy\n", FUNC_ADPT_ARG(padapter));
4180 rtw_change_p2pie_ch_list(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr), 0);
4187 case P2P_GO_NEGO_CONF:
4189 struct rtw_wdev_nego_info* nego_info = &pwdev_priv->nego_info;
4190 bool is_go = _FALSE;
4193 #if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
4194 if(check_buddy_fwstate(padapter, _FW_LINKED))
4195 rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
4199 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len)))
4201 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len)))
4204 if (nego_info->token == dialogToken && nego_info->state == 1
4205 && _rtw_memcmp(nego_info->peer_mac, tx ? GetAddr1Ptr(buf) : GetAddr2Ptr(buf), ETH_ALEN) == _TRUE
4207 nego_info->status = (status==-1) ? 0xff : status;
4208 nego_info->conf_op_ch = (op_ch==-1) ? 0 : op_ch;
4209 nego_info->state = 2;
4212 if (rtw_p2p_nego_intent_compare(nego_info->req_intent, nego_info->rsp_intent) ^ !tx)
4216 nego_info->token = 0; /* init */
4219 dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
4220 DBG_871X("RTW_%s:P2P_GO_NEGO_CONF, dialogToken=%d, status:%d, op_ch:%d, ch_list:%s\n",
4221 (tx==_TRUE)?"Tx":"Rx", dialogToken, status, op_ch, ch_list_buf);
4230 struct rtw_wdev_invit_info* invit_info = &pwdev_priv->invit_info;
4234 #if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
4235 if(check_buddy_fwstate(padapter, _FW_LINKED))
4236 rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
4240 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_INVITATION_FLAGS, NULL, &cont_len)))
4242 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len)))
4245 if (invit_info->token != dialogToken)
4246 rtw_wdev_invit_info_init(invit_info);
4248 _rtw_memcpy(invit_info->peer_mac, tx ? GetAddr1Ptr(buf) : GetAddr2Ptr(buf), ETH_ALEN);
4249 invit_info->active = tx ? 1 : 0;
4250 invit_info->token = dialogToken;
4251 invit_info->flags = (flags==-1) ? 0x0 : flags;
4252 invit_info->req_op_ch= op_ch;
4253 invit_info->state = 0;
4255 dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
4256 DBG_871X("RTW_%s:P2P_INVIT_REQ, dialogToken=%d, flags:0x%02x, op_ch:%d, ch_list:%s\n",
4257 (tx==_TRUE)?"Tx":"Rx", dialogToken, flags, op_ch, ch_list_buf);
4260 #if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
4261 if(check_buddy_fwstate(padapter, _FW_LINKED)) {
4262 if (op_ch != -1 && rtw_chk_p2pie_op_ch_with_buddy(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr)) == _FALSE) {
4263 DBG_871X(FUNC_ADPT_FMT" op_ch:%u has no intersect with buddy\n", FUNC_ADPT_ARG(padapter), op_ch);
4264 rtw_change_p2pie_ch_list(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr), 0);
4265 } else if (rtw_chk_p2pie_ch_list_with_buddy(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr)) == _FALSE) {
4266 DBG_871X(FUNC_ADPT_FMT" ch_list has no intersect with buddy\n", FUNC_ADPT_ARG(padapter));
4267 rtw_change_p2pie_ch_list(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr), 0);
4275 case P2P_INVIT_RESP:
4277 struct rtw_wdev_invit_info* invit_info = &pwdev_priv->invit_info;
4280 #if defined(CONFIG_CONCURRENT_MODE) && defined(CONFIG_CFG80211_ONECHANNEL_UNDER_CONCURRENT)
4281 if(check_buddy_fwstate(padapter, _FW_LINKED))
4282 rtw_cfg80211_adjust_p2pie_channel(padapter, frame_body, len-sizeof(struct rtw_ieee80211_hdr_3addr));
4286 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len)))
4288 #ifdef CONFIG_P2P_INVITE_IOT
4291 DBG_871X("TX_P2P_INVITE_RESP, status is no common channel, change to unknown group\n");
4292 *cont = 8; //unknow group status
4294 #endif //CONFIG_P2P_INVITE_IOT
4297 if ((cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_OPERATING_CH, NULL, &cont_len)))
4300 if (invit_info->token == dialogToken && invit_info->state == 0
4301 && _rtw_memcmp(invit_info->peer_mac, tx ? GetAddr1Ptr(buf) : GetAddr2Ptr(buf), ETH_ALEN) == _TRUE
4303 invit_info->status = (status==-1) ? 0xff : status;
4304 invit_info->rsp_op_ch= op_ch;
4305 invit_info->state = 1;
4306 invit_info->token = 0; /* init */
4309 dump_p2p_attr_ch_list(p2p_ie, p2p_ielen, ch_list_buf, 128);
4310 DBG_871X("RTW_%s:P2P_INVIT_RESP, dialogToken=%d, status:%d, op_ch:%d, ch_list:%s\n",
4311 (tx==_TRUE)?"Tx":"Rx", dialogToken, status, op_ch, ch_list_buf);
4318 case P2P_DEVDISC_REQ:
4319 DBG_871X("RTW_%s:P2P_DEVDISC_REQ, dialogToken=%d\n", (tx==_TRUE)?"Tx":"Rx", dialogToken);
4321 case P2P_DEVDISC_RESP:
4322 cont = rtw_get_p2p_attr_content(p2p_ie, p2p_ielen, P2P_ATTR_STATUS, NULL, &cont_len);
4323 DBG_871X("RTW_%s:P2P_DEVDISC_RESP, dialogToken=%d, status:%d\n", (tx==_TRUE)?"Tx":"Rx", dialogToken, cont?*cont:-1);
4325 case P2P_PROVISION_DISC_REQ:
4327 size_t frame_body_len = len - sizeof(struct rtw_ieee80211_hdr_3addr);
4330 uint contentlen = 0;
4332 DBG_871X("RTW_%s:P2P_PROVISION_DISC_REQ, dialogToken=%d\n", (tx==_TRUE)?"Tx":"Rx", dialogToken);
4336 pwdev_priv->provdisc_req_issued = _FALSE;
4338 if( (p2p_ie=rtw_get_p2p_ie( frame_body + _PUBLIC_ACTION_IE_OFFSET_, frame_body_len - _PUBLIC_ACTION_IE_OFFSET_, NULL, &p2p_ielen)))
4341 if(rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_GROUP_ID, NULL, &contentlen))
4343 pwdev_priv->provdisc_req_issued = _FALSE;//case: p2p_client join p2p GO
4347 #ifdef CONFIG_DEBUG_CFG80211
4348 DBG_871X("provdisc_req_issued is _TRUE\n");
4349 #endif //CONFIG_DEBUG_CFG80211
4350 pwdev_priv->provdisc_req_issued = _TRUE;//case: p2p_devices connection before Nego req.
4357 case P2P_PROVISION_DISC_RESP:
4358 DBG_871X("RTW_%s:P2P_PROVISION_DISC_RESP, dialogToken=%d\n", (tx==_TRUE)?"Tx":"Rx", dialogToken);
4361 DBG_871X("RTW_%s:OUI_Subtype=%d, dialogToken=%d\n", (tx==_TRUE)?"Tx":"Rx", OUI_Subtype, dialogToken);
4368 else if(category == RTW_WLAN_CATEGORY_P2P)
4370 OUI_Subtype = frame_body[5];
4371 dialogToken = frame_body[6];
4373 #ifdef CONFIG_DEBUG_CFG80211
4374 DBG_871X("ACTION_CATEGORY_P2P: OUI=0x%x, OUI_Subtype=%d, dialogToken=%d\n",
4375 cpu_to_be32( *( ( u32* ) ( frame_body + 1 ) ) ), OUI_Subtype, dialogToken);
4378 is_p2p_frame = OUI_Subtype;
4382 case P2P_NOTICE_OF_ABSENCE:
4383 DBG_871X("RTW_%s:P2P_NOTICE_OF_ABSENCE, dialogToken=%d\n", (tx==_TRUE)?"TX":"RX", dialogToken);
4385 case P2P_PRESENCE_REQUEST:
4386 DBG_871X("RTW_%s:P2P_PRESENCE_REQUEST, dialogToken=%d\n", (tx==_TRUE)?"TX":"RX", dialogToken);
4388 case P2P_PRESENCE_RESPONSE:
4389 DBG_871X("RTW_%s:P2P_PRESENCE_RESPONSE, dialogToken=%d\n", (tx==_TRUE)?"TX":"RX", dialogToken);
4391 case P2P_GO_DISC_REQUEST:
4392 DBG_871X("RTW_%s:P2P_GO_DISC_REQUEST, dialogToken=%d\n", (tx==_TRUE)?"TX":"RX", dialogToken);
4395 DBG_871X("RTW_%s:OUI_Subtype=%d, dialogToken=%d\n", (tx==_TRUE)?"TX":"RX", OUI_Subtype, dialogToken);
4402 DBG_871X("RTW_%s:action frame category=%d\n", (tx==_TRUE)?"TX":"RX", category);
4405 return is_p2p_frame;
4408 void rtw_init_cfg80211_wifidirect_info( _adapter* padapter)
4410 struct cfg80211_wifidirect_info *pcfg80211_wdinfo = &padapter->cfg80211_wdinfo;
4412 _rtw_memset(pcfg80211_wdinfo, 0x00, sizeof(struct cfg80211_wifidirect_info) );
4414 _init_timer( &pcfg80211_wdinfo->remain_on_ch_timer, padapter->pnetdev, ro_ch_timer_process, padapter );
4416 #endif //CONFIG_IOCTL_CFG80211
4418 void p2p_protocol_wk_hdl(_adapter *padapter, int intCmdType)
4420 struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4426 case P2P_FIND_PHASE_WK:
4428 find_phase_handler( padapter );
4431 case P2P_RESTORE_STATE_WK:
4433 restore_p2p_state_handler( padapter );
4436 case P2P_PRE_TX_PROVDISC_PROCESS_WK:
4438 #ifdef CONFIG_CONCURRENT_MODE
4439 if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
4441 p2p_concurrent_handler( padapter );
4445 pre_tx_provdisc_handler( padapter );
4448 pre_tx_provdisc_handler( padapter );
4452 case P2P_PRE_TX_INVITEREQ_PROCESS_WK:
4454 #ifdef CONFIG_CONCURRENT_MODE
4455 if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
4457 p2p_concurrent_handler( padapter );
4461 pre_tx_invitereq_handler( padapter );
4464 pre_tx_invitereq_handler( padapter );
4468 case P2P_PRE_TX_NEGOREQ_PROCESS_WK:
4470 #ifdef CONFIG_CONCURRENT_MODE
4471 if ( check_buddy_fwstate(padapter, _FW_LINKED ) )
4473 p2p_concurrent_handler( padapter );
4477 pre_tx_negoreq_handler( padapter );
4480 pre_tx_negoreq_handler( padapter );
4485 #ifdef CONFIG_CONCURRENT_MODE
4486 case P2P_AP_P2P_CH_SWITCH_PROCESS_WK:
4488 p2p_concurrent_handler( padapter );
4493 #ifdef CONFIG_IOCTL_CFG80211
4496 ro_ch_handler( padapter );
4499 #endif //CONFIG_IOCTL_CFG80211
4506 #ifdef CONFIG_P2P_PS
4507 void process_p2p_ps_ie(PADAPTER padapter, u8 *IEs, u32 IELength)
4513 u8 noa_attr[MAX_P2P_IE_LEN] = { 0x00 };// NoA length should be n*(13) + 2
4514 u32 attr_contentlen = 0;
4516 struct wifidirect_info *pwdinfo = &( padapter->wdinfo );
4517 u8 find_p2p = _FALSE, find_p2p_ps = _FALSE;
4518 u8 noa_offset, noa_num, noa_index;
4522 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
4526 #ifdef CONFIG_CONCURRENT_MODE
4527 if(padapter->iface_type != IFACE_PORT0)
4530 if(IELength <= _BEACON_IE_OFFSET_)
4533 ies = IEs + _BEACON_IE_OFFSET_;
4534 ies_len = IELength - _BEACON_IE_OFFSET_;
4536 p2p_ie = rtw_get_p2p_ie( ies, ies_len, NULL, &p2p_ielen);
4541 // Get Notice of Absence IE.
4542 if(rtw_get_p2p_attr_content( p2p_ie, p2p_ielen, P2P_ATTR_NOA, noa_attr, &attr_contentlen))
4544 find_p2p_ps = _TRUE;
4545 noa_index = noa_attr[0];
4547 if( (pwdinfo->p2p_ps_mode == P2P_PS_NONE) ||
4548 (noa_index != pwdinfo->noa_index) )// if index change, driver should reconfigure related setting.
4550 pwdinfo->noa_index = noa_index;
4551 pwdinfo->opp_ps = noa_attr[1] >> 7;
4552 pwdinfo->ctwindow = noa_attr[1] & 0x7F;
4556 // NoA length should be n*(13) + 2
4557 if(attr_contentlen > 2)
4559 while(noa_offset < attr_contentlen)
4561 //_rtw_memcpy(&wifidirect_info->noa_count[noa_num], &noa_attr[noa_offset], 1);
4562 pwdinfo->noa_count[noa_num] = noa_attr[noa_offset];
4565 _rtw_memcpy(&pwdinfo->noa_duration[noa_num], &noa_attr[noa_offset], 4);
4568 _rtw_memcpy(&pwdinfo->noa_interval[noa_num], &noa_attr[noa_offset], 4);
4571 _rtw_memcpy(&pwdinfo->noa_start_time[noa_num], &noa_attr[noa_offset], 4);
4577 pwdinfo->noa_num = noa_num;
4579 if( pwdinfo->opp_ps == 1 )
4581 pwdinfo->p2p_ps_mode = P2P_PS_CTWINDOW;
4582 // driver should wait LPS for entering CTWindow
4583 if(adapter_to_pwrctl(padapter)->bFwCurrentInPSMode == _TRUE)
4585 p2p_ps_wk_cmd(padapter, P2P_PS_ENABLE, 1);
4588 else if( pwdinfo->noa_num > 0 )
4590 pwdinfo->p2p_ps_mode = P2P_PS_NOA;
4591 p2p_ps_wk_cmd(padapter, P2P_PS_ENABLE, 1);
4593 else if( pwdinfo->p2p_ps_mode > P2P_PS_NONE)
4595 p2p_ps_wk_cmd(padapter, P2P_PS_DISABLE, 1);
4599 break; // find target, just break.
4602 //Get the next P2P IE
4603 p2p_ie = rtw_get_p2p_ie(p2p_ie+p2p_ielen, ies_len -(p2p_ie -ies + p2p_ielen), NULL, &p2p_ielen);
4607 if(find_p2p == _TRUE)
4609 if( (pwdinfo->p2p_ps_mode > P2P_PS_NONE) && (find_p2p_ps == _FALSE) )
4611 p2p_ps_wk_cmd(padapter, P2P_PS_DISABLE, 1);
4618 void p2p_ps_wk_hdl(_adapter *padapter, u8 p2p_ps_state)
4620 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4621 struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4625 // Pre action for p2p state
4626 switch(p2p_ps_state)
4628 case P2P_PS_DISABLE:
4629 pwdinfo->p2p_ps_state = p2p_ps_state;
4631 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
4633 pwdinfo->noa_index = 0;
4634 pwdinfo->ctwindow = 0;
4635 pwdinfo->opp_ps = 0;
4636 pwdinfo->noa_num = 0;
4637 pwdinfo->p2p_ps_mode = P2P_PS_NONE;
4638 if(pwrpriv->bFwCurrentInPSMode == _TRUE)
4640 if(pwrpriv->smart_ps == 0)
4642 pwrpriv->smart_ps = 2;
4643 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&(pwrpriv->pwr_mode)));
4648 if (pwdinfo->p2p_ps_mode > P2P_PS_NONE) {
4649 pwdinfo->p2p_ps_state = p2p_ps_state;
4651 if( pwdinfo->ctwindow > 0 )
4653 if(pwrpriv->smart_ps != 0)
4655 pwrpriv->smart_ps = 0;
4656 DBG_871X("%s(): Enter CTW, change SmartPS\n", __FUNCTION__);
4657 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&(pwrpriv->pwr_mode)));
4660 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
4664 case P2P_PS_SCAN_DONE:
4665 case P2P_PS_ALLSTASLEEP:
4666 if (pwdinfo->p2p_ps_mode > P2P_PS_NONE) {
4667 pwdinfo->p2p_ps_state = p2p_ps_state;
4668 rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, (u8 *)(&p2p_ps_state));
4678 u8 p2p_ps_wk_cmd(_adapter*padapter, u8 p2p_ps_state, u8 enqueue)
4680 struct cmd_obj *ph2c;
4681 struct drvextra_cmd_parm *pdrvextra_cmd_parm;
4682 struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
4683 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
4688 if ( rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)
4689 #ifdef CONFIG_CONCURRENT_MODE
4690 || (padapter->iface_type != IFACE_PORT0)
4699 ph2c = (struct cmd_obj*)rtw_zmalloc(sizeof(struct cmd_obj));
4705 pdrvextra_cmd_parm = (struct drvextra_cmd_parm*)rtw_zmalloc(sizeof(struct drvextra_cmd_parm));
4706 if(pdrvextra_cmd_parm==NULL){
4707 rtw_mfree((unsigned char *)ph2c, sizeof(struct cmd_obj));
4712 pdrvextra_cmd_parm->ec_id = P2P_PS_WK_CID;
4713 pdrvextra_cmd_parm->type = p2p_ps_state;
4714 pdrvextra_cmd_parm->size = 0;
4715 pdrvextra_cmd_parm->pbuf = NULL;
4717 init_h2fwcmd_w_parm_no_rsp(ph2c, pdrvextra_cmd_parm, GEN_CMD_CODE(_Set_Drv_Extra));
4719 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
4723 p2p_ps_wk_hdl(padapter, p2p_ps_state);
4733 #endif // CONFIG_P2P_PS
4735 static void reset_ch_sitesurvey_timer_process (void *FunctionContext)
4737 _adapter *adapter = (_adapter *)FunctionContext;
4738 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
4740 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
4743 DBG_871X( "[%s] In\n", __FUNCTION__ );
4744 // Reset the operation channel information
4745 pwdinfo->rx_invitereq_info.operation_ch[0] = 0;
4746 #ifdef CONFIG_P2P_OP_CHK_SOCIAL_CH
4747 pwdinfo->rx_invitereq_info.operation_ch[1] = 0;
4748 pwdinfo->rx_invitereq_info.operation_ch[2] = 0;
4749 pwdinfo->rx_invitereq_info.operation_ch[3] = 0;
4750 #endif //CONFIG_P2P_OP_CHK_SOCIAL_CH
4751 pwdinfo->rx_invitereq_info.scan_op_ch_only = 0;
4754 static void reset_ch_sitesurvey_timer_process2 (void *FunctionContext)
4756 _adapter *adapter = (_adapter *)FunctionContext;
4757 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
4759 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
4762 DBG_871X( "[%s] In\n", __FUNCTION__ );
4763 // Reset the operation channel information
4764 pwdinfo->p2p_info.operation_ch[0] = 0;
4765 #ifdef CONFIG_P2P_OP_CHK_SOCIAL_CH
4766 pwdinfo->p2p_info.operation_ch[1] = 0;
4767 pwdinfo->p2p_info.operation_ch[2] = 0;
4768 pwdinfo->p2p_info.operation_ch[3] = 0;
4769 #endif //CONFIG_P2P_OP_CHK_SOCIAL_CH
4770 pwdinfo->p2p_info.scan_op_ch_only = 0;
4773 static void restore_p2p_state_timer_process (void *FunctionContext)
4775 _adapter *adapter = (_adapter *)FunctionContext;
4776 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
4778 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
4781 p2p_protocol_wk_cmd( adapter, P2P_RESTORE_STATE_WK );
4784 static void pre_tx_scan_timer_process (void *FunctionContext)
4786 _adapter *adapter = (_adapter *) FunctionContext;
4787 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
4789 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
4792 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
4795 _enter_critical_bh(&pmlmepriv->lock, &irqL);
4798 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_PROVISION_DIS_REQ))
4800 if ( _TRUE == pwdinfo->tx_prov_disc_info.benable ) // the provision discovery request frame is trigger to send or not
4802 p2p_protocol_wk_cmd( adapter, P2P_PRE_TX_PROVDISC_PROCESS_WK );
4803 //issue_probereq_p2p(adapter, NULL);
4804 //_set_timer( &pwdinfo->pre_tx_scan_timer, P2P_TX_PRESCAN_TIMEOUT );
4807 else if (rtw_p2p_chk_state(pwdinfo, P2P_STATE_GONEGO_ING))
4809 if ( _TRUE == pwdinfo->nego_req_info.benable )
4811 p2p_protocol_wk_cmd( adapter, P2P_PRE_TX_NEGOREQ_PROCESS_WK );
4814 else if ( rtw_p2p_chk_state(pwdinfo, P2P_STATE_TX_INVITE_REQ ) )
4816 if ( _TRUE == pwdinfo->invitereq_info.benable )
4818 p2p_protocol_wk_cmd( adapter, P2P_PRE_TX_INVITEREQ_PROCESS_WK );
4823 DBG_8192C( "[%s] p2p_state is %d, ignore!!\n", __FUNCTION__, rtw_p2p_state(pwdinfo) );
4826 _exit_critical_bh(&pmlmepriv->lock, &irqL);
4829 static void find_phase_timer_process (void *FunctionContext)
4831 _adapter *adapter = (_adapter *)FunctionContext;
4832 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
4834 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
4837 adapter->wdinfo.find_phase_state_exchange_cnt++;
4839 p2p_protocol_wk_cmd( adapter, P2P_FIND_PHASE_WK );
4842 #ifdef CONFIG_CONCURRENT_MODE
4843 void ap_p2p_switch_timer_process (void *FunctionContext)
4845 _adapter *adapter = (_adapter *)FunctionContext;
4846 struct wifidirect_info *pwdinfo = &adapter->wdinfo;
4847 #ifdef CONFIG_IOCTL_CFG80211
4848 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(adapter);
4851 if(rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
4854 #ifdef CONFIG_IOCTL_CFG80211
4855 ATOMIC_SET(&pwdev_priv->switch_ch_to, 1);
4858 p2p_protocol_wk_cmd( adapter, P2P_AP_P2P_CH_SWITCH_PROCESS_WK );
4862 void reset_global_wifidirect_info( _adapter* padapter )
4864 struct wifidirect_info *pwdinfo;
4866 pwdinfo = &padapter->wdinfo;
4867 pwdinfo->persistent_supported = 0;
4868 pwdinfo->session_available = _TRUE;
4869 pwdinfo->wfd_tdls_enable = 0;
4870 pwdinfo->wfd_tdls_weaksec = _TRUE;
4874 int rtw_init_wifi_display_info(_adapter* padapter)
4877 struct wifi_display_info *pwfd_info = &padapter->wfd_info;
4879 // Used in P2P and TDLS
4880 pwfd_info->rtsp_ctrlport = 554;
4881 pwfd_info->peer_rtsp_ctrlport = 0; // Reset to 0
4882 pwfd_info->wfd_enable = _FALSE;
4883 pwfd_info->wfd_device_type = WFD_DEVINFO_PSINK;
4884 pwfd_info->scan_result_type = SCAN_RESULT_P2P_ONLY;
4887 pwfd_info->peer_session_avail = _TRUE;
4888 pwfd_info->wfd_pc = _FALSE;
4891 _rtw_memset( pwfd_info->ip_address, 0x00, 4 );
4892 _rtw_memset( pwfd_info->peer_ip_address, 0x00, 4 );
4898 void rtw_init_wifidirect_timers(_adapter* padapter)
4900 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
4902 _init_timer( &pwdinfo->find_phase_timer, padapter->pnetdev, find_phase_timer_process, padapter );
4903 _init_timer( &pwdinfo->restore_p2p_state_timer, padapter->pnetdev, restore_p2p_state_timer_process, padapter );
4904 _init_timer( &pwdinfo->pre_tx_scan_timer, padapter->pnetdev, pre_tx_scan_timer_process, padapter );
4905 _init_timer( &pwdinfo->reset_ch_sitesurvey, padapter->pnetdev, reset_ch_sitesurvey_timer_process, padapter );
4906 _init_timer( &pwdinfo->reset_ch_sitesurvey2, padapter->pnetdev, reset_ch_sitesurvey_timer_process2, padapter );
4907 #ifdef CONFIG_CONCURRENT_MODE
4908 _init_timer( &pwdinfo->ap_p2p_switch_timer, padapter->pnetdev, ap_p2p_switch_timer_process, padapter );
4912 void rtw_init_wifidirect_addrs(_adapter* padapter, u8 *dev_addr, u8 *iface_addr)
4915 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
4917 /*init device&interface address */
4919 _rtw_memcpy(pwdinfo->device_addr, dev_addr, ETH_ALEN);
4922 _rtw_memcpy(pwdinfo->interface_addr, iface_addr, ETH_ALEN);
4927 void init_wifidirect_info( _adapter* padapter, enum P2P_ROLE role)
4929 struct wifidirect_info *pwdinfo;
4931 struct wifi_display_info *pwfd_info = &padapter->wfd_info;
4933 #ifdef CONFIG_CONCURRENT_MODE
4934 _adapter *pbuddy_adapter = padapter->pbuddy_adapter;
4935 struct wifidirect_info *pbuddy_wdinfo = NULL;
4936 struct mlme_priv *pbuddy_mlmepriv = NULL;
4937 struct mlme_ext_priv *pbuddy_mlmeext = NULL;
4940 pwdinfo = &padapter->wdinfo;
4942 pwdinfo->padapter = padapter;
4944 // 1, 6, 11 are the social channel defined in the WiFi Direct specification.
4945 pwdinfo->social_chan[0] = 1;
4946 pwdinfo->social_chan[1] = 6;
4947 pwdinfo->social_chan[2] = 11;
4948 pwdinfo->social_chan[3] = 0; // channel 0 for scanning ending in site survey function.
4950 #ifdef CONFIG_CONCURRENT_MODE
4951 if (pbuddy_adapter) {
4952 pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
4953 pbuddy_mlmepriv = &pbuddy_adapter->mlmepriv;
4954 pbuddy_mlmeext = &pbuddy_adapter->mlmeextpriv;
4957 if ( ( check_buddy_fwstate(padapter, _FW_LINKED ) == _TRUE ) &&
4958 ( ( pbuddy_mlmeext->cur_channel == 1) || ( pbuddy_mlmeext->cur_channel == 6 ) || ( pbuddy_mlmeext->cur_channel == 11 ) )
4961 // Use the AP's channel as the listen channel
4962 // This will avoid the channel switch between AP's channel and listen channel.
4963 pwdinfo->listen_channel = pbuddy_mlmeext->cur_channel;
4966 #endif //CONFIG_CONCURRENT_MODE
4968 // Use the channel 11 as the listen channel
4969 pwdinfo->listen_channel = 11;
4972 if (role == P2P_ROLE_DEVICE)
4974 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DEVICE);
4975 #ifdef CONFIG_CONCURRENT_MODE
4976 if ( check_buddy_fwstate(padapter, _FW_LINKED ) == _TRUE )
4978 rtw_p2p_set_state(pwdinfo, P2P_STATE_IDLE);
4983 rtw_p2p_set_state(pwdinfo, P2P_STATE_LISTEN);
4985 pwdinfo->intent = 1;
4986 rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_LISTEN);
4988 else if (role == P2P_ROLE_CLIENT)
4990 rtw_p2p_set_role(pwdinfo, P2P_ROLE_CLIENT);
4991 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
4992 pwdinfo->intent = 1;
4993 rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
4995 else if (role == P2P_ROLE_GO)
4997 rtw_p2p_set_role(pwdinfo, P2P_ROLE_GO);
4998 rtw_p2p_set_state(pwdinfo, P2P_STATE_GONEGO_OK);
4999 pwdinfo->intent = 15;
5000 rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_GONEGO_OK);
5003 // Use the OFDM rate in the P2P probe response frame. ( 6(B), 9(B), 12, 18, 24, 36, 48, 54 )
5004 pwdinfo->support_rate[0] = 0x8c; // 6(B)
5005 pwdinfo->support_rate[1] = 0x92; // 9(B)
5006 pwdinfo->support_rate[2] = 0x18; // 12
5007 pwdinfo->support_rate[3] = 0x24; // 18
5008 pwdinfo->support_rate[4] = 0x30; // 24
5009 pwdinfo->support_rate[5] = 0x48; // 36
5010 pwdinfo->support_rate[6] = 0x60; // 48
5011 pwdinfo->support_rate[7] = 0x6c; // 54
5013 _rtw_memcpy( ( void* ) pwdinfo->p2p_wildcard_ssid, "DIRECT-", 7 );
5015 _rtw_memset( pwdinfo->device_name, 0x00, WPS_MAX_DEVICE_NAME_LEN );
5016 pwdinfo->device_name_len = 0;
5018 _rtw_memset( &pwdinfo->invitereq_info, 0x00, sizeof( struct tx_invite_req_info ) );
5019 pwdinfo->invitereq_info.token = 3; // Token used for P2P invitation request frame.
5021 _rtw_memset( &pwdinfo->inviteresp_info, 0x00, sizeof( struct tx_invite_resp_info ) );
5022 pwdinfo->inviteresp_info.token = 0;
5024 pwdinfo->profileindex = 0;
5025 _rtw_memset( &pwdinfo->profileinfo[ 0 ], 0x00, sizeof( struct profile_info ) * P2P_MAX_PERSISTENT_GROUP_NUM );
5027 rtw_p2p_findphase_ex_set(pwdinfo, P2P_FINDPHASE_EX_NONE);
5029 pwdinfo->listen_dwell = ( u8 ) (( rtw_get_current_time() % 3 ) + 1);
5030 //DBG_8192C( "[%s] listen_dwell time is %d00ms\n", __FUNCTION__, pwdinfo->listen_dwell );
5032 _rtw_memset( &pwdinfo->tx_prov_disc_info, 0x00, sizeof( struct tx_provdisc_req_info ) );
5033 pwdinfo->tx_prov_disc_info.wps_config_method_request = WPS_CM_NONE;
5035 _rtw_memset( &pwdinfo->nego_req_info, 0x00, sizeof( struct tx_nego_req_info ) );
5037 pwdinfo->device_password_id_for_nego = WPS_DPID_PBC;
5038 pwdinfo->negotiation_dialog_token = 1;
5040 _rtw_memset( pwdinfo->nego_ssid, 0x00, WLAN_SSID_MAXLEN );
5041 pwdinfo->nego_ssidlen = 0;
5043 pwdinfo->ui_got_wps_info = P2P_NO_WPSINFO;
5045 pwdinfo->supported_wps_cm = WPS_CONFIG_METHOD_DISPLAY | WPS_CONFIG_METHOD_PBC;
5046 pwdinfo->wfd_info = pwfd_info;
5048 pwdinfo->supported_wps_cm = WPS_CONFIG_METHOD_DISPLAY | WPS_CONFIG_METHOD_PBC | WPS_CONFIG_METHOD_KEYPAD;
5050 pwdinfo->channel_list_attr_len = 0;
5051 _rtw_memset( pwdinfo->channel_list_attr, 0x00, 100 );
5053 _rtw_memset( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, 0x00, 4 );
5054 _rtw_memset( pwdinfo->rx_prov_disc_info.strconfig_method_desc_of_prov_disc_req, '0', 3 );
5055 _rtw_memset( &pwdinfo->groupid_info, 0x00, sizeof( struct group_id_info ) );
5056 #ifdef CONFIG_CONCURRENT_MODE
5057 #ifdef CONFIG_IOCTL_CFG80211
5058 pwdinfo->ext_listen_interval = 1000; //The interval to be available with legacy AP during p2p0-find/scan
5059 pwdinfo->ext_listen_period = 3000; //The time period to be available for P2P during nego
5060 #else //!CONFIG_IOCTL_CFG80211
5061 //pwdinfo->ext_listen_interval = 3000;
5062 //pwdinfo->ext_listen_period = 400;
5063 pwdinfo->ext_listen_interval = 1000;
5064 pwdinfo->ext_listen_period = 1000;
5065 #endif //!CONFIG_IOCTL_CFG80211
5068 // Commented by Kurt 20130319
5069 // For WiDi purpose: Use CFG80211 interface but controled WFD/RDS frame by driver itself.
5070 #ifdef CONFIG_IOCTL_CFG80211
5071 pwdinfo->driver_interface = DRIVER_CFG80211;
5073 pwdinfo->driver_interface = DRIVER_WEXT;
5074 #endif //CONFIG_IOCTL_CFG80211
5076 pwdinfo->wfd_tdls_enable = 0;
5077 _rtw_memset( pwdinfo->p2p_peer_interface_addr, 0x00, ETH_ALEN );
5078 _rtw_memset( pwdinfo->p2p_peer_device_addr, 0x00, ETH_ALEN );
5080 pwdinfo->rx_invitereq_info.operation_ch[0] = 0;
5081 pwdinfo->rx_invitereq_info.operation_ch[1] = 0; // Used to indicate the scan end in site survey function
5082 #ifdef CONFIG_P2P_OP_CHK_SOCIAL_CH
5083 pwdinfo->rx_invitereq_info.operation_ch[2] = 0;
5084 pwdinfo->rx_invitereq_info.operation_ch[3] = 0;
5085 pwdinfo->rx_invitereq_info.operation_ch[4] = 0;
5086 #endif //CONFIG_P2P_OP_CHK_SOCIAL_CH
5087 pwdinfo->rx_invitereq_info.scan_op_ch_only = 0;
5088 pwdinfo->p2p_info.operation_ch[0] = 0;
5089 pwdinfo->p2p_info.operation_ch[1] = 0; // Used to indicate the scan end in site survey function
5090 #ifdef CONFIG_P2P_OP_CHK_SOCIAL_CH
5091 pwdinfo->p2p_info.operation_ch[2] = 0;
5092 pwdinfo->p2p_info.operation_ch[3] = 0;
5093 pwdinfo->p2p_info.operation_ch[4] = 0;
5094 #endif //CONFIG_P2P_OP_CHK_SOCIAL_CH
5095 pwdinfo->p2p_info.scan_op_ch_only = 0;
5098 #ifdef CONFIG_DBG_P2P
5101 * rtw_p2p_role_txt - Get the p2p role name as a text string
5103 * Returns: The state name as a printable text string
5105 const char * rtw_p2p_role_txt(enum P2P_ROLE role)
5108 case P2P_ROLE_DISABLE:
5109 return "P2P_ROLE_DISABLE";
5110 case P2P_ROLE_DEVICE:
5111 return "P2P_ROLE_DEVICE";
5112 case P2P_ROLE_CLIENT:
5113 return "P2P_ROLE_CLIENT";
5115 return "P2P_ROLE_GO";
5122 * rtw_p2p_state_txt - Get the p2p state name as a text string
5124 * Returns: The state name as a printable text string
5126 const char * rtw_p2p_state_txt(enum P2P_STATE state)
5129 case P2P_STATE_NONE:
5130 return "P2P_STATE_NONE";
5131 case P2P_STATE_IDLE:
5132 return "P2P_STATE_IDLE";
5133 case P2P_STATE_LISTEN:
5134 return "P2P_STATE_LISTEN";
5135 case P2P_STATE_SCAN:
5136 return "P2P_STATE_SCAN";
5137 case P2P_STATE_FIND_PHASE_LISTEN:
5138 return "P2P_STATE_FIND_PHASE_LISTEN";
5139 case P2P_STATE_FIND_PHASE_SEARCH:
5140 return "P2P_STATE_FIND_PHASE_SEARCH";
5141 case P2P_STATE_TX_PROVISION_DIS_REQ:
5142 return "P2P_STATE_TX_PROVISION_DIS_REQ";
5143 case P2P_STATE_RX_PROVISION_DIS_RSP:
5144 return "P2P_STATE_RX_PROVISION_DIS_RSP";
5145 case P2P_STATE_RX_PROVISION_DIS_REQ:
5146 return "P2P_STATE_RX_PROVISION_DIS_REQ";
5147 case P2P_STATE_GONEGO_ING:
5148 return "P2P_STATE_GONEGO_ING";
5149 case P2P_STATE_GONEGO_OK:
5150 return "P2P_STATE_GONEGO_OK";
5151 case P2P_STATE_GONEGO_FAIL:
5152 return "P2P_STATE_GONEGO_FAIL";
5153 case P2P_STATE_RECV_INVITE_REQ_MATCH:
5154 return "P2P_STATE_RECV_INVITE_REQ_MATCH";
5155 case P2P_STATE_PROVISIONING_ING:
5156 return "P2P_STATE_PROVISIONING_ING";
5157 case P2P_STATE_PROVISIONING_DONE:
5158 return "P2P_STATE_PROVISIONING_DONE";
5159 case P2P_STATE_TX_INVITE_REQ:
5160 return "P2P_STATE_TX_INVITE_REQ";
5161 case P2P_STATE_RX_INVITE_RESP_OK:
5162 return "P2P_STATE_RX_INVITE_RESP_OK";
5163 case P2P_STATE_RECV_INVITE_REQ_DISMATCH:
5164 return "P2P_STATE_RECV_INVITE_REQ_DISMATCH";
5165 case P2P_STATE_RECV_INVITE_REQ_GO:
5166 return "P2P_STATE_RECV_INVITE_REQ_GO";
5167 case P2P_STATE_RECV_INVITE_REQ_JOIN:
5168 return "P2P_STATE_RECV_INVITE_REQ_JOIN";
5169 case P2P_STATE_RX_INVITE_RESP_FAIL:
5170 return "P2P_STATE_RX_INVITE_RESP_FAIL";
5171 case P2P_STATE_RX_INFOR_NOREADY:
5172 return "P2P_STATE_RX_INFOR_NOREADY";
5173 case P2P_STATE_TX_INFOR_NOREADY:
5174 return "P2P_STATE_TX_INFOR_NOREADY";
5180 void dbg_rtw_p2p_set_state(struct wifidirect_info *wdinfo, enum P2P_STATE state, const char *caller, int line)
5182 if(!_rtw_p2p_chk_state(wdinfo, state)) {
5183 enum P2P_STATE old_state = _rtw_p2p_state(wdinfo);
5184 _rtw_p2p_set_state(wdinfo, state);
5185 DBG_871X("[CONFIG_DBG_P2P]%s:%d set_state from %s to %s\n", caller, line
5186 , rtw_p2p_state_txt(old_state), rtw_p2p_state_txt(_rtw_p2p_state(wdinfo))
5189 DBG_871X("[CONFIG_DBG_P2P]%s:%d set_state to same state %s\n", caller, line
5190 , rtw_p2p_state_txt(_rtw_p2p_state(wdinfo))
5194 void dbg_rtw_p2p_set_pre_state(struct wifidirect_info *wdinfo, enum P2P_STATE state, const char *caller, int line)
5196 if(_rtw_p2p_pre_state(wdinfo) != state) {
5197 enum P2P_STATE old_state = _rtw_p2p_pre_state(wdinfo);
5198 _rtw_p2p_set_pre_state(wdinfo, state);
5199 DBG_871X("[CONFIG_DBG_P2P]%s:%d set_pre_state from %s to %s\n", caller, line
5200 , rtw_p2p_state_txt(old_state), rtw_p2p_state_txt(_rtw_p2p_pre_state(wdinfo))
5203 DBG_871X("[CONFIG_DBG_P2P]%s:%d set_pre_state to same state %s\n", caller, line
5204 , rtw_p2p_state_txt(_rtw_p2p_pre_state(wdinfo))
5209 void dbg_rtw_p2p_restore_state(struct wifidirect_info *wdinfo, const char *caller, int line)
5211 if(wdinfo->pre_p2p_state != -1) {
5212 DBG_871X("[CONFIG_DBG_P2P]%s:%d restore from %s to %s\n", caller, line
5213 , p2p_state_str[wdinfo->p2p_state], p2p_state_str[wdinfo->pre_p2p_state]
5215 _rtw_p2p_restore_state(wdinfo);
5217 DBG_871X("[CONFIG_DBG_P2P]%s:%d restore no pre state, cur state %s\n", caller, line
5218 , p2p_state_str[wdinfo->p2p_state]
5223 void dbg_rtw_p2p_set_role(struct wifidirect_info *wdinfo, enum P2P_ROLE role, const char *caller, int line)
5225 if(wdinfo->role != role) {
5226 enum P2P_ROLE old_role = wdinfo->role;
5227 _rtw_p2p_set_role(wdinfo, role);
5228 DBG_871X("[CONFIG_DBG_P2P]%s:%d set_role from %s to %s\n", caller, line
5229 , rtw_p2p_role_txt(old_role), rtw_p2p_role_txt(wdinfo->role)
5232 DBG_871X("[CONFIG_DBG_P2P]%s:%d set_role to same role %s\n", caller, line
5233 , rtw_p2p_role_txt(wdinfo->role)
5237 #endif //CONFIG_DBG_P2P
5240 int rtw_p2p_enable(_adapter *padapter, enum P2P_ROLE role)
5243 struct wifidirect_info *pwdinfo= &(padapter->wdinfo);
5245 if (role == P2P_ROLE_DEVICE || role == P2P_ROLE_CLIENT|| role == P2P_ROLE_GO)
5247 u8 channel, ch_offset;
5250 #ifdef CONFIG_CONCURRENT_MODE
5251 _adapter *pbuddy_adapter = padapter->pbuddy_adapter;
5252 struct wifidirect_info *pbuddy_wdinfo = &pbuddy_adapter->wdinfo;
5253 // Commented by Albert 2011/12/30
5254 // The driver just supports 1 P2P group operation.
5255 // So, this function will do nothing if the buddy adapter had enabled the P2P function.
5256 if(!rtw_p2p_chk_state(pbuddy_wdinfo, P2P_STATE_NONE))
5258 // The buddy adapter had enabled the P2P function.
5261 #endif //CONFIG_CONCURRENT_MODE
5263 //leave IPS/Autosuspend
5264 if (_FAIL == rtw_pwr_wakeup(padapter)) {
5269 // Added by Albert 2011/03/22
5270 // In the P2P mode, the driver should not support the b mode.
5271 // So, the Tx packet shouldn't use the CCK rate
5272 update_tx_basic_rate(padapter, WIRELESS_11AGN);
5274 //Enable P2P function
5275 init_wifidirect_info(padapter, role);
5277 rtw_hal_set_odm_var(padapter,HAL_ODM_P2P_STATE,NULL,_TRUE);
5279 rtw_hal_set_odm_var(padapter,HAL_ODM_WIFI_DISPLAY_STATE,NULL,_TRUE);
5283 else if (role == P2P_ROLE_DISABLE)
5285 #ifdef CONFIG_INTEL_WIDI
5286 if( padapter->mlmepriv.p2p_reject_disable == _TRUE )
5288 #endif //CONFIG_INTEL_WIDI
5290 #ifdef CONFIG_IOCTL_CFG80211
5291 if( padapter->wdinfo.driver_interface == DRIVER_CFG80211 )
5292 adapter_wdev_data(padapter)->p2p_enabled = _FALSE;
5293 #endif //CONFIG_IOCTL_CFG80211
5296 //Disable P2P function
5297 if(!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
5299 _cancel_timer_ex( &pwdinfo->find_phase_timer );
5300 _cancel_timer_ex( &pwdinfo->restore_p2p_state_timer );
5301 _cancel_timer_ex( &pwdinfo->pre_tx_scan_timer);
5302 _cancel_timer_ex( &pwdinfo->reset_ch_sitesurvey);
5303 _cancel_timer_ex( &pwdinfo->reset_ch_sitesurvey2);
5304 reset_ch_sitesurvey_timer_process( padapter );
5305 reset_ch_sitesurvey_timer_process2( padapter );
5306 #ifdef CONFIG_CONCURRENT_MODE
5307 _cancel_timer_ex( &pwdinfo->ap_p2p_switch_timer);
5309 rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
5310 rtw_p2p_set_pre_state(pwdinfo, P2P_STATE_NONE);
5311 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DISABLE);
5312 _rtw_memset(&pwdinfo->rx_prov_disc_info, 0x00, sizeof(struct rx_provdisc_req_info));
5314 /* Remove profiles in wifidirect_info structure. */
5315 _rtw_memset( &pwdinfo->profileinfo[ 0 ], 0x00, sizeof( struct profile_info ) * P2P_MAX_PERSISTENT_GROUP_NUM );
5316 pwdinfo->profileindex = 0;
5319 rtw_hal_set_odm_var(padapter,HAL_ODM_P2P_STATE,NULL,_FALSE);
5321 rtw_hal_set_odm_var(padapter,HAL_ODM_WIFI_DISPLAY_STATE,NULL,_FALSE);
5324 if (_FAIL == rtw_pwr_wakeup(padapter)) {
5329 //Restore to initial setting.
5330 update_tx_basic_rate(padapter, padapter->registrypriv.wireless_mode);
5332 #ifdef CONFIG_INTEL_WIDI
5333 rtw_reset_widi_info(padapter);
5334 #endif //CONFIG_INTEL_WIDI
5337 #ifdef CONFIG_IOCTL_CFG80211
5338 pwdinfo->driver_interface = DRIVER_CFG80211;
5340 pwdinfo->driver_interface = DRIVER_WEXT;
5341 #endif //CONFIG_IOCTL_CFG80211