drivers/net/wireless/rockchip_wlan/mt5931_kk/drv_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 * Copyright (c) 2007 MediaTek Inc.
  12 *
  13 * All rights reserved. Copying, compilation, modification, distribution
  14 * or any other use whatsoever of this material is strictly prohibited
  15 * except in accordance with a Software License Agreement with
  16 * MediaTek Inc.
  17 *******************************************************************************
  18 */
  19
  20 /******************************************************************************
  21 * LEGAL DISCLAIMER
  22 *
  23 * BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND
  24 * AGREES THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK
  25 * SOFTWARE") RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE
  26 * PROVIDED TO BUYER ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY
  27 * DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
  28 * LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  29 * PARTICULAR PURPOSE OR NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE
  30 * ANY WARRANTY WHATSOEVER WITH RESPECT TO THE SOFTWARE OF ANY THIRD PARTY
  31 * WHICH MAY BE USED BY, INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK
  32 * SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY
  33 * WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE
  34 * FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S SPECIFICATION OR TO
  35 * CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  36 *
  37 * BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  38 * LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL
  39 * BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT
  40 * ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY
  41 * BUYER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  42 *
  43 * THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  44 * WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT
  45 * OF LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING
  46 * THEREOF AND RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN
  47 * FRANCISCO, CA, UNDER THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE
  48 * (ICC).
  49 *******************************************************************************
  50 */
  51
  52 /*
  53 ** $Log: wlan_p2p.c $
  54  *
  55  * 07 17 2012 yuche.tsai
  56  * NULL
  57  * Compile no error before trial run.
  58  *
  59  * 11 24 2011 yuche.tsai
  60  * NULL
  61  * Fix P2P IOCTL of multicast address bug, add low power driver stop control.
  62  *
  63  * 11 22 2011 yuche.tsai
  64  * NULL
  65  * Update RSSI link quality of P2P Network query method. (Bug fix)
  66  *
  67  * 11 19 2011 yuche.tsai
  68  * NULL
  69  * Add RSSI support for P2P network.
  70  *
  71  * 11 08 2011 yuche.tsai
  72  * [WCXRP00001094] [Volunteer Patch][Driver] Driver version & supplicant version query & set support for service discovery version check.
  73  * Add support for driver version query & p2p supplicant verseion set.
  74  * For new service discovery mechanism sync.
  75  *
  76  * 10 18 2011 yuche.tsai
  77  * [WCXRP00001045] [WiFi Direct][Driver] Check 2.1 branch.
  78  * Support Channle Query.
  79  *
  80  * 10 18 2011 yuche.tsai
  81  * [WCXRP00001045] [WiFi Direct][Driver] Check 2.1 branch.
  82  * New 2.1 branch
  83
  84  *
  85  * 08 23 2011 yuche.tsai
  86  * NULL
  87  * Fix Multicast Issue of P2P.
  88  *
  89  * 04 27 2011 george.huang
  90  * [WCXRP00000684] [MT6620 Wi-Fi][Driver] Support P2P setting ARP filter
  91  * Support P2P ARP filter setting on early suspend/ late resume
  92  *
  93  * 04 08 2011 george.huang
  94  * [WCXRP00000621] [MT6620 Wi-Fi][Driver] Support P2P supplicant to set power mode
  95  * separate settings of P2P and AIS
  96  *
  97  * 03 22 2011 george.huang
  98  * [WCXRP00000504] [MT6620 Wi-Fi][FW] Support Sigma CAPI for power saving related command
  99  * link with supplicant commands
 100  *
 101  * 03 17 2011 wh.su
 102  * [WCXRP00000571] [MT6620 Wi-Fi] [Driver] Not check the p2p role during set key
 103  * Skip the p2p role for adding broadcast key issue.
 104  *
 105  * 03 16 2011 wh.su
 106  * [WCXRP00000530] [MT6620 Wi-Fi] [Driver] skip doing p2pRunEventAAAComplete after send assoc response Tx Done
 107  * fixed compiling error while enable dbg.
 108  *
 109  * 03 08 2011 yuche.tsai
 110  * [WCXRP00000480] [Volunteer Patch][MT6620][Driver] WCS IE format issue[WCXRP00000509] [Volunteer Patch][MT6620][Driver] Kernal panic when remove p2p module.
 111  * .
 112  *
 113  * 03 07 2011 terry.wu
 114  * [WCXRP00000521] [MT6620 Wi-Fi][Driver] Remove non-standard debug message
 115  * Toggle non-standard debug messages to comments.
 116  *
 117  * 03 07 2011 wh.su
 118  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
 119  * rename the define to anti_pviracy.
 120  *
 121  * 03 05 2011 wh.su
 122  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
 123  * add the code to get the check rsponse and indicate to app.
 124  *
 125  * 03 02 2011 wh.su
 126  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
 127  * Add Security check related code.
 128  *
 129  * 03 02 2011 yuche.tsai
 130  * [WCXRP00000245] 1. Invitation Request/Response.
 131 2. Provision Discovery Request/Response
 132
 133  * Fix SD Request Query Length issue.
 134  *
 135  * 03 02 2011 yuche.tsai
 136  * [WCXRP00000245] 1. Invitation Request/Response.
 137 2. Provision Discovery Request/Response
 138
 139  * Service Discovery Request.
 140  *
 141  * 03 01 2011 yuche.tsai
 142  * [WCXRP00000245] 1. Invitation Request/Response.
 143 2. Provision Discovery Request/Response
 144
 145  * Update Service Discovery Wlan OID related function.
 146  *
 147  * 03 01 2011 yuche.tsai
 148  * [WCXRP00000245] 1. Invitation Request/Response.
 149 2. Provision Discovery Request/Response
 150
 151  * Update Service Discovery Related wlanoid function.
 152  *
 153  * 02 09 2011 yuche.tsai
 154  * [WCXRP00000245] 1. Invitation Request/Response.
 155 2. Provision Discovery Request/Response
 156
 157  * Add Service Discovery Indication Related code.
 158  *
 159  * 01 26 2011 yuche.tsai
 160  * [WCXRP00000245] 1. Invitation Request/Response.
 161 2. Provision Discovery Request/Response
 162
 163  * Add Service Discovery Function.
 164  *
 165  * 01 05 2011 cp.wu
 166  * [WCXRP00000283] [MT6620 Wi-Fi][Driver][Wi-Fi Direct] Implementation of interface for supporting Wi-Fi Direct Service Discovery
 167  * ioctl implementations for P2P Service Discovery
 168  *
 169  * 01 04 2011 cp.wu
 170  * [WCXRP00000338] [MT6620 Wi-Fi][Driver] Separate kalMemAlloc into kmalloc and vmalloc implementations to ease physically continous memory demands
 171  * separate kalMemAlloc() into virtually-continous and physically-continous type to ease slab system pressure
 172  *
 173  * 12 22 2010 cp.wu
 174  * [WCXRP00000283] [MT6620 Wi-Fi][Driver][Wi-Fi Direct] Implementation of interface for supporting Wi-Fi Direct Service Discovery
 175  * 1. header file restructure for more clear module isolation
 176  * 2. add function interface definition for implementing Service Discovery callbacks
 177  *
 178  * 10 04 2010 cp.wu
 179  * [WCXRP00000077] [MT6620 Wi-Fi][Driver][FW] Eliminate use of ENUM_NETWORK_TYPE_T and replaced by ENUM_NETWORK_TYPE_INDEX_T only
 180  * remove ENUM_NETWORK_TYPE_T definitions
 181  *
 182  * 09 28 2010 wh.su
 183  * NULL
 184  * [WCXRP00000069][MT6620 Wi-Fi][Driver] Fix some code for phase 1 P2P Demo.
 185  *
 186  * 09 21 2010 kevin.huang
 187  * [WCXRP00000054] [MT6620 Wi-Fi][Driver] Restructure driver for second Interface
 188  * Isolate P2P related function for Hardware Software Bundle
 189  *
 190  * 09 03 2010 kevin.huang
 191  * NULL
 192  * Refine #include sequence and solve recursive/nested #include issue
 193  *
 194  * 08 23 2010 cp.wu
 195  * NULL
 196  * revise constant definitions to be matched with implementation (original cmd-event definition is deprecated)
 197  *
 198  * 08 16 2010 cp.wu
 199  * NULL
 200  * add subroutines for P2P to set multicast list.
 201  *
 202  * 08 16 2010 george.huang
 203  * NULL
 204  * .
 205  *
 206  * 08 16 2010 george.huang
 207  * NULL
 208  * support wlanoidSetP2pPowerSaveProfile() in P2P
 209  *
 210  * 08 16 2010 george.huang
 211  * NULL
 212  * Support wlanoidSetNetworkAddress() for P2P
 213  *
 214  * 07 08 2010 cp.wu
 215  *
 216  * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
 217  *
 218  * 06 25 2010 cp.wu
 219  * [WPD00003833][MT6620 and MT5931] Driver migration
 220  * add API in que_mgt to retrieve sta-rec index for security frames.
 221  *
 222  * 06 24 2010 cp.wu
 223  * [WPD00003833][MT6620 and MT5931] Driver migration
 224  * 802.1x and bluetooth-over-Wi-Fi security frames are now delievered to firmware via command path instead of data path.
 225  *
 226  * 06 11 2010 cp.wu
 227  * [WPD00003833][MT6620 and MT5931] Driver migration
 228  * 1) migrate assoc.c.
 229  * 2) add ucTxSeqNum for tracking frames which needs TX-DONE awareness
 230  * 3) add configuration options for CNM_MEM and RSN modules
 231  * 4) add data path for management frames
 232  * 5) eliminate rPacketInfo of MSDU_INFO_T
 233  *
 234  * 06 06 2010 kevin.huang
 235  * [WPD00003832][MT6620 5931] Create driver base
 236  * [MT6620 5931] Create driver base
 237  *
 238  * 05 17 2010 cp.wu
 239  * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 240  * 1) add timeout handler mechanism for pending command packets
 241  * 2) add p2p add/removal key
 242  *
 243 **
 244 */
 245
 246 /******************************************************************************
 247 *                         C O M P I L E R   F L A G S
 248 *******************************************************************************
 249 */
 250
 251 /******************************************************************************
 252 *                    E X T E R N A L   R E F E R E N C E S
 253 *******************************************************************************
 254 */
 255 #include "precomp.h"
 256
 257 /******************************************************************************
 258 *                              C O N S T A N T S
 259 *******************************************************************************
 260 */
 261
 262 /******************************************************************************
 263 *                             D A T A   T Y P E S
 264 *******************************************************************************
 265 */
 266
 267 /******************************************************************************
 268 *                            P U B L I C   D A T A
 269 *******************************************************************************
 270 */
 271
 272 /******************************************************************************
 273 *                           P R I V A T E   D A T A
 274 *******************************************************************************
 275 */
 276
 277 /******************************************************************************
 278 *                                 M A C R O S
 279 *******************************************************************************
 280 */
 281
 282 /******************************************************************************
 283 *                   F U N C T I O N   D E C L A R A T I O N S
 284 *******************************************************************************
 285 */
 286
 287 /******************************************************************************
 288 *                              F U N C T I O N S
 289 *******************************************************************************
 290 */
 291 /*----------------------------------------------------------------------------*/
 292 /*!
 293 * \brief command packet generation utility
 294 *
 295 * \param[in] prAdapter          Pointer to the Adapter structure.
 296 * \param[in] ucCID              Command ID
 297 * \param[in] fgSetQuery         Set or Query
 298 * \param[in] fgNeedResp         Need for response
 299 * \param[in] pfCmdDoneHandler   Function pointer when command is done
 300 * \param[in] u4SetQueryInfoLen  The length of the set/query buffer
 301 * \param[in] pucInfoBuffer      Pointer to set/query buffer
 302 *
 303 *
 304 * \retval WLAN_STATUS_PENDING
 305 * \retval WLAN_STATUS_FAILURE
 306 */
 307 /*----------------------------------------------------------------------------*/
 308 WLAN_STATUS
 309 wlanoidSendSetQueryP2PCmd (
 310     IN P_ADAPTER_T  prAdapter,
 311     UINT_8          ucCID,
 312     BOOLEAN         fgSetQuery,
 313     BOOLEAN         fgNeedResp,
 314     BOOLEAN         fgIsOid,
 315     PFN_CMD_DONE_HANDLER pfCmdDoneHandler,
 316     PFN_CMD_TIMEOUT_HANDLER pfCmdTimeoutHandler,
 317     UINT_32         u4SetQueryInfoLen,
 318     PUINT_8         pucInfoBuffer,
 319     OUT PVOID       pvSetQueryBuffer,
 320     IN UINT_32      u4SetQueryBufferLen
 321     )
 322 {
 323     P_GLUE_INFO_T prGlueInfo;
 324     P_CMD_INFO_T prCmdInfo;
 325     P_WIFI_CMD_T prWifiCmd;
 326     UINT_8 ucCmdSeqNum;
 327
 328     ASSERT(prAdapter);
 329
 330     prGlueInfo = prAdapter->prGlueInfo;
 331     ASSERT(prGlueInfo);
 332
 333     DEBUGFUNC("wlanoidSendSetQueryP2PCmd");
 334     DBGLOG(REQ, TRACE, ("Command ID = 0x%08X\n", ucCID));
 335
 336     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + u4SetQueryInfoLen));
 337
 338     if (!prCmdInfo) {
 339         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
 340         return WLAN_STATUS_FAILURE;
 341     }
 342
 343     // increase command sequence number
 344     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
 345     DBGLOG(REQ, TRACE, ("ucCmdSeqNum =%d\n", ucCmdSeqNum));
 346
 347     // Setup common CMD Info Packet
 348     prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
 349     prCmdInfo->eNetworkType = NETWORK_TYPE_P2P_INDEX;
 350     prCmdInfo->u2InfoBufLen = (UINT_16)(CMD_HDR_SIZE + u4SetQueryInfoLen);
 351     prCmdInfo->pfCmdDoneHandler = pfCmdDoneHandler;
 352     prCmdInfo->pfCmdTimeoutHandler = pfCmdTimeoutHandler;
 353     prCmdInfo->fgIsOid = fgIsOid;
 354     prCmdInfo->ucCID = ucCID;
 355     prCmdInfo->fgSetQuery = fgSetQuery;
 356     prCmdInfo->fgNeedResp = fgNeedResp;
 357     prCmdInfo->fgDriverDomainMCR = FALSE;
 358     prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
 359     prCmdInfo->u4SetInfoLen = u4SetQueryInfoLen;
 360     prCmdInfo->pvInformationBuffer = pvSetQueryBuffer;
 361     prCmdInfo->u4InformationBufferLength = u4SetQueryBufferLen;
 362
 363     // Setup WIFI_CMD_T (no payload)
 364     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
 365     prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
 366     prWifiCmd->ucCID = prCmdInfo->ucCID;
 367     prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
 368     prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
 369
 370     if(u4SetQueryInfoLen > 0 && pucInfoBuffer != NULL) {
 371         kalMemCopy(prWifiCmd->aucBuffer, pucInfoBuffer, u4SetQueryInfoLen);
 372     }
 373
 374     // insert into prCmdQueue
 375     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
 376
 377     // wakeup txServiceThread later
 378     GLUE_SET_EVENT(prGlueInfo);
 379     return WLAN_STATUS_PENDING;
 380 }
 381
 382 /*----------------------------------------------------------------------------*/
 383 /*!
 384 * \brief This routine is called to set a key to Wi-Fi Direct driver
 385 *
 386 * \param[in] prAdapter Pointer to the Adapter structure.
 387 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
 388 * \param[in] u4SetBufferLen The length of the set buffer.
 389 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
 390 *                          bytes read from the set buffer. If the call failed
 391 *                          due to invalid length of the set buffer, returns
 392 *                          the amount of storage needed.
 393 *
 394 * \retval WLAN_STATUS_SUCCESS
 395 * \retval WLAN_STATUS_ADAPTER_NOT_READY
 396 * \retval WLAN_STATUS_INVALID_LENGTH
 397 * \retval WLAN_STATUS_INVALID_DATA
 398 */
 399 /*----------------------------------------------------------------------------*/
 400 WLAN_STATUS
 401 wlanoidSetAddP2PKey(
 402     IN  P_ADAPTER_T prAdapter,
 403     IN  PVOID       pvSetBuffer,
 404     IN  UINT_32     u4SetBufferLen,
 405     OUT PUINT_32    pu4SetInfoLen
 406     )
 407 {
 408     CMD_802_11_KEY rCmdKey;
 409     P_PARAM_KEY_T prNewKey;
 410
 411     DEBUGFUNC("wlanoidSetAddP2PKey");
 412     DBGLOG(REQ, INFO, ("\n"));
 413
 414     ASSERT(prAdapter);
 415     ASSERT(pvSetBuffer);
 416     ASSERT(pu4SetInfoLen);
 417
 418     prNewKey = (P_PARAM_KEY_T) pvSetBuffer;
 419
 420     /* Verify the key structure length. */
 421     if (prNewKey->u4Length > u4SetBufferLen) {
 422         DBGLOG(REQ, WARN, ("Invalid key structure length (%d) greater than total buffer length (%d)\n",
 423                     (UINT_8)prNewKey->u4Length,
 424                     (UINT_8)u4SetBufferLen));
 425
 426         *pu4SetInfoLen = u4SetBufferLen;
 427         return WLAN_STATUS_INVALID_LENGTH;
 428     }
 429     /* Verify the key material length for key material buffer */
 430     else if (prNewKey->u4KeyLength > prNewKey->u4Length - OFFSET_OF(PARAM_KEY_T, aucKeyMaterial)) {
 431         DBGLOG(REQ, WARN, ("Invalid key material length (%d)\n", (UINT_8)prNewKey->u4KeyLength));
 432         *pu4SetInfoLen = u4SetBufferLen;
 433         return WLAN_STATUS_INVALID_DATA;
 434     }
 435     /* Exception check */
 436     else if (prNewKey->u4KeyIndex & 0x0fffff00) {
 437         return WLAN_STATUS_INVALID_DATA;
 438     }
 439     /* Exception check, pairwise key must with transmit bit enabled */
 440     else if ((prNewKey->u4KeyIndex & BITS(30,31)) == IS_UNICAST_KEY) {
 441         return WLAN_STATUS_INVALID_DATA;
 442     }
 443     else if (!(prNewKey->u4KeyLength == CCMP_KEY_LEN) && !(prNewKey->u4KeyLength == TKIP_KEY_LEN)) {
 444         return WLAN_STATUS_INVALID_DATA;
 445     }
 446     /* Exception check, pairwise key must with transmit bit enabled */
 447     else if ((prNewKey->u4KeyIndex & BITS(30,31)) == BITS(30,31)) {
 448         if (((prNewKey->u4KeyIndex & 0xff) != 0) ||
 449                 ((prNewKey->arBSSID[0] == 0xff) && (prNewKey->arBSSID[1] == 0xff) && (prNewKey->arBSSID[2] == 0xff) &&
 450                  (prNewKey->arBSSID[3] == 0xff) && (prNewKey->arBSSID[4] == 0xff) && (prNewKey->arBSSID[5] == 0xff))) {
 451             return WLAN_STATUS_INVALID_DATA;
 452         }
 453     }
 454
 455     *pu4SetInfoLen = u4SetBufferLen;
 456
 457     // fill CMD_802_11_KEY
 458     kalMemZero(&rCmdKey, sizeof(CMD_802_11_KEY));
 459     rCmdKey.ucAddRemove = 1; /* add */
 460     rCmdKey.ucTxKey = ((prNewKey->u4KeyIndex & IS_TRANSMIT_KEY) == IS_TRANSMIT_KEY) ? 1 : 0;
 461     rCmdKey.ucKeyType = ((prNewKey->u4KeyIndex & IS_UNICAST_KEY) == IS_UNICAST_KEY) ? 1 : 0;
 462     if(kalP2PGetRole(prAdapter->prGlueInfo) == 1) { /* group client */
 463         rCmdKey.ucIsAuthenticator = 0;
 464     }
 465     else { /* group owner */
 466         rCmdKey.ucIsAuthenticator = 1;
 467     }
 468     COPY_MAC_ADDR(rCmdKey.aucPeerAddr, prNewKey->arBSSID);
 469     rCmdKey.ucNetType = NETWORK_TYPE_P2P_INDEX;
 470         if(prNewKey->u4KeyLength == CCMP_KEY_LEN)
 471     rCmdKey.ucAlgorithmId = CIPHER_SUITE_CCMP; // AES
 472     else if(prNewKey->u4KeyLength == TKIP_KEY_LEN)
 473                 rCmdKey.ucAlgorithmId = CIPHER_SUITE_TKIP; // TKIP
 474     rCmdKey.ucKeyId = (UINT_8)(prNewKey->u4KeyIndex & 0xff);
 475     rCmdKey.ucKeyLen = (UINT_8)prNewKey->u4KeyLength;
 476     kalMemCopy(rCmdKey.aucKeyMaterial, (PUINT_8)prNewKey->aucKeyMaterial, rCmdKey.ucKeyLen);
 477
 478     return wlanoidSendSetQueryP2PCmd(prAdapter,
 479             CMD_ID_ADD_REMOVE_KEY,
 480             TRUE,
 481             FALSE,
 482             TRUE,
 483             nicCmdEventSetCommon,
 484             NULL,
 485             sizeof(CMD_802_11_KEY),
 486             (PUINT_8)&rCmdKey,
 487             pvSetBuffer,
 488             u4SetBufferLen
 489             );
 490 }
 491
 492
 493 /*----------------------------------------------------------------------------*/
 494 /*!
 495 * \brief This routine is called to request Wi-Fi Direct driver to remove keys
 496 *
 497 * \param[in] prAdapter Pointer to the Adapter structure.
 498 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
 499 * \param[in] u4SetBufferLen The length of the set buffer.
 500 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
 501 *                          bytes read from the set buffer. If the call failed
 502 *                          due to invalid length of the set buffer, returns
 503 *                          the amount of storage needed.
 504 *
 505 * \retval WLAN_STATUS_SUCCESS
 506 * \retval WLAN_STATUS_INVALID_DATA
 507 * \retval WLAN_STATUS_INVALID_LENGTH
 508 * \retval WLAN_STATUS_INVALID_DATA
 509 */
 510 /*----------------------------------------------------------------------------*/
 511 WLAN_STATUS
 512 wlanoidSetRemoveP2PKey(
 513     IN  P_ADAPTER_T prAdapter,
 514     IN  PVOID       pvSetBuffer,
 515     IN  UINT_32     u4SetBufferLen,
 516     OUT PUINT_32    pu4SetInfoLen
 517     )
 518 {
 519     CMD_802_11_KEY rCmdKey;
 520     P_PARAM_REMOVE_KEY_T prRemovedKey;
 521
 522     DEBUGFUNC("wlanoidSetRemoveP2PKey");
 523     ASSERT(prAdapter);
 524
 525     if (u4SetBufferLen < sizeof(PARAM_REMOVE_KEY_T)) {
 526         return WLAN_STATUS_INVALID_LENGTH;
 527     }
 528
 529     ASSERT(pvSetBuffer);
 530     prRemovedKey = (P_PARAM_REMOVE_KEY_T)pvSetBuffer;
 531
 532     /* Check bit 31: this bit should always 0 */
 533     if (prRemovedKey->u4KeyIndex & IS_TRANSMIT_KEY) {
 534         /* Bit 31 should not be set */
 535         DBGLOG(REQ, ERROR, ("invalid key index: 0x%08lx\n",
 536                     prRemovedKey->u4KeyIndex));
 537         return WLAN_STATUS_INVALID_DATA;
 538     }
 539
 540     /* Check bits 8 ~ 29 should always be 0 */
 541     if (prRemovedKey->u4KeyIndex & BITS(8, 29)) {
 542         /* Bit 31 should not be set */
 543         DBGLOG(REQ, ERROR, ("invalid key index: 0x%08lx\n",
 544                     prRemovedKey->u4KeyIndex));
 545         return WLAN_STATUS_INVALID_DATA;
 546     }
 547
 548     /* There should not be any key operation for P2P Device */
 549     if(kalP2PGetRole(prAdapter->prGlueInfo) == 0) {
 550     //    return WLAN_STATUS_NOT_ACCEPTED;
 551     }
 552
 553     kalMemZero((PUINT_8)&rCmdKey, sizeof(CMD_802_11_KEY));
 554
 555     rCmdKey.ucAddRemove = 0; // remove
 556     if(kalP2PGetRole(prAdapter->prGlueInfo) == 1) { /* group client */
 557         rCmdKey.ucIsAuthenticator = 0;
 558     }
 559     else { /* group owner */
 560         rCmdKey.ucIsAuthenticator = 1;
 561     }
 562     kalMemCopy(rCmdKey.aucPeerAddr, (PUINT_8)prRemovedKey->arBSSID, MAC_ADDR_LEN);
 563     rCmdKey.ucNetType = NETWORK_TYPE_P2P_INDEX;
 564     rCmdKey.ucKeyId = (UINT_8)(prRemovedKey->u4KeyIndex & 0x000000ff);
 565
 566     return wlanoidSendSetQueryP2PCmd(prAdapter,
 567             CMD_ID_ADD_REMOVE_KEY,
 568             TRUE,
 569             FALSE,
 570             TRUE,
 571             nicCmdEventSetCommon,
 572             NULL,
 573             sizeof(CMD_802_11_KEY),
 574             (PUINT_8)&rCmdKey,
 575             pvSetBuffer,
 576             u4SetBufferLen
 577             );
 578 }
 579
 580 /*----------------------------------------------------------------------------*/
 581 /*!
 582 * \brief Setting the IP address for pattern search function.
 583 *
 584 * \param[in] prAdapter Pointer to the Adapter structure.
 585 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
 586 * \param[in] u4SetBufferLen The length of the set buffer.
 587 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
 588 *                           bytes read from the set buffer. If the call failed
 589 *                           due to invalid length of the set buffer, returns
 590 *                           the amount of storage needed.
 591 *
 592 * \return WLAN_STATUS_SUCCESS
 593 * \return WLAN_STATUS_ADAPTER_NOT_READY
 594 * \return WLAN_STATUS_INVALID_LENGTH
 595 */
 596 /*----------------------------------------------------------------------------*/
 597 WLAN_STATUS
 598 wlanoidSetP2pNetworkAddress(
 599     IN  P_ADAPTER_T prAdapter,
 600     IN  PVOID       pvSetBuffer,
 601     IN  UINT_32     u4SetBufferLen,
 602     OUT PUINT_32    pu4SetInfoLen
 603     )
 604 {
 605     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
 606     UINT_32 i, j;
 607     P_CMD_SET_NETWORK_ADDRESS_LIST prCmdNetworkAddressList;
 608     P_PARAM_NETWORK_ADDRESS_LIST prNetworkAddressList = (P_PARAM_NETWORK_ADDRESS_LIST)pvSetBuffer;
 609     P_PARAM_NETWORK_ADDRESS prNetworkAddress;
 610     P_PARAM_NETWORK_ADDRESS_IP prNetAddrIp;
 611     UINT_32 u4IpAddressCount, u4CmdSize;
 612
 613     DEBUGFUNC("wlanoidSetP2pNetworkAddress");
 614     DBGLOG(INIT, TRACE, ("\n"));
 615
 616     ASSERT(prAdapter);
 617     ASSERT(pu4SetInfoLen);
 618
 619     *pu4SetInfoLen = 4;
 620
 621     if (u4SetBufferLen < sizeof(PARAM_NETWORK_ADDRESS_LIST)) {
 622         return WLAN_STATUS_INVALID_DATA;
 623     }
 624
 625     *pu4SetInfoLen = 0;
 626     u4IpAddressCount = 0;
 627
 628     prNetworkAddress = prNetworkAddressList->arAddress;
 629     for ( i = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
 630         if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
 631                 prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
 632             u4IpAddressCount++;
 633         }
 634
 635         prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
 636             (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
 637     }
 638
 639     // construct payload of command packet
 640     u4CmdSize = OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress) +
 641         sizeof(IPV4_NETWORK_ADDRESS) * u4IpAddressCount;
 642
 643     prCmdNetworkAddressList = (P_CMD_SET_NETWORK_ADDRESS_LIST) kalMemAlloc(u4CmdSize, VIR_MEM_TYPE);
 644
 645     if(prCmdNetworkAddressList == NULL)
 646         return WLAN_STATUS_FAILURE;
 647
 648     // fill P_CMD_SET_NETWORK_ADDRESS_LIST
 649     prCmdNetworkAddressList->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
 650     prCmdNetworkAddressList->ucAddressCount = (UINT_8)u4IpAddressCount;
 651     prNetworkAddress = prNetworkAddressList->arAddress;
 652     for (i = 0, j = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
 653         if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
 654                 prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
 655             prNetAddrIp = (P_PARAM_NETWORK_ADDRESS_IP)prNetworkAddress->aucAddress;
 656
 657             kalMemCopy(prCmdNetworkAddressList->arNetAddress[j].aucIpAddr,
 658                     &(prNetAddrIp->in_addr),
 659                     sizeof(UINT_32));
 660
 661             j++;
 662         }
 663
 664         prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
 665             (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
 666     }
 667
 668     rStatus = wlanSendSetQueryCmd(prAdapter,
 669             CMD_ID_SET_IP_ADDRESS,
 670             TRUE,
 671             FALSE,
 672             TRUE,
 673             nicCmdEventSetIpAddress,
 674             nicOidCmdTimeoutCommon,
 675             u4CmdSize,
 676             (PUINT_8)prCmdNetworkAddressList,
 677             pvSetBuffer,
 678             u4SetBufferLen
 679             );
 680
 681     kalMemFree(prCmdNetworkAddressList, VIR_MEM_TYPE, u4CmdSize);
 682     return rStatus;
 683 }
 684
 685 /*----------------------------------------------------------------------------*/
 686 /*!
 687 * \brief This routine is used to query the power save profile.
 688 *
 689 * \param[in] prAdapter Pointer to the Adapter structure.
 690 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
 691 *                           the query.
 692 * \param[in] u4QueryBufLen The length of the query buffer.
 693 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
 694 *                            bytes written into the query buffer. If the call
 695 *                            failed due to invalid length of the query buffer,
 696 *                            returns the amount of storage needed.
 697 *
 698 * \return WLAN_STATUS_SUCCESS
 699 */
 700 /*----------------------------------------------------------------------------*/
 701 WLAN_STATUS
 702 wlanoidQueryP2pPowerSaveProfile (
 703     IN  P_ADAPTER_T prAdapter,
 704     IN  PVOID       pvQueryBuffer,
 705     IN  UINT_32     u4QueryBufferLen,
 706     OUT PUINT_32    pu4QueryInfoLen
 707     )
 708 {
 709     DEBUGFUNC("wlanoidQueryP2pPowerSaveProfile");
 710
 711     ASSERT(prAdapter);
 712     ASSERT(pu4QueryInfoLen);
 713
 714     if (u4QueryBufferLen!=0) {
 715         ASSERT(pvQueryBuffer);
 716
 717         *(PPARAM_POWER_MODE) pvQueryBuffer = (PARAM_POWER_MODE)(prAdapter->rWlanInfo.arPowerSaveMode[NETWORK_TYPE_P2P_INDEX].ucPsProfile);
 718         *pu4QueryInfoLen = sizeof(PARAM_POWER_MODE);
 719     }
 720
 721     return WLAN_STATUS_SUCCESS;
 722 }
 723
 724 /*----------------------------------------------------------------------------*/
 725 /*!
 726 * \brief This routine is used to set the power save profile.
 727 *
 728 * \param[in] pvAdapter Pointer to the Adapter structure.
 729 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
 730 * \param[in] u4SetBufferLen The length of the set buffer.
 731 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
 732 *                          bytes read from the set buffer. If the call failed
 733 *                          due to invalid length of the set buffer, returns
 734 *                          the amount of storage needed.
 735 *
 736 * \retval WLAN_STATUS_SUCCESS
 737 * \retval WLAN_STATUS_INVALID_LENGTH
 738 */
 739 /*----------------------------------------------------------------------------*/
 740 WLAN_STATUS
 741 wlanoidSetP2pPowerSaveProfile (
 742     IN  P_ADAPTER_T prAdapter,
 743     IN  PVOID       pvSetBuffer,
 744     IN  UINT_32     u4SetBufferLen,
 745     OUT PUINT_32    pu4SetInfoLen
 746     )
 747 {
 748     WLAN_STATUS status;
 749     PARAM_POWER_MODE ePowerMode;
 750     DEBUGFUNC("wlanoidSetP2pPowerSaveProfile");
 751
 752     ASSERT(prAdapter);
 753     ASSERT(pu4SetInfoLen);
 754
 755     *pu4SetInfoLen = sizeof(PARAM_POWER_MODE);
 756     if (u4SetBufferLen < sizeof(PARAM_POWER_MODE)) {
 757         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4SetBufferLen));
 758         return WLAN_STATUS_INVALID_LENGTH;
 759     }
 760     else if (*(PPARAM_POWER_MODE) pvSetBuffer >= Param_PowerModeMax) {
 761         WARNLOG(("Invalid power mode %d\n",
 762                     *(PPARAM_POWER_MODE) pvSetBuffer));
 763         return WLAN_STATUS_INVALID_DATA;
 764     }
 765
 766     ePowerMode = *(PPARAM_POWER_MODE) pvSetBuffer;
 767
 768     if (prAdapter->fgEnCtiaPowerMode) {
 769         if (ePowerMode == Param_PowerModeCAM) {
 770
 771         } else {
 772             // User setting to PS mode (Param_PowerModeMAX_PSP or Param_PowerModeFast_PSP)
 773
 774             if (prAdapter->u4CtiaPowerMode == 0) {
 775                 // force to keep in CAM mode
 776                 ePowerMode = Param_PowerModeCAM;
 777             } else if (prAdapter->u4CtiaPowerMode == 1) {
 778                 ePowerMode = Param_PowerModeMAX_PSP;
 779             } else if (prAdapter->u4CtiaPowerMode == 2) {
 780                 ePowerMode = Param_PowerModeFast_PSP;
 781             }
 782         }
 783     }
 784
 785     status = nicConfigPowerSaveProfile(
 786         prAdapter,
 787         NETWORK_TYPE_P2P_INDEX,
 788         ePowerMode,
 789         TRUE);
 790     return status;
 791 } /* end of wlanoidSetP2pPowerSaveProfile() */
 792
 793 /*----------------------------------------------------------------------------*/
 794 /*!
 795 * \brief This routine is used to set the power save profile.
 796 *
 797 * \param[in] pvAdapter Pointer to the Adapter structure.
 798 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
 799 * \param[in] u4SetBufferLen The length of the set buffer.
 800 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
 801 *                          bytes read from the set buffer. If the call failed
 802 *                          due to invalid length of the set buffer, returns
 803 *                          the amount of storage needed.
 804 *
 805 * \retval WLAN_STATUS_SUCCESS
 806 * \retval WLAN_STATUS_INVALID_LENGTH
 807 */
 808 /*----------------------------------------------------------------------------*/
 809 WLAN_STATUS
 810 wlanoidSetP2pSetNetworkAddress (
 811     IN  P_ADAPTER_T prAdapter,
 812     IN  PVOID       pvSetBuffer,
 813     IN  UINT_32     u4SetBufferLen,
 814     OUT PUINT_32    pu4SetInfoLen
 815     )
 816 {
 817     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
 818     UINT_32 i, j;
 819     P_CMD_SET_NETWORK_ADDRESS_LIST prCmdNetworkAddressList;
 820     P_PARAM_NETWORK_ADDRESS_LIST prNetworkAddressList = (P_PARAM_NETWORK_ADDRESS_LIST)pvSetBuffer;
 821     P_PARAM_NETWORK_ADDRESS prNetworkAddress;
 822     P_PARAM_NETWORK_ADDRESS_IP prNetAddrIp;
 823     UINT_32 u4IpAddressCount, u4CmdSize;
 824         PUINT_8 pucBuf = (PUINT_8)pvSetBuffer;
 825
 826     DEBUGFUNC("wlanoidSetP2pSetNetworkAddress");
 827     DBGLOG(INIT, TRACE, ("\n"));
 828     printk("wlanoidSetP2pSetNetworkAddress (%d)\n", (INT_16)u4SetBufferLen);
 829
 830     ASSERT(prAdapter);
 831     ASSERT(pu4SetInfoLen);
 832
 833     *pu4SetInfoLen = 4;
 834
 835     if (u4SetBufferLen < sizeof(PARAM_NETWORK_ADDRESS_LIST)) {
 836         return WLAN_STATUS_INVALID_DATA;
 837     }
 838
 839     *pu4SetInfoLen = 0;
 840     u4IpAddressCount = 0;
 841
 842     prNetworkAddress = prNetworkAddressList->arAddress;
 843     for ( i = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
 844         if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
 845                 prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
 846             u4IpAddressCount++;
 847         }
 848
 849         prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
 850             (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
 851     }
 852
 853     // construct payload of command packet
 854     u4CmdSize = OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress) +
 855         sizeof(IPV4_NETWORK_ADDRESS) * u4IpAddressCount;
 856
 857         if (u4IpAddressCount == 0) {
 858                 u4CmdSize = sizeof(CMD_SET_NETWORK_ADDRESS_LIST);
 859         }
 860
 861     prCmdNetworkAddressList = (P_CMD_SET_NETWORK_ADDRESS_LIST) kalMemAlloc(u4CmdSize, VIR_MEM_TYPE);
 862
 863     if(prCmdNetworkAddressList == NULL)
 864         return WLAN_STATUS_FAILURE;
 865
 866     // fill P_CMD_SET_NETWORK_ADDRESS_LIST
 867     prCmdNetworkAddressList->ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
 868
 869     /* only to set IP address to FW once ARP filter is enabled */
 870     if (prAdapter->fgEnArpFilter) {
 871         prCmdNetworkAddressList->ucAddressCount = (UINT_8)u4IpAddressCount;
 872         prNetworkAddress = prNetworkAddressList->arAddress;
 873
 874         printk("u4IpAddressCount (%ld) \n", (INT_32)u4IpAddressCount);
 875         for (i = 0, j = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
 876             if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
 877                     prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
 878                 prNetAddrIp = (P_PARAM_NETWORK_ADDRESS_IP)prNetworkAddress->aucAddress;
 879
 880                 kalMemCopy(prCmdNetworkAddressList->arNetAddress[j].aucIpAddr,
 881                         &(prNetAddrIp->in_addr),
 882                         sizeof(UINT_32));
 883
 884                 j++;
 885
 886                 pucBuf = (PUINT_8)&prNetAddrIp->in_addr;
 887                 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]);
 888             }
 889
 890             prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
 891                 (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
 892         }
 893
 894     } else {
 895         prCmdNetworkAddressList->ucAddressCount = 0;
 896     }
 897
 898     rStatus = wlanSendSetQueryCmd(prAdapter,
 899             CMD_ID_SET_IP_ADDRESS,
 900             TRUE,
 901             FALSE,
 902             TRUE,
 903             nicCmdEventSetIpAddress,
 904             nicOidCmdTimeoutCommon,
 905             u4CmdSize,
 906             (PUINT_8)prCmdNetworkAddressList,
 907             pvSetBuffer,
 908             u4SetBufferLen
 909             );
 910
 911     kalMemFree(prCmdNetworkAddressList, VIR_MEM_TYPE, u4CmdSize);
 912     return rStatus;
 913 } /* end of wlanoidSetP2pSetNetworkAddress() */
 914
 915
 916 /*----------------------------------------------------------------------------*/
 917 /*!
 918 * \brief This routine is called to set Multicast Address List.
 919 *
 920 * \param[in] prAdapter      Pointer to the Adapter structure.
 921 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
 922 * \param[in] u4SetBufferLen The length of the set buffer.
 923 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
 924 *                           bytes read from the set buffer. If the call failed
 925 *                           due to invalid length of the set buffer, returns
 926 *                           the amount of storage needed.
 927 *
 928 * \retval WLAN_STATUS_SUCCESS
 929 * \retval WLAN_STATUS_INVALID_LENGTH
 930 * \retval WLAN_STATUS_ADAPTER_NOT_READY
 931 * \retval WLAN_STATUS_MULTICAST_FULL
 932 */
 933 /*----------------------------------------------------------------------------*/
 934 WLAN_STATUS
 935 wlanoidSetP2PMulticastList(
 936     IN  P_ADAPTER_T prAdapter,
 937     IN  PVOID       pvSetBuffer,
 938     IN  UINT_32     u4SetBufferLen,
 939     OUT PUINT_32    pu4SetInfoLen
 940     )
 941 {
 942     CMD_MAC_MCAST_ADDR  rCmdMacMcastAddr;
 943     ASSERT(prAdapter);
 944     ASSERT(pu4SetInfoLen);
 945
 946     /* The data must be a multiple of the Ethernet address size. */
 947     if ((u4SetBufferLen % MAC_ADDR_LEN)) {
 948         DBGLOG(REQ, WARN, ("Invalid MC list length %ld\n", u4SetBufferLen));
 949
 950         *pu4SetInfoLen = (((u4SetBufferLen + MAC_ADDR_LEN) - 1) /
 951                 MAC_ADDR_LEN) * MAC_ADDR_LEN;
 952
 953          return WLAN_STATUS_INVALID_LENGTH;
 954     }
 955
 956     *pu4SetInfoLen = u4SetBufferLen;
 957
 958     /* Verify if we can support so many multicast addresses. */
 959     if ((u4SetBufferLen / MAC_ADDR_LEN) > MAX_NUM_GROUP_ADDR) {
 960         DBGLOG(REQ, WARN, ("Too many MC addresses\n"));
 961
 962         return WLAN_STATUS_MULTICAST_FULL;
 963     }
 964
 965     /* NOTE(Kevin): Windows may set u4SetBufferLen == 0 &&
 966      * pvSetBuffer == NULL to clear exist Multicast List.
 967      */
 968     if (u4SetBufferLen) {
 969         ASSERT(pvSetBuffer);
 970     }
 971
 972     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
 973         DBGLOG(REQ, WARN, ("Fail in set multicast list! (Adapter not ready). ACPI=D%d, Radio=%d\n",
 974                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
 975         return WLAN_STATUS_ADAPTER_NOT_READY;
 976     }
 977
 978     rCmdMacMcastAddr.u4NumOfGroupAddr = u4SetBufferLen / MAC_ADDR_LEN;
 979     rCmdMacMcastAddr.ucNetTypeIndex = NETWORK_TYPE_P2P_INDEX;
 980     kalMemCopy(rCmdMacMcastAddr.arAddress, pvSetBuffer, u4SetBufferLen);
 981
 982     return wlanoidSendSetQueryP2PCmd(prAdapter,
 983             CMD_ID_MAC_MCAST_ADDR,
 984             TRUE,
 985             FALSE,
 986             FALSE,              // This CMD response is no need to complete the OID. Or the event would unsync.
 987             nicCmdEventSetCommon,
 988             nicOidCmdTimeoutCommon,
 989             sizeof(CMD_MAC_MCAST_ADDR),
 990             (PUINT_8)&rCmdMacMcastAddr,
 991             pvSetBuffer,
 992             u4SetBufferLen
 993             );
 994
 995 } /* end of wlanoidSetP2PMulticastList() */
 996
 997
 998 /*----------------------------------------------------------------------------*/
 999 /*!
1000 * \brief This routine is called to send GAS frame for P2P Service Discovery Request
1001 *
1002 * \param[in] prAdapter      Pointer to the Adapter structure.
1003 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
1004 * \param[in] u4SetBufferLen The length of the set buffer.
1005 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1006 *                           bytes read from the set buffer. If the call failed
1007 *                           due to invalid length of the set buffer, returns
1008 *                           the amount of storage needed.
1009 *
1010 * \retval WLAN_STATUS_SUCCESS
1011 * \retval WLAN_STATUS_INVALID_LENGTH
1012 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1013 * \retval WLAN_STATUS_MULTICAST_FULL
1014 */
1015 /*----------------------------------------------------------------------------*/
1016 WLAN_STATUS
1017 wlanoidSendP2PSDRequest(
1018     IN  P_ADAPTER_T prAdapter,
1019     IN  PVOID       pvSetBuffer,
1020     IN  UINT_32     u4SetBufferLen,
1021     OUT PUINT_32    pu4SetInfoLen
1022     )
1023 {
1024     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1025     ASSERT(prAdapter);
1026     ASSERT(pu4SetInfoLen);
1027
1028     if (u4SetBufferLen) {
1029         ASSERT(pvSetBuffer);
1030     }
1031
1032     if (u4SetBufferLen < sizeof(PARAM_P2P_SEND_SD_REQUEST)) {
1033         *pu4SetInfoLen = sizeof(PARAM_P2P_SEND_SD_REQUEST);
1034         return WLAN_STATUS_BUFFER_TOO_SHORT;
1035     }
1036
1037 //    rWlanStatus = p2pFsmRunEventSDRequest(prAdapter, (P_PARAM_P2P_SEND_SD_REQUEST)pvSetBuffer);
1038
1039     return rWlanStatus;
1040 } /* end of wlanoidSendP2PSDRequest() */
1041
1042
1043 /*----------------------------------------------------------------------------*/
1044 /*!
1045 * \brief This routine is called to send GAS frame for P2P Service Discovery Response
1046 *
1047 * \param[in] prAdapter      Pointer to the Adapter structure.
1048 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
1049 * \param[in] u4SetBufferLen The length of the set buffer.
1050 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1051 *                           bytes read from the set buffer. If the call failed
1052 *                           due to invalid length of the set buffer, returns
1053 *                           the amount of storage needed.
1054 *
1055 * \retval WLAN_STATUS_SUCCESS
1056 * \retval WLAN_STATUS_INVALID_LENGTH
1057 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1058 * \retval WLAN_STATUS_MULTICAST_FULL
1059 */
1060 /*----------------------------------------------------------------------------*/
1061 WLAN_STATUS
1062 wlanoidSendP2PSDResponse(
1063     IN  P_ADAPTER_T prAdapter,
1064     IN  PVOID       pvSetBuffer,
1065     IN  UINT_32     u4SetBufferLen,
1066     OUT PUINT_32    pu4SetInfoLen
1067     )
1068 {
1069     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1070     ASSERT(prAdapter);
1071     ASSERT(pu4SetInfoLen);
1072
1073     if (u4SetBufferLen) {
1074         ASSERT(pvSetBuffer);
1075     }
1076
1077     if (u4SetBufferLen < sizeof(PARAM_P2P_SEND_SD_RESPONSE)) {
1078         *pu4SetInfoLen = sizeof(PARAM_P2P_SEND_SD_RESPONSE);
1079         return WLAN_STATUS_BUFFER_TOO_SHORT;
1080     }
1081
1082 //    rWlanStatus = p2pFsmRunEventSDResponse(prAdapter, (P_PARAM_P2P_SEND_SD_RESPONSE)pvSetBuffer);
1083
1084     return rWlanStatus;
1085 } /* end of wlanoidGetP2PSDRequest() */
1086
1087
1088 /*----------------------------------------------------------------------------*/
1089 /*!
1090 * \brief This routine is called to get GAS frame for P2P Service Discovery Request
1091 *
1092 * \param[in]  prAdapter        Pointer to the Adapter structure.
1093 * \param[out] pvQueryBuffer    A pointer to the buffer that holds the result of
1094 *                              the query.
1095 * \param[in]  u4QueryBufferLen The length of the query buffer.
1096 * \param[out] pu4QueryInfoLen  If the call is successful, returns the number of
1097 *                              bytes written into the query buffer. If the call
1098 *                              failed due to invalid length of the query buffer,
1099 *                              returns the amount of storage needed.
1100 *
1101 * \retval WLAN_STATUS_SUCCESS
1102 * \retval WLAN_STATUS_INVALID_LENGTH
1103 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1104 * \retval WLAN_STATUS_MULTICAST_FULL
1105 */
1106 /*----------------------------------------------------------------------------*/
1107 WLAN_STATUS
1108 wlanoidGetP2PSDRequest(
1109     IN  P_ADAPTER_T prAdapter,
1110     IN  PVOID       pvQueryBuffer,
1111     IN  UINT_32     u4QueryBufferLen,
1112     OUT PUINT_32    pu4QueryInfoLen
1113     )
1114 {
1115     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1116     PUINT_8 pucPacketBuffer = NULL, pucTA = NULL;
1117 //    PUINT_8 pucChannelNum = NULL;
1118     PUINT_16 pu2PacketLength = NULL;
1119     P_WLAN_MAC_HEADER_T prWlanHdr = (P_WLAN_MAC_HEADER_T)NULL;
1120     UINT_8 ucVersionNum = 0;
1121 //    UINT_8 ucChannelNum = 0, ucSeqNum = 0;
1122
1123     ASSERT(prAdapter);
1124     ASSERT(pu4QueryInfoLen);
1125
1126     if (u4QueryBufferLen) {
1127         ASSERT(pvQueryBuffer);
1128     }
1129
1130     if (u4QueryBufferLen < sizeof(PARAM_P2P_GET_SD_REQUEST)) {
1131         *pu4QueryInfoLen = sizeof(PARAM_P2P_GET_SD_REQUEST);
1132         return WLAN_STATUS_BUFFER_TOO_SHORT;
1133     }
1134
1135     DBGLOG(P2P, TRACE, ("Get Service Discovery Request\n"));
1136 #if 0
1137     if ((ucVersionNum = p2pFuncGetVersionNumOfSD(prAdapter)) == 0) {
1138         P_PARAM_P2P_GET_SD_REQUEST prP2pGetSdReq = (P_PARAM_P2P_GET_SD_REQUEST)pvQueryBuffer;
1139
1140         pucPacketBuffer = prP2pGetSdReq->aucPacketContent;
1141         pu2PacketLength = &prP2pGetSdReq->u2PacketLength;
1142         pucTA = &prP2pGetSdReq->rTransmitterAddr;
1143     }
1144     else {
1145         P_PARAM_P2P_GET_SD_REQUEST_EX prP2pGetSdReqEx = (P_PARAM_P2P_GET_SD_REQUEST_EX)NULL;
1146
1147         prP2pGetSdReqEx = (P_PARAM_P2P_GET_SD_REQUEST)pvQueryBuffer;
1148         pucPacketBuffer = prP2pGetSdReqEx->aucPacketContent;
1149         pu2PacketLength = &prP2pGetSdReqEx->u2PacketLength;
1150         pucTA = &prP2pGetSdReqEx->rTransmitterAddr;
1151         pucChannelNum = &prP2pGetSdReqEx->ucChannelNum;
1152         ucSeqNum = prP2pGetSdReqEx->ucSeqNum;
1153     }
1154
1155
1156     rWlanStatus = p2pFuncGetServiceDiscoveryFrame(prAdapter,
1157                                             pucPacketBuffer,
1158                                             (u4QueryBufferLen - sizeof(PARAM_P2P_GET_SD_REQUEST)),
1159                                             (PUINT_32)pu2PacketLength,
1160                                             pucChannelNum,
1161                                             ucSeqNum);
1162 #else
1163     *pu4QueryInfoLen = 0;
1164     return rWlanStatus;
1165 #endif
1166
1167     prWlanHdr = (P_WLAN_MAC_HEADER_T)pucPacketBuffer;
1168
1169     kalMemCopy(pucTA, prWlanHdr->aucAddr2, MAC_ADDR_LEN);
1170
1171     if (pu4QueryInfoLen) {
1172         if (ucVersionNum == 0) {
1173             *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_REQUEST) + (*pu2PacketLength));
1174         }
1175         else {
1176             *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_REQUEST_EX) + (*pu2PacketLength));
1177         }
1178
1179     }
1180
1181     return rWlanStatus;
1182 } /* end of wlanoidGetP2PSDRequest() */
1183
1184
1185 /*----------------------------------------------------------------------------*/
1186 /*!
1187 * \brief This routine is called to get GAS frame for P2P Service Discovery Response
1188 *
1189 * \param[in]  prAdapter        Pointer to the Adapter structure.
1190 * \param[out] pvQueryBuffer    A pointer to the buffer that holds the result of
1191 *                              the query.
1192 * \param[in]  u4QueryBufferLen The length of the query buffer.
1193 * \param[out] pu4QueryInfoLen  If the call is successful, returns the number of
1194 *                              bytes written into the query buffer. If the call
1195 *                              failed due to invalid length of the query buffer,
1196 *                              returns the amount of storage needed.
1197 *
1198 * \retval WLAN_STATUS_SUCCESS
1199 * \retval WLAN_STATUS_INVALID_LENGTH
1200 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1201 * \retval WLAN_STATUS_MULTICAST_FULL
1202 */
1203 /*----------------------------------------------------------------------------*/
1204 WLAN_STATUS
1205 wlanoidGetP2PSDResponse(
1206     IN  P_ADAPTER_T prAdapter,
1207     IN  PVOID       pvQueryBuffer,
1208     IN  UINT_32     u4QueryBufferLen,
1209     OUT PUINT_32    pu4QueryInfoLen
1210     )
1211 {
1212     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1213     P_WLAN_MAC_HEADER_T prWlanHdr = (P_WLAN_MAC_HEADER_T)NULL;
1214     //UINT_8 ucSeqNum = 0,
1215     UINT_8 ucVersionNum = 0;
1216     PUINT_8 pucPacketContent = (PUINT_8)NULL, pucTA = (PUINT_8)NULL;
1217     PUINT_16 pu2PacketLength = (PUINT_16)NULL;
1218
1219     ASSERT(prAdapter);
1220     ASSERT(pu4QueryInfoLen);
1221
1222     if (u4QueryBufferLen) {
1223         ASSERT(pvQueryBuffer);
1224     }
1225
1226     if (u4QueryBufferLen < sizeof(PARAM_P2P_GET_SD_RESPONSE)) {
1227         *pu4QueryInfoLen = sizeof(PARAM_P2P_GET_SD_RESPONSE);
1228         return WLAN_STATUS_BUFFER_TOO_SHORT;
1229     }
1230
1231     DBGLOG(P2P, TRACE, ("Get Service Discovery Response\n"));
1232
1233 #if 0
1234     if ((ucVersionNum = p2pFuncGetVersionNumOfSD(prAdapter)) == 0) {
1235         P_PARAM_P2P_GET_SD_RESPONSE prP2pGetSdRsp = (P_PARAM_P2P_GET_SD_RESPONSE)NULL;
1236
1237         prP2pGetSdRsp = (P_PARAM_P2P_GET_SD_REQUEST)pvQueryBuffer;
1238         pucPacketContent = prP2pGetSdRsp->aucPacketContent;
1239         pucTA = &prP2pGetSdRsp->rTransmitterAddr;
1240         pu2PacketLength = &prP2pGetSdRsp->u2PacketLength;
1241     }
1242     else {
1243         P_PARAM_P2P_GET_SD_RESPONSE_EX prP2pGetSdRspEx = (P_PARAM_P2P_GET_SD_RESPONSE_EX)NULL;
1244
1245         prP2pGetSdRspEx = (P_PARAM_P2P_GET_SD_RESPONSE_EX)pvQueryBuffer;
1246         pucPacketContent = prP2pGetSdRspEx->aucPacketContent;
1247         pucTA = &prP2pGetSdRspEx->rTransmitterAddr;
1248         pu2PacketLength = &prP2pGetSdRspEx->u2PacketLength;
1249         ucSeqNum = prP2pGetSdRspEx->ucSeqNum;
1250     }
1251
1252
1253 //    rWlanStatus = p2pFuncGetServiceDiscoveryFrame(prAdapter,
1254 //                    pucPacketContent,
1255 //                    (u4QueryBufferLen - sizeof(PARAM_P2P_GET_SD_RESPONSE)),
1256 //                    (PUINT_32)pu2PacketLength,
1257 //                    NULL,
1258 //                    ucSeqNum);
1259 #else
1260     *pu4QueryInfoLen = 0;
1261     return rWlanStatus;
1262 #endif
1263     prWlanHdr = (P_WLAN_MAC_HEADER_T)pucPacketContent;
1264
1265     kalMemCopy(pucTA, prWlanHdr->aucAddr2, MAC_ADDR_LEN);
1266
1267
1268     if (pu4QueryInfoLen) {
1269         if (ucVersionNum == 0) {
1270             *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_RESPONSE) + *pu2PacketLength);
1271         }
1272         else {
1273             *pu4QueryInfoLen = (UINT_32)(sizeof(PARAM_P2P_GET_SD_RESPONSE_EX) + *pu2PacketLength);
1274         }
1275     }
1276
1277     return rWlanStatus;
1278 } /* end of wlanoidGetP2PSDResponse() */
1279
1280
1281 /*----------------------------------------------------------------------------*/
1282 /*!
1283 * \brief This routine is called to terminate P2P Service Discovery Phase
1284 *
1285 * \param[in] prAdapter      Pointer to the Adapter structure.
1286 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
1287 * \param[in] u4SetBufferLen The length of the set buffer.
1288 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1289 *                           bytes read from the set buffer. If the call failed
1290 *                           due to invalid length of the set buffer, returns
1291 *                           the amount of storage needed.
1292 *
1293 * \retval WLAN_STATUS_SUCCESS
1294 * \retval WLAN_STATUS_INVALID_LENGTH
1295 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1296 * \retval WLAN_STATUS_MULTICAST_FULL
1297 */
1298 /*----------------------------------------------------------------------------*/
1299 WLAN_STATUS
1300 wlanoidSetP2PTerminateSDPhase(
1301     IN  P_ADAPTER_T prAdapter,
1302     IN  PVOID       pvSetBuffer,
1303     IN  UINT_32     u4SetBufferLen,
1304     OUT PUINT_32    pu4SetInfoLen
1305     )
1306 {
1307     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1308     P_PARAM_P2P_TERMINATE_SD_PHASE prP2pTerminateSD = (P_PARAM_P2P_TERMINATE_SD_PHASE)NULL;
1309     UINT_8 aucNullAddr[] = NULL_MAC_ADDR;
1310
1311     do {
1312         if ((prAdapter == NULL) || (pu4SetInfoLen == NULL)) {
1313             break;
1314         }
1315
1316
1317         if ((u4SetBufferLen) && (pvSetBuffer == NULL)) {
1318             break;
1319         }
1320
1321         if (u4SetBufferLen < sizeof(PARAM_P2P_TERMINATE_SD_PHASE)) {
1322             *pu4SetInfoLen = sizeof(PARAM_P2P_TERMINATE_SD_PHASE);
1323             rWlanStatus = WLAN_STATUS_BUFFER_TOO_SHORT;
1324             break;
1325         }
1326
1327         prP2pTerminateSD = (P_PARAM_P2P_TERMINATE_SD_PHASE)pvSetBuffer;
1328
1329         if (EQUAL_MAC_ADDR(prP2pTerminateSD->rPeerAddr, aucNullAddr)) {
1330             DBGLOG(P2P, TRACE, ("Service Discovery Version 2.0\n"));
1331 //            p2pFuncSetVersionNumOfSD(prAdapter, 2);
1332         }
1333
1334         //rWlanStatus = p2pFsmRunEventSDAbort(prAdapter);
1335
1336     } while (FALSE);
1337
1338
1339
1340
1341
1342     return rWlanStatus;
1343 } /* end of wlanoidSetP2PTerminateSDPhase() */
1344
1345
1346 #if CFG_SUPPORT_ANTI_PIRACY
1347 /*----------------------------------------------------------------------------*/
1348 /*!
1349 * \brief This routine is called to
1350 *
1351 * \param[in] prAdapter      Pointer to the Adapter structure.
1352 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
1353 * \param[in] u4SetBufferLen The length of the set buffer.
1354 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1355 *                           bytes read from the set buffer. If the call failed
1356 *                           due to invalid length of the set buffer, returns
1357 *                           the amount of storage needed.
1358 *
1359 * \retval WLAN_STATUS_SUCCESS
1360 * \retval WLAN_STATUS_INVALID_LENGTH
1361 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1362 * \retval WLAN_STATUS_MULTICAST_FULL
1363 */
1364 /*----------------------------------------------------------------------------*/
1365 WLAN_STATUS
1366 wlanoidSetSecCheckRequest(
1367     IN  P_ADAPTER_T prAdapter,
1368     IN  PVOID       pvSetBuffer,
1369     IN  UINT_32     u4SetBufferLen,
1370     OUT PUINT_32    pu4SetInfoLen
1371     )
1372 {
1373     ASSERT(prAdapter);
1374     ASSERT(pu4SetInfoLen);
1375
1376     if (u4SetBufferLen) {
1377         ASSERT(pvSetBuffer);
1378     }
1379
1380     return wlanoidSendSetQueryP2PCmd(prAdapter,
1381             CMD_ID_SEC_CHECK,
1382             FALSE,
1383             TRUE,
1384             TRUE,
1385             NULL,
1386             nicOidCmdTimeoutCommon,
1387             u4SetBufferLen,
1388             (PUINT_8)pvSetBuffer,
1389             pvSetBuffer,
1390             u4SetBufferLen
1391             );
1392
1393 } /* end of wlanoidSetSecCheckRequest() */
1394
1395
1396 /*----------------------------------------------------------------------------*/
1397 /*!
1398 * \brief This routine is called to
1399 *
1400 * \param[in]  prAdapter        Pointer to the Adapter structure.
1401 * \param[out] pvQueryBuffer    A pointer to the buffer that holds the result of
1402 *                              the query.
1403 * \param[in]  u4QueryBufferLen The length of the query buffer.
1404 * \param[out] pu4QueryInfoLen  If the call is successful, returns the number of
1405 *                              bytes written into the query buffer. If the call
1406 *                              failed due to invalid length of the query buffer,
1407 *                              returns the amount of storage needed.
1408 *
1409 * \retval WLAN_STATUS_SUCCESS
1410 * \retval WLAN_STATUS_INVALID_LENGTH
1411 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1412 * \retval WLAN_STATUS_MULTICAST_FULL
1413 */
1414 /*----------------------------------------------------------------------------*/
1415 WLAN_STATUS
1416 wlanoidGetSecCheckResponse(
1417     IN  P_ADAPTER_T prAdapter,
1418     IN  PVOID       pvQueryBuffer,
1419     IN  UINT_32     u4QueryBufferLen,
1420     OUT PUINT_32    pu4QueryInfoLen
1421     )
1422 {
1423     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
1424     //P_WLAN_MAC_HEADER_T prWlanHdr = (P_WLAN_MAC_HEADER_T)NULL;
1425     P_GLUE_INFO_T prGlueInfo;
1426
1427     prGlueInfo = prAdapter->prGlueInfo;
1428
1429     ASSERT(prAdapter);
1430     ASSERT(pu4QueryInfoLen);
1431
1432     if (u4QueryBufferLen) {
1433         ASSERT(pvQueryBuffer);
1434     }
1435
1436     if (u4QueryBufferLen > 256) {
1437         u4QueryBufferLen = 256;
1438     }
1439
1440     *pu4QueryInfoLen = u4QueryBufferLen;
1441
1442     #if DBG
1443     DBGLOG_MEM8(SEC, LOUD, prGlueInfo->prP2PInfo->aucSecCheckRsp, u4QueryBufferLen);
1444     #endif
1445     kalMemCopy((PUINT_8)(pvQueryBuffer + OFFSET_OF(IW_P2P_TRANSPORT_STRUCT, aucBuffer)), prGlueInfo->prP2PInfo->aucSecCheckRsp, u4QueryBufferLen);
1446
1447     return rWlanStatus;
1448 } /* end of wlanoidGetSecCheckResponse() */
1449 #endif
1450
1451 WLAN_STATUS
1452 wlanoidSetNoaParam (
1453     IN  P_ADAPTER_T       prAdapter,
1454     IN  PVOID             pvSetBuffer,
1455     IN  UINT_32           u4SetBufferLen,
1456     OUT PUINT_32          pu4SetInfoLen
1457     )
1458 {
1459     P_PARAM_CUSTOM_NOA_PARAM_STRUC_T prNoaParam;
1460     CMD_CUSTOM_NOA_PARAM_STRUC_T rCmdNoaParam;
1461
1462     DEBUGFUNC("wlanoidSetNoaParam");
1463     DBGLOG(INIT, TRACE,("\n"));
1464
1465     ASSERT(prAdapter);
1466     ASSERT(pu4SetInfoLen);
1467
1468     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_NOA_PARAM_STRUC_T);
1469
1470     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_NOA_PARAM_STRUC_T)) {
1471         return WLAN_STATUS_INVALID_LENGTH;
1472     }
1473
1474     ASSERT(pvSetBuffer);
1475
1476     prNoaParam = (P_PARAM_CUSTOM_NOA_PARAM_STRUC_T)pvSetBuffer;
1477
1478     kalMemZero(&rCmdNoaParam, sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T));
1479     rCmdNoaParam.u4NoaDurationMs = prNoaParam->u4NoaDurationMs;
1480     rCmdNoaParam.u4NoaIntervalMs = prNoaParam->u4NoaIntervalMs;
1481     rCmdNoaParam.u4NoaCount = prNoaParam->u4NoaCount;
1482
1483 #if 0
1484     return wlanSendSetQueryCmd(prAdapter,
1485             CMD_ID_SET_NOA_PARAM,
1486             TRUE,
1487             FALSE,
1488             TRUE,
1489             nicCmdEventSetCommon,
1490             nicOidCmdTimeoutCommon,
1491             sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T),
1492             (PUINT_8)&rCmdNoaParam,
1493             pvSetBuffer,
1494             u4SetBufferLen
1495             );
1496 #else
1497     return wlanoidSendSetQueryP2PCmd(prAdapter,
1498             CMD_ID_SET_NOA_PARAM,
1499             TRUE,
1500             FALSE,
1501             TRUE,
1502             NULL,
1503             nicOidCmdTimeoutCommon,
1504             sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T),
1505             (PUINT_8)&rCmdNoaParam,
1506             pvSetBuffer,
1507             u4SetBufferLen
1508             );
1509
1510 #endif
1511
1512 }
1513
1514 WLAN_STATUS
1515 wlanoidSetOppPsParam (
1516     IN  P_ADAPTER_T       prAdapter,
1517     IN  PVOID             pvSetBuffer,
1518     IN  UINT_32           u4SetBufferLen,
1519     OUT PUINT_32          pu4SetInfoLen
1520     )
1521 {
1522     P_PARAM_CUSTOM_OPPPS_PARAM_STRUC_T prOppPsParam;
1523     CMD_CUSTOM_OPPPS_PARAM_STRUC_T rCmdOppPsParam;
1524
1525     DEBUGFUNC("wlanoidSetOppPsParam");
1526     DBGLOG(INIT, TRACE,("\n"));
1527
1528     ASSERT(prAdapter);
1529     ASSERT(pu4SetInfoLen);
1530
1531     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_OPPPS_PARAM_STRUC_T);
1532
1533     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_OPPPS_PARAM_STRUC_T)) {
1534         return WLAN_STATUS_INVALID_LENGTH;
1535     }
1536
1537     ASSERT(pvSetBuffer);
1538
1539     prOppPsParam = (P_PARAM_CUSTOM_OPPPS_PARAM_STRUC_T)pvSetBuffer;
1540
1541     kalMemZero(&rCmdOppPsParam, sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T));
1542     rCmdOppPsParam.u4CTwindowMs = prOppPsParam->u4CTwindowMs;
1543
1544 #if 0
1545     return wlanSendSetQueryCmd(prAdapter,
1546             CMD_ID_SET_OPPPS_PARAM,
1547             TRUE,
1548             FALSE,
1549             TRUE,
1550             nicCmdEventSetCommon,
1551             nicOidCmdTimeoutCommon,
1552             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1553             (PUINT_8)&rCmdOppPsParam,
1554             pvSetBuffer,
1555             u4SetBufferLen
1556             );
1557 #else
1558     return wlanoidSendSetQueryP2PCmd(prAdapter,
1559             CMD_ID_SET_NOA_PARAM,
1560             TRUE,
1561             FALSE,
1562             TRUE,
1563             NULL,
1564             nicOidCmdTimeoutCommon,
1565             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1566             (PUINT_8)&rCmdOppPsParam,
1567             pvSetBuffer,
1568             u4SetBufferLen
1569             );
1570
1571 #endif
1572
1573 }
1574
1575 WLAN_STATUS
1576 wlanoidSetUApsdParam (
1577     IN  P_ADAPTER_T       prAdapter,
1578     IN  PVOID             pvSetBuffer,
1579     IN  UINT_32           u4SetBufferLen,
1580     OUT PUINT_32          pu4SetInfoLen
1581     )
1582 {
1583     P_PARAM_CUSTOM_UAPSD_PARAM_STRUC_T prUapsdParam;
1584     CMD_CUSTOM_UAPSD_PARAM_STRUC_T rCmdUapsdParam;
1585     P_PM_PROFILE_SETUP_INFO_T prPmProfSetupInfo;
1586     P_BSS_INFO_T prBssInfo;
1587
1588
1589     DEBUGFUNC("wlanoidSetUApsdParam");
1590     DBGLOG(INIT, TRACE,("\n"));
1591
1592     ASSERT(prAdapter);
1593     ASSERT(pu4SetInfoLen);
1594
1595     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_UAPSD_PARAM_STRUC_T);
1596
1597     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_UAPSD_PARAM_STRUC_T)) {
1598         return WLAN_STATUS_INVALID_LENGTH;
1599     }
1600
1601     ASSERT(pvSetBuffer);
1602
1603     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
1604     prPmProfSetupInfo = &prBssInfo->rPmProfSetupInfo;
1605
1606     prUapsdParam = (P_PARAM_CUSTOM_UAPSD_PARAM_STRUC_T)pvSetBuffer;
1607
1608     kalMemZero(&rCmdUapsdParam, sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T));
1609     rCmdUapsdParam.fgEnAPSD = prUapsdParam->fgEnAPSD;
1610     prAdapter->rWifiVar.fgSupportUAPSD = prUapsdParam->fgEnAPSD;
1611
1612     rCmdUapsdParam.fgEnAPSD_AcBe = prUapsdParam->fgEnAPSD_AcBe;
1613     rCmdUapsdParam.fgEnAPSD_AcBk = prUapsdParam->fgEnAPSD_AcBk;
1614     rCmdUapsdParam.fgEnAPSD_AcVo = prUapsdParam->fgEnAPSD_AcVo;
1615     rCmdUapsdParam.fgEnAPSD_AcVi = prUapsdParam->fgEnAPSD_AcVi;
1616     prPmProfSetupInfo->ucBmpDeliveryAC  =
1617         ((prUapsdParam->fgEnAPSD_AcBe << 0) |
1618         (prUapsdParam->fgEnAPSD_AcBk << 1) |
1619         (prUapsdParam->fgEnAPSD_AcVi << 2) |
1620         (prUapsdParam->fgEnAPSD_AcVo << 3));
1621     prPmProfSetupInfo->ucBmpTriggerAC  =
1622         ((prUapsdParam->fgEnAPSD_AcBe << 0) |
1623         (prUapsdParam->fgEnAPSD_AcBk << 1) |
1624         (prUapsdParam->fgEnAPSD_AcVi << 2) |
1625         (prUapsdParam->fgEnAPSD_AcVo << 3));
1626
1627     rCmdUapsdParam.ucMaxSpLen = prUapsdParam->ucMaxSpLen;
1628     prPmProfSetupInfo->ucUapsdSp  = prUapsdParam->ucMaxSpLen;
1629
1630 #if 0
1631     return wlanSendSetQueryCmd(prAdapter,
1632             CMD_ID_SET_UAPSD_PARAM,
1633             TRUE,
1634             FALSE,
1635             TRUE,
1636             nicCmdEventSetCommon,
1637             nicOidCmdTimeoutCommon,
1638             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1639             (PUINT_8)&rCmdUapsdParam,
1640             pvSetBuffer,
1641             u4SetBufferLen
1642             );
1643  #else
1644     return wlanoidSendSetQueryP2PCmd(prAdapter,
1645             CMD_ID_SET_UAPSD_PARAM,
1646             TRUE,
1647             FALSE,
1648             TRUE,
1649             NULL,
1650             nicOidCmdTimeoutCommon,
1651             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
1652             (PUINT_8)&rCmdUapsdParam,
1653             pvSetBuffer,
1654             u4SetBufferLen
1655             );
1656
1657 #endif
1658 }
1659
1660
1661
1662 WLAN_STATUS
1663 wlanoidQueryP2pOpChannel (
1664     IN P_ADAPTER_T prAdapter,
1665     IN PVOID pvQueryBuffer,
1666     IN UINT_32 u4QueryBufferLen,
1667     OUT PUINT_32 pu4QueryInfoLen
1668     )
1669 {
1670
1671     WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1672 //    PUINT_8 pucOpChnl = (PUINT_8)pvQueryBuffer;
1673
1674     do {
1675         if ((prAdapter == NULL) || (pu4QueryInfoLen == NULL)) {
1676             break;
1677         }
1678
1679
1680         if ((u4QueryBufferLen) && (pvQueryBuffer == NULL)) {
1681             break;
1682         }
1683
1684         if (u4QueryBufferLen < sizeof(UINT_8)) {
1685             *pu4QueryInfoLen = sizeof(UINT_8);
1686             rResult = WLAN_STATUS_BUFFER_TOO_SHORT;
1687             break;
1688         }
1689
1690 #if 0
1691         if (!p2pFuncGetCurrentOpChnl(prAdapter, pucOpChnl)) {
1692             rResult = WLAN_STATUS_INVALID_DATA;
1693             break;
1694         }
1695 #else
1696         rResult = WLAN_STATUS_INVALID_DATA;
1697         break;
1698 #endif
1699
1700         *pu4QueryInfoLen = sizeof(UINT_8);
1701         rResult = WLAN_STATUS_SUCCESS;
1702
1703     } while (FALSE);
1704
1705     return rResult;
1706 } /* wlanoidQueryP2pOpChannel */
1707
1708 WLAN_STATUS
1709 wlanoidQueryP2pVersion (
1710     IN P_ADAPTER_T prAdapter,
1711     IN PVOID pvQueryBuffer,
1712     IN UINT_32 u4QueryBufferLen,
1713     OUT PUINT_32 pu4QueryInfoLen
1714     )
1715 {
1716     WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1717 //    PUINT_8 pucVersionNum = (PUINT_8)pvQueryBuffer;
1718
1719     do {
1720         if ((prAdapter == NULL) || (pu4QueryInfoLen == NULL)) {
1721             break;
1722         }
1723
1724
1725         if ((u4QueryBufferLen) && (pvQueryBuffer == NULL)) {
1726             break;
1727         }
1728
1729         if (u4QueryBufferLen < sizeof(UINT_8)) {
1730             *pu4QueryInfoLen = sizeof(UINT_8);
1731             rResult = WLAN_STATUS_BUFFER_TOO_SHORT;
1732             break;
1733         }
1734
1735     } while (FALSE);
1736
1737     return rResult;
1738 } /* wlanoidQueryP2pVersion */
1739
1740 WLAN_STATUS
1741 wlanoidSetP2pSupplicantVersion (
1742     IN  P_ADAPTER_T       prAdapter,
1743     IN  PVOID             pvSetBuffer,
1744     IN  UINT_32           u4SetBufferLen,
1745     OUT PUINT_32          pu4SetInfoLen
1746     )
1747 {
1748     WLAN_STATUS rResult = WLAN_STATUS_FAILURE;
1749     UINT_8 ucVersionNum;
1750
1751     do {
1752         if ((prAdapter == NULL) || (pu4SetInfoLen == NULL)) {
1753
1754             rResult = WLAN_STATUS_INVALID_DATA;
1755             break;
1756         }
1757
1758         if ((u4SetBufferLen) && (pvSetBuffer == NULL)) {
1759             rResult = WLAN_STATUS_INVALID_DATA;
1760             break;
1761         }
1762
1763         *pu4SetInfoLen = sizeof(UINT_8);
1764
1765         if (u4SetBufferLen < sizeof(UINT_8)) {
1766             rResult = WLAN_STATUS_INVALID_LENGTH;
1767             break;
1768         }
1769
1770
1771         ucVersionNum = *((PUINT_8)pvSetBuffer);
1772
1773
1774         rResult = WLAN_STATUS_SUCCESS;
1775     } while (FALSE);
1776
1777     return rResult;
1778 } /* wlanoidSetP2pSupplicantVersion */
1779
1780 #if CFG_SUPPORT_P2P_RSSI_QUERY
1781 WLAN_STATUS
1782 wlanoidQueryP2pRssi (
1783     IN P_ADAPTER_T prAdapter,
1784     IN PVOID pvQueryBuffer,
1785     IN UINT_32 u4QueryBufferLen,
1786     OUT PUINT_32 pu4QueryInfoLen
1787     )
1788 {
1789     DEBUGFUNC("wlanoidQueryP2pRssi");
1790
1791     ASSERT(prAdapter);
1792     ASSERT(pu4QueryInfoLen);
1793     if (u4QueryBufferLen) {
1794         ASSERT(pvQueryBuffer);
1795     }
1796
1797     *pu4QueryInfoLen = sizeof(PARAM_RSSI);
1798
1799     /* Check for query buffer length */
1800     if (u4QueryBufferLen < *pu4QueryInfoLen) {
1801         DBGLOG(REQ, WARN, ("Too short length %ld\n", u4QueryBufferLen));
1802         return WLAN_STATUS_BUFFER_TOO_SHORT;
1803     }
1804
1805     if (prAdapter->fgIsP2pLinkQualityValid == TRUE &&
1806             (kalGetTimeTick() - prAdapter->rP2pLinkQualityUpdateTime) <= CFG_LINK_QUALITY_VALID_PERIOD) {
1807         PARAM_RSSI rRssi;
1808
1809         rRssi = (PARAM_RSSI)prAdapter->rP2pLinkQuality.cRssi; // ranged from (-128 ~ 30) in unit of dBm
1810
1811         if(rRssi > PARAM_WHQL_RSSI_MAX_DBM)
1812             rRssi = PARAM_WHQL_RSSI_MAX_DBM;
1813         else if(rRssi < PARAM_WHQL_RSSI_MIN_DBM)
1814             rRssi = PARAM_WHQL_RSSI_MIN_DBM;
1815
1816         kalMemCopy(pvQueryBuffer, &rRssi, sizeof(PARAM_RSSI));
1817         return WLAN_STATUS_SUCCESS;
1818     }
1819
1820     #ifdef LINUX
1821     return wlanSendSetQueryCmd(prAdapter,
1822             CMD_ID_GET_LINK_QUALITY,
1823             FALSE,
1824             TRUE,
1825             TRUE,
1826             nicCmdEventQueryLinkQuality,
1827             nicOidCmdTimeoutCommon,
1828             *pu4QueryInfoLen,
1829             pvQueryBuffer,
1830             pvQueryBuffer,
1831             u4QueryBufferLen
1832             );
1833     #else
1834     return wlanSendSetQueryCmd(prAdapter,
1835             CMD_ID_GET_LINK_QUALITY,
1836             FALSE,
1837             TRUE,
1838             TRUE,
1839             nicCmdEventQueryLinkQuality,
1840             nicOidCmdTimeoutCommon,
1841             0,
1842             NULL,
1843             pvQueryBuffer,
1844             u4QueryBufferLen
1845             );
1846
1847     #endif
1848 } /* wlanoidQueryP2pRssi */
1849 #endif
1850
1851