|
1 /* |
|
2 * CmdMBox.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 CmdMBox.c |
|
41 * \brief Handle the wlan hardware command mailbox |
|
42 * |
|
43 * \see CmdMBox.h, CmdMBox_api.h, CmdQueue.c |
|
44 */ |
|
45 |
|
46 #define __FILE_ID__ FILE_ID_101 |
|
47 #include "tidef.h" |
|
48 #include "osApi.h" |
|
49 #include "timer.h" |
|
50 #include "report.h" |
|
51 #include "FwEvent_api.h" |
|
52 #include "CmdMBox_api.h" |
|
53 #include "CmdMBox.h" |
|
54 #include "CmdQueue_api.h" |
|
55 #include "TWDriverInternal.h" |
|
56 #include "TwIf.h" |
|
57 |
|
58 /***************************************************************************** |
|
59 ** Internal functions definitions ** |
|
60 *****************************************************************************/ |
|
61 |
|
62 /* |
|
63 * \brief Handle cmdMbox timeout. |
|
64 * |
|
65 * \param hCmdMbox - Handle to CmdMbox |
|
66 * \return TI_OK |
|
67 * |
|
68 * \par Description |
|
69 * Call fErrorCb() to handle the error. |
|
70 * |
|
71 * \sa cmdMbox_SendCommand |
|
72 */ |
|
73 static void cmdMbox_TimeOut (TI_HANDLE hCmdMbox, TI_BOOL bTwdInitOccured); |
|
74 static void cmdMbox_ConfigHwCb (TI_HANDLE hCmdMbox, TTxnStruct *pTxn); |
|
75 |
|
76 /* |
|
77 * \brief Create the mailbox object |
|
78 * |
|
79 * \param hOs - OS module object handle |
|
80 * \return Handle to the created object |
|
81 * |
|
82 * \par Description |
|
83 * Calling this function creates a CmdMbox object |
|
84 * |
|
85 * \sa cmdMbox_Destroy |
|
86 */ |
|
87 TI_HANDLE cmdMbox_Create (TI_HANDLE hOs) |
|
88 { |
|
89 TCmdMbox *pCmdMbox; |
|
90 TI_UINT8 CMD; |
|
91 |
|
92 pCmdMbox = os_memoryAlloc (hOs, sizeof (TCmdMbox),MemoryNormal); |
|
93 if (pCmdMbox == NULL) |
|
94 { |
|
95 WLAN_OS_REPORT (("FATAL ERROR: cmdMbox_Create(): Error Creating CmdMbox - Aborting\n")); |
|
96 return NULL; |
|
97 } |
|
98 |
|
99 /* reset control module control block */ |
|
100 os_memoryZero (hOs, pCmdMbox, sizeof (TCmdMbox)); |
|
101 pCmdMbox->hOs = hOs; |
|
102 |
|
103 /* Allocate the CMD Mbox buffers and Registers buffers */ |
|
104 for (CMD = 0; CMD < CMD_NUM; CMD++) |
|
105 { |
|
106 /* MBOX */ |
|
107 pCmdMbox->aCmdTxn[CMD].pCmdMbox = os_memoryAlloc (hOs, sizeof (Command_t) + WSPI_PAD_LEN_READ,MemoryDMA); |
|
108 if (pCmdMbox->aCmdTxn[CMD].pCmdMbox == NULL) |
|
109 { |
|
110 return NULL; |
|
111 } |
|
112 os_memoryZero (hOs, pCmdMbox->aCmdTxn[CMD].pCmdMbox, sizeof (Command_t) + WSPI_PAD_LEN_READ); |
|
113 pCmdMbox->aCmdTxn[CMD].pCmdMbox += WSPI_PAD_LEN_READ; |
|
114 /* Register */ |
|
115 pCmdMbox->aRegTxn[CMD].pRegister = os_memoryAlloc (hOs, sizeof (TI_UINT32) + WSPI_PAD_LEN_READ,MemoryDMA); |
|
116 if (pCmdMbox->aRegTxn[CMD].pRegister == NULL) |
|
117 { |
|
118 return NULL; |
|
119 } |
|
120 os_memoryZero (hOs, pCmdMbox->aRegTxn[CMD].pRegister, sizeof (TI_UINT32) + WSPI_PAD_LEN_READ); |
|
121 pCmdMbox->aRegTxn[CMD].pRegister += WSPI_PAD_LEN_READ; |
|
122 } |
|
123 |
|
124 |
|
125 return pCmdMbox; |
|
126 } |
|
127 |
|
128 |
|
129 /* |
|
130 * \brief Destroys the mailbox object |
|
131 * |
|
132 * \param hCmdMbox - The object to free |
|
133 * \return TI_OK |
|
134 * |
|
135 * \par Description |
|
136 * Calling this function destroys a CmdMbox object |
|
137 * |
|
138 * \sa cmdMbox_Create |
|
139 */ |
|
140 TI_STATUS cmdMbox_Destroy (TI_HANDLE hCmdMbox) |
|
141 { |
|
142 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
143 TI_UINT8 CMD; |
|
144 |
|
145 /* free timer */ |
|
146 if (pCmdMbox->hCmdMboxTimer) |
|
147 { |
|
148 tmr_DestroyTimer (pCmdMbox->hCmdMboxTimer); |
|
149 } |
|
150 |
|
151 /* Free MBOX and Registers buffers */ |
|
152 for (CMD = 0; CMD < CMD_NUM; CMD++) |
|
153 { |
|
154 if (pCmdMbox->aCmdTxn[CMD].pCmdMbox) |
|
155 { |
|
156 os_memoryFree (pCmdMbox->hOs, ((TI_UINT8*)(pCmdMbox->aCmdTxn[CMD].pCmdMbox)) - WSPI_PAD_LEN_READ, sizeof (Command_t) + WSPI_PAD_LEN_READ); |
|
157 } |
|
158 if (pCmdMbox->aRegTxn[CMD].pRegister) |
|
159 { |
|
160 os_memoryFree (pCmdMbox->hOs, pCmdMbox->aRegTxn[CMD].pRegister - WSPI_PAD_LEN_READ, sizeof (TI_UINT32) + WSPI_PAD_LEN_READ); |
|
161 } |
|
162 } |
|
163 |
|
164 /* free context */ |
|
165 os_memoryFree (pCmdMbox->hOs, pCmdMbox, sizeof (TCmdMbox)); |
|
166 |
|
167 return TI_OK; |
|
168 } |
|
169 |
|
170 |
|
171 /* |
|
172 * \brief Configure the CmdMbox object |
|
173 * |
|
174 * \param hCmdMbox - Handle to CmdMbox |
|
175 * \param hReport - Handle to report module |
|
176 * \param hTwIf - Handle to TwIf |
|
177 * \param hTimer - Handle to os timer |
|
178 * \param hCmdQueue - Handle to CmdQueue |
|
179 * \param fErrorCb - Handle to error handling function |
|
180 * \return TI_OK on success or TI_NOK on failure |
|
181 * |
|
182 * \par Description |
|
183 * |
|
184 * \sa |
|
185 */ |
|
186 TI_STATUS cmdMbox_Init (TI_HANDLE hCmdMbox, |
|
187 TI_HANDLE hReport, |
|
188 TI_HANDLE hTwIf, |
|
189 TI_HANDLE hTimer, |
|
190 TI_HANDLE hCmdQueue, |
|
191 TCmdMboxErrorCb fErrorCb) |
|
192 { |
|
193 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
194 |
|
195 pCmdMbox->hCmdQueue = hCmdQueue; |
|
196 pCmdMbox->hTwIf = hTwIf; |
|
197 pCmdMbox->hReport = hReport; |
|
198 pCmdMbox->hCmdMboxTimer = hTimer; |
|
199 |
|
200 pCmdMbox->uFwAddr = 0; |
|
201 pCmdMbox->uReadLen = 0; |
|
202 pCmdMbox->uWriteLen = 0; |
|
203 pCmdMbox->bCmdInProgress = TI_FALSE; |
|
204 pCmdMbox->fErrorCb = fErrorCb; |
|
205 |
|
206 /* allocate OS timer memory */ |
|
207 pCmdMbox->hCmdMboxTimer = tmr_CreateTimer (hTimer); |
|
208 if (pCmdMbox->hCmdMboxTimer == NULL) |
|
209 { |
|
210 TRACE0(pCmdMbox->hReport, REPORT_SEVERITY_ERROR, "cmdMbox_Init(): Failed to create hCmdMboxTimer!\n"); |
|
211 return TI_NOK; |
|
212 } |
|
213 |
|
214 return TI_OK; |
|
215 } |
|
216 |
|
217 |
|
218 /* |
|
219 * \brief Send the Command to the Mailbox |
|
220 * |
|
221 * \param hCmdMbox - Handle to CmdMbox |
|
222 * \param cmdType - |
|
223 * \param pParamsBuf - The buffer that will be written to the mailbox |
|
224 * \param uWriteLen - Length of data to write to the mailbox |
|
225 * \param uReadLen - Length of data to read from the mailbox (when the result is received) |
|
226 * \return TI_PENDING |
|
227 * |
|
228 * \par Description |
|
229 * Copy the buffer given to a local struct, update the write & read lengths |
|
230 * and send to the FW's mailbox. |
|
231 * |
|
232 * ------------------------------------------------------ |
|
233 * | CmdMbox Header | Cmd Header | Command parameters | |
|
234 * ------------------------------------------------------ |
|
235 * | ID | Status | Type | Length | Command parameters | |
|
236 * ------------------------------------------------------ |
|
237 * 16bit 16bit 16bit 16bit |
|
238 * |
|
239 * \sa cmdMbox_CommandComplete |
|
240 */ |
|
241 TI_STATUS cmdMbox_SendCommand (TI_HANDLE hCmdMbox, Command_e cmdType, TI_UINT8* pParamsBuf, TI_UINT32 uWriteLen, TI_UINT32 uReadLen) |
|
242 { |
|
243 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
244 TTxnStruct *pCmdTxn = (TTxnStruct*)&pCmdMbox->aCmdTxn[0].tTxnStruct; |
|
245 TTxnStruct *pRegTxn = (TTxnStruct*)&pCmdMbox->aRegTxn[0].tTxnStruct; |
|
246 Command_t *pCmd = ((Command_t *)(pCmdMbox->aCmdTxn[0].pCmdMbox)); |
|
247 |
|
248 |
|
249 if (pCmdMbox->bCmdInProgress) |
|
250 { |
|
251 TRACE0(pCmdMbox->hReport, REPORT_SEVERITY_ERROR, "cmdMbox_SendCommand(): Trying to send Cmd while other Cmd is still in progres!\n"); |
|
252 return TI_NOK; |
|
253 } |
|
254 |
|
255 /* Add the CMDMBOX_HEADER_LEN to the read length, used when reading the result later on */ |
|
256 pCmdMbox->uReadLen = uReadLen + CMDMBOX_HEADER_LEN; |
|
257 /* Prepare the Cmd Hw template */ |
|
258 pCmd->cmdID = cmdType; |
|
259 pCmd->cmdStatus = TI_OK; |
|
260 os_memoryCopy (pCmdMbox->hOs, (void *)pCmd->parameters, (void *)pParamsBuf, uWriteLen); |
|
261 |
|
262 /* Add the CMDMBOX_HEADER_LEN to the write length */ |
|
263 pCmdMbox->uWriteLen = uWriteLen + CMDMBOX_HEADER_LEN; |
|
264 |
|
265 /* Must make sure that the length is multiple of 32 bit */ |
|
266 if (pCmdMbox->uWriteLen & 0x3) |
|
267 { |
|
268 TRACE1(pCmdMbox->hReport, REPORT_SEVERITY_WARNING, "cmdMbox_SendCommand(): Command length isn't 32bit aligned! CmdId=%d\n", pCmd->cmdID); |
|
269 pCmdMbox->uWriteLen = (pCmdMbox->uWriteLen + 4) & 0xFFFFFFFC; |
|
270 } |
|
271 |
|
272 /* no other command can start the send process till bCmdInProgress will return to TI_FALSE*/ |
|
273 pCmdMbox->bCmdInProgress = TI_TRUE; |
|
274 |
|
275 /* Build the command TxnStruct */ |
|
276 TXN_PARAM_SET(pCmdTxn, TXN_LOW_PRIORITY, TXN_FUNC_ID_WLAN, TXN_DIRECTION_WRITE, TXN_INC_ADDR) |
|
277 BUILD_TTxnStruct(pCmdTxn, pCmdMbox->uFwAddr, pCmd, pCmdMbox->uWriteLen, NULL, NULL) |
|
278 /* Send the command */ |
|
279 twIf_Transact(pCmdMbox->hTwIf, pCmdTxn); |
|
280 |
|
281 /* Build the trig TxnStruct */ |
|
282 *((TI_UINT32*)(pCmdMbox->aRegTxn[0].pRegister)) = INTR_TRIG_CMD; |
|
283 TXN_PARAM_SET(pRegTxn, TXN_LOW_PRIORITY, TXN_FUNC_ID_WLAN, TXN_DIRECTION_WRITE, TXN_INC_ADDR) |
|
284 BUILD_TTxnStruct(pRegTxn, ACX_REG_INTERRUPT_TRIG, pCmdMbox->aRegTxn[0].pRegister, REGISTER_SIZE, NULL, NULL) |
|
285 |
|
286 /* start the CmdMbox timer */ |
|
287 tmr_StartTimer (pCmdMbox->hCmdMboxTimer, cmdMbox_TimeOut, hCmdMbox, CMDMBOX_WAIT_TIMEOUT, TI_FALSE); |
|
288 |
|
289 /* Send the FW trigger */ |
|
290 twIf_Transact(pCmdMbox->hTwIf, pRegTxn); |
|
291 |
|
292 |
|
293 return TXN_STATUS_PENDING; |
|
294 } |
|
295 |
|
296 |
|
297 /* |
|
298 * \brief Read the command's result |
|
299 * |
|
300 * \param hCmdMbox - Handle to CmdMbox |
|
301 * \return void |
|
302 * |
|
303 * \par Description |
|
304 * This function is called from FwEvent module uppon receiving command complete interrupt. |
|
305 * It issues a read transaction from the mailbox with a CB. |
|
306 * |
|
307 * \sa cmdMbox_SendCommand, cmdMbox_TransferComplete |
|
308 */ |
|
309 void cmdMbox_CommandComplete (TI_HANDLE hCmdMbox) |
|
310 { |
|
311 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
312 TTxnStruct *pCmdTxn = (TTxnStruct*)&pCmdMbox->aCmdTxn[1].tTxnStruct; |
|
313 Command_t *pCmd = ((Command_t *)(pCmdMbox->aCmdTxn[1].pCmdMbox)); |
|
314 ETxnStatus rc; |
|
315 |
|
316 /* stop the CmdMbox timer */ |
|
317 tmr_StopTimer(pCmdMbox->hCmdMboxTimer); |
|
318 |
|
319 /* Build the command TxnStruct */ |
|
320 TXN_PARAM_SET(pCmdTxn, TXN_LOW_PRIORITY, TXN_FUNC_ID_WLAN, TXN_DIRECTION_READ, TXN_INC_ADDR) |
|
321 /* Applying a CB in case of an async read */ |
|
322 BUILD_TTxnStruct(pCmdTxn, pCmdMbox->uFwAddr, pCmd, pCmdMbox->uReadLen,(TTxnDoneCb)cmdMbox_TransferComplete, hCmdMbox) |
|
323 /* Send the command */ |
|
324 rc = twIf_Transact(pCmdMbox->hTwIf, pCmdTxn); |
|
325 |
|
326 /* In case of a sync read, call the CB directly */ |
|
327 if (rc == TXN_STATUS_COMPLETE) |
|
328 { |
|
329 cmdMbox_TransferComplete(hCmdMbox); |
|
330 } |
|
331 } |
|
332 |
|
333 |
|
334 /* |
|
335 * \brief Calls the cmdQueue_ResultReceived. |
|
336 * |
|
337 * \param hCmdMbox - Handle to CmdMbox |
|
338 * \return TI_OK |
|
339 * |
|
340 * \par Description |
|
341 * This function is called from cmdMbox_CommandComplete on a sync read, or from TwIf as a CB on an async read. |
|
342 * It calls cmdQueue_ResultReceived to continue the result handling procces & switch the bCmdInProgress flag to TI_FALSE, |
|
343 * meaning other commands can be sent to the FW. |
|
344 * |
|
345 * \sa cmdMbox_SendCommand, cmdMbox_TransferComplete |
|
346 */ |
|
347 TI_STATUS cmdMbox_TransferComplete(TI_HANDLE hCmdMbox) |
|
348 { |
|
349 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
350 |
|
351 /* Other commands can be sent to the FW */ |
|
352 pCmdMbox->bCmdInProgress = TI_FALSE; |
|
353 |
|
354 cmdQueue_ResultReceived(pCmdMbox->hCmdQueue); |
|
355 |
|
356 return TI_OK; |
|
357 } |
|
358 |
|
359 |
|
360 /* |
|
361 * \brief Handle cmdMbox timeout. |
|
362 * |
|
363 * \param hCmdMbox - Handle to CmdMbox |
|
364 * \return TI_OK |
|
365 * |
|
366 * \par Description |
|
367 * Call fErrorCb() to handle the error. |
|
368 * |
|
369 * \sa cmdMbox_SendCommand |
|
370 */ |
|
371 static void cmdMbox_TimeOut (TI_HANDLE hCmdMbox, TI_BOOL bTwdInitOccured) |
|
372 { |
|
373 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
374 Command_t *pCmd = ((Command_t *)(pCmdMbox->aCmdTxn[0].pCmdMbox)); |
|
375 |
|
376 TRACE0(pCmdMbox->hReport, REPORT_SEVERITY_ERROR , "cmdMbox_TimeOut: Timeout occured in CmdMbox\n"); |
|
377 |
|
378 /* Call error CB */ |
|
379 if (pCmdMbox->fErrorCb != NULL) |
|
380 { |
|
381 pCmdMbox->fErrorCb (pCmdMbox->hCmdQueue, |
|
382 (TI_UINT32)pCmd->cmdID, |
|
383 CMD_STATUS_TIMEOUT, |
|
384 (void *)pCmd->parameters); |
|
385 } |
|
386 } |
|
387 |
|
388 |
|
389 /* |
|
390 * \brief configure the mailbox address. |
|
391 * |
|
392 * \param hCmdMbox - Handle to CmdMbox |
|
393 * \param fCb - Pointer to the CB |
|
394 * \param hCb - Cb's handle |
|
395 * \return TI_OK or TI_PENDING |
|
396 * |
|
397 * \par Description |
|
398 * Called from HwInit to read the command mailbox address. |
|
399 * |
|
400 * \sa |
|
401 */ |
|
402 TI_STATUS cmdMbox_ConfigHw (TI_HANDLE hCmdMbox, fnotify_t fCb, TI_HANDLE hCb) |
|
403 { |
|
404 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
405 TTxnStruct *pRegTxn = (TTxnStruct*)&pCmdMbox->aRegTxn[1].tTxnStruct; |
|
406 TI_STATUS rc; |
|
407 |
|
408 pCmdMbox->fCb = fCb; |
|
409 pCmdMbox->hCb = hCb; |
|
410 /* Build the command TxnStruct */ |
|
411 TXN_PARAM_SET(pRegTxn, TXN_LOW_PRIORITY, TXN_FUNC_ID_WLAN, TXN_DIRECTION_READ, TXN_INC_ADDR) |
|
412 BUILD_TTxnStruct(pRegTxn, REG_COMMAND_MAILBOX_PTR, pCmdMbox->aRegTxn[1].pRegister, REGISTER_SIZE,(TTxnDoneCb)cmdMbox_ConfigHwCb, hCmdMbox) |
|
413 /* Get the command mailbox address */ |
|
414 rc = twIf_Transact(pCmdMbox->hTwIf, pRegTxn); |
|
415 if (rc == TXN_STATUS_COMPLETE) |
|
416 { |
|
417 pCmdMbox->uFwAddr = *((TI_UINT32 *)(pCmdMbox->aRegTxn[1].pRegister)); |
|
418 } |
|
419 |
|
420 return rc; |
|
421 } |
|
422 |
|
423 |
|
424 /* |
|
425 * \brief Cb to cmdMbox_ConfigHw |
|
426 * |
|
427 * \param hCmdMbox - Handle to CmdMbox |
|
428 * \return TI_OK |
|
429 * |
|
430 * \par Description |
|
431 * |
|
432 * \sa |
|
433 */ |
|
434 static void cmdMbox_ConfigHwCb (TI_HANDLE hCmdMbox, TTxnStruct *pTxn) |
|
435 { |
|
436 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
437 |
|
438 pCmdMbox->uFwAddr = *((TI_UINT32 *)(pCmdMbox->aRegTxn[1].pRegister)); |
|
439 |
|
440 /* Call back the original State Machine */ |
|
441 pCmdMbox->fCb(pCmdMbox->hCb, TI_OK); |
|
442 } |
|
443 |
|
444 |
|
445 /* |
|
446 * \brief Restart the module upon driver stop or restart |
|
447 * |
|
448 * \param hCmdMbox - Handle to CmdMbox |
|
449 * \return TI_OK |
|
450 * |
|
451 * \par Description |
|
452 * |
|
453 * \sa |
|
454 */ |
|
455 TI_STATUS cmdMbox_Restart (TI_HANDLE hCmdMbox) |
|
456 { |
|
457 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
458 |
|
459 /* Stop the timeout timer if running and reset the state */ |
|
460 tmr_StopTimer (pCmdMbox->hCmdMboxTimer); |
|
461 pCmdMbox->bCmdInProgress = TI_FALSE; |
|
462 pCmdMbox->uReadLen = 0; |
|
463 pCmdMbox->uWriteLen = 0; |
|
464 |
|
465 return TI_OK; |
|
466 } |
|
467 |
|
468 |
|
469 /* |
|
470 * \brief Return the latest command status |
|
471 * |
|
472 * \param hCmdMbox - Handle to CmdMbox |
|
473 * \return TI_OK or TI_NOK |
|
474 * |
|
475 * \par Description |
|
476 * |
|
477 * \sa |
|
478 */ |
|
479 TI_STATUS cmdMbox_GetStatus (TI_HANDLE hCmdMbox) |
|
480 { |
|
481 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
482 Command_t *pCmd = ((Command_t *)(pCmdMbox->aCmdTxn[1].pCmdMbox)); |
|
483 TI_STATUS status; |
|
484 |
|
485 status = (pCmd->cmdStatus == CMD_STATUS_SUCCESS) ? TI_OK : TI_NOK; |
|
486 TRACE2(pCmdMbox->hReport, REPORT_SEVERITY_INFORMATION , "cmdMbox_GetStatus: TI_STATUS = (%d) <= pCmdMbox->pCmdMbox.cmdStatus = %d\n", status, pCmd->cmdStatus); |
|
487 return status; |
|
488 } |
|
489 |
|
490 |
|
491 /* |
|
492 * \brief Return the MBox address |
|
493 * |
|
494 * \param hCmdMbox - Handle to CmdMbox |
|
495 * \return MBox address |
|
496 * |
|
497 * \par Description |
|
498 * |
|
499 * \sa |
|
500 */ |
|
501 TI_UINT32 cmdMbox_GetMboxAddress (TI_HANDLE hCmdMbox) |
|
502 { |
|
503 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
504 |
|
505 return pCmdMbox->uFwAddr; |
|
506 } |
|
507 |
|
508 |
|
509 /* |
|
510 * \brief Return the Command parameters buffer |
|
511 * |
|
512 * \param hCmdMbox - Handle to CmdMbox |
|
513 * \param pParamBuf - Holds the returned buffer |
|
514 * \return |
|
515 * |
|
516 * \par Description |
|
517 * Copying the command's data to pParamBuf |
|
518 * |
|
519 * \sa |
|
520 */ |
|
521 void cmdMbox_GetCmdParams (TI_HANDLE hCmdMbox, TI_UINT8* pParamBuf) |
|
522 { |
|
523 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
524 Command_t *pCmd = ((Command_t *)(pCmdMbox->aCmdTxn[1].pCmdMbox)); |
|
525 |
|
526 /* |
|
527 * Copy the results to the caller buffer: |
|
528 * We need to copy only the data without the cmdMbox header, |
|
529 * otherwise we will overflow the pParambuf |
|
530 */ |
|
531 os_memoryCopy (pCmdMbox->hOs, |
|
532 (void *)pParamBuf, |
|
533 (void *)pCmd->parameters, |
|
534 pCmdMbox->uReadLen - CMDMBOX_HEADER_LEN); |
|
535 |
|
536 } |
|
537 |
|
538 |
|
539 #ifdef TI_DBG |
|
540 |
|
541 void cmdMbox_PrintInfo(TI_HANDLE hCmdMbox) |
|
542 { |
|
543 TCmdMbox *pCmdMbox = (TCmdMbox *)hCmdMbox; |
|
544 |
|
545 WLAN_OS_REPORT(("Print cmdMbox module info\n")); |
|
546 WLAN_OS_REPORT(("=========================\n")); |
|
547 WLAN_OS_REPORT(("bCmdInProgress = %d\n", pCmdMbox->bCmdInProgress)); |
|
548 } |
|
549 |
|
550 #endif /* TI_DBG */ |
|
551 |
|
552 |