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