0
|
1 |
/*
|
|
2 |
* CmdBldCfgIE.c
|
|
3 |
*
|
|
4 |
* Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
|
|
5 |
* All rights reserved.
|
|
6 |
*
|
|
7 |
* This program and the accompanying materials are made available under the
|
|
8 |
* terms of the Eclipse Public License v1.0 or BSD License which accompanies
|
|
9 |
* this distribution. The Eclipse Public License is available at
|
|
10 |
* http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below.
|
|
11 |
*
|
|
12 |
* Redistribution and use in source and binary forms, with or without
|
|
13 |
* modification, are permitted provided that the following conditions
|
|
14 |
* are met:
|
|
15 |
*
|
|
16 |
* * Redistributions of source code must retain the above copyright
|
|
17 |
* notice, this list of conditions and the following disclaimer.
|
|
18 |
* * Redistributions in binary form must reproduce the above copyright
|
|
19 |
* notice, this list of conditions and the following disclaimer in
|
|
20 |
* the documentation and/or other materials provided with the
|
|
21 |
* distribution.
|
|
22 |
* * Neither the name Texas Instruments nor the names of its
|
|
23 |
* contributors may be used to endorse or promote products derived
|
|
24 |
* from this software without specific prior written permission.
|
|
25 |
*
|
|
26 |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
27 |
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
28 |
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
29 |
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
30 |
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
31 |
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
32 |
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
33 |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
34 |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
35 |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
36 |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
37 |
*/
|
|
38 |
|
|
39 |
|
|
40 |
/** \file CmdBldCfgIE.c
|
|
41 |
* \brief Command builder. Configuration commands information elements
|
|
42 |
*
|
|
43 |
* \see CmdBld.h
|
|
44 |
*/
|
|
45 |
#define __FILE_ID__ FILE_ID_92
|
|
46 |
#include "osApi.h"
|
|
47 |
#include "report.h"
|
|
48 |
#include "CmdBld.h"
|
|
49 |
#include "CmdQueue_api.h"
|
|
50 |
#include "rate.h"
|
|
51 |
#include "TwIf.h"
|
|
52 |
|
|
53 |
/****************************************************************************
|
|
54 |
* cmdBld_CfgIeConfigMemory()
|
|
55 |
****************************************************************************
|
|
56 |
* DESCRIPTION: Configure wlan hardware memory
|
|
57 |
*
|
|
58 |
* INPUTS:
|
|
59 |
*
|
|
60 |
* OUTPUT: None
|
|
61 |
*
|
|
62 |
* RETURNS: TI_OK or TI_NOK
|
|
63 |
****************************************************************************/
|
|
64 |
TI_STATUS cmdBld_CfgIeConfigMemory (TI_HANDLE hCmdBld, TDmaParams *pDmaParams, void *fCb, TI_HANDLE hCb)
|
|
65 |
{
|
|
66 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
67 |
ACXConfigMemory_t AcxElm_ConfigMemory;
|
|
68 |
ACXConfigMemory_t *pCfg = &AcxElm_ConfigMemory;
|
|
69 |
|
|
70 |
os_memoryZero(pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));
|
|
71 |
|
|
72 |
/*
|
|
73 |
* Set information element header
|
|
74 |
*/
|
|
75 |
pCfg->EleHdr.id = ACX_MEM_CFG;
|
|
76 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
77 |
|
|
78 |
/*
|
|
79 |
* Set configuration fields
|
|
80 |
*/
|
|
81 |
pCfg->numStations = pDmaParams->NumStations;
|
|
82 |
pCfg->rxMemblockNumber = TWD_RX_MEM_BLKS_NUM;
|
|
83 |
pCfg->txMinimumMemblockNumber = TWD_TX_MIN_MEM_BLKS_NUM;
|
|
84 |
pCfg->numSsidProfiles = 1;
|
|
85 |
pCfg->totalTxDescriptors = ENDIAN_HANDLE_LONG(NUM_TX_DESCRIPTORS);
|
|
86 |
|
|
87 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
88 |
}
|
|
89 |
|
|
90 |
|
|
91 |
/* WoneIndex value when running as station */
|
|
92 |
#define STATION_WONE_INDEX 0
|
|
93 |
|
|
94 |
|
|
95 |
/****************************************************************************
|
|
96 |
* cmdBld_CfgIeSlotTime()
|
|
97 |
****************************************************************************
|
|
98 |
* DESCRIPTION: Configure/Interrogate the Slot Time
|
|
99 |
*
|
|
100 |
* INPUTS: None
|
|
101 |
*
|
|
102 |
* OUTPUT: None
|
|
103 |
*
|
|
104 |
* RETURNS: TI_OK or TI_NOK
|
|
105 |
****************************************************************************/
|
|
106 |
TI_STATUS cmdBld_CfgIeSlotTime (TI_HANDLE hCmdBld, TI_UINT8 apSlotTime, void *fCb, TI_HANDLE hCb)
|
|
107 |
{
|
|
108 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
109 |
ACXSlot_t AcxElm_SlotTime;
|
|
110 |
ACXSlot_t *pCfg = &AcxElm_SlotTime;
|
|
111 |
|
|
112 |
/* Set information element header */
|
|
113 |
pCfg->EleHdr.id = ACX_SLOT;
|
|
114 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
115 |
|
|
116 |
/* Set configuration fields */
|
|
117 |
/* woneIndex is not relevant to station implementation */
|
|
118 |
pCfg->woneIndex = STATION_WONE_INDEX;
|
|
119 |
pCfg->slotTime = apSlotTime;
|
|
120 |
|
|
121 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Sending info elem to firmware, Slot Time = %d\n", (TI_UINT8)pCfg->slotTime);
|
|
122 |
|
|
123 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
124 |
}
|
|
125 |
|
|
126 |
|
|
127 |
/****************************************************************************
|
|
128 |
* cmdBld_CfgIePreamble()
|
|
129 |
****************************************************************************
|
|
130 |
* DESCRIPTION: Configure/Interrogate the Preamble
|
|
131 |
*
|
|
132 |
* INPUTS: None
|
|
133 |
*
|
|
134 |
* OUTPUT: None
|
|
135 |
*
|
|
136 |
* RETURNS: TI_OK or TI_NOK
|
|
137 |
****************************************************************************/
|
|
138 |
TI_STATUS cmdBld_CfgIePreamble (TI_HANDLE hCmdBld, TI_UINT8 preamble, void *fCb, TI_HANDLE hCb)
|
|
139 |
{
|
|
140 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
141 |
ACXPreamble_t AcxElm_Preamble;
|
|
142 |
ACXPreamble_t *pCfg = &AcxElm_Preamble;
|
|
143 |
|
|
144 |
/* Set information element header */
|
|
145 |
pCfg->EleHdr.id = ACX_PREAMBLE_TYPE;
|
|
146 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
147 |
|
|
148 |
/* Set configuration fields */
|
|
149 |
/* woneIndex is not relevant to station implementation */
|
|
150 |
pCfg->preamble = preamble;
|
|
151 |
|
|
152 |
TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: preamble=%u\n", pCfg->EleHdr.id, preamble);
|
|
153 |
|
|
154 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
155 |
}
|
|
156 |
|
|
157 |
|
|
158 |
/****************************************************************************
|
|
159 |
* cmdBld_CfgIeRx()
|
|
160 |
****************************************************************************
|
|
161 |
* DESCRIPTION: Configure/Interrogate RxConfig information element
|
|
162 |
*
|
|
163 |
* INPUTS: None
|
|
164 |
*
|
|
165 |
* OUTPUT: None
|
|
166 |
*
|
|
167 |
* RETURNS: TI_OK or TI_NOK
|
|
168 |
****************************************************************************/
|
|
169 |
TI_STATUS cmdBld_CfgIeRx (TI_HANDLE hCmdBld, TI_UINT32 apRxConfigOption, TI_UINT32 apRxFilterOption, void *fCb, TI_HANDLE hCb)
|
|
170 |
{
|
|
171 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
172 |
ACXRxConfig_t AcxElm_RxConfig;
|
|
173 |
ACXRxConfig_t *pCfg = &AcxElm_RxConfig;
|
|
174 |
|
|
175 |
/* Set information element header */
|
|
176 |
pCfg->EleHdr.id = ACX_RX_CFG;
|
|
177 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
178 |
|
|
179 |
/* Set configuration fields */
|
|
180 |
pCfg->ConfigOptions = ENDIAN_HANDLE_LONG(apRxConfigOption);
|
|
181 |
pCfg->FilterOptions = ENDIAN_HANDLE_LONG(apRxFilterOption);
|
|
182 |
|
|
183 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
184 |
}
|
|
185 |
|
|
186 |
/****************************************************************************
|
|
187 |
* cmdBld_CfgIeEnableRxDataFilter()
|
|
188 |
*****************************************************************************
|
|
189 |
* DESCRIPTION: Enables or disables Rx data filtering.
|
|
190 |
*
|
|
191 |
* INPUTS: enabled - 0 to disable data filtering, any other value to enable
|
|
192 |
* defaultAction - The default action to take on non-matching packets.
|
|
193 |
*
|
|
194 |
* OUTPUT: None
|
|
195 |
*
|
|
196 |
* RETURNS: TI_OK or TI_NOK
|
|
197 |
****************************************************************************/
|
|
198 |
TI_STATUS cmdBld_CfgIeEnableRxDataFilter (TI_HANDLE hCmdBld, TI_BOOL enabled, filter_e defaultAction, void *fCb, TI_HANDLE hCb)
|
|
199 |
{
|
|
200 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
201 |
DataFilterDefault_t dataFilterDefault;
|
|
202 |
DataFilterDefault_t * pCfg = &dataFilterDefault;
|
|
203 |
|
|
204 |
/* Set information element header */
|
|
205 |
pCfg->EleHdr.id = ACX_ENABLE_RX_DATA_FILTER;
|
|
206 |
pCfg->EleHdr.len = 0;
|
|
207 |
|
|
208 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Rx Data Filter configuration:\n");
|
|
209 |
TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": enabled = %d, defaultAction = %d\n", enabled, defaultAction);
|
|
210 |
|
|
211 |
/* Set information element configuration fields */
|
|
212 |
pCfg->enable = enabled;
|
|
213 |
pCfg->action = defaultAction;
|
|
214 |
pCfg->EleHdr.len += sizeof(pCfg->enable) + sizeof(pCfg->action);
|
|
215 |
|
|
216 |
TRACE_INFO_HEX(pCmdBld->hReport, (TI_UINT8 *) pCfg, sizeof(dataFilterDefault));
|
|
217 |
|
|
218 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
219 |
}
|
|
220 |
|
|
221 |
/****************************************************************************
|
|
222 |
* cmdBld_CfgIeRxDataFilter()
|
|
223 |
*****************************************************************************
|
|
224 |
* DESCRIPTION: Add/remove Rx Data filter information element.
|
|
225 |
*
|
|
226 |
* INPUTS: index - Index of the Rx Data filter
|
|
227 |
* command - Add or remove the filter
|
|
228 |
* action - Action to take on packets matching the pattern
|
|
229 |
* numFieldPatterns - Number of field patterns in the filter
|
|
230 |
* lenFieldPatterns - Length of the field pattern series
|
|
231 |
* fieldPatterns - Series of field patterns
|
|
232 |
*
|
|
233 |
* OUTPUT: None
|
|
234 |
*
|
|
235 |
* RETURNS: TI_OK or TI_NOK
|
|
236 |
****************************************************************************/
|
|
237 |
TI_STATUS cmdBld_CfgIeRxDataFilter (TI_HANDLE hCmdBld,
|
|
238 |
TI_UINT8 index,
|
|
239 |
TI_UINT8 command,
|
|
240 |
filter_e action,
|
|
241 |
TI_UINT8 numFieldPatterns,
|
|
242 |
TI_UINT8 lenFieldPatterns,
|
|
243 |
TI_UINT8 *pFieldPatterns,
|
|
244 |
void *fCb,
|
|
245 |
TI_HANDLE hCb)
|
|
246 |
{
|
|
247 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
248 |
TI_UINT8 dataFilterConfig[sizeof(DataFilterConfig_t) + MAX_DATA_FILTER_SIZE];
|
|
249 |
DataFilterConfig_t * pCfg = (DataFilterConfig_t *) &dataFilterConfig;
|
|
250 |
|
|
251 |
/* Set information element header */
|
|
252 |
pCfg->EleHdr.id = ACX_SET_RX_DATA_FILTER;
|
|
253 |
pCfg->EleHdr.len = 0;
|
|
254 |
|
|
255 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Rx Data Filter configuration:\n");
|
|
256 |
TRACE5(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": command = %d, index = %d, action = %d, numFieldPatterns = %d, lenFieldPatterns = %d\n", command, index, action, numFieldPatterns, lenFieldPatterns);
|
|
257 |
|
|
258 |
/* Set information element configuration fields */
|
|
259 |
pCfg->command = command;
|
|
260 |
pCfg->index = index;
|
|
261 |
pCfg->EleHdr.len += sizeof(pCfg->command) + sizeof(pCfg->index);
|
|
262 |
|
|
263 |
/* When removing a filter only the index and command are to be sent */
|
|
264 |
if (command == ADD_FILTER)
|
|
265 |
{
|
|
266 |
pCfg->action = action;
|
|
267 |
pCfg->numOfFields = numFieldPatterns;
|
|
268 |
pCfg->EleHdr.len += sizeof(pCfg->action) + sizeof(pCfg->numOfFields);
|
|
269 |
|
|
270 |
if (pFieldPatterns == NULL)
|
|
271 |
{
|
|
272 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, ": Null pattern table argument received!\n");
|
|
273 |
|
|
274 |
return PARAM_VALUE_NOT_VALID;
|
|
275 |
}
|
|
276 |
|
|
277 |
os_memoryCopy(pCmdBld->hOs, &pCfg->FPTable, pFieldPatterns, lenFieldPatterns);
|
|
278 |
pCfg->EleHdr.len += lenFieldPatterns;
|
|
279 |
}
|
|
280 |
|
|
281 |
TRACE_INFO_HEX(pCmdBld->hReport, (TI_UINT8 *) pCfg, sizeof(dataFilterConfig));
|
|
282 |
|
|
283 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(dataFilterConfig), fCb, hCb, NULL);
|
|
284 |
}
|
|
285 |
|
|
286 |
/****************************************************************************
|
|
287 |
* cmdBld_CfgIeArpIpFilter()
|
|
288 |
****************************************************************************
|
|
289 |
* DESCRIPTION: Configure/Interrogate ARP addr table information element for
|
|
290 |
* ipV4 only
|
|
291 |
*
|
|
292 |
* INPUTS: None
|
|
293 |
*
|
|
294 |
* OUTPUT: None
|
|
295 |
*
|
|
296 |
* RETURNS: TI_OK or TI_NOK
|
|
297 |
****************************************************************************/
|
|
298 |
TI_STATUS cmdBld_CfgIeArpIpFilter (TI_HANDLE hCmdBld,
|
|
299 |
TIpAddr tIpAddr,
|
|
300 |
TI_BOOL bFilteringEnabled,
|
|
301 |
void *fCb,
|
|
302 |
TI_HANDLE hCb)
|
|
303 |
{
|
|
304 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
305 |
ACXConfigureIP_t AcxElm_CmdConfigureIP;
|
|
306 |
ACXConfigureIP_t *pCfg = &AcxElm_CmdConfigureIP;
|
|
307 |
|
|
308 |
/* Set information element header */
|
|
309 |
pCfg->EleHdr.id = ACX_ARP_IP_FILTER;
|
|
310 |
pCfg->EleHdr.len = sizeof(ACXConfigureIP_t) - sizeof(EleHdrStruct);
|
|
311 |
|
|
312 |
pCfg->arpFilterEnable = (TI_UINT32)bFilteringEnabled;
|
|
313 |
|
|
314 |
/* IP address */
|
|
315 |
/* Note that in the case of IPv4 it is assumed that the extra two bytes are zero */
|
|
316 |
IP_COPY (pCfg->address, tIpAddr);
|
|
317 |
|
|
318 |
TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: ip=%x, enable=%u\n", pCfg->EleHdr.id, *((TI_UINT32*)pCfg->address), bFilteringEnabled);
|
|
319 |
|
|
320 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(ACXConfigureIP_t), fCb, hCb, NULL);
|
|
321 |
}
|
|
322 |
|
|
323 |
|
|
324 |
/****************************************************************************
|
|
325 |
* cmdBld_CfgIeGroupAdressTable()
|
|
326 |
****************************************************************************
|
|
327 |
* DESCRIPTION: Configure/Interrogate Group addr table information element
|
|
328 |
*
|
|
329 |
* INPUTS: None
|
|
330 |
*
|
|
331 |
* OUTPUT: None
|
|
332 |
*
|
|
333 |
* RETURNS: TI_OK or TI_NOK
|
|
334 |
****************************************************************************/
|
|
335 |
TI_STATUS cmdBld_CfgIeGroupAdressTable (TI_HANDLE hCmdBld,
|
|
336 |
TI_UINT8 numGroupAddrs,
|
|
337 |
TMacAddr *pGroupAddr,
|
|
338 |
TI_BOOL bEnabled,
|
|
339 |
void *fCb,
|
|
340 |
TI_HANDLE hCb)
|
|
341 |
{
|
|
342 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
343 |
TI_UINT32 i = 0;
|
|
344 |
TI_UINT8 *tmpLoc = NULL;
|
|
345 |
dot11MulticastGroupAddrStart_t AcxElm_CmdConfigureMulticastIp;
|
|
346 |
dot11MulticastGroupAddrStart_t* pCfg = &AcxElm_CmdConfigureMulticastIp;
|
|
347 |
|
|
348 |
os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(dot11MulticastGroupAddrStart_t));
|
|
349 |
|
|
350 |
/* Set information element header */
|
|
351 |
pCfg->EleHdr.id = DOT11_GROUP_ADDRESS_TBL;
|
|
352 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
353 |
|
|
354 |
pCfg->numOfGroups = numGroupAddrs;
|
|
355 |
pCfg->fltrState = bEnabled;
|
|
356 |
tmpLoc = pCfg->dataLocation;
|
|
357 |
|
|
358 |
if (NULL != pGroupAddr)
|
|
359 |
{
|
|
360 |
for (i = 0; i < numGroupAddrs; i++)
|
|
361 |
{
|
|
362 |
MAC_COPY (&tmpLoc[MAC_ADDR_LEN * i], *(pGroupAddr + i));
|
|
363 |
|
|
364 |
TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeGroupAdressTable: MAC %x: %x:%x:%x:%x:%x:%x\n", i, tmpLoc[MAC_ADDR_LEN*i+0] , tmpLoc[MAC_ADDR_LEN*i+1] , tmpLoc[MAC_ADDR_LEN*i+2] , tmpLoc[MAC_ADDR_LEN*i+3] , tmpLoc[MAC_ADDR_LEN*i+4] , tmpLoc[MAC_ADDR_LEN*i+5]);
|
|
365 |
}
|
|
366 |
}
|
|
367 |
|
|
368 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(dot11MulticastGroupAddrStart_t), fCb, hCb, NULL);
|
|
369 |
|
|
370 |
}
|
|
371 |
|
|
372 |
|
|
373 |
/****************************************************************************
|
|
374 |
* cmdBld_CfgIeSgEnable()
|
|
375 |
****************************************************************************
|
|
376 |
* DESCRIPTION: Enable/Disable the BTH-WLAN
|
|
377 |
*
|
|
378 |
* INPUTS: Enable flag
|
|
379 |
*
|
|
380 |
* OUTPUT: None
|
|
381 |
*
|
|
382 |
* RETURNS: TI_OK or TI_NOK
|
|
383 |
****************************************************************************/
|
|
384 |
TI_STATUS cmdBld_CfgIeSgEnable (TI_HANDLE hCmdBld, ESoftGeminiEnableModes SoftGeminiEnableModes, void *fCb, TI_HANDLE hCb)
|
|
385 |
{
|
|
386 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
387 |
ACXBluetoothWlanCoEnableStruct AcxElm_BluetoothWlanEnable;
|
|
388 |
ACXBluetoothWlanCoEnableStruct* pCfg = &AcxElm_BluetoothWlanEnable;
|
|
389 |
|
|
390 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSgEnable: Enable flag = %d\n", SoftGeminiEnableModes);
|
|
391 |
|
|
392 |
/* Set information element header */
|
|
393 |
pCfg->EleHdr.id = ACX_SG_ENABLE;
|
|
394 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
395 |
|
|
396 |
/* Set enable field */
|
|
397 |
pCfg->coexOperationMode = (TI_UINT8)SoftGeminiEnableModes;
|
|
398 |
|
|
399 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
400 |
}
|
|
401 |
|
|
402 |
|
|
403 |
/****************************************************************************
|
|
404 |
* cmdBld_CfgIeSg()
|
|
405 |
****************************************************************************
|
|
406 |
* DESCRIPTION: Configure the BTH-WLAN co-exsistance
|
|
407 |
*
|
|
408 |
* INPUTS: Configuration structure pointer
|
|
409 |
*
|
|
410 |
* OUTPUT: None
|
|
411 |
*
|
|
412 |
* RETURNS: TI_OK or TI_NOK
|
|
413 |
****************************************************************************/
|
|
414 |
TI_STATUS cmdBld_CfgIeSg (TI_HANDLE hCmdBld, TSoftGeminiParams *pSoftGeminiParam, void *fCb, TI_HANDLE hCb)
|
|
415 |
{
|
|
416 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
417 |
ACXBluetoothWlanCoParamsStruct AcxElm_BluetoothWlanEnable;
|
|
418 |
ACXBluetoothWlanCoParamsStruct *pCfg = &AcxElm_BluetoothWlanEnable;
|
|
419 |
int i=0;
|
|
420 |
|
|
421 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSg. \n");
|
|
422 |
|
|
423 |
/* Set information element header */
|
|
424 |
pCfg->EleHdr.id = ACX_SG_CFG;
|
|
425 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
426 |
|
|
427 |
pCfg->softGeminiParams.paramIdx = pSoftGeminiParam->paramIdx;
|
|
428 |
|
|
429 |
|
|
430 |
for (i=0; i< SOFT_GEMINI_PARAMS_MAX ; i++)
|
|
431 |
{
|
|
432 |
pCfg->softGeminiParams.coexParams[i] = pSoftGeminiParam->coexParams[i];
|
|
433 |
}
|
|
434 |
|
|
435 |
/* Rate conversion is done in the HAL */
|
|
436 |
pCfg->softGeminiParams.coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH] = rateNumberToBitmap((TI_UINT8)pSoftGeminiParam->coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH]);
|
|
437 |
|
|
438 |
if (pCfg->softGeminiParams.coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH] == 0)
|
|
439 |
{
|
|
440 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "coexAPRateAdapationThr is 0, convert to 1MBPS. \n");
|
|
441 |
pCfg->softGeminiParams.coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH] = HW_BIT_RATE_1MBPS;
|
|
442 |
}
|
|
443 |
|
|
444 |
/* Send the configuration command */
|
|
445 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
446 |
}
|
|
447 |
|
|
448 |
|
|
449 |
/****************************************************************************
|
|
450 |
* cmdBld_CfgIeFmCoex()
|
|
451 |
****************************************************************************
|
|
452 |
* DESCRIPTION: Configure the FM-WLAN co-exsistance parameters
|
|
453 |
*
|
|
454 |
* INPUTS: Configuration structure pointer
|
|
455 |
*
|
|
456 |
* OUTPUT: None
|
|
457 |
*
|
|
458 |
* RETURNS: TI_OK or TI_NOK
|
|
459 |
****************************************************************************/
|
|
460 |
TI_STATUS cmdBld_CfgIeFmCoex (TI_HANDLE hCmdBld, TFmCoexParams *pFmCoexParams, void *fCb, TI_HANDLE hCb)
|
|
461 |
{
|
|
462 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
463 |
ACXWlanFmCoexStruct tFmWlanCoex;
|
|
464 |
ACXWlanFmCoexStruct *pCfg = &tFmWlanCoex;
|
|
465 |
|
|
466 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeFmCoex\n");
|
|
467 |
|
|
468 |
/* Set information element header */
|
|
469 |
pCfg->EleHdr.id = ACX_FM_COEX_CFG;
|
|
470 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
471 |
|
|
472 |
/* Set parameters with endianess handling */
|
|
473 |
pCfg->enable = pFmCoexParams->uEnable;
|
|
474 |
pCfg->swallowPeriod = pFmCoexParams->uSwallowPeriod;
|
|
475 |
pCfg->nDividerFrefSet1 = pFmCoexParams->uNDividerFrefSet1;
|
|
476 |
pCfg->nDividerFrefSet2 = pFmCoexParams->uNDividerFrefSet2;
|
|
477 |
pCfg->mDividerFrefSet1 = ENDIAN_HANDLE_WORD(pFmCoexParams->uMDividerFrefSet1);
|
|
478 |
pCfg->mDividerFrefSet2 = ENDIAN_HANDLE_WORD(pFmCoexParams->uMDividerFrefSet2);
|
|
479 |
pCfg->coexPllStabilizationTime = ENDIAN_HANDLE_LONG(pFmCoexParams->uCoexPllStabilizationTime);
|
|
480 |
pCfg->ldoStabilizationTime = ENDIAN_HANDLE_WORD(pFmCoexParams->uLdoStabilizationTime);
|
|
481 |
pCfg->fmDisturbedBandMargin = pFmCoexParams->uFmDisturbedBandMargin;
|
|
482 |
pCfg->swallowClkDif = pFmCoexParams->uSwallowClkDif;
|
|
483 |
|
|
484 |
/* Send the configuration command */
|
|
485 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
486 |
}
|
|
487 |
|
|
488 |
|
|
489 |
/****************************************************************************
|
|
490 |
* cmdBld_CfgIeMemoryMap ()
|
|
491 |
****************************************************************************
|
|
492 |
* DESCRIPTION: Configure/Interrogate MemoryMap information element
|
|
493 |
*
|
|
494 |
* INPUTS:
|
|
495 |
* AcxElm_MemoryMap_T *apMap pointer to the memory map structure
|
|
496 |
*
|
|
497 |
* OUTPUT: None
|
|
498 |
*
|
|
499 |
* RETURNS: TI_OK or TI_NOK
|
|
500 |
****************************************************************************/
|
|
501 |
TI_STATUS cmdBld_CfgIeMemoryMap (TI_HANDLE hCmdBld, MemoryMap_t *apMap, void *fCb, TI_HANDLE hCb)
|
|
502 |
{
|
|
503 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
504 |
MemoryMap_t SwapMap;
|
|
505 |
TI_UINT32 *pSwap, *pOrig, i, uMemMapNumFields;
|
|
506 |
|
|
507 |
/* Set information element header */
|
|
508 |
SwapMap.EleHdr.id = ACX_MEM_MAP;
|
|
509 |
SwapMap.EleHdr.len = sizeof(MemoryMap_t) - sizeof(EleHdrStruct);
|
|
510 |
|
|
511 |
/* Solve endian problem (all fields are 32 bit) */
|
|
512 |
pOrig = (TI_UINT32* )&apMap->codeStart;
|
|
513 |
pSwap = (TI_UINT32* )&SwapMap.codeStart;
|
|
514 |
uMemMapNumFields = (sizeof(MemoryMap_t) - sizeof(EleHdrStruct)) % 4;
|
|
515 |
for (i = 0; i < uMemMapNumFields; i++)
|
|
516 |
pSwap[i] = ENDIAN_HANDLE_LONG(pOrig[i]);
|
|
517 |
|
|
518 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, &SwapMap, sizeof(SwapMap), fCb, hCb, NULL);
|
|
519 |
}
|
|
520 |
|
|
521 |
|
|
522 |
/****************************************************************************
|
|
523 |
* cmdBld_CfgIeAid()
|
|
524 |
****************************************************************************
|
|
525 |
* DESCRIPTION: Configure/Interrogate the AID info element
|
|
526 |
*
|
|
527 |
* INPUTS:
|
|
528 |
* TI_UINT16* apAidVal The AID value
|
|
529 |
*
|
|
530 |
* OUTPUT: None
|
|
531 |
*
|
|
532 |
* RETURNS: TI_OK or TI_NOK
|
|
533 |
****************************************************************************/
|
|
534 |
TI_STATUS cmdBld_CfgIeAid (TI_HANDLE hCmdBld, TI_UINT16 apAidVal, void *fCb, TI_HANDLE hCb)
|
|
535 |
{
|
|
536 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
537 |
ACXAid_t WlanElm_AID;
|
|
538 |
ACXAid_t *pCfg = &WlanElm_AID;
|
|
539 |
|
|
540 |
/* Set information element header */
|
|
541 |
pCfg->EleHdr.id = ACX_AID;
|
|
542 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
543 |
|
|
544 |
pCfg->Aid = ENDIAN_HANDLE_WORD(apAidVal);
|
|
545 |
|
|
546 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
547 |
}
|
|
548 |
|
|
549 |
|
|
550 |
/****************************************************************************
|
|
551 |
* cmdBld_CfgIeWakeUpCondition()
|
|
552 |
****************************************************************************
|
|
553 |
* DESCRIPTION: Configure/Interrogate the power management option
|
|
554 |
*
|
|
555 |
* INPUTS:
|
|
556 |
*
|
|
557 |
* OUTPUT: None
|
|
558 |
*
|
|
559 |
* RETURNS: TI_OK or TI_NOK
|
|
560 |
****************************************************************************/
|
|
561 |
TI_STATUS cmdBld_CfgIeWakeUpCondition (TI_HANDLE hCmdBld, TPowerMgmtConfig *pPMConfig, void *fCb, TI_HANDLE hCb)
|
|
562 |
{
|
|
563 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
564 |
WakeUpCondition_t WakeUpCondition;
|
|
565 |
WakeUpCondition_t *pCfg = &WakeUpCondition;
|
|
566 |
|
|
567 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "WakeUpCondition :\n listenInterval = 0x%X\n", pPMConfig->listenInterval);
|
|
568 |
|
|
569 |
switch (pPMConfig->tnetWakeupOn)
|
|
570 |
{
|
|
571 |
case TNET_WAKE_ON_BEACON:
|
|
572 |
pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_BEACON_BITMAP;
|
|
573 |
break;
|
|
574 |
case TNET_WAKE_ON_DTIM:
|
|
575 |
pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_DTIM_BITMAP;
|
|
576 |
break;
|
|
577 |
case TNET_WAKE_ON_N_BEACON:
|
|
578 |
pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_N_BEACONS_BITMAP;
|
|
579 |
break;
|
|
580 |
case TNET_WAKE_ON_N_DTIM:
|
|
581 |
pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_N_DTIM_BITMAP;
|
|
582 |
break;
|
|
583 |
default:
|
|
584 |
pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_BEACON_BITMAP;
|
|
585 |
break;
|
|
586 |
}
|
|
587 |
|
|
588 |
pCfg->listenInterval = pPMConfig->listenInterval;
|
|
589 |
|
|
590 |
TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " cmdBld_wakeUpCondition tnetWakeupOn=0x%x listenInterval=%d\n",pCfg->wakeUpConditionBitmap,pCfg->listenInterval);
|
|
591 |
|
|
592 |
/* Set information element header */
|
|
593 |
pCfg->EleHdr.id = ACX_WAKE_UP_CONDITIONS;
|
|
594 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
595 |
|
|
596 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
597 |
}
|
|
598 |
|
|
599 |
|
|
600 |
/****************************************************************************
|
|
601 |
* cmdBld_CfgIeSleepAuth()
|
|
602 |
****************************************************************************
|
|
603 |
* DESCRIPTION: Configure/Interrogate the power management option
|
|
604 |
*
|
|
605 |
* INPUTS:
|
|
606 |
*
|
|
607 |
* OUTPUT: None
|
|
608 |
*
|
|
609 |
* RETURNS: TI_OK or TI_NOK
|
|
610 |
****************************************************************************/
|
|
611 |
TI_STATUS cmdBld_CfgIeSleepAuth (TI_HANDLE hCmdBld, EPowerPolicy eMinPowerLevel, void *fCb, TI_HANDLE hCb)
|
|
612 |
{
|
|
613 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
614 |
ACXSleepAuth_t ACXSleepAuth;
|
|
615 |
ACXSleepAuth_t *pCfg = &ACXSleepAuth;
|
|
616 |
EElpCtrlMode eElpCtrlMode;
|
|
617 |
TI_STATUS status;
|
|
618 |
TI_BOOL bSendSleep = TI_FALSE;
|
|
619 |
|
|
620 |
/* Set the ELP control according to the new power policy */
|
|
621 |
switch (eMinPowerLevel)
|
|
622 |
{
|
|
623 |
case POWERAUTHO_POLICY_AWAKE: eElpCtrlMode = ELPCTRL_MODE_KEEP_AWAKE; break;
|
|
624 |
case POWERAUTHO_POLICY_PD: eElpCtrlMode = ELPCTRL_MODE_KEEP_AWAKE; break;
|
|
625 |
case POWERAUTHO_POLICY_ELP: eElpCtrlMode = ELPCTRL_MODE_NORMAL; break;
|
|
626 |
default:
|
|
627 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, " - Param value is not supported, %d\n", eMinPowerLevel);
|
|
628 |
return TI_NOK;
|
|
629 |
|
|
630 |
}
|
|
631 |
|
|
632 |
/* Set the ELP mode only if there is a change */
|
|
633 |
if (pCmdBld->uLastElpCtrlMode != eElpCtrlMode)
|
|
634 |
{
|
|
635 |
pCmdBld->uLastElpCtrlMode = eElpCtrlMode;
|
|
636 |
if (eElpCtrlMode == ELPCTRL_MODE_KEEP_AWAKE)
|
|
637 |
{
|
|
638 |
twIf_Awake(pCmdBld->hTwIf);
|
|
639 |
}
|
|
640 |
else
|
|
641 |
{
|
|
642 |
/* Remeber to change HW to sleep mode */
|
|
643 |
bSendSleep = TI_TRUE;
|
|
644 |
}
|
|
645 |
}
|
|
646 |
|
|
647 |
/* In the info element the enums are in reverse */
|
|
648 |
switch (eMinPowerLevel)
|
|
649 |
{
|
|
650 |
case POWERAUTHO_POLICY_ELP:
|
|
651 |
pCfg->sleepAuth = 2;
|
|
652 |
break;
|
|
653 |
case POWERAUTHO_POLICY_AWAKE:
|
|
654 |
pCfg->sleepAuth = 0;
|
|
655 |
break;
|
|
656 |
default:
|
|
657 |
pCfg->sleepAuth = eMinPowerLevel;
|
|
658 |
}
|
|
659 |
|
|
660 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " cmdBld_MinPowerLevelSet sleepAuth=%d\n", eMinPowerLevel);
|
|
661 |
|
|
662 |
/* Set information element header*/
|
|
663 |
pCfg->EleHdr.id = ACX_SLEEP_AUTH;
|
|
664 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
665 |
|
|
666 |
status = cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
667 |
|
|
668 |
if (bSendSleep) {
|
|
669 |
twIf_Sleep(pCmdBld->hTwIf);
|
|
670 |
}
|
|
671 |
|
|
672 |
return status;
|
|
673 |
}
|
|
674 |
|
|
675 |
|
|
676 |
/****************************************************************************
|
|
677 |
* cmdBld_CfgIeBcnBrcOptions()
|
|
678 |
****************************************************************************
|
|
679 |
* DESCRIPTION: Configure/Interrogate the power management option
|
|
680 |
*
|
|
681 |
* INPUTS:
|
|
682 |
*
|
|
683 |
* OUTPUT: None
|
|
684 |
*
|
|
685 |
* RETURNS: TI_OK or TI_NOK
|
|
686 |
****************************************************************************/
|
|
687 |
TI_STATUS cmdBld_CfgIeBcnBrcOptions (TI_HANDLE hCmdBld, TPowerMgmtConfig *pPMConfig, void *fCb, TI_HANDLE hCb)
|
|
688 |
{
|
|
689 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
690 |
ACXBeaconAndBroadcastOptions_t ACXBeaconAndBroadcastOptions;
|
|
691 |
ACXBeaconAndBroadcastOptions_t *pCfg = &ACXBeaconAndBroadcastOptions;
|
|
692 |
|
|
693 |
pCfg->beaconRxTimeOut = pPMConfig->BcnBrcOptions.BeaconRxTimeout;
|
|
694 |
pCfg->broadcastTimeOut = pPMConfig->BcnBrcOptions.BroadcastRxTimeout;
|
|
695 |
pCfg->rxBroadcastInPS = pPMConfig->BcnBrcOptions.RxBroadcastInPs;
|
|
696 |
pCfg->consecutivePsPollDeliveryFailureThr = pPMConfig->ConsecutivePsPollDeliveryFailureThreshold;
|
|
697 |
|
|
698 |
|
|
699 |
TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " cmdBld_BcnBrcOptions BeaconRxTimeout=%d BroadcastRxTimeout=%d RxBroadcastInPs=0x%x, consecutivePsPollDeliveryFailureThr=%d\n", pCfg->beaconRxTimeOut,pCfg->broadcastTimeOut, pCfg->rxBroadcastInPS, pCfg->consecutivePsPollDeliveryFailureThr);
|
|
700 |
|
|
701 |
/* Set information element header */
|
|
702 |
pCfg->EleHdr.id = ACX_BCN_DTIM_OPTIONS;
|
|
703 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
704 |
|
|
705 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
706 |
}
|
|
707 |
|
|
708 |
|
|
709 |
/****************************************************************************
|
|
710 |
* cmdBld_CfgIeFeatureConfig()
|
|
711 |
ACXBeaconAndBroadcastOptions_t* pWlanElm_BcnBrcOptions,
|
|
712 |
****************************************************************************
|
|
713 |
* DESCRIPTION: Configure the feature config info element
|
|
714 |
*
|
|
715 |
* INPUTS:
|
|
716 |
*
|
|
717 |
* OUTPUT: None
|
|
718 |
*
|
|
719 |
* RETURNS: TI_OK or TI_NOK
|
|
720 |
****************************************************************************/
|
|
721 |
TI_STATUS cmdBld_CfgIeFeatureConfig (TI_HANDLE hCmdBld, TI_UINT32 options, TI_UINT32 uDataFlowOptions, void *fCb, TI_HANDLE hCb)
|
|
722 |
{
|
|
723 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
724 |
ACXFeatureConfig_t WlanElm_FeatureConfig;
|
|
725 |
ACXFeatureConfig_t *pCfg = &WlanElm_FeatureConfig;
|
|
726 |
|
|
727 |
/* Set information element header */
|
|
728 |
pCfg->EleHdr.id = ACX_FEATURE_CFG;
|
|
729 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
730 |
|
|
731 |
/* Set fields */
|
|
732 |
pCfg->Options = ENDIAN_HANDLE_LONG(options);
|
|
733 |
pCfg->dataflowOptions = ENDIAN_HANDLE_LONG(uDataFlowOptions);
|
|
734 |
|
|
735 |
TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: option=0x%x, def.option=0x%x\n", pCfg->EleHdr.id, options, uDataFlowOptions);
|
|
736 |
|
|
737 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
738 |
}
|
|
739 |
|
|
740 |
|
|
741 |
/****************************************************************************
|
|
742 |
* cmdBld_CfgIeTxPowerDbm ()
|
|
743 |
****************************************************************************
|
|
744 |
* DESCRIPTION: Set the Tx power in Dbm units.
|
|
745 |
*
|
|
746 |
* INPUTS:
|
|
747 |
*
|
|
748 |
* OUTPUT: None
|
|
749 |
*
|
|
750 |
* RETURNS: TI_OK or TI_NOK
|
|
751 |
****************************************************************************/
|
|
752 |
TI_STATUS cmdBld_CfgIeTxPowerDbm (TI_HANDLE hCmdBld, TI_UINT8 uTxPowerDbm , void *fCb, TI_HANDLE hCb)
|
|
753 |
{
|
|
754 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
755 |
dot11CurrentTxPowerStruct dot11CurrentTxPower;
|
|
756 |
dot11CurrentTxPowerStruct *pCfg = &dot11CurrentTxPower;
|
|
757 |
|
|
758 |
TRACE1( pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " uTxPowerDbm = %d\n", uTxPowerDbm);
|
|
759 |
|
|
760 |
|
|
761 |
/* Set information element header*/
|
|
762 |
pCfg->EleHdr.id = DOT11_CUR_TX_PWR;
|
|
763 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
764 |
|
|
765 |
pCfg->dot11CurrentTxPower = uTxPowerDbm;
|
|
766 |
|
|
767 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
768 |
}
|
|
769 |
|
|
770 |
|
|
771 |
/****************************************************************************
|
|
772 |
* cmdBld_CfgIeStatisitics ()
|
|
773 |
****************************************************************************
|
|
774 |
* DESCRIPTION: Set the ACX statistics counters to zero.
|
|
775 |
*
|
|
776 |
* INPUTS:
|
|
777 |
*
|
|
778 |
* OUTPUT: None
|
|
779 |
*
|
|
780 |
* RETURNS: TI_OK or TI_NOK
|
|
781 |
****************************************************************************/
|
|
782 |
TI_STATUS cmdBld_CfgIeStatisitics (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
|
|
783 |
{
|
|
784 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
785 |
ACXStatistics_t acx;
|
|
786 |
ACXStatistics_t *pCfg = &acx;
|
|
787 |
|
|
788 |
/* Set information element header */
|
|
789 |
pCfg->EleHdr.id = ACX_STATISTICS;
|
|
790 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
791 |
|
|
792 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
793 |
}
|
|
794 |
|
|
795 |
|
|
796 |
/****************************************************************************
|
|
797 |
* cmdBld_CfgIeTid()
|
|
798 |
****************************************************************************
|
|
799 |
* DESCRIPTION: Write the Queue configuration (For Quality Of Service)
|
|
800 |
*
|
|
801 |
* INPUTS:
|
|
802 |
*
|
|
803 |
* OUTPUT: None
|
|
804 |
*
|
|
805 |
* RETURNS: TI_OK or TI_NOK
|
|
806 |
****************************************************************************/
|
|
807 |
TI_STATUS cmdBld_CfgIeTid (TI_HANDLE hCmdBld, TQueueTrafficParams* pQtrafficParams, void *fCb, TI_HANDLE hCb)
|
|
808 |
|
|
809 |
{
|
|
810 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
811 |
ACXTIDConfig_t TrafficCategoryCfg;
|
|
812 |
ACXTIDConfig_t *pCfg = &TrafficCategoryCfg;
|
|
813 |
|
|
814 |
os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));
|
|
815 |
|
|
816 |
/*
|
|
817 |
* Set information element header
|
|
818 |
* ==============================
|
|
819 |
*/
|
|
820 |
pCfg->EleHdr.id = ACX_TID_CFG;
|
|
821 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
822 |
|
|
823 |
/*
|
|
824 |
* Set information element Data
|
|
825 |
* ==============================
|
|
826 |
*/
|
|
827 |
pCfg->queueID = pQtrafficParams->queueID;
|
|
828 |
pCfg->channelType = pQtrafficParams->channelType;
|
|
829 |
pCfg->tsid = pQtrafficParams->tsid;
|
|
830 |
pCfg->psScheme = pQtrafficParams->psScheme;
|
|
831 |
pCfg->APSDConf[0] = pQtrafficParams->APSDConf[0];
|
|
832 |
pCfg->APSDConf[1] = pQtrafficParams->APSDConf[1];
|
|
833 |
|
|
834 |
TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: queue-id=%u, chan-type=%u, tsid=%u, ps-scheme=%u, apsd-1=0x%x, apsd-2=0x%x\n", pCfg->EleHdr.id, pCfg->queueID, pCfg->channelType, pCfg->tsid, pCfg->psScheme, pCfg->APSDConf[0], pCfg->APSDConf[1]);
|
|
835 |
|
|
836 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
837 |
}
|
|
838 |
|
|
839 |
|
|
840 |
/****************************************************************************
|
|
841 |
* cmdBld_CfgIeAcParams()
|
|
842 |
****************************************************************************
|
|
843 |
* DESCRIPTION: Write the AC configuration (For Quality Of Service)
|
|
844 |
*
|
|
845 |
* INPUTS:
|
|
846 |
*
|
|
847 |
* OUTPUT: None
|
|
848 |
*
|
|
849 |
* RETURNS: TI_OK or TI_NOK
|
|
850 |
****************************************************************************/
|
|
851 |
TI_STATUS cmdBld_CfgIeAcParams (TI_HANDLE hCmdBld, TAcQosParams *pAcQosParams, void *fCb, TI_HANDLE hCb)
|
|
852 |
{
|
|
853 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
854 |
ACXAcCfg_t AcCfg;
|
|
855 |
ACXAcCfg_t *pCfg = &AcCfg;
|
|
856 |
|
|
857 |
os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));
|
|
858 |
|
|
859 |
/*
|
|
860 |
* Set information element header
|
|
861 |
* ==============================
|
|
862 |
*/
|
|
863 |
pCfg->EleHdr.id = ACX_AC_CFG;
|
|
864 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
865 |
|
|
866 |
/*
|
|
867 |
* Set information element Data
|
|
868 |
* ==============================
|
|
869 |
*/
|
|
870 |
|
|
871 |
pCfg->ac = pAcQosParams->ac;
|
|
872 |
pCfg->aifsn = pAcQosParams->aifsn;
|
|
873 |
pCfg->cwMax = ENDIAN_HANDLE_WORD(pAcQosParams->cwMax);
|
|
874 |
pCfg->cwMin = pAcQosParams->cwMin;
|
|
875 |
pCfg->txopLimit = ENDIAN_HANDLE_WORD(pAcQosParams->txopLimit);
|
|
876 |
|
|
877 |
TRACE6(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: ac= %u, aifsn=%u, cw-max=%u, cw-min=%u, txop=%u\n", pCfg->EleHdr.id, pAcQosParams->ac, pAcQosParams->aifsn, pAcQosParams->cwMax, pAcQosParams->cwMin, pAcQosParams->txopLimit);
|
|
878 |
|
|
879 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
880 |
}
|
|
881 |
|
|
882 |
|
|
883 |
/****************************************************************************
|
|
884 |
* cmdBld_CfgIePsRxStreaming()
|
|
885 |
****************************************************************************
|
|
886 |
* DESCRIPTION: Write the AC PS-Rx-Streaming
|
|
887 |
*
|
|
888 |
* INPUTS:
|
|
889 |
*
|
|
890 |
* OUTPUT: None
|
|
891 |
*
|
|
892 |
* RETURNS: TI_OK or TI_NOK
|
|
893 |
****************************************************************************/
|
|
894 |
TI_STATUS cmdBld_CfgIePsRxStreaming (TI_HANDLE hCmdBld, TPsRxStreaming *pPsRxStreaming, void *fCb, TI_HANDLE hCb)
|
|
895 |
{
|
|
896 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
897 |
ACXPsRxStreaming_t tStreamingCfg;
|
|
898 |
ACXPsRxStreaming_t *pCfg = &tStreamingCfg;
|
|
899 |
|
|
900 |
os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));
|
|
901 |
|
|
902 |
/*
|
|
903 |
* Set information element header
|
|
904 |
* ==============================
|
|
905 |
*/
|
|
906 |
pCfg->EleHdr.id = ACX_PS_RX_STREAMING;
|
|
907 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
908 |
|
|
909 |
/*
|
|
910 |
* Set information element Data
|
|
911 |
* ============================
|
|
912 |
*/
|
|
913 |
pCfg->TID = (TI_UINT8)pPsRxStreaming->uTid;
|
|
914 |
pCfg->rxPSDEnabled = (TI_UINT8)pPsRxStreaming->bEnabled;
|
|
915 |
pCfg->streamPeriod = (TI_UINT8)pPsRxStreaming->uStreamPeriod;
|
|
916 |
pCfg->txTimeout = (TI_UINT8)pPsRxStreaming->uTxTimeout;
|
|
917 |
|
|
918 |
TRACE5(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "ID=%u: tid= %u, enable=%u, streamPeriod=%u, txTimeout=%u\n", pCfg->EleHdr.id, pCfg->TID, pCfg->rxPSDEnabled, pCfg->streamPeriod, pCfg->txTimeout);
|
|
919 |
|
|
920 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
921 |
}
|
|
922 |
|
|
923 |
|
|
924 |
/****************************************************************************
|
|
925 |
* cmdBld_CfgIePacketDetectionThreshold()
|
|
926 |
****************************************************************************
|
|
927 |
* DESCRIPTION: Set the PacketDetection threshold
|
|
928 |
*
|
|
929 |
* INPUTS:
|
|
930 |
*
|
|
931 |
* OUTPUT: None
|
|
932 |
*
|
|
933 |
* RETURNS: TI_OK or TI_NOK
|
|
934 |
****************************************************************************/
|
|
935 |
TI_STATUS cmdBld_CfgIePacketDetectionThreshold (TI_HANDLE hCmdBld, TI_UINT32 pdThreshold, void *fCb, TI_HANDLE hCb)
|
|
936 |
{
|
|
937 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
938 |
ACXPacketDetection_t PacketDetectionThresholdCfg;
|
|
939 |
ACXPacketDetection_t *pCfg = &PacketDetectionThresholdCfg;
|
|
940 |
|
|
941 |
/*
|
|
942 |
* Set information element header
|
|
943 |
* ==============================
|
|
944 |
*/
|
|
945 |
pCfg->EleHdr.id = ACX_PD_THRESHOLD;
|
|
946 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
947 |
|
|
948 |
/*
|
|
949 |
* Set information element Data
|
|
950 |
* ==============================
|
|
951 |
*/
|
|
952 |
pCfg->pdThreshold = ENDIAN_HANDLE_LONG(pdThreshold);
|
|
953 |
|
|
954 |
TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": pdThreshold = 0x%x , len = 0x%x \n",pCfg->pdThreshold,pCfg->EleHdr.len);
|
|
955 |
|
|
956 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
957 |
}
|
|
958 |
|
|
959 |
|
|
960 |
|
|
961 |
|
|
962 |
/****************************************************************************
|
|
963 |
* cmdBld_CfgIeBeaconFilterOpt()
|
|
964 |
****************************************************************************
|
|
965 |
* DESCRIPTION: Configure/Interrogate the beacon filtering option
|
|
966 |
*
|
|
967 |
* INPUTS:
|
|
968 |
*
|
|
969 |
* OUTPUT: None
|
|
970 |
*
|
|
971 |
* RETURNS: TI_OK or TI_NOK
|
|
972 |
****************************************************************************/
|
|
973 |
TI_STATUS cmdBld_CfgIeBeaconFilterOpt (TI_HANDLE hCmdBld, TI_UINT8 beaconFilteringStatus, TI_UINT8 numOfBeaconsToBuffer, void *fCb, TI_HANDLE hCb)
|
|
974 |
{
|
|
975 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
976 |
ACXBeaconFilterOptions_t ACXBeaconFilterOptions;
|
|
977 |
ACXBeaconFilterOptions_t *pCfg = &ACXBeaconFilterOptions;
|
|
978 |
|
|
979 |
pCfg->enable = beaconFilteringStatus;
|
|
980 |
pCfg->maxNumOfBeaconsStored = numOfBeaconsToBuffer;
|
|
981 |
|
|
982 |
/* Set information element header */
|
|
983 |
pCfg->EleHdr.id = ACX_BEACON_FILTER_OPT;
|
|
984 |
pCfg->EleHdr.len = sizeof(ACXBeaconFilterOptions_t) - sizeof(EleHdrStruct);
|
|
985 |
|
|
986 |
TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: enable=%u, num-stored=%u\n", pCfg->EleHdr.id, beaconFilteringStatus, numOfBeaconsToBuffer);
|
|
987 |
|
|
988 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(ACXBeaconFilterOptions_t), fCb, hCb, NULL);
|
|
989 |
}
|
|
990 |
/****************************************************************************
|
|
991 |
* cmdBld_CfgIeRateMngDbg()
|
|
992 |
****************************************************************************
|
|
993 |
* DESCRIPTION: Configure the rate managment params
|
|
994 |
* INPUTS:
|
|
995 |
*
|
|
996 |
* OUTPUT: None
|
|
997 |
*
|
|
998 |
* RETURNS: TI_OK or TI_NOK
|
|
999 |
****************************************************************************/
|
|
1000 |
|
|
1001 |
TI_STATUS cmdBld_CfgIeRateMngDbg (TI_HANDLE hCmdBld, RateMangeParams_t *pRateMngParams, void *fCb, TI_HANDLE hCb)
|
|
1002 |
{
|
|
1003 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1004 |
AcxRateAdaptParams RateMng;
|
|
1005 |
AcxRateAdaptParams *pCfg = &RateMng;
|
|
1006 |
int i;
|
|
1007 |
|
|
1008 |
/* Set information element header */
|
|
1009 |
pCfg->EleHdr.id = ACX_SET_RATE_MAMAGEMENT_PARAMS;
|
|
1010 |
pCfg->EleHdr.len = sizeof(AcxRateMangeParams) - sizeof(EleHdrStruct);
|
|
1011 |
|
|
1012 |
|
|
1013 |
TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u, index=%d \n",pCfg->EleHdr.id,pRateMngParams->paramIndex);
|
|
1014 |
|
|
1015 |
pCfg->paramIndex = pRateMngParams->paramIndex;
|
|
1016 |
|
|
1017 |
pCfg->InverseCuriosityFactor[0] = pRateMngParams->InverseCuriosityFactor[0];
|
|
1018 |
pCfg->InverseCuriosityFactor[1] = pRateMngParams->InverseCuriosityFactor[1];
|
|
1019 |
pCfg->MaxPer = pRateMngParams->MaxPer;
|
|
1020 |
pCfg->PerAdd = pRateMngParams->PerAdd;
|
|
1021 |
pCfg->PerAddShift = pRateMngParams->PerAddShift;
|
|
1022 |
pCfg->PerAlphaShift = pRateMngParams->PerAlphaShift;
|
|
1023 |
pCfg->PerBeta1Shift = pRateMngParams->PerBeta1Shift;
|
|
1024 |
pCfg->PerBeta2Shift = pRateMngParams->PerBeta2Shift;
|
|
1025 |
pCfg->PerTh1 = pRateMngParams->PerTh1;
|
|
1026 |
pCfg->PerTh2 = pRateMngParams->PerTh2;
|
|
1027 |
pCfg->RateCheckDown = pRateMngParams->RateCheckDown;
|
|
1028 |
pCfg->RateCheckUp = pRateMngParams->RateCheckUp;
|
|
1029 |
pCfg->RateRetryScore = pRateMngParams->RateRetryScore;
|
|
1030 |
pCfg->TxFailHighTh = pRateMngParams->TxFailHighTh;
|
|
1031 |
pCfg->TxFailLowTh = pRateMngParams->TxFailLowTh;
|
|
1032 |
pCfg->PerWeightShift[0] = pRateMngParams->PerWeightShift[0];
|
|
1033 |
pCfg->PerWeightShift[1] = pRateMngParams->PerWeightShift[1];
|
|
1034 |
pCfg->TpWeightShift[0] = pRateMngParams->TpWeightShift[0];
|
|
1035 |
pCfg->TpWeightShift[1] = pRateMngParams->TpWeightShift[1];
|
|
1036 |
|
|
1037 |
for (i=0 ; i< 13 ; i++)
|
|
1038 |
{
|
|
1039 |
pCfg->RateRetryPolicy[i] = pRateMngParams->RateRetryPolicy[i];
|
|
1040 |
}
|
|
1041 |
|
|
1042 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(AcxRateMangeParams), fCb, hCb, NULL);
|
|
1043 |
}
|
|
1044 |
|
|
1045 |
|
|
1046 |
|
|
1047 |
/****************************************************************************
|
|
1048 |
* cmdBld_CfgIeBeaconFilterTable
|
|
1049 |
****************************************************************************
|
|
1050 |
* DESCRIPTION: Configure/Interrogate the beacon filter IE table
|
|
1051 |
*
|
|
1052 |
* INPUTS:
|
|
1053 |
*
|
|
1054 |
* OUTPUT: None
|
|
1055 |
*
|
|
1056 |
* RETURNS: TI_OK or TI_NOK
|
|
1057 |
****************************************************************************/
|
|
1058 |
TI_STATUS cmdBld_CfgIeBeaconFilterTable (TI_HANDLE hCmdBld,
|
|
1059 |
TI_UINT8 uNumberOfIEs,
|
|
1060 |
TI_UINT8 *pIETable,
|
|
1061 |
TI_UINT8 uIETableSize,
|
|
1062 |
void *fCb,
|
|
1063 |
TI_HANDLE hCb)
|
|
1064 |
{
|
|
1065 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1066 |
ACXBeaconFilterIETable_t beaconFilterIETableStruct;
|
|
1067 |
ACXBeaconFilterIETable_t *pCfg = &beaconFilterIETableStruct;
|
|
1068 |
TI_UINT32 counter;
|
|
1069 |
|
|
1070 |
if (NULL == pIETable)
|
|
1071 |
{
|
|
1072 |
return PARAM_VALUE_NOT_VALID;
|
|
1073 |
}
|
|
1074 |
|
|
1075 |
pCfg->EleHdr.id = ACX_BEACON_FILTER_TABLE;
|
|
1076 |
pCfg->EleHdr.len = uIETableSize + 1;
|
|
1077 |
pCfg->NumberOfIEs = uNumberOfIEs;
|
|
1078 |
|
|
1079 |
os_memoryZero (pCmdBld->hOs, (void *)pCfg->IETable, BEACON_FILTER_TABLE_MAX_SIZE);
|
|
1080 |
os_memoryCopy (pCmdBld->hOs, (void *)pCfg->IETable, (void *)pIETable, uIETableSize);
|
|
1081 |
|
|
1082 |
TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: num-ie=%u, table-size=%u\n", pCfg->EleHdr.id, uNumberOfIEs, uIETableSize);
|
|
1083 |
|
|
1084 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "Beacon IE Table:\n");
|
|
1085 |
for (counter = 0; counter < uIETableSize; counter++)
|
|
1086 |
{
|
|
1087 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "%2x ", pIETable[counter]);
|
|
1088 |
}
|
|
1089 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "\n");
|
|
1090 |
|
|
1091 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(ACXBeaconFilterIETable_t), fCb, hCb, NULL);
|
|
1092 |
}
|
|
1093 |
|
|
1094 |
/****************************************************************************
|
|
1095 |
* cmdBld_CfgCoexActivity
|
|
1096 |
****************************************************************************
|
|
1097 |
* DESCRIPTION: Configure/Interrogate the Coex activity IE
|
|
1098 |
*
|
|
1099 |
* INPUTS:
|
|
1100 |
*
|
|
1101 |
* OUTPUT: None
|
|
1102 |
*
|
|
1103 |
* RETURNS: TI_OK or TI_NOK
|
|
1104 |
****************************************************************************/
|
|
1105 |
TI_STATUS cmdBld_CfgIeCoexActivity (TI_HANDLE hCmdBld,
|
|
1106 |
TCoexActivity *pCoexActivity,
|
|
1107 |
void *fCb,
|
|
1108 |
TI_HANDLE hCb)
|
|
1109 |
{
|
|
1110 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1111 |
ACXCoexActivityIE_t coexActivityIEStruct;
|
|
1112 |
ACXCoexActivityIE_t *pCfg = &coexActivityIEStruct;
|
|
1113 |
|
|
1114 |
if (NULL == pCoexActivity)
|
|
1115 |
{
|
|
1116 |
return PARAM_VALUE_NOT_VALID;
|
|
1117 |
}
|
|
1118 |
|
|
1119 |
pCfg->EleHdr.id = ACX_COEX_ACTIVITY;
|
|
1120 |
pCfg->EleHdr.len = sizeof(ACXCoexActivityIE_t) - sizeof(EleHdrStruct);
|
|
1121 |
|
|
1122 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "CoexActivity: ID=0x%x\n", pCfg->EleHdr.id);
|
|
1123 |
|
|
1124 |
pCfg->coexIp = pCoexActivity->coexIp;
|
|
1125 |
pCfg->activityId = pCoexActivity->activityId;
|
|
1126 |
pCfg->defaultPriority = pCoexActivity->defaultPriority;
|
|
1127 |
pCfg->raisedPriority = pCoexActivity->raisedPriority;
|
|
1128 |
pCfg->minService = ENDIAN_HANDLE_WORD(pCoexActivity->minService);
|
|
1129 |
pCfg->maxService = ENDIAN_HANDLE_WORD(pCoexActivity->maxService);
|
|
1130 |
|
|
1131 |
TRACE6(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "CoexActivity: 0x%02x 0x%02x - 0x%02x 0x%02x 0x%04x 0x%04x\n",
|
|
1132 |
pCfg->coexIp,
|
|
1133 |
pCfg->activityId,
|
|
1134 |
pCfg->defaultPriority,
|
|
1135 |
pCfg->raisedPriority,
|
|
1136 |
pCfg->minService,
|
|
1137 |
pCfg->maxService);
|
|
1138 |
|
|
1139 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1140 |
}
|
|
1141 |
|
|
1142 |
/****************************************************************************
|
|
1143 |
* cmdBld_CfgIeCcaThreshold()
|
|
1144 |
****************************************************************************
|
|
1145 |
* DESCRIPTION: Configure/Interrogate the Slot Time
|
|
1146 |
*
|
|
1147 |
* INPUTS: None
|
|
1148 |
*
|
|
1149 |
* OUTPUT: None
|
|
1150 |
*
|
|
1151 |
* RETURNS: TI_OK or TI_NOK
|
|
1152 |
****************************************************************************/
|
|
1153 |
TI_STATUS cmdBld_CfgIeCcaThreshold (TI_HANDLE hCmdBld, TI_UINT16 ccaThreshold, void *fCb, TI_HANDLE hCb)
|
|
1154 |
{
|
|
1155 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1156 |
ACXEnergyDetection_t AcxElm_CcaThreshold;
|
|
1157 |
ACXEnergyDetection_t *pCfg = &AcxElm_CcaThreshold;
|
|
1158 |
|
|
1159 |
/* Set information element header */
|
|
1160 |
pCfg->EleHdr.id = ACX_CCA_THRESHOLD;
|
|
1161 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1162 |
|
|
1163 |
pCfg->rxCCAThreshold = ENDIAN_HANDLE_WORD(ccaThreshold);
|
|
1164 |
|
|
1165 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1166 |
}
|
|
1167 |
|
|
1168 |
|
|
1169 |
/****************************************************************************
|
|
1170 |
* cmdBld_CfgIeEventMask()
|
|
1171 |
****************************************************************************
|
|
1172 |
* DESCRIPTION: Change the Event Vector Mask in the FW
|
|
1173 |
*
|
|
1174 |
* INPUTS: MaskVector The Updated Vector Mask
|
|
1175 |
*
|
|
1176 |
* RETURNS: TI_OK or TI_NOK
|
|
1177 |
****************************************************************************/
|
|
1178 |
TI_STATUS cmdBld_CfgIeEventMask (TI_HANDLE hCmdBld, TI_UINT32 mask, void *fCb, TI_HANDLE hCb)
|
|
1179 |
{
|
|
1180 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1181 |
|
|
1182 |
ACXEventMboxMask_t EventMboxData;
|
|
1183 |
ACXEventMboxMask_t *pCfg = &EventMboxData;
|
|
1184 |
|
|
1185 |
/* Set information element header*/
|
|
1186 |
pCfg->EleHdr.id = ACX_EVENT_MBOX_MASK;
|
|
1187 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1188 |
pCfg->lowEventMask = ENDIAN_HANDLE_LONG(mask);
|
|
1189 |
pCfg->highEventMask = ENDIAN_HANDLE_LONG(0xffffffff); /* Not in Use */
|
|
1190 |
|
|
1191 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "cmdBld_CfgIeEventMask:\n");
|
|
1192 |
|
|
1193 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1194 |
}
|
|
1195 |
|
|
1196 |
|
|
1197 |
/****************************************************************************
|
|
1198 |
* cmdBld_CfgIeMaxTxRetry()
|
|
1199 |
****************************************************************************
|
|
1200 |
* DESCRIPTION: Configure the Max Tx Retry parameters
|
|
1201 |
*
|
|
1202 |
* INPUTS: None
|
|
1203 |
*
|
|
1204 |
* OUTPUT: None
|
|
1205 |
*
|
|
1206 |
* RETURNS: TI_OK or TI_NOK
|
|
1207 |
****************************************************************************/
|
|
1208 |
TI_STATUS cmdBld_CfgIeMaxTxRetry (TI_HANDLE hCmdBld,
|
|
1209 |
TRroamingTriggerParams *pRoamingTriggerCmd,
|
|
1210 |
void *fCb,
|
|
1211 |
TI_HANDLE hCb)
|
|
1212 |
{
|
|
1213 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1214 |
ACXConsTxFailureTriggerParameters_t AcxElm_SetMaxTxRetry;
|
|
1215 |
ACXConsTxFailureTriggerParameters_t* pCfg = &AcxElm_SetMaxTxRetry;
|
|
1216 |
|
|
1217 |
pCfg->maxTxRetry = pRoamingTriggerCmd->maxTxRetry;
|
|
1218 |
|
|
1219 |
/* Set information element header */
|
|
1220 |
pCfg->EleHdr.id = ACX_CONS_TX_FAILURE;
|
|
1221 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1222 |
|
|
1223 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1224 |
}
|
|
1225 |
|
|
1226 |
|
|
1227 |
/****************************************************************************
|
|
1228 |
* cmdBld_CfgIeConnMonitParams()
|
|
1229 |
****************************************************************************
|
|
1230 |
* DESCRIPTION: Configure the Bss Lost Timeout & TSF miss threshold
|
|
1231 |
*
|
|
1232 |
* INPUTS: None
|
|
1233 |
*
|
|
1234 |
* OUTPUT: None
|
|
1235 |
*
|
|
1236 |
* RETURNS: TI_OK or TI_NOK
|
|
1237 |
****************************************************************************/
|
|
1238 |
TI_STATUS cmdBld_CfgIeConnMonitParams (TI_HANDLE hCmdBld, TRroamingTriggerParams *pRoamingTriggerCmd, void *fCb, TI_HANDLE hCb)
|
|
1239 |
{
|
|
1240 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1241 |
AcxConnectionMonitorOptions AcxElm_SetBssLossTsfThreshold;
|
|
1242 |
AcxConnectionMonitorOptions* pCfg = &AcxElm_SetBssLossTsfThreshold;
|
|
1243 |
|
|
1244 |
pCfg->BSSLossTimeout = ENDIAN_HANDLE_LONG(pRoamingTriggerCmd->BssLossTimeout);
|
|
1245 |
pCfg->TSFMissedThreshold = ENDIAN_HANDLE_LONG(pRoamingTriggerCmd->TsfMissThreshold);
|
|
1246 |
|
|
1247 |
/* Set information element header */
|
|
1248 |
pCfg->EleHdr.id = ACX_CONN_MONIT_PARAMS;
|
|
1249 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1250 |
|
|
1251 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1252 |
}
|
|
1253 |
|
|
1254 |
|
|
1255 |
/****************************************************************************
|
|
1256 |
* cmdBld_CfgIeTxRatePolicy()
|
|
1257 |
****************************************************************************
|
|
1258 |
* DESCRIPTION: Write the TxRateClass configuration
|
|
1259 |
*
|
|
1260 |
* INPUTS:
|
|
1261 |
*
|
|
1262 |
* OUTPUT: None
|
|
1263 |
*
|
|
1264 |
* RETURNS: TI_OK or TI_NOK
|
|
1265 |
****************************************************************************/
|
|
1266 |
TI_STATUS cmdBld_CfgIeTxRatePolicy (TI_HANDLE hCmdBld, TTxRatePolicy *pTxRatePolicy, void *fCb, TI_HANDLE hCb)
|
|
1267 |
{
|
|
1268 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1269 |
ACXTxAttrClasses_t TxClassCfg;
|
|
1270 |
ACXTxAttrClasses_t *pCfg = &TxClassCfg;
|
|
1271 |
TI_UINT8 PolicyId;
|
|
1272 |
|
|
1273 |
os_memoryZero (pCmdBld->hOs, (void *)pCfg, sizeof(*pCfg));
|
|
1274 |
|
|
1275 |
/*
|
|
1276 |
* Set information element header
|
|
1277 |
* ==============================
|
|
1278 |
*/
|
|
1279 |
pCfg->EleHdr.id = ACX_RATE_POLICY;
|
|
1280 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1281 |
pCfg->numOfClasses = pTxRatePolicy->numOfRateClasses;
|
|
1282 |
|
|
1283 |
for (PolicyId = 0; PolicyId < pTxRatePolicy->numOfRateClasses; PolicyId++)
|
|
1284 |
{
|
|
1285 |
os_memoryCopy (pCmdBld->hOs,
|
|
1286 |
(void *)&(pCfg->rateClasses[PolicyId]),
|
|
1287 |
(void *)&(pTxRatePolicy->rateClass[PolicyId]),
|
|
1288 |
sizeof(TTxRateClass));
|
|
1289 |
}
|
|
1290 |
|
|
1291 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1292 |
}
|
|
1293 |
|
|
1294 |
|
|
1295 |
/****************************************************************************
|
|
1296 |
* cmdBld_CfgIeRtsThreshold()
|
|
1297 |
****************************************************************************
|
|
1298 |
* DESCRIPTION: Configure the RTS threshold
|
|
1299 |
*
|
|
1300 |
* INPUTS: None
|
|
1301 |
*
|
|
1302 |
* OUTPUT: None
|
|
1303 |
*
|
|
1304 |
* RETURNS: TI_OK or TI_NOK
|
|
1305 |
****************************************************************************/
|
|
1306 |
TI_STATUS cmdBld_CfgIeRtsThreshold (TI_HANDLE hCmdBld, TI_UINT16 uRtsThreshold, void *fCb, TI_HANDLE hCb)
|
|
1307 |
{
|
|
1308 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1309 |
dot11RTSThreshold_t AcxElm_RtsThreshold;
|
|
1310 |
dot11RTSThreshold_t *pCfg = &AcxElm_RtsThreshold;
|
|
1311 |
|
|
1312 |
/* Set information element header */
|
|
1313 |
pCfg->EleHdr.id = DOT11_RTS_THRESHOLD;
|
|
1314 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1315 |
|
|
1316 |
pCfg->RTSThreshold = ENDIAN_HANDLE_WORD(uRtsThreshold);
|
|
1317 |
|
|
1318 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1319 |
}
|
|
1320 |
|
|
1321 |
|
|
1322 |
/****************************************************************************
|
|
1323 |
* cmdBld_CfgIeRtsThreshold()
|
|
1324 |
****************************************************************************
|
|
1325 |
* DESCRIPTION: Configure the tx fragmentation threshold
|
|
1326 |
*
|
|
1327 |
* INPUTS: None
|
|
1328 |
*
|
|
1329 |
* OUTPUT: None
|
|
1330 |
*
|
|
1331 |
* RETURNS: TI_OK or TI_NOK
|
|
1332 |
****************************************************************************/
|
|
1333 |
TI_STATUS cmdBld_CfgIeFragmentThreshold (TI_HANDLE hCmdBld, TI_UINT16 uFragmentThreshold, void *fCb, TI_HANDLE hCb)
|
|
1334 |
{
|
|
1335 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1336 |
ACXFRAGThreshold_t AcxElm_FragmentThreshold;
|
|
1337 |
ACXFRAGThreshold_t *pCfg = &AcxElm_FragmentThreshold;
|
|
1338 |
|
|
1339 |
/* Set information element header */
|
|
1340 |
pCfg->EleHdr.id = ACX_FRAG_CFG;
|
|
1341 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1342 |
|
|
1343 |
pCfg->fragThreshold = ENDIAN_HANDLE_WORD(uFragmentThreshold);
|
|
1344 |
|
|
1345 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1346 |
}
|
|
1347 |
|
|
1348 |
|
|
1349 |
/****************************************************************************
|
|
1350 |
* cmdBld_CfgIePmConfig()
|
|
1351 |
****************************************************************************
|
|
1352 |
* DESCRIPTION: Configure PM parameters
|
|
1353 |
*
|
|
1354 |
* INPUTS: None
|
|
1355 |
*
|
|
1356 |
* OUTPUT: None
|
|
1357 |
*
|
|
1358 |
* RETURNS: TI_OK or TI_NOK
|
|
1359 |
****************************************************************************/
|
|
1360 |
TI_STATUS cmdBld_CfgIePmConfig (TI_HANDLE hCmdBld,
|
|
1361 |
TI_UINT32 uHostClkSettlingTime,
|
|
1362 |
TI_UINT8 uHostFastWakeupSupport,
|
|
1363 |
void * fCb,
|
|
1364 |
TI_HANDLE hCb)
|
|
1365 |
{
|
|
1366 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1367 |
ACXPMConfig_t tPmConfig;
|
|
1368 |
ACXPMConfig_t *pCfg = &tPmConfig;
|
|
1369 |
|
|
1370 |
/* Set information element header*/
|
|
1371 |
pCfg->EleHdr.id = ACX_PM_CONFIG;
|
|
1372 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1373 |
|
|
1374 |
pCfg->hostClkSettlingTime = uHostClkSettlingTime;
|
|
1375 |
pCfg->hostFastWakeupSupport = uHostFastWakeupSupport;
|
|
1376 |
|
|
1377 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1378 |
}
|
|
1379 |
|
|
1380 |
|
|
1381 |
/****************************************************************************
|
|
1382 |
* cmdBld_CfgIeTxCmpltPacing()
|
|
1383 |
****************************************************************************
|
|
1384 |
* DESCRIPTION: Configure Tx-Complete interrupt pacing to FW
|
|
1385 |
*
|
|
1386 |
* INPUTS: None
|
|
1387 |
*
|
|
1388 |
* OUTPUT: None
|
|
1389 |
*
|
|
1390 |
* RETURNS: TI_OK or TI_NOK
|
|
1391 |
****************************************************************************/
|
|
1392 |
TI_STATUS cmdBld_CfgIeTxCmpltPacing (TI_HANDLE hCmdBld,
|
|
1393 |
TI_UINT16 uTxCompletePacingThreshold,
|
|
1394 |
TI_UINT16 uTxCompletePacingTimeout,
|
|
1395 |
void * fCb,
|
|
1396 |
TI_HANDLE hCb)
|
|
1397 |
{
|
|
1398 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1399 |
ACXTxConfigOptions_t tTxCmpltPacing;
|
|
1400 |
ACXTxConfigOptions_t *pCfg = &tTxCmpltPacing;
|
|
1401 |
|
|
1402 |
/* Set information element header */
|
|
1403 |
pCfg->EleHdr.id = ACX_TX_CONFIG_OPT;
|
|
1404 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1405 |
|
|
1406 |
pCfg->txCompleteThreshold = ENDIAN_HANDLE_WORD(uTxCompletePacingThreshold);
|
|
1407 |
pCfg->txCompleteTimeout = ENDIAN_HANDLE_WORD(uTxCompletePacingTimeout);
|
|
1408 |
|
|
1409 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1410 |
}
|
|
1411 |
|
|
1412 |
|
|
1413 |
/****************************************************************************
|
|
1414 |
* cmdBld_CfgIeRxIntrPacing()
|
|
1415 |
****************************************************************************
|
|
1416 |
* DESCRIPTION: Configure Rx-Complete interrupt pacing to FW
|
|
1417 |
*
|
|
1418 |
* INPUTS: None
|
|
1419 |
*
|
|
1420 |
* OUTPUT: None
|
|
1421 |
*
|
|
1422 |
* RETURNS: TI_OK or TI_NOK
|
|
1423 |
****************************************************************************/
|
|
1424 |
TI_STATUS cmdBld_CfgIeRxIntrPacing (TI_HANDLE hCmdBld,
|
|
1425 |
TI_UINT16 uRxIntrPacingThreshold,
|
|
1426 |
TI_UINT16 uRxIntrPacingTimeout,
|
|
1427 |
void * fCb,
|
|
1428 |
TI_HANDLE hCb)
|
|
1429 |
{
|
|
1430 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1431 |
ACXRxBufferingConfig_t tRxIntrPacing;
|
|
1432 |
ACXRxBufferingConfig_t *pCfg = &tRxIntrPacing;
|
|
1433 |
|
|
1434 |
/* Set information element header */
|
|
1435 |
pCfg->EleHdr.id = ACX_RX_CONFIG_OPT;
|
|
1436 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1437 |
|
|
1438 |
pCfg->rxPktThreshold = ENDIAN_HANDLE_WORD(uRxIntrPacingThreshold);
|
|
1439 |
pCfg->rxCompleteTimeout = ENDIAN_HANDLE_WORD(uRxIntrPacingTimeout);
|
|
1440 |
pCfg->rxMblkThreshold = ENDIAN_HANDLE_WORD(0xFFFF); /* Set to maximum so it has no effect (only the PktThreshold is used) */
|
|
1441 |
pCfg->rxQueueType = RX_QUEUE_TYPE_RX_LOW_PRIORITY; /* Only low priority data packets are buffered */
|
|
1442 |
|
|
1443 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1444 |
}
|
|
1445 |
|
|
1446 |
|
|
1447 |
/****************************************************************************
|
|
1448 |
* cmdBld_CfgIeCtsProtection()
|
|
1449 |
****************************************************************************
|
|
1450 |
* DESCRIPTION: Configure The Cts to self feature
|
|
1451 |
*
|
|
1452 |
* INPUTS: None
|
|
1453 |
*
|
|
1454 |
* OUTPUT: None
|
|
1455 |
*
|
|
1456 |
* RETURNS: TI_OK or TI_NOK
|
|
1457 |
****************************************************************************/
|
|
1458 |
TI_STATUS cmdBld_CfgIeCtsProtection (TI_HANDLE hCmdBld, TI_UINT8 ctsProtection, void *fCb, TI_HANDLE hCb)
|
|
1459 |
{
|
|
1460 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1461 |
ACXCtsProtection_t AcxElm_CtsToSelf;
|
|
1462 |
ACXCtsProtection_t *pCfg = &AcxElm_CtsToSelf;
|
|
1463 |
|
|
1464 |
/* Set information element header*/
|
|
1465 |
pCfg->EleHdr.id = ACX_CTS_PROTECTION;
|
|
1466 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1467 |
|
|
1468 |
pCfg->ctsProtectMode = ctsProtection;
|
|
1469 |
|
|
1470 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1471 |
}
|
|
1472 |
|
|
1473 |
|
|
1474 |
/****************************************************************************
|
|
1475 |
* cmdBld_CfgIeRxMsduLifeTime()
|
|
1476 |
****************************************************************************
|
|
1477 |
* DESCRIPTION: Configure The Cts to self feature
|
|
1478 |
*
|
|
1479 |
* INPUTS: None
|
|
1480 |
*
|
|
1481 |
* OUTPUT: None
|
|
1482 |
*
|
|
1483 |
* RETURNS: TI_OK or TI_NOK
|
|
1484 |
****************************************************************************/
|
|
1485 |
TI_STATUS cmdBld_CfgIeRxMsduLifeTime (TI_HANDLE hCmdBld, TI_UINT32 RxMsduLifeTime, void *fCb, TI_HANDLE hCb)
|
|
1486 |
{
|
|
1487 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1488 |
dot11RxMsduLifeTime_t AcxElm_RxMsduLifeTime;
|
|
1489 |
dot11RxMsduLifeTime_t *pCfg = &AcxElm_RxMsduLifeTime;
|
|
1490 |
|
|
1491 |
/* Set information element header*/
|
|
1492 |
pCfg->EleHdr.id = DOT11_RX_MSDU_LIFE_TIME;
|
|
1493 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1494 |
pCfg->RxMsduLifeTime = RxMsduLifeTime;
|
|
1495 |
|
|
1496 |
TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": RxMsduLifeTime = 0x%x, len = 0x%x\n",pCfg->RxMsduLifeTime,pCfg->EleHdr.len);
|
|
1497 |
|
|
1498 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1499 |
}
|
|
1500 |
|
|
1501 |
|
|
1502 |
/****************************************************************************
|
|
1503 |
* cmdBld_CfgIeServicePeriodTimeout()
|
|
1504 |
****************************************************************************
|
|
1505 |
* DESCRIPTION: Configure The Rx Time Out
|
|
1506 |
*
|
|
1507 |
* INPUTS: None
|
|
1508 |
*
|
|
1509 |
* OUTPUT: None
|
|
1510 |
*
|
|
1511 |
* RETURNS: TI_OK or TI_NOK
|
|
1512 |
****************************************************************************/
|
|
1513 |
TI_STATUS cmdBld_CfgIeServicePeriodTimeout (TI_HANDLE hCmdBld, TRxTimeOut* pRxTimeOut, void *fCb, TI_HANDLE hCb)
|
|
1514 |
{
|
|
1515 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1516 |
ACXRxTimeout_t AcxElm_rxTimeOut;
|
|
1517 |
ACXRxTimeout_t *pCfg = &AcxElm_rxTimeOut;
|
|
1518 |
|
|
1519 |
/* Set information element header*/
|
|
1520 |
pCfg->EleHdr.id = ACX_SERVICE_PERIOD_TIMEOUT;
|
|
1521 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1522 |
|
|
1523 |
pCfg->PsPollTimeout = pRxTimeOut->psPoll;
|
|
1524 |
pCfg->UpsdTimeout = pRxTimeOut->UPSD;
|
|
1525 |
|
|
1526 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1527 |
}
|
|
1528 |
|
|
1529 |
|
|
1530 |
/****************************************************************************
|
|
1531 |
* cmdBld_CfgIePsWmm()
|
|
1532 |
****************************************************************************
|
|
1533 |
* DESCRIPTION: Configure The PS for WMM
|
|
1534 |
*
|
|
1535 |
* INPUTS: TI_TRUE - Configure PS to work on WMM mode - do not send the NULL/PS_POLL
|
|
1536 |
* packets even if TIM is set.
|
|
1537 |
* TI_FALSE - Configure PS to work on Non-WMM mode - work according to the
|
|
1538 |
* standard
|
|
1539 |
*
|
|
1540 |
* RETURNS: TI_OK or TI_NOK
|
|
1541 |
****************************************************************************/
|
|
1542 |
TI_STATUS cmdBld_CfgIePsWmm (TI_HANDLE hCmdBld, TI_BOOL enableWA, void *fCb, TI_HANDLE hCb)
|
|
1543 |
{
|
|
1544 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1545 |
ACXConfigPsWmm_t ConfigPsWmm;
|
|
1546 |
ACXConfigPsWmm_t *pCfg = &ConfigPsWmm;
|
|
1547 |
|
|
1548 |
/*
|
|
1549 |
* Set information element header
|
|
1550 |
*/
|
|
1551 |
pCfg->EleHdr.id = ACX_CONFIG_PS_WMM;
|
|
1552 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1553 |
|
|
1554 |
pCfg->ConfigPsOnWmmMode = enableWA;
|
|
1555 |
|
|
1556 |
/* Report the meesage only if we are using the WiFi patch */
|
|
1557 |
if (enableWA)
|
|
1558 |
{
|
|
1559 |
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_CONSOLE, "cmdBld_CfgIePsWmm: PS is on WMM mode\n");
|
|
1560 |
WLAN_OS_REPORT(("%s PS is on WMM mode\n",__FUNCTION__));
|
|
1561 |
}
|
|
1562 |
|
|
1563 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1564 |
}
|
|
1565 |
|
|
1566 |
/****************************************************************************
|
|
1567 |
* cmdBld_CfgIeRssiSnrTrigger()
|
|
1568 |
****************************************************************************
|
|
1569 |
* DESCRIPTION: Configure the RSSI/SNR Trigger parameters
|
|
1570 |
*
|
|
1571 |
* INPUTS: None
|
|
1572 |
*
|
|
1573 |
* OUTPUT: None
|
|
1574 |
*
|
|
1575 |
* RETURNS: OK or NOK
|
|
1576 |
****************************************************************************/
|
|
1577 |
TI_STATUS cmdBld_CfgIeRssiSnrTrigger (TI_HANDLE hCmdBld, RssiSnrTriggerCfg_t *pTriggerParam, void *fCb, TI_HANDLE hCb)
|
|
1578 |
{
|
|
1579 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1580 |
ACXRssiSnrTriggerCfg_t tAcxTriggerParameters;
|
|
1581 |
ACXRssiSnrTriggerCfg_t *pCfg = &tAcxTriggerParameters;
|
|
1582 |
|
|
1583 |
pCfg->param.index = pTriggerParam->index ;
|
|
1584 |
pCfg->param.threshold = pTriggerParam->threshold;
|
|
1585 |
pCfg->param.pacing = pTriggerParam->pacing ;
|
|
1586 |
pCfg->param.metric = pTriggerParam->metric ;
|
|
1587 |
pCfg->param.type = pTriggerParam->type ;
|
|
1588 |
pCfg->param.direction = pTriggerParam->direction;
|
|
1589 |
pCfg->param.hystersis = pTriggerParam->hystersis;
|
|
1590 |
pCfg->param.enable = pTriggerParam->enable ;
|
|
1591 |
|
|
1592 |
/* Set information element header */
|
|
1593 |
pCfg->EleHdr.id = ACX_RSSI_SNR_TRIGGER;
|
|
1594 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1595 |
|
|
1596 |
TRACE8(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: threshold=%u, pacing=%u, metric=%u, type=%u, dir=%u, hyst=%u, enable=%u\n", pTriggerParam->index, pTriggerParam->threshold, pTriggerParam->pacing, pTriggerParam->metric, pTriggerParam->type, pTriggerParam->direction, pTriggerParam->hystersis, pTriggerParam->enable);
|
|
1597 |
|
|
1598 |
/* Send the configuration command */
|
|
1599 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1600 |
}
|
|
1601 |
|
|
1602 |
/****************************************************************************
|
|
1603 |
* cmdBld_CfgIeRssiSnrWeights()
|
|
1604 |
****************************************************************************
|
|
1605 |
* DESCRIPTION: Configure the RSSI/SNR Trigger parameters
|
|
1606 |
*
|
|
1607 |
* INPUTS: None
|
|
1608 |
*
|
|
1609 |
* OUTPUT: None
|
|
1610 |
*
|
|
1611 |
* RETURNS: OK or NOK
|
|
1612 |
****************************************************************************/
|
|
1613 |
TI_STATUS cmdBld_CfgIeRssiSnrWeights (TI_HANDLE hCmdBld, RssiSnrAverageWeights_t *pWeightsParam, void *fCb, TI_HANDLE hCb)
|
|
1614 |
{
|
|
1615 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1616 |
ACXRssiSnrAverageWeights_t tAcxAverageWeights;
|
|
1617 |
ACXRssiSnrAverageWeights_t *pCfg = &tAcxAverageWeights;
|
|
1618 |
|
|
1619 |
pCfg->param.rssiBeaconAverageWeight = pWeightsParam->rssiBeaconAverageWeight;
|
|
1620 |
pCfg->param.rssiPacketAverageWeight = pWeightsParam->rssiPacketAverageWeight;
|
|
1621 |
pCfg->param.snrBeaconAverageWeight = pWeightsParam->snrBeaconAverageWeight ;
|
|
1622 |
pCfg->param.snrPacketAverageWeight = pWeightsParam->snrPacketAverageWeight ;
|
|
1623 |
|
|
1624 |
/* Set information element header */
|
|
1625 |
pCfg->EleHdr.id = ACX_RSSI_SNR_WEIGHTS;
|
|
1626 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1627 |
|
|
1628 |
TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "rssi-beacon-avg-weight=%u, rssi-packet-avg-weight=%u, snr-beacon-avg-weight=%u, snr-packet-avg-weight=%u", pWeightsParam->rssiBeaconAverageWeight, pWeightsParam->rssiPacketAverageWeight, pWeightsParam->snrBeaconAverageWeight, pWeightsParam->snrPacketAverageWeight);
|
|
1629 |
|
|
1630 |
/* Send the configuration command */
|
|
1631 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1632 |
}
|
|
1633 |
|
|
1634 |
|
|
1635 |
/*
|
|
1636 |
* ----------------------------------------------------------------------------
|
|
1637 |
* Function : cmdBld_CfgIeBet
|
|
1638 |
*
|
|
1639 |
* Input : enabled - 0 to disable BET, 0 to disable BET
|
|
1640 |
* MaximumConsecutiveET - Max number of consecutive beacons
|
|
1641 |
* that may be early terminated.
|
|
1642 |
* Output : TI_STATUS
|
|
1643 |
* Process : Configures Beacon Early Termination information element.
|
|
1644 |
* Note(s) : None
|
|
1645 |
* -----------------------------------------------------------------------------
|
|
1646 |
*/
|
|
1647 |
TI_STATUS cmdBld_CfgIeBet (TI_HANDLE hCmdBld, TI_UINT8 Enable, TI_UINT8 MaximumConsecutiveET, void *fCb, TI_HANDLE hCb)
|
|
1648 |
{
|
|
1649 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1650 |
|
|
1651 |
ACXBet_Enable_t ACXBet_Enable;
|
|
1652 |
ACXBet_Enable_t* pCfg = &ACXBet_Enable;
|
|
1653 |
|
|
1654 |
/* Set information element header */
|
|
1655 |
pCfg->EleHdr.id = ACX_BET_ENABLE;
|
|
1656 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1657 |
|
|
1658 |
/* Set configuration fields */
|
|
1659 |
pCfg->Enable = Enable;
|
|
1660 |
pCfg->MaximumConsecutiveET = MaximumConsecutiveET;
|
|
1661 |
|
|
1662 |
TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Sending info elem to firmware, Enable=%d, MaximumConsecutiveET=%d\n", (TI_UINT32)pCfg->Enable, (TI_UINT32)pCfg->MaximumConsecutiveET);
|
|
1663 |
|
|
1664 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1665 |
}
|
|
1666 |
|
|
1667 |
/****************************************************************************
|
|
1668 |
* cmdBld_CmdIeConfigureKeepAliveParams()
|
|
1669 |
****************************************************************************
|
|
1670 |
* DESCRIPTION: Configure keep-alive parameters for a single template
|
|
1671 |
*
|
|
1672 |
* INPUTS: hCmdBld - handle to command builder object
|
|
1673 |
* uIndex - keep-alive index
|
|
1674 |
* uEnaDisFlag - whether keep-alive is enabled or disables
|
|
1675 |
* trigType - send keep alive when TX is idle or always
|
|
1676 |
* interval - keep-alive interval
|
|
1677 |
* fCB - callback function for command complete
|
|
1678 |
* hCb - handle to be apssed to callback function
|
|
1679 |
*
|
|
1680 |
* OUTPUT: None
|
|
1681 |
*
|
|
1682 |
* RETURNS: OK or NOK
|
|
1683 |
****************************************************************************/
|
|
1684 |
TI_STATUS cmdBld_CmdIeConfigureKeepAliveParams (TI_HANDLE hCmdBld, TI_UINT8 uIndex,
|
|
1685 |
TI_UINT8 uEnaDisFlag, TI_UINT8 trigType,
|
|
1686 |
TI_UINT32 interval, void *fCb, TI_HANDLE hCb)
|
|
1687 |
{
|
|
1688 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1689 |
AcxSetKeepAliveConfig_t ACXKeepAlive;
|
|
1690 |
|
|
1691 |
/* set IE header */
|
|
1692 |
ACXKeepAlive.EleHdr.id = ACX_SET_KEEP_ALIVE_CONFIG;
|
|
1693 |
ACXKeepAlive.EleHdr.len = sizeof (AcxSetKeepAliveConfig_t) - sizeof (EleHdrStruct);
|
|
1694 |
|
|
1695 |
/* set Keep-Alive values */
|
|
1696 |
ACXKeepAlive.index = uIndex;
|
|
1697 |
ACXKeepAlive.period = interval;
|
|
1698 |
ACXKeepAlive.trigger = trigType;
|
|
1699 |
ACXKeepAlive.valid = uEnaDisFlag;
|
|
1700 |
|
|
1701 |
TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Sending info elem to firmware, index=%d, enaDis=%d, trigType=%d, interval=%d\n", (TI_UINT32)ACXKeepAlive.index, (TI_UINT32)ACXKeepAlive.valid, (TI_UINT32)ACXKeepAlive.trigger, (TI_UINT32)ACXKeepAlive.period);
|
|
1702 |
|
|
1703 |
/* send the command to the FW */
|
|
1704 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, &ACXKeepAlive, sizeof(AcxSetKeepAliveConfig_t), fCb, hCb, NULL);
|
|
1705 |
}
|
|
1706 |
|
|
1707 |
/****************************************************************************
|
|
1708 |
* cmdBld_CmdIeConfigureKeepAliveParams()
|
|
1709 |
****************************************************************************
|
|
1710 |
* DESCRIPTION: Configure keep-alive global enable / disable flag
|
|
1711 |
*
|
|
1712 |
* INPUTS: enable / disable flag
|
|
1713 |
*
|
|
1714 |
* OUTPUT: None
|
|
1715 |
*
|
|
1716 |
* RETURNS: OK or NOK
|
|
1717 |
****************************************************************************/
|
|
1718 |
TI_STATUS cmdBld_CmdIeConfigureKeepAliveEnaDis (TI_HANDLE hCmdBld, TI_UINT8 enaDisFlag,
|
|
1719 |
void *fCb, TI_HANDLE hCb)
|
|
1720 |
{
|
|
1721 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1722 |
AcxKeepAliveMode ACXKeepAliveMode;
|
|
1723 |
|
|
1724 |
/* set IE header */
|
|
1725 |
ACXKeepAliveMode.EleHdr.id = ACX_KEEP_ALIVE_MODE;
|
|
1726 |
ACXKeepAliveMode.EleHdr.len = sizeof (AcxKeepAliveMode) - sizeof (EleHdrStruct);
|
|
1727 |
|
|
1728 |
/* set Keep-Alive mode */
|
|
1729 |
ACXKeepAliveMode.modeEnabled = enaDisFlag;
|
|
1730 |
|
|
1731 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, ": Sending info elem to firmware, enaDis=%d\n", (TI_UINT32)ACXKeepAliveMode.modeEnabled);
|
|
1732 |
|
|
1733 |
/* send the command to the FW */
|
|
1734 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, &ACXKeepAliveMode, sizeof(AcxKeepAliveMode), fCb, hCb, NULL);
|
|
1735 |
}
|
|
1736 |
|
|
1737 |
/**
|
|
1738 |
* \fn cmdBld_CfgIeSetFwHtCapabilities
|
|
1739 |
* \brief set the current AP HT Capabilities to the FW.
|
|
1740 |
*
|
|
1741 |
* \note
|
|
1742 |
* \return TI_OK on success or TI_NOK on failure
|
|
1743 |
* \sa
|
|
1744 |
*/
|
|
1745 |
TI_STATUS cmdBld_CfgIeSetFwHtCapabilities (TI_HANDLE hCmdBld,
|
|
1746 |
TI_UINT32 uHtCapabilites,
|
|
1747 |
TMacAddr tMacAddress,
|
|
1748 |
TI_UINT8 uAmpduMaxLeng,
|
|
1749 |
TI_UINT8 uAmpduMinSpac,
|
|
1750 |
void *fCb,
|
|
1751 |
TI_HANDLE hCb)
|
|
1752 |
{
|
|
1753 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1754 |
TAxcHtCapabilitiesIeFwInterface tAcxFwHtCap;
|
|
1755 |
TAxcHtCapabilitiesIeFwInterface *pCfg = &tAcxFwHtCap;
|
|
1756 |
|
|
1757 |
/* Set information element header */
|
|
1758 |
pCfg->EleHdr.id = ACX_PEER_HT_CAP;
|
|
1759 |
pCfg->EleHdr.len = sizeof(tAcxFwHtCap) - sizeof(EleHdrStruct);
|
|
1760 |
|
|
1761 |
MAC_COPY (pCfg->aMacAddress, tMacAddress);
|
|
1762 |
pCfg->uHtCapabilites = uHtCapabilites;
|
|
1763 |
pCfg->uAmpduMaxLength = uAmpduMaxLeng;
|
|
1764 |
pCfg->uAmpduMinSpacing = uAmpduMinSpac;
|
|
1765 |
|
|
1766 |
TRACE9(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSetFwHtCapabilities: HtCapabilites=0x%x, AmpduMaxLength=%d, AmpduMinSpac=%d, MAC: %x:%x:%x:%x:%x:%x\n", uHtCapabilites, uAmpduMaxLeng, uAmpduMinSpac, pCfg->aMacAddress[0], pCfg->aMacAddress[1], pCfg->aMacAddress[2], pCfg->aMacAddress[3], pCfg->aMacAddress[4], pCfg->aMacAddress[5]);
|
|
1767 |
|
|
1768 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(TAxcHtCapabilitiesIeFwInterface), fCb, hCb, NULL);
|
|
1769 |
|
|
1770 |
}
|
|
1771 |
|
|
1772 |
/**
|
|
1773 |
* \fn cmdBld_CfgIeSetFwHtInformation
|
|
1774 |
* \brief set the current AP HT Information to the FW.
|
|
1775 |
*
|
|
1776 |
* \note
|
|
1777 |
* \return TI_OK on success or TI_NOK on failure
|
|
1778 |
* \sa
|
|
1779 |
*/
|
|
1780 |
TI_STATUS cmdBld_CfgIeSetFwHtInformation (TI_HANDLE hCmdBld,
|
|
1781 |
TI_UINT8 uRifsMode,
|
|
1782 |
TI_UINT8 uHtProtection,
|
|
1783 |
TI_UINT8 uGfProtection,
|
|
1784 |
TI_UINT8 uHtTxBurstLimit,
|
|
1785 |
TI_UINT8 uDualCtsProtection,
|
|
1786 |
void *fCb,
|
|
1787 |
TI_HANDLE hCb)
|
|
1788 |
{
|
|
1789 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1790 |
TAxcHtInformationIeFwInterface tAcxFwHtInf;
|
|
1791 |
TAxcHtInformationIeFwInterface *pCfg = &tAcxFwHtInf;
|
|
1792 |
|
|
1793 |
/* Set information element header */
|
|
1794 |
pCfg->EleHdr.id = ACX_HT_BSS_OPERATION;
|
|
1795 |
pCfg->EleHdr.len = sizeof(tAcxFwHtInf) - sizeof(EleHdrStruct);
|
|
1796 |
|
|
1797 |
pCfg->uRifsMode = uRifsMode;
|
|
1798 |
pCfg->uHtProtection = uHtProtection;
|
|
1799 |
pCfg->uGfProtection = uGfProtection;
|
|
1800 |
pCfg->uHtTxBurstLimit = uHtTxBurstLimit;
|
|
1801 |
pCfg->uDualCtsProtection = uDualCtsProtection;
|
|
1802 |
|
|
1803 |
TRACE5(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSetFwHtInformation: RifsMode=0x%x, HtProtection=0x%x, GfProtection=0x%x, HtTxBurstLimit=0x%x, DualCtsProtection=0x%x\n", uRifsMode, uHtProtection, uGfProtection, uHtTxBurstLimit, uDualCtsProtection);
|
|
1804 |
|
|
1805 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(TAxcHtInformationIeFwInterface), fCb, hCb, NULL);
|
|
1806 |
}
|
|
1807 |
|
|
1808 |
/**
|
|
1809 |
* \fn cmdBld_CfgIeSetBaSession
|
|
1810 |
* \brief configure BA session initiator\receiver parameters setting in the FW.
|
|
1811 |
*
|
|
1812 |
* \note
|
|
1813 |
* \return TI_OK on success or TI_NOK on failure
|
|
1814 |
* \sa
|
|
1815 |
*/
|
|
1816 |
TI_STATUS cmdBld_CfgIeSetBaSession (TI_HANDLE hCmdBld,
|
|
1817 |
InfoElement_e eBaType,
|
|
1818 |
TI_UINT8 uTid,
|
|
1819 |
TI_UINT8 uState,
|
|
1820 |
TMacAddr tRa,
|
|
1821 |
TI_UINT16 uWinSize,
|
|
1822 |
TI_UINT16 uInactivityTimeout,
|
|
1823 |
void *fCb,
|
|
1824 |
TI_HANDLE hCb)
|
|
1825 |
{
|
|
1826 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1827 |
TAxcBaSessionInitiatorResponderPolicy tAcxBaSessionPrm;
|
|
1828 |
TAxcBaSessionInitiatorResponderPolicy *pCfg = &tAcxBaSessionPrm;
|
|
1829 |
|
|
1830 |
/* Set information element header */
|
|
1831 |
pCfg->EleHdr.id = eBaType;
|
|
1832 |
pCfg->EleHdr.len = sizeof(tAcxBaSessionPrm) - sizeof(EleHdrStruct);
|
|
1833 |
|
|
1834 |
MAC_COPY (pCfg->aMacAddress, tRa);
|
|
1835 |
pCfg->uTid = uTid;
|
|
1836 |
pCfg->uPolicy = uState;
|
|
1837 |
pCfg->uWinSize = uWinSize;
|
|
1838 |
|
|
1839 |
if (eBaType == ACX_BA_SESSION_INITIATOR_POLICY)
|
|
1840 |
{
|
|
1841 |
pCfg->uInactivityTimeout = uInactivityTimeout;
|
|
1842 |
}
|
|
1843 |
else
|
|
1844 |
{
|
|
1845 |
if (eBaType == ACX_BA_SESSION_RESPONDER_POLICY)
|
|
1846 |
{
|
|
1847 |
pCfg->uInactivityTimeout = 0;
|
|
1848 |
}
|
|
1849 |
else
|
|
1850 |
{
|
|
1851 |
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_CfgIeSetBaSession: error ID=%u\n", pCfg->EleHdr.id);
|
|
1852 |
return TI_NOK;
|
|
1853 |
}
|
|
1854 |
}
|
|
1855 |
|
|
1856 |
TRACE10(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CfgIeSetBaSession: ID=, TID=%u, Policy=%u, MAC: %x:%x:%x:%x:%x:%x, uWinSize=%u, Timeout=%u\n", pCfg->uTid, pCfg->uPolicy, pCfg->aMacAddress[0], pCfg->aMacAddress[1], pCfg->aMacAddress[2], pCfg->aMacAddress[3], pCfg->aMacAddress[4], pCfg->aMacAddress[5], pCfg->uWinSize, pCfg->uInactivityTimeout);
|
|
1857 |
|
|
1858 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(TAxcBaSessionInitiatorResponderPolicy), fCb, hCb, NULL);
|
|
1859 |
}
|
|
1860 |
|
|
1861 |
/**
|
|
1862 |
* \fn cmdBld_CfgIeRadioParams
|
|
1863 |
* \brief configure radio parameters setting in the FW.
|
|
1864 |
*
|
|
1865 |
* \note
|
|
1866 |
* \return TI_OK on success or TI_NOK on failure
|
|
1867 |
* \sa
|
|
1868 |
*/
|
|
1869 |
TI_STATUS cmdBld_CfgIeRadioParams (TI_HANDLE hCmdBld, IniFileRadioParam *pIniFileRadioParams, void *fCb, TI_HANDLE hCb)
|
|
1870 |
{
|
|
1871 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1872 |
TTestCmd TestCmd;
|
|
1873 |
TTestCmd *pTestCmd = &TestCmd;
|
|
1874 |
|
|
1875 |
pTestCmd->testCmdId = TEST_CMD_INI_FILE_RADIO_PARAM;
|
|
1876 |
|
|
1877 |
os_memoryCopy(pCmdBld->hOs, &pTestCmd->testCmd_u.IniFileRadioParams, pIniFileRadioParams, sizeof(IniFileRadioParam));
|
|
1878 |
|
|
1879 |
|
|
1880 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
|
|
1881 |
CMD_TEST,
|
|
1882 |
(void *)pTestCmd,
|
|
1883 |
sizeof(IniFileRadioParam) + 4,
|
|
1884 |
fCb,
|
|
1885 |
hCb,
|
|
1886 |
(void*)pTestCmd);
|
|
1887 |
}
|
|
1888 |
|
|
1889 |
|
|
1890 |
TI_STATUS cmdBld_CfgPlatformGenParams (TI_HANDLE hCmdBld, IniFileGeneralParam *pGenParams, void *fCb, TI_HANDLE hCb)
|
|
1891 |
{
|
|
1892 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1893 |
TTestCmd TestCmd;
|
|
1894 |
TTestCmd *pTestCmd = &TestCmd;
|
|
1895 |
|
|
1896 |
pTestCmd->testCmdId = TEST_CMD_INI_FILE_GENERAL_PARAM;
|
|
1897 |
|
|
1898 |
os_memoryCopy(pCmdBld->hOs, &pTestCmd->testCmd_u.IniFileGeneralParams, pGenParams, sizeof(IniFileGeneralParam));
|
|
1899 |
|
|
1900 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
|
|
1901 |
CMD_TEST,
|
|
1902 |
(void *)pTestCmd,
|
|
1903 |
sizeof(IniFileGeneralParam) + 4,
|
|
1904 |
fCb,
|
|
1905 |
hCb,
|
|
1906 |
(void*)pTestCmd);
|
|
1907 |
|
|
1908 |
}
|
|
1909 |
|
|
1910 |
|
|
1911 |
|
|
1912 |
|
|
1913 |
/****************************************************************************
|
|
1914 |
* cmdBld_CfgIeBurstMode()
|
|
1915 |
****************************************************************************
|
|
1916 |
* DESCRIPTION: Configure burst mode
|
|
1917 |
*
|
|
1918 |
* INPUTS: hCmdBld - handle to command builder object
|
|
1919 |
* bEnabled - is enabled flag
|
|
1920 |
* fCB - callback function for command complete
|
|
1921 |
* hCb - handle to be apssed to callback function
|
|
1922 |
*
|
|
1923 |
* OUTPUT: None
|
|
1924 |
*
|
|
1925 |
* RETURNS: OK or NOK
|
|
1926 |
****************************************************************************/
|
|
1927 |
TI_STATUS cmdBld_CfgIeBurstMode (TI_HANDLE hCmdBld, TI_BOOL bEnabled, void *fCb, TI_HANDLE hCb)
|
|
1928 |
{
|
|
1929 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1930 |
AcxBurstMode tAcxBurstMode;
|
|
1931 |
AcxBurstMode *pCfg = &tAcxBurstMode;
|
|
1932 |
|
|
1933 |
/* set IE header */
|
|
1934 |
pCfg->EleHdr.id = ACX_BURST_MODE;
|
|
1935 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1936 |
|
|
1937 |
/* set burst mode value */
|
|
1938 |
pCfg->enable = (uint8)bEnabled;
|
|
1939 |
|
|
1940 |
/* send the command to the FW */
|
|
1941 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1942 |
}
|
|
1943 |
|
|
1944 |
/****************************************************************************
|
|
1945 |
* cmdBld_CfgIeSRstate()
|
|
1946 |
****************************************************************************
|
|
1947 |
* DESCRIPTION: Configure sart reflex state
|
|
1948 |
*
|
|
1949 |
* INPUTS: hCmdBld - handle to command builder object
|
|
1950 |
* bEnabled - is enabled flag
|
|
1951 |
* fCB - callback function for command complete
|
|
1952 |
* hCb - handle to be apssed to callback function
|
|
1953 |
*
|
|
1954 |
* OUTPUT: None
|
|
1955 |
*
|
|
1956 |
* RETURNS: OK or NOK
|
|
1957 |
****************************************************************************/
|
|
1958 |
|
|
1959 |
TI_STATUS cmdBld_CfgIeSRState (TI_HANDLE hCmdBld, uint8 SRstate, void *fCb, TI_HANDLE hCb)
|
|
1960 |
{
|
|
1961 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1962 |
ACXSmartReflexState_t tSmartReflexState;
|
|
1963 |
ACXSmartReflexState_t *pCfg = &tSmartReflexState;
|
|
1964 |
|
|
1965 |
/* set IE header */
|
|
1966 |
pCfg->EleHdr.id = ACX_SET_SMART_REFLEX_STATE;
|
|
1967 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
1968 |
|
|
1969 |
/* set smart refelx state */
|
|
1970 |
pCfg->enable = SRstate;
|
|
1971 |
|
|
1972 |
/* send the command to the FW */
|
|
1973 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
1974 |
|
|
1975 |
}
|
|
1976 |
|
|
1977 |
/****************************************************************************
|
|
1978 |
* cmdBld_CfgIeSRDebug()
|
|
1979 |
****************************************************************************
|
|
1980 |
* DESCRIPTION: Send debug param just if it's configured in ini file
|
|
1981 |
* INPUTS: hCmdBld - handle to command builder object
|
|
1982 |
* bEnabled - is enabled flag
|
|
1983 |
* fCB - callback function for command complete
|
|
1984 |
* hCb - handle to be apssed to callback function
|
|
1985 |
*
|
|
1986 |
* OUTPUT: None
|
|
1987 |
*
|
|
1988 |
* RETURNS: OK or NOK
|
|
1989 |
****************************************************************************/
|
|
1990 |
TI_STATUS cmdBld_CfgIeSRDebug (TI_HANDLE hCmdBld, ACXSmartReflexDebugParams_t *pSRDebug, void *fCb, TI_HANDLE hCb)
|
|
1991 |
{
|
|
1992 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
1993 |
ACXSmartReflexDebugParams_t tSmartReflexDebug;
|
|
1994 |
ACXSmartReflexDebugParams_t *pCfg = &tSmartReflexDebug;
|
|
1995 |
|
|
1996 |
/* send this command to FW just in case it's initialize in ini file */
|
|
1997 |
if (pSRDebug->senNRN == 0) {
|
|
1998 |
return TI_NOK;
|
|
1999 |
}
|
|
2000 |
|
|
2001 |
/* copy smart reflex debug params*/
|
|
2002 |
os_memoryCopy(pCmdBld->hOs, pCfg, pSRDebug, sizeof(ACXSmartReflexDebugParams_t));
|
|
2003 |
|
|
2004 |
/* set IE header */
|
|
2005 |
pCfg->EleHdr.id = ACX_SET_SMART_REFLEX_DEBUG;
|
|
2006 |
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
|
|
2007 |
|
|
2008 |
/* send the command to the FW */
|
|
2009 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(*pCfg), fCb, hCb, NULL);
|
|
2010 |
|
|
2011 |
}
|
|
2012 |
|
|
2013 |
/****************************************************************************
|
|
2014 |
* cmdBld_CfgIeDcoItrimParams()
|
|
2015 |
****************************************************************************
|
|
2016 |
* DESCRIPTION: Configure/Interrogate the DCO Itrim parameters
|
|
2017 |
*
|
|
2018 |
* INPUTS:
|
|
2019 |
*
|
|
2020 |
* OUTPUT: None
|
|
2021 |
*
|
|
2022 |
* RETURNS: TI_OK or TI_NOK
|
|
2023 |
****************************************************************************/
|
|
2024 |
TI_STATUS cmdBld_CfgIeDcoItrimParams (TI_HANDLE hCmdBld, TI_BOOL enable, TI_UINT32 moderationTimeoutUsec, void *fCb, TI_HANDLE hCb)
|
|
2025 |
{
|
|
2026 |
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
|
|
2027 |
ACXDCOItrimParams_t ACXBeaconFilterOptions;
|
|
2028 |
ACXDCOItrimParams_t *pCfg = &ACXBeaconFilterOptions;
|
|
2029 |
|
|
2030 |
pCfg->enable = enable;
|
|
2031 |
pCfg->moderation_timeout_usec = moderationTimeoutUsec;
|
|
2032 |
|
|
2033 |
/* Set information element header */
|
|
2034 |
pCfg->EleHdr.id = ACX_SET_DCO_ITRIM_PARAMS;
|
|
2035 |
pCfg->EleHdr.len = sizeof(ACXDCOItrimParams_t) - sizeof(EleHdrStruct);
|
|
2036 |
|
|
2037 |
TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "ID=%u: enable=%u, moderation_timeout_usec=%u\n", pCfg->EleHdr.id, enable, moderationTimeoutUsec);
|
|
2038 |
|
|
2039 |
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CONFIGURE, pCfg, sizeof(ACXDCOItrimParams_t), fCb, hCb, NULL);
|
|
2040 |
}
|
|
2041 |
|
|
2042 |
|
|
2043 |
|