drivers/mtk_wcn_combo/drv_wlan/p2p/common/wlan_p2p.c

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