1 /****************************************************************************
2 **+-----------------------------------------------------------------------+**
3 **| |**
4 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |**
5 **| All rights reserved. |**
6 **| |**
7 **| Redistribution and use in source and binary forms, with or without |**
8 **| modification, are permitted provided that the following conditions |**
9 **| are met: |**
10 **| |**
11 **| * Redistributions of source code must retain the above copyright |**
12 **| notice, this list of conditions and the following disclaimer. |**
13 **| * Redistributions in binary form must reproduce the above copyright |**
14 **| notice, this list of conditions and the following disclaimer in |**
15 **| the documentation and/or other materials provided with the |**
16 **| distribution. |**
17 **| * Neither the name Texas Instruments nor the names of its |**
18 **| contributors may be used to endorse or promote products derived |**
19 **| from this software without specific prior written permission. |**
20 **| |**
21 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |**
22 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |**
23 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |**
24 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |**
25 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |**
26 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |**
27 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |**
28 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |**
29 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |**
30 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |**
31 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |**
32 **| |**
33 **+-----------------------------------------------------------------------+**
34 ****************************************************************************/
35
36 /**********************************************************************************/
37 /* */
38 /* MODULE: ElpCtrl.c */
39 /* PURPOSE: ELP controller implementation module */
40 /* */
41 /**********************************************************************************/
42 #include "osApi.h"
43 #include "whalBus_Api.h"
44 #include "fsm.h"
45 #include "TNETWIF.h"
46 #include "whalHwAccess.h"
47 #include "ElpCtrl.h"
48 /* #include <linux/timer.h> */
49
50 /* Healthy timer timeout in milliseconds */
51 #define ELPCTRL_TIMER_TIMEOUT 100
52
53
54 typedef enum
55 {
56 ELPS_AWAKE,
57 ELPS_ASLEEP,
58 ELPS_WAKING_UP_WRITE,
59 ELPS_WAKING_UP_READ,
60 ELPS_WAKING_UP_MUX
61
62 } elpCtrl_State_e;
63
64
65 typedef struct _elpCtrl_t
66 {
67 TI_HANDLE hOs;
68 TI_HANDLE hTNETWIF;
69 TI_HANDLE hTNETWArb;
70
71 TNETWIF_callback_t fCb;
72 elpCtrl_Mode_e mode;
73 elpCtrl_State_e state;
74 UINT32 uElpRegister;
75 BOOL bExitWakeUpSeq;
76 BOOL bMuxBackNeeded;
77 BOOL bSynch;
78 TI_STATUS eReturnValue;
79
80 failureEventCB_t fFail; /* upper layer failure event callback.
81 * called when the scan command has been timer expiry */
82 TI_HANDLE hFail; /* object parameter passed to the fFail
83 * when it is called */
84 TI_HANDLE hTimer;
85
86 } elpCtrl_t;
87
88 /****************************************************************************
89 * elpCtrl_TimerTimeout()
90 ****************************************************************************
91 * DESCRIPTION:
92 *
93 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
94 *
95 * OUTPUT:
96 *
97 * RETURNS: OK
98 ****************************************************************************/
elpCtrl_TimerTimeout(TI_HANDLE hElpCtrl)99 void elpCtrl_TimerTimeout (TI_HANDLE hElpCtrl)
100 {
101 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
102
103 /*
104 * Error Reporting and Recovery
105 * This Timeout means that we failed to wake up the FW
106 * so the only way out of it is to restart the device - by recovery
107 */
108 /* WLAN_OS_REPORT (("elpCtrl_TimerTimeout - ELP timeout timer expired! %lu\n", jiffies)); */
109 WLAN_OS_REPORT (("elpCtrl_TimerTimeout - ELP timeout timer expired!\n"));
110
111 if (pElpCtrl->fFail)
112 pElpCtrl->fFail (pElpCtrl->hFail, HW_AWAKE_FAILURE);
113 }
114
115 /****************************************************************************
116 * elpCtrl_Create()
117 ****************************************************************************
118 * DESCRIPTION:
119 *
120 * INPUTS: hOs - the handle to the OS layer
121 * hReport - the handle to the report module
122 *
123 *
124 * OUTPUT: the context of the ElpCtrl module
125 *
126 * RETURNS: the context of the ElpCtrl module (NULL if error)
127 ****************************************************************************/
elpCtrl_Create(TI_HANDLE hOs)128 TI_HANDLE elpCtrl_Create (TI_HANDLE hOs)
129 {
130 elpCtrl_t *pElpCtrl;
131
132 /* Create context */
133 pElpCtrl = os_memoryAlloc (hOs, sizeof(elpCtrl_t));
134 if (pElpCtrl == NULL)
135 {
136 WLAN_OS_REPORT (("%s: Error allocating object\n", __FUNCTION__));
137 return NULL;
138 }
139 os_memoryZero (hOs, pElpCtrl, sizeof(elpCtrl_t));
140
141 pElpCtrl->hOs = hOs;
142
143 /* Create timer */
144 pElpCtrl->hTimer = os_timerCreate (hOs, elpCtrl_TimerTimeout, pElpCtrl);
145 if (pElpCtrl->hTimer == NULL)
146 {
147 WLAN_OS_REPORT (("%s: Error in creating timer\n", __FUNCTION__));
148 elpCtrl_Destroy (pElpCtrl);
149 return NULL;
150 }
151
152 return pElpCtrl;
153 }
154
155
156 /****************************************************************************
157 * elpCtrl_Destroy()
158 ****************************************************************************
159 * DESCRIPTION:
160 *
161 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
162 *
163 *
164 * OUTPUT:
165 *
166 * RETURNS: OK
167 ****************************************************************************/
elpCtrl_Destroy(TI_HANDLE hElpCtrl)168 int elpCtrl_Destroy (TI_HANDLE hElpCtrl)
169 {
170 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
171
172 if (pElpCtrl)
173 {
174 if (NULL != pElpCtrl->hTimer)
175 {
176 os_timerDestroy (pElpCtrl->hOs, pElpCtrl->hTimer);
177 }
178
179 os_memoryFree (pElpCtrl->hOs, pElpCtrl, sizeof(elpCtrl_t));
180 }
181
182 return OK;
183 }
184
185
186 /****************************************************************************
187 * elpCtrl_Configure()
188 ****************************************************************************
189 * DESCRIPTION:
190 *
191 * INPUTS: hElpCtrl - the handle to the ElpCtrl module
192 * hTNETWIF - the handle to the TNETWIF module
193 * fCb - ELP asynchronous operation default callback
194 *
195 * OUTPUT:
196 *
197 * RETURNS: ELPCTRL_COMPLETE - if succeeded (sync.)
198 * ELPCTRL_PENDING - if succeeded (async.)
199 * ELPCTRL_ERROR - if failed
200 ****************************************************************************/
elpCtrl_Configure(TI_HANDLE hElpCtrl,TI_HANDLE hTNETWIF,TNETWIF_callback_t fCb)201 int elpCtrl_Configure (TI_HANDLE hElpCtrl, TI_HANDLE hTNETWIF, TNETWIF_callback_t fCb)
202 {
203 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
204
205 pElpCtrl->state = ELPS_AWAKE;
206 pElpCtrl->mode = ELPCTRL_MODE_KEEP_AWAKE;
207 pElpCtrl->hTNETWIF = hTNETWIF;
208 pElpCtrl->hTNETWArb = ((TNETWIF_t *)hTNETWIF)->hTNETWArb;
209 pElpCtrl->fCb = fCb;
210 pElpCtrl->bMuxBackNeeded = FALSE;
211 return ELPCTRL_COMPLETE;
212 }
213
214 /****************************************************************************
215 * elpCtrl_wakeUpSeqSM()
216 ****************************************************************************
217 * DESCRIPTION: SM for handling Synch & Asynch wake up sequence.
218 * The flow of the SM is by that order:
219 * WRITE (wake up) -> READ (elp) -> if awake - exit. else WRITE (mux)
220 *
221 * OUTPUT:
222 *
223 * RETURNS:
224 ****************************************************************************/
elpCtrl_wakeUpSeqSM(TI_HANDLE hElpCtrl,UINT8 module_id,TI_STATUS status)225 static void elpCtrl_wakeUpSeqSM (TI_HANDLE hElpCtrl, UINT8 module_id, TI_STATUS status)
226 {
227 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
228
229 /* Check if Arbiter announced that interrupt occurred (i.e. no need for wake up sequence) */
230 if (pElpCtrl->bExitWakeUpSeq)
231 {
232 /* Fw is up - we should imitate TXN_COMPLETE to announce that we are done */
233 pElpCtrl->state = ELPS_AWAKE;
234 /* set TXN_COMPLETE to ArbiterSM - Note: It could only happen in Asynch IF */
235 pElpCtrl->fCb (pElpCtrl->hTNETWArb, DEFAULT_MODULE_ID, OK);
236 return;
237 }
238
239 pElpCtrl->eReturnValue = OK;
240
241 /*
242 * This while loop will continue till the exit or when waiting for the CB due to
243 * memory transfer operation pending for DMA to complete
244 */
245 while (TNETWIF_PENDING != pElpCtrl->eReturnValue)
246 {
247 switch(pElpCtrl->state)
248 {
249 case ELPS_ASLEEP:
250
251 pElpCtrl->state = ELPS_WAKING_UP_WRITE;
252 pElpCtrl->eReturnValue = TNETWIF_WriteELPOpt (pElpCtrl->hTNETWIF,
253 ELPCTRL_WAKE_UP,
254 DEFAULT_MODULE_ID,
255 elpCtrl_wakeUpSeqSM,
256 hElpCtrl,
257 TRUE);
258 break;
259
260
261 case ELPS_WAKING_UP_WRITE:
262
263 pElpCtrl->state = ELPS_WAKING_UP_READ;
264 pElpCtrl->eReturnValue = TNETWIF_ReadELPOpt (pElpCtrl->hTNETWIF,
265 (UINT8*)&pElpCtrl->uElpRegister,
266 DEFAULT_MODULE_ID,
267 elpCtrl_wakeUpSeqSM,
268 hElpCtrl,
269 TRUE);
270 break;
271
272 case ELPS_WAKING_UP_READ:
273
274 /* Check whether Muxing is needed */
275 if (pElpCtrl->uElpRegister & ELPCTRL_WLAN_READY)
276 {
277 /* Fw is up, but no WLAN_READY interrupt will occur (since we disabled the mux) */
278 pElpCtrl->state = ELPS_AWAKE;
279 /*
280 * set TXN_COMPLETE to ArbiterSM only if we are not working in synchronize IF
281 * In synch IF we set the TXN_COMPLETE at the end of this function
282 */
283 if ( !pElpCtrl->bSynch)
284 {
285 pElpCtrl->fCb (pElpCtrl->hTNETWArb, DEFAULT_MODULE_ID, OK);
286 }
287 }
288 else /* Fw is asleep - Mux to WLAN_READY and let arbiter wait for interrupt */
289 {
290 pElpCtrl->state = ELPS_WAKING_UP_MUX;
291 pElpCtrl->bMuxBackNeeded = TRUE;
292 #ifdef DM_USE_WORKQUEUE
293 /* printk("TI: %s:\t%lu - start timeout 1000 ms\n", __FUNCTION__, jiffies); */
294 os_timerStart (pElpCtrl->hOs, pElpCtrl->hTimer, ELPCTRL_TIMER_TIMEOUT * 10, FALSE);
295 #else
296 os_timerStart (pElpCtrl->hOs, pElpCtrl->hTimer, ELPCTRL_TIMER_TIMEOUT, FALSE);
297 #endif
298 /*
299 * Mux to WLAN_READY and let the Arbiter wait for Txn complete
300 */
301 pElpCtrl->eReturnValue = TNETWIF_WriteELPOpt (pElpCtrl->hTNETWIF,
302 ELPCTRL_WAKE_UP_WLAN_READY,
303 DEFAULT_MODULE_ID,
304 pElpCtrl->fCb,
305 pElpCtrl->hTNETWArb,
306 TRUE);
307 if(TNETWIF_PENDING == pElpCtrl->eReturnValue)
308 {
309 /* If we are here then we are not using Synch IF */
310 pElpCtrl->bSynch = FALSE;
311 }
312
313 /* The previous states was async and now it sync */
314 if((TNETWIF_COMPLETE == pElpCtrl->eReturnValue) && (pElpCtrl->bSynch == FALSE))
315 {
316 pElpCtrl->fCb (pElpCtrl->hTNETWArb, DEFAULT_MODULE_ID, OK);
317 }
318 }
319
320 return;
321
322 default:
323
324 WLAN_OS_REPORT(("Error: %s state = %d\n", __FUNCTION__, pElpCtrl->state));
325
326 }
327 }
328 /* If we are here then we are not using Synch IF */
329 pElpCtrl->bSynch = FALSE;
330 }
331
332 /****************************************************************************
333 * elpCtrl_Wake()
334 ****************************************************************************
335 * DESCRIPTION:
336 *
337 * INPUTS: hElpCtrl - the handle to the ElpCtrl module
338 * bHwAvail - TRUE if HW is available
339 *
340 * OUTPUT:
341 *
342 * RETURNS: TNETWIF_COMPLETE | TNETWIF_PENDING
343 ****************************************************************************/
elpCtrl_Wake(TI_HANDLE hElpCtrl,BOOL bHwAvail)344 int elpCtrl_Wake (TI_HANDLE hElpCtrl, BOOL bHwAvail)
345 {
346 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
347 int rc = ELPCTRL_AWAKE;
348
349 if (pElpCtrl->state == ELPS_ASLEEP)
350 {
351 if (bHwAvail == FALSE)
352 {
353 /*
354 * Wake up the FW without mux. The mux will be done only if the FW is asleep. This is done due to a race
355 * condition in the Fw, which causes 2 interrupts in the driver - one of them is not needed
356 */
357 pElpCtrl->bExitWakeUpSeq = FALSE;
358 pElpCtrl->bSynch = TRUE;
359
360 elpCtrl_wakeUpSeqSM (hElpCtrl, DEFAULT_MODULE_ID, OK);
361
362 /*
363 * In Synch IF we send won't send TXN_COMPLETE from elpCtrl so we should
364 * indicate the arbiter to roll forward its SM.
365 */
366 rc = ((pElpCtrl->bSynch) ? ELPCTRL_WLAN_RDY_COMPLETE : ELPCTRL_COMPLETE);
367 }
368 else
369 {
370 pElpCtrl->state = ELPS_AWAKE;
371
372 if (TNETWIF_WriteELPOpt (pElpCtrl->hTNETWIF,
373 ELPCTRL_WAKE_UP,
374 DEFAULT_MODULE_ID,
375 pElpCtrl->fCb,
376 pElpCtrl->hTNETWArb,
377 TRUE) == TNETWIF_COMPLETE)
378 {
379 rc = ELPCTRL_WLAN_RDY_COMPLETE;
380 }
381 else
382 {
383 rc = ELPCTRL_WLAN_RDY;
384 }
385 }
386 }
387
388 return rc;
389 }
390
391
392 /****************************************************************************
393 * elpCtrl_Sleep()
394 ****************************************************************************
395 * DESCRIPTION:
396 *
397 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
398 *
399 * OUTPUT:
400 *
401 * RETURNS: TNETWIF_PENDING | TNETWIF_COMPLETE
402 ****************************************************************************/
elpCtrl_Sleep(TI_HANDLE hElpCtrl)403 int elpCtrl_Sleep (TI_HANDLE hElpCtrl)
404 {
405 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
406 int rc = TNETWIF_COMPLETE;
407
408 if (pElpCtrl->state == ELPS_AWAKE && pElpCtrl->mode == ELPCTRL_MODE_NORMAL)
409 {
410 pElpCtrl->state = ELPS_ASLEEP;
411
412 /* IRQ_SRC(0) WLAN_WUP(0) - 'more' flag is FALSE since the HW is going to sleep */
413 rc = TNETWIF_WriteELPOpt (pElpCtrl->hTNETWIF,
414 ELPCTRL_SLEEP,
415 DEFAULT_MODULE_ID,
416 pElpCtrl->fCb,
417 pElpCtrl->hTNETWArb,
418 FALSE);
419 }
420
421 return rc;
422 }
423
424
425 /****************************************************************************
426 * elpCtrl_Unmux()
427 ****************************************************************************
428 * DESCRIPTION:
429 *
430 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
431 *
432 * OUTPUT:
433 *
434 * RETURNS: TNETWIF_PENDING | TNETWIF_COMPLETE
435 ****************************************************************************/
elpCtrl_UnMux(TI_HANDLE hElpCtrl)436 int elpCtrl_UnMux (TI_HANDLE hElpCtrl)
437 {
438 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
439 int rc = (pElpCtrl->bMuxBackNeeded ? OK : NOK);
440
441
442 pElpCtrl->bMuxBackNeeded = FALSE;
443
444 return rc;
445 }
446
447 /****************************************************************************
448 * elpCtrl_ReceivedIRQ()
449 ****************************************************************************
450 * DESCRIPTION:
451 *
452 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
453 *
454 * OUTPUT:
455 *
456 * RETURNS: TNETWIF_PENDING | TNETWIF_COMPLETE
457 ****************************************************************************/
elpCtrl_ReceivedIRQ(TI_HANDLE hElpCtrl)458 void elpCtrl_ReceivedIRQ (TI_HANDLE hElpCtrl)
459 {
460 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
461
462 if (pElpCtrl->state == ELPS_WAKING_UP_MUX)
463 {
464 pElpCtrl->state = ELPS_AWAKE;
465 /* printk("TI: %s:\t%lu - stop timeout\n", __FUNCTION__, jiffies); */
466 os_timerStop (pElpCtrl->hOs, pElpCtrl->hTimer);
467 }
468
469 return;
470 }
471
472 /****************************************************************************
473 * elpCtrl_Mode()
474 ****************************************************************************
475 * DESCRIPTION:
476 *
477 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
478 *
479 *
480 * OUTPUT:
481 *
482 * RETURNS: ELPCTRL_COMPLETE
483 ****************************************************************************/
elpCtrl_Mode(TI_HANDLE hElpCtrl,elpCtrl_Mode_e mode)484 int elpCtrl_Mode (TI_HANDLE hElpCtrl, elpCtrl_Mode_e mode)
485 {
486 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
487
488 pElpCtrl->mode = mode;
489
490 return ELPCTRL_COMPLETE;
491 }
492
493 /****************************************************************************
494 * elpCtrl_isIRQComing()
495 ****************************************************************************
496 * DESCRIPTION: Check if IRQ is about to come from Fw - depending on the ELP state
497 *
498 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
499 *
500 *
501 * OUTPUT:
502 *
503 * RETURNS: TRUE - IRQ will arrive from WLAN_READY. FALSE - Otherwise
504 ****************************************************************************/
elpCtrl_isIRQComing(TI_HANDLE hElpCtrl)505 BOOL elpCtrl_isIRQComing (TI_HANDLE hElpCtrl)
506 {
507 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
508
509 return (pElpCtrl->state == ELPS_WAKING_UP_MUX ? TRUE : FALSE);
510 }
511
512 /****************************************************************************
513 * elpCtrl_exitWakeUpSeq()
514 ****************************************************************************
515 * DESCRIPTION: Mark that exit from wake up sequence is needed and return if
516 * wake up is already over.
517 *
518 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
519 *
520 *
521 * OUTPUT: bExitWakeUpSeq = TRUE
522 *
523 * RETURNS: TRUE - IRQ will arrive from WLAN_READY. FALSE - Otherwise
524 ****************************************************************************/
elpCtrl_exitWakeUpSeq(TI_HANDLE hElpCtrl)525 elpCtrl_e elpCtrl_exitWakeUpSeq (TI_HANDLE hElpCtrl)
526 {
527 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
528
529 if (pElpCtrl->state == ELPS_AWAKE)
530 { /* We are already awake */
531 return ELPCTRL_AWAKE;
532 }
533 else /* Still in wake up sequence */
534 {
535 pElpCtrl->bExitWakeUpSeq = TRUE;
536 return ELPCTRL_ASLEEP;
537 }
538 }
539
540 /****************************************************************************************
541 * elpCtrl_RegisterFailureEventCB *
542 ****************************************************************************************
543 DESCRIPTION: Registers a failure event callback for Hw available
544
545 INPUT: - hElpCtrl - handle to the Elp Ctrl object.
546 - fCb - the failure event callback function.\n
547 - hCb - handle to the object passed to the failure event callback function.
548
549 OUTPUT:
550
551 RETURN: void.
552 ****************************************************************************************/
553
elpCtrl_RegisterFailureEventCB(TI_HANDLE hElpCtrl,void * fCb,TI_HANDLE hCb)554 void elpCtrl_RegisterFailureEventCB (TI_HANDLE hElpCtrl, void *fCb, TI_HANDLE hCb)
555 {
556 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
557
558 pElpCtrl->fFail = (failureEventCB_t)fCb;
559 pElpCtrl->hFail = hCb;
560 }
561
562 /****************************************************************************
563 * elpCtrl_Stop()
564 ****************************************************************************
565 * DESCRIPTION: Stop ElpCtrl module before Recovery.
566 * Move to "open": MODE_KEEP_AWAKE + STATE_ON
567 *
568 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
569 *
570 * OUTPUT:
571 *
572 * RETURNS: OK
573 ****************************************************************************/
elpCtrl_Stop(TI_HANDLE hElpCtrl)574 int elpCtrl_Stop(TI_HANDLE hElpCtrl)
575 {
576 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
577
578 /* set the init state */
579 pElpCtrl->mode = ELPCTRL_MODE_KEEP_AWAKE;
580 pElpCtrl->state = ELPS_AWAKE;
581
582 /* printk("TI: %s:\t%lu - stop timeout\n", __FUNCTION__, jiffies); */
583 os_timerStop (pElpCtrl->hOs, pElpCtrl->hTimer);
584
585 return OK;
586 }
587
588 /****************************************************************************
589 * elpCtrl_Start()
590 ****************************************************************************
591 * DESCRIPTION: Stop ElpCtrl module before Recovery.
592 * Move to "open": MODE_KEEP_AWAKE + STATE_ON
593 *
594 * INPUTS: hElpCtrl - the handle to the ElpCtrl module.
595 *
596 * OUTPUT:
597 *
598 * RETURNS: OK
599 ****************************************************************************/
elpCtrl_Start(TI_HANDLE hElpCtrl)600 int elpCtrl_Start(TI_HANDLE hElpCtrl)
601 {
602 elpCtrl_t *pElpCtrl = (elpCtrl_t*)hElpCtrl;
603
604 /* Set: SCR = 1 and WUP = 1. The pattern is 101 */
605 /* NOTE: no callback needed */
606 /* IRQ_SRC(1) WLAN_WUP(1)*/
607 TNETWIF_WriteELPOpt (pElpCtrl->hTNETWIF,
608 ELPCTRL_WAKE_UP,
609 DEFAULT_MODULE_ID,
610 NULL,
611 NULL,
612 TRUE);
613
614
615 return OK;
616 }
617
618