2 ** $Id: //Department/DaVinci/TRUNK/WiFi_P2P_Driver/common/wlan_p2p.c#8 $
6 \brief This file contains the Wi-Fi Direct commands processing routines for
7 MediaTek Inc. 802.11 Wireless LAN Adapters.
15 * 07 17 2012 yuche.tsai
17 * Compile no error before trial run.
19 * 11 24 2011 yuche.tsai
21 * Fix P2P IOCTL of multicast address bug, add low power driver stop control.
23 * 11 22 2011 yuche.tsai
25 * Update RSSI link quality of P2P Network query method. (Bug fix)
27 * 11 19 2011 yuche.tsai
29 * Add RSSI support for P2P network.
31 * 11 08 2011 yuche.tsai
32 * [WCXRP00001094] [Volunteer Patch][Driver] Driver version & supplicant version query & set support for service discovery version check.
33 * Add support for driver version query & p2p supplicant verseion set.
34 * For new service discovery mechanism sync.
36 * 10 18 2011 yuche.tsai
37 * [WCXRP00001045] [WiFi Direct][Driver] Check 2.1 branch.
38 * Support Channle Query.
40 * 10 18 2011 yuche.tsai
41 * [WCXRP00001045] [WiFi Direct][Driver] Check 2.1 branch.
45 * 08 23 2011 yuche.tsai
47 * Fix Multicast Issue of P2P.
49 * 04 27 2011 george.huang
50 * [WCXRP00000684] [MT6620 Wi-Fi][Driver] Support P2P setting ARP filter
51 * Support P2P ARP filter setting on early suspend/ late resume
53 * 04 08 2011 george.huang
54 * [WCXRP00000621] [MT6620 Wi-Fi][Driver] Support P2P supplicant to set power mode
55 * separate settings of P2P and AIS
57 * 03 22 2011 george.huang
58 * [WCXRP00000504] [MT6620 Wi-Fi][FW] Support Sigma CAPI for power saving related command
59 * link with supplicant commands
62 * [WCXRP00000571] [MT6620 Wi-Fi] [Driver] Not check the p2p role during set key
63 * Skip the p2p role for adding broadcast key issue.
66 * [WCXRP00000530] [MT6620 Wi-Fi] [Driver] skip doing p2pRunEventAAAComplete after send assoc response Tx Done
67 * fixed compiling error while enable dbg.
69 * 03 08 2011 yuche.tsai
70 * [WCXRP00000480] [Volunteer Patch][MT6620][Driver] WCS IE format issue[WCXRP00000509] [Volunteer Patch][MT6620][Driver] Kernal panic when remove p2p module.
74 * [WCXRP00000521] [MT6620 Wi-Fi][Driver] Remove non-standard debug message
75 * Toggle non-standard debug messages to comments.
78 * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
79 * rename the define to anti_pviracy.
82 * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
83 * add the code to get the check rsponse and indicate to app.
86 * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
87 * Add Security check related code.
89 * 03 02 2011 yuche.tsai
90 * [WCXRP00000245] 1. Invitation Request/Response.
91 2. Provision Discovery Request/Response
93 * Fix SD Request Query Length issue.
95 * 03 02 2011 yuche.tsai
96 * [WCXRP00000245] 1. Invitation Request/Response.
97 2. Provision Discovery Request/Response
99 * Service Discovery Request.
101 * 03 01 2011 yuche.tsai
102 * [WCXRP00000245] 1. Invitation Request/Response.
103 2. Provision Discovery Request/Response
105 * Update Service Discovery Wlan OID related function.
107 * 03 01 2011 yuche.tsai
108 * [WCXRP00000245] 1. Invitation Request/Response.
109 2. Provision Discovery Request/Response
111 * Update Service Discovery Related wlanoid function.
113 * 02 09 2011 yuche.tsai
114 * [WCXRP00000245] 1. Invitation Request/Response.
115 2. Provision Discovery Request/Response
117 * Add Service Discovery Indication Related code.
119 * 01 26 2011 yuche.tsai
120 * [WCXRP00000245] 1. Invitation Request/Response.
121 2. Provision Discovery Request/Response
123 * Add Service Discovery Function.
126 * [WCXRP00000283] [MT6620 Wi-Fi][Driver][Wi-Fi Direct] Implementation of interface for supporting Wi-Fi Direct Service Discovery
127 * ioctl implementations for P2P Service Discovery
130 * [WCXRP00000338] [MT6620 Wi-Fi][Driver] Separate kalMemAlloc into kmalloc and vmalloc implementations to ease physically continous memory demands
131 * separate kalMemAlloc() into virtually-continous and physically-continous type to ease slab system pressure
134 * [WCXRP00000283] [MT6620 Wi-Fi][Driver][Wi-Fi Direct] Implementation of interface for supporting Wi-Fi Direct Service Discovery
135 * 1. header file restructure for more clear module isolation
136 * 2. add function interface definition for implementing Service Discovery callbacks
139 * [WCXRP00000077] [MT6620 Wi-Fi][Driver][FW] Eliminate use of ENUM_NETWORK_TYPE_T and replaced by ENUM_NETWORK_TYPE_INDEX_T only
140 * remove ENUM_NETWORK_TYPE_T definitions
144 * [WCXRP00000069][MT6620 Wi-Fi][Driver] Fix some code for phase 1 P2P Demo.
146 * 09 21 2010 kevin.huang
147 * [WCXRP00000054] [MT6620 Wi-Fi][Driver] Restructure driver for second Interface
148 * Isolate P2P related function for Hardware Software Bundle
150 * 09 03 2010 kevin.huang
152 * Refine #include sequence and solve recursive/nested #include issue
156 * revise constant definitions to be matched with implementation (original cmd-event definition is deprecated)
160 * add subroutines for P2P to set multicast list.
162 * 08 16 2010 george.huang
166 * 08 16 2010 george.huang
168 * support wlanoidSetP2pPowerSaveProfile() in P2P
170 * 08 16 2010 george.huang
172 * Support wlanoidSetNetworkAddress() for P2P
176 * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
179 * [WPD00003833][MT6620 and MT5931] Driver migration
180 * add API in que_mgt to retrieve sta-rec index for security frames.
183 * [WPD00003833][MT6620 and MT5931] Driver migration
184 * 802.1x and bluetooth-over-Wi-Fi security frames are now delievered to firmware via command path instead of data path.
187 * [WPD00003833][MT6620 and MT5931] Driver migration
188 * 1) migrate assoc.c.
189 * 2) add ucTxSeqNum for tracking frames which needs TX-DONE awareness
190 * 3) add configuration options for CNM_MEM and RSN modules
191 * 4) add data path for management frames
192 * 5) eliminate rPacketInfo of MSDU_INFO_T
194 * 06 06 2010 kevin.huang
195 * [WPD00003832][MT6620 5931] Create driver base
196 * [MT6620 5931] Create driver base
199 * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
200 * 1) add timeout handler mechanism for pending command packets
201 * 2) add p2p add/removal key
206 /******************************************************************************
207 * C O M P I L E R F L A G S
208 *******************************************************************************
211 /******************************************************************************
212 * E X T E R N A L R E F E R E N C E S
213 *******************************************************************************
217 /******************************************************************************
219 *******************************************************************************
222 /******************************************************************************
224 *******************************************************************************
227 /******************************************************************************
228 * P U B L I C D A T A
229 *******************************************************************************
232 /******************************************************************************
233 * P R I V A T E D A T A
234 *******************************************************************************
237 /******************************************************************************
239 *******************************************************************************
242 /******************************************************************************
243 * F U N C T I O N D E C L A R A T I O N S
244 *******************************************************************************
247 /******************************************************************************
249 *******************************************************************************
251 /*----------------------------------------------------------------------------*/
253 * \brief command packet generation utility
255 * \param[in] prAdapter Pointer to the Adapter structure.
256 * \param[in] ucCID Command ID
257 * \param[in] fgSetQuery Set or Query
258 * \param[in] fgNeedResp Need for response
259 * \param[in] pfCmdDoneHandler Function pointer when command is done
260 * \param[in] u4SetQueryInfoLen The length of the set/query buffer
261 * \param[in] pucInfoBuffer Pointer to set/query buffer
264 * \retval WLAN_STATUS_PENDING
265 * \retval WLAN_STATUS_FAILURE
267 /*----------------------------------------------------------------------------*/
269 wlanoidSendSetQueryP2PCmd (
270 IN P_ADAPTER_T prAdapter,
275 PFN_CMD_DONE_HANDLER pfCmdDoneHandler,
276 PFN_CMD_TIMEOUT_HANDLER pfCmdTimeoutHandler,
277 UINT_32 u4SetQueryInfoLen,
278 PUINT_8 pucInfoBuffer,
279 OUT PVOID pvSetQueryBuffer,
280 IN UINT_32 u4SetQueryBufferLen
283 P_GLUE_INFO_T prGlueInfo;
284 P_CMD_INFO_T prCmdInfo;
285 P_WIFI_CMD_T prWifiCmd;
290 prGlueInfo = prAdapter->prGlueInfo;
293 DEBUGFUNC("wlanoidSendSetQueryP2PCmd");
294 DBGLOG(REQ, TRACE, ("Command ID = 0x%08X\n", ucCID));
296 prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + u4SetQueryInfoLen));
299 DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
300 return WLAN_STATUS_FAILURE;
303 // increase command sequence number
304 ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
305 DBGLOG(REQ, TRACE, ("ucCmdSeqNum =%d\n", ucCmdSeqNum));
307 // Setup common CMD Info Packet
308 prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
309 prCmdInfo->eNetworkType = NETWORK_TYPE_P2P_INDEX;
310 prCmdInfo->u2InfoBufLen = (UINT_16)(CMD_HDR_SIZE + u4SetQueryInfoLen);
311 prCmdInfo->pfCmdDoneHandler = pfCmdDoneHandler;
312 prCmdInfo->pfCmdTimeoutHandler = pfCmdTimeoutHandler;
313 prCmdInfo->fgIsOid = fgIsOid;
314 prCmdInfo->ucCID = ucCID;
315 prCmdInfo->fgSetQuery = fgSetQuery;
316 prCmdInfo->fgNeedResp = fgNeedResp;
317 prCmdInfo->fgDriverDomainMCR = FALSE;
318 prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
319 prCmdInfo->u4SetInfoLen = u4SetQueryInfoLen;
320 prCmdInfo->pvInformationBuffer = pvSetQueryBuffer;
321 prCmdInfo->u4InformationBufferLength = u4SetQueryBufferLen;
323 // Setup WIFI_CMD_T (no payload)
324 prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
325 prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
326 prWifiCmd->ucCID = prCmdInfo->ucCID;
327 prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
328 prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
330 if(u4SetQueryInfoLen > 0 && pucInfoBuffer != NULL) {
331 kalMemCopy(prWifiCmd->aucBuffer, pucInfoBuffer, u4SetQueryInfoLen);
334 // insert into prCmdQueue
335 kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
337 // wakeup txServiceThread later
338 GLUE_SET_EVENT(prGlueInfo);
339 return WLAN_STATUS_PENDING;
342 /*----------------------------------------------------------------------------*/
344 * \brief This routine is called to set a key to Wi-Fi Direct driver
346 * \param[in] prAdapter Pointer to the Adapter structure.
347 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
348 * \param[in] u4SetBufferLen The length of the set buffer.
349 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
350 * bytes read from the set buffer. If the call failed
351 * due to invalid length of the set buffer, returns
352 * the amount of storage needed.
354 * \retval WLAN_STATUS_SUCCESS
355 * \retval WLAN_STATUS_ADAPTER_NOT_READY
356 * \retval WLAN_STATUS_INVALID_LENGTH
357 * \retval WLAN_STATUS_INVALID_DATA
359 /*----------------------------------------------------------------------------*/
362 IN P_ADAPTER_T prAdapter,
363 IN PVOID pvSetBuffer,
364 IN UINT_32 u4SetBufferLen,
365 OUT PUINT_32 pu4SetInfoLen
368 CMD_802_11_KEY rCmdKey;
369 P_PARAM_KEY_T prNewKey;
371 DEBUGFUNC("wlanoidSetAddP2PKey");
372 DBGLOG(REQ, INFO, ("\n"));
376 ASSERT(pu4SetInfoLen);
378 prNewKey = (P_PARAM_KEY_T) pvSetBuffer;
380 /* Verify the key structure length. */
381 if (prNewKey->u4Length > u4SetBufferLen) {
382 DBGLOG(REQ, WARN, ("Invalid key structure length (%d) greater than total buffer length (%d)\n",
383 (UINT_8)prNewKey->u4Length,
384 (UINT_8)u4SetBufferLen));
386 *pu4SetInfoLen = u4SetBufferLen;
387 return WLAN_STATUS_INVALID_LENGTH;
389 /* Verify the key material length for key material buffer */
390 else if (prNewKey->u4KeyLength > prNewKey->u4Length - OFFSET_OF(PARAM_KEY_T, aucKeyMaterial)) {
391 DBGLOG(REQ, WARN, ("Invalid key material length (%d)\n", (UINT_8)prNewKey->u4KeyLength));
392 *pu4SetInfoLen = u4SetBufferLen;
393 return WLAN_STATUS_INVALID_DATA;
395 /* Exception check */
396 else if (prNewKey->u4KeyIndex & 0x0fffff00) {
397 return WLAN_STATUS_INVALID_DATA;
399 /* Exception check, pairwise key must with transmit bit enabled */
400 else if ((prNewKey->u4KeyIndex & BITS(30,31)) == IS_UNICAST_KEY) {
401 return WLAN_STATUS_INVALID_DATA;
403 else if (!(prNewKey->u4KeyLength == CCMP_KEY_LEN) && !(prNewKey->u4KeyLength == TKIP_KEY_LEN)) {
404 return WLAN_STATUS_INVALID_DATA;
406 /* Exception check, pairwise key must with transmit bit enabled */
407 else if ((prNewKey->u4KeyIndex & BITS(30,31)) == BITS(30,31)) {
408 if (((prNewKey->u4KeyIndex & 0xff) != 0) ||
409 ((prNewKey->arBSSID[0] == 0xff) && (prNewKey->arBSSID[1] == 0xff) && (prNewKey->arBSSID[2] == 0xff) &&
410 (prNewKey->arBSSID[3] == 0xff) && (prNewKey->arBSSID[4] == 0xff) && (prNewKey->arBSSID[5] == 0xff))) {
411 return WLAN_STATUS_INVALID_DATA;
415 *pu4SetInfoLen = u4SetBufferLen;
417 // fill CMD_802_11_KEY
418 kalMemZero(&rCmdKey, sizeof(CMD_802_11_KEY));
419 rCmdKey.ucAddRemove = 1; /* add */
420 rCmdKey.ucTxKey = ((prNewKey->u4KeyIndex & IS_TRANSMIT_KEY) == IS_TRANSMIT_KEY) ? 1 : 0;
421 rCmdKey.ucKeyType = ((prNewKey->u4KeyIndex & IS_UNICAST_KEY) == IS_UNICAST_KEY) ? 1 : 0;
422 if(kalP2PGetRole(prAdapter->prGlueInfo) == 1) { /* group client */
423 rCmdKey.ucIsAuthenticator = 0;
425 else { /* group owner */
426 rCmdKey.ucIsAuthenticator = 1;
428 COPY_MAC_ADDR(rCmdKey.aucPeerAddr, prNewKey->arBSSID);
429 rCmdKey.ucNetType = NETWORK_TYPE_P2P_INDEX;
430 if(prNewKey->u4KeyLength == CCMP_KEY_LEN)
431 rCmdKey.ucAlgorithmId = CIPHER_SUITE_CCMP; // AES
432 else if(prNewKey->u4KeyLength == TKIP_KEY_LEN)
433 rCmdKey.ucAlgorithmId = CIPHER_SUITE_TKIP; // TKIP
434 rCmdKey.ucKeyId = (UINT_8)(prNewKey->u4KeyIndex & 0xff);
435 rCmdKey.ucKeyLen = (UINT_8)prNewKey->u4KeyLength;
436 kalMemCopy(rCmdKey.aucKeyMaterial, (PUINT_8)prNewKey->aucKeyMaterial, rCmdKey.ucKeyLen);
438 return wlanoidSendSetQueryP2PCmd(prAdapter,
439 CMD_ID_ADD_REMOVE_KEY,
443 nicCmdEventSetCommon,
445 sizeof(CMD_802_11_KEY),
453 /*----------------------------------------------------------------------------*/
455 * \brief This routine is called to request Wi-Fi Direct driver to remove keys
457 * \param[in] prAdapter Pointer to the Adapter structure.
458 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
459 * \param[in] u4SetBufferLen The length of the set buffer.
460 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
461 * bytes read from the set buffer. If the call failed
462 * due to invalid length of the set buffer, returns
463 * the amount of storage needed.
465 * \retval WLAN_STATUS_SUCCESS
466 * \retval WLAN_STATUS_INVALID_DATA
467 * \retval WLAN_STATUS_INVALID_LENGTH
468 * \retval WLAN_STATUS_INVALID_DATA
470 /*----------------------------------------------------------------------------*/
472 wlanoidSetRemoveP2PKey(
473 IN P_ADAPTER_T prAdapter,
474 IN PVOID pvSetBuffer,
475 IN UINT_32 u4SetBufferLen,
476 OUT PUINT_32 pu4SetInfoLen
479 CMD_802_11_KEY rCmdKey;
480 P_PARAM_REMOVE_KEY_T prRemovedKey;
482 DEBUGFUNC("wlanoidSetRemoveP2PKey");
485 if (u4SetBufferLen < sizeof(PARAM_REMOVE_KEY_T)) {
486 return WLAN_STATUS_INVALID_LENGTH;
490 prRemovedKey = (P_PARAM_REMOVE_KEY_T)pvSetBuffer;
492 /* Check bit 31: this bit should always 0 */
493 if (prRemovedKey->u4KeyIndex & IS_TRANSMIT_KEY) {
494 /* Bit 31 should not be set */
495 DBGLOG(REQ, ERROR, ("invalid key index: 0x%08lx\n",
496 prRemovedKey->u4KeyIndex));
497 return WLAN_STATUS_INVALID_DATA;
500 /* Check bits 8 ~ 29 should always be 0 */
501 if (prRemovedKey->u4KeyIndex & BITS(8, 29)) {
502 /* Bit 31 should not be set */
503 DBGLOG(REQ, ERROR, ("invalid key index: 0x%08lx\n",
504 prRemovedKey->u4KeyIndex));
505 return WLAN_STATUS_INVALID_DATA;
508 /* There should not be any key operation for P2P Device */
509 if(kalP2PGetRole(prAdapter->prGlueInfo) == 0) {
510 // return WLAN_STATUS_NOT_ACCEPTED;
513 kalMemZero((PUINT_8)&rCmdKey, sizeof(CMD_802_11_KEY));
515 rCmdKey.ucAddRemove = 0; // remove
516 if(kalP2PGetRole(prAdapter->prGlueInfo) == 1) { /* group client */
517 rCmdKey.ucIsAuthenticator = 0;
519 else { /* group owner */
520 rCmdKey.ucIsAuthenticator = 1;
522 kalMemCopy(rCmdKey.aucPeerAddr, (PUINT_8)prRemovedKey->arBSSID, MAC_ADDR_LEN);
523 rCmdKey.ucNetType = NETWORK_TYPE_P2P_INDEX;
524 rCmdKey.ucKeyId = (UINT_8)(prRemovedKey->u4KeyIndex & 0x000000ff);
526 return wlanoidSendSetQueryP2PCmd(prAdapter,
527 CMD_ID_ADD_REMOVE_KEY,
531 nicCmdEventSetCommon,
533 sizeof(CMD_802_11_KEY),
540 /*----------------------------------------------------------------------------*/
542 * \brief Setting the IP address for pattern search function.
544 * \param[in] prAdapter Pointer to the Adapter structure.
545 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
546 * \param[in] u4SetBufferLen The length of the set buffer.
547 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
548 * bytes read from the set buffer. If the call failed
549 * due to invalid length of the set buffer, returns
550 * the amount of storage needed.
552 * \return WLAN_STATUS_SUCCESS
553 * \return WLAN_STATUS_ADAPTER_NOT_READY
554 * \return WLAN_STATUS_INVALID_LENGTH
556 /*----------------------------------------------------------------------------*/
558 wlanoidSetP2pNetworkAddress(
559 IN P_ADAPTER_T prAdapter,
560 IN PVOID pvSetBuffer,
561 IN UINT_32 u4SetBufferLen,
562 OUT PUINT_32 pu4SetInfoLen
565 WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
567 P_CMD_SET_NETWORK_ADDRESS_LIST prCmdNetworkAddressList;
568 P_PARAM_NETWORK_ADDRESS_LIST prNetworkAddressList = (P_PARAM_NETWORK_ADDRESS_LIST)pvSetBuffer;
569 P_PARAM_NETWORK_ADDRESS prNetworkAddress;
570 P_PARAM_NETWORK_ADDRESS_IP prNetAddrIp;
571 UINT_32 u4IpAddressCount, u4CmdSize;
573 DEBUGFUNC("wlanoidSetP2pNetworkAddress");
574 DBGLOG(INIT, TRACE, ("\n"));
577 ASSERT(pu4SetInfoLen);
581 if (u4SetBufferLen < sizeof(PARAM_NETWORK_ADDRESS_LIST)) {
582 return WLAN_STATUS_INVALID_DATA;
586 u4IpAddressCount = 0;
588 prNetworkAddress = prNetworkAddressList->arAddress;
589 for ( i = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
590 if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
591 prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
595 prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
596 (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
599 // construct payload of command packet
600 u4CmdSize = OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress) +
601 sizeof(IPV4_NETWORK_ADDRESS) * u4IpAddressCount;
603 prCmdNetworkAddressList = (P_CMD_SET_NETWORK_ADDRESS_LIST) kalMemAlloc(u4CmdSize, VIR_MEM_TYPE);
605 if(prCmdNetworkAddressList == NULL)
606 return WLAN_STATUS_FAILURE;
608 // fill P_CMD_SET_NETWORK_ADDRESS_LIST
609 prCmdNetworkAddressList->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
610 prCmdNetworkAddressList->ucAddressCount = (UINT_8)u4IpAddressCount;
611 prNetworkAddress = prNetworkAddressList->arAddress;
612 for (i = 0, j = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
613 if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
614 prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
615 prNetAddrIp = (P_PARAM_NETWORK_ADDRESS_IP)prNetworkAddress->aucAddress;
617 kalMemCopy(prCmdNetworkAddressList->arNetAddress[j].aucIpAddr,
618 &(prNetAddrIp->in_addr),
624 prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
625 (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
628 rStatus = wlanSendSetQueryCmd(prAdapter,
629 CMD_ID_SET_IP_ADDRESS,
633 nicCmdEventSetIpAddress,
634 nicOidCmdTimeoutCommon,
636 (PUINT_8)prCmdNetworkAddressList,
641 kalMemFree(prCmdNetworkAddressList, VIR_MEM_TYPE, u4CmdSize);
645 /*----------------------------------------------------------------------------*/
647 * \brief This routine is used to query the power save profile.
649 * \param[in] prAdapter Pointer to the Adapter structure.
650 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
652 * \param[in] u4QueryBufLen The length of the query buffer.
653 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
654 * bytes written into the query buffer. If the call
655 * failed due to invalid length of the query buffer,
656 * returns the amount of storage needed.
658 * \return WLAN_STATUS_SUCCESS
660 /*----------------------------------------------------------------------------*/
662 wlanoidQueryP2pPowerSaveProfile (
663 IN P_ADAPTER_T prAdapter,
664 IN PVOID pvQueryBuffer,
665 IN UINT_32 u4QueryBufferLen,
666 OUT PUINT_32 pu4QueryInfoLen
669 DEBUGFUNC("wlanoidQueryP2pPowerSaveProfile");
672 ASSERT(pu4QueryInfoLen);
674 if (u4QueryBufferLen!=0) {
675 ASSERT(pvQueryBuffer);
677 *(PPARAM_POWER_MODE) pvQueryBuffer = (PARAM_POWER_MODE)(prAdapter->rWlanInfo.arPowerSaveMode[NETWORK_TYPE_P2P_INDEX].ucPsProfile);
678 *pu4QueryInfoLen = sizeof(PARAM_POWER_MODE);
681 return WLAN_STATUS_SUCCESS;
684 /*----------------------------------------------------------------------------*/
686 * \brief This routine is used to set the power save profile.
688 * \param[in] pvAdapter Pointer to the Adapter structure.
689 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
690 * \param[in] u4SetBufferLen The length of the set buffer.
691 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
692 * bytes read from the set buffer. If the call failed
693 * due to invalid length of the set buffer, returns
694 * the amount of storage needed.
696 * \retval WLAN_STATUS_SUCCESS
697 * \retval WLAN_STATUS_INVALID_LENGTH
699 /*----------------------------------------------------------------------------*/
701 wlanoidSetP2pPowerSaveProfile (
702 IN P_ADAPTER_T prAdapter,
703 IN PVOID pvSetBuffer,
704 IN UINT_32 u4SetBufferLen,
705 OUT PUINT_32 pu4SetInfoLen
709 PARAM_POWER_MODE ePowerMode;
710 DEBUGFUNC("wlanoidSetP2pPowerSaveProfile");
713 ASSERT(pu4SetInfoLen);
715 *pu4SetInfoLen = sizeof(PARAM_POWER_MODE);
716 if (u4SetBufferLen < sizeof(PARAM_POWER_MODE)) {
717 DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4SetBufferLen));
718 return WLAN_STATUS_INVALID_LENGTH;
720 else if (*(PPARAM_POWER_MODE) pvSetBuffer >= Param_PowerModeMax) {
721 WARNLOG(("Invalid power mode %d\n",
722 *(PPARAM_POWER_MODE) pvSetBuffer));
723 return WLAN_STATUS_INVALID_DATA;
726 ePowerMode = *(PPARAM_POWER_MODE) pvSetBuffer;
728 if (prAdapter->fgEnCtiaPowerMode) {
729 if (ePowerMode == Param_PowerModeCAM) {
732 // User setting to PS mode (Param_PowerModeMAX_PSP or Param_PowerModeFast_PSP)
734 if (prAdapter->u4CtiaPowerMode == 0) {
735 // force to keep in CAM mode
736 ePowerMode = Param_PowerModeCAM;
737 } else if (prAdapter->u4CtiaPowerMode == 1) {
738 ePowerMode = Param_PowerModeMAX_PSP;
739 } else if (prAdapter->u4CtiaPowerMode == 2) {
740 ePowerMode = Param_PowerModeFast_PSP;
745 status = nicConfigPowerSaveProfile(
747 NETWORK_TYPE_P2P_INDEX,
751 } /* end of wlanoidSetP2pPowerSaveProfile() */
753 /*----------------------------------------------------------------------------*/
755 * \brief This routine is used to set the power save profile.
757 * \param[in] pvAdapter Pointer to the Adapter structure.
758 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
759 * \param[in] u4SetBufferLen The length of the set buffer.
760 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
761 * bytes read from the set buffer. If the call failed
762 * due to invalid length of the set buffer, returns
763 * the amount of storage needed.
765 * \retval WLAN_STATUS_SUCCESS
766 * \retval WLAN_STATUS_INVALID_LENGTH
768 /*----------------------------------------------------------------------------*/
770 wlanoidSetP2pSetNetworkAddress (
771 IN P_ADAPTER_T prAdapter,
772 IN PVOID pvSetBuffer,
773 IN UINT_32 u4SetBufferLen,
774 OUT PUINT_32 pu4SetInfoLen
777 WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
779 P_CMD_SET_NETWORK_ADDRESS_LIST prCmdNetworkAddressList;
780 P_PARAM_NETWORK_ADDRESS_LIST prNetworkAddressList = (P_PARAM_NETWORK_ADDRESS_LIST)pvSetBuffer;
781 P_PARAM_NETWORK_ADDRESS prNetworkAddress;
782 P_PARAM_NETWORK_ADDRESS_IP prNetAddrIp;
783 UINT_32 u4IpAddressCount, u4CmdSize;
784 PUINT_8 pucBuf = (PUINT_8)pvSetBuffer;
786 DEBUGFUNC("wlanoidSetP2pSetNetworkAddress");
787 DBGLOG(INIT, TRACE, ("\n"));
788 printk("wlanoidSetP2pSetNetworkAddress (%d)\n", (INT_16)u4SetBufferLen);
791 ASSERT(pu4SetInfoLen);
795 if (u4SetBufferLen < sizeof(PARAM_NETWORK_ADDRESS_LIST)) {
796 return WLAN_STATUS_INVALID_DATA;
800 u4IpAddressCount = 0;
802 prNetworkAddress = prNetworkAddressList->arAddress;
803 for ( i = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
804 if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
805 prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
809 prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
810 (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
813 // construct payload of command packet
814 u4CmdSize = OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress) +
815 sizeof(IPV4_NETWORK_ADDRESS) * u4IpAddressCount;
817 if (u4IpAddressCount == 0) {
818 u4CmdSize = sizeof(CMD_SET_NETWORK_ADDRESS_LIST);
821 prCmdNetworkAddressList = (P_CMD_SET_NETWORK_ADDRESS_LIST) kalMemAlloc(u4CmdSize, VIR_MEM_TYPE);
823 if(prCmdNetworkAddressList == NULL)
824 return WLAN_STATUS_FAILURE;
826 // fill P_CMD_SET_NETWORK_ADDRESS_LIST
827 prCmdNetworkAddressList->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
829 /* only to set IP address to FW once ARP filter is enabled */
830 if (prAdapter->fgEnArpFilter) {
831 prCmdNetworkAddressList->ucAddressCount = (UINT_8)u4IpAddressCount;
832 prNetworkAddress = prNetworkAddressList->arAddress;
834 printk("u4IpAddressCount (%ld) \n", (INT_32)u4IpAddressCount);
835 for (i = 0, j = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
836 if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
837 prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
838 prNetAddrIp = (P_PARAM_NETWORK_ADDRESS_IP)prNetworkAddress->aucAddress;
840 kalMemCopy(prCmdNetworkAddressList->arNetAddress[j].aucIpAddr,
841 &(prNetAddrIp->in_addr),
846 pucBuf = (PUINT_8)&prNetAddrIp->in_addr;
847 printk("prNetAddrIp->in_addr:%d:%d:%d:%d\n", (UINT_8)pucBuf[0], (UINT_8)pucBuf[1], (UINT_8)pucBuf[2], (UINT_8)pucBuf[3]);
850 prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
851 (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
855 prCmdNetworkAddressList->ucAddressCount = 0;
858 rStatus = wlanSendSetQueryCmd(prAdapter,
859 CMD_ID_SET_IP_ADDRESS,
863 nicCmdEventSetIpAddress,
864 nicOidCmdTimeoutCommon,
866 (PUINT_8)prCmdNetworkAddressList,
871 kalMemFree(prCmdNetworkAddressList, VIR_MEM_TYPE, u4CmdSize);
873 } /* end of wlanoidSetP2pSetNetworkAddress() */
876 /*----------------------------------------------------------------------------*/
878 * \brief This routine is called to set Multicast Address List.
880 * \param[in] prAdapter Pointer to the Adapter structure.
881 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
882 * \param[in] u4SetBufferLen The length of the set buffer.
883 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
884 * bytes read from the set buffer. If the call failed
885 * due to invalid length of the set buffer, returns
886 * the amount of storage needed.
888 * \retval WLAN_STATUS_SUCCESS
889 * \retval WLAN_STATUS_INVALID_LENGTH
890 * \retval WLAN_STATUS_ADAPTER_NOT_READY
891 * \retval WLAN_STATUS_MULTICAST_FULL
893 /*----------------------------------------------------------------------------*/
895 wlanoidSetP2PMulticastList(
896 IN P_ADAPTER_T prAdapter,
897 IN PVOID pvSetBuffer,
898 IN UINT_32 u4SetBufferLen,
899 OUT PUINT_32 pu4SetInfoLen
902 CMD_MAC_MCAST_ADDR rCmdMacMcastAddr;
904 ASSERT(pu4SetInfoLen);
906 /* The data must be a multiple of the Ethernet address size. */
907 if ((u4SetBufferLen % MAC_ADDR_LEN)) {
908 DBGLOG(REQ, WARN, ("Invalid MC list length %ld\n", u4SetBufferLen));
910 *pu4SetInfoLen = (((u4SetBufferLen + MAC_ADDR_LEN) - 1) /
911 MAC_ADDR_LEN) * MAC_ADDR_LEN;
913 return WLAN_STATUS_INVALID_LENGTH;
916 *pu4SetInfoLen = u4SetBufferLen;
918 /* Verify if we can support so many multicast addresses. */
919 if ((u4SetBufferLen / MAC_ADDR_LEN) > MAX_NUM_GROUP_ADDR) {
920 DBGLOG(REQ, WARN, ("Too many MC addresses\n"));
922 return WLAN_STATUS_MULTICAST_FULL;
925 /* NOTE(Kevin): Windows may set u4SetBufferLen == 0 &&
926 * pvSetBuffer == NULL to clear exist Multicast List.
928 if (u4SetBufferLen) {
932 if (prAdapter->rAcpiState == ACPI_STATE_D3) {
933 DBGLOG(REQ, WARN, ("Fail in set multicast list! (Adapter not ready). ACPI=D%d, Radio=%d\n",
934 prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
935 return WLAN_STATUS_ADAPTER_NOT_READY;
938 rCmdMacMcastAddr.u4NumOfGroupAddr = u4SetBufferLen / MAC_ADDR_LEN;
939 rCmdMacMcastAddr.ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
940 kalMemCopy(rCmdMacMcastAddr.arAddress, pvSetBuffer, u4SetBufferLen);
942 return wlanoidSendSetQueryP2PCmd(prAdapter,
943 CMD_ID_MAC_MCAST_ADDR,
946 FALSE, // This CMD response is no need to complete the OID. Or the event would unsync.
947 nicCmdEventSetCommon,
948 nicOidCmdTimeoutCommon,
949 sizeof(CMD_MAC_MCAST_ADDR),
950 (PUINT_8)&rCmdMacMcastAddr,
955 } /* end of wlanoidSetP2PMulticastList() */
958 /*----------------------------------------------------------------------------*/
960 * \brief This routine is called to send GAS frame for P2P Service Discovery Request
962 * \param[in] prAdapter Pointer to the Adapter structure.
963 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
964 * \param[in] u4SetBufferLen The length of the set buffer.
965 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
966 * bytes read from the set buffer. If the call failed
967 * due to invalid length of the set buffer, returns
968 * the amount of storage needed.
970 * \retval WLAN_STATUS_SUCCESS
971 * \retval WLAN_STATUS_INVALID_LENGTH
972 * \retval WLAN_STATUS_ADAPTER_NOT_READY
973 * \retval WLAN_STATUS_MULTICAST_FULL
975 /*----------------------------------------------------------------------------*/
977 wlanoidSendP2PSDRequest(
978 IN P_ADAPTER_T prAdapter,
979 IN PVOID pvSetBuffer,
980 IN UINT_32 u4SetBufferLen,
981 OUT PUINT_32 pu4SetInfoLen
984 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
986 ASSERT(pu4SetInfoLen);
988 if (u4SetBufferLen) {
992 if (u4SetBufferLen < sizeof(PARAM_P2P_SEND_SD_REQUEST)) {
993 *pu4SetInfoLen = sizeof(PARAM_P2P_SEND_SD_REQUEST);
994 return WLAN_STATUS_BUFFER_TOO_SHORT;
997 // rWlanStatus = p2pFsmRunEventSDRequest(prAdapter, (P_PARAM_P2P_SEND_SD_REQUEST)pvSetBuffer);
1000 } /* end of wlanoidSendP2PSDRequest() */
1003 /*----------------------------------------------------------------------------*/
1005 * \brief This routine is called to send GAS frame for P2P Service Discovery Response
1007 * \param[in] prAdapter Pointer to the Adapter structure.
1008 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
1009 * \param[in] u4SetBufferLen The length of the set buffer.
1010 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1011 * bytes read from the set buffer. If the call failed
1012 * due to invalid length of the set buffer, returns
1013 * the amount of storage needed.
1015 * \retval WLAN_STATUS_SUCCESS
1016 * \retval WLAN_STATUS_INVALID_LENGTH
1017 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1018 * \retval WLAN_STATUS_MULTICAST_FULL
1020 /*----------------------------------------------------------------------------*/
1022 wlanoidSendP2PSDResponse(
1023 IN P_ADAPTER_T prAdapter,
1024 IN PVOID pvSetBuffer,
1025 IN UINT_32 u4SetBufferLen,
1026 OUT PUINT_32 pu4SetInfoLen
1029 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1031 ASSERT(pu4SetInfoLen);
1033 if (u4SetBufferLen) {
1034 ASSERT(pvSetBuffer);
1037 if (u4SetBufferLen < sizeof(PARAM_P2P_SEND_SD_RESPONSE)) {
1038 *pu4SetInfoLen = sizeof(PARAM_P2P_SEND_SD_RESPONSE);
1039 return WLAN_STATUS_BUFFER_TOO_SHORT;
1042 // rWlanStatus = p2pFsmRunEventSDResponse(prAdapter, (P_PARAM_P2P_SEND_SD_RESPONSE)pvSetBuffer);
1045 } /* end of wlanoidGetP2PSDRequest() */
1048 /*----------------------------------------------------------------------------*/
1050 * \brief This routine is called to get GAS frame for P2P Service Discovery Request
1052 * \param[in] prAdapter Pointer to the Adapter structure.
1053 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
1055 * \param[in] u4QueryBufferLen The length of the query buffer.
1056 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
1057 * bytes written into the query buffer. If the call
1058 * failed due to invalid length of the query buffer,
1059 * returns the amount of storage needed.
1061 * \retval WLAN_STATUS_SUCCESS
1062 * \retval WLAN_STATUS_INVALID_LENGTH
1063 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1064 * \retval WLAN_STATUS_MULTICAST_FULL
1066 /*----------------------------------------------------------------------------*/
1068 wlanoidGetP2PSDRequest(
1069 IN P_ADAPTER_T prAdapter,
1070 IN PVOID pvQueryBuffer,
1071 IN UINT_32 u4QueryBufferLen,
1072 OUT PUINT_32 pu4QueryInfoLen
1075 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1076 PUINT_8 pucPacketBuffer = NULL, pucTA = NULL;
1077 // PUINT_8 pucChannelNum = NULL;
1078 PUINT_16 pu2PacketLength = NULL;
1079 P_WLAN_MAC_HEADER_T prWlanHdr = (P_WLAN_MAC_HEADER_T)NULL;
1080 UINT_8 ucVersionNum = 0;
1081 // UINT_8 ucChannelNum = 0, ucSeqNum = 0;
1084 ASSERT(pu4QueryInfoLen);
1086 if (u4QueryBufferLen) {
1087 ASSERT(pvQueryBuffer);
1090 if (u4QueryBufferLen < sizeof(PARAM_P2P_GET_SD_REQUEST)) {
1091 *pu4QueryInfoLen = sizeof(PARAM_P2P_GET_SD_REQUEST);
1092 return WLAN_STATUS_BUFFER_TOO_SHORT;
1095 DBGLOG(P2P, TRACE, ("Get Service Discovery Request\n"));
1097 if ((ucVersionNum = p2pFuncGetVersionNumOfSD(prAdapter)) == 0) {
1098 P_PARAM_P2P_GET_SD_REQUEST prP2pGetSdReq = (P_PARAM_P2P_GET_SD_REQUEST)pvQueryBuffer;
1100 pucPacketBuffer = prP2pGetSdReq->aucPacketContent;
1101 pu2PacketLength = &prP2pGetSdReq->u2PacketLength;
1102 pucTA = &prP2pGetSdReq->rTransmitterAddr;
1105 P_PARAM_P2P_GET_SD_REQUEST_EX prP2pGetSdReqEx = (P_PARAM_P2P_GET_SD_REQUEST_EX)NULL;
1107 prP2pGetSdReqEx = (P_PARAM_P2P_GET_SD_REQUEST)pvQueryBuffer;
1108 pucPacketBuffer = prP2pGetSdReqEx->aucPacketContent;
1109 pu2PacketLength = &prP2pGetSdReqEx->u2PacketLength;
1110 pucTA = &prP2pGetSdReqEx->rTransmitterAddr;
1111 pucChannelNum = &prP2pGetSdReqEx->ucChannelNum;
1112 ucSeqNum = prP2pGetSdReqEx->ucSeqNum;
1116 rWlanStatus = p2pFuncGetServiceDiscoveryFrame(prAdapter,
1118 (u4QueryBufferLen - sizeof(PARAM_P2P_GET_SD_REQUEST)),
1119 (PUINT_32)pu2PacketLength,
1123 *pu4QueryInfoLen = 0;
1127 prWlanHdr = (P_WLAN_MAC_HEADER_T)pucPacketBuffer;
1129 kalMemCopy(pucTA, prWlanHdr->aucAddr2, MAC_ADDR_LEN);
1131 if (pu4QueryInfoLen) {
1132 if (ucVersionNum == 0) {
1133 *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_REQUEST) + (*pu2PacketLength));
1136 *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_REQUEST_EX) + (*pu2PacketLength));
1142 } /* end of wlanoidGetP2PSDRequest() */
1145 /*----------------------------------------------------------------------------*/
1147 * \brief This routine is called to get GAS frame for P2P Service Discovery Response
1149 * \param[in] prAdapter Pointer to the Adapter structure.
1150 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
1152 * \param[in] u4QueryBufferLen The length of the query buffer.
1153 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
1154 * bytes written into the query buffer. If the call
1155 * failed due to invalid length of the query buffer,
1156 * returns the amount of storage needed.
1158 * \retval WLAN_STATUS_SUCCESS
1159 * \retval WLAN_STATUS_INVALID_LENGTH
1160 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1161 * \retval WLAN_STATUS_MULTICAST_FULL
1163 /*----------------------------------------------------------------------------*/
1165 wlanoidGetP2PSDResponse(
1166 IN P_ADAPTER_T prAdapter,
1167 IN PVOID pvQueryBuffer,
1168 IN UINT_32 u4QueryBufferLen,
1169 OUT PUINT_32 pu4QueryInfoLen
1172 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1173 P_WLAN_MAC_HEADER_T prWlanHdr = (P_WLAN_MAC_HEADER_T)NULL;
1174 //UINT_8 ucSeqNum = 0,
1175 UINT_8 ucVersionNum = 0;
1176 PUINT_8 pucPacketContent = (PUINT_8)NULL, pucTA = (PUINT_8)NULL;
1177 PUINT_16 pu2PacketLength = (PUINT_16)NULL;
1180 ASSERT(pu4QueryInfoLen);
1182 if (u4QueryBufferLen) {
1183 ASSERT(pvQueryBuffer);
1186 if (u4QueryBufferLen < sizeof(PARAM_P2P_GET_SD_RESPONSE)) {
1187 *pu4QueryInfoLen = sizeof(PARAM_P2P_GET_SD_RESPONSE);
1188 return WLAN_STATUS_BUFFER_TOO_SHORT;
1191 DBGLOG(P2P, TRACE, ("Get Service Discovery Response\n"));
1194 if ((ucVersionNum = p2pFuncGetVersionNumOfSD(prAdapter)) == 0) {
1195 P_PARAM_P2P_GET_SD_RESPONSE prP2pGetSdRsp = (P_PARAM_P2P_GET_SD_RESPONSE)NULL;
1197 prP2pGetSdRsp = (P_PARAM_P2P_GET_SD_REQUEST)pvQueryBuffer;
1198 pucPacketContent = prP2pGetSdRsp->aucPacketContent;
1199 pucTA = &prP2pGetSdRsp->rTransmitterAddr;
1200 pu2PacketLength = &prP2pGetSdRsp->u2PacketLength;
1203 P_PARAM_P2P_GET_SD_RESPONSE_EX prP2pGetSdRspEx = (P_PARAM_P2P_GET_SD_RESPONSE_EX)NULL;
1205 prP2pGetSdRspEx = (P_PARAM_P2P_GET_SD_RESPONSE_EX)pvQueryBuffer;
1206 pucPacketContent = prP2pGetSdRspEx->aucPacketContent;
1207 pucTA = &prP2pGetSdRspEx->rTransmitterAddr;
1208 pu2PacketLength = &prP2pGetSdRspEx->u2PacketLength;
1209 ucSeqNum = prP2pGetSdRspEx->ucSeqNum;
1213 // rWlanStatus = p2pFuncGetServiceDiscoveryFrame(prAdapter,
1214 // pucPacketContent,
1215 // (u4QueryBufferLen - sizeof(PARAM_P2P_GET_SD_RESPONSE)),
1216 // (PUINT_32)pu2PacketLength,
1220 *pu4QueryInfoLen = 0;
1223 prWlanHdr = (P_WLAN_MAC_HEADER_T)pucPacketContent;
1225 kalMemCopy(pucTA, prWlanHdr->aucAddr2, MAC_ADDR_LEN);
1228 if (pu4QueryInfoLen) {
1229 if (ucVersionNum == 0) {
1230 *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_RESPONSE) + *pu2PacketLength);
1233 *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_RESPONSE_EX) + *pu2PacketLength);
1238 } /* end of wlanoidGetP2PSDResponse() */
1241 /*----------------------------------------------------------------------------*/
1243 * \brief This routine is called to terminate P2P Service Discovery Phase
1245 * \param[in] prAdapter Pointer to the Adapter structure.
1246 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
1247 * \param[in] u4SetBufferLen The length of the set buffer.
1248 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1249 * bytes read from the set buffer. If the call failed
1250 * due to invalid length of the set buffer, returns
1251 * the amount of storage needed.
1253 * \retval WLAN_STATUS_SUCCESS
1254 * \retval WLAN_STATUS_INVALID_LENGTH
1255 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1256 * \retval WLAN_STATUS_MULTICAST_FULL
1258 /*----------------------------------------------------------------------------*/
1260 wlanoidSetP2PTerminateSDPhase(
1261 IN P_ADAPTER_T prAdapter,
1262 IN PVOID pvSetBuffer,
1263 IN UINT_32 u4SetBufferLen,
1264 OUT PUINT_32 pu4SetInfoLen
1267 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1268 P_PARAM_P2P_TERMINATE_SD_PHASE prP2pTerminateSD = (P_PARAM_P2P_TERMINATE_SD_PHASE)NULL;
1269 UINT_8 aucNullAddr[] = NULL_MAC_ADDR;
1272 if ((prAdapter == NULL) || (pu4SetInfoLen == NULL)) {
1277 if ((u4SetBufferLen) && (pvSetBuffer == NULL)) {
1281 if (u4SetBufferLen < sizeof(PARAM_P2P_TERMINATE_SD_PHASE)) {
1282 *pu4SetInfoLen = sizeof(PARAM_P2P_TERMINATE_SD_PHASE);
1283 rWlanStatus = WLAN_STATUS_BUFFER_TOO_SHORT;
1287 prP2pTerminateSD = (P_PARAM_P2P_TERMINATE_SD_PHASE)pvSetBuffer;
1289 if (EQUAL_MAC_ADDR(prP2pTerminateSD->rPeerAddr, aucNullAddr)) {
1290 DBGLOG(P2P, TRACE, ("Service Discovery Version 2.0\n"));
1291 // p2pFuncSetVersionNumOfSD(prAdapter, 2);
1294 //rWlanStatus = p2pFsmRunEventSDAbort(prAdapter);
1303 } /* end of wlanoidSetP2PTerminateSDPhase() */
1306 #if CFG_SUPPORT_ANTI_PIRACY
1307 /*----------------------------------------------------------------------------*/
1309 * \brief This routine is called to
1311 * \param[in] prAdapter Pointer to the Adapter structure.
1312 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
1313 * \param[in] u4SetBufferLen The length of the set buffer.
1314 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1315 * bytes read from the set buffer. If the call failed
1316 * due to invalid length of the set buffer, returns
1317 * the amount of storage needed.
1319 * \retval WLAN_STATUS_SUCCESS
1320 * \retval WLAN_STATUS_INVALID_LENGTH
1321 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1322 * \retval WLAN_STATUS_MULTICAST_FULL
1324 /*----------------------------------------------------------------------------*/
1326 wlanoidSetSecCheckRequest(
1327 IN P_ADAPTER_T prAdapter,
1328 IN PVOID pvSetBuffer,
1329 IN UINT_32 u4SetBufferLen,
1330 OUT PUINT_32 pu4SetInfoLen
1334 ASSERT(pu4SetInfoLen);
1336 if (u4SetBufferLen) {
1337 ASSERT(pvSetBuffer);
1340 return wlanoidSendSetQueryP2PCmd(prAdapter,
1346 nicOidCmdTimeoutCommon,
1348 (PUINT_8)pvSetBuffer,
1353 } /* end of wlanoidSetSecCheckRequest() */
1356 /*----------------------------------------------------------------------------*/
1358 * \brief This routine is called to
1360 * \param[in] prAdapter Pointer to the Adapter structure.
1361 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
1363 * \param[in] u4QueryBufferLen The length of the query buffer.
1364 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
1365 * bytes written into the query buffer. If the call
1366 * failed due to invalid length of the query buffer,
1367 * returns the amount of storage needed.
1369 * \retval WLAN_STATUS_SUCCESS
1370 * \retval WLAN_STATUS_INVALID_LENGTH
1371 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1372 * \retval WLAN_STATUS_MULTICAST_FULL
1374 /*----------------------------------------------------------------------------*/
1376 wlanoidGetSecCheckResponse(
1377 IN P_ADAPTER_T prAdapter,
1378 IN PVOID pvQueryBuffer,
1379 IN UINT_32 u4QueryBufferLen,
1380 OUT PUINT_32 pu4QueryInfoLen
1383 WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1384 //P_WLAN_MAC_HEADER_T prWlanHdr = (P_WLAN_MAC_HEADER_T)NULL;
1385 P_GLUE_INFO_T prGlueInfo;
1387 prGlueInfo = prAdapter->prGlueInfo;
1390 ASSERT(pu4QueryInfoLen);
1392 if (u4QueryBufferLen) {
1393 ASSERT(pvQueryBuffer);
1396 if (u4QueryBufferLen > 256) {
1397 u4QueryBufferLen = 256;
1400 *pu4QueryInfoLen = u4QueryBufferLen;
1403 DBGLOG_MEM8(SEC, LOUD, prGlueInfo->prP2PInfo->aucSecCheckRsp, u4QueryBufferLen);
1405 kalMemCopy((PUINT_8)(pvQueryBuffer + OFFSET_OF(IW_P2P_TRANSPORT_STRUCT, aucBuffer)), prGlueInfo->prP2PInfo->aucSecCheckRsp, u4QueryBufferLen);
1408 } /* end of wlanoidGetSecCheckResponse() */
1412 wlanoidSetNoaParam (
1413 IN P_ADAPTER_T prAdapter,
1414 IN PVOID pvSetBuffer,
1415 IN UINT_32 u4SetBufferLen,
1416 OUT PUINT_32 pu4SetInfoLen
1419 P_PARAM_CUSTOM_NOA_PARAM_STRUC_T prNoaParam;
1420 CMD_CUSTOM_NOA_PARAM_STRUC_T rCmdNoaParam;
1422 DEBUGFUNC("wlanoidSetNoaParam");
1423 DBGLOG(INIT, TRACE,("\n"));
1426 ASSERT(pu4SetInfoLen);
1428 *pu4SetInfoLen = sizeof(PARAM_CUSTOM_NOA_PARAM_STRUC_T);
1430 if (u4SetBufferLen < sizeof(PARAM_CUSTOM_NOA_PARAM_STRUC_T)) {
1431 return WLAN_STATUS_INVALID_LENGTH;
1434 ASSERT(pvSetBuffer);
1436 prNoaParam = (P_PARAM_CUSTOM_NOA_PARAM_STRUC_T)pvSetBuffer;
1438 kalMemZero(&rCmdNoaParam, sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T));
1439 rCmdNoaParam.u4NoaDurationMs = prNoaParam->u4NoaDurationMs;
1440 rCmdNoaParam.u4NoaIntervalMs = prNoaParam->u4NoaIntervalMs;
1441 rCmdNoaParam.u4NoaCount = prNoaParam->u4NoaCount;
1444 return wlanSendSetQueryCmd(prAdapter,
1445 CMD_ID_SET_NOA_PARAM,
1449 nicCmdEventSetCommon,
1450 nicOidCmdTimeoutCommon,
1451 sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T),
1452 (PUINT_8)&rCmdNoaParam,
1457 return wlanoidSendSetQueryP2PCmd(prAdapter,
1458 CMD_ID_SET_NOA_PARAM,
1463 nicOidCmdTimeoutCommon,
1464 sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T),
1465 (PUINT_8)&rCmdNoaParam,
1475 wlanoidSetOppPsParam (
1476 IN P_ADAPTER_T prAdapter,
1477 IN PVOID pvSetBuffer,
1478 IN UINT_32 u4SetBufferLen,
1479 OUT PUINT_32 pu4SetInfoLen
1482 P_PARAM_CUSTOM_OPPPS_PARAM_STRUC_T prOppPsParam;
1483 CMD_CUSTOM_OPPPS_PARAM_STRUC_T rCmdOppPsParam;
1485 DEBUGFUNC("wlanoidSetOppPsParam");
1486 DBGLOG(INIT, TRACE,("\n"));
1489 ASSERT(pu4SetInfoLen);
1491 *pu4SetInfoLen = sizeof(PARAM_CUSTOM_OPPPS_PARAM_STRUC_T);
1493 if (u4SetBufferLen < sizeof(PARAM_CUSTOM_OPPPS_PARAM_STRUC_T)) {
1494 return WLAN_STATUS_INVALID_LENGTH;
1497 ASSERT(pvSetBuffer);
1499 prOppPsParam = (P_PARAM_CUSTOM_OPPPS_PARAM_STRUC_T)pvSetBuffer;
1501 kalMemZero(&rCmdOppPsParam, sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T));
1502 rCmdOppPsParam.u4CTwindowMs = prOppPsParam->u4CTwindowMs;
1505 return wlanSendSetQueryCmd(prAdapter,
1506 CMD_ID_SET_OPPPS_PARAM,
1510 nicCmdEventSetCommon,
1511 nicOidCmdTimeoutCommon,
1512 sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1513 (PUINT_8)&rCmdOppPsParam,
1518 return wlanoidSendSetQueryP2PCmd(prAdapter,
1519 CMD_ID_SET_NOA_PARAM,
1524 nicOidCmdTimeoutCommon,
1525 sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1526 (PUINT_8)&rCmdOppPsParam,
1536 wlanoidSetUApsdParam (
1537 IN P_ADAPTER_T prAdapter,
1538 IN PVOID pvSetBuffer,
1539 IN UINT_32 u4SetBufferLen,
1540 OUT PUINT_32 pu4SetInfoLen
1543 P_PARAM_CUSTOM_UAPSD_PARAM_STRUC_T prUapsdParam;
1544 CMD_CUSTOM_UAPSD_PARAM_STRUC_T rCmdUapsdParam;
1545 P_PM_PROFILE_SETUP_INFO_T prPmProfSetupInfo;
1546 P_BSS_INFO_T prBssInfo;
1549 DEBUGFUNC("wlanoidSetUApsdParam");
1550 DBGLOG(INIT, TRACE,("\n"));
1553 ASSERT(pu4SetInfoLen);
1555 *pu4SetInfoLen = sizeof(PARAM_CUSTOM_UAPSD_PARAM_STRUC_T);
1557 if (u4SetBufferLen < sizeof(PARAM_CUSTOM_UAPSD_PARAM_STRUC_T)) {
1558 return WLAN_STATUS_INVALID_LENGTH;
1561 ASSERT(pvSetBuffer);
1563 prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1564 prPmProfSetupInfo = &prBssInfo->rPmProfSetupInfo;
1566 prUapsdParam = (P_PARAM_CUSTOM_UAPSD_PARAM_STRUC_T)pvSetBuffer;
1568 kalMemZero(&rCmdUapsdParam, sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T));
1569 rCmdUapsdParam.fgEnAPSD = prUapsdParam->fgEnAPSD;
1570 prAdapter->rWifiVar.fgSupportUAPSD = prUapsdParam->fgEnAPSD;
1572 rCmdUapsdParam.fgEnAPSD_AcBe = prUapsdParam->fgEnAPSD_AcBe;
1573 rCmdUapsdParam.fgEnAPSD_AcBk = prUapsdParam->fgEnAPSD_AcBk;
1574 rCmdUapsdParam.fgEnAPSD_AcVo = prUapsdParam->fgEnAPSD_AcVo;
1575 rCmdUapsdParam.fgEnAPSD_AcVi = prUapsdParam->fgEnAPSD_AcVi;
1576 prPmProfSetupInfo->ucBmpDeliveryAC =
1577 ((prUapsdParam->fgEnAPSD_AcBe << 0) |
1578 (prUapsdParam->fgEnAPSD_AcBk << 1) |
1579 (prUapsdParam->fgEnAPSD_AcVi << 2) |
1580 (prUapsdParam->fgEnAPSD_AcVo << 3));
1581 prPmProfSetupInfo->ucBmpTriggerAC =
1582 ((prUapsdParam->fgEnAPSD_AcBe << 0) |
1583 (prUapsdParam->fgEnAPSD_AcBk << 1) |
1584 (prUapsdParam->fgEnAPSD_AcVi << 2) |
1585 (prUapsdParam->fgEnAPSD_AcVo << 3));
1587 rCmdUapsdParam.ucMaxSpLen = prUapsdParam->ucMaxSpLen;
1588 prPmProfSetupInfo->ucUapsdSp = prUapsdParam->ucMaxSpLen;
1591 return wlanSendSetQueryCmd(prAdapter,
1592 CMD_ID_SET_UAPSD_PARAM,
1596 nicCmdEventSetCommon,
1597 nicOidCmdTimeoutCommon,
1598 sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1599 (PUINT_8)&rCmdUapsdParam,
1604 return wlanoidSendSetQueryP2PCmd(prAdapter,
1605 CMD_ID_SET_UAPSD_PARAM,
1610 nicOidCmdTimeoutCommon,
1611 sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1612 (PUINT_8)&rCmdUapsdParam,
1623 wlanoidQueryP2pOpChannel (
1624 IN P_ADAPTER_T prAdapter,
1625 IN PVOID pvQueryBuffer,
1626 IN UINT_32 u4QueryBufferLen,
1627 OUT PUINT_32 pu4QueryInfoLen
1631 WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1632 // PUINT_8 pucOpChnl = (PUINT_8)pvQueryBuffer;
1635 if ((prAdapter == NULL) || (pu4QueryInfoLen == NULL)) {
1640 if ((u4QueryBufferLen) && (pvQueryBuffer == NULL)) {
1644 if (u4QueryBufferLen < sizeof(UINT_8)) {
1645 *pu4QueryInfoLen = sizeof(UINT_8);
1646 rResult = WLAN_STATUS_BUFFER_TOO_SHORT;
1651 if (!p2pFuncGetCurrentOpChnl(prAdapter, pucOpChnl)) {
1652 rResult = WLAN_STATUS_INVALID_DATA;
1656 rResult = WLAN_STATUS_INVALID_DATA;
1660 *pu4QueryInfoLen = sizeof(UINT_8);
1661 rResult = WLAN_STATUS_SUCCESS;
1666 } /* wlanoidQueryP2pOpChannel */
1669 wlanoidQueryP2pVersion (
1670 IN P_ADAPTER_T prAdapter,
1671 IN PVOID pvQueryBuffer,
1672 IN UINT_32 u4QueryBufferLen,
1673 OUT PUINT_32 pu4QueryInfoLen
1676 WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1677 // PUINT_8 pucVersionNum = (PUINT_8)pvQueryBuffer;
1680 if ((prAdapter == NULL) || (pu4QueryInfoLen == NULL)) {
1685 if ((u4QueryBufferLen) && (pvQueryBuffer == NULL)) {
1689 if (u4QueryBufferLen < sizeof(UINT_8)) {
1690 *pu4QueryInfoLen = sizeof(UINT_8);
1691 rResult = WLAN_STATUS_BUFFER_TOO_SHORT;
1698 } /* wlanoidQueryP2pVersion */
1701 wlanoidSetP2pSupplicantVersion (
1702 IN P_ADAPTER_T prAdapter,
1703 IN PVOID pvSetBuffer,
1704 IN UINT_32 u4SetBufferLen,
1705 OUT PUINT_32 pu4SetInfoLen
1708 WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1709 UINT_8 ucVersionNum;
1712 if ((prAdapter == NULL) || (pu4SetInfoLen == NULL)) {
1714 rResult = WLAN_STATUS_INVALID_DATA;
1718 if ((u4SetBufferLen) && (pvSetBuffer == NULL)) {
1719 rResult = WLAN_STATUS_INVALID_DATA;
1723 *pu4SetInfoLen = sizeof(UINT_8);
1725 if (u4SetBufferLen < sizeof(UINT_8)) {
1726 rResult = WLAN_STATUS_INVALID_LENGTH;
1731 ucVersionNum = *((PUINT_8)pvSetBuffer);
1734 rResult = WLAN_STATUS_SUCCESS;
1738 } /* wlanoidSetP2pSupplicantVersion */
1741 /*----------------------------------------------------------------------------*/
1743 * \brief This routine is used to set the WPS mode.
1745 * \param[in] pvAdapter Pointer to the Adapter structure.
1746 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
1747 * \param[in] u4SetBufferLen The length of the set buffer.
1748 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1749 * bytes read from the set buffer. If the call failed
1750 * due to invalid length of the set buffer, returns
1751 * the amount of storage needed.
1753 * \retval WLAN_STATUS_SUCCESS
1754 * \retval WLAN_STATUS_INVALID_LENGTH
1756 /*----------------------------------------------------------------------------*/
1758 wlanoidSetP2pWPSmode (
1759 IN P_ADAPTER_T prAdapter,
1760 IN PVOID pvSetBuffer,
1761 IN UINT_32 u4SetBufferLen,
1762 OUT PUINT_32 pu4SetInfoLen
1766 UINT_32 u4IsWPSmode = 0;
1767 DEBUGFUNC("wlanoidSetP2pWPSmode");
1770 ASSERT(pu4SetInfoLen);
1773 u4IsWPSmode = *(PUINT_32)pvSetBuffer;
1780 prAdapter->rWifiVar.prP2pFsmInfo->fgIsWPSMode = 1;
1783 prAdapter->rWifiVar.prP2pFsmInfo->fgIsWPSMode = 0;
1786 status = nicUpdateBss(
1788 NETWORK_TYPE_P2P_INDEX);
1791 } /* end of wlanoidSetP2pWPSmode() */
1794 #if CFG_SUPPORT_P2P_RSSI_QUERY
1796 wlanoidQueryP2pRssi (
1797 IN P_ADAPTER_T prAdapter,
1798 IN PVOID pvQueryBuffer,
1799 IN UINT_32 u4QueryBufferLen,
1800 OUT PUINT_32 pu4QueryInfoLen
1803 DEBUGFUNC("wlanoidQueryP2pRssi");
1806 ASSERT(pu4QueryInfoLen);
1807 if (u4QueryBufferLen) {
1808 ASSERT(pvQueryBuffer);
1811 *pu4QueryInfoLen = sizeof(PARAM_RSSI);
1813 /* Check for query buffer length */
1814 if (u4QueryBufferLen < *pu4QueryInfoLen) {
1815 DBGLOG(REQ, WARN, ("Too short length %ld\n", u4QueryBufferLen));
1816 return WLAN_STATUS_BUFFER_TOO_SHORT;
1819 if (prAdapter->fgIsP2pLinkQualityValid == TRUE &&
1820 (kalGetTimeTick() - prAdapter->rP2pLinkQualityUpdateTime) <= CFG_LINK_QUALITY_VALID_PERIOD) {
1823 rRssi = (PARAM_RSSI)prAdapter->rP2pLinkQuality.cRssi; // ranged from (-128 ~ 30) in unit of dBm
1825 if(rRssi > PARAM_WHQL_RSSI_MAX_DBM)
1826 rRssi = PARAM_WHQL_RSSI_MAX_DBM;
1827 else if(rRssi < PARAM_WHQL_RSSI_MIN_DBM)
1828 rRssi = PARAM_WHQL_RSSI_MIN_DBM;
1830 kalMemCopy(pvQueryBuffer, &rRssi, sizeof(PARAM_RSSI));
1831 return WLAN_STATUS_SUCCESS;
1835 return wlanSendSetQueryCmd(prAdapter,
1836 CMD_ID_GET_LINK_QUALITY,
1840 nicCmdEventQueryLinkQuality,
1841 nicOidCmdTimeoutCommon,
1848 return wlanSendSetQueryCmd(prAdapter,
1849 CMD_ID_GET_LINK_QUALITY,
1853 nicCmdEventQueryLinkQuality,
1854 nicOidCmdTimeoutCommon,
1862 } /* wlanoidQueryP2pRssi */