drivers/mtk_wcn_combo/drv_wlan/mt6620/wlan/common/wlan_p2p.c

   1 /*
   2 ** $Id: //Department/DaVinci/TRUNK/WiFi_P2P_Driver/common/wlan_p2p.c#8 $
   3 */
   4
   5 /*! \file wlan_bow.c
   6     \brief This file contains the Wi-Fi Direct commands processing routines for
   7            MediaTek Inc. 802.11 Wireless LAN Adapters.
   8 */
   9
  10
  11
  12 /*
  13 ** $Log: wlan_p2p.c $
  14  *
  15  * 07 17 2012 yuche.tsai
  16  * NULL
  17  * Compile no error before trial run.
  18  *
  19  * 11 24 2011 yuche.tsai
  20  * NULL
  21  * Fix P2P IOCTL of multicast address bug, add low power driver stop control.
  22  *
  23  * 11 22 2011 yuche.tsai
  24  * NULL
  25  * Update RSSI link quality of P2P Network query method. (Bug fix)
  26  *
  27  * 11 19 2011 yuche.tsai
  28  * NULL
  29  * Add RSSI support for P2P network.
  30  *
  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.
  35  *
  36  * 10 18 2011 yuche.tsai
  37  * [WCXRP00001045] [WiFi Direct][Driver] Check 2.1 branch.
  38  * Support Channle Query.
  39  *
  40  * 10 18 2011 yuche.tsai
  41  * [WCXRP00001045] [WiFi Direct][Driver] Check 2.1 branch.
  42  * New 2.1 branch
  43
  44  *
  45  * 08 23 2011 yuche.tsai
  46  * NULL
  47  * Fix Multicast Issue of P2P.
  48  *
  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
  52  *
  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
  56  *
  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
  60  *
  61  * 03 17 2011 wh.su
  62  * [WCXRP00000571] [MT6620 Wi-Fi] [Driver] Not check the p2p role during set key
  63  * Skip the p2p role for adding broadcast key issue.
  64  *
  65  * 03 16 2011 wh.su
  66  * [WCXRP00000530] [MT6620 Wi-Fi] [Driver] skip doing p2pRunEventAAAComplete after send assoc response Tx Done
  67  * fixed compiling error while enable dbg.
  68  *
  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.
  71  * .
  72  *
  73  * 03 07 2011 terry.wu
  74  * [WCXRP00000521] [MT6620 Wi-Fi][Driver] Remove non-standard debug message
  75  * Toggle non-standard debug messages to comments.
  76  *
  77  * 03 07 2011 wh.su
  78  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
  79  * rename the define to anti_pviracy.
  80  *
  81  * 03 05 2011 wh.su
  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.
  84  *
  85  * 03 02 2011 wh.su
  86  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
  87  * Add Security check related code.
  88  *
  89  * 03 02 2011 yuche.tsai
  90  * [WCXRP00000245] 1. Invitation Request/Response.
  91 2. Provision Discovery Request/Response
  92
  93  * Fix SD Request Query Length issue.
  94  *
  95  * 03 02 2011 yuche.tsai
  96  * [WCXRP00000245] 1. Invitation Request/Response.
  97 2. Provision Discovery Request/Response
  98
  99  * Service Discovery Request.
 100  *
 101  * 03 01 2011 yuche.tsai
 102  * [WCXRP00000245] 1. Invitation Request/Response.
 103 2. Provision Discovery Request/Response
 104
 105  * Update Service Discovery Wlan OID related function.
 106  *
 107  * 03 01 2011 yuche.tsai
 108  * [WCXRP00000245] 1. Invitation Request/Response.
 109 2. Provision Discovery Request/Response
 110
 111  * Update Service Discovery Related wlanoid function.
 112  *
 113  * 02 09 2011 yuche.tsai
 114  * [WCXRP00000245] 1. Invitation Request/Response.
 115 2. Provision Discovery Request/Response
 116
 117  * Add Service Discovery Indication Related code.
 118  *
 119  * 01 26 2011 yuche.tsai
 120  * [WCXRP00000245] 1. Invitation Request/Response.
 121 2. Provision Discovery Request/Response
 122
 123  * Add Service Discovery Function.
 124  *
 125  * 01 05 2011 cp.wu
 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
 128  *
 129  * 01 04 2011 cp.wu
 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
 132  *
 133  * 12 22 2010 cp.wu
 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
 137  *
 138  * 10 04 2010 cp.wu
 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
 141  *
 142  * 09 28 2010 wh.su
 143  * NULL
 144  * [WCXRP00000069][MT6620 Wi-Fi][Driver] Fix some code for phase 1 P2P Demo.
 145  *
 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
 149  *
 150  * 09 03 2010 kevin.huang
 151  * NULL
 152  * Refine #include sequence and solve recursive/nested #include issue
 153  *
 154  * 08 23 2010 cp.wu
 155  * NULL
 156  * revise constant definitions to be matched with implementation (original cmd-event definition is deprecated)
 157  *
 158  * 08 16 2010 cp.wu
 159  * NULL
 160  * add subroutines for P2P to set multicast list.
 161  *
 162  * 08 16 2010 george.huang
 163  * NULL
 164  * .
 165  *
 166  * 08 16 2010 george.huang
 167  * NULL
 168  * support wlanoidSetP2pPowerSaveProfile() in P2P
 169  *
 170  * 08 16 2010 george.huang
 171  * NULL
 172  * Support wlanoidSetNetworkAddress() for P2P
 173  *
 174  * 07 08 2010 cp.wu
 175  *
 176  * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
 177  *
 178  * 06 25 2010 cp.wu
 179  * [WPD00003833][MT6620 and MT5931] Driver migration
 180  * add API in que_mgt to retrieve sta-rec index for security frames.
 181  *
 182  * 06 24 2010 cp.wu
 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.
 185  *
 186  * 06 11 2010 cp.wu
 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
 193  *
 194  * 06 06 2010 kevin.huang
 195  * [WPD00003832][MT6620 5931] Create driver base
 196  * [MT6620 5931] Create driver base
 197  *
 198  * 05 17 2010 cp.wu
 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
 202  *
 203 **
 204 */
 205
 206 /******************************************************************************
 207 *                         C O M P I L E R   F L A G S
 208 *******************************************************************************
 209 */
 210
 211 /******************************************************************************
 212 *                    E X T E R N A L   R E F E R E N C E S
 213 *******************************************************************************
 214 */
 215 #include "precomp.h"
 216
 217 /******************************************************************************
 218 *                              C O N S T A N T S
 219 *******************************************************************************
 220 */
 221
 222 /******************************************************************************
 223 *                             D A T A   T Y P E S
 224 *******************************************************************************
 225 */
 226
 227 /******************************************************************************
 228 *                            P U B L I C   D A T A
 229 *******************************************************************************
 230 */
 231
 232 /******************************************************************************
 233 *                           P R I V A T E   D A T A
 234 *******************************************************************************
 235 */
 236
 237 /******************************************************************************
 238 *                                 M A C R O S
 239 *******************************************************************************
 240 */
 241
 242 /******************************************************************************
 243 *                   F U N C T I O N   D E C L A R A T I O N S
 244 *******************************************************************************
 245 */
 246
 247 /******************************************************************************
 248 *                              F U N C T I O N S
 249 *******************************************************************************
 250 */
 251 /*----------------------------------------------------------------------------*/
 252 /*!
 253 * \brief command packet generation utility
 254 *
 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
 262 *
 263 *
 264 * \retval WLAN_STATUS_PENDING
 265 * \retval WLAN_STATUS_FAILURE
 266 */
 267 /*----------------------------------------------------------------------------*/
 268 WLAN_STATUS
 269 wlanoidSendSetQueryP2PCmd (
 270     IN P_ADAPTER_T  prAdapter,
 271     UINT_8          ucCID,
 272     BOOLEAN         fgSetQuery,
 273     BOOLEAN         fgNeedResp,
 274     BOOLEAN         fgIsOid,
 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
 281     )
 282 {
 283     P_GLUE_INFO_T prGlueInfo;
 284     P_CMD_INFO_T prCmdInfo;
 285     P_WIFI_CMD_T prWifiCmd;
 286     UINT_8 ucCmdSeqNum;
 287
 288     ASSERT(prAdapter);
 289
 290     prGlueInfo = prAdapter->prGlueInfo;
 291     ASSERT(prGlueInfo);
 292
 293     DEBUGFUNC("wlanoidSendSetQueryP2PCmd");
 294     DBGLOG(REQ, TRACE, ("Command ID = 0x%08X\n", ucCID));
 295
 296     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + u4SetQueryInfoLen));
 297
 298     if (!prCmdInfo) {
 299         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
 300         return WLAN_STATUS_FAILURE;
 301     }
 302
 303     // increase command sequence number
 304     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
 305     DBGLOG(REQ, TRACE, ("ucCmdSeqNum =%d\n", ucCmdSeqNum));
 306
 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;
 322
 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;
 329
 330     if(u4SetQueryInfoLen > 0 && pucInfoBuffer != NULL) {
 331         kalMemCopy(prWifiCmd->aucBuffer, pucInfoBuffer, u4SetQueryInfoLen);
 332     }
 333
 334     // insert into prCmdQueue
 335     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
 336
 337     // wakeup txServiceThread later
 338     GLUE_SET_EVENT(prGlueInfo);
 339     return WLAN_STATUS_PENDING;
 340 }
 341
 342 /*----------------------------------------------------------------------------*/
 343 /*!
 344 * \brief This routine is called to set a key to Wi-Fi Direct driver
 345 *
 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.
 353 *
 354 * \retval WLAN_STATUS_SUCCESS
 355 * \retval WLAN_STATUS_ADAPTER_NOT_READY
 356 * \retval WLAN_STATUS_INVALID_LENGTH
 357 * \retval WLAN_STATUS_INVALID_DATA
 358 */
 359 /*----------------------------------------------------------------------------*/
 360 WLAN_STATUS
 361 wlanoidSetAddP2PKey(
 362     IN  P_ADAPTER_T prAdapter,
 363     IN  PVOID       pvSetBuffer,
 364     IN  UINT_32     u4SetBufferLen,
 365     OUT PUINT_32    pu4SetInfoLen
 366     )
 367 {
 368     CMD_802_11_KEY rCmdKey;
 369     P_PARAM_KEY_T prNewKey;
 370
 371     DEBUGFUNC("wlanoidSetAddP2PKey");
 372     DBGLOG(REQ, INFO, ("\n"));
 373
 374     ASSERT(prAdapter);
 375     ASSERT(pvSetBuffer);
 376     ASSERT(pu4SetInfoLen);
 377
 378     prNewKey = (P_PARAM_KEY_T) pvSetBuffer;
 379
 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));
 385
 386         *pu4SetInfoLen = u4SetBufferLen;
 387         return WLAN_STATUS_INVALID_LENGTH;
 388     }
 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;
 394     }
 395     /* Exception check */
 396     else if (prNewKey->u4KeyIndex & 0x0fffff00) {
 397         return WLAN_STATUS_INVALID_DATA;
 398     }
 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;
 402     }
 403     else if (!(prNewKey->u4KeyLength == CCMP_KEY_LEN) && !(prNewKey->u4KeyLength == TKIP_KEY_LEN)) {
 404         return WLAN_STATUS_INVALID_DATA;
 405     }
 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;
 412         }
 413     }
 414
 415     *pu4SetInfoLen = u4SetBufferLen;
 416
 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;
 424     }
 425     else { /* group owner */
 426         rCmdKey.ucIsAuthenticator = 1;
 427     }
 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);
 437
 438     return wlanoidSendSetQueryP2PCmd(prAdapter,
 439             CMD_ID_ADD_REMOVE_KEY,
 440             TRUE,
 441             FALSE,
 442             TRUE,
 443             nicCmdEventSetCommon,
 444             NULL,
 445             sizeof(CMD_802_11_KEY),
 446             (PUINT_8)&rCmdKey,
 447             pvSetBuffer,
 448             u4SetBufferLen
 449             );
 450 }
 451
 452
 453 /*----------------------------------------------------------------------------*/
 454 /*!
 455 * \brief This routine is called to request Wi-Fi Direct driver to remove keys
 456 *
 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.
 464 *
 465 * \retval WLAN_STATUS_SUCCESS
 466 * \retval WLAN_STATUS_INVALID_DATA
 467 * \retval WLAN_STATUS_INVALID_LENGTH
 468 * \retval WLAN_STATUS_INVALID_DATA
 469 */
 470 /*----------------------------------------------------------------------------*/
 471 WLAN_STATUS
 472 wlanoidSetRemoveP2PKey(
 473     IN  P_ADAPTER_T prAdapter,
 474     IN  PVOID       pvSetBuffer,
 475     IN  UINT_32     u4SetBufferLen,
 476     OUT PUINT_32    pu4SetInfoLen
 477     )
 478 {
 479     CMD_802_11_KEY rCmdKey;
 480     P_PARAM_REMOVE_KEY_T prRemovedKey;
 481
 482     DEBUGFUNC("wlanoidSetRemoveP2PKey");
 483     ASSERT(prAdapter);
 484
 485     if (u4SetBufferLen < sizeof(PARAM_REMOVE_KEY_T)) {
 486         return WLAN_STATUS_INVALID_LENGTH;
 487     }
 488
 489     ASSERT(pvSetBuffer);
 490     prRemovedKey = (P_PARAM_REMOVE_KEY_T)pvSetBuffer;
 491
 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;
 498     }
 499
 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;
 506     }
 507
 508     /* There should not be any key operation for P2P Device */
 509     if(kalP2PGetRole(prAdapter->prGlueInfo) == 0) {
 510     //    return WLAN_STATUS_NOT_ACCEPTED;
 511     }
 512
 513     kalMemZero((PUINT_8)&rCmdKey, sizeof(CMD_802_11_KEY));
 514
 515     rCmdKey.ucAddRemove = 0; // remove
 516     if(kalP2PGetRole(prAdapter->prGlueInfo) == 1) { /* group client */
 517         rCmdKey.ucIsAuthenticator = 0;
 518     }
 519     else { /* group owner */
 520         rCmdKey.ucIsAuthenticator = 1;
 521     }
 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);
 525
 526     return wlanoidSendSetQueryP2PCmd(prAdapter,
 527             CMD_ID_ADD_REMOVE_KEY,
 528             TRUE,
 529             FALSE,
 530             TRUE,
 531             nicCmdEventSetCommon,
 532             NULL,
 533             sizeof(CMD_802_11_KEY),
 534             (PUINT_8)&rCmdKey,
 535             pvSetBuffer,
 536             u4SetBufferLen
 537             );
 538 }
 539
 540 /*----------------------------------------------------------------------------*/
 541 /*!
 542 * \brief Setting the IP address for pattern search function.
 543 *
 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.
 551 *
 552 * \return WLAN_STATUS_SUCCESS
 553 * \return WLAN_STATUS_ADAPTER_NOT_READY
 554 * \return WLAN_STATUS_INVALID_LENGTH
 555 */
 556 /*----------------------------------------------------------------------------*/
 557 WLAN_STATUS
 558 wlanoidSetP2pNetworkAddress(
 559     IN  P_ADAPTER_T prAdapter,
 560     IN  PVOID       pvSetBuffer,
 561     IN  UINT_32     u4SetBufferLen,
 562     OUT PUINT_32    pu4SetInfoLen
 563     )
 564 {
 565     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
 566     UINT_32 i, j;
 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;
 572
 573     DEBUGFUNC("wlanoidSetP2pNetworkAddress");
 574     DBGLOG(INIT, TRACE, ("\n"));
 575
 576     ASSERT(prAdapter);
 577     ASSERT(pu4SetInfoLen);
 578
 579     *pu4SetInfoLen = 4;
 580
 581     if (u4SetBufferLen < sizeof(PARAM_NETWORK_ADDRESS_LIST)) {
 582         return WLAN_STATUS_INVALID_DATA;
 583     }
 584
 585     *pu4SetInfoLen = 0;
 586     u4IpAddressCount = 0;
 587
 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)) {
 592             u4IpAddressCount++;
 593         }
 594
 595         prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
 596             (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
 597     }
 598
 599     // construct payload of command packet
 600     u4CmdSize = OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress) +
 601         sizeof(IPV4_NETWORK_ADDRESS) * u4IpAddressCount;
 602
 603     prCmdNetworkAddressList = (P_CMD_SET_NETWORK_ADDRESS_LIST) kalMemAlloc(u4CmdSize, VIR_MEM_TYPE);
 604
 605     if(prCmdNetworkAddressList == NULL)
 606         return WLAN_STATUS_FAILURE;
 607
 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;
 616
 617             kalMemCopy(prCmdNetworkAddressList->arNetAddress[j].aucIpAddr,
 618                     &(prNetAddrIp->in_addr),
 619                     sizeof(UINT_32));
 620
 621             j++;
 622         }
 623
 624         prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
 625             (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
 626     }
 627
 628     rStatus = wlanSendSetQueryCmd(prAdapter,
 629             CMD_ID_SET_IP_ADDRESS,
 630             TRUE,
 631             FALSE,
 632             TRUE,
 633             nicCmdEventSetIpAddress,
 634             nicOidCmdTimeoutCommon,
 635             u4CmdSize,
 636             (PUINT_8)prCmdNetworkAddressList,
 637             pvSetBuffer,
 638             u4SetBufferLen
 639             );
 640
 641     kalMemFree(prCmdNetworkAddressList, VIR_MEM_TYPE, u4CmdSize);
 642     return rStatus;
 643 }
 644
 645 /*----------------------------------------------------------------------------*/
 646 /*!
 647 * \brief This routine is used to query the power save profile.
 648 *
 649 * \param[in] prAdapter Pointer to the Adapter structure.
 650 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
 651 *                           the query.
 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.
 657 *
 658 * \return WLAN_STATUS_SUCCESS
 659 */
 660 /*----------------------------------------------------------------------------*/
 661 WLAN_STATUS
 662 wlanoidQueryP2pPowerSaveProfile (
 663     IN  P_ADAPTER_T prAdapter,
 664     IN  PVOID       pvQueryBuffer,
 665     IN  UINT_32     u4QueryBufferLen,
 666     OUT PUINT_32    pu4QueryInfoLen
 667     )
 668 {
 669     DEBUGFUNC("wlanoidQueryP2pPowerSaveProfile");
 670
 671     ASSERT(prAdapter);
 672     ASSERT(pu4QueryInfoLen);
 673
 674     if (u4QueryBufferLen!=0) {
 675         ASSERT(pvQueryBuffer);
 676
 677         *(PPARAM_POWER_MODE) pvQueryBuffer = (PARAM_POWER_MODE)(prAdapter->rWlanInfo.arPowerSaveMode[NETWORK_TYPE_P2P_INDEX].ucPsProfile);
 678         *pu4QueryInfoLen = sizeof(PARAM_POWER_MODE);
 679     }
 680
 681     return WLAN_STATUS_SUCCESS;
 682 }
 683
 684 /*----------------------------------------------------------------------------*/
 685 /*!
 686 * \brief This routine is used to set the power save profile.
 687 *
 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.
 695 *
 696 * \retval WLAN_STATUS_SUCCESS
 697 * \retval WLAN_STATUS_INVALID_LENGTH
 698 */
 699 /*----------------------------------------------------------------------------*/
 700 WLAN_STATUS
 701 wlanoidSetP2pPowerSaveProfile (
 702     IN  P_ADAPTER_T prAdapter,
 703     IN  PVOID       pvSetBuffer,
 704     IN  UINT_32     u4SetBufferLen,
 705     OUT PUINT_32    pu4SetInfoLen
 706     )
 707 {
 708     WLAN_STATUS status;
 709     PARAM_POWER_MODE ePowerMode;
 710     DEBUGFUNC("wlanoidSetP2pPowerSaveProfile");
 711
 712     ASSERT(prAdapter);
 713     ASSERT(pu4SetInfoLen);
 714
 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;
 719     }
 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;
 724     }
 725
 726     ePowerMode = *(PPARAM_POWER_MODE) pvSetBuffer;
 727
 728     if (prAdapter->fgEnCtiaPowerMode) {
 729         if (ePowerMode == Param_PowerModeCAM) {
 730
 731         } else {
 732             // User setting to PS mode (Param_PowerModeMAX_PSP or Param_PowerModeFast_PSP)
 733
 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;
 741             }
 742         }
 743     }
 744
 745     status = nicConfigPowerSaveProfile(
 746         prAdapter,
 747         NETWORK_TYPE_P2P_INDEX,
 748         ePowerMode,
 749         TRUE);
 750     return status;
 751 } /* end of wlanoidSetP2pPowerSaveProfile() */
 752
 753 /*----------------------------------------------------------------------------*/
 754 /*!
 755 * \brief This routine is used to set the power save profile.
 756 *
 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.
 764 *
 765 * \retval WLAN_STATUS_SUCCESS
 766 * \retval WLAN_STATUS_INVALID_LENGTH
 767 */
 768 /*----------------------------------------------------------------------------*/
 769 WLAN_STATUS
 770 wlanoidSetP2pSetNetworkAddress (
 771     IN  P_ADAPTER_T prAdapter,
 772     IN  PVOID       pvSetBuffer,
 773     IN  UINT_32     u4SetBufferLen,
 774     OUT PUINT_32    pu4SetInfoLen
 775     )
 776 {
 777     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
 778     UINT_32 i, j;
 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;
 785
 786     DEBUGFUNC("wlanoidSetP2pSetNetworkAddress");
 787     DBGLOG(INIT, TRACE, ("\n"));
 788     printk("wlanoidSetP2pSetNetworkAddress (%d)\n", (INT_16)u4SetBufferLen);
 789
 790     ASSERT(prAdapter);
 791     ASSERT(pu4SetInfoLen);
 792
 793     *pu4SetInfoLen = 4;
 794
 795     if (u4SetBufferLen < sizeof(PARAM_NETWORK_ADDRESS_LIST)) {
 796         return WLAN_STATUS_INVALID_DATA;
 797     }
 798
 799     *pu4SetInfoLen = 0;
 800     u4IpAddressCount = 0;
 801
 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)) {
 806             u4IpAddressCount++;
 807         }
 808
 809         prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
 810             (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
 811     }
 812
 813     // construct payload of command packet
 814     u4CmdSize = OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress) +
 815         sizeof(IPV4_NETWORK_ADDRESS) * u4IpAddressCount;
 816
 817         if (u4IpAddressCount == 0) {
 818                 u4CmdSize = sizeof(CMD_SET_NETWORK_ADDRESS_LIST);
 819         }
 820
 821     prCmdNetworkAddressList = (P_CMD_SET_NETWORK_ADDRESS_LIST) kalMemAlloc(u4CmdSize, VIR_MEM_TYPE);
 822
 823     if(prCmdNetworkAddressList == NULL)
 824         return WLAN_STATUS_FAILURE;
 825
 826     // fill P_CMD_SET_NETWORK_ADDRESS_LIST
 827     prCmdNetworkAddressList->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
 828
 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;
 833
 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;
 839
 840                 kalMemCopy(prCmdNetworkAddressList->arNetAddress[j].aucIpAddr,
 841                         &(prNetAddrIp->in_addr),
 842                         sizeof(UINT_32));
 843
 844                 j++;
 845
 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]);
 848             }
 849
 850             prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
 851                 (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
 852         }
 853
 854     } else {
 855         prCmdNetworkAddressList->ucAddressCount = 0;
 856     }
 857
 858     rStatus = wlanSendSetQueryCmd(prAdapter,
 859             CMD_ID_SET_IP_ADDRESS,
 860             TRUE,
 861             FALSE,
 862             TRUE,
 863             nicCmdEventSetIpAddress,
 864             nicOidCmdTimeoutCommon,
 865             u4CmdSize,
 866             (PUINT_8)prCmdNetworkAddressList,
 867             pvSetBuffer,
 868             u4SetBufferLen
 869             );
 870
 871     kalMemFree(prCmdNetworkAddressList, VIR_MEM_TYPE, u4CmdSize);
 872     return rStatus;
 873 } /* end of wlanoidSetP2pSetNetworkAddress() */
 874
 875
 876 /*----------------------------------------------------------------------------*/
 877 /*!
 878 * \brief This routine is called to set Multicast Address List.
 879 *
 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.
 887 *
 888 * \retval WLAN_STATUS_SUCCESS
 889 * \retval WLAN_STATUS_INVALID_LENGTH
 890 * \retval WLAN_STATUS_ADAPTER_NOT_READY
 891 * \retval WLAN_STATUS_MULTICAST_FULL
 892 */
 893 /*----------------------------------------------------------------------------*/
 894 WLAN_STATUS
 895 wlanoidSetP2PMulticastList(
 896     IN  P_ADAPTER_T prAdapter,
 897     IN  PVOID       pvSetBuffer,
 898     IN  UINT_32     u4SetBufferLen,
 899     OUT PUINT_32    pu4SetInfoLen
 900     )
 901 {
 902     CMD_MAC_MCAST_ADDR  rCmdMacMcastAddr;
 903     ASSERT(prAdapter);
 904     ASSERT(pu4SetInfoLen);
 905
 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));
 909
 910         *pu4SetInfoLen = (((u4SetBufferLen + MAC_ADDR_LEN) - 1) /
 911                 MAC_ADDR_LEN) * MAC_ADDR_LEN;
 912
 913          return WLAN_STATUS_INVALID_LENGTH;
 914     }
 915
 916     *pu4SetInfoLen = u4SetBufferLen;
 917
 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"));
 921
 922         return WLAN_STATUS_MULTICAST_FULL;
 923     }
 924
 925     /* NOTE(Kevin): Windows may set u4SetBufferLen == 0 &&
 926      * pvSetBuffer == NULL to clear exist Multicast List.
 927      */
 928     if (u4SetBufferLen) {
 929         ASSERT(pvSetBuffer);
 930     }
 931
 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;
 936     }
 937
 938     rCmdMacMcastAddr.u4NumOfGroupAddr = u4SetBufferLen / MAC_ADDR_LEN;
 939     rCmdMacMcastAddr.ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
 940     kalMemCopy(rCmdMacMcastAddr.arAddress, pvSetBuffer, u4SetBufferLen);
 941
 942     return wlanoidSendSetQueryP2PCmd(prAdapter,
 943             CMD_ID_MAC_MCAST_ADDR,
 944             TRUE,
 945             FALSE,
 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,
 951             pvSetBuffer,
 952             u4SetBufferLen
 953             );
 954
 955 } /* end of wlanoidSetP2PMulticastList() */
 956
 957
 958 /*----------------------------------------------------------------------------*/
 959 /*!
 960 * \brief This routine is called to send GAS frame for P2P Service Discovery Request
 961 *
 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.
 969 *
 970 * \retval WLAN_STATUS_SUCCESS
 971 * \retval WLAN_STATUS_INVALID_LENGTH
 972 * \retval WLAN_STATUS_ADAPTER_NOT_READY
 973 * \retval WLAN_STATUS_MULTICAST_FULL
 974 */
 975 /*----------------------------------------------------------------------------*/
 976 WLAN_STATUS
 977 wlanoidSendP2PSDRequest(
 978     IN  P_ADAPTER_T prAdapter,
 979     IN  PVOID       pvSetBuffer,
 980     IN  UINT_32     u4SetBufferLen,
 981     OUT PUINT_32    pu4SetInfoLen
 982     )
 983 {
 984     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
 985     ASSERT(prAdapter);
 986     ASSERT(pu4SetInfoLen);
 987
 988     if (u4SetBufferLen) {
 989         ASSERT(pvSetBuffer);
 990     }
 991
 992     if (u4SetBufferLen < sizeof(PARAM_P2P_SEND_SD_REQUEST)) {
 993         *pu4SetInfoLen = sizeof(PARAM_P2P_SEND_SD_REQUEST);
 994         return WLAN_STATUS_BUFFER_TOO_SHORT;
 995     }
 996
 997 //    rWlanStatus = p2pFsmRunEventSDRequest(prAdapter, (P_PARAM_P2P_SEND_SD_REQUEST)pvSetBuffer);
 998
 999     return rWlanStatus;
1000 } /* end of wlanoidSendP2PSDRequest() */
1001
1002
1003 /*----------------------------------------------------------------------------*/
1004 /*!
1005 * \brief This routine is called to send GAS frame for P2P Service Discovery Response
1006 *
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.
1014 *
1015 * \retval WLAN_STATUS_SUCCESS
1016 * \retval WLAN_STATUS_INVALID_LENGTH
1017 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1018 * \retval WLAN_STATUS_MULTICAST_FULL
1019 */
1020 /*----------------------------------------------------------------------------*/
1021 WLAN_STATUS
1022 wlanoidSendP2PSDResponse(
1023     IN  P_ADAPTER_T prAdapter,
1024     IN  PVOID       pvSetBuffer,
1025     IN  UINT_32     u4SetBufferLen,
1026     OUT PUINT_32    pu4SetInfoLen
1027     )
1028 {
1029     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1030     ASSERT(prAdapter);
1031     ASSERT(pu4SetInfoLen);
1032
1033     if (u4SetBufferLen) {
1034         ASSERT(pvSetBuffer);
1035     }
1036
1037     if (u4SetBufferLen < sizeof(PARAM_P2P_SEND_SD_RESPONSE)) {
1038         *pu4SetInfoLen = sizeof(PARAM_P2P_SEND_SD_RESPONSE);
1039         return WLAN_STATUS_BUFFER_TOO_SHORT;
1040     }
1041
1042 //    rWlanStatus = p2pFsmRunEventSDResponse(prAdapter, (P_PARAM_P2P_SEND_SD_RESPONSE)pvSetBuffer);
1043
1044     return rWlanStatus;
1045 } /* end of wlanoidGetP2PSDRequest() */
1046
1047
1048 /*----------------------------------------------------------------------------*/
1049 /*!
1050 * \brief This routine is called to get GAS frame for P2P Service Discovery Request
1051 *
1052 * \param[in]  prAdapter        Pointer to the Adapter structure.
1053 * \param[out] pvQueryBuffer    A pointer to the buffer that holds the result of
1054 *                              the query.
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.
1060 *
1061 * \retval WLAN_STATUS_SUCCESS
1062 * \retval WLAN_STATUS_INVALID_LENGTH
1063 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1064 * \retval WLAN_STATUS_MULTICAST_FULL
1065 */
1066 /*----------------------------------------------------------------------------*/
1067 WLAN_STATUS
1068 wlanoidGetP2PSDRequest(
1069     IN  P_ADAPTER_T prAdapter,
1070     IN  PVOID       pvQueryBuffer,
1071     IN  UINT_32     u4QueryBufferLen,
1072     OUT PUINT_32    pu4QueryInfoLen
1073     )
1074 {
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;
1082
1083     ASSERT(prAdapter);
1084     ASSERT(pu4QueryInfoLen);
1085
1086     if (u4QueryBufferLen) {
1087         ASSERT(pvQueryBuffer);
1088     }
1089
1090     if (u4QueryBufferLen < sizeof(PARAM_P2P_GET_SD_REQUEST)) {
1091         *pu4QueryInfoLen = sizeof(PARAM_P2P_GET_SD_REQUEST);
1092         return WLAN_STATUS_BUFFER_TOO_SHORT;
1093     }
1094
1095     DBGLOG(P2P, TRACE, ("Get Service Discovery Request\n"));
1096 #if 0
1097     if ((ucVersionNum = p2pFuncGetVersionNumOfSD(prAdapter)) == 0) {
1098         P_PARAM_P2P_GET_SD_REQUEST prP2pGetSdReq = (P_PARAM_P2P_GET_SD_REQUEST)pvQueryBuffer;
1099
1100         pucPacketBuffer = prP2pGetSdReq->aucPacketContent;
1101         pu2PacketLength = &prP2pGetSdReq->u2PacketLength;
1102         pucTA = &prP2pGetSdReq->rTransmitterAddr;
1103     }
1104     else {
1105         P_PARAM_P2P_GET_SD_REQUEST_EX prP2pGetSdReqEx = (P_PARAM_P2P_GET_SD_REQUEST_EX)NULL;
1106
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;
1113     }
1114
1115
1116     rWlanStatus = p2pFuncGetServiceDiscoveryFrame(prAdapter,
1117                                             pucPacketBuffer,
1118                                             (u4QueryBufferLen - sizeof(PARAM_P2P_GET_SD_REQUEST)),
1119                                             (PUINT_32)pu2PacketLength,
1120                                             pucChannelNum,
1121                                             ucSeqNum);
1122 #else
1123     *pu4QueryInfoLen = 0;
1124     return rWlanStatus;
1125 #endif
1126
1127     prWlanHdr = (P_WLAN_MAC_HEADER_T)pucPacketBuffer;
1128
1129     kalMemCopy(pucTA, prWlanHdr->aucAddr2, MAC_ADDR_LEN);
1130
1131     if (pu4QueryInfoLen) {
1132         if (ucVersionNum == 0) {
1133             *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_REQUEST) + (*pu2PacketLength));
1134         }
1135         else {
1136             *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_REQUEST_EX) + (*pu2PacketLength));
1137         }
1138
1139     }
1140
1141     return rWlanStatus;
1142 } /* end of wlanoidGetP2PSDRequest() */
1143
1144
1145 /*----------------------------------------------------------------------------*/
1146 /*!
1147 * \brief This routine is called to get GAS frame for P2P Service Discovery Response
1148 *
1149 * \param[in]  prAdapter        Pointer to the Adapter structure.
1150 * \param[out] pvQueryBuffer    A pointer to the buffer that holds the result of
1151 *                              the query.
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.
1157 *
1158 * \retval WLAN_STATUS_SUCCESS
1159 * \retval WLAN_STATUS_INVALID_LENGTH
1160 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1161 * \retval WLAN_STATUS_MULTICAST_FULL
1162 */
1163 /*----------------------------------------------------------------------------*/
1164 WLAN_STATUS
1165 wlanoidGetP2PSDResponse(
1166     IN  P_ADAPTER_T prAdapter,
1167     IN  PVOID       pvQueryBuffer,
1168     IN  UINT_32     u4QueryBufferLen,
1169     OUT PUINT_32    pu4QueryInfoLen
1170     )
1171 {
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;
1178
1179     ASSERT(prAdapter);
1180     ASSERT(pu4QueryInfoLen);
1181
1182     if (u4QueryBufferLen) {
1183         ASSERT(pvQueryBuffer);
1184     }
1185
1186     if (u4QueryBufferLen < sizeof(PARAM_P2P_GET_SD_RESPONSE)) {
1187         *pu4QueryInfoLen = sizeof(PARAM_P2P_GET_SD_RESPONSE);
1188         return WLAN_STATUS_BUFFER_TOO_SHORT;
1189     }
1190
1191     DBGLOG(P2P, TRACE, ("Get Service Discovery Response\n"));
1192
1193 #if 0
1194     if ((ucVersionNum = p2pFuncGetVersionNumOfSD(prAdapter)) == 0) {
1195         P_PARAM_P2P_GET_SD_RESPONSE prP2pGetSdRsp = (P_PARAM_P2P_GET_SD_RESPONSE)NULL;
1196
1197         prP2pGetSdRsp = (P_PARAM_P2P_GET_SD_REQUEST)pvQueryBuffer;
1198         pucPacketContent = prP2pGetSdRsp->aucPacketContent;
1199         pucTA = &prP2pGetSdRsp->rTransmitterAddr;
1200         pu2PacketLength = &prP2pGetSdRsp->u2PacketLength;
1201     }
1202     else {
1203         P_PARAM_P2P_GET_SD_RESPONSE_EX prP2pGetSdRspEx = (P_PARAM_P2P_GET_SD_RESPONSE_EX)NULL;
1204
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;
1210     }
1211
1212
1213 //    rWlanStatus = p2pFuncGetServiceDiscoveryFrame(prAdapter,
1214 //                    pucPacketContent,
1215 //                    (u4QueryBufferLen - sizeof(PARAM_P2P_GET_SD_RESPONSE)),
1216 //                    (PUINT_32)pu2PacketLength,
1217 //                    NULL,
1218 //                    ucSeqNum);
1219 #else
1220     *pu4QueryInfoLen = 0;
1221     return rWlanStatus;
1222 #endif
1223     prWlanHdr = (P_WLAN_MAC_HEADER_T)pucPacketContent;
1224
1225     kalMemCopy(pucTA, prWlanHdr->aucAddr2, MAC_ADDR_LEN);
1226
1227
1228     if (pu4QueryInfoLen) {
1229         if (ucVersionNum == 0) {
1230             *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_RESPONSE) + *pu2PacketLength);
1231         }
1232         else {
1233             *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_RESPONSE_EX) + *pu2PacketLength);
1234         }
1235     }
1236
1237     return rWlanStatus;
1238 } /* end of wlanoidGetP2PSDResponse() */
1239
1240
1241 /*----------------------------------------------------------------------------*/
1242 /*!
1243 * \brief This routine is called to terminate P2P Service Discovery Phase
1244 *
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.
1252 *
1253 * \retval WLAN_STATUS_SUCCESS
1254 * \retval WLAN_STATUS_INVALID_LENGTH
1255 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1256 * \retval WLAN_STATUS_MULTICAST_FULL
1257 */
1258 /*----------------------------------------------------------------------------*/
1259 WLAN_STATUS
1260 wlanoidSetP2PTerminateSDPhase(
1261     IN  P_ADAPTER_T prAdapter,
1262     IN  PVOID       pvSetBuffer,
1263     IN  UINT_32     u4SetBufferLen,
1264     OUT PUINT_32    pu4SetInfoLen
1265     )
1266 {
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;
1270
1271     do {
1272         if ((prAdapter == NULL) || (pu4SetInfoLen == NULL)) {
1273             break;
1274         }
1275
1276
1277         if ((u4SetBufferLen) && (pvSetBuffer == NULL)) {
1278             break;
1279         }
1280
1281         if (u4SetBufferLen < sizeof(PARAM_P2P_TERMINATE_SD_PHASE)) {
1282             *pu4SetInfoLen = sizeof(PARAM_P2P_TERMINATE_SD_PHASE);
1283             rWlanStatus = WLAN_STATUS_BUFFER_TOO_SHORT;
1284             break;
1285         }
1286
1287         prP2pTerminateSD = (P_PARAM_P2P_TERMINATE_SD_PHASE)pvSetBuffer;
1288
1289         if (EQUAL_MAC_ADDR(prP2pTerminateSD->rPeerAddr, aucNullAddr)) {
1290             DBGLOG(P2P, TRACE, ("Service Discovery Version 2.0\n"));
1291 //            p2pFuncSetVersionNumOfSD(prAdapter, 2);
1292         }
1293
1294         //rWlanStatus = p2pFsmRunEventSDAbort(prAdapter);
1295
1296     } while (FALSE);
1297
1298
1299
1300
1301
1302     return rWlanStatus;
1303 } /* end of wlanoidSetP2PTerminateSDPhase() */
1304
1305
1306 #if CFG_SUPPORT_ANTI_PIRACY
1307 /*----------------------------------------------------------------------------*/
1308 /*!
1309 * \brief This routine is called to
1310 *
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.
1318 *
1319 * \retval WLAN_STATUS_SUCCESS
1320 * \retval WLAN_STATUS_INVALID_LENGTH
1321 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1322 * \retval WLAN_STATUS_MULTICAST_FULL
1323 */
1324 /*----------------------------------------------------------------------------*/
1325 WLAN_STATUS
1326 wlanoidSetSecCheckRequest(
1327     IN  P_ADAPTER_T prAdapter,
1328     IN  PVOID       pvSetBuffer,
1329     IN  UINT_32     u4SetBufferLen,
1330     OUT PUINT_32    pu4SetInfoLen
1331     )
1332 {
1333     ASSERT(prAdapter);
1334     ASSERT(pu4SetInfoLen);
1335
1336     if (u4SetBufferLen) {
1337         ASSERT(pvSetBuffer);
1338     }
1339
1340     return wlanoidSendSetQueryP2PCmd(prAdapter,
1341             CMD_ID_SEC_CHECK,
1342             FALSE,
1343             TRUE,
1344             TRUE,
1345             NULL,
1346             nicOidCmdTimeoutCommon,
1347             u4SetBufferLen,
1348             (PUINT_8)pvSetBuffer,
1349             pvSetBuffer,
1350             u4SetBufferLen
1351             );
1352
1353 } /* end of wlanoidSetSecCheckRequest() */
1354
1355
1356 /*----------------------------------------------------------------------------*/
1357 /*!
1358 * \brief This routine is called to
1359 *
1360 * \param[in]  prAdapter        Pointer to the Adapter structure.
1361 * \param[out] pvQueryBuffer    A pointer to the buffer that holds the result of
1362 *                              the query.
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.
1368 *
1369 * \retval WLAN_STATUS_SUCCESS
1370 * \retval WLAN_STATUS_INVALID_LENGTH
1371 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1372 * \retval WLAN_STATUS_MULTICAST_FULL
1373 */
1374 /*----------------------------------------------------------------------------*/
1375 WLAN_STATUS
1376 wlanoidGetSecCheckResponse(
1377     IN  P_ADAPTER_T prAdapter,
1378     IN  PVOID       pvQueryBuffer,
1379     IN  UINT_32     u4QueryBufferLen,
1380     OUT PUINT_32    pu4QueryInfoLen
1381     )
1382 {
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;
1386
1387     prGlueInfo = prAdapter->prGlueInfo;
1388
1389     ASSERT(prAdapter);
1390     ASSERT(pu4QueryInfoLen);
1391
1392     if (u4QueryBufferLen) {
1393         ASSERT(pvQueryBuffer);
1394     }
1395
1396     if (u4QueryBufferLen > 256) {
1397         u4QueryBufferLen = 256;
1398     }
1399
1400     *pu4QueryInfoLen = u4QueryBufferLen;
1401
1402     #if DBG
1403     DBGLOG_MEM8(SEC, LOUD, prGlueInfo->prP2PInfo->aucSecCheckRsp, u4QueryBufferLen);
1404     #endif
1405     kalMemCopy((PUINT_8)(pvQueryBuffer + OFFSET_OF(IW_P2P_TRANSPORT_STRUCT, aucBuffer)), prGlueInfo->prP2PInfo->aucSecCheckRsp, u4QueryBufferLen);
1406
1407     return rWlanStatus;
1408 } /* end of wlanoidGetSecCheckResponse() */
1409 #endif
1410
1411 WLAN_STATUS
1412 wlanoidSetNoaParam (
1413     IN  P_ADAPTER_T       prAdapter,
1414     IN  PVOID             pvSetBuffer,
1415     IN  UINT_32           u4SetBufferLen,
1416     OUT PUINT_32          pu4SetInfoLen
1417     )
1418 {
1419     P_PARAM_CUSTOM_NOA_PARAM_STRUC_T prNoaParam;
1420     CMD_CUSTOM_NOA_PARAM_STRUC_T rCmdNoaParam;
1421
1422     DEBUGFUNC("wlanoidSetNoaParam");
1423     DBGLOG(INIT, TRACE,("\n"));
1424
1425     ASSERT(prAdapter);
1426     ASSERT(pu4SetInfoLen);
1427
1428     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_NOA_PARAM_STRUC_T);
1429
1430     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_NOA_PARAM_STRUC_T)) {
1431         return WLAN_STATUS_INVALID_LENGTH;
1432     }
1433
1434     ASSERT(pvSetBuffer);
1435
1436     prNoaParam = (P_PARAM_CUSTOM_NOA_PARAM_STRUC_T)pvSetBuffer;
1437
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;
1442
1443 #if 0
1444     return wlanSendSetQueryCmd(prAdapter,
1445             CMD_ID_SET_NOA_PARAM,
1446             TRUE,
1447             FALSE,
1448             TRUE,
1449             nicCmdEventSetCommon,
1450             nicOidCmdTimeoutCommon,
1451             sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T),
1452             (PUINT_8)&rCmdNoaParam,
1453             pvSetBuffer,
1454             u4SetBufferLen
1455             );
1456 #else
1457     return wlanoidSendSetQueryP2PCmd(prAdapter,
1458             CMD_ID_SET_NOA_PARAM,
1459             TRUE,
1460             FALSE,
1461             TRUE,
1462             NULL,
1463             nicOidCmdTimeoutCommon,
1464             sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T),
1465             (PUINT_8)&rCmdNoaParam,
1466             pvSetBuffer,
1467             u4SetBufferLen
1468             );
1469
1470 #endif
1471
1472 }
1473
1474 WLAN_STATUS
1475 wlanoidSetOppPsParam (
1476     IN  P_ADAPTER_T       prAdapter,
1477     IN  PVOID             pvSetBuffer,
1478     IN  UINT_32           u4SetBufferLen,
1479     OUT PUINT_32          pu4SetInfoLen
1480     )
1481 {
1482     P_PARAM_CUSTOM_OPPPS_PARAM_STRUC_T prOppPsParam;
1483     CMD_CUSTOM_OPPPS_PARAM_STRUC_T rCmdOppPsParam;
1484
1485     DEBUGFUNC("wlanoidSetOppPsParam");
1486     DBGLOG(INIT, TRACE,("\n"));
1487
1488     ASSERT(prAdapter);
1489     ASSERT(pu4SetInfoLen);
1490
1491     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_OPPPS_PARAM_STRUC_T);
1492
1493     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_OPPPS_PARAM_STRUC_T)) {
1494         return WLAN_STATUS_INVALID_LENGTH;
1495     }
1496
1497     ASSERT(pvSetBuffer);
1498
1499     prOppPsParam = (P_PARAM_CUSTOM_OPPPS_PARAM_STRUC_T)pvSetBuffer;
1500
1501     kalMemZero(&rCmdOppPsParam, sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T));
1502     rCmdOppPsParam.u4CTwindowMs = prOppPsParam->u4CTwindowMs;
1503
1504 #if 0
1505     return wlanSendSetQueryCmd(prAdapter,
1506             CMD_ID_SET_OPPPS_PARAM,
1507             TRUE,
1508             FALSE,
1509             TRUE,
1510             nicCmdEventSetCommon,
1511             nicOidCmdTimeoutCommon,
1512             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1513             (PUINT_8)&rCmdOppPsParam,
1514             pvSetBuffer,
1515             u4SetBufferLen
1516             );
1517 #else
1518     return wlanoidSendSetQueryP2PCmd(prAdapter,
1519             CMD_ID_SET_NOA_PARAM,
1520             TRUE,
1521             FALSE,
1522             TRUE,
1523             NULL,
1524             nicOidCmdTimeoutCommon,
1525             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1526             (PUINT_8)&rCmdOppPsParam,
1527             pvSetBuffer,
1528             u4SetBufferLen
1529             );
1530
1531 #endif
1532
1533 }
1534
1535 WLAN_STATUS
1536 wlanoidSetUApsdParam (
1537     IN  P_ADAPTER_T       prAdapter,
1538     IN  PVOID             pvSetBuffer,
1539     IN  UINT_32           u4SetBufferLen,
1540     OUT PUINT_32          pu4SetInfoLen
1541     )
1542 {
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;
1547
1548
1549     DEBUGFUNC("wlanoidSetUApsdParam");
1550     DBGLOG(INIT, TRACE,("\n"));
1551
1552     ASSERT(prAdapter);
1553     ASSERT(pu4SetInfoLen);
1554
1555     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_UAPSD_PARAM_STRUC_T);
1556
1557     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_UAPSD_PARAM_STRUC_T)) {
1558         return WLAN_STATUS_INVALID_LENGTH;
1559     }
1560
1561     ASSERT(pvSetBuffer);
1562
1563     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1564     prPmProfSetupInfo = &prBssInfo->rPmProfSetupInfo;
1565
1566     prUapsdParam = (P_PARAM_CUSTOM_UAPSD_PARAM_STRUC_T)pvSetBuffer;
1567
1568     kalMemZero(&rCmdUapsdParam, sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T));
1569     rCmdUapsdParam.fgEnAPSD = prUapsdParam->fgEnAPSD;
1570     prAdapter->rWifiVar.fgSupportUAPSD = prUapsdParam->fgEnAPSD;
1571
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));
1586
1587     rCmdUapsdParam.ucMaxSpLen = prUapsdParam->ucMaxSpLen;
1588     prPmProfSetupInfo->ucUapsdSp  = prUapsdParam->ucMaxSpLen;
1589
1590 #if 0
1591     return wlanSendSetQueryCmd(prAdapter,
1592             CMD_ID_SET_UAPSD_PARAM,
1593             TRUE,
1594             FALSE,
1595             TRUE,
1596             nicCmdEventSetCommon,
1597             nicOidCmdTimeoutCommon,
1598             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1599             (PUINT_8)&rCmdUapsdParam,
1600             pvSetBuffer,
1601             u4SetBufferLen
1602             );
1603  #else
1604     return wlanoidSendSetQueryP2PCmd(prAdapter,
1605             CMD_ID_SET_UAPSD_PARAM,
1606             TRUE,
1607             FALSE,
1608             TRUE,
1609             NULL,
1610             nicOidCmdTimeoutCommon,
1611             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1612             (PUINT_8)&rCmdUapsdParam,
1613             pvSetBuffer,
1614             u4SetBufferLen
1615             );
1616
1617 #endif
1618 }
1619
1620
1621
1622 WLAN_STATUS
1623 wlanoidQueryP2pOpChannel (
1624     IN P_ADAPTER_T prAdapter,
1625     IN PVOID pvQueryBuffer,
1626     IN UINT_32 u4QueryBufferLen,
1627     OUT PUINT_32 pu4QueryInfoLen
1628     )
1629 {
1630
1631     WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1632 //    PUINT_8 pucOpChnl = (PUINT_8)pvQueryBuffer;
1633
1634     do {
1635         if ((prAdapter == NULL) || (pu4QueryInfoLen == NULL)) {
1636             break;
1637         }
1638
1639
1640         if ((u4QueryBufferLen) && (pvQueryBuffer == NULL)) {
1641             break;
1642         }
1643
1644         if (u4QueryBufferLen < sizeof(UINT_8)) {
1645             *pu4QueryInfoLen = sizeof(UINT_8);
1646             rResult = WLAN_STATUS_BUFFER_TOO_SHORT;
1647             break;
1648         }
1649
1650 #if 0
1651         if (!p2pFuncGetCurrentOpChnl(prAdapter, pucOpChnl)) {
1652             rResult = WLAN_STATUS_INVALID_DATA;
1653             break;
1654         }
1655 #else
1656         rResult = WLAN_STATUS_INVALID_DATA;
1657         break;
1658 #endif
1659
1660         *pu4QueryInfoLen = sizeof(UINT_8);
1661         rResult = WLAN_STATUS_SUCCESS;
1662
1663     } while (FALSE);
1664
1665     return rResult;
1666 } /* wlanoidQueryP2pOpChannel */
1667
1668 WLAN_STATUS
1669 wlanoidQueryP2pVersion (
1670     IN P_ADAPTER_T prAdapter,
1671     IN PVOID pvQueryBuffer,
1672     IN UINT_32 u4QueryBufferLen,
1673     OUT PUINT_32 pu4QueryInfoLen
1674     )
1675 {
1676     WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1677 //    PUINT_8 pucVersionNum = (PUINT_8)pvQueryBuffer;
1678
1679     do {
1680         if ((prAdapter == NULL) || (pu4QueryInfoLen == NULL)) {
1681             break;
1682         }
1683
1684
1685         if ((u4QueryBufferLen) && (pvQueryBuffer == NULL)) {
1686             break;
1687         }
1688
1689         if (u4QueryBufferLen < sizeof(UINT_8)) {
1690             *pu4QueryInfoLen = sizeof(UINT_8);
1691             rResult = WLAN_STATUS_BUFFER_TOO_SHORT;
1692             break;
1693         }
1694
1695     } while (FALSE);
1696
1697     return rResult;
1698 } /* wlanoidQueryP2pVersion */
1699
1700 WLAN_STATUS
1701 wlanoidSetP2pSupplicantVersion (
1702     IN  P_ADAPTER_T       prAdapter,
1703     IN  PVOID             pvSetBuffer,
1704     IN  UINT_32           u4SetBufferLen,
1705     OUT PUINT_32          pu4SetInfoLen
1706     )
1707 {
1708     WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1709     UINT_8 ucVersionNum;
1710
1711     do {
1712         if ((prAdapter == NULL) || (pu4SetInfoLen == NULL)) {
1713
1714             rResult = WLAN_STATUS_INVALID_DATA;
1715             break;
1716         }
1717
1718         if ((u4SetBufferLen) && (pvSetBuffer == NULL)) {
1719             rResult = WLAN_STATUS_INVALID_DATA;
1720             break;
1721         }
1722
1723         *pu4SetInfoLen = sizeof(UINT_8);
1724
1725         if (u4SetBufferLen < sizeof(UINT_8)) {
1726             rResult = WLAN_STATUS_INVALID_LENGTH;
1727             break;
1728         }
1729
1730
1731         ucVersionNum = *((PUINT_8)pvSetBuffer);
1732
1733
1734         rResult = WLAN_STATUS_SUCCESS;
1735     } while (FALSE);
1736
1737     return rResult;
1738 } /* wlanoidSetP2pSupplicantVersion */
1739
1740 #if CFG_SUPPORT_P2P_RSSI_QUERY
1741 WLAN_STATUS
1742 wlanoidQueryP2pRssi (
1743     IN P_ADAPTER_T prAdapter,
1744     IN PVOID pvQueryBuffer,
1745     IN UINT_32 u4QueryBufferLen,
1746     OUT PUINT_32 pu4QueryInfoLen
1747     )
1748 {
1749     DEBUGFUNC("wlanoidQueryP2pRssi");
1750
1751     ASSERT(prAdapter);
1752     ASSERT(pu4QueryInfoLen);
1753     if (u4QueryBufferLen) {
1754         ASSERT(pvQueryBuffer);
1755     }
1756
1757     *pu4QueryInfoLen = sizeof(PARAM_RSSI);
1758
1759     /* Check for query buffer length */
1760     if (u4QueryBufferLen < *pu4QueryInfoLen) {
1761         DBGLOG(REQ, WARN, ("Too short length %ld\n", u4QueryBufferLen));
1762         return WLAN_STATUS_BUFFER_TOO_SHORT;
1763     }
1764
1765     if (prAdapter->fgIsP2pLinkQualityValid == TRUE &&
1766             (kalGetTimeTick() - prAdapter->rP2pLinkQualityUpdateTime) <= CFG_LINK_QUALITY_VALID_PERIOD) {
1767         PARAM_RSSI rRssi;
1768
1769         rRssi = (PARAM_RSSI)prAdapter->rP2pLinkQuality.cRssi; // ranged from (-128 ~ 30) in unit of dBm
1770
1771         if(rRssi > PARAM_WHQL_RSSI_MAX_DBM)
1772             rRssi = PARAM_WHQL_RSSI_MAX_DBM;
1773         else if(rRssi < PARAM_WHQL_RSSI_MIN_DBM)
1774             rRssi = PARAM_WHQL_RSSI_MIN_DBM;
1775
1776         kalMemCopy(pvQueryBuffer, &rRssi, sizeof(PARAM_RSSI));
1777         return WLAN_STATUS_SUCCESS;
1778     }
1779
1780     #ifdef LINUX
1781     return wlanSendSetQueryCmd(prAdapter,
1782             CMD_ID_GET_LINK_QUALITY,
1783             FALSE,
1784             TRUE,
1785             TRUE,
1786             nicCmdEventQueryLinkQuality,
1787             nicOidCmdTimeoutCommon,
1788             *pu4QueryInfoLen,
1789             pvQueryBuffer,
1790             pvQueryBuffer,
1791             u4QueryBufferLen
1792             );
1793     #else
1794     return wlanSendSetQueryCmd(prAdapter,
1795             CMD_ID_GET_LINK_QUALITY,
1796             FALSE,
1797             TRUE,
1798             TRUE,
1799             nicCmdEventQueryLinkQuality,
1800             nicOidCmdTimeoutCommon,
1801             0,
1802             NULL,
1803             pvQueryBuffer,
1804             u4QueryBufferLen
1805             );
1806
1807     #endif
1808 } /* wlanoidQueryP2pRssi */
1809 #endif
1810
1811