1 /****************************************************************************
2 **+-----------------------------------------------------------------------+**
3 **| |**
4 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |**
5 **| All rights reserved. |**
6 **| |**
7 **| Redistribution and use in source and binary forms, with or without |**
8 **| modification, are permitted provided that the following conditions |**
9 **| are met: |**
10 **| |**
11 **| * Redistributions of source code must retain the above copyright |**
12 **| notice, this list of conditions and the following disclaimer. |**
13 **| * Redistributions in binary form must reproduce the above copyright |**
14 **| notice, this list of conditions and the following disclaimer in |**
15 **| the documentation and/or other materials provided with the |**
16 **| distribution. |**
17 **| * Neither the name Texas Instruments nor the names of its |**
18 **| contributors may be used to endorse or promote products derived |**
19 **| from this software without specific prior written permission. |**
20 **| |**
21 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |**
22 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |**
23 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |**
24 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |**
25 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |**
26 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |**
27 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |**
28 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |**
29 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |**
30 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |**
31 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |**
32 **| |**
33 **+-----------------------------------------------------------------------+**
34 ****************************************************************************/
35
36 #ifdef _WINDOWS /*nick*/
37 #elif defined(__ARMCC__)
38 #include "string.h"
39 #endif
40
41 #include "osAdapter.h"
42 #include "srcApi.h"
43 #include "tiwlnif.h"
44 #include "osDot11.h"
45 #include "osUtil.h"
46 #include "paramOut.h"
47 #include "wspVer.h"
48 #include "osClsfr.h"
49 #include "whalHwMboxCmdBit.h"
50
51 static TI_STATUS
52 UtilRegulatoryDomain_setCountryIE(
53 PTIWLN_ADAPTER_T pAdapter,
54 externalParam_e ParamType,
55 PUCHAR pData,
56 ULONG Length
57 );
58
59 #ifdef TIWLN_WINCE30
60
gprintf(const char * format,...)61 gprintf(const char *format ,... )
62 {
63 #if 1
64 #ifdef DEBUG_PB
65 wchar_t Buf[500];
66 #endif
67
68 FILE *Fpn;
69
70 Fpn = fopen("TILog.txt","a");
71
72 if (Fpn)
73 {
74 char Msg[500];
75 va_list ap;
76 va_start(ap,format);
77 _vsnprintf(Msg,500,format,ap);
78 fprintf(Fpn,"%s", Msg);
79 #ifdef DEBUG_PB
80 mbstowcs(Buf,Msg,strlen(Msg)+1);
81 DEBUGMSG(1,(Buf));
82 #endif
83
84 fclose(Fpn);
85
86 }
87 #endif
88 }
89
90 #endif
91
92
93 /*-----------------------------------------------------------------------------
94 Routine Name: UtilSetParam
95 Routine Description:
96 Arguments:
97 Return Value:
98 -----------------------------------------------------------------------------*/
99 TI_STATUS
UtilSetParam(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)100 UtilSetParam(
101 PTIWLN_ADAPTER_T pAdapter,
102 externalParam_e ParamType,
103 PUCHAR pData,
104 ULONG Length
105 )
106 {
107 paramInfo_t Param;
108 TI_STATUS Status;
109
110 Param.paramType = ParamType;
111 if (Length > sizeof(Param.content))
112 {
113 PRINTF(DBG_NDIS_OIDS_VERY_LOUD, (" UtilSetParam: Buffer for parameter 0x%X is bigger(%d) then Param size(%d)\n", ParamType, (int)Length, sizeof(Param.content)));
114 Param.paramLength = sizeof(Param.content);
115 NdisMoveMemory(&Param.content, pData, sizeof(Param.content));
116 } else
117 {
118 Param.paramLength = Length;
119 NdisMoveMemory(&Param.content, pData, Length);
120 }
121
122 Status = configMgr_setParam(pAdapter->CoreHalCtx, &Param);
123
124 return Status;
125 }
126
127
128 /*-----------------------------------------------------------------------------
129 Routine Name: UtilGetParam
130 Routine Description:
131 Arguments:
132 Return Value:
133 -----------------------------------------------------------------------------*/
134 TI_STATUS
UtilGetParam(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)135 UtilGetParam(
136 PTIWLN_ADAPTER_T pAdapter,
137 externalParam_e ParamType,
138 PUCHAR pData,
139 ULONG Length
140 )
141 {
142 paramInfo_t Param;
143 TI_STATUS Status;
144
145 Param.paramType = ParamType;
146 Param.paramLength = Length;
147
148 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
149
150 if (Status == NOK)
151 {
152 PRINTF(DBG_NDIS_OIDS_VERY_LOUD, (" UtilGetParam: ERROR on return from get param, status=%d, param=%d\n",
153 Status, ParamType));
154 } else if ( Status != NOK )
155 {
156 PRINTF(DBG_NDIS_OIDS_LOUD, (" UtilGetParam: WARNING on return from get param, status=%d, param=%d\n",
157 Status, ParamType));
158 }
159
160 if (Length > sizeof(Param.content))
161 {
162 PRINTF(DBG_NDIS_OIDS_VERY_LOUD, (" UtilGetParam: Buffer for parameter 0x%X is bigger then Param size\n", ParamType));
163 NdisMoveMemory(pData, &Param.content, sizeof(Param.content));
164 } else
165 {
166 NdisMoveMemory(pData, &Param.content, Length);
167 }
168
169 return Status;
170 }
171
172 /*-----------------------------------------------------------------------------
173 Routine Name: UtilSetGetParam
174 Routine Description:
175 Arguments:
176 Return Value:
177 -----------------------------------------------------------------------------*/
178 TI_STATUS
UtilSetGetParam(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)179 UtilSetGetParam(
180 PTIWLN_ADAPTER_T pAdapter,
181 externalParam_e ParamType,
182 PUCHAR pData,
183 ULONG Length
184 )
185 {
186 paramInfo_t Param;
187 TI_STATUS Status;
188
189 Param.paramType = ParamType;
190 if (Length > sizeof(Param.content))
191 {
192 PRINTF(DBG_NDIS_OIDS_VERY_LOUD, (" UtilSetParam: Buffer for parameter 0x%X is bigger(%d) then Param size(%d)\n", ParamType, (int)Length, sizeof(Param.content)));
193 Param.paramLength = sizeof(Param.content);
194 NdisMoveMemory(&Param.content, pData, sizeof(Param.content));
195 } else
196 {
197 Param.paramLength = Length;
198 NdisMoveMemory(&Param.content, pData, Length);
199 }
200
201 Status = configMgr_setParam(pAdapter->CoreHalCtx, &Param);
202
203 if (Length > sizeof(Param.content))
204 {
205 PRINTF(DBG_NDIS_OIDS_VERY_LOUD, (" UtilGetParam: Buffer for parameter 0x%X is bigger then Param size\n", ParamType));
206 NdisMoveMemory(pData, &Param.content, sizeof(Param.content));
207 } else
208 {
209 NdisMoveMemory(pData, &Param.content, Length);
210 }
211
212 return Status;
213 }
214
215 /*-----------------------------------------------------------------------------
216 Routine Name: UtilGetTxPowerValue
217 Routine Description:
218 Arguments:
219 Return Value:
220 -----------------------------------------------------------------------------*/
221 ULONG
UtilGetTxPowerValue(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)222 UtilGetTxPowerValue(
223 PTIWLN_ADAPTER_T pAdapter,
224 externalParam_e ParamType,
225 PUCHAR pData,
226 ULONG Length
227 )
228 {
229 paramInfo_t Param;
230 TI_STATUS Status;
231
232 Param.paramType = ParamType;
233 Param.paramLength = Length;
234 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
235
236 *(PULONG)pData = (ULONG)Param.content.regulatoryDomainParam.txPower;
237
238 return Status;
239 }
240
241
242 /*-----------------------------------------------------------------------------
243 Routine Name: UtilSetTxPowerDbm
244 Routine Description:
245 Arguments:
246 Return Value:
247 -----------------------------------------------------------------------------*/
UtilSetTxPowerDbm(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)248 ULONG UtilSetTxPowerDbm(PTIWLN_ADAPTER_T pAdapter,
249 PUCHAR pData,
250 ULONG Length)
251 {
252 ULONG retValue;
253
254 retValue = UtilSetParam(pAdapter, REGULATORY_DOMAIN_CURRENT_TX_POWER_IN_DBM_PARAM, pData, sizeof(UINT8));
255
256 return retValue;
257 }
258
259
260 /*-----------------------------------------------------------------------------
261 Routine Name: UtilGetTxPowerLevel
262 Routine Description:
263 Arguments:
264 Return Value:
265 -----------------------------------------------------------------------------*/
UtilGetTxPowerLevel(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)266 ULONG UtilGetTxPowerLevel(PTIWLN_ADAPTER_T pAdapter,
267 PUCHAR pData,
268 PULONG Length)
269 {
270 ULONG retValue;
271
272 retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_TX_POWER_LEVEL_TABLE_PARAM, pData, sizeof(TIWLAN_POWER_LEVEL_TABLE));
273 *Length=sizeof(TIWLAN_POWER_LEVEL_TABLE);
274
275 return retValue;
276 }
277
278
279
280 /*-----------------------------------------------------------------------------
281 Routine Name: UtilEnableDisableRxDataFilters
282 Routine Description:
283 Arguments:
284 Return Value:
285 -----------------------------------------------------------------------------*/
UtilEnableDisableRxDataFilters(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)286 ULONG UtilEnableDisableRxDataFilters(PTIWLN_ADAPTER_T pAdapter,
287 PUCHAR pData,
288 ULONG Length)
289 {
290 ULONG retValue;
291
292 retValue = UtilSetParam(pAdapter, RX_DATA_ENABLE_DISABLE_RX_DATA_FILTERS, pData, Length);
293
294 return retValue;
295 }
296
297
298
299 /*-----------------------------------------------------------------------------
300 Routine Name: UtilGetRxDataFiltersStatisticsCB
301
302 Routine Description: This is the CB triggered when Rx Data Filter statistics
303 are returned by the FW.
304 Arguments:
305
306 Return Value:
307 -----------------------------------------------------------------------------*/
UtilGetRxDataFiltersStatisticsCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)308 static VOID UtilGetRxDataFiltersStatisticsCB(TI_HANDLE hAdapter, TI_STATUS status, PUINT8 pReadBuff)
309 {
310 PTIWLN_ADAPTER_T pAdapter = (PTIWLN_ADAPTER_T) hAdapter;
311 ACXDataFilteringStatistics_t * pStatistics = (ACXDataFilteringStatistics_t *) pReadBuff;
312 TIWLAN_DATA_FILTER_STATISTICS * pResult = (TIWLAN_DATA_FILTER_STATISTICS *) &(pAdapter->pIoBuffer[0]);
313 int i;
314
315 pResult->UnmatchedPacketsCount = pStatistics->unmatchedPacketsCount;
316
317 for (i = 0; i < MAX_DATA_FILTERS; ++i)
318 {
319 pResult->MatchedPacketsCount[i] = pStatistics->matchedPacketsCount[i];
320 }
321
322 *(pAdapter->pIoCompleteBuffSize) = sizeof(TIWLAN_DATA_FILTER_STATISTICS);
323
324 /* indicate that the buffer is ready */
325 os_IoctlComplete(pAdapter, status);
326 }
327
328
329 /*-----------------------------------------------------------------------------
330 Routine Name: UtilEnableDisableRxDataFilters
331 Routine Description:
332 Arguments:
333 Return Value:
334 -----------------------------------------------------------------------------*/
UtilGetRxDataFiltersStatistics(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)335 ULONG UtilGetRxDataFiltersStatistics(PTIWLN_ADAPTER_T pAdapter,
336 PUCHAR pData,
337 PULONG Length)
338 {
339 paramInfo_t Param;
340
341 memset(&(pAdapter->IoCompleteBuff[0]) , 0xFF , MAX_IO_BUFFER_COMPLETE_SIZE);
342
343 pAdapter->pIoBuffer = pData;
344 pAdapter->pIoCompleteBuffSize = Length;
345
346 Param.paramType = RX_DATA_GET_RX_DATA_FILTERS_STATISTICS;
347 Param.paramLength = sizeof(TIWLAN_DATA_FILTER_STATISTICS);
348 Param.content.interogateCmdCBParams.CB_handle = (TI_HANDLE) pAdapter;
349 Param.content.interogateCmdCBParams.CB_Func = (PVOID) UtilGetRxDataFiltersStatisticsCB;
350 Param.content.interogateCmdCBParams.CB_buf = &(pAdapter->IoCompleteBuff[0]) ;
351
352 return configMgr_getParam(pAdapter->CoreHalCtx, &Param);
353 }
354
355
356 /*-----------------------------------------------------------------------------
357 Routine Name: UtilGetPowerConsumptionStatisticsCB
358
359 Routine Description: This is the CB triggered when Power consumption statistics
360 are returned by the FW.
361 Arguments:
362
363 Return Value:
364 -----------------------------------------------------------------------------*/
UtilGetPowerConsumptionStatisticsCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)365 static VOID UtilGetPowerConsumptionStatisticsCB(TI_HANDLE hAdapter, TI_STATUS status, PUINT8 pReadBuff)
366 {
367 PTIWLN_ADAPTER_T pAdapter = (PTIWLN_ADAPTER_T) hAdapter;
368 ACXPowerConsumptionTimeStat_t * pStatistics = (ACXPowerConsumptionTimeStat_t *) pReadBuff;
369 PowerConsumptionTimeStat_t * pResult = (PowerConsumptionTimeStat_t *) &(pAdapter->pIoBuffer[0]);
370
371 pResult->activeTimeCnt_Hi = pStatistics->activeTimeCnt_Hi;
372 pResult->activeTimeCnt_Low = pStatistics->activeTimeCnt_Low;
373 pResult->elpTimeCnt_Hi = pStatistics->elpTimeCnt_Hi;
374 pResult->elpTimeCnt_Low = pStatistics->elpTimeCnt_Low;
375 pResult->powerDownTimeCnt_Hi = pStatistics->powerDownTimeCnt_Hi;
376 pResult->powerDownTimeCnt_Low = pStatistics->powerDownTimeCnt_Low;
377
378 *(pAdapter->pIoCompleteBuffSize) = sizeof(PowerConsumptionTimeStat_t);
379
380 /* indicate that the buffer is ready */
381 os_IoctlComplete(pAdapter, status);
382 }
383
384
385 /*-----------------------------------------------------------------------------
386 Routine Name: UtilGetPowerConsumptionStatistics
387 Routine Description: Request the power consumption statistics from the FW
388 Arguments:
389 Return Value:
390 -----------------------------------------------------------------------------*/
UtilGetPowerConsumptionStatistics(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)391 ULONG UtilGetPowerConsumptionStatistics(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, PULONG Length)
392 {
393 paramInfo_t Param;
394
395 memset(&(pAdapter->IoCompleteBuff[0]) , 0xFF , MAX_IO_BUFFER_COMPLETE_SIZE);
396
397 pAdapter->pIoBuffer = pData;
398 pAdapter->pIoCompleteBuffSize = Length;
399
400 Param.paramType = HAL_CTRL_POWER_CONSUMPTION;
401 Param.paramLength = sizeof(PowerConsumptionTimeStat_t);
402 Param.content.interogateCmdCBParams.CB_handle = (TI_HANDLE) pAdapter;
403 Param.content.interogateCmdCBParams.CB_Func = (PVOID) UtilGetPowerConsumptionStatisticsCB;
404 Param.content.interogateCmdCBParams.CB_buf = &(pAdapter->IoCompleteBuff[0]);
405
406 return configMgr_getParam(pAdapter->CoreHalCtx, &Param);
407 }
408
409
410 /*-----------------------------------------------------------------------------
411 Routine Name: UtilAddRxDataFilter
412 Routine Description:
413 Arguments:
414 Return Value:
415 -----------------------------------------------------------------------------*/
UtilAddRxDataFilter(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)416 ULONG UtilAddRxDataFilter(PTIWLN_ADAPTER_T pAdapter,
417 PUCHAR pData,
418 ULONG Length)
419 {
420 ULONG retValue;
421
422 retValue = UtilSetParam(pAdapter, RX_DATA_ADD_RX_DATA_FILTER, pData, Length);
423
424 return retValue;
425 }
426
427
428
429 /*-----------------------------------------------------------------------------
430 Routine Name: UtilRemoveRxDataFilter
431 Routine Description:
432 Arguments:
433 Return Value:
434 -----------------------------------------------------------------------------*/
UtilRemoveRxDataFilter(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)435 ULONG UtilRemoveRxDataFilter(PTIWLN_ADAPTER_T pAdapter,
436 PUCHAR pData,
437 ULONG Length)
438 {
439 ULONG retValue;
440
441 retValue = UtilSetParam(pAdapter, RX_DATA_REMOVE_RX_DATA_FILTER, pData, Length);
442
443 return retValue;
444 }
445
446
447
448 /*-----------------------------------------------------------------------------
449 Routine Name: UtilGetCurrentRssiLevel
450 Routine Description:
451 Arguments:
452 Return Value:
453 -----------------------------------------------------------------------------*/
UtilGetCurrentRssiLevel(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)454 ULONG UtilGetCurrentRssiLevel(PTIWLN_ADAPTER_T pAdapter,
455 PUCHAR pData,
456 PULONG Length)
457 {
458 ULONG retValue;
459 retValue = UtilGetParam(pAdapter, SITE_MGR_CURRENT_SIGNAL_PARAM, pData, sizeof(INT32));
460 *Length = sizeof(INT32);
461 return retValue;
462 }
463
464
465 /*-----------------------------------------------------------------------------
466 Routine Name: RssiUtilIoctlCompleteCB
467
468 Routine Description: This is the CB triggered when Rssi/Snr have been
469 returned by FW - return RSSI only to user
470 Arguments:
471
472 Return Value:
473 -----------------------------------------------------------------------------*/
RssiUtilIoctlCompleteCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)474 VOID RssiUtilIoctlCompleteCB(TI_HANDLE hAdapter, TI_STATUS status, PUINT8 pReadBuff)
475 {
476 PTIWLN_ADAPTER_T pAdapter = (PTIWLN_ADAPTER_T)hAdapter;
477 TIWLN_RADIO_RX_QUALITY tmpRadioRxQuality;
478 paramInfo_t Param;
479 ACXRoamingStatisticsTable_t * radioResults = (ACXRoamingStatisticsTable_t *) pReadBuff;
480
481 tmpRadioRxQuality.Rssi = radioResults->rssi;
482 tmpRadioRxQuality.Snr = (INT32) radioResults->snr;
483
484 /* here we update the site manager about these new values */
485 Param.paramType = SITE_MGR_CURRENT_SIGNAL_PARAM;
486 Param.paramLength = sizeof(INT32);
487 Param.content.siteMgrCurrentRssi = tmpRadioRxQuality.Rssi;
488 configMgr_setParam(pAdapter->CoreHalCtx, &Param);
489
490
491 *(pAdapter->pIoCompleteBuffSize) = sizeof(INT32);
492 os_memoryCopy(hAdapter, (PVOID) &(pAdapter->pIoBuffer[0]), (PVOID) &(tmpRadioRxQuality.Rssi), sizeof(INT32));
493
494 /* Call back the Completion that will indicate to the user that the buffer is ready to be read */
495 os_IoctlComplete(pAdapter, status);
496 }
497
498 /*-----------------------------------------------------------------------------
499 Routine Name: SnrUtilIoctlCompleteCB
500
501 Routine Description: This is the CB triggered when Rssi/Snr have been
502 returned by FW - return SNR only to user
503 Arguments:
504
505 Return Value:
506 -----------------------------------------------------------------------------*/
SnrUtilIoctlCompleteCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)507 VOID SnrUtilIoctlCompleteCB(TI_HANDLE hAdapter, TI_STATUS status, PUINT8 pReadBuff)
508 {
509 PTIWLN_ADAPTER_T pAdapter = (PTIWLN_ADAPTER_T) hAdapter;
510 TIWLN_RADIO_RX_QUALITY tmpRadioRxQuality;
511 ACXRoamingStatisticsTable_t * radioResults = (ACXRoamingStatisticsTable_t *) pReadBuff;
512
513 tmpRadioRxQuality.Rssi = radioResults->rssi;
514 /* The SNR returned by FW is not true. We have to divide it by 2 and turns it to a signed */
515 tmpRadioRxQuality.Snr = (INT32) radioResults->snr;
516
517 *(pAdapter->pIoCompleteBuffSize) = sizeof(INT32);
518
519 os_memoryCopy(hAdapter, (PVOID) &(pAdapter->pIoBuffer[0]), (PVOID) &(tmpRadioRxQuality.Snr), sizeof(INT32));
520
521 os_IoctlComplete(pAdapter, status);
522 }
523
524
525 /*-----------------------------------------------------------------------------
526 Routine Name: UtilGetAsyncCurrentRssiLevel
527 Routine Description:
528 Arguments:
529 Return Value:
530 -----------------------------------------------------------------------------*/
UtilGetAsyncCurrentRssiLevel(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)531 ULONG UtilGetAsyncCurrentRssiLevel(PTIWLN_ADAPTER_T pAdapter,
532 PUCHAR pData,
533 PULONG Length)
534 {
535 paramInfo_t Param;
536
537
538 TI_STATUS Status;
539
540 memset(&(pAdapter->IoCompleteBuff[0]) , 0xFF , MAX_IO_BUFFER_COMPLETE_SIZE );
541
542 /* To implement the Async IOCTL store the user buffer pointer to be filled at
543 the Command Completion calback */
544 pAdapter->pIoBuffer = pData;
545 pAdapter->pIoCompleteBuffSize = Length ;
546
547 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
548 Param.paramType = HAL_CTRL_RSSI_LEVEL_PARAM;
549 Param.paramLength = sizeof(INT32);
550 Param.content.interogateCmdCBParams.CB_handle = (TI_HANDLE)pAdapter;
551 Param.content.interogateCmdCBParams.CB_Func = (PVOID)RssiUtilIoctlCompleteCB;
552 Param.content.interogateCmdCBParams.CB_buf = &(pAdapter->IoCompleteBuff[0]) ;
553
554 /* This Get Param will in fact get till the HAL and will interrogate the FW */
555 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
556
557 return Status;
558 }
559
560
561 /*-----------------------------------------------------------------------------
562 Routine Name: UtilGetAsyncCurrentRssiLevel
563 Routine Description:
564 Arguments:
565 Return Value:
566 -----------------------------------------------------------------------------*/
UtilGetAsyncCurrentSnrRatio(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)567 ULONG UtilGetAsyncCurrentSnrRatio(PTIWLN_ADAPTER_T pAdapter,
568 PUCHAR pData,
569 PULONG Length)
570 {
571 paramInfo_t Param;
572
573
574 TI_STATUS Status;
575
576 memset(&(pAdapter->IoCompleteBuff[0]) , 0xFF , MAX_IO_BUFFER_COMPLETE_SIZE );
577
578 pAdapter->pIoBuffer = pData;
579 pAdapter->pIoCompleteBuffSize = Length ;
580
581 Param.paramType = HAL_CTRL_SNR_RATIO_PARAM;
582 Param.paramLength = sizeof(INT32);
583 Param.content.interogateCmdCBParams.CB_handle = (TI_HANDLE)pAdapter;
584 Param.content.interogateCmdCBParams.CB_Func = (PVOID)SnrUtilIoctlCompleteCB;
585 Param.content.interogateCmdCBParams.CB_buf = &(pAdapter->IoCompleteBuff[0]) ;
586
587 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
588
589 return Status;
590
591
592 }
593
594
595 /*-----------------------------------------------------------------------------
596 Routine Name: UtilGetAPTxPowerLevel
597 Routine Description:
598 Arguments:
599 Return Value:
600 -----------------------------------------------------------------------------*/
601 ULONG
UtilGetAPTxPowerLevel(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)602 UtilGetAPTxPowerLevel(
603 PTIWLN_ADAPTER_T pAdapter,
604 externalParam_e ParamType,
605 PUCHAR pData,
606 ULONG Length
607 )
608 {
609 paramInfo_t Param;
610 TI_STATUS Status;
611
612 Param.paramType = ParamType;
613 Param.paramLength = Length;
614 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
615
616 *(PULONG)pData = (ULONG)Param.content.APTxPower;
617
618 return Status;
619 }
620
621
622 /*-----------------------------------------------------------------------------
623 Routine Name: UtilGetCountryCode
624 Routine Description:
625 Arguments:
626 Return Value:
627 -----------------------------------------------------------------------------*/
628 ULONG
UtilGetCountryCode(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)629 UtilGetCountryCode(
630 PTIWLN_ADAPTER_T pAdapter,
631 externalParam_e ParamType,
632 PUCHAR pData,
633 ULONG Length
634 )
635 {
636 paramInfo_t Param;
637 TI_STATUS Status;
638
639 Param.paramType = ParamType;
640 Param.paramLength = Length;
641 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
642
643 NdisMoveMemory(pData, Param.content.pCountryString, Length);
644
645 return Status;
646 }
647
648
649
650 /*-----------------------------------------------------------------------------
651 Routine Name: UtilGetRegDomainBand
652 Routine Description:
653 Arguments:
654 Return Value:
655 -----------------------------------------------------------------------------*/
656 ULONG
UtilGetRegDomainBand(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)657 UtilGetRegDomainBand(
658 PTIWLN_ADAPTER_T pAdapter,
659 externalParam_e ParamType,
660 PUCHAR pData,
661 ULONG Length
662 )
663 {
664 paramInfo_t Param;
665 TI_STATUS Status;
666
667 Param.paramType = ParamType;
668 Param.paramLength = Length;
669
670 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
671
672 *(PULONG)pData = (ULONG) *(PUCHAR)&Param.content;
673
674 return Status;
675 }
676
677
678 /*-----------------------------------------------------------------------------
679 Routine Name: UtilGetPacketBursting
680 Routine Description:
681 Arguments:
682 Return Value:
683 -----------------------------------------------------------------------------*/
684 ULONG
UtilGetPacketBursting(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)685 UtilGetPacketBursting(
686 PTIWLN_ADAPTER_T pAdapter,
687 externalParam_e ParamType,
688 PUCHAR pData,
689 ULONG Length
690 )
691 {
692 paramInfo_t Param;
693 TI_STATUS Status;
694
695 Param.paramType = ParamType;
696 Param.paramLength = Length;
697
698 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
699
700 *(PULONG)pData = (ULONG)Param.content.qosPacketBurstEnb;
701 return Status;
702 }
703
704
705 /*-----------------------------------------------------------------------------
706 Routine Name: UtilGetMixedMode
707 Routine Description:
708 Arguments:
709 Return Value:
710 -----------------------------------------------------------------------------*/
711 ULONG
UtilGetMixedMode(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,PULONG Length)712 UtilGetMixedMode(
713 PTIWLN_ADAPTER_T pAdapter,
714 externalParam_e ParamType,
715 PUCHAR pData,
716 PULONG Length
717 )
718 {
719 paramInfo_t Param;
720 TI_STATUS Status;
721
722 Param.paramType = ParamType;
723
724 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
725
726 *(PULONG)pData = (ULONG)Param.content.rsnMixedMode;
727 return Status;
728 }
729
730 /*-----------------------------------------------------------------------------
731 Routine Name: UtilGetDefaultKeyId
732 Routine Description:
733 Arguments:
734 Return Value:
735 -----------------------------------------------------------------------------*/
736 ULONG
UtilGetDefaultKeyId(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,PULONG Length)737 UtilGetDefaultKeyId(
738 PTIWLN_ADAPTER_T pAdapter,
739 externalParam_e ParamType,
740 PUCHAR pData,
741 PULONG Length
742 )
743 {
744 paramInfo_t Param;
745 TI_STATUS Status;
746
747 Param.paramType = ParamType;
748
749 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
750
751 *(PULONG)pData = (ULONG)Param.content.rsnDefaultKeyID;
752 return Status;
753 }
754
755
756 /*-----------------------------------------------------------------------------
757 Routine Name: UtilSetTrafficIntensityThresholds
758 Routine Description: Sets the traffic intensity thresholds
759 Arguments:
760 Return Value:
761 -----------------------------------------------------------------------------*/
UtilSetTrafficIntensityThresholds(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)762 ULONG UtilSetTrafficIntensityThresholds(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, ULONG Length)
763 {
764 ULONG retValue;
765 retValue = UtilSetParam(pAdapter,CTRL_DATA_TRAFFIC_INTENSITY_THRESHOLD , pData, Length);
766 return retValue;
767 }
768
769
770 /*-----------------------------------------------------------------------------
771 Routine Name: UtilGetTrafficIntensityThresholds
772 Routine Description: retrieves the traffic intensity thresholds
773 Arguments:
774 Return Value:
775 -----------------------------------------------------------------------------*/
UtilGetTrafficIntensityThresholds(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)776 ULONG UtilGetTrafficIntensityThresholds(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, PULONG Length)
777 {
778 ULONG retValue;
779 retValue = UtilGetParam(pAdapter, CTRL_DATA_TRAFFIC_INTENSITY_THRESHOLD, pData, (*Length));
780 *Length = sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS);
781 return retValue;
782 }
783
784
785 /*-----------------------------------------------------------------------------
786 Routine Name: UtilToggleTrafficIntensityEvents
787 Routine Description: Toggles ON/OFF traffic intensity events
788 Arguments:
789 Return Value:
790 -----------------------------------------------------------------------------*/
UtilToggleTrafficIntensityEvents(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)791 ULONG UtilToggleTrafficIntensityEvents(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, ULONG Length)
792 {
793 ULONG retValue;
794 retValue = UtilSetParam(pAdapter,CTRL_DATA_TOGGLE_TRAFFIC_INTENSITY_EVENTS , pData, Length);
795 return retValue;
796 }
797
798
799
800
801 /*-----------------------------------------------------------------------------
802 Routine Name:
803
804 UtilSetBSSID
805 Routine Description:
806 Arguments:
807 Return Value:
808 -----------------------------------------------------------------------------*/
809 ULONG
UtilSetBSSID(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)810 UtilSetBSSID(
811 PTIWLN_ADAPTER_T pAdapter,
812 PUCHAR pData,
813 ULONG Length
814 )
815 {
816 return UtilSetParam(pAdapter, SITE_MGR_DESIRED_BSSID_PARAM, pData, ETH_ADDR_SIZE);
817 }
818
819 /*-----------------------------------------------------------------------------
820 Routine Name: UtilGetBSSID
821 Routine Description:
822 Arguments:
823 Return Value:
824 -----------------------------------------------------------------------------*/
825 ULONG
UtilGetBSSID(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)826 UtilGetBSSID(
827 PTIWLN_ADAPTER_T pAdapter,
828 PUCHAR pData,
829 PULONG Length
830 )
831 {
832 TI_STATUS res;
833
834 if (!Length)
835 return NOK;
836
837 res = UtilGetParam(pAdapter, CTRL_DATA_CURRENT_BSSID_PARAM, pData, ETH_ADDR_SIZE);
838
839 *Length = ETH_ADDR_SIZE;
840
841 return res;
842 }
843
844
845 /*-----------------------------------------------------------------------------
846 Routine Name: UtilGetSSID
847 Routine Description:
848 Arguments:
849 Return Value:
850 -----------------------------------------------------------------------------*/
851 ULONG
UtilGetSSID(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)852 UtilGetSSID(
853 PTIWLN_ADAPTER_T pAdapter,
854 PUCHAR pData,
855 PULONG Length
856 )
857 {
858 ULONG size;
859 ssid_t ssid;
860 OS_802_11_SSID* RetSsid;
861
862 if (*Length<sizeof(OS_802_11_SSID))
863 return NOK;
864
865 size = sizeof(ssid_t);
866 UtilGetParam(pAdapter, SITE_MGR_CURRENT_SSID_PARAM, (PUCHAR)&ssid, size);
867
868 RetSsid = (OS_802_11_SSID*) pData;
869
870 RetSsid->SsidLength = ssid.len;
871 NdisMoveMemory((void *)RetSsid->Ssid, (void *)ssid.ssidString, ssid.len);
872
873 *Length = sizeof(OS_802_11_SSID);
874
875 return OK;
876 }
877
878
879 /*-----------------------------------------------------------------------------
880 Routine Name: UtilGetDesiredSSID
881 Routine Description:
882 Arguments:
883 Return Value:
884 -----------------------------------------------------------------------------*/
885 ULONG
UtilGetDesiredSSID(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)886 UtilGetDesiredSSID(
887 PTIWLN_ADAPTER_T pAdapter,
888 PUCHAR pData,
889 PULONG Length
890 )
891 {
892 ULONG size,retValue;
893 ssid_t ssid;
894 OS_802_11_SSID* RetSsid;
895
896 if (!(*Length))
897 {
898 *Length = sizeof(OS_802_11_SSID);
899 return NOK;
900 }
901
902 size = sizeof(ssid_t);
903 retValue = UtilGetParam(pAdapter, SITE_MGR_DESIRED_SSID_PARAM, (PUCHAR)&ssid, size);
904
905 RetSsid = (OS_802_11_SSID*) pData;
906
907 RetSsid->SsidLength = ssid.len;
908 NdisMoveMemory((void *)RetSsid->Ssid, (void *)ssid.ssidString, ssid.len);
909
910 *Length = sizeof(OS_802_11_SSID);
911 return retValue;
912 }
913
914
915 /*-----------------------------------------------------------------------------
916 Routine Name: UtilSetSSID
917 Routine Description:
918 Arguments:
919 Return Value:
920 -----------------------------------------------------------------------------*/
921 ULONG
UtilSetSSID(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)922 UtilSetSSID(
923 PTIWLN_ADAPTER_T pAdapter,
924 PUCHAR pData,
925 ULONG Length
926 )
927 {
928 OS_802_11_SSID* UtilSsid;
929 ssid_t ssid;
930
931 UtilSsid = (OS_802_11_SSID*) pData;
932
933 if (UtilSsid->SsidLength<=MAX_SSID_LEN)
934 {
935 ssid.len = (UINT8)UtilSsid->SsidLength;
936
937 NdisMoveMemory((void *)ssid.ssidString, (void *)UtilSsid->Ssid, ssid.len);
938
939 /* The driver should support setting the SSID to NULL string */
940 if (ssid.len == 0)
941 ssid.ssidString[0] = '\0';
942
943 #ifdef TI_DBG
944 {
945 UCHAR tempName[33];
946
947 NdisMoveMemory(tempName, (void *)UtilSsid->Ssid, ssid.len);
948 tempName[ssid.len] ='\0';
949
950 PRINTF(DBG_NDIS_OIDS_LOUD, (" SET SSID: Len=%d %s\n", ssid.len, tempName));
951 }
952 #endif
953
954 UtilSetParam(pAdapter, SITE_MGR_DESIRED_SSID_PARAM, (PUCHAR)&ssid, sizeof(ssid_t));
955 }
956
957 return OK;
958
959 }
960
961
962 /*-----------------------------------------------------------------------------
963 Routine Name: UtilNetworkTypesSupported
964 Routine Description:
965 Arguments:
966 Return Value:
967 -----------------------------------------------------------------------------*/
968 ULONG
UtilNetworkTypesSupported(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)969 UtilNetworkTypesSupported(
970 PTIWLN_ADAPTER_T pAdapter,
971 PUCHAR pData,
972 PULONG Length
973 )
974 {
975 OS_802_11_NETWORK_TYPE_LIST * pList;
976 ULONG mode, size;
977
978 UtilGetParam(pAdapter, SITE_MGR_DESIRED_DOT11_MODE_PARAM,
979 (PUCHAR)&mode, sizeof(ULONG));
980
981 if (!(*Length))
982 {
983
984 /**/
985 /* Return the maximum size*/
986 /**/
987 size = sizeof(OS_802_11_NETWORK_TYPE_LIST) +
988 3 * sizeof(OS_802_11_NETWORK_TYPE) -
989 sizeof(OS_802_11_NETWORK_TYPE);
990
991 *Length = size;
992 return NOK;
993
994 }
995
996 pList = (OS_802_11_NETWORK_TYPE_LIST *) pData;
997
998 switch (mode)
999 {
1000
1001 case 1:
1002 pList->NumberOfItems = 1;
1003 pList->NetworkType[0] = os802_11DS;
1004 break;
1005
1006 case 2:
1007 pList->NumberOfItems = 1;
1008 pList->NetworkType[0] = os802_11OFDM5;
1009 break;
1010
1011 case 3:
1012 pList->NumberOfItems = 2;
1013 pList->NetworkType[0] = os802_11DS;
1014 pList->NetworkType[1] = os802_11OFDM24;
1015 break;
1016
1017 case 4:
1018 pList->NumberOfItems = 3;
1019 pList->NetworkType[0] = os802_11DS;
1020 pList->NetworkType[1] = os802_11OFDM24;
1021 pList->NetworkType[2] = os802_11OFDM5;
1022 break;
1023
1024 default:
1025 pList->NumberOfItems = 1;
1026 pList->NetworkType[0] = os802_11DS;
1027 break;
1028 }
1029
1030 size = sizeof(OS_802_11_NETWORK_TYPE_LIST) +
1031 pList->NumberOfItems * sizeof(OS_802_11_NETWORK_TYPE) -
1032 sizeof(OS_802_11_NETWORK_TYPE);
1033
1034 *Length = size;
1035 return OK;
1036 }
1037
1038
1039 /*-----------------------------------------------------------------------------
1040 Routine Name: UtilNetworkTypeInUseGet
1041 Routine Description:
1042 Arguments:
1043 Return Value:
1044 -----------------------------------------------------------------------------*/
1045 ULONG
UtilNetworkTypeInUseGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1046 UtilNetworkTypeInUseGet(
1047 PTIWLN_ADAPTER_T pAdapter,
1048 PUCHAR pData,
1049 PULONG Length
1050 )
1051 {
1052 ULONG mode;
1053 if (!(*Length))
1054 {
1055
1056 *Length = sizeof(OS_802_11_NETWORK_TYPE);
1057 return NOK;
1058
1059 }
1060
1061 UtilGetParam(pAdapter, SITE_MGR_DESIRED_DOT11_MODE_PARAM,
1062 (PUCHAR)&mode, sizeof(ULONG));
1063
1064 switch (mode)
1065 {
1066
1067 case 1:
1068 *((OS_802_11_NETWORK_TYPE *) pData) = os802_11DS;
1069 break;
1070
1071 case 2:
1072 *((OS_802_11_NETWORK_TYPE *) pData) = os802_11OFDM5;
1073 break;
1074
1075 case 3:
1076 *((OS_802_11_NETWORK_TYPE *) pData) = os802_11OFDM24;
1077 break;
1078
1079 case 4:
1080 *((OS_802_11_NETWORK_TYPE *) pData) = os802_11Automode;
1081 break;
1082
1083 default:
1084 *((OS_802_11_NETWORK_TYPE *) pData) = os802_11DS;
1085 break;
1086
1087 }
1088
1089 *Length = sizeof(OS_802_11_NETWORK_TYPE);
1090 return OK;
1091 }
1092
1093
1094 /*-----------------------------------------------------------------------------
1095 Routine Name: UtilNetworkTypeInUseSet
1096 Routine Description:
1097 Arguments:
1098 Return Value:
1099 -----------------------------------------------------------------------------*/
1100 ULONG
UtilNetworkTypeInUseSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1101 UtilNetworkTypeInUseSet(
1102 PTIWLN_ADAPTER_T pAdapter,
1103 PUCHAR pData,
1104 ULONG Length
1105 )
1106 {
1107 ULONG retValue;
1108 retValue = UtilSetParam(pAdapter, SITE_MGR_DESIRED_DOT11_MODE_PARAM, pData, sizeof(ULONG));
1109 return retValue;
1110 }
1111
1112
1113 /*-----------------------------------------------------------------------------
1114 Routine Name: UtilSetPacketBursting
1115 Routine Description:
1116 Arguments:
1117 Return Value:
1118 -----------------------------------------------------------------------------*/
1119 ULONG
UtilSetPacketBursting(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1120 UtilSetPacketBursting(
1121 PTIWLN_ADAPTER_T pAdapter,
1122 PUCHAR pData,
1123 ULONG Length
1124 )
1125 {
1126 paramInfo_t Param;
1127 TI_STATUS Status;
1128
1129 Param.paramType = QOS_PACKET_BURST_ENABLE;
1130 Param.content.qosPacketBurstEnb = *((UINT8*)pData);
1131 Status = configMgr_setParam(pAdapter->CoreHalCtx, &Param);
1132 return Status;
1133 }
1134
1135
1136 /*-----------------------------------------------------------------------------
1137 Routine Name: UtilSetMixedMode
1138 Routine Description:
1139 Arguments:
1140 Return Value:
1141 -----------------------------------------------------------------------------*/
1142 ULONG
UtilSetMixedMode(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1143 UtilSetMixedMode(
1144 PTIWLN_ADAPTER_T pAdapter,
1145 PUCHAR pData,
1146 ULONG Length
1147 )
1148 {
1149 paramInfo_t Param;
1150 TI_STATUS Status;
1151
1152 Param.paramType = RSN_MIXED_MODE;
1153 Param.content.rsnMixedMode = *((UINT32*)pData);
1154 Status = configMgr_setParam(pAdapter->CoreHalCtx, &Param);
1155
1156 return Status;
1157 }
1158
1159
1160 /*-----------------------------------------------------------------------------
1161 Routine Name: UtilPowerModeSet
1162 Routine Description:
1163 Arguments:
1164 Return Value:
1165 -----------------------------------------------------------------------------*/
1166 ULONG
UtilPowerModeSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1167 UtilPowerModeSet(
1168 PTIWLN_ADAPTER_T pAdapter,
1169 PUCHAR pData,
1170 ULONG Length
1171 )
1172 {
1173 ULONG retValue;
1174 PowerMgr_PowerMode_t PowerMgr_PowerMode;
1175 PowerMgr_PowerMode.PowerMode = (PowerMgr_PowerMode_e)*pData;
1176 PowerMgr_PowerMode.powerMngPriority = POWER_MANAGER_USER_PRIORITY;
1177 retValue = UtilSetParam(pAdapter, POWER_MGR_POWER_MODE,(PUCHAR)&PowerMgr_PowerMode, sizeof(PowerMgr_PowerMode));
1178 return retValue;
1179 }
1180
1181
1182 /*-----------------------------------------------------------------------------
1183 Routine Name: UtilPowerModeGet
1184 Routine Description:
1185 Arguments:
1186 Return Value:
1187 -----------------------------------------------------------------------------*/
1188 ULONG
UtilPowerModeGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1189 UtilPowerModeGet(
1190 PTIWLN_ADAPTER_T pAdapter,
1191 PUCHAR pData,
1192 PULONG Length
1193 )
1194 {
1195 ULONG retValue;
1196 retValue = UtilGetParam(pAdapter, POWER_MGR_POWER_MODE, pData, sizeof(PowerMgr_PowerMode_e));
1197 *Length = sizeof(PowerMgr_PowerMode_e);
1198 return retValue;
1199 }
1200
1201
1202
1203 /*-----------------------------------------------------------------------------
1204 Routine Name: UtilPowerLevelPSGet
1205 Routine Description:
1206 Arguments:
1207 Return Value:
1208 -----------------------------------------------------------------------------*/
1209 ULONG
UtilPowerLevelPSGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1210 UtilPowerLevelPSGet(
1211 PTIWLN_ADAPTER_T pAdapter,
1212 PUCHAR pData,
1213 PULONG Length
1214 )
1215 {
1216 ULONG retValue;
1217 retValue = UtilGetParam(pAdapter, POWER_MGR_POWER_LEVEL_PS, pData, sizeof(powerAutho_PowerPolicy_e));
1218 *Length = sizeof(powerAutho_PowerPolicy_e);
1219 return retValue;
1220 }
1221
1222 /*-----------------------------------------------------------------------------
1223 Routine Name: UtilPowerLevelPSSet
1224 Routine Description:
1225 Arguments:
1226 Return Value:
1227 -----------------------------------------------------------------------------*/
1228 ULONG
UtilPowerLevelPSSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1229 UtilPowerLevelPSSet(
1230 PTIWLN_ADAPTER_T pAdapter,
1231 PUCHAR pData,
1232 PULONG Length
1233 )
1234 {
1235 ULONG retValue;
1236 retValue = UtilSetParam(pAdapter, POWER_MGR_POWER_LEVEL_PS, pData, sizeof(powerAutho_PowerPolicy_e));
1237 *Length = sizeof(powerAutho_PowerPolicy_e);
1238 return retValue;
1239 }
1240
1241 /*-----------------------------------------------------------------------------
1242 Routine Name: UtilPowerLevelDefaultGet
1243 Routine Description:
1244 Arguments:
1245 Return Value:
1246 -----------------------------------------------------------------------------*/
1247 ULONG
UtilPowerLevelDefaultGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1248 UtilPowerLevelDefaultGet(
1249 PTIWLN_ADAPTER_T pAdapter,
1250 PUCHAR pData,
1251 PULONG Length
1252 )
1253 {
1254 ULONG retValue;
1255 retValue = UtilGetParam(pAdapter, POWER_MGR_POWER_LEVEL_DEFAULT, pData, sizeof(powerAutho_PowerPolicy_e));
1256 *Length = sizeof(powerAutho_PowerPolicy_e);
1257 return retValue;
1258 }
1259
1260 /*-----------------------------------------------------------------------------
1261 Routine Name: UtilPowerLevelDefaultSet
1262 Routine Description:
1263 Arguments:
1264 Return Value:
1265 -----------------------------------------------------------------------------*/
1266 ULONG
UtilPowerLevelDefaultSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1267 UtilPowerLevelDefaultSet(
1268 PTIWLN_ADAPTER_T pAdapter,
1269 PUCHAR pData,
1270 PULONG Length
1271 )
1272 {
1273 ULONG retValue;
1274 retValue = UtilSetParam(pAdapter, POWER_MGR_POWER_LEVEL_DEFAULT, pData, sizeof(powerAutho_PowerPolicy_e));
1275 *Length = sizeof(powerAutho_PowerPolicy_e);
1276 return retValue;
1277 }
1278
1279 /*-----------------------------------------------------------------------------
1280 Routine Name: UtilPowerLevelDozeModeGet
1281 Routine Description:
1282 Arguments:
1283 Return Value:
1284 -----------------------------------------------------------------------------*/
1285 ULONG
UtilPowerLevelDozeModeGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1286 UtilPowerLevelDozeModeGet(
1287 PTIWLN_ADAPTER_T pAdapter,
1288 PUCHAR pData,
1289 PULONG Length
1290 )
1291 {
1292 ULONG retValue;
1293 retValue = UtilGetParam(pAdapter, POWER_MGR_POWER_LEVEL_DOZE_MODE, pData, sizeof(PowerMgr_PowerMode_e));
1294 *Length = sizeof(PowerMgr_PowerMode_e);
1295 return retValue;
1296 }
1297
1298 /*-----------------------------------------------------------------------------
1299 Routine Name: UtilPowerLevelDozeModeSet
1300 Routine Description:
1301 Arguments:
1302 Return Value:
1303 -----------------------------------------------------------------------------*/
1304 ULONG
UtilPowerLevelDozeModeSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1305 UtilPowerLevelDozeModeSet(
1306 PTIWLN_ADAPTER_T pAdapter,
1307 PUCHAR pData,
1308 PULONG Length
1309 )
1310 {
1311 ULONG retValue;
1312 retValue = UtilSetParam(pAdapter, POWER_MGR_POWER_LEVEL_DOZE_MODE, pData, sizeof(PowerMgr_PowerMode_e));
1313 *Length = sizeof(PowerMgr_PowerMode_e);
1314 return retValue;
1315 }
1316
1317
1318 /*-----------------------------------------------------------------------------
1319 Routine Name: UtilBeaconFilterDesiredStateSet
1320 Routine Description:
1321 Arguments:
1322 Return Value:
1323 -----------------------------------------------------------------------------*/
1324 ULONG
UtilBeaconFilterDesiredStateSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1325 UtilBeaconFilterDesiredStateSet(
1326 PTIWLN_ADAPTER_T pAdapter,
1327 PUCHAR pData,
1328 PULONG Length
1329 )
1330 {
1331 ULONG retValue;
1332
1333 retValue = UtilSetParam(pAdapter, SITE_MGR_BEACON_FILTER_DESIRED_STATE_PARAM, pData, sizeof(UINT8));
1334 *Length = sizeof(UINT8);
1335 return retValue;
1336 }
1337
1338 /*-----------------------------------------------------------------------------
1339 Routine Name: UtilBeaconFilterDesiredStateGet
1340 Routine Description: gets the current beacon filter state
1341 Arguments:
1342 Return Value:
1343 -----------------------------------------------------------------------------*/
1344 ULONG
UtilBeaconFilterDesiredStateGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1345 UtilBeaconFilterDesiredStateGet(
1346 PTIWLN_ADAPTER_T pAdapter,
1347 PUCHAR pData,
1348 PULONG Length
1349 )
1350 {
1351 ULONG retValue;
1352 retValue = UtilGetParam(pAdapter, SITE_MGR_BEACON_FILTER_DESIRED_STATE_PARAM, pData, sizeof(UINT8));
1353 *Length = sizeof(UINT8);
1354 return retValue;
1355 }
1356
1357
1358 /*-----------------------------------------------------------------------------
1359 Routine Name: UtilBssidListGet
1360 Routine Description:
1361 Arguments:
1362 Return Value:
1363 -----------------------------------------------------------------------------*/
1364 ULONG
UtilBssidListGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length,BOOLEAN ExtBssid,BOOLEAN allVarIes)1365 UtilBssidListGet(
1366 PTIWLN_ADAPTER_T pAdapter,
1367 PUCHAR pData,
1368 PULONG Length,
1369 BOOLEAN ExtBssid,
1370 BOOLEAN allVarIes
1371 )
1372 {
1373 OS_802_11_BSSID_LIST_EX* pListEx;
1374 OS_802_11_BSSID_EX* pBssidEx;
1375 OS_802_11_BSSID* pBssid;
1376 OS_802_11_BSSID_LIST* pList;
1377 paramInfo_t Param;
1378 ULONG RetSize, i;
1379 TI_STATUS Status;
1380 PUCHAR pTempData=NULL;
1381 ULONG LocalLength = sizeof(OS_802_11_BSSID_LIST_EX)+NUM_OF_SITE_TABLE*MAX_SITES_BG_BAND*sizeof(OS_802_11_BSSID);
1382
1383
1384 /****** At the callback of RSSI update the RSSI in the Site TAble in the Site Manager *
1385 Update Site Table in order to represent the RSSI of current AP correctly in the utility
1386 param.paramType = SITE_MGR_CURRENT_SIGNAL_PARAM;
1387 param.content.siteMgrCurrentSignal.rssi = pCurrBSS->averageRssi;
1388 siteMgr_setParam(pCurrBSS->hSiteMgr, ¶m);
1389 ***************************************/
1390
1391
1392 if (allVarIes)
1393 {
1394 Param.paramType = SITE_MGR_BSSID_FULL_LIST_PARAM;
1395 } else
1396 {
1397 Param.paramType = SITE_MGR_BSSID_LIST_PARAM;
1398 }
1399
1400 if (ExtBssid)
1401 {
1402 *(PULONG)&Param.content = (ULONG)pData;
1403 Param.paramLength = *Length;
1404 } else
1405 {
1406 if (*Length)
1407 {
1408 pTempData = os_memoryAlloc(pAdapter, LocalLength);
1409
1410 if (!pTempData)
1411 {
1412 *(PULONG)pData = LocalLength;
1413 *Length = 0;
1414 return NOK;
1415 }
1416
1417 *(PULONG)&Param.content = (ULONG)pTempData;
1418 Param.paramLength = *Length;
1419 } else
1420 {
1421 *Length = LocalLength;
1422 return NOK;
1423 }
1424 }
1425
1426 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
1427
1428 if (!(*Length))
1429 {
1430
1431 *Length = Param.paramLength * 4;
1432 return NOK;
1433
1434 }
1435
1436 if (Status != OK)
1437 {
1438 *(PULONG)pData = Param.paramLength;
1439 PRINT(DBG_IOCTL_LOUD, "...More buffer space needed\n");
1440 if (!ExtBssid)
1441 os_memoryFree(pAdapter, pTempData, LocalLength);
1442
1443 *Length = 0;
1444 return NOK;
1445
1446 }
1447
1448 if (!ExtBssid)
1449 {
1450
1451 pListEx = (OS_802_11_BSSID_LIST_EX*) pTempData;
1452
1453 if (pListEx->NumberOfItems)
1454 {
1455
1456 if ((sizeof(OS_802_11_BSSID_LIST) +
1457 sizeof(OS_802_11_BSSID)*pListEx->NumberOfItems -
1458 sizeof(OS_802_11_BSSID)) > *Length)
1459 {
1460 PRINT(DBG_IOCTL_LOUD, "Utility buffer is too small\n");
1461 os_memoryFree(pAdapter, pTempData, LocalLength);
1462 *Length = 0;
1463 return NOK;
1464 }
1465 if (pListEx->NumberOfItems >
1466 ((0xFFFFFFFFUL - ((ULONG)sizeof(OS_802_11_BSSID_LIST) - 1)) /
1467 (ULONG)sizeof(OS_802_11_BSSID) + 1)) /* Dm: Security fix */
1468 {
1469 printk("TI: %s - Security Error\n", __FUNCTION__);
1470 PRINT(DBG_IOCTL_LOUD, "Number of AP is too big\n");
1471 os_memoryFree(pAdapter, pTempData, LocalLength);
1472 *Length = 0;
1473 return NOK;
1474 }
1475
1476 pList = (OS_802_11_BSSID_LIST *)pData;
1477 pList->NumberOfItems = pListEx->NumberOfItems;
1478
1479 *Length = RetSize = sizeof(OS_802_11_BSSID_LIST) +
1480 sizeof(OS_802_11_BSSID)*pList->NumberOfItems -
1481 sizeof(OS_802_11_BSSID);
1482
1483 pBssidEx = pListEx->Bssid;
1484
1485 for (i=0; i<pListEx->NumberOfItems; i++)
1486 {
1487
1488 pBssid = (OS_802_11_BSSID*) pBssidEx;
1489
1490 NdisMoveMemory(&pList->Bssid[i], pBssid,
1491 sizeof(OS_802_11_BSSID));
1492
1493 pList->Bssid[i].Length = sizeof(OS_802_11_BSSID);
1494
1495 pBssidEx = (OS_802_11_BSSID_EX*) ((PUCHAR)pBssidEx +
1496 pBssidEx->Length);
1497
1498 }
1499
1500 }
1501
1502 else
1503 {
1504
1505 pList = (OS_802_11_BSSID_LIST*) pData;
1506 pList->NumberOfItems = 0;
1507
1508 RetSize = sizeof(OS_802_11_BSSID_LIST);
1509 *Length = RetSize;
1510
1511 }
1512
1513 PRINT(DBG_IOCTL_LOUD, "...Copy done.\n");
1514
1515 os_memoryFree(pAdapter, pTempData, LocalLength);
1516
1517 }
1518
1519 else
1520 {
1521
1522 RetSize = Param.paramLength;
1523 *Length = RetSize;
1524
1525 }
1526
1527 return OK;
1528 }
1529
1530
1531 /*-----------------------------------------------------------------------------
1532 Routine Name: UtilStartAppScanSet
1533 Routine Description:
1534 Arguments:
1535 Return Value:
1536 -----------------------------------------------------------------------------*/
1537 ULONG
UtilStartAppScanSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1538 UtilStartAppScanSet(
1539 PTIWLN_ADAPTER_T pAdapter,
1540 PUCHAR pData,
1541 ULONG Length
1542 )
1543 {
1544 ULONG retValue;
1545 /* scan concentrator will start an application scan */
1546 retValue = UtilSetParam(pAdapter, SCAN_CNCN_START_APP_SCAN, (PUCHAR)&pData, sizeof(PUCHAR));
1547 return retValue;
1548 }
1549
1550
1551 /*-----------------------------------------------------------------------------
1552 Routine Name: UtilStopAppScanSet
1553 Routine Description:
1554 Arguments:
1555 Return Value:
1556 -----------------------------------------------------------------------------*/
1557 ULONG
UtilStopAppScanSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1558 UtilStopAppScanSet(
1559 PTIWLN_ADAPTER_T pAdapter,
1560 PUCHAR pData,
1561 ULONG Length
1562 )
1563 {
1564 ULONG retValue;
1565 /* scan concentrator will stop the running application scan (if any) */
1566 retValue = UtilSetParam(pAdapter, SCAN_CNCN_STOP_APP_SCAN, NULL, 0);
1567 return retValue;
1568 }
1569
1570
1571 /*-----------------------------------------------------------------------------
1572 Routine Name: UtilScanPolicyParamSet
1573 Routine Description:
1574 Arguments:
1575 Return Value:
1576 -----------------------------------------------------------------------------*/
1577 ULONG
UtilScanPolicyParamSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1578 UtilScanPolicyParamSet(
1579 PTIWLN_ADAPTER_T pAdapter,
1580 PUCHAR pData,
1581 ULONG Length
1582 )
1583 {
1584 ULONG retValue;
1585
1586 applicationConfigBuffer_t applicationConfigBuffer;
1587
1588 applicationConfigBuffer.buffer = pData;
1589 applicationConfigBuffer.bufferSize = (UINT16)Length;
1590
1591 /* set the scan manager policy */
1592 retValue = UtilSetParam( pAdapter, SCAN_MNGR_SET_CONFIGURATION, (PUCHAR)&applicationConfigBuffer, sizeof(applicationConfigBuffer_t) );
1593
1594 return retValue;
1595 }
1596
1597
1598 /*-----------------------------------------------------------------------------
1599 Routine Name: UtilScanBssListGet
1600 Routine Description:
1601 Arguments:
1602 Return Value:
1603 -----------------------------------------------------------------------------*/
1604 ULONG
UtilScanBssListGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1605 UtilScanBssListGet(
1606 PTIWLN_ADAPTER_T pAdapter,
1607 PUCHAR pData,
1608 PULONG Length
1609 )
1610 {
1611 paramInfo_t param;
1612 TI_STATUS status;
1613
1614 param.paramType = SCAN_MNGR_BSS_LIST_GET;
1615 param.paramLength = sizeof(PUCHAR);
1616
1617 status = configMgr_getParam(pAdapter->CoreHalCtx, ¶m);
1618
1619 NdisMoveMemory( pData, param.content.pScanBssList, *Length );
1620 *Length = sizeof(bssList_t);
1621
1622 return status;
1623 }
1624
1625
1626 /*-----------------------------------------------------------------------------
1627 Routine Name: UtilBssidListScanOid
1628 Routine Description:
1629 Arguments:
1630 Return Value:
1631 -----------------------------------------------------------------------------*/
1632 ULONG
UtilBssidListScanOid(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1633 UtilBssidListScanOid(
1634 PTIWLN_ADAPTER_T pAdapter,
1635 PUCHAR pData,
1636 ULONG Length
1637 )
1638 {
1639 TI_STATUS Status;
1640 //TRS: Scan changes from TI
1641 Status = UtilSetParam(pAdapter, SCAN_CNCN_BSSID_LIST_SCAN_PARAM, pData, 0);
1642 //TRS: end of Scan changes from TI
1643 return Status;
1644 }
1645
1646
1647 /*-----------------------------------------------------------------------------
1648 Routine Name: UtilInfrastructureModeGet
1649 Routine Description:
1650 Arguments:
1651 Return Value:
1652 -----------------------------------------------------------------------------*/
1653 ULONG
UtilInfrastructureModeGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1654 UtilInfrastructureModeGet(
1655 PTIWLN_ADAPTER_T pAdapter,
1656 PUCHAR pData,
1657 PULONG Length
1658 )
1659 {
1660 ULONG retValue;
1661
1662 if (!Length)
1663 return NOK;
1664
1665 retValue = UtilGetParam(pAdapter, CTRL_DATA_CURRENT_BSS_TYPE_PARAM, pData, sizeof(bssType_e));
1666 *Length = sizeof(ULONG);
1667 return(retValue);
1668 }
1669
1670
1671 /*-----------------------------------------------------------------------------
1672 Routine Name: UtilDesiredInfrastructureModeGet
1673 Routine Description:
1674 Arguments:
1675 Return Value:
1676 -----------------------------------------------------------------------------*/
1677 ULONG
UtilDesiredInfrastructureModeGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1678 UtilDesiredInfrastructureModeGet(
1679 PTIWLN_ADAPTER_T pAdapter,
1680 PUCHAR pData,
1681 PULONG Length
1682 )
1683 {
1684 ULONG retValue;
1685
1686 if (!Length)
1687 return NOK;
1688
1689 retValue = UtilGetParam(pAdapter, SITE_MGR_DESIRED_BSS_TYPE_PARAM, pData, sizeof(bssType_e));
1690
1691 *Length = sizeof(ULONG);
1692 return retValue;
1693 }
1694
1695
1696 /*-----------------------------------------------------------------------------
1697 Routine Name: UtilInfrastructureModeSet
1698 Routine Description:
1699 Arguments:
1700 Return Value:
1701 -----------------------------------------------------------------------------*/
1702 ULONG
UtilInfrastructureModeSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1703 UtilInfrastructureModeSet(
1704 PTIWLN_ADAPTER_T pAdapter,
1705 PUCHAR pData,
1706 ULONG Length
1707 )
1708 {
1709 ULONG retValue;
1710 retValue = UtilSetParam(pAdapter, SITE_MGR_DESIRED_BSS_TYPE_PARAM, pData, sizeof(bssType_e));
1711 return retValue;
1712 }
1713
1714
1715 /*-----------------------------------------------------------------------------
1716 Routine Name: UtilFragmentationThresholdGet
1717 Routine Description:
1718 Arguments:
1719 Return Value:
1720 -----------------------------------------------------------------------------*/
1721 ULONG
UtilFragmentationThresholdGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1722 UtilFragmentationThresholdGet(
1723 PTIWLN_ADAPTER_T pAdapter,
1724 PUCHAR pData,
1725 PULONG Length
1726 )
1727 {
1728 UINT16 FragThreshold;
1729 ULONG retValue;
1730
1731 if (!Length)
1732 {
1733 *Length = sizeof(ULONG);
1734 return NOK;
1735 }
1736
1737 retValue = UtilGetParam(pAdapter, HAL_CTRL_FRAG_THRESHOLD_PARAM, pData, sizeof(ULONG));
1738
1739 FragThreshold = *(PUINT16)pData;
1740 *(PULONG)pData = FragThreshold;
1741
1742 *Length = sizeof(ULONG);
1743 return retValue;
1744 }
1745
1746
1747 /*-----------------------------------------------------------------------------
1748 Routine Name: UtilFragmentationThresholdSet
1749 Routine Description:
1750 Arguments:
1751 Return Value:
1752 -----------------------------------------------------------------------------*/
1753 ULONG
UtilFragmentationThresholdSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1754 UtilFragmentationThresholdSet(
1755 PTIWLN_ADAPTER_T pAdapter,
1756 PUCHAR pData,
1757 ULONG Length
1758 )
1759 {
1760 UINT16 FragThreshold = (UINT16) *(PULONG)pData;
1761 ULONG retValue;
1762
1763 FragThreshold = ((FragThreshold+1)>>1) << 1; /*make it always even(GreenA)*/
1764 retValue = UtilSetParam(pAdapter, HAL_CTRL_FRAG_THRESHOLD_PARAM, (PUCHAR)&FragThreshold, sizeof(UINT16));
1765
1766 return retValue;
1767 }
1768
1769
1770 /*-----------------------------------------------------------------------------
1771 Routine Name: UtilRtsThresholdGet
1772 Routine Description:
1773 Arguments:
1774 Return Value:
1775 -----------------------------------------------------------------------------*/
1776 ULONG
UtilRtsThresholdGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1777 UtilRtsThresholdGet(
1778 PTIWLN_ADAPTER_T pAdapter,
1779 PUCHAR pData,
1780 PULONG Length
1781 )
1782 {
1783 UINT16 RtsThreshold;
1784 ULONG retValue;
1785
1786 if (!Length)
1787 {
1788 *Length = sizeof(ULONG);
1789 return NOK;
1790 }
1791
1792 retValue = UtilGetParam(pAdapter, HAL_CTRL_RTS_THRESHOLD_PARAM, pData, sizeof(ULONG));
1793
1794 RtsThreshold = *(PUINT16)pData;
1795 *(PULONG)pData = RtsThreshold;
1796 *Length = sizeof (ULONG);
1797
1798 return retValue;
1799 }
1800
1801
1802 /*-----------------------------------------------------------------------------
1803 Routine Name: UtilSupportedRates
1804 Routine Description:
1805 Arguments:
1806 Return Value:
1807 -----------------------------------------------------------------------------*/
1808 ULONG
UtilSupportedRates(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1809 UtilSupportedRates(
1810 PTIWLN_ADAPTER_T pAdapter,
1811 PUCHAR pData,
1812 PULONG Length
1813 )
1814 {
1815 rates_t rateSet;
1816 ULONG retValue;
1817
1818 retValue = UtilGetParam(pAdapter, SITE_MGR_DESIRED_SUPPORTED_RATE_SET_PARAM, (PUCHAR)&rateSet, sizeof(rates_t));
1819
1820 NdisMoveMemory(pData, (PUCHAR)&rateSet, *Length);
1821 *Length = rateSet.len +1; /* 1 is added for the length field itself */
1822
1823 return retValue;
1824 }
1825
1826
1827 /*-----------------------------------------------------------------------------
1828 Routine Name: UtilSupportedRatesSet
1829 Routine Description:
1830 Arguments:
1831 Return Value:
1832 -----------------------------------------------------------------------------*/
1833 ULONG
UtilSupportedRatesSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1834 UtilSupportedRatesSet(
1835 PTIWLN_ADAPTER_T pAdapter,
1836 PUCHAR pData,
1837 ULONG Length
1838 )
1839 {
1840 rates_t rateSet;
1841 ULONG retValue;
1842
1843 NdisMoveMemory(&rateSet, pData, Length);
1844
1845 retValue = UtilSetParam(pAdapter, SITE_MGR_DESIRED_SUPPORTED_RATE_SET_PARAM, (PUCHAR)&rateSet, sizeof(rates_t));
1846
1847 return retValue;
1848 }
1849
1850
1851 /*-----------------------------------------------------------------------------
1852 Routine Name: UtilRtsThresholdSet
1853 Routine Description:
1854 Arguments:
1855 Return Value:
1856 -----------------------------------------------------------------------------*/
1857 ULONG
UtilRtsThresholdSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1858 UtilRtsThresholdSet(
1859 PTIWLN_ADAPTER_T pAdapter,
1860 PUCHAR pData,
1861 ULONG Length
1862 )
1863 {
1864 UINT16 RtsThreshold = (UINT16) *(PULONG)pData;
1865 ULONG retValue;
1866
1867 retValue = UtilSetParam(pAdapter, HAL_CTRL_RTS_THRESHOLD_PARAM,
1868 (PUCHAR)&RtsThreshold, sizeof(UINT16));
1869
1870 return retValue;
1871
1872 }
1873
1874
1875 /*-----------------------------------------------------------------------------
1876 Routine Name: UtilChannelGet
1877 Routine Description:
1878 Arguments:
1879 Return Value:
1880 -----------------------------------------------------------------------------*/
1881 ULONG
UtilChannelGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1882 UtilChannelGet(
1883 PTIWLN_ADAPTER_T pAdapter,
1884 PUCHAR pData,
1885 PULONG Length
1886 )
1887 {
1888 ULONG Channel,retValue;
1889
1890 if (!Length)
1891 return NOK;
1892
1893 retValue = UtilGetParam(pAdapter, SITE_MGR_CURRENT_CHANNEL_PARAM, pData, sizeof(ULONG));
1894
1895 Channel = *(PUCHAR)pData;
1896 *(PULONG)pData = (ULONG) Channel;
1897 *Length = sizeof (ULONG);
1898
1899 return retValue;
1900 }
1901
1902
1903 /*-----------------------------------------------------------------------------
1904 Routine Name: UtilDesiredChannelGet
1905 Routine Description:
1906 Arguments:
1907 Return Value:
1908 -----------------------------------------------------------------------------*/
1909 ULONG
UtilDesiredChannelGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1910 UtilDesiredChannelGet(
1911 PTIWLN_ADAPTER_T pAdapter,
1912 PUCHAR pData,
1913 PULONG Length
1914 )
1915 {
1916 ULONG Channel,retValue;
1917
1918 if (!Length)
1919 return NOK;
1920
1921 retValue = UtilGetParam(pAdapter, SITE_MGR_DESIRED_CHANNEL_PARAM, pData, sizeof(ULONG));
1922
1923 Channel = *(PUCHAR)pData;
1924 *(PULONG)pData = (ULONG) Channel;
1925 *Length = sizeof (ULONG);
1926
1927 return retValue;
1928
1929 }
1930
1931
1932 /*-----------------------------------------------------------------------------
1933 Routine Name: UtilDesiredChannelSet
1934 Routine Description:
1935 Arguments:
1936 Return Value:
1937 -----------------------------------------------------------------------------*/
1938 ULONG
UtilDesiredChannelSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1939 UtilDesiredChannelSet(
1940 PTIWLN_ADAPTER_T pAdapter,
1941 PUCHAR pData,
1942 ULONG Length
1943 )
1944 {
1945 UINT8 Channel = *pData;
1946 ULONG retValue;
1947
1948 retValue = UtilSetParam(pAdapter, SITE_MGR_DESIRED_CHANNEL_PARAM, &Channel, sizeof(UCHAR));
1949
1950 return retValue;
1951
1952 }
1953
1954
1955 /*-----------------------------------------------------------------------------
1956 Routine Name: UtilShortPreambleGet
1957 Routine Description:
1958 Arguments:
1959 Return Value:
1960 -----------------------------------------------------------------------------*/
1961 ULONG
UtilShortPreambleGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)1962 UtilShortPreambleGet(
1963 PTIWLN_ADAPTER_T pAdapter,
1964 PUCHAR pData,
1965 PULONG Length
1966 )
1967 {
1968 ULONG retValue;
1969 if (!Length)
1970 {
1971 *Length = sizeof(ULONG);
1972 return NOK;
1973 }
1974
1975 retValue = UtilGetParam(pAdapter, SITE_MGR_DESIRED_PREAMBLE_TYPE_PARAM, pData, sizeof(ULONG));
1976
1977 *Length = sizeof (ULONG);
1978
1979 return retValue;
1980
1981 }
1982
1983
1984 /*-----------------------------------------------------------------------------
1985 Routine Name: UtilShortPreambleSet
1986 Routine Description:
1987 Arguments:
1988 Return Value:
1989 -----------------------------------------------------------------------------*/
1990 ULONG
UtilShortPreambleSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)1991 UtilShortPreambleSet(
1992 PTIWLN_ADAPTER_T pAdapter,
1993 PUCHAR pData,
1994 ULONG Length
1995 )
1996 {
1997 ULONG retValue;
1998 retValue = UtilSetParam(pAdapter, SITE_MGR_DESIRED_PREAMBLE_TYPE_PARAM,
1999 pData, sizeof(ULONG));
2000
2001 return retValue;
2002
2003 }
2004
2005
2006 /*-----------------------------------------------------------------------------
2007 Routine Name: UtilRegulatoryDomain_enableDisable_802_11d
2008 Routine Description:
2009 Arguments:
2010 Return Value:
2011 -----------------------------------------------------------------------------*/
2012 ULONG
UtilRegulatoryDomain_enableDisable_802_11d(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2013 UtilRegulatoryDomain_enableDisable_802_11d(
2014 PTIWLN_ADAPTER_T pAdapter,
2015 PUCHAR pData,
2016 ULONG Length
2017 )
2018 {
2019 ULONG retValue;
2020 retValue = UtilSetParam(pAdapter, REGULATORY_DOMAIN_ENABLE_DISABLE_802_11D, pData, sizeof(UINT8));
2021
2022 return retValue;
2023
2024 }
2025
2026 /*-----------------------------------------------------------------------------
2027 Routine Name: UtilRegulatoryDomain_enableDisable_802_11h
2028 Routine Description:
2029 Arguments:
2030 Return Value:
2031 -----------------------------------------------------------------------------*/
2032 ULONG
UtilRegulatoryDomain_enableDisable_802_11h(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2033 UtilRegulatoryDomain_enableDisable_802_11h(
2034 PTIWLN_ADAPTER_T pAdapter,
2035 PUCHAR pData,
2036 ULONG Length
2037 )
2038 {
2039 ULONG retValue;
2040 retValue = UtilSetParam(pAdapter, REGULATORY_DOMAIN_ENABLE_DISABLE_802_11H, pData, sizeof(UINT8));
2041
2042 return retValue;
2043
2044 }
2045
2046
2047 /*-----------------------------------------------------------------------------
2048 Routine Name: UtilRegulatoryDomain_Get_802_11d
2049 Routine Description:
2050 Arguments:
2051 Return Value:
2052 -----------------------------------------------------------------------------*/
2053 ULONG
UtilRegulatoryDomain_Get_802_11d(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2054 UtilRegulatoryDomain_Get_802_11d(
2055 PTIWLN_ADAPTER_T pAdapter,
2056 PUCHAR pData,
2057 PULONG Length
2058 )
2059 {
2060 ULONG retValue;
2061 retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_ENABLED_PARAM, pData, sizeof(UINT8));
2062
2063 return retValue;
2064
2065 }
2066
2067 /*-----------------------------------------------------------------------------
2068 Routine Name: UtilRegulatoryDomain_Get_802_11h
2069 Routine Description:
2070 Arguments:
2071 Return Value:
2072 -----------------------------------------------------------------------------*/
2073 ULONG
UtilRegulatoryDomain_Get_802_11h(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2074 UtilRegulatoryDomain_Get_802_11h(
2075 PTIWLN_ADAPTER_T pAdapter,
2076 PUCHAR pData,
2077 PULONG Length
2078 )
2079 {
2080 ULONG retValue;
2081 retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_MANAGEMENT_CAPABILITY_ENABLED_PARAM, pData, sizeof(UINT8));
2082
2083 return retValue;
2084
2085 }
2086
2087 /*-----------------------------------------------------------------------------
2088 Routine Name: UtilRegulatoryDomain_setCountryIE
2089 Routine Description:
2090 Arguments:
2091 Return Value:
2092 -----------------------------------------------------------------------------*/
2093 static TI_STATUS
UtilRegulatoryDomain_setCountryIE(PTIWLN_ADAPTER_T pAdapter,externalParam_e ParamType,PUCHAR pData,ULONG Length)2094 UtilRegulatoryDomain_setCountryIE(
2095 PTIWLN_ADAPTER_T pAdapter,
2096 externalParam_e ParamType,
2097 PUCHAR pData,
2098 ULONG Length
2099 )
2100 {
2101 paramInfo_t Param;
2102 TI_STATUS Status;
2103 country_t countryIe;
2104
2105 Param.paramType = ParamType;
2106 Param.paramLength = sizeof(country_t);
2107 NdisMoveMemory(&countryIe, pData, Length);
2108
2109 Param.content.pCountry = &countryIe;
2110 Status = configMgr_setParam(pAdapter->CoreHalCtx, &Param);
2111
2112 return Status;
2113
2114 }
2115
2116
2117 /*-----------------------------------------------------------------------------
2118 Routine Name: UtilRegulatoryDomain_setCountryIE_2_4
2119 Routine Description:
2120 Arguments:
2121 Return Value:
2122 -----------------------------------------------------------------------------*/
2123 ULONG
UtilRegulatoryDomain_setCountryIE_2_4(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2124 UtilRegulatoryDomain_setCountryIE_2_4(
2125 PTIWLN_ADAPTER_T pAdapter,
2126 PUCHAR pData,
2127 ULONG Length)
2128 {
2129 ULONG retValue;
2130
2131 retValue = UtilRegulatoryDomain_setCountryIE(pAdapter, REGULATORY_DOMAIN_COUNTRY_2_4_PARAM, pData, sizeof(country_t));
2132
2133 return retValue;
2134
2135 }
2136
2137
2138
2139 /*-----------------------------------------------------------------------------
2140 Routine Name: UtilRegulatoryDomain_getCountryIE_2_4
2141 Routine Description:
2142 Arguments:
2143 Return Value:
2144 -----------------------------------------------------------------------------*/
2145 ULONG
UtilRegulatoryDomain_getCountryIE_2_4(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2146 UtilRegulatoryDomain_getCountryIE_2_4(
2147 PTIWLN_ADAPTER_T pAdapter,
2148 PUCHAR pData,
2149 PULONG Length
2150 )
2151 {
2152 ULONG retValue;
2153 retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_COUNTRY_2_4_PARAM, pData, COUNTRY_STRING_LEN);
2154
2155 return retValue;
2156
2157 }
2158
2159 /*-----------------------------------------------------------------------------
2160 Routine Name: UtilRegulatoryDomain_setCountryIE_5
2161 Routine Description:
2162 Arguments:
2163 Return Value:
2164 -----------------------------------------------------------------------------*/
2165 ULONG
UtilRegulatoryDomain_setCountryIE_5(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2166 UtilRegulatoryDomain_setCountryIE_5(
2167 PTIWLN_ADAPTER_T pAdapter,
2168 PUCHAR pData,
2169 ULONG Length
2170 )
2171 {
2172 ULONG retValue;
2173 retValue = UtilRegulatoryDomain_setCountryIE(pAdapter, REGULATORY_DOMAIN_COUNTRY_5_PARAM, pData, sizeof(country_t));
2174
2175 return retValue;
2176
2177 }
2178
2179
2180 /*-----------------------------------------------------------------------------
2181 Routine Name: UtilRegulatoryDomain_getCountryIE_5
2182 Routine Description:
2183 Arguments:
2184 Return Value:
2185 -----------------------------------------------------------------------------*/
2186 ULONG
UtilRegulatoryDomain_getCountryIE_5(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2187 UtilRegulatoryDomain_getCountryIE_5(
2188 PTIWLN_ADAPTER_T pAdapter,
2189 PUCHAR pData,
2190 PULONG Length
2191 )
2192 {
2193 ULONG retValue;
2194 retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_COUNTRY_5_PARAM, pData, COUNTRY_STRING_LEN);
2195
2196 return retValue;
2197
2198 }
2199
2200 /*-----------------------------------------------------------------------------
2201 Routine Name: UtilRegulatoryDomain_setMinMaxDfsChannels
2202 Routine Description:
2203 Arguments:
2204 Return Value:
2205 -----------------------------------------------------------------------------*/
2206 ULONG
UtilRegulatoryDomain_setMinMaxDfsChannels(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2207 UtilRegulatoryDomain_setMinMaxDfsChannels(
2208 PTIWLN_ADAPTER_T pAdapter,
2209 PUCHAR pData,
2210 ULONG Length
2211 )
2212 {
2213 ULONG retValue;
2214
2215 retValue = UtilSetParam(pAdapter, REGULATORY_DOMAIN_DFS_CHANNELS_RANGE, pData, sizeof(DFS_ChannelRange_t));
2216
2217 return retValue;
2218
2219 }
2220
2221
2222 /*-----------------------------------------------------------------------------
2223 Routine Name: UtilRegulatoryDomain_getMinMaxDfsChannels
2224 Routine Description:
2225 Arguments:
2226 Return Value:
2227 -----------------------------------------------------------------------------*/
2228 ULONG
UtilRegulatoryDomain_getMinMaxDfsChannels(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2229 UtilRegulatoryDomain_getMinMaxDfsChannels(
2230 PTIWLN_ADAPTER_T pAdapter,
2231 PUCHAR pData,
2232 PULONG Length
2233 )
2234 {
2235 ULONG retValue;
2236 retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_DFS_CHANNELS_RANGE, pData, sizeof(DFS_ChannelRange_t));
2237
2238 return retValue;
2239
2240 }
2241
2242
2243 /*-----------------------------------------------------------------------------
2244 Routine Name: UtilShortRetryGet
2245 Routine Description:
2246 Arguments:
2247 Return Value:
2248 -----------------------------------------------------------------------------*/
2249 ULONG
UtilShortRetryGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2250 UtilShortRetryGet(
2251 PTIWLN_ADAPTER_T pAdapter,
2252 PUCHAR pData,
2253 PULONG Length
2254 )
2255
2256 {
2257 ULONG retValue;
2258
2259
2260 txRatePolicy_t TxRatePolicy;
2261 /*
2262 * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
2263 */
2264
2265
2266 if (!Length)
2267 return sizeof(ULONG);
2268
2269 retValue = UtilGetParam(pAdapter, CTRL_DATA_SHORT_RETRY_LIMIT_PARAM,
2270 (PUCHAR)(&TxRatePolicy), sizeof(txRatePolicy_t));
2271
2272 *(PULONG)pData = TxRatePolicy.rateClass[0].shortRetryLimit;
2273
2274 return retValue;
2275 }
2276
2277
2278 /*-----------------------------------------------------------------------------
2279 Routine Name: UtilShortRetrySet
2280 Routine Description:
2281 Arguments:
2282 Return Value:
2283 -----------------------------------------------------------------------------*/
2284 ULONG
UtilShortRetrySet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2285 UtilShortRetrySet(
2286 PTIWLN_ADAPTER_T pAdapter,
2287 PUCHAR pData,
2288 ULONG Length
2289 )
2290 {
2291 ULONG retValue;
2292 txRatePolicy_t TxRatePolicy;
2293
2294 /*
2295 * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
2296 */
2297
2298
2299 TxRatePolicy.rateClass[0].shortRetryLimit = (UINT8) *(PULONG)pData;
2300
2301 retValue = UtilSetParam(pAdapter, CTRL_DATA_SHORT_RETRY_LIMIT_PARAM,
2302 (PUCHAR)(&TxRatePolicy), sizeof(txRatePolicy_t));
2303
2304 return retValue ;
2305
2306 }
2307
2308
2309 /*-----------------------------------------------------------------------------
2310 Routine Name: UtilLongRetryGet
2311 Routine Description:
2312 Arguments:
2313 Return Value:
2314 -----------------------------------------------------------------------------*/
2315 ULONG
UtilLongRetryGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2316 UtilLongRetryGet(
2317 PTIWLN_ADAPTER_T pAdapter,
2318 PUCHAR pData,
2319 PULONG Length
2320 )
2321 {
2322 ULONG retValue;
2323 txRatePolicy_t TxRatePolicy;
2324 /*
2325 * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
2326 */
2327
2328
2329 if (!Length)
2330 return NOK;
2331
2332 retValue = UtilGetParam(pAdapter, CTRL_DATA_LONG_RETRY_LIMIT_PARAM,
2333 (PUCHAR)(&TxRatePolicy), sizeof(txRatePolicy_t));
2334
2335 *(PULONG)pData = TxRatePolicy.rateClass[0].longRetryLimit;
2336 return retValue;
2337
2338 }
2339
2340
2341 /*-----------------------------------------------------------------------------
2342 Routine Name: UtilLongRetrySet
2343 Routine Description:
2344 Arguments:
2345 Return Value:
2346 -----------------------------------------------------------------------------*/
2347 ULONG
UtilLongRetrySet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2348 UtilLongRetrySet(
2349 PTIWLN_ADAPTER_T pAdapter,
2350 PUCHAR pData,
2351 ULONG Length
2352 )
2353 {
2354 txRatePolicy_t TxRatePolicy;
2355 ULONG retValue;
2356
2357 /*
2358 * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
2359 */
2360
2361
2362 TxRatePolicy.rateClass[0].longRetryLimit = (UINT8) *(PULONG)pData;
2363
2364 retValue = UtilSetParam(pAdapter, CTRL_DATA_SHORT_RETRY_LIMIT_PARAM,
2365 (PUCHAR)(&TxRatePolicy), sizeof(txRatePolicy_t));
2366
2367 return retValue;
2368 }
2369 /*-----------------------------------------------------------------------------*/
2370 ULONG
UtilDesiredRatesGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2371 UtilDesiredRatesGet(
2372 PTIWLN_ADAPTER_T pAdapter,
2373 PUCHAR pData,
2374 PULONG Length
2375 )
2376 {
2377 UCHAR rate;
2378 ULONG retValue;
2379
2380 if (!Length)
2381 return NOK;
2382
2383 retValue = UtilGetParam(pAdapter, SITE_MGR_DESIRED_TX_RATE_PARAM, (PUCHAR)&rate, sizeof(UCHAR));
2384
2385 *Length = sizeof(UCHAR);
2386 *(PUCHAR)pData = rate;
2387
2388 return retValue;
2389 }
2390
2391 /*-----------------------------------------------------------------------------
2392 Routine Name: UtilCurrentRatesGet
2393 Routine Description:
2394 Arguments:
2395 Return Value:
2396 -----------------------------------------------------------------------------*/
2397 ULONG
UtilCurrentRatesGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2398 UtilCurrentRatesGet(
2399 PTIWLN_ADAPTER_T pAdapter,
2400 PUCHAR pData,
2401 PULONG Length
2402 )
2403 {
2404 UCHAR rate;
2405 ULONG retValue;
2406
2407 rate = (UCHAR) *(PULONG)pData;
2408
2409 retValue = UtilGetParam(pAdapter, SITE_MGR_CURRENT_TX_RATE_PARAM, (PUCHAR)&rate, sizeof(UCHAR));
2410 *(PUCHAR)pData = rate;
2411 *Length = sizeof(UCHAR);
2412
2413 return retValue;
2414 }
2415
2416
2417 /*-----------------------------------------------------------------------------
2418 Routine Name: UtilConfigurationGet
2419 Routine Description:
2420 Arguments:
2421 Return Value:
2422 -----------------------------------------------------------------------------*/
2423 ULONG
UtilConfigurationGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2424 UtilConfigurationGet(
2425 PTIWLN_ADAPTER_T pAdapter,
2426 PUCHAR pData,
2427 PULONG Length
2428 )
2429 {
2430 paramInfo_t Param;
2431 ULONG retValue;
2432
2433 if (!Length)
2434 {
2435 *Length = sizeof(OS_802_11_CONFIGURATION);
2436 return NOK;
2437 }
2438
2439 Param.paramType = SITE_MGR_CONFIGURATION_PARAM;
2440 Param.paramLength = *Length;
2441 *(PULONG)&Param.content = (ULONG)pData;
2442
2443 retValue = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
2444
2445 *Length = sizeof(OS_802_11_CONFIGURATION);
2446
2447 return retValue;
2448
2449 }
2450
2451
2452 /*-----------------------------------------------------------------------------
2453 Routine Name: UtilConfigurationSet
2454 Routine Description:
2455 Arguments:
2456 Return Value:
2457 -----------------------------------------------------------------------------*/
2458 ULONG
UtilConfigurationSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2459 UtilConfigurationSet(
2460 PTIWLN_ADAPTER_T pAdapter,
2461 PUCHAR pData,
2462 ULONG Length
2463 )
2464 {
2465 paramInfo_t Param;
2466 ULONG retValue;
2467
2468 Param.paramType = SITE_MGR_CONFIGURATION_PARAM;
2469 Param.paramLength = Length;
2470 *(PULONG)&Param.content = (ULONG)pData;
2471
2472 retValue = configMgr_setParam(pAdapter->CoreHalCtx, &Param);
2473
2474 return retValue;
2475
2476 }
2477
2478 /*-----------------------------------------------------------------------------
2479 Routine Name: UtilGetCounter
2480 Routine Description:
2481 Arguments:
2482 Return Value:
2483 -----------------------------------------------------------------------------*/
2484 ULONG
UtilGetCounter(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Offset)2485 UtilGetCounter(
2486 PTIWLN_ADAPTER_T pAdapter,
2487 PUCHAR pData,
2488 ULONG Offset
2489 )
2490 {
2491 TIWLN_COUNTERS TiCounters;
2492
2493 UtilGetParam(pAdapter, SITE_MGR_TI_WLAN_COUNTERS_PARAM,
2494 (PUCHAR)&TiCounters, sizeof(TIWLN_COUNTERS));
2495
2496 NdisMoveMemory(pData, (PUCHAR)&TiCounters + Offset, sizeof(ULONG));
2497
2498 return sizeof(ULONG);
2499 }
2500
2501 /*-----------------------------------------------------------------------------
2502 Routine Name: UtilStatistics
2503 Routine Description:
2504 Arguments:
2505 Return Value:
2506 -----------------------------------------------------------------------------*/
2507 ULONG
UtilStatistics(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2508 UtilStatistics(
2509 PTIWLN_ADAPTER_T pAdapter,
2510 PUCHAR pData,
2511 PULONG Length
2512 )
2513 {
2514 TIWLN_STATISTICS* pStats;
2515 paramInfo_t Param;
2516 ULONG RetSize, data,retValue,dataSize;
2517
2518
2519 if (*Length >= sizeof(TIWLN_STATISTICS)) //TRS:GAA allow larger than needed buffer
2520 {
2521 pStats = (TIWLN_STATISTICS *) pData;
2522 NdisZeroMemory(pStats, sizeof(TIWLN_STATISTICS));
2523
2524 RetSize = sizeof(TIWLN_STATISTICS);
2525
2526 NdisMoveMemory(&pStats->currentMACAddress, pAdapter->CurrentAddr, ETH_ADDR_SIZE);
2527
2528 dataSize = sizeof(tiUINT32);
2529 if ((retValue = UtilPowerModeGet(pAdapter, (PUCHAR)&pStats->PowerMode, &dataSize)) != OK)
2530 return retValue;
2531
2532 dataSize = sizeof(OS_802_11_SSID);
2533 if ((retValue = UtilGetSSID(pAdapter, (PUCHAR)&pStats->dot11DesiredSSID, &dataSize)) != OK)
2534 return retValue;
2535
2536 dataSize = sizeof(UINT32);
2537 if ((retValue = UtilChannelGet(pAdapter, (PUCHAR)&pStats->dot11CurrentChannel, &dataSize)) != OK)
2538 return retValue;
2539
2540 dataSize = sizeof(ULONG);
2541 if ((retValue = UtilExtAuthenticationModeGet(pAdapter, (PUCHAR)&pStats->AuthenticationMode, &dataSize)) != OK)
2542 return retValue;
2543
2544 dataSize = sizeof(ULONG);
2545 if ((retValue = UtilRtsThresholdGet(pAdapter, (PUCHAR)&pStats->RTSThreshold, &dataSize)) != OK)
2546 return retValue;
2547
2548 dataSize = sizeof(ULONG);
2549 if ((retValue = UtilFragmentationThresholdGet(pAdapter, (PUCHAR)&pStats->FragmentationThreshold, &dataSize)) != OK)
2550 return retValue;
2551
2552 dataSize = sizeof(ULONG);
2553 if ((retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_CURRENT_TX_POWER_IN_DBM_PARAM,
2554 (PUCHAR)&pStats->TxPowerDbm, dataSize)) != OK)
2555 return retValue;
2556
2557 dataSize = sizeof(ULONG);
2558 if ((retValue = UtilInfrastructureModeGet(pAdapter, (PUCHAR)&pStats->dot11BSSType, &dataSize)) != OK)
2559 return retValue;
2560
2561 dataSize = sizeof(ULONG);
2562 if ((retValue = UtilWepStatusGet(pAdapter, (PUCHAR)&pStats->WEPStatus, &dataSize)) != OK)
2563 return retValue;
2564
2565 if ((retValue = UtilGetParam(pAdapter, SITE_MGR_CONNECTION_STATUS_PARAM, (PUCHAR)&pStats->dot11State, sizeof(ULONG))) != OK)
2566 return retValue;
2567
2568 pStats->dot11CurrentTxRate = pAdapter->LinkSpeed/5000;
2569
2570 if ((retValue = UtilGetParam(pAdapter, SITE_MGR_CURRENT_PREAMBLE_TYPE_PARAM, (PUCHAR)&data, sizeof(ULONG))) != OK)
2571 return retValue;
2572
2573 pStats->bShortPreambleUsed = (BOOLEAN) data;
2574
2575 Param.paramType = SITE_MGR_GET_SELECTED_BSSID_INFO;
2576 Param.content.pSiteMgrPrimarySiteDesc = &pStats->targetAP;
2577 if ((retValue = configMgr_getParam(pAdapter->CoreHalCtx, &Param)) != OK)
2578 return retValue;
2579
2580 PRINTF(DBG_IOCTL_LOUD, ("...RSSI: %d\n", pStats->targetAP.Rssi));
2581 pStats->RxLevel = pStats->targetAP.Rssi;
2582
2583 dataSize = sizeof(ULONG);
2584 if ((retValue = UtilTxAntennaGet(pAdapter, (PUCHAR)&pStats->TxAntenna, &dataSize)) != OK)
2585 return retValue;
2586
2587 dataSize = sizeof(ULONG);
2588 if ((retValue = UtilRxAntennaGet(pAdapter, (PUCHAR)&pStats->RxAntenna, &dataSize)) != OK)
2589 return retValue;
2590
2591 #ifdef EXC_MODULE_INCLUDED
2592 dataSize = sizeof(BOOL);
2593 if ((retValue = UtilExcNetworkEapGet(pAdapter, (PUCHAR)&pStats->dwSecuritySuit, &dataSize)) != OK)
2594 return retValue;
2595 if ((pStats->dwSecuritySuit==OS_EXC_NETWORK_EAP_ON) && (pStats->WEPStatus==os802_11WEPEnabled))
2596 {
2597 pStats->dwSecuritySuit = TIWLN_STAT_SECURITY_RESERVE_1;
2598 } else
2599 #else
2600 {
2601 pStats->dwSecuritySuit = 0;
2602 }
2603 #endif
2604 if ((retValue = UtilGetParam(pAdapter, RSN_SECURITY_STATE_PARAM, (PUCHAR)&pStats->dwSecurityState, sizeof(ULONG))) != OK)
2605 return retValue;
2606
2607 pStats->dwSecurityAuthStatus = 0;
2608 pStats->dwFeatureSuit = 0;
2609
2610 if ((retValue = UtilGetParam(pAdapter, SITE_MGR_TI_WLAN_COUNTERS_PARAM, (PUCHAR)&pStats->tiCounters, sizeof(TIWLN_COUNTERS))) != OK)
2611 return retValue;
2612
2613 if ((retValue = UtilGetParam(pAdapter, MLME_BEACON_RECV, (PUCHAR)&pStats->tiCounters, sizeof(TIWLN_COUNTERS))) != OK)
2614 return retValue;
2615 }
2616
2617 else
2618 {
2619
2620 NdisZeroMemory(pData, *Length);
2621 *Length = 0;
2622 return NOK;
2623
2624 }
2625
2626 *Length = RetSize;
2627 return retValue;
2628 }
2629
2630
2631 /*-----------------------------------------------------------------------------
2632 Routine Name: UtilTxStatistics
2633 Routine Description:
2634 Arguments:
2635 Return Value:
2636 -----------------------------------------------------------------------------*/
2637 ULONG
UtilTxStatistics(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG inLength,PULONG outLength)2638 UtilTxStatistics(
2639 PTIWLN_ADAPTER_T pAdapter,
2640 PUCHAR pData,
2641 ULONG inLength,
2642 PULONG outLength
2643 )
2644 {
2645 ULONG retValue;
2646 txDataCounters_t *pTxDataCounters;
2647 UINT32 resetStatsFlag;
2648
2649 if (*outLength == sizeof(TIWLN_TX_STATISTICS))
2650 {
2651 /* check whether statistics clear is also requested */
2652 resetStatsFlag = *pData;
2653
2654 /* note that only the pointer (by reference!) is passed to UtilGetParam, and the actual copying of data
2655 is done here */
2656 if ((retValue = UtilGetParam( pAdapter, TX_DATA_COUNTERS_PARAM,
2657 (PUCHAR)&pTxDataCounters, sizeof(txDataCounters_t*))) != OK)
2658 return retValue;
2659
2660 NdisMoveMemory( pData, pTxDataCounters, sizeof(TIWLN_TX_STATISTICS) );
2661
2662 *outLength = sizeof(TIWLN_TX_STATISTICS);
2663
2664 if ( 1 == resetStatsFlag )
2665 {
2666 UtilSetParam( pAdapter, TX_DATA_RESET_COUNTERS_PARAM, NULL, 0 );
2667 }
2668 } else
2669 {
2670 NdisZeroMemory(pData, *outLength);
2671 *outLength = 0;
2672 return NOK;
2673 }
2674
2675 return retValue;
2676 }
2677
2678
2679 /*-----------------------------------------------------------------------------
2680 Routine Name: UtilAddWep
2681 Routine Description:
2682 Arguments:
2683 Return Value:
2684 -----------------------------------------------------------------------------*/
2685 ULONG
UtilAddWep(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length,BOOLEAN CalledFromIoctl)2686 UtilAddWep(
2687 PTIWLN_ADAPTER_T pAdapter,
2688 PUCHAR pData,
2689 ULONG Length,
2690 BOOLEAN CalledFromIoctl
2691 )
2692 {
2693 OS_802_11_WEP* pWep;
2694 OS_802_11_KEY key;
2695 UINT32 keyIndexTxRx;
2696 TI_STATUS Status;
2697
2698 pWep = (OS_802_11_WEP*) pData;
2699
2700 if ((pWep->KeyIndex & 0x3FFFFFFF) > 3)
2701 {
2702 return 0;
2703 }
2704
2705 if (CalledFromIoctl)
2706 {
2707 NdisMoveMemory(&pAdapter->DefaultWepKeys[pWep->KeyIndex & 0x3FFFFFFF],
2708 pWep, sizeof(OS_802_11_WEP));
2709 }
2710 key.Length = pWep->Length;
2711 /* Convert the Key index to match OS_802_11_KEY index */
2712
2713 keyIndexTxRx = (pWep->KeyIndex & 0x80000000);
2714
2715 key.KeyIndex = keyIndexTxRx | /*(keyIndexTxRx>>1) |*/
2716 (pWep->KeyIndex & 0x3FFFFFFF);
2717
2718 key.KeyLength = pWep->KeyLength;
2719
2720 if( pWep->KeyLength > sizeof(key.KeyMaterial) ) { /* Dm: Security fix */
2721 printk("TI: %s - Security Error\n", __FUNCTION__);
2722 return EXTERNAL_SET_PARAM_DENIED;
2723 }
2724
2725 NdisMoveMemory(key.KeyMaterial, (void *)pWep->KeyMaterial, pWep->KeyLength);
2726 /* Set the MAC Address to zero for WEP */
2727 NdisZeroMemory(key.BSSID, sizeof(key.BSSID));
2728
2729 Status = UtilSetParam(pAdapter, RSN_ADD_KEY_PARAM,
2730 (PUCHAR)&key, sizeof(OS_802_11_KEY));
2731
2732 return Status;
2733 }
2734
2735
2736 /*-----------------------------------------------------------------------------
2737 Routine Name: UtilRemoveWep
2738 Routine Description:
2739 Arguments:
2740 Return Value:
2741 -----------------------------------------------------------------------------*/
2742 ULONG
UtilRemoveWep(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2743 UtilRemoveWep(
2744 PTIWLN_ADAPTER_T pAdapter,
2745 PUCHAR pData,
2746 ULONG Length
2747 )
2748 {
2749 UINT32 keyIndex;
2750 OS_802_11_KEY key;
2751 TI_STATUS Status;
2752
2753 keyIndex = *(UINT32*)pData;
2754
2755 /* Convert the Key index to match OS_802_11_KEY index */
2756 NdisZeroMemory(&key, sizeof(OS_802_11_KEY));
2757
2758 key.KeyIndex = keyIndex;
2759
2760 Status = UtilSetParam(pAdapter, RSN_REMOVE_KEY_PARAM,
2761 (PUCHAR)&key, sizeof(OS_802_11_KEY));
2762
2763 return(Status);
2764 }
2765
2766
2767 #define ADD_KEY_HEADER_LENGTH 26
2768
2769
2770 /*-----------------------------------------------------------------------------
2771 Routine Name: UtilAddKey
2772 Routine Description:
2773 Arguments:
2774 Return Value:
2775 -----------------------------------------------------------------------------*/
2776 ULONG
UtilAddKey(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2777 UtilAddKey(
2778 PTIWLN_ADAPTER_T pAdapter,
2779 PUCHAR pData,
2780 ULONG Length
2781 )
2782 {
2783 TI_STATUS status;
2784 OS_802_11_KEY* pKey;
2785
2786 pKey = (OS_802_11_KEY*) pData;
2787
2788 status = UtilSetParam(pAdapter, RSN_ADD_KEY_PARAM, pData, pKey->Length);
2789
2790 return status;
2791 }
2792
2793
2794 /*-----------------------------------------------------------------------------
2795 Routine Name: UtilRemoveKey
2796 Routine Description:
2797 Arguments:
2798 Return Value:
2799 -----------------------------------------------------------------------------*/
2800 ULONG
UtilRemoveKey(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2801 UtilRemoveKey(
2802 PTIWLN_ADAPTER_T pAdapter,
2803 PUCHAR pData,
2804 ULONG Length
2805 )
2806 {
2807 TI_STATUS status;
2808 OS_802_11_REMOVE_KEY *pRemoveKey;
2809 OS_802_11_KEY key;
2810
2811 pRemoveKey = (OS_802_11_REMOVE_KEY*)pData;
2812
2813 key.KeyIndex = pRemoveKey->KeyIndex;
2814 NdisMoveMemory(key.BSSID, (void *)pRemoveKey->BSSID, sizeof(key.BSSID));
2815
2816 status = UtilSetParam(pAdapter, RSN_REMOVE_KEY_PARAM,
2817 (PUCHAR)&key, sizeof(OS_802_11_KEY));
2818
2819 return(status);
2820 }
2821
2822
2823 /*-----------------------------------------------------------------------------
2824 Routine Name: UtilExtAuthenticationModeSet
2825 Routine Description:
2826 Arguments:
2827 Return Value:
2828 -----------------------------------------------------------------------------*/
2829 ULONG
UtilExtAuthenticationModeSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)2830 UtilExtAuthenticationModeSet(
2831 PTIWLN_ADAPTER_T pAdapter,
2832 PUCHAR pData,
2833 ULONG Length
2834 )
2835 {
2836 ULONG retValue;
2837
2838 retValue = UtilSetParam(pAdapter, RSN_EXT_AUTHENTICATION_MODE, pData, sizeof(ULONG));
2839
2840 return retValue;
2841 }
2842
2843
2844 /*-----------------------------------------------------------------------------
2845 Routine Name: UtilExtAuthenticationModeGet
2846 Routine Description:
2847 Arguments:
2848 Return Value:
2849 -----------------------------------------------------------------------------*/
2850 ULONG
UtilExtAuthenticationModeGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2851 UtilExtAuthenticationModeGet(
2852 PTIWLN_ADAPTER_T pAdapter,
2853 PUCHAR pData,
2854 PULONG Length
2855 )
2856 {
2857 ULONG retValue;
2858
2859 if (!Length)
2860 return NOK;
2861
2862 retValue = UtilGetParam(pAdapter, RSN_EXT_AUTHENTICATION_MODE, pData, sizeof(ULONG));
2863
2864 *Length = sizeof (ULONG);
2865
2866 return retValue;
2867 }
2868
2869
2870 /*-----------------------------------------------------------------------------
2871 Routine Name: Util802CapabilityGet
2872 Routine Description:
2873 Arguments:
2874 Return Value:
2875 -----------------------------------------------------------------------------*/
Util802CapabilityGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2876 ULONG Util802CapabilityGet(
2877 PTIWLN_ADAPTER_T pAdapter,
2878 PUCHAR pData,
2879 PULONG Length)
2880 {
2881 OS_802_11_CAPABILITY *capability_802_11;
2882 rsnAuthEncrCapability_t rsnAuthEncrCap;
2883 OS_802_11_ENCRYPTION_STATUS encrStatus = os802_11EncryptionDisabled;
2884 ULONG neededLength = 0;
2885 UINT i = 0;
2886 paramInfo_t Param;
2887 TI_STATUS status;
2888
2889 /* If length of the input buffer less than needed length, do nothing, */
2890 /* return the needed length */
2891 neededLength = sizeof(OS_802_11_CAPABILITY) +
2892 (sizeof(OS_802_11_AUTH_ENCRYPTION) * (MAX_AUTH_ENCR_PAIR -1));
2893
2894 if (*Length < neededLength)
2895 {
2896 *Length = neededLength;
2897 return NOK;
2898 }
2899
2900 NdisZeroMemory (pData, neededLength);
2901 capability_802_11 = (OS_802_11_CAPABILITY *)pData;
2902
2903 /* Fill Param fields and get the 802_11 capability information */
2904 Param.paramType = RSN_AUTH_ENCR_CAPABILITY;
2905 Param.paramLength = neededLength;
2906 Param.content.pRsnAuthEncrCapability = &rsnAuthEncrCap;
2907
2908 status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
2909
2910 if (status != OK)
2911 {
2912 /* return the default values only */
2913 /* PMKIDs is 0, AUTH/Encr pairs is 1, Auth/Encr is OPEN/NONE (0/0) */
2914 capability_802_11->Length = sizeof(OS_802_11_CAPABILITY);
2915 capability_802_11->Version = OID_CAPABILITY_VERSION;
2916 capability_802_11->NoOfPmKIDs = 0;
2917 capability_802_11->NoOfAuthEncryptPairsSupported = 1;
2918 capability_802_11->AuthEncryptionSupported[0].AuthModeSupported =
2919 os802_11AuthModeOpen;
2920 capability_802_11->AuthEncryptionSupported[0].EncryptionStatusSupported =
2921 os802_11EncryptionDisabled;
2922
2923
2924 *Length = sizeof(OS_802_11_CAPABILITY);
2925 return NOK;
2926 }
2927
2928 /* Copy the received info to the OS_802_11_CAPABILITY needed format */
2929 capability_802_11->Length = neededLength;
2930 capability_802_11->Version = OID_CAPABILITY_VERSION;
2931 capability_802_11->NoOfPmKIDs = rsnAuthEncrCap.NoOfPMKIDs;
2932 capability_802_11->NoOfAuthEncryptPairsSupported =
2933 rsnAuthEncrCap.NoOfAuthEncrPairSupported;
2934
2935 /* Convert received cipher suite type to encr.status type */
2936 for (i = 0; i < rsnAuthEncrCap.NoOfAuthEncrPairSupported; i ++)
2937 {
2938 capability_802_11->AuthEncryptionSupported[i].AuthModeSupported =
2939 (OS_802_11_AUTHENTICATION_MODE)rsnAuthEncrCap.authEncrPairs[i].authenticationMode;
2940
2941 switch (rsnAuthEncrCap.authEncrPairs[i].cipherSuite)
2942 {
2943 case RSN_CIPHER_NONE:
2944 encrStatus = os802_11EncryptionDisabled;
2945 break;
2946
2947 case RSN_CIPHER_WEP:
2948 encrStatus = os802_11WEPEnabled;
2949 break;
2950
2951 case RSN_CIPHER_TKIP:
2952 encrStatus = os802_11Encryption2Enabled;
2953 break;
2954
2955 case RSN_CIPHER_AES_CCMP:
2956 encrStatus = os802_11Encryption3Enabled;
2957 break;
2958
2959 default:
2960 encrStatus = os802_11EncryptionDisabled;
2961 break;
2962
2963 }
2964 capability_802_11->AuthEncryptionSupported[i].EncryptionStatusSupported
2965 = encrStatus;
2966 }
2967
2968 /* Success; return the actual length of the written data */
2969 *Length = neededLength;
2970 return status;
2971
2972 }
2973
2974
2975 /*-----------------------------------------------------------------------------
2976 Routine Name: Util802PmkidGet
2977 Routine Description:
2978 Arguments:
2979 Return Value:
2980 -----------------------------------------------------------------------------*/
Util802PmkidGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)2981 ULONG Util802PmkidGet(
2982 PTIWLN_ADAPTER_T pAdapter,
2983 PUCHAR pData,
2984 PULONG Length)
2985 {
2986 OS_802_11_PMKID *pPmkidList = (OS_802_11_PMKID *)pData;
2987 TI_STATUS status = NOK;
2988
2989 /* Check the data buffer size */
2990 if (*Length < sizeof(OS_802_11_PMKID))
2991 {
2992 *Length = (sizeof(OS_802_11_PMKID));
2993 return NOK;
2994 }
2995
2996 NdisZeroMemory(pData, sizeof(OS_802_11_PMKID));
2997 pPmkidList->Length = *Length;
2998
2999 status = UtilGetParam(pAdapter, RSN_PMKID_LIST, pData, *Length);
3000
3001 if (status != OK)
3002 {
3003 if (*Length < (pPmkidList->Length))
3004 *Length = pPmkidList->Length;
3005 else
3006 *Length = 0;
3007 }
3008 else
3009 {
3010 *Length = pPmkidList->Length;
3011 }
3012
3013 return status;
3014 }
3015
3016 /*-----------------------------------------------------------------------------
3017 Routine Name: Util802PmkidSet
3018 Routine Description:
3019 Arguments:
3020 Return Value:
3021 -----------------------------------------------------------------------------*/
3022 ULONG
Util802PmkidSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3023 Util802PmkidSet(
3024 PTIWLN_ADAPTER_T pAdapter,
3025 PUCHAR pData,
3026 ULONG Length
3027 )
3028 {
3029 paramInfo_t Param;
3030 TI_STATUS status;
3031
3032 Param.paramType = RSN_PMKID_LIST;
3033 Param.paramLength = Length;
3034 if( Length > sizeof(Param.content) ) { /* Dm: Security fix */
3035 printk("TI: %s - Security Error\n",__FUNCTION__);
3036 return EXTERNAL_SET_PARAM_DENIED;
3037 }
3038 NdisMoveMemory(&Param.content, pData, Length);
3039
3040 status = configMgr_setParam(pAdapter->CoreHalCtx, &Param);
3041
3042 return(status);
3043 }
3044
3045 /*-----------------------------------------------------------------------------
3046 Routine Name: Util802FSWAvailableOptionsGet
3047 Routine Description:
3048 Arguments:
3049 Return Value:
3050 -----------------------------------------------------------------------------*/
3051 ULONG
Util802FSWAvailableOptionsGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3052 Util802FSWAvailableOptionsGet(
3053 PTIWLN_ADAPTER_T pAdapter,
3054 PUCHAR pData,
3055 PULONG Length)
3056 {
3057 ULONG retValue;
3058
3059 if (!Length)
3060 {
3061 *Length = sizeof(ULONG);
3062 return NOK;
3063 }
3064
3065 retValue = UtilGetParam(pAdapter, RSN_WPA_PROMOTE_AVAILABLE_OPTIONS,
3066 pData, sizeof(ULONG));
3067 *Length = sizeof(ULONG);
3068
3069 return retValue;
3070 }
3071
3072
3073 /*-----------------------------------------------------------------------------
3074 Routine Name: Util802FSWOptionsGet
3075 Routine Description:
3076 Arguments:
3077 Return Value:
3078 -----------------------------------------------------------------------------*/
3079 ULONG
Util802FSWOptionsGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3080 Util802FSWOptionsGet(
3081 PTIWLN_ADAPTER_T pAdapter,
3082 PUCHAR pData,
3083 PULONG Length)
3084 {
3085 ULONG retValue;
3086
3087 if (!Length)
3088 {
3089 *Length = sizeof(ULONG);
3090 return NOK;
3091 }
3092
3093 retValue = UtilGetParam(pAdapter, RSN_WPA_PROMOTE_OPTIONS, pData, sizeof(ULONG));
3094
3095 *Length = sizeof(ULONG);
3096 return retValue;
3097 }
3098
3099 /*-----------------------------------------------------------------------------
3100 Routine Name: Util802FSWOptionsSet
3101 Routine Description:
3102 Arguments:
3103 Return Value:
3104 -----------------------------------------------------------------------------*/
3105
3106 ULONG
Util802FSWOptionsSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3107 Util802FSWOptionsSet(
3108 PTIWLN_ADAPTER_T pAdapter,
3109 PUCHAR pData,
3110 ULONG Length)
3111 {
3112 ULONG retValue;
3113
3114 retValue = UtilSetParam(pAdapter, RSN_WPA_PROMOTE_OPTIONS, pData, sizeof(ULONG));
3115
3116 return retValue;
3117 }
3118
3119 /*-----------------------------------------------------------------------------
3120 Routine Name: UtilWepStatusGet
3121 Routine Description:
3122 Arguments:
3123 Return Value:
3124 -----------------------------------------------------------------------------*/
3125 ULONG
UtilWepStatusGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3126 UtilWepStatusGet(
3127 PTIWLN_ADAPTER_T pAdapter,
3128 PUCHAR pData,
3129 PULONG Length
3130 )
3131 {
3132 ULONG retValue;
3133
3134 if (!Length)
3135 {
3136 *Length = sizeof(ULONG);
3137 return NOK;
3138 }
3139
3140 retValue = UtilGetParam(pAdapter, RSN_ENCRYPTION_STATUS_PARAM, pData, sizeof(ULONG));
3141
3142 *Length = sizeof(ULONG);
3143 return retValue;
3144
3145 }
3146
3147
3148 /*-----------------------------------------------------------------------------
3149 Routine Name: UtilWepStatusSet
3150 Routine Description:
3151 Arguments:
3152 Return Value:
3153 -----------------------------------------------------------------------------*/
3154 ULONG
UtilWepStatusSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3155 UtilWepStatusSet(
3156 PTIWLN_ADAPTER_T pAdapter,
3157 PUCHAR pData,
3158 ULONG Length
3159 )
3160 {
3161 ULONG retValue;
3162 retValue = UtilSetParam(pAdapter, RSN_ENCRYPTION_STATUS_PARAM, pData, sizeof(ULONG));
3163 return retValue;
3164 }
3165
3166
3167
3168 /*-----------------------------------------------------------------------------
3169 Routine Name: UtilAssociationInfoGet
3170 Routine Description:
3171 Arguments:
3172 Return Value:
3173 -----------------------------------------------------------------------------*/
3174 ULONG
UtilAssociationInfoGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3175 UtilAssociationInfoGet(
3176 PTIWLN_ADAPTER_T pAdapter,
3177 PUCHAR pData,
3178 PULONG Length
3179 )
3180 {
3181 OS_802_11_ASSOCIATION_INFORMATION *assocInformation;
3182 UINT8 *requestIEs;
3183 UINT8 *responseIEs;
3184 ULONG TotalLength = 0,retValue;
3185 paramInfo_t param;
3186
3187 if (*Length < sizeof(OS_802_11_ASSOCIATION_INFORMATION))
3188 {
3189 PRINT(DBG_IOCTL_LOUD, "...More buffer space needed\n");
3190 return(sizeof(OS_802_11_ASSOCIATION_INFORMATION));
3191 }
3192
3193 param.paramType = ASSOC_ASSOCIATION_INFORMATION_PARAM;
3194 param.paramLength = *Length;
3195
3196 retValue = configMgr_getParam(pAdapter->CoreHalCtx, ¶m);
3197
3198 TotalLength = sizeof(OS_802_11_ASSOCIATION_INFORMATION) +
3199 param.content.assocAssociationInformation.RequestIELength +
3200 param.content.assocAssociationInformation.ResponseIELength;
3201
3202 if (TotalLength <= *Length)
3203 {
3204 NdisMoveMemory(pData, (UINT8 *)¶m.content, sizeof(OS_802_11_ASSOCIATION_INFORMATION));
3205 assocInformation = (OS_802_11_ASSOCIATION_INFORMATION*)pData;
3206 requestIEs = (UINT8*)pData + sizeof(OS_802_11_ASSOCIATION_INFORMATION);
3207
3208 if (assocInformation->RequestIELength > 0)
3209 {
3210
3211 NdisMoveMemory(requestIEs, (UINT8*)assocInformation->OffsetRequestIEs,
3212 assocInformation->RequestIELength);
3213
3214 assocInformation->OffsetRequestIEs = sizeof(OS_802_11_ASSOCIATION_INFORMATION);
3215 }
3216
3217 if (assocInformation->ResponseIELength > 0)
3218 {
3219
3220 responseIEs = requestIEs + assocInformation->RequestIELength;
3221
3222 NdisMoveMemory(responseIEs, (UINT8*)assocInformation->OffsetResponseIEs,
3223 assocInformation->ResponseIELength);
3224
3225 assocInformation->OffsetResponseIEs =
3226 assocInformation->OffsetRequestIEs + assocInformation->RequestIELength;
3227 }
3228
3229 PRINTF(DBG_IOCTL_LOUD, ("UtilAssociationInfoGet: pData=%p, "
3230 "OffsetRequestIEs=0x%lx, OffsetResponseIEs=0x%lx\n",
3231 pData, (long)assocInformation->OffsetRequestIEs,
3232 (long)assocInformation->OffsetResponseIEs));
3233 } else
3234 {
3235 *(PULONG)pData = TotalLength;
3236 PRINT(DBG_IOCTL_LOUD, "...More buffer space needed\n");
3237 }
3238
3239 *Length = TotalLength;
3240 return retValue;
3241
3242 }
3243
3244 /*-----------------------------------------------------------------------------
3245 Routine Name: UtilCurrentRegDomainGet
3246 Routine Description:
3247 Arguments:
3248 Return Value:
3249 -----------------------------------------------------------------------------*/
3250 ULONG
UtilCurrentRegDomainGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3251 UtilCurrentRegDomainGet(
3252 PTIWLN_ADAPTER_T pAdapter,
3253 PUCHAR pData,
3254 PULONG Length
3255 )
3256 {
3257 ULONG retValue;
3258
3259 if (!Length)
3260 return NOK;
3261
3262 retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_CURRENT_REGULATORY_DOMAIN_PARAM, pData, sizeof(UINT8));
3263
3264 *Length = sizeof(UINT8);
3265
3266 return retValue;
3267 }
3268
3269 /*-----------------------------------------------------------------------------
3270 Routine Name: Util4xActiveStateGet
3271 Routine Description:
3272 Arguments:
3273 Return Value:
3274 -----------------------------------------------------------------------------*/
3275 ULONG
Util4xActiveStateGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3276 Util4xActiveStateGet(
3277 PTIWLN_ADAPTER_T pAdapter,
3278 PUCHAR pData,
3279 PULONG Length
3280 )
3281 {
3282 ULONG retValue;
3283 retValue = UtilGetParam(pAdapter, CTRL_DATA_FOUR_X_CURRRENT_STATUS_PARAM, pData, sizeof(UINT8));
3284 *Length = sizeof(UINT8);
3285 return retValue;
3286 }
3287
3288 /*-----------------------------------------------------------------------------
3289 Routine Name: power
3290 Routine Description:
3291 Arguments:
3292 Return Value:
3293 -----------------------------------------------------------------------------*/
power(int x,int y)3294 static int power(int x, int y)
3295 {
3296 int i = 0,z = 1;
3297
3298 for (i = 0; i < y; i++)
3299 z *= x;
3300
3301 return z;
3302 }
3303
3304 /*-----------------------------------------------------------------------------
3305 Routine Name: UtilGetSwVersion
3306 Routine Description:
3307 Arguments:
3308 Return Value:
3309 -----------------------------------------------------------------------------*/
3310 ULONG
UtilGetSwVersion(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3311 UtilGetSwVersion(
3312 PTIWLN_ADAPTER_T pAdapter,
3313 PUCHAR pData,
3314 PULONG Length
3315 )
3316 {
3317 TIWLN_VERSION* swVer;
3318 ULONG retValue,tmpLen;
3319 UCHAR FwVersion[FW_VERSION_LEN];
3320 e2Version_t EepromVersion;
3321 int i, start = 0, end = 0, temp = 0;
3322
3323 swVer = (TIWLN_VERSION *) pData;
3324
3325 swVer->DrvVersion.major = SW_VERSION_MAJOR;
3326 swVer->DrvVersion.minor = SW_VERSION_MINOR;
3327 swVer->DrvVersion.bugfix = SW_VERSION_PATCH;
3328 swVer->DrvVersion.subld = SW_VERSION_SUBLD;
3329 swVer->DrvVersion.build = SW_VERSION_BUILD;
3330
3331 NdisZeroMemory(&swVer->FWVersion, sizeof(swVer->FWVersion));
3332
3333 UtilGetParam(pAdapter, SITE_MGR_FIRMWARE_VERSION_PARAM, FwVersion, FW_VERSION_LEN);
3334
3335 /* major */
3336 start = end = temp = 4;
3337 while (FwVersion[end++] != '.');
3338 temp = end;
3339 end -= 2;
3340 for (i = end; i>= start; i--)
3341 {
3342 swVer->FWVersion.major += (FwVersion[i] - 0x30)*power(10, end - i);
3343 }
3344
3345
3346 /* minor */
3347 start = end = temp;
3348 while (FwVersion[end++] != '.');
3349 temp = end;
3350 end -= 2;
3351 for (i = end; i>= start; i--)
3352 {
3353 swVer->FWVersion.minor += (FwVersion[i] - 0x30)*power(10, end - i);
3354 }
3355
3356 /* bug fix */
3357 start = end = temp;
3358 while (FwVersion[end++] != '.');
3359 temp = end;
3360 end -= 2;
3361 for (i = end; i>= start; i--)
3362 {
3363 swVer->FWVersion.bugfix += (FwVersion[i] - 0x30)*power(10, end - i);
3364 }
3365
3366
3367 /* build */
3368 start = end = temp;
3369 while (FwVersion[end++] != '.');
3370 temp = end;
3371 end -= 2;
3372 for (i = end; i>= start; i--)
3373 {
3374 swVer->FWVersion.subld += (FwVersion[i] - 0x30)*power(10, end - i);
3375 }
3376
3377 /* minor build */
3378 start = end = temp;
3379 while (FwVersion[end++] != 0);
3380 temp = end;
3381 end -= 2;
3382 for (i = end; i>= start; i--)
3383 {
3384 swVer->FWVersion.build += (FwVersion[i] - 0x30)*power(10, end - i);
3385 }
3386
3387
3388 NdisZeroMemory(&swVer->HWVersion, sizeof(swVer->HWVersion));
3389
3390 retValue = UtilGetParam(pAdapter, SITE_MGR_EEPROM_VERSION_PARAM, (PUCHAR)&EepromVersion, sizeof(e2Version_t));
3391
3392 swVer->HWVersion.major = (UCHAR) EepromVersion.major;
3393 swVer->HWVersion.minor = (UCHAR) EepromVersion.minor;
3394 swVer->HWVersion.bugfix = (UCHAR) EepromVersion.bugfix;
3395
3396 swVer->osNdisVersion = (TIWLN_MAJOR_VERSION << 16) + TIWLN_MINOR_VERSION;
3397
3398 tmpLen = sizeof(TIWLN_VERSION);
3399
3400 if (*Length >= sizeof(TIWLN_VERSION_EX)) //TRS:GAA allow larger than needed buffer
3401 {
3402
3403 ((PTIWLN_VERSION_EX)swVer)->extVerSign = 2;
3404
3405 ((PTIWLN_VERSION_EX)swVer)->NVVersion.bugfix = EepromVersion.last;
3406
3407 ((PTIWLN_VERSION_EX)swVer)->NVVersion.minor = EepromVersion.minor;
3408
3409 ((PTIWLN_VERSION_EX)swVer)->NVVersion.major =
3410 (UCHAR)EepromVersion.major;
3411
3412 ((PTIWLN_VERSION_EX)swVer)->NVVersion.subld =
3413 (UCHAR)EepromVersion.bugfix;
3414
3415 tmpLen = sizeof(TIWLN_VERSION_EX);
3416
3417 }
3418
3419 *Length = tmpLen;
3420
3421 return retValue;
3422 }
3423
3424
3425
3426 /*-----------------------------------------------------------------------------
3427 Routine Name: UtilRxAntennaSet
3428 Routine Description:
3429 Arguments:
3430 Return Value:
3431 -----------------------------------------------------------------------------*/
3432 ULONG
UtilRxAntennaSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3433 UtilRxAntennaSet(
3434 PTIWLN_ADAPTER_T pAdapter,
3435 PUCHAR pData,
3436 ULONG Length
3437 )
3438 {
3439 ULONG retValue;
3440 retValue = UtilSetParam(pAdapter, HAL_CTRL_RX_ANTENNA_PARAM, pData, sizeof(ULONG));
3441 return retValue;
3442 }
3443
3444
3445 /*-----------------------------------------------------------------------------
3446 Routine Name: UtilRxAntennaGet
3447 Routine Description:
3448 Arguments:
3449 Return Value:
3450 -----------------------------------------------------------------------------*/
3451 ULONG
UtilRxAntennaGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3452 UtilRxAntennaGet(
3453 PTIWLN_ADAPTER_T pAdapter,
3454 PUCHAR pData,
3455 PULONG Length
3456 )
3457 {
3458 ULONG retValue;
3459
3460 if ((!Length) || (*Length == 0))
3461 return NOK;
3462
3463 retValue = UtilGetParam(pAdapter, HAL_CTRL_RX_ANTENNA_PARAM, pData, sizeof(UINT8));
3464 *Length = sizeof(UINT8);
3465 return retValue;
3466 }
3467
3468
3469 /*-----------------------------------------------------------------------------
3470 Routine Name: UtilTxAntennaSet
3471 Routine Description:
3472 Arguments:
3473 Return Value:
3474 -----------------------------------------------------------------------------*/
3475 ULONG
UtilTxAntennaSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3476 UtilTxAntennaSet(
3477 PTIWLN_ADAPTER_T pAdapter,
3478 PUCHAR pData,
3479 ULONG Length
3480 )
3481 {
3482 ULONG retValue;
3483 retValue = UtilSetParam(pAdapter, HAL_CTRL_TX_ANTENNA_PARAM, pData, sizeof(ULONG));
3484 return retValue;
3485 }
3486
3487
3488 /*-----------------------------------------------------------------------------
3489 Routine Name: UtilTxAntennaGet
3490 Routine Description:
3491 Arguments:
3492 Return Value:
3493 -----------------------------------------------------------------------------*/
3494 ULONG
UtilTxAntennaGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3495 UtilTxAntennaGet(
3496 PTIWLN_ADAPTER_T pAdapter,
3497 PUCHAR pData,
3498 PULONG Length
3499 )
3500 {
3501 ULONG retValue;
3502
3503 if ((!Length) || (*Length == 0))
3504 return NOK;
3505
3506 retValue = UtilGetParam(pAdapter, HAL_CTRL_TX_ANTENNA_PARAM, pData, sizeof(UINT8));
3507 *Length = sizeof (UINT8);
3508 return retValue;
3509 }
3510
3511
3512 /*-----------------------------------------------------------------------------
3513 Routine Name: UtilNumberOfAntennas
3514 Routine Description:
3515 Arguments:
3516 Return Value:
3517 -----------------------------------------------------------------------------*/
3518 ULONG
UtilNumberOfAntennas(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3519 UtilNumberOfAntennas(
3520 PTIWLN_ADAPTER_T pAdapter,
3521 PUCHAR pData,
3522 PULONG Length
3523 )
3524 {
3525 if ((!Length) || (*Length == 0))
3526 return NOK;
3527
3528 *(PULONG)pData = 2;
3529 *Length = sizeof(ULONG);
3530 return OK;
3531 }
3532
3533 /*-----------------------------------------------------------------------------
3534 Routine Name:
3535 UtilAntennaDivresitySet
3536 Routine Description:
3537 Arguments:
3538 Return Value:
3539 -----------------------------------------------------------------------------*/
3540 ULONG
UtilAntennaDivresitySet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3541 UtilAntennaDivresitySet(
3542 PTIWLN_ADAPTER_T pAdapter,
3543 PUCHAR pData,
3544 ULONG Length
3545 )
3546 {
3547
3548 return(UtilSetParam(pAdapter, HAL_CTRL_ANTENNA_DIVERSITY_PARAMS, pData, Length));
3549 }
3550
3551 /*-----------------------------------------------------------------------------
3552 Routine Name: UtilDriverStatusGet
3553 Routine Description:
3554 Arguments:
3555 Return Value:
3556 -----------------------------------------------------------------------------*/
3557 ULONG
UtilDriverStatusGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3558 UtilDriverStatusGet(
3559 PTIWLN_ADAPTER_T pAdapter,
3560 PUCHAR pData,
3561 PULONG Length
3562 )
3563 {
3564 ULONG retValue;
3565 retValue = UtilGetParam(pAdapter, DRIVER_STATUS_PARAM, pData, sizeof(ULONG));
3566 *Length = sizeof (ULONG);
3567 return retValue;
3568 }
3569
3570
3571 /*-----------------------------------------------------------------------------
3572 Routine Name: UtilDriverSuspend
3573 Routine Description:
3574 Arguments:
3575 Return Value:
3576 -----------------------------------------------------------------------------*/
3577 ULONG
UtilDriverSuspend(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3578 UtilDriverSuspend(
3579 PTIWLN_ADAPTER_T pAdapter,
3580 PUCHAR pData,
3581 ULONG Length
3582 )
3583 {
3584 ULONG retValue;
3585 OS_802_11_SSID FakeSsid;
3586 UINT32 loopIndex;
3587
3588 for (loopIndex = 0; loopIndex < MAX_SSID_LEN; loopIndex++)
3589 FakeSsid.Ssid[loopIndex] = (loopIndex+1);
3590
3591 FakeSsid.SsidLength = MAX_SSID_LEN;
3592 retValue = UtilSetSSID(pAdapter, (PUCHAR)&FakeSsid, sizeof(OS_802_11_SSID));
3593
3594 return retValue;
3595
3596 }
3597
3598 /*-----------------------------------------------------------------------------
3599 Routine Name: UtilDriverStatusSet
3600 Routine Description:
3601 Arguments:
3602 Return Value:
3603 -----------------------------------------------------------------------------*/
3604 ULONG
UtilDriverStatusSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3605 UtilDriverStatusSet(
3606 PTIWLN_ADAPTER_T pAdapter,
3607 PUCHAR pData,
3608 ULONG Length
3609 )
3610 {
3611 ULONG retValue;
3612
3613 if (*(PULONG)pData)
3614 {
3615 retValue = configMgr_start(pAdapter->CoreHalCtx);
3616 } else
3617 {
3618 retValue = configMgr_stop(pAdapter->CoreHalCtx);
3619 }
3620
3621 return retValue;
3622 }
3623
3624
3625 /*-----------------------------------------------------------------------------
3626 Routine Name: UtilRssiGet
3627 Routine Description:
3628 Arguments:
3629 Return Value:
3630 -----------------------------------------------------------------------------*/
3631 ULONG
UtilRssiGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3632 UtilRssiGet(
3633 PTIWLN_ADAPTER_T pAdapter,
3634 PUCHAR pData,
3635 PULONG Length
3636 )
3637 {
3638 TIWLN_STATISTICS pStats;
3639 paramInfo_t Param;
3640 ULONG retValue;
3641
3642 if (!Length)
3643 return NOK;
3644
3645 NdisZeroMemory(&pStats, sizeof(TIWLN_STATISTICS));
3646
3647 Param.paramType = SITE_MGR_GET_SELECTED_BSSID_INFO;
3648 Param.content.pSiteMgrPrimarySiteDesc = &pStats.targetAP;
3649
3650 retValue = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
3651
3652 *(PULONG)pData = pStats.targetAP.Rssi;
3653
3654 *Length = sizeof(ULONG);
3655 return retValue;
3656 }
3657
3658
3659 /*-----------------------------------------------------------------------------
3660 Routine Name: UtilDeviceSuspend
3661 Routine Description:
3662 Arguments:
3663 Return Value:
3664 -----------------------------------------------------------------------------*/
3665 VOID
UtilDeviceSuspend(PTIWLN_ADAPTER_T pAdapter)3666 UtilDeviceSuspend(
3667 PTIWLN_ADAPTER_T pAdapter
3668 )
3669 {
3670 configMgr_stop(pAdapter->CoreHalCtx);
3671 }
3672
3673
3674 /*-----------------------------------------------------------------------------
3675 Routine Name: UtilDeviceResume
3676 Routine Description:
3677 Arguments:
3678 Return Value:
3679 -----------------------------------------------------------------------------*/
3680 VOID
UtilDeviceResume(PTIWLN_ADAPTER_T pAdapter)3681 UtilDeviceResume(
3682 PTIWLN_ADAPTER_T pAdapter
3683 )
3684 {
3685 configMgr_start(pAdapter->CoreHalCtx);
3686 }
3687
3688
3689 /*-----------------------------------------------------------------------------
3690 Routine Name: UtilIbssProtectionGet
3691 Routine Description:
3692 Arguments:
3693 Return Value:
3694 -----------------------------------------------------------------------------*/
3695 ULONG
UtilIbssProtectionGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3696 UtilIbssProtectionGet(
3697 PTIWLN_ADAPTER_T pAdapter,
3698 PUCHAR pData,
3699 PULONG Length
3700 )
3701 {
3702 ULONG retValue;
3703 if (!Length)
3704 return NOK;
3705 retValue = UtilGetParam(pAdapter, CTRL_DATA_CURRENT_IBSS_PROTECTION_PARAM, pData, sizeof(ULONG));
3706 *Length = sizeof(ULONG);
3707 return retValue;
3708 }
3709
3710
3711 /*-----------------------------------------------------------------------------
3712 Routine Name: UtilIbssProtectionSet
3713 Routine Description:
3714 Arguments:
3715 Return Value:
3716 -----------------------------------------------------------------------------*/
3717 ULONG
UtilIbssProtectionSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3718 UtilIbssProtectionSet(
3719 PTIWLN_ADAPTER_T pAdapter,
3720 PUCHAR pData,
3721 ULONG Length
3722 )
3723 {
3724 ULONG retValue;
3725 retValue = UtilSetParam(pAdapter, CTRL_DATA_CURRENT_IBSS_PROTECTION_PARAM, pData, sizeof(ULONG));
3726 return retValue;
3727 }
3728
3729
3730 /*-----------------------------------------------------------------------------
3731 Routine Name: UtilShortSlotGet
3732 Routine Description:
3733 Arguments:
3734 Return Value:
3735 -----------------------------------------------------------------------------*/
3736 ULONG
UtilShortSlotGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3737 UtilShortSlotGet(
3738 PTIWLN_ADAPTER_T pAdapter,
3739 PUCHAR pData,
3740 PULONG Length
3741 )
3742 {
3743 ULONG retValue;
3744
3745 if (!Length)
3746 return NOK;
3747
3748 retValue = UtilGetParam(pAdapter, SITE_MGR_DESIRED_SLOT_TIME_PARAM, pData, sizeof(ULONG));
3749 *Length = sizeof (ULONG);
3750 return retValue;
3751 }
3752
3753
3754 /*-----------------------------------------------------------------------------
3755 Routine Name: UtilShortSlotSet
3756 Routine Description:
3757 Arguments:
3758 Return Value:
3759 -----------------------------------------------------------------------------*/
3760 ULONG
UtilShortSlotSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3761 UtilShortSlotSet(
3762 PTIWLN_ADAPTER_T pAdapter,
3763 PUCHAR pData,
3764 ULONG Length
3765 )
3766 {
3767 ULONG retValue;
3768 retValue = UtilSetParam(pAdapter, SITE_MGR_DESIRED_SLOT_TIME_PARAM, pData, sizeof(ULONG));
3769 return retValue;
3770 }
3771
3772
3773 /*-----------------------------------------------------------------------------
3774 Routine Name: UtilExtRatesIeGet
3775 Routine Description:
3776 Arguments:
3777 Return Value:
3778 -----------------------------------------------------------------------------*/
3779 ULONG
UtilExtRatesIeGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3780 UtilExtRatesIeGet(
3781 PTIWLN_ADAPTER_T pAdapter,
3782 PUCHAR pData,
3783 PULONG Length
3784 )
3785 {
3786 ULONG retValue;
3787
3788 if (!Length)
3789 return NOK;
3790
3791 retValue = UtilGetParam(pAdapter, SITE_MGR_USE_DRAFT_NUM_PARAM, pData, sizeof(ULONG));
3792
3793 *Length = sizeof(ULONG);
3794
3795 return retValue;
3796 }
3797
3798
3799 /*-----------------------------------------------------------------------------
3800 Routine Name: UtilExtRatesIeSet
3801 Routine Description:
3802 Arguments:
3803 Return Value:
3804 -----------------------------------------------------------------------------*/
3805 ULONG
UtilExtRatesIeSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3806 UtilExtRatesIeSet(
3807 PTIWLN_ADAPTER_T pAdapter,
3808 PUCHAR pData,
3809 ULONG Length
3810 )
3811 {
3812 ULONG retValue;
3813 retValue = UtilSetParam(pAdapter, SITE_MGR_USE_DRAFT_NUM_PARAM, pData, sizeof(ULONG));
3814 return retValue;
3815 }
3816
3817
3818 /*-----------------------------------------------------------------------------
3819 Routine Name: UtilQosSetParams
3820 Routine Description:
3821 Arguments:
3822 Return Value:
3823 -----------------------------------------------------------------------------*/
UtilQosSetParams(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3824 ULONG UtilQosSetParams(PTIWLN_ADAPTER_T pAdapter,
3825 PUCHAR pData,
3826 ULONG Length)
3827 {
3828 ULONG retValue;
3829 retValue = UtilSetParam(pAdapter, QOS_MNGR_SET_OS_PARAMS, pData, Length);
3830 return retValue;
3831 }
3832
3833 /*-----------------------------------------------------------------------------
3834 Routine Name: UtilQosSetParams
3835 Routine Description:
3836 Arguments:
3837 Return Value:
3838 -----------------------------------------------------------------------------*/
UtilQosSetRxTimeOut(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3839 ULONG UtilQosSetRxTimeOut(PTIWLN_ADAPTER_T pAdapter,
3840 PUCHAR pData,
3841 ULONG Length)
3842 {
3843 ULONG retValue;
3844 retValue = UtilSetParam(pAdapter, QOS_SET_RX_TIME_OUT, pData, Length);
3845 return retValue;
3846 }
3847
3848 /*-----------------------------------------------------------------------------
3849 Routine Name: UtilSetDTagToAcMappingTable
3850 Routine Description:
3851 Arguments:
3852 Return Value:
3853 -----------------------------------------------------------------------------*/
UtilSetDTagToAcMappingTable(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3854 ULONG UtilSetDTagToAcMappingTable(PTIWLN_ADAPTER_T pAdapter,
3855 PUCHAR pData,
3856 ULONG Length)
3857 {
3858 ULONG retValue;
3859 retValue = UtilSetParam(pAdapter, TX_DATA_TAG_TO_AC_CLASSIFIER_TABLE, pData, Length);
3860 return retValue;
3861 }
3862
3863 /*-----------------------------------------------------------------------------
3864 Routine Name: UtilSetVAD
3865 Routine Description:
3866 Arguments:
3867 Return Value:
3868 -----------------------------------------------------------------------------*/
UtilSetVAD(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3869 ULONG UtilSetVAD(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, ULONG Length)
3870 {
3871 ULONG retValue;
3872 retValue = UtilSetParam(pAdapter, TX_DATA_SET_VAD, pData, Length);
3873 return retValue;
3874 }
3875
UtilGetVAD(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3876 ULONG UtilGetVAD (PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, PULONG Length)
3877 {
3878 ULONG retValue;
3879 retValue = UtilGetParam(pAdapter, TX_DATA_GET_VAD , pData, sizeof(txDataVadTimerParams_t));
3880 *Length = sizeof(txDataVadTimerParams_t);
3881 return retValue;
3882 }
3883
3884 /*-----------------------------------------------------------------------------
3885 Routine Name: UtilRemoveClassifierEntry
3886 Routine Description:
3887 Arguments:
3888 Return Value:
3889 -----------------------------------------------------------------------------*/
UtilRemoveClassifierEntry(PTIWLN_ADAPTER_T pAdapter,PUCHAR ioBuffer,ULONG inBufLen)3890 ULONG UtilRemoveClassifierEntry(PTIWLN_ADAPTER_T pAdapter,
3891 PUCHAR ioBuffer,
3892 ULONG inBufLen)
3893 {
3894 ULONG retValue;
3895 retValue = UtilSetParam(pAdapter, CTRL_DATA_CLSFR_REMOVE_ENTRY,ioBuffer, inBufLen);
3896 return retValue;
3897 }
3898
3899
3900 /*-----------------------------------------------------------------------------
3901 Routine Name: UtilConfigTxClassifier
3902 Routine Description:
3903 Arguments:
3904 Return Value:
3905 -----------------------------------------------------------------------------*/
UtilConfigTxClassifier(PTIWLN_ADAPTER_T pAdapter,PUCHAR ioBuffer,ULONG inBufLen)3906 ULONG UtilConfigTxClassifier(PTIWLN_ADAPTER_T pAdapter,
3907 PUCHAR ioBuffer,
3908 ULONG inBufLen)
3909 {
3910 ULONG retValue;
3911 retValue = UtilSetParam(pAdapter, CTRL_DATA_CLSFR_CONFIG,ioBuffer, inBufLen);
3912 return retValue;
3913 }
3914
3915
3916 /*-----------------------------------------------------------------------------
3917 Routine Name: UtilGetClsfrType
3918 Routine Description:
3919 Arguments:
3920 Return Value:
3921 -----------------------------------------------------------------------------*/
UtilGetClsfrType(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3922 ULONG UtilGetClsfrType(PTIWLN_ADAPTER_T pAdapter,
3923 PUCHAR pData,
3924 PULONG Length)
3925 {
3926 ULONG retValue;
3927 retValue = UtilGetParam(pAdapter, CTRL_DATA_CLSFR_TYPE , pData, sizeof(clsfrTypeAndSupport));
3928 *Length = sizeof(clsfrTypeAndSupport);
3929 return retValue;
3930 }
3931
3932
3933 /*-----------------------------------------------------------------------------
3934 Routine Name: UtilGetAPQosParams
3935 Routine Description:
3936 Arguments:
3937 Return Value:
3938 -----------------------------------------------------------------------------*/
UtilGetAPQosParams(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3939 ULONG UtilGetAPQosParams(PTIWLN_ADAPTER_T pAdapter,
3940 PUCHAR pData,
3941 PULONG Length)
3942 {
3943 ULONG retValue;
3944 retValue = UtilSetGetParam(pAdapter, QOS_MNGR_AP_QOS_PARAMETERS , pData, sizeof(OS_802_11_AC_QOS_PARAMS));
3945 *Length = sizeof(OS_802_11_AC_QOS_PARAMS);
3946 return(retValue);
3947 }
3948
3949
3950 /*-----------------------------------------------------------------------------
3951 Routine Name: UtilGetAPQosCapabilities
3952 Routine Description:
3953 Arguments:
3954 Return Value:
3955 -----------------------------------------------------------------------------*/
UtilGetAPQosCapabilities(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3956 ULONG UtilGetAPQosCapabilities(PTIWLN_ADAPTER_T pAdapter,
3957 PUCHAR pData,
3958 PULONG Length)
3959 {
3960 ULONG retValue;
3961 *Length=sizeof(OS_802_11_AP_QOS_CAPABILITIES_PARAMS);
3962 retValue = UtilGetParam(pAdapter, SITE_MGR_GET_AP_QOS_CAPABILITIES , pData, sizeof(OS_802_11_AP_QOS_CAPABILITIES_PARAMS));
3963 return(retValue);
3964 }
3965
3966
3967 /*-----------------------------------------------------------------------------
3968 Routine Name: UtilAddTspec
3969 Routine Description:
3970 Arguments:
3971 Return Value:
3972 -----------------------------------------------------------------------------*/
UtilAddTspec(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)3973 ULONG UtilAddTspec(PTIWLN_ADAPTER_T pAdapter,
3974 PUCHAR pData,
3975 ULONG Length)
3976 {
3977 ULONG retValue;
3978 retValue = UtilSetParam(pAdapter, QOS_MNGR_ADD_TSPEC_REQUEST , pData, sizeof(OS_802_11_QOS_TSPEC_PARAMS));
3979 return retValue;
3980 }
3981
3982
3983 /*-----------------------------------------------------------------------------
3984 Routine Name: UtilGetTspecParams
3985 Routine Description:
3986 Arguments:
3987 Return Value:
3988 -----------------------------------------------------------------------------*/
UtilGetTspecParams(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)3989 ULONG UtilGetTspecParams(PTIWLN_ADAPTER_T pAdapter,
3990 PUCHAR pData,
3991 PULONG Length)
3992 {
3993 ULONG retValue;
3994 retValue = UtilSetGetParam(pAdapter, QOS_MNGR_OS_TSPEC_PARAMS , pData, sizeof(OS_802_11_QOS_TSPEC_PARAMS));
3995 *Length = sizeof(OS_802_11_QOS_TSPEC_PARAMS);
3996 return retValue;
3997 }
3998
3999
4000 /*-----------------------------------------------------------------------------
4001 Routine Name: UtilDeleteTspec
4002 Routine Description:
4003 Arguments:
4004 Return Value:
4005 -----------------------------------------------------------------------------*/
UtilDeleteTspec(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4006 ULONG UtilDeleteTspec(PTIWLN_ADAPTER_T pAdapter,
4007 PUCHAR pData,
4008 ULONG Length)
4009 {
4010 ULONG retValue;
4011 retValue = UtilSetParam(pAdapter, QOS_MNGR_DEL_TSPEC_REQUEST , pData, sizeof(OS_802_11_QOS_DELETE_TSPEC_PARAMS));
4012 return retValue;
4013 }
4014
4015
4016 /*-----------------------------------------------------------------------------
4017 Routine Name: UtilGetCurrentAcStatus
4018 Routine Description:
4019 Arguments:
4020 Return Value:
4021 -----------------------------------------------------------------------------*/
UtilGetCurrentAcStatus(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4022 ULONG UtilGetCurrentAcStatus(PTIWLN_ADAPTER_T pAdapter,
4023 PUCHAR pData,
4024 PULONG Length)
4025 {
4026 ULONG retValue;
4027 retValue = UtilSetGetParam(pAdapter, QOS_MNGR_AC_STATUS , pData, sizeof(OS_802_11_AC_UPSD_STATUS_PARAMS));
4028 *Length = sizeof(OS_802_11_AC_UPSD_STATUS_PARAMS);
4029 return retValue;
4030 }
4031
4032
4033 /*-----------------------------------------------------------------------------
4034 Routine Name: UtilGetUserPriorityOfStream
4035 Routine Description:
4036 Arguments:
4037 Return Value:
4038 -----------------------------------------------------------------------------*/
UtilGetUserPriorityOfStream(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4039 ULONG UtilGetUserPriorityOfStream(PTIWLN_ADAPTER_T pAdapter,
4040 PUCHAR pData,
4041 PULONG Length)
4042 {
4043 ULONG retValue;
4044 retValue = UtilSetGetParam(pAdapter, CTRL_DATA_GET_USER_PRIORITY_OF_STREAM , pData, sizeof(STREAM_TRAFFIC_PROPERTIES));
4045 *Length = sizeof(STREAM_TRAFFIC_PROPERTIES);
4046 return retValue;
4047 }
4048
4049
4050 /*-----------------------------------------------------------------------------
4051 Routine Name: UtilSetMediumUsageThreshold
4052 Routine Description:
4053 Arguments:
4054 Return Value:
4055 -----------------------------------------------------------------------------*/
UtilSetMediumUsageThreshold(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4056 ULONG UtilSetMediumUsageThreshold(PTIWLN_ADAPTER_T pAdapter,
4057 PUCHAR pData,
4058 ULONG Length)
4059 {
4060 ULONG retValue;
4061 retValue = UtilSetParam(pAdapter, TX_DATA_SET_MEDIUM_USAGE_THRESHOLD , pData, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS));
4062 return retValue;
4063 }
4064
4065
4066 /*-----------------------------------------------------------------------------
4067 Routine Name: UtilSetPhyRateThreshold
4068 Routine Description:
4069 Arguments:
4070 Return Value:
4071 -----------------------------------------------------------------------------*/
UtilSetPhyRateThreshold(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4072 ULONG UtilSetPhyRateThreshold(PTIWLN_ADAPTER_T pAdapter,
4073 PUCHAR pData,
4074 ULONG Length)
4075 {
4076 ULONG retValue;
4077 retValue = UtilSetParam(pAdapter, QOS_SET_RATE_THRESHOLD , pData, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS));
4078 return retValue;
4079 }
4080
4081
4082 /*-----------------------------------------------------------------------------
4083 Routine Name: UtilGetMediumUsageThreshold
4084 Routine Description:
4085 Arguments:
4086 Return Value:
4087 -----------------------------------------------------------------------------*/
UtilGetMediumUsageThreshold(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4088 ULONG UtilGetMediumUsageThreshold(PTIWLN_ADAPTER_T pAdapter,
4089 PUCHAR pData,
4090 PULONG Length)
4091 {
4092 ULONG retValue;
4093 retValue = UtilSetGetParam(pAdapter, TX_DATA_GET_MEDIUM_USAGE_THRESHOLD , pData, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS));
4094 *Length = sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS);
4095 return retValue;
4096 }
4097
4098
4099 /*-----------------------------------------------------------------------------
4100 Routine Name: UtilGetPhyRateThreshold
4101 Routine Description:
4102 Arguments:
4103 Return Value:
4104 -----------------------------------------------------------------------------*/
UtilGetPhyRateThreshold(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4105 ULONG UtilGetPhyRateThreshold(PTIWLN_ADAPTER_T pAdapter,
4106 PUCHAR pData,
4107 PULONG Length)
4108 {
4109 ULONG retValue;
4110 retValue = UtilSetGetParam(pAdapter, QOS_GET_RATE_THRESHOLD , pData, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS));
4111 *Length = sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS);
4112 return retValue;
4113 }
4114
4115
4116 /*-----------------------------------------------------------------------------
4117 Routine Name: UtilGetDesiredPsMode
4118 Routine Description:
4119 Arguments:
4120 Return Value:
4121 -----------------------------------------------------------------------------*/
UtilGetDesiredPsMode(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4122 ULONG UtilGetDesiredPsMode(PTIWLN_ADAPTER_T pAdapter,
4123 PUCHAR pData,
4124 PULONG Length)
4125 {
4126 ULONG retValue;
4127 retValue = UtilGetParam(pAdapter, QOS_MNGR_GET_DESIRED_PS_MODE , pData, sizeof(OS_802_11_QOS_DESIRED_PS_MODE));
4128 *Length = sizeof(OS_802_11_QOS_DESIRED_PS_MODE);
4129 return retValue;
4130 }
4131
4132
4133 /*-----------------------------------------------------------------------------
4134 Routine Name: UtilPollApPackets
4135 Routine Description:
4136 Arguments:
4137 Return Value:
4138 -----------------------------------------------------------------------------*/
UtilPollApPackets(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4139 ULONG UtilPollApPackets(PTIWLN_ADAPTER_T pAdapter,
4140 PUCHAR pData,
4141 ULONG Length)
4142 {
4143 ULONG retValue;
4144 retValue = configMgr_PollApPackets(pAdapter->CoreHalCtx);
4145 return retValue;
4146 }
4147
4148
4149 /*-----------------------------------------------------------------------------
4150 Routine Name: UtilPollApPacketsFromAC
4151 Routine Description:
4152 Arguments:
4153 Return Value:
4154 -----------------------------------------------------------------------------*/
UtilPollApPacketsFromAC(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4155 ULONG UtilPollApPacketsFromAC(PTIWLN_ADAPTER_T pAdapter,
4156 PUCHAR pData,
4157 ULONG Length)
4158 {
4159 ULONG retValue;
4160 retValue = UtilSetParam(pAdapter, TX_DATA_POLL_AP_PACKETS_FROM_AC , (unsigned char *)pData, Length);
4161 return retValue;
4162 }
4163
4164
4165 /*-----------------------------------------------------------------------------
4166 Routine Name: UtilEnableEvent
4167 Routine Description:
4168 Arguments:
4169 Return Value:
4170 -----------------------------------------------------------------------------*/
UtilEnableEvent(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4171 ULONG UtilEnableEvent(PTIWLN_ADAPTER_T pAdapter,
4172 PUCHAR pData,
4173 ULONG Length)
4174 {
4175 /*UtilSetParam(pAdapter, , pData, Length); EITAN TBD */
4176 return PARAM_NOT_SUPPORTED;
4177 }
4178
4179
4180 /*-----------------------------------------------------------------------------
4181 Routine Name: UtilDisableEvent
4182 Routine Description:
4183 Arguments:
4184 Return Value:
4185 -----------------------------------------------------------------------------*/
UtilDisableEvent(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4186 ULONG UtilDisableEvent(PTIWLN_ADAPTER_T pAdapter,
4187 PUCHAR pData,
4188 ULONG Length)
4189 {
4190 /*UtilSetParam(pAdapter, , pData, Length); EITAN TBD */
4191 return PARAM_NOT_SUPPORTED;
4192 }
4193
4194
4195 /*-----------------------------------------------------------------------------
4196 Routine Name: UtilConfigRSSI
4197 Routine Description:
4198 Arguments:
4199 Return Value:
4200 -----------------------------------------------------------------------------*/
UtilConfigRSSI(PTIWLN_ADAPTER_T pAdapter,UINT32 pData,ULONG Length)4201 ULONG UtilConfigRSSI(PTIWLN_ADAPTER_T pAdapter,
4202 UINT32 pData,
4203 ULONG Length)
4204 {
4205 ULONG retValue;
4206 retValue = UtilSetParam(pAdapter, SITE_MGR_DESIRED_RSSI_THRESHOLD_SET , (unsigned char *)pData, Length);
4207 return retValue;
4208 }
4209
4210
4211 /*-----------------------------------------------------------------------------
4212 Routine Name: UtilConfigPERLevel
4213 Routine Description:
4214 Arguments:
4215 Return Value:
4216 -----------------------------------------------------------------------------*/
UtilConfigPERLevel(PTIWLN_ADAPTER_T pAdapter,UINT32 pData,ULONG Length)4217 ULONG UtilConfigPERLevel(PTIWLN_ADAPTER_T pAdapter,
4218 UINT32 pData,
4219 ULONG Length)
4220 {
4221 ULONG retValue;
4222 retValue = UtilSetParam(pAdapter, SITE_MGR_DESIRED_TX_RATE_PRCT_SET , (unsigned char *)pData, Length);
4223 return retValue;
4224 }
4225
4226
4227 /*-----------------------------------------------------------------------------
4228 Routine Name: UtilGetDrvCapabilities
4229 Routine Description:
4230 Arguments:
4231 Return Value:
4232 -----------------------------------------------------------------------------*/
UtilGetDrvCapabilities(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4233 ULONG UtilGetDrvCapabilities(PTIWLN_ADAPTER_T pAdapter,
4234 PUCHAR pData,
4235 PULONG Length)
4236 {
4237 /*UtilSetParam(pAdapter, , pData, Length); EITAN TBD */
4238 return PARAM_NOT_SUPPORTED;
4239 }
4240
4241
4242 /*-----------------------------------------------------------------------------
4243 Routine Name: UtilGetPrimaryBSSIDInfo
4244 Routine Description:
4245 Arguments:
4246 Return Value:
4247 -----------------------------------------------------------------------------*/
UtilGetPrimaryBSSIDInfo(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4248 ULONG UtilGetPrimaryBSSIDInfo(PTIWLN_ADAPTER_T pAdapter,
4249 PUCHAR pData,
4250 PULONG Length)
4251 {
4252 paramInfo_t Param;
4253 TI_STATUS Status;
4254
4255 if ( *Length < sizeof(OS_802_11_BSSID_EX) )
4256 {
4257 PRINTF(DBG_NDIS_OIDS_ERROR, ("UtilGetPrimaryBSSIDInfo: ERROR Length is:%ld < %d\n",
4258 *Length, sizeof(OS_802_11_BSSID)) );
4259 return NOK;
4260 }
4261
4262 Param.paramType = SITE_MGR_PRIMARY_SITE_PARAM;
4263 Param.paramLength = *Length;
4264 Param.content.pSiteMgrSelectedSiteInfo = (OS_802_11_BSSID_EX*)pData;
4265 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
4266
4267 if(Status != OK) {
4268 PRINTF(DBG_NDIS_OIDS_ERROR, (" UtilGetPrimaryBSSIDInfo: ERROR on return from get param SITE_MGR_PRIMARY_SITE_PARAM\n"));
4269 }
4270 else
4271 {
4272 *Length = Param.paramLength;
4273 }
4274
4275 return Status;
4276 }
4277
4278 /*-----------------------------------------------------------------------------
4279 Routine Name: UtilGetSelectedBSSIDInfo
4280 Routine Description:
4281 Arguments:
4282 Return Value:
4283 -----------------------------------------------------------------------------*/
UtilGetSelectedBSSIDInfo(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4284 ULONG UtilGetSelectedBSSIDInfo(PTIWLN_ADAPTER_T pAdapter,
4285 PUCHAR pData,
4286 PULONG Length)
4287 {
4288 paramInfo_t Param;
4289 TI_STATUS Status;
4290
4291 if ( *Length < sizeof(OS_802_11_BSSID_EX) )
4292 {
4293 PRINTF(DBG_NDIS_OIDS_ERROR, ("UtilGetSelectedBSSIDInfo: ERROR Length is:%ld < %d",
4294 *Length, sizeof(OS_802_11_BSSID)) );
4295 return NOK;
4296 }
4297
4298 Param.paramType = SITE_MGR_GET_SELECTED_BSSID_INFO;
4299 Param.paramLength = *Length;
4300 Param.content.pSiteMgrPrimarySiteDesc = (OS_802_11_BSSID*)pData;
4301 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
4302
4303 if(Status != OK)
4304 {
4305 PRINTF(DBG_NDIS_OIDS_ERROR, (" UtilGetSelectedBSSIDInfo: ERROR on return from get param SITE_MGR_GET_SELECTED_BSSID_INFO"));
4306 }
4307
4308 return Status;
4309 }
4310
4311
4312 /*-----------------------------------------------------------------------------
4313 Routine Name: UtilGetDriverState
4314 Routine Description:
4315 Arguments:
4316 Return Value:
4317 -----------------------------------------------------------------------------*/
UtilGetDriverState(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4318 ULONG UtilGetDriverState (PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, PULONG Length)
4319 {
4320 ULONG retValue;
4321 retValue = UtilGetParam(pAdapter, SME_SM_STATE_PARAM , pData, *Length);
4322 *Length = sizeof (ULONG);
4323 return retValue;
4324 }
4325
4326
4327 /*#ifdef NDIS51_MINIPORT*/
4328
4329 /*-----------------------------------------------------------------------------
4330 Routine Name: UtilPrivacyFilterGet
4331 Routine Description:
4332 Arguments:
4333 Return Value:
4334 -----------------------------------------------------------------------------*/
4335 ULONG
UtilPrivacyFilterGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4336 UtilPrivacyFilterGet(
4337 PTIWLN_ADAPTER_T pAdapter,
4338 PUCHAR pData,
4339 PULONG Length
4340 )
4341 {
4342 ULONG WepStatus,retValue,dataSize;
4343
4344 if (!Length)
4345 return NOK;
4346
4347 dataSize = sizeof (ULONG);
4348 retValue = UtilWepStatusGet(pAdapter, (PUCHAR)&WepStatus, &dataSize);
4349
4350 if (WepStatus)
4351 {
4352 *(PULONG)pData = os802_11PrivFilterAcceptAll;
4353 } else
4354 {
4355 *(PULONG)pData = os802_11PrivFilter8021xWEP;
4356 }
4357 *Length = sizeof (ULONG);
4358
4359 return retValue;
4360 }
4361
4362
4363 /*-----------------------------------------------------------------------------
4364 Routine Name: UtilPrivacyFilterSet
4365 Routine Description:
4366 Arguments:
4367 Return Value:
4368 -----------------------------------------------------------------------------*/
4369 ULONG
UtilPrivacyFilterSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4370 UtilPrivacyFilterSet(
4371 PTIWLN_ADAPTER_T pAdapter,
4372 PUCHAR pData,
4373 ULONG Length
4374 )
4375 {
4376 ULONG WepStatus,dataSize,retValue;
4377
4378 dataSize = sizeof(ULONG);
4379 retValue = UtilWepStatusGet(pAdapter, (PUCHAR)&WepStatus, &dataSize);
4380
4381 if ((WepStatus && (*(PULONG)pData == os802_11PrivFilter8021xWEP)) || (retValue != OK))
4382 return NOK; /* was return -1 */
4383
4384 if ((!WepStatus) && (retValue == OK))
4385 {
4386 *(PULONG)pData = 0;
4387 retValue = UtilSetParam(pAdapter, RX_DATA_EXCLUDE_UNENCRYPTED_PARAM, pData, sizeof(ULONG));
4388 }
4389
4390 return retValue;
4391 }
4392
4393
4394
4395 /*#endif*/
4396
4397 /*-----------------------------------------------------------------------------
4398 Routine Name: UtilReadReg
4399 Routine Description:
4400 Arguments:
4401 Return Value:
4402 -----------------------------------------------------------------------------*/
4403 ULONG
UtilReadReg(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4404 UtilReadReg(
4405 PTIWLN_ADAPTER_T pAdapter,
4406 PUCHAR pData,
4407 PULONG Length
4408 )
4409 {
4410 TIWLN_REG_RW * pReg;
4411
4412 pReg = (TIWLN_REG_RW *) pData;
4413
4414 #if defined(TNETW1150)
4415 if (pReg->regAddr >= 0x3C0000)
4416 pReg->regValue = configMgr_ReadPhyRegister(pAdapter->CoreHalCtx, pReg->regAddr);
4417 else
4418 pReg->regValue = configMgr_ReadMacRegister(pAdapter->CoreHalCtx, pReg->regAddr);
4419 #else
4420 if (pReg->regAddr >= 0x1000)
4421 pReg->regValue = configMgr_ReadPhyRegister(pAdapter->CoreHalCtx, pReg->regAddr);
4422 else
4423 pReg->regValue = configMgr_ReadMacRegister(pAdapter->CoreHalCtx, pReg->regAddr);
4424 #endif
4425
4426
4427 #ifdef __LINUX__
4428 print_info("Register %#x=%#x(%d)\n", pReg->regAddr, pReg->regValue, pReg->regValue );
4429 #endif
4430 *Length = sizeof(TIWLN_REG_RW);
4431 return OK;
4432 }
4433
4434 /*-----------------------------------------------------------------------------
4435 Routine Name: UtilWriteReg
4436 Routine Description:
4437 Arguments:
4438 Return Value:
4439 -----------------------------------------------------------------------------*/
4440 ULONG
UtilWriteReg(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4441 UtilWriteReg(
4442 PTIWLN_ADAPTER_T pAdapter,
4443 PUCHAR pData,
4444 ULONG Length
4445 )
4446 {
4447 TIWLN_REG_RW * pReg;
4448
4449 pReg = (TIWLN_REG_RW *) pData;
4450
4451 #if defined(TNETW1150)
4452 if (pReg->regAddr >= 0x3C0000)
4453 configMgr_WritePhyRegister(pAdapter->CoreHalCtx, pReg->regAddr, pReg->regValue);
4454 else
4455 configMgr_WriteMacRegister(pAdapter->CoreHalCtx, pReg->regAddr, pReg->regValue);
4456 #else
4457 if (pReg->regAddr >= 0x1000)
4458 configMgr_WritePhyRegister(pAdapter->CoreHalCtx, pReg->regAddr, pReg->regValue);
4459 else
4460 configMgr_WriteMacRegister(pAdapter->CoreHalCtx, pReg->regAddr, pReg->regValue);
4461 #endif
4462
4463 return OK;
4464 }
4465
4466
4467
4468 /*-----------------------------------------------------------------------------
4469 Routine Name: UtilDisassociate
4470 Routine Description:
4471 Arguments:
4472 Return Value:
4473 -----------------------------------------------------------------------------*/
4474 ULONG
UtilDisassociate(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4475 UtilDisassociate(
4476 PTIWLN_ADAPTER_T pAdapter,
4477 PUCHAR pData,
4478 ULONG Length
4479 )
4480 {
4481 OS_802_11_SSID FakeSsid;
4482 UINT32 loopIndex;
4483 ULONG retValue;
4484
4485 /*
4486 * Clean up desired SSID value
4487 */
4488 for (loopIndex = 0; loopIndex < MAX_SSID_LEN; loopIndex++)
4489 FakeSsid.Ssid[loopIndex] = (loopIndex+1);
4490
4491 FakeSsid.SsidLength = MAX_SSID_LEN;
4492
4493 retValue = UtilSetSSID(pAdapter, (PUCHAR)&FakeSsid, sizeof(OS_802_11_SSID));
4494
4495 return retValue;
4496 }
4497
4498 /*-----------------------------------------------------------------------------
4499 Routine Name: UtilInfoCodeQueryInformation
4500 Routine Description:
4501 Arguments:
4502 Return Value:
4503 -----------------------------------------------------------------------------*/
4504 ULONG
UtilInfoCodeQueryInformation(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4505 UtilInfoCodeQueryInformation(
4506 PTIWLN_ADAPTER_T pAdapter,
4507 PUCHAR pData,
4508 PULONG Length
4509 )
4510 {
4511 UINT32 InfoCode, retVal, PureInfoLength;
4512 ULONG dataSize;
4513 PRINT(DBG_IOCTL_LOUD, "UtilInfoCodeQueryInformation\n");
4514
4515 retVal = OK;
4516
4517 if (*Length<sizeof(InfoCode))
4518 {
4519 *Length = sizeof(ULONG);
4520 return NOK;
4521 }
4522
4523 InfoCode = *((UINT32*)pData);
4524 #ifndef _WINDOWS
4525 PureInfoLength = *Length - sizeof(InfoCode);
4526 #else
4527 #endif
4528
4529 switch (InfoCode)
4530 {
4531 case VAL_TX_POWER_VALUE:
4532 PRINT(DBG_IOCTL_LOUD, "case VAL_TX_POWER_VALUE (100)\n");
4533 retVal = UtilGetTxPowerValue(pAdapter, REGULATORY_DOMAIN_CURRENT_TX_POWER_IN_DBM_PARAM, pData, PureInfoLength);
4534 break;
4535 case VAL_NETWORK_TYPE:
4536 PRINT(DBG_IOCTL_LOUD, "case VAL_NETWORK_TYPE (101)\n");
4537 dataSize = PureInfoLength;
4538 retVal = UtilNetworkTypeInUseGet(pAdapter, pData, &dataSize);
4539 break;
4540 case VAL_AP_TX_POWER_LEVEL:
4541 PRINT(DBG_IOCTL_LOUD, "case VAL_AP_TX_POWER_LEVEL (102)\n");
4542 retVal = UtilGetAPTxPowerLevel(pAdapter, SITE_MGR_AP_TX_POWER_PARAM, pData, PureInfoLength);
4543 break;
4544 case VAL_PACKET_BURSTING:
4545 PRINT(DBG_IOCTL_LOUD, "case VAL_PACKET_BURSTING (106)\n");
4546 retVal = UtilGetPacketBursting(pAdapter, QOS_PACKET_BURST_ENABLE, pData, PureInfoLength);
4547 break;
4548 case VAL_MIXED_MODE:
4549 dataSize = PureInfoLength;
4550 retVal = UtilGetMixedMode(pAdapter, RSN_MIXED_MODE, pData, &dataSize);
4551 break;
4552 case VAL_DEFAULT_KEY_ID:
4553 PRINT(DBG_IOCTL_LOUD, "case VAL_DEFAULT_KEY_ID (110)\n");
4554 dataSize = PureInfoLength;
4555 retVal = UtilGetDefaultKeyId(pAdapter, RSN_DEFAULT_KEY_ID, pData, &dataSize);
4556 break;
4557 default:
4558 PRINT(DBG_IOCTL_LOUD, "case default\n");
4559 break;
4560 }
4561 *Length = PureInfoLength;
4562 return retVal;
4563 }
4564
4565 /*-----------------------------------------------------------------------------
4566 Routine Name: UtilInfoCodeSetInformation
4567 Routine Description:
4568 Arguments:
4569 Return Value:
4570 -----------------------------------------------------------------------------*/
4571 ULONG
UtilInfoCodeSetInformation(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4572 UtilInfoCodeSetInformation(
4573 PTIWLN_ADAPTER_T pAdapter,
4574 PUCHAR pData,
4575 ULONG Length
4576 )
4577 {
4578 UINT32 InfoCode, retVal, PureInfoLength;
4579
4580 PRINT(DBG_IOCTL_LOUD, "UtilInfoCodeSetInformation\n");
4581
4582 if (Length<sizeof(UINT32))
4583 return NOK;
4584
4585 InfoCode = *((UINT32*)pData);
4586 retVal = PureInfoLength = Length - sizeof(InfoCode);
4587
4588 switch (InfoCode)
4589 {
4590 case VAL_TX_POWER_VALUE:
4591 PRINT(DBG_IOCTL_LOUD, "case VAL_TX_POWER_VALUE (100)\n");
4592 retVal = UtilSetParam(pAdapter, REGULATORY_DOMAIN_CURRENT_TX_POWER_IN_DBM_PARAM, pData+sizeof(InfoCode), PureInfoLength);
4593 break;
4594 case VAL_NETWORK_TYPE:
4595 PRINT(DBG_IOCTL_LOUD, "case VAL_NETWORK_TYPE (101)\n");
4596 retVal = UtilNetworkTypeInUseSet(pAdapter, pData+sizeof(InfoCode), PureInfoLength);
4597 break;
4598 case VAL_PACKET_BURSTING:
4599 PRINT(DBG_IOCTL_LOUD, "case VAL_PACKET_BURSTING (106)\n");
4600 retVal = UtilSetPacketBursting(pAdapter, pData+sizeof(InfoCode), PureInfoLength);
4601 break;
4602 case VAL_MIXED_MODE:
4603 retVal = UtilSetMixedMode(pAdapter, pData+sizeof(InfoCode), PureInfoLength);
4604 break;
4605 case VAL_DEFAULT_KEY_ID:
4606 retVal = UtilSetParam(pAdapter, RSN_DEFAULT_KEY_ID, pData+sizeof(InfoCode), PureInfoLength);
4607 break;
4608 default:
4609 PRINT(DBG_IOCTL_LOUD, "case default\n");
4610 break;
4611 }
4612 return retVal;
4613 }
4614
4615 #ifdef _WINDOWS
4616 #endif /* _WINDOWS */
4617
4618 /*-----------------------------------------------------------------------------
4619 Routine Name: UtilTxPowerLevelDbmGet
4620 Routine Description:
4621 Arguments:
4622 Return Value:
4623 -----------------------------------------------------------------------------*/
4624 ULONG
UtilTxPowerLevelDbmGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4625 UtilTxPowerLevelDbmGet(
4626 PTIWLN_ADAPTER_T pAdapter,
4627 PUCHAR pData,
4628 PULONG Length
4629 )
4630 {
4631 ULONG retValue;
4632
4633 if (!Length)
4634 return NOK;
4635
4636 retValue = UtilGetParam(pAdapter, REGULATORY_DOMAIN_CURRENT_TX_POWER_IN_DBM_PARAM, pData, sizeof(UINT8));
4637 *Length = sizeof(INT8);
4638
4639 return retValue;
4640 }
4641
4642
4643 /*-----------------------------------------------------------------------------
4644 Routine Name: UtilTxPowerLevelDbmSet
4645 Routine Description:
4646 Arguments:
4647 Return Value:
4648 -----------------------------------------------------------------------------*/
4649 ULONG
UtilTxPowerLevelDbmSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4650 UtilTxPowerLevelDbmSet(
4651 PTIWLN_ADAPTER_T pAdapter,
4652 PUCHAR pData,
4653 ULONG Length
4654 )
4655 {
4656 ULONG mW, Dbm, power,retValue;
4657
4658 if (!Length)
4659 return NOK;
4660
4661 mW = *(PULONG)pData;
4662
4663 for (power=1; mW/10; mW/=10, power++);
4664
4665 Dbm = 20 * power;
4666
4667
4668 retValue = UtilSetParam(pAdapter, REGULATORY_DOMAIN_CURRENT_TX_POWER_IN_DBM_PARAM, (PUCHAR)&Dbm, sizeof(ULONG));
4669 return retValue;
4670 }
4671
4672 /*-----------------------------------------------------------------------------
4673 Routine Name: Util802EapTypeGet
4674 Routine Description:
4675 Arguments:
4676 Return Value:
4677 -----------------------------------------------------------------------------*/
4678 ULONG
Util802EapTypeGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4679 Util802EapTypeGet(
4680 PTIWLN_ADAPTER_T pAdapter,
4681 PUCHAR pData,
4682 PULONG Length
4683 )
4684 {
4685 ULONG retValue;
4686 retValue = UtilGetParam(pAdapter, RSN_EAP_TYPE, pData, sizeof(ULONG));
4687 *Length = sizeof(ULONG);
4688 return retValue;
4689 }
4690
4691 /*-----------------------------------------------------------------------------
4692 Routine Name: Util802EapTypeSet
4693 Routine Description:
4694 Arguments:
4695 Return Value:
4696 -----------------------------------------------------------------------------*/
4697 ULONG
Util802EapTypeSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4698 Util802EapTypeSet(
4699 PTIWLN_ADAPTER_T pAdapter,
4700 PUCHAR pData,
4701 ULONG Length
4702 )
4703 {
4704 ULONG retValue;
4705 retValue = UtilSetParam(pAdapter, RSN_EAP_TYPE, pData, sizeof(ULONG));
4706 return retValue;
4707 }
4708
4709 #ifdef EXC_MODULE_INCLUDED
4710
4711 /*-----------------------------------------------------------------------------
4712 Routine Name: UtilExcConfigurationGet
4713 Routine Description:
4714 Arguments:
4715 Return Value:
4716 -----------------------------------------------------------------------------*/
4717 ULONG
UtilExcConfigurationGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4718 UtilExcConfigurationGet(
4719 PTIWLN_ADAPTER_T pAdapter,
4720 PUCHAR pData,
4721 PULONG Length
4722 )
4723 {
4724 ULONG retValue;
4725 retValue = UtilGetParam(pAdapter, EXC_CONFIGURATION, pData, sizeof(ULONG));
4726 *Length = sizeof(ULONG);
4727 return retValue;
4728 }
4729
4730 /*-----------------------------------------------------------------------------
4731 Routine Name: UtilExcNetworkEapGet
4732 Routine Description:
4733 Arguments:
4734 Return Value:
4735 -----------------------------------------------------------------------------*/
4736 ULONG
UtilExcNetworkEapGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4737 UtilExcNetworkEapGet(
4738 PTIWLN_ADAPTER_T pAdapter,
4739 PUCHAR pData,
4740 PULONG Length
4741 )
4742 {
4743 ULONG retValue;
4744 retValue = UtilGetParam(pAdapter, RSN_EXC_NETWORK_EAP, pData, sizeof(ULONG));
4745 *Length = sizeof(ULONG);
4746 return retValue;
4747 }
4748
4749 /*-----------------------------------------------------------------------------
4750 Routine Name: UtilExcConfigurationSet
4751 Routine Description:
4752 Arguments:
4753 Return Value:
4754 -----------------------------------------------------------------------------*/
4755 ULONG
UtilExcConfigurationSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4756 UtilExcConfigurationSet(
4757 PTIWLN_ADAPTER_T pAdapter,
4758 PUCHAR pData,
4759 ULONG Length
4760 )
4761 {
4762 ULONG retValue;
4763 retValue = UtilSetParam(pAdapter, EXC_CONFIGURATION, pData, sizeof(ULONG));
4764 return retValue;
4765 }
4766
4767 /*-----------------------------------------------------------------------------
4768 Routine Name: UtilExcNetworkEapSet
4769 Routine Description:
4770 Arguments:
4771 Return Value:
4772 -----------------------------------------------------------------------------*/
4773 ULONG
UtilExcNetworkEapSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4774 UtilExcNetworkEapSet(
4775 PTIWLN_ADAPTER_T pAdapter,
4776 PUCHAR pData,
4777 ULONG Length
4778 )
4779 {
4780 ULONG retValue;
4781 retValue = UtilSetParam(pAdapter, RSN_EXC_NETWORK_EAP, pData, sizeof(ULONG));
4782 return retValue;
4783 }
4784
4785
4786 /*-----------------------------------------------------------------------------
4787 Routine Name: UtilExcRogueApDetectedSet
4788 Routine Description:
4789 Arguments:
4790 Return Value:
4791 -----------------------------------------------------------------------------*/
4792 ULONG
UtilExcRogueApDetectedSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4793 UtilExcRogueApDetectedSet(
4794 PTIWLN_ADAPTER_T pAdapter,
4795 PUCHAR pData,
4796 ULONG Length
4797 )
4798 {
4799 ULONG retValue;
4800 retValue = UtilSetParam(pAdapter, EXC_ROGUE_AP_DETECTED, pData, sizeof(OS_EXC_ROGUE_AP_DETECTED));
4801 return retValue;
4802 }
4803
4804 /*-----------------------------------------------------------------------------
4805 Routine Name: UtilExcReportRogueApSet
4806 Routine Description:
4807 Arguments:
4808 Return Value:
4809 -----------------------------------------------------------------------------*/
4810 ULONG
UtilExcReportRogueApSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4811 UtilExcReportRogueApSet(
4812 PTIWLN_ADAPTER_T pAdapter,
4813 PUCHAR pData,
4814 ULONG Length
4815 )
4816 {
4817 ULONG retValue;
4818 retValue = UtilSetParam(pAdapter, EXC_REPORT_ROGUE_APS, pData, 0);
4819 return retValue;
4820 }
4821
4822 /*-----------------------------------------------------------------------------
4823 Routine Name: UtilExcAuthSuccessSet
4824 Routine Description:
4825 Arguments:
4826 Return Value:
4827 -----------------------------------------------------------------------------*/
4828 ULONG
UtilExcAuthSuccessSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4829 UtilExcAuthSuccessSet(
4830 PTIWLN_ADAPTER_T pAdapter,
4831 PUCHAR pData,
4832 ULONG Length
4833 )
4834 {
4835 ULONG retValue;
4836 retValue = UtilSetParam(pAdapter, EXC_AUTH_SUCCESS, pData, sizeof(OS_EXC_AUTH_SUCCESS));
4837 return retValue;
4838 }
4839
4840
4841 /*-----------------------------------------------------------------------------
4842 Routine Name: UtilExcCckmRequestSet
4843 Routine Description:
4844 Arguments:
4845 Return Value:
4846 -----------------------------------------------------------------------------*/
4847 ULONG
UtilExcCckmRequestSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4848 UtilExcCckmRequestSet(
4849 PTIWLN_ADAPTER_T pAdapter,
4850 PUCHAR pData,
4851 ULONG Length
4852 )
4853 {
4854 ULONG retValue;
4855
4856 OS_EXC_CCKM_REQUEST *cckmRequest = (OS_EXC_CCKM_REQUEST*)pData;
4857 ULONG reqLength = cckmRequest->AssociationRequestIELength+sizeof(cckmRequest->RequestCode)+sizeof(cckmRequest->AssociationRequestIELength);
4858
4859 PRINTF(DBG_IOCTL_LOUD, ("UtilExcCckmRequestSet, In Length = %d, Required Length=%d\n",
4860 (int) Length, (int) reqLength));
4861
4862 if ((cckmRequest==NULL) || (reqLength > Length))
4863 {
4864 PRINTF(DBG_IOCTL_LOUD, ("UtilExcCckmRequestSet, wrong size or pointer, In Length = %d, Required Length=%d\n",
4865 (int) Length, (int) reqLength));
4866 return NOK;
4867 }
4868 retValue = UtilSetParam(pAdapter, EXC_CCKM_REQUEST, pData, reqLength);
4869 return retValue;
4870 }
4871
4872
4873 /*-----------------------------------------------------------------------------
4874 Routine Name: UtilExcCckmResultSet
4875 Routine Description:
4876 Arguments:
4877 Return Value:
4878 -----------------------------------------------------------------------------*/
4879 ULONG
UtilExcCckmResultSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4880 UtilExcCckmResultSet(
4881 PTIWLN_ADAPTER_T pAdapter,
4882 PUCHAR pData,
4883 ULONG Length
4884 )
4885 {
4886 ULONG retValue;
4887 retValue = UtilSetParam(pAdapter, EXC_CCKM_RESULT, pData, sizeof(ULONG));
4888 return retValue;
4889 }
4890
4891 #endif /* EXC_MODULE_INCLUDED */
4892
4893
4894 /*-----------------------------------------------------------------------------
4895 Routine Name: UtilGetMACAddress
4896 Routine Description:
4897 Arguments:
4898 Return Value:
4899 -----------------------------------------------------------------------------*/
4900 ULONG
UtilGetMACAddress(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4901 UtilGetMACAddress(
4902 PTIWLN_ADAPTER_T pAdapter,
4903 PUCHAR pData,
4904 PULONG Length
4905 )
4906 {
4907 ULONG retValue;
4908
4909 if ((*Length) < MAC_ADDR_LEN)
4910 {
4911 *Length = MAC_ADDR_LEN;
4912 return NOK;
4913 }
4914
4915 retValue = UtilGetParam(pAdapter, CTRL_DATA_MAC_ADDRESS, pData, MAC_ADDR_LEN);
4916 *Length = MAC_ADDR_LEN;
4917 return retValue;
4918 }
4919
4920
4921 /*-----------------------------------------------------------------------------
4922 Routine Name: UtilConfigRoamingParamsSet
4923 Routine Description:
4924 Arguments:
4925 Return Value:
4926 -----------------------------------------------------------------------------*/
4927 ULONG
UtilConfigRoamingParamsSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4928 UtilConfigRoamingParamsSet(
4929 PTIWLN_ADAPTER_T pAdapter,
4930 PUCHAR pData,
4931 ULONG Length
4932 )
4933 {
4934 ULONG retValue;
4935 applicationConfigBuffer_t applicationConfigBuffer;
4936
4937 applicationConfigBuffer.buffer = pData;
4938 applicationConfigBuffer.bufferSize = (UINT16)Length;
4939
4940 retValue = UtilSetParam(pAdapter, ROAMING_MNGR_APPLICATION_CONFIGURATION, (PUCHAR)&applicationConfigBuffer, sizeof(applicationConfigBuffer_t));
4941
4942 return retValue;
4943 }
4944
4945 /*-----------------------------------------------------------------------------
4946 Routine Name: UtilConfigRoamingParamsGet
4947 Routine Description:
4948 Arguments:
4949 Return Value:
4950 -----------------------------------------------------------------------------*/
4951 ULONG
UtilConfigRoamingParamsGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)4952 UtilConfigRoamingParamsGet(
4953 PTIWLN_ADAPTER_T pAdapter,
4954 PUCHAR pData,
4955 PULONG Length
4956 )
4957 {
4958 ULONG retValue;
4959 retValue = UtilGetParam(pAdapter, ROAMING_MNGR_APPLICATION_CONFIGURATION, pData, *Length);
4960 return retValue;
4961 }
4962
4963
4964 /*-----------------------------------------------------------------------------
4965 Routine Name: UtilMeasurementEnableDisableParamsSet
4966 Routine Description:
4967 Arguments:
4968 Return Value:
4969 -----------------------------------------------------------------------------*/
4970 ULONG
UtilMeasurementEnableDisableParamsSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4971 UtilMeasurementEnableDisableParamsSet(
4972 PTIWLN_ADAPTER_T pAdapter,
4973 PUCHAR pData,
4974 ULONG Length
4975 )
4976 {
4977 ULONG retValue;
4978 retValue = UtilSetParam(pAdapter, MEASUREMENT_ENABLE_DISABLE_PARAM, pData, Length);
4979 return retValue;
4980 }
4981
4982 /*-----------------------------------------------------------------------------
4983 Routine Name: UtilMeasurementMaxDurationParamsSet
4984 Routine Description:
4985 Arguments:
4986 Return Value:
4987 -----------------------------------------------------------------------------*/
4988 ULONG
UtilMeasurementMaxDurationParamsSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)4989 UtilMeasurementMaxDurationParamsSet(
4990 PTIWLN_ADAPTER_T pAdapter,
4991 PUCHAR pData,
4992 ULONG Length
4993 )
4994 {
4995 ULONG retValue;
4996 retValue = UtilSetParam(pAdapter, MEASUREMENT_MAX_DURATION_PARAM, pData, sizeof(UINT32));
4997 return retValue;
4998 }
4999
5000 /*-----------------------------------------------------------------------------
5001 Routine Name: UtilEarlyWakeupIeGet
5002 Routine Description:
5003 Arguments:
5004 Return Value:
5005 -----------------------------------------------------------------------------*/
5006 ULONG
UtilEarlyWakeupIeGet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)5007 UtilEarlyWakeupIeGet(
5008 PTIWLN_ADAPTER_T pAdapter,
5009 PUCHAR pData,
5010 PULONG Length
5011 )
5012 {
5013 ULONG retValue;
5014
5015 if (!Length)
5016 return NOK;
5017
5018 retValue = UtilGetParam(pAdapter, HAL_CTRL_EARLY_WAKEUP, pData, sizeof(UINT8));
5019
5020 *Length = sizeof(UINT8);
5021
5022 return retValue;
5023 }
5024
5025
5026 /*-----------------------------------------------------------------------------
5027 Routine Name: UtilEarlyWakeupIeSet
5028 Routine Description:
5029 Arguments:
5030 Return Value:
5031 -----------------------------------------------------------------------------*/
5032 ULONG
UtilEarlyWakeupIeSet(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5033 UtilEarlyWakeupIeSet(
5034 PTIWLN_ADAPTER_T pAdapter,
5035 PUCHAR pData,
5036 ULONG Length
5037 )
5038 {
5039 ULONG retValue;
5040 retValue = UtilSetParam(pAdapter, HAL_CTRL_EARLY_WAKEUP, pData, sizeof(ULONG));
5041 return retValue;
5042 }
5043
5044
5045
5046 /*-----------------------------------------------------------------------------
5047 Routine Name: UtilBthWlanCoeEnable
5048 Routine Description:
5049 Arguments:
5050 Return Value:
5051 -----------------------------------------------------------------------------*/
5052 ULONG
UtilBthWlanCoeEnable(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5053 UtilBthWlanCoeEnable(
5054 PTIWLN_ADAPTER_T pAdapter,
5055 PUCHAR pData,
5056 ULONG Length
5057 )
5058 {
5059 ULONG retValue;
5060 retValue = UtilSetParam(pAdapter, SOFT_GEMINI_SET_ENABLE, pData, sizeof(ULONG));
5061 return retValue;
5062 }
5063
5064 /*-----------------------------------------------------------------------------
5065 Routine Name: UtilBthWlanCoeRate
5066 Routine Description:
5067 Arguments:
5068 Return Value:
5069 -----------------------------------------------------------------------------*/
5070 ULONG
UtilBthWlanCoeRate(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5071 UtilBthWlanCoeRate(
5072 PTIWLN_ADAPTER_T pAdapter,
5073 PUCHAR pData,
5074 ULONG Length
5075 )
5076 {
5077 ULONG retValue;
5078 retValue = UtilSetParam(pAdapter, SOFT_GEMINI_SET_RATE, pData, sizeof(ULONG)*NUM_OF_RATES_IN_SG);
5079 return retValue;
5080 }
5081
5082
5083 /*-----------------------------------------------------------------------------
5084 Routine Name: UtilBthWlanCoeConfig
5085 Routine Description:
5086 Arguments:
5087 Return Value:
5088 -----------------------------------------------------------------------------*/
5089 ULONG
UtilBthWlanCoeConfig(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5090 UtilBthWlanCoeConfig(
5091 PTIWLN_ADAPTER_T pAdapter,
5092 PUCHAR pData,
5093 ULONG Length
5094 )
5095 {
5096 ULONG retValue;
5097 retValue = UtilSetParam(pAdapter, SOFT_GEMINI_SET_CONFIG, pData, sizeof(ULONG) * NUM_OF_CONFIG_PARAMS_IN_SG);
5098 return retValue;
5099 }
5100
5101
5102 /*-----------------------------------------------------------------------------
5103 Routine Name: UtilBthWlanCoeGetStatus
5104 Routine Description:
5105 Arguments:
5106 Return Value:
5107 -----------------------------------------------------------------------------*/
5108 ULONG
UtilBthWlanCoeGetStatus(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)5109 UtilBthWlanCoeGetStatus(
5110 PTIWLN_ADAPTER_T pAdapter,
5111 PUCHAR pData,
5112 PULONG Length
5113 )
5114 {
5115 ULONG retValue;
5116 retValue = UtilGetParam(pAdapter, SOFT_GEMINI_GET_STATUS, pData, 0);
5117 *Length = 0;
5118 return retValue;
5119 }
5120
5121
5122 /*-----------------------------------------------------------------------------
5123 Routine Name: UtilPltRxPerStart
5124 Routine Description:
5125 Arguments:
5126 Return Value:
5127 -----------------------------------------------------------------------------*/
5128 ULONG
UtilPltRxPerStart(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5129 UtilPltRxPerStart(
5130 PTIWLN_ADAPTER_T pAdapter,
5131 PUCHAR pData,
5132 ULONG Length
5133 )
5134 {
5135 ULONG Status;
5136 interogateCmdCBParams_t interogateCmdCBParams;
5137 memset(&(pAdapter->IoCompleteBuff[0]) , 0xFF , MAX_IO_BUFFER_COMPLETE_SIZE );
5138
5139 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
5140 interogateCmdCBParams.CB_handle = (TI_HANDLE)pAdapter;
5141 interogateCmdCBParams.CB_Func = NULL;
5142 interogateCmdCBParams.CB_buf = NULL;
5143 Status = UtilSetParam(pAdapter, HAL_CTRL_PLT_RX_PER_START, (PUCHAR)&interogateCmdCBParams, sizeof(interogateCmdCBParams));
5144
5145 return Status;
5146 }
5147
5148 /*-----------------------------------------------------------------------------
5149 Routine Name: UtilPltRxPerStop
5150 Routine Description:
5151 Arguments:
5152 Return Value:
5153 -----------------------------------------------------------------------------*/
5154 ULONG
UtilPltRxPerStop(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5155 UtilPltRxPerStop(
5156 PTIWLN_ADAPTER_T pAdapter,
5157 PUCHAR pData,
5158 ULONG Length
5159 )
5160 {
5161 ULONG Status;
5162 interogateCmdCBParams_t interogateCmdCBParams;
5163
5164 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
5165 interogateCmdCBParams.CB_handle = (TI_HANDLE)pAdapter;
5166 interogateCmdCBParams.CB_Func = NULL;
5167 interogateCmdCBParams.CB_buf = NULL;
5168 Status = UtilSetParam(pAdapter, HAL_CTRL_PLT_RX_PER_STOP, (PUCHAR)&interogateCmdCBParams, sizeof(interogateCmdCBParams));
5169 return Status;
5170 }
5171
5172 /*-----------------------------------------------------------------------------
5173 Routine Name: UtilPltRxPerClear
5174 Routine Description:
5175 Arguments:
5176 Return Value:
5177 -----------------------------------------------------------------------------*/
5178 ULONG
UtilPltRxPerClear(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5179 UtilPltRxPerClear(
5180 PTIWLN_ADAPTER_T pAdapter,
5181 PUCHAR pData,
5182 ULONG Length
5183 )
5184 {
5185 ULONG Status;
5186 interogateCmdCBParams_t interogateCmdCBParams;
5187 memset(&(pAdapter->IoCompleteBuff[0]) , 0xFF , MAX_IO_BUFFER_COMPLETE_SIZE );
5188
5189 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
5190 interogateCmdCBParams.CB_handle = (TI_HANDLE)pAdapter;
5191 interogateCmdCBParams.CB_Func = NULL;
5192 interogateCmdCBParams.CB_buf = NULL;
5193 Status = UtilSetParam(pAdapter, HAL_CTRL_PLT_RX_PER_CLEAR, (PUCHAR)&interogateCmdCBParams, sizeof(interogateCmdCBParams));
5194 return Status;
5195 }
5196
5197 /*-----------------------------------------------------------------------------
5198 Routine Name: UtilPltRxPerGetResults
5199 Routine Description:
5200 Arguments:
5201 Return Value:
5202 -----------------------------------------------------------------------------*/
5203 ULONG
UtilPltRxPerGetResults(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG pLength)5204 UtilPltRxPerGetResults(
5205 PTIWLN_ADAPTER_T pAdapter,
5206 PUCHAR pData,
5207 PULONG pLength
5208 )
5209 {
5210
5211 ULONG Status;
5212 paramInfo_t Param;
5213 interogateCmdCBParams_t* pInterogateCmdCBParams = &Param.content.interogateCmdCBParams;
5214
5215 memset(&(pAdapter->IoCompleteBuff[0]) , 0xFF , MAX_IO_BUFFER_COMPLETE_SIZE );
5216
5217 /* To implement the Async IOCTL store the user buffer pointer to be filled at
5218 the Command Completion calback */
5219 pAdapter->pIoBuffer = pData;
5220 pAdapter->pIoCompleteBuffSize = pLength ;
5221
5222
5223 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
5224 pInterogateCmdCBParams->CB_handle = (TI_HANDLE)pAdapter;
5225 pInterogateCmdCBParams->CB_Func = (PVOID)UtilPltRxPerCB;
5226 pInterogateCmdCBParams->CB_buf = &(pAdapter->IoCompleteBuff[0]);
5227
5228 Param.paramType = HAL_CTRL_PLT_RX_PER_GET_RESULTS;
5229 Param.paramLength = sizeof(interogateCmdCBParams_t);
5230
5231 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
5232
5233 return Status;
5234 }
5235
5236
5237 /*-----------------------------------------------------------------------------
5238 Routine Name: UtilPltRxPerCB
5239
5240 Routine Description: This is the CB triggered when PltRX command been
5241 returned by FW.
5242 Arguments:
5243
5244 Return Value:
5245 -----------------------------------------------------------------------------*/
UtilPltRxPerCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)5246 VOID UtilPltRxPerCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)
5247 {
5248 HwMboxCmdBit_RxPer_t* pRxPer = (HwMboxCmdBit_RxPer_t* )pReadBuff;
5249 PTIWLN_ADAPTER_T pAdapter = (PTIWLN_ADAPTER_T)hAdapter;
5250
5251 if (pRxPer->CB_RxPerCmd == PLT_RX_PER_GETRESULTS)
5252 {
5253 *(pAdapter->pIoCompleteBuffSize) = sizeof(pRxPer->PltRxPer);
5254 os_memoryCopy(hAdapter, (void*)&(pAdapter->pIoBuffer[0]) ,(void*) &(pRxPer->PltRxPer) , *(pAdapter->pIoCompleteBuffSize));
5255 /* Call back the Completion that will indicate to the user that the buffer is ready to be read */
5256 os_IoctlComplete(pAdapter, status);
5257
5258 }
5259 }
5260
5261 /*-----------------------------------------------------------------------------
5262 Routine Name: UtilPltTxCW
5263 Routine Description:
5264 Arguments:
5265 Return Value:
5266 -----------------------------------------------------------------------------*/
UtilPltTxCW(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5267 ULONG UtilPltTxCW(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, ULONG Length)
5268 {
5269 ULONG retValue;
5270 retValue = UtilSetParam(pAdapter, HAL_CTRL_PLT_TX_CW, pData, Length);
5271 return retValue;
5272 }
5273 /*-----------------------------------------------------------------------------
5274 Routine Name: UtilPltTxContinues
5275 Routine Description:
5276 Arguments:
5277 Return Value:
5278 -----------------------------------------------------------------------------*/
UtilPltTxContinues(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5279 ULONG UtilPltTxContinues(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, ULONG Length)
5280 {
5281 ULONG retValue;
5282 retValue = UtilSetParam(pAdapter, HAL_CTRL_PLT_TX_CONTINUES, pData, Length);
5283 return retValue;
5284 }
5285
5286 /*-----------------------------------------------------------------------------
5287 Routine Name: UtilPltTxStop
5288 Routine Description:
5289 Arguments:
5290 Return Value:
5291 -----------------------------------------------------------------------------*/
UtilPltTxStop(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5292 ULONG UtilPltTxStop(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, ULONG Length)
5293 {
5294 ULONG retValue;
5295 retValue = UtilSetParam(pAdapter, HAL_CTRL_PLT_TX_STOP, pData, 0);
5296 return retValue;
5297 }
5298
5299 /*-----------------------------------------------------------------------------
5300 Routine Name: UtilPltWriteMib
5301 Routine Description:
5302 Arguments:
5303 Return Value:
5304 -----------------------------------------------------------------------------*/
UtilPltWriteMib(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5305 ULONG UtilPltWriteMib(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, ULONG Length)
5306 {
5307 ULONG retValue;
5308 retValue = UtilSetParam(pAdapter, HAL_CTRL_PLT_WRITE_MIB, pData, Length);
5309 return retValue;
5310 }
5311 /*-----------------------------------------------------------------------------
5312 Routine Name: UtilPltReadMib
5313 Routine Description:
5314 Arguments:
5315 Return Value:
5316 -----------------------------------------------------------------------------*/
UtilPltReadMib(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG pOutLength,ULONG InLength)5317 ULONG UtilPltReadMib(PTIWLN_ADAPTER_T pAdapter, PUCHAR pData, PULONG pOutLength, ULONG InLength)
5318 {
5319 ULONG Status;
5320 paramInfo_t Param;
5321
5322 /* To implement the Async IOCTL store the user buffer pointer to be filled at
5323 the Command Completion calback */
5324 pAdapter->pIoBuffer = pData;
5325 pAdapter->pIoCompleteBuffSize = pOutLength;
5326
5327 os_memoryCopy((TI_HANDLE)pAdapter, (PVOID)pAdapter->IoCompleteBuff, pData, InLength);
5328
5329 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
5330 Param.content.interogateCmdCBParams.CB_handle = (TI_HANDLE)pAdapter;
5331 Param.content.interogateCmdCBParams.CB_Func = (PVOID)UtilPltReadMibCB;
5332 Param.content.interogateCmdCBParams.CB_buf = pAdapter->IoCompleteBuff;
5333
5334 Param.paramType = HAL_CTRL_PLT_READ_MIB;
5335 Param.paramLength = sizeof(interogateCmdCBParams_t);
5336 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
5337
5338 return Status;
5339 }
5340
5341
5342 /*-----------------------------------------------------------------------------
5343 Routine Name: UtilPltReadMibCB
5344
5345 Routine Description: This is the CB triggered when PltReadRegister command been
5346 returned by FW.
5347 Arguments:
5348
5349 Return Value:
5350 -----------------------------------------------------------------------------*/
UtilPltReadMibCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)5351 VOID UtilPltReadMibCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)
5352 {
5353 PTIWLN_ADAPTER_T pAdapter = (PTIWLN_ADAPTER_T)hAdapter;
5354 PLT_MIB_t* pReturnMib = (PLT_MIB_t*)pAdapter->pIoBuffer;
5355 tiBOOL IsAsync = TRUE;
5356
5357 switch (pReturnMib->aMib)
5358 {
5359 case PLT_MIB_dot11StationId:
5360 {
5361 dot11StationIDStruct* pdot11StationID = (dot11StationIDStruct*)pReadBuff;
5362 pReturnMib->Length = sizeof(pReturnMib->aData.StationId);
5363 os_memoryCopy(hAdapter, (PVOID)pReturnMib->aData.StationId.addr, (PVOID)pdot11StationID->dot11StationID, sizeof(pReturnMib->aData.StationId));
5364 }
5365 break;
5366
5367 case PLT_MIB_countersTable:
5368 {
5369 ACXErrorCounters_t* pACXErrorCounters = (ACXErrorCounters_t*)pReadBuff;
5370 pReturnMib->Length = sizeof(pReturnMib->aData.CounterTable);
5371 pReturnMib->aData.CounterTable.FCSErrorCount = pACXErrorCounters->FCSErrorCount;
5372 pReturnMib->aData.CounterTable.PLCPErrorCount = pACXErrorCounters->PLCPErrorCount;
5373 }
5374 break;
5375
5376 /* MIBs with data which is already in pReadBuff and in the correct form. */
5377 case PLT_MIB_ctsToSelf:
5378 case PLT_MIB_dot11MaxReceiveLifetime:
5379 case PLT_MIB_dot11GroupAddressesTable:
5380 case PLT_MIB_arpIpAddressesTable:
5381 case PLT_MIB_rxFilter:
5382 case PLT_MIB_templateFrame:
5383 case PLT_MIB_beaconFilterIETable:
5384 case PLT_MIB_txRatePolicy:
5385 IsAsync = FALSE;
5386 PRINTF(DBG_NDIS_OIDS_LOUD, ("UtilPltReadMibCB:MIB aMib 0x%x \n",pReturnMib->aMib));
5387 os_memoryCopy(hAdapter, (PVOID)pAdapter->pIoBuffer, (PVOID)pAdapter->IoCompleteBuff, sizeof(PLT_MIB_t));
5388 break;
5389 default:
5390 PRINTF(DBG_NDIS_OIDS_LOUD, ("UtilPltReadMibCB:MIB aMib 0x%x Not supported\n",pReturnMib->aMib));
5391 }
5392 /* Call back the Completion that will indicate to the user that the buffer is ready to be read */
5393 if (IsAsync)
5394 os_IoctlComplete(pAdapter, status);
5395 }
5396
5397 /*-----------------------------------------------------------------------------
5398 Routine Name: UtilPltReadRegister
5399 Routine Description:
5400 Arguments:
5401 Return Value:
5402 -----------------------------------------------------------------------------*/
5403 ULONG
UtilPltReadRegister(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG Length)5404 UtilPltReadRegister(
5405 PTIWLN_ADAPTER_T pAdapter,
5406 PUCHAR pData,
5407 PULONG Length
5408 )
5409 {
5410
5411 ULONG Status;
5412 paramInfo_t Param;
5413 interogateCmdCBParams_t* pInterogateCmdCBParams = &Param.content.interogateCmdCBParams;
5414 ReadWriteCommand_t* pReadWriteCommandStruct = (ReadWriteCommand_t*)pAdapter->IoCompleteBuff;
5415 UINT32* pRegAdress = (UINT32*)pData;
5416
5417 /* To implement the Async IOCTL store the user buffer pointer to be filled at
5418 the Command Completion calback */
5419 pAdapter->pIoBuffer = pData;
5420 pAdapter->pIoCompleteBuffSize = Length ;
5421
5422 memset(&(pAdapter->IoCompleteBuff[0]) , 0xFF , MAX_IO_BUFFER_COMPLETE_SIZE );
5423 pReadWriteCommandStruct->addr = *pRegAdress;
5424 pReadWriteCommandStruct->size = 4;
5425
5426 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
5427 pInterogateCmdCBParams->CB_handle = (TI_HANDLE)pAdapter;
5428 pInterogateCmdCBParams->CB_Func = (PVOID)UtilPltReadRegisterCB;
5429 pInterogateCmdCBParams->CB_buf = &(pAdapter->IoCompleteBuff[0]) ;
5430
5431 Param.paramType = HAL_CTRL_PLT_READ_REGISTER;
5432 Param.paramLength = sizeof(interogateCmdCBParams_t);
5433
5434 Status = configMgr_getParam(pAdapter->CoreHalCtx, &Param);
5435 return Status;
5436 }
5437
5438 /*-----------------------------------------------------------------------------
5439 Routine Name: UtilPltReadRegisterCB
5440
5441 Routine Description: This is the CB triggered when PltReadRegister command been
5442 returned by FW.
5443 Arguments:
5444
5445 Return Value:
5446 -----------------------------------------------------------------------------*/
UtilPltReadRegisterCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)5447 VOID UtilPltReadRegisterCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)
5448 {
5449 PTIWLN_ADAPTER_T pAdapter = (PTIWLN_ADAPTER_T)hAdapter;
5450 ReadWriteCommand_t* pReadWriteCommandStruct = (ReadWriteCommand_t*)pReadBuff;
5451 UINT32* pRegDataReturn = (UINT32*)pAdapter->pIoBuffer;
5452
5453 *(pAdapter->pIoCompleteBuffSize) = sizeof(INT32);
5454
5455 /*Convert the returned data structure from ReadWriteCommandStruct to UINT32*/
5456 os_memoryCopy(hAdapter, (PVOID)pRegDataReturn, (PVOID)pReadWriteCommandStruct->value, sizeof(UINT32));
5457
5458 /* Call back the Completion that will indicate to the user that the buffer is ready to be read */
5459 os_IoctlComplete(pAdapter, status);
5460 }
5461
5462 /*-----------------------------------------------------------------------------
5463 Routine Name: UtilPltWriteRegister
5464 Routine Description:
5465 Arguments:
5466 Return Value:
5467 -----------------------------------------------------------------------------*/
5468 ULONG
UtilPltWriteRegister(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,ULONG Length)5469 UtilPltWriteRegister(
5470 PTIWLN_ADAPTER_T pAdapter,
5471 PUCHAR pData,
5472 ULONG Length
5473 )
5474 {
5475 ReadWriteCommand_t* pReadWriteCommandStruct = (ReadWriteCommand_t*)pAdapter->IoCompleteBuff;
5476 TIWLN_REG_RW* pReg = (TIWLN_REG_RW*)pData;
5477 interogateCmdCBParams_t interogateCmdCBParams;
5478 UINT32 Status;
5479
5480
5481 pReadWriteCommandStruct->addr = pReg->regAddr;
5482 pReadWriteCommandStruct->size = pReg->regSize;
5483 os_memoryCopy((TI_HANDLE)pAdapter, (PVOID)pReadWriteCommandStruct->value, (PVOID)&pReg->regValue, pReadWriteCommandStruct->size);
5484
5485 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
5486 interogateCmdCBParams.CB_handle = (TI_HANDLE)pAdapter;
5487 interogateCmdCBParams.CB_Func = NULL;
5488 interogateCmdCBParams.CB_buf = pAdapter->IoCompleteBuff;
5489 Status = UtilSetParam(pAdapter, HAL_CTRL_PLT_WRITE_REGISTER, (PUCHAR)&interogateCmdCBParams, sizeof(interogateCmdCBParams));
5490 return Status;
5491 }
5492
5493 /*-----------------------------------------------------------------------------
5494 Routine Name: utilPltRxTxCal
5495 Routine Description:
5496 Arguments:
5497 Return Value:
5498 -----------------------------------------------------------------------------*/
UtilPltRxTxCal(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG pOutLength,ULONG InLength)5499 ULONG UtilPltRxTxCal(
5500 PTIWLN_ADAPTER_T pAdapter,
5501 PUCHAR pData,
5502 PULONG pOutLength,
5503 ULONG InLength)
5504
5505 {
5506 paramInfo_t Param;
5507 interogateCmdCBParams_t* pInterogateCmdCBParams = &Param.content.interogateCmdCBParams;
5508
5509 /* To implement the Async IOCTL store the user buffer pointer to be filled at
5510 the Command Completion callback */
5511 pAdapter->pIoBuffer = (PUINT8)pData;
5512 pAdapter->pIoCompleteBuffSize = pOutLength;
5513
5514 /* Fill the IOCTL struct to the Command Mailbox by giving a stack parameter */
5515 pInterogateCmdCBParams->CB_handle = (TI_HANDLE)pAdapter;
5516 pInterogateCmdCBParams->CB_Func = (PVOID)UtilPltRxTxCalCB;
5517 pInterogateCmdCBParams->CB_buf = pAdapter->pIoBuffer;
5518
5519 Param.paramType = HAL_CTRL_PLT_RX_TX_CAL;
5520 Param.paramLength = sizeof(interogateCmdCBParams_t);
5521
5522 return configMgr_getParam(pAdapter->CoreHalCtx, &Param);
5523 }
5524
5525 /*-----------------------------------------------------------------------------
5526 Routine Name: UtilPltRxTxCalCB
5527
5528 Routine Description: This is the CB triggered when utilPltRxTxCal command been
5529 returned by FW.
5530 Arguments: pReadBuff - Should return the TestCmd_t
5531
5532 Return Value:
5533 -----------------------------------------------------------------------------*/
UtilPltRxTxCalCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)5534 VOID UtilPltRxTxCalCB(TI_HANDLE hAdapter,TI_STATUS status,PUINT8 pReadBuff)
5535 {
5536 PTIWLN_ADAPTER_T pAdapter = (PTIWLN_ADAPTER_T)hAdapter;
5537
5538 *(pAdapter->pIoCompleteBuffSize) = sizeof(TestCmd_t);
5539
5540 /* Call back the Completion that will indicate to the user that the buffer is ready to be read */
5541 os_IoctlComplete(pAdapter, status);
5542 }
5543
5544 /*-----------------------------------------------------------------------------
5545 Routine Name: UtilPltRxCal
5546 Routine Description:
5547 Arguments:
5548 Return Value:
5549 -----------------------------------------------------------------------------*/
UtilPltRxCal(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG pOutLength,ULONG InLength)5550 ULONG UtilPltRxCal(
5551 PTIWLN_ADAPTER_T pAdapter,
5552 PUCHAR pData,
5553 PULONG pOutLength,
5554 ULONG InLength)
5555 {
5556 whalParamInfo_t Param;
5557
5558 Param.paramType = HAL_CTRL_PLT_RX_TX_CAL;
5559 Param.paramLength = sizeof(TestCmd_t*);
5560 Param.content.interogateCmdCBParams.CB_Func = NULL;
5561 Param.content.interogateCmdCBParams.CB_handle = NULL;
5562 Param.content.interogateCmdCBParams.CB_buf = (PUINT8)pData;
5563
5564 return configMgr_getParam(pAdapter->CoreHalCtx, (paramInfo_t*)&Param);
5565 }
5566
5567 /*-----------------------------------------------------------------------------
5568 Routine Name: utilRxCalibrationStatus
5569 Routine Description:
5570 Arguments:
5571 Return Value:
5572 -----------------------------------------------------------------------------*/
utilRxCalibrationStatus(PTIWLN_ADAPTER_T pAdapter,PUCHAR pData,PULONG pOutLength,ULONG InLength)5573 ULONG utilRxCalibrationStatus(
5574 PTIWLN_ADAPTER_T pAdapter,
5575 PUCHAR pData,
5576 PULONG pOutLength,
5577 ULONG InLength)
5578 {
5579 whalParamInfo_t Param;
5580 ULONG status;
5581
5582 Param.paramType = HAL_CTRL_PLT_RX_CAL_STATUS;
5583 Param.paramLength = sizeof(TI_STATUS);
5584
5585 status = configMgr_getParam(pAdapter->CoreHalCtx, (paramInfo_t*)&Param);
5586
5587 *pData = Param.content.PltRxCalibrationStatus;
5588
5589 return status;
5590 }
5591