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 #include "arch_ti.h"
38
39 #include <linux/stddef.h>
40 #include <linux/string.h>
41 #include <linux/time.h>
42 #include <linux/timer.h>
43 #include <linux/module.h>
44 #include <linux/kernel.h>
45 #include <linux/netdevice.h>
46 #include <linux/etherdevice.h>
47 #include <linux/vmalloc.h>
48 #include <linux/string.h>
49 #include <linux/delay.h>
50 #include <linux/time.h>
51 #include <linux/list.h>
52 #include <asm/io.h>
53
54 #include "debug_module.h"
55 #include "esta_drv.h"
56 #ifdef DRIVER_PROFILING
57 #include "tiwlan_profile.h"
58 #endif
59 #include "osApi.h"
60 #include "osTIType.h"
61 #include "srcApi.h"
62 #include "whalHwRegs.h"
63 #include "bmtrace.h"
64 #include "TI_IPC_Api.h"
65 #include "whalBus_Defs.h"
66 #include "802_11Defs.h"
67 #include "Ethernet.h"
68
69 #define OS_PROTECT_HANDLE 0xffffeee0
70 /*#define DEBUG_REG_ACCESS*/
71
72 #ifdef DEBUG_REG_ACCESS
73 #define PRINT_REG(fmt, args...) print_info(fmt, args)
74 #else
75 #define PRINT_REG(fmt, args...)
76 #endif
77 #define NOPRINT_REG(fmt, args...)
78
79 #ifdef ESTA_TIMER_DEBUG
80 #define esta_timer_log(fmt,args...) printk(fmt, ## args)
81 #else
82 #define esta_timer_log(fmt,args...)
83 #endif
84
85 #define FRAG_SIZE 200
86
87 /* Wlan chip reset defines */
88 #define GPIO_16 16
89 #define GPIO_16_DIRECTION_OUTPUT 0
90 #define GPIO_16_CLEAR 0
91 #define GPIO_16_SET 1
92
93 #define GPIO1_IRQSTATUS1 0xFFFBE418
94 #define GPIO1_DATAIN 0xFFFBE42C
95
96 /********************* LOCAL DECLARATIONS ************************/
97 static inline void os_timer_dec_use_count(timer_obj_t *tmr);
98 static int os_tl_timerHandlr(struct tiwlan_req *req);
99 static void os_timerHandlr(unsigned long parm);
100 static void send_frag(char* msg, int message_len, int level, int module);
101
102 BOOL use_debug_module = FALSE;
103
104 /****************************************************************************************
105 * *
106 * OS Report API *
107 * *
108 ****************************************************************************************/
109
110 /****************************************************************************************
111 * os_setDebugMode()
112 ****************************************************************************************
113 DESCRIPTION: Set the Debug Mode
114
115 INPUT:
116
117 RETURN: None
118
119 NOTES:
120 *****************************************************************************************/
os_setDebugMode(BOOL enable)121 void os_setDebugMode(BOOL enable)
122 {
123 use_debug_module = enable;
124 }
125
126
127 /****************************************************************************************
128 * os_printf()
129 ****************************************************************************************
130 DESCRIPTION: Print formatted output.
131
132 INPUT: format - Specifies the string, to be printed
133
134 RETURN: None
135
136 NOTES:
137 *****************************************************************************************/
os_printf(const char * format,...)138 void os_printf(const char *format ,...)
139 {
140 static int from_new_line = 1; /* Used to save the last message EOL */
141 static UINT8 module = 0; /* Used to save the last message module */
142 static UINT8 level = 0; /* Used to save the last message level */
143 va_list ap;
144 static char msg[500];
145 char *p_msg = msg; /* Pointer to the message */
146 UINT16 message_len;
147 UINT32 sec = 0;
148 UINT32 uSec = 0;
149
150 /* Format the message and keep the message length */
151 va_start(ap,format);
152 message_len = vsnprintf(&msg[1], sizeof(msg) - 1, format, ap);
153
154
155 if (use_debug_module)
156 {
157 /*********************/
158 /* Use debug module */
159 /*******************/
160
161 if (msg[1] == '$')
162 {
163 /************************************
164 Message format: "$XX"
165 |||
166 message prefix ----|||
167 module index -------||
168 severity index ------|
169 ************************************/
170
171 level = (msg[2] - 'A');
172 module = (msg[3] - 'A');
173 }
174 else
175 {
176 send_frag(msg, message_len, level, module);
177 }
178 }
179 else
180 {
181 /***********************/
182 /* Use regular printk */
183 /*********************/
184
185 if( from_new_line )
186 {
187 if (msg[1] == '$')
188 {
189 p_msg += 4;
190 }
191
192 sec = os_timeStampUs(NULL);
193 uSec = sec % 1000000;
194 sec /= 1000000;
195
196 printk(KERN_INFO DRIVER_NAME ": %d.%06d: %s",sec,uSec,p_msg);
197 }
198 else
199 {
200 printk(&msg[1]);
201 }
202
203 from_new_line = ( msg[message_len] == '\n' );
204 }
205 }
206
send_frag(char * msg,int message_len,int level,int module)207 static void send_frag(char* msg, int message_len, int level, int module)
208 {
209 #ifdef TIWLAN_OMAP1610 /* Dm: */
210 int return_value;
211 int offset = 1;
212 int TmpLen;
213 char* FragMsg;
214
215 do
216 {
217 TmpLen = min(message_len - offset, FRAG_SIZE);
218 FragMsg = msg + offset - 1;
219 FragMsg[0] = module;
220
221 return_value = debug_module_enqueue_message(DEBUG_MODULE_TRACE_QUEUE_ID, level, FragMsg, TmpLen+1, CONTROL_CODE_TYPE_MESSAGE);
222
223 if (return_value)
224 {
225 /* Message overrun */
226
227 /* Send the overrun indication to the debug module */
228 os_memoryCopy(NULL, &msg[1], "*** Message Overrun ***", strlen("*** Message Overrun ***"));
229 msg[0] = 0;
230 debug_module_enqueue_message(DEBUG_MODULE_TRACE_QUEUE_ID, 0, msg, (strlen("*** Message Overrun ***") + 1), CONTROL_CODE_TYPE_MESSAGE);
231
232 /* Print overrun indication to the terminal */
233 /*printk(KERN_INFO DRIVER_NAME ": %d.%06d: %s\n", sec, uSec, "**** Debug module message overrun! ****\n");*/
234 }
235 offset += TmpLen;
236 }while (offset < message_len);
237
238 #endif
239 }
240
241 /****************************************************************************************
242 * *
243 * OS DMA CALLBACK API *
244 ****************************************************************************************/
245
246 /****************************************************************************************
247 * os_TNETWIF_BusTxn_Complete()
248 ****************************************************************************************
249 DESCRIPTION: Callback directly called at an IRQ context from the SPI modue
250 This should triger a tasklet_schedule so that the End of DMA will be handled
251 in a tasklet context and then be directed to the TNETWIF to call the Client callback.
252
253 INPUT: OsContext - our adapter context.
254
255 RETURN: None
256
257 NOTES:
258 *****************************************************************************************/
os_TNETWIF_BusTxn_Complete(TI_HANDLE OsContext,int status)259 void os_TNETWIF_BusTxn_Complete(TI_HANDLE OsContext,int status)
260 {
261 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
262
263 drv->dma_done = 1;
264 #ifdef DM_USE_WORKQUEUE
265 /* printk("TI: %s:\t%lu\n", __FUNCTION__, jiffies); */
266 #ifdef CONFIG_ANDROID_POWER
267 android_lock_suspend( &drv->timer_wake_lock );
268 #endif
269 queue_work( drv->tiwlan_wq, &drv->tw );
270 #else
271 tasklet_schedule(&drv->tl);
272 #endif
273 }
274
275 /****************************************************************************************
276 * *
277 * OS TIMER API *
278 * *
279 ****************************************************************************************/
280
281 /****************************************************************************************
282 * os_timerCreate()
283 ****************************************************************************************
284 DESCRIPTION: This function creates and initializes a timer object associated with a
285 caller's pRoutine function.
286
287 ARGUMENTS:
288
289 RETURN: A handle of the created timer.
290 TI_HANDLE_INVALID if there is insufficient memory available
291
292 NOTES: Using the Kernel timer feature, problem is that kernel timers are one-shots.
293 For timers that are periodic this abstraction layer will have to mediate
294 between the callback function and the re-submission of a timer request.
295
296 *****************************************************************************************/
297 TI_HANDLE
os_timerCreate(TI_HANDLE OsContext,PTIMER_FUNCTION pRoutine,TI_HANDLE Context)298 os_timerCreate(
299 TI_HANDLE OsContext,
300 PTIMER_FUNCTION pRoutine,
301 TI_HANDLE Context
302 )
303 {
304 timer_obj_t *tmr;
305
306 #ifdef ESTA_TIMER_DEBUG
307 esta_timer_log("\n\n%s:%d ::os_timerCreate(%p,%p,%p)",__FUNCTION__, __LINE__,OsContext,pRoutine,Context);
308 #endif
309 ti_nodprintf(TIWLAN_LOG_INFO, "\n----> os_timerCreate function = 0x%08x , context= 0x%08x",
310 (int)pRoutine, (int)Context);
311
312 os_profile (OsContext, 6, 0);
313
314 tmr = os_memoryAlloc (OsContext, sizeof(timer_obj_t));
315 if (tmr == NULL)
316 return(TI_HANDLE_INVALID);
317
318 memset (tmr,0,sizeof(timer_obj_t));
319
320 init_timer(&tmr->timer);
321 INIT_LIST_HEAD(&tmr->req.list);
322 tmr->timer.function = os_timerHandlr;
323 tmr->timer.data = (int)tmr;
324 tmr->req.drv = (tiwlan_net_dev_t *)OsContext;
325 tmr->req.u.req.p1 = (UINT32)pRoutine;
326 tmr->req.u.req.p2 = (UINT32)Context;
327 tmr->req.u.req.f = os_tl_timerHandlr;
328 tmr->use_count = 1;
329
330 esta_timer_log("=%p\n\n", tmr);
331
332 return (TI_HANDLE)tmr;
333 }
334
335
336 /****************************************************************************************
337 * os_timerDestroy()
338 ****************************************************************************************
339 DESCRIPTION: This function destroy the timer object.
340
341 ARGUMENTS:
342
343 RETURN:
344
345 NOTES: Returning the Kernel level timer_list memory allocation and the
346 abstraction level timer object.
347 *****************************************************************************************/
348 VOID
os_timerDestroy(TI_HANDLE OsContext,TI_HANDLE TimerHandle)349 os_timerDestroy(
350 TI_HANDLE OsContext,
351 TI_HANDLE TimerHandle
352 )
353 {
354 timer_obj_t *tmr = TimerHandle;
355
356 os_profile (OsContext, 6, 0);
357
358 os_timerStop (OsContext, TimerHandle);
359 os_timer_dec_use_count (tmr);
360 }
361
362
363 /****************************************************************************************
364 * os_timerStart()
365 ****************************************************************************************
366 DESCRIPTION: This function start the timer object.
367
368 ARGUMENTS:
369
370 RETURN:
371
372 NOTES:
373 *****************************************************************************************/
374 VOID
os_timerStart(TI_HANDLE OsContext,TI_HANDLE TimerHandle,UINT32 DelayMs,BOOL bPeriodic)375 os_timerStart(
376 TI_HANDLE OsContext,
377 TI_HANDLE TimerHandle,
378 UINT32 DelayMs,
379 BOOL bPeriodic
380 )
381 {
382 timer_obj_t *tmr= (timer_obj_t *)TimerHandle;
383
384 UINT32 jiffie_cnt = msecs_to_jiffies(DelayMs);
385
386 #ifdef ESTA_TIMER_DEBUG
387 esta_timer_log("\n\n%s:%d ::os_timerStart(%p,%p,%u,%d)\n\n",__FUNCTION__, __LINE__,OsContext,TimerHandle,DelayMs,bPeriodic);
388 #endif
389
390 tmr->req.u.req.p3 = bPeriodic;
391 tmr->req.u.req.p4 = jiffie_cnt;
392 tmr->timer.data = (unsigned long)tmr;
393 mod_timer(&tmr->timer, jiffies + jiffie_cnt);
394
395
396 return;
397 }
398
399 /****************************************************************************************
400 * os_stopTimer()
401 ****************************************************************************************
402 DESCRIPTION: This function stop the timer object.
403
404 ARGUMENTS:
405
406 RETURN:
407
408 NOTES:
409 *****************************************************************************************/
410 VOID
os_timerStop(TI_HANDLE OsContext,TI_HANDLE TimerHandle)411 os_timerStop(
412 TI_HANDLE OsContext,
413 TI_HANDLE TimerHandle
414 )
415 {
416 timer_obj_t *tmr= (timer_obj_t *)TimerHandle;
417
418 del_timer_sync(&tmr->timer);
419 tmr->req.u.req.p3 = 0; /* Turn "periodic" off */
420 list_del_init(&tmr->req.list);
421
422 return;
423 }
424
425 /****************************************************************************************
426 * os_periodicIntrTimerStart()
427 ****************************************************************************************
428 DESCRIPTION: This function starts the periodic interrupt mechanism. This mode is used
429 when interrupts that usually received from the Fw is now masked, and we are
430 checking for any need of Fw handling in time periods.
431
432 ARGUMENTS:
433
434 RETURN:
435
436 NOTES: Power level of the CHIP should be always awake in this mode (no ELP)
437 *****************************************************************************************/
438 VOID
os_periodicIntrTimerStart(TI_HANDLE OsContext)439 os_periodicIntrTimerStart(
440 TI_HANDLE OsContext
441 )
442 {
443 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
444
445 mod_timer (&drv->poll_timer, jiffies + TIWLAN_IRQ_POLL_INTERVAL);
446 }
447
448 /****************************************************************************************
449 * os_timeStampMs()
450 ****************************************************************************************
451 DESCRIPTION: This function returns the number of milliseconds that have elapsed since
452 the system was booted.
453
454 ARGUMENTS: OsContext - our adapter context.
455
456 RETURN:
457
458 NOTES:
459 *****************************************************************************************/
460 UINT32
os_timeStampMs(TI_HANDLE OsContext)461 os_timeStampMs(
462 TI_HANDLE OsContext
463 )
464 {
465 struct timeval tv;
466 do_gettimeofday(&tv);
467 return tv.tv_sec*1000 + tv.tv_usec/1000;
468 }
469
470 /****************************************************************************************
471 * os_timeStampUs()
472 ****************************************************************************************
473 DESCRIPTION: This function returns the number of microseconds that have elapsed since
474 the system was booted.
475
476 ARGUMENTS: OsContext - our adapter context.
477 Note that sometimes this function will be called with NULL(!!!) as argument!
478
479 RETURN:
480
481 NOTES:
482 *****************************************************************************************/
483 UINT32
os_timeStampUs(TI_HANDLE OsContext)484 os_timeStampUs(
485 TI_HANDLE OsContext
486 )
487 {
488 struct timeval tv;
489 do_gettimeofday(&tv);
490 return tv.tv_sec*1000000 + tv.tv_usec;
491 }
492
493 /****************************************************************************************
494 * os_StalluSec()
495 ****************************************************************************************
496 DESCRIPTION: This function make delay in microseconds.
497
498 ARGUMENTS: OsContext - our adapter context.
499 uSec - delay time in microseconds
500
501 RETURN:
502
503 NOTES:
504 *****************************************************************************************/
505 VOID
os_StalluSec(TI_HANDLE OsContext,UINT32 uSec)506 os_StalluSec(
507 TI_HANDLE OsContext,
508 UINT32 uSec
509 )
510 {
511 /*UINT32 usec_now = os_timeStampUs(OsContext);
512 while(os_timeStampUs(OsContext) - usec_now < uSec)
513 ;
514 */
515 udelay(uSec);
516 }
517
518 /****************************************************************************************
519 * os_WaitComplete()
520 ****************************************************************************************
521 DESCRIPTION: This function start waiting for the complete
522
523 ARGUMENTS:
524
525 RETURN:
526
527 NOTES: can be called only from process context, and not from tasklet
528 *****************************************************************************************/
529 VOID
os_WaitComplete(TI_HANDLE OsContext)530 os_WaitComplete(
531 TI_HANDLE OsContext
532 )
533 {
534 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
535
536 /* ti_dprintf(TIWLAN_LOG_INFO, "os_WaitComplete drv %x drv->comp %x\n",(UINT32)drv,(UINT32)&drv->comp); */
537
538 /*
539 he tasklet should them send back the user (here)the completion event so the user could
540 go through the configuration phase
541 */
542 wait_for_completion(&drv->comp);
543 }
544
545 /****************************************************************************************
546 * os_Complete()
547 ****************************************************************************************
548 DESCRIPTION: This function signals to the waiting process that completion occured
549
550 ARGUMENTS:
551
552 RETURN:
553
554 NOTES:
555 *****************************************************************************************/
556 VOID
os_Complete(TI_HANDLE OsContext)557 os_Complete(
558 TI_HANDLE OsContext
559 )
560 {
561 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
562
563 /* ti_dprintf(TIWLAN_LOG_INFO, "os_Complete drv %x drv->comp %x\n",(UINT32)drv, (UINT32)&drv->comp); */
564
565 /*
566 Call the completion routine that will unblock the caller that was waiting on that object
567 */
568 complete(&drv->comp);
569 }
570
571
572
573 /****************************************************************************************
574 * *
575 * Hardware access functions API *
576 * *
577 ****************************************************************************************/
578
579 /****************************************************************************************
580 * os_clearWlanReady()
581 ****************************************************************************************
582 DESCRIPTION: Clear the WLAN Ready Interrupt Line stored in the PIC Controller
583
584 INPUT: None
585
586 RETURN: None
587
588 NOTES:
589 *****************************************************************************************/
590
591 __inline__ VOID
os_clearWlanReady(void)592 os_clearWlanReady(
593 void)
594 {
595 #ifdef TIWLAN_OMAP1610
596 omap_writel(4,GPIO1_IRQSTATUS1);
597 #endif
598 }
599
600
601 /****************************************************************************************
602 * os_senseIrqLine()
603 ****************************************************************************************
604 DESCRIPTION: Read the WLAN_IRQ line
605
606 INPUT: void
607
608 RETURN: Read value
609
610 NOTES:
611 *****************************************************************************************/
612
613 __inline__ UINT32
os_senseIrqLine(TI_HANDLE OsContext)614 os_senseIrqLine(
615 TI_HANDLE OsContext
616 )
617 {
618 #ifdef TIWLAN_OMAP1610
619 return (omap_readl(GPIO1_DATAIN) & 0x4);
620 #else
621 return 0;
622 #endif
623 }
624
625
626
627 /****************************************************************************************
628 * os_hwGetRegistersAddr()
629 ****************************************************************************************
630 DESCRIPTION:
631
632 ARGUMENTS:
633
634 RETURN:
635
636 NOTES:
637 *****************************************************************************************/
638 PVOID
os_hwGetRegistersAddr(TI_HANDLE OsContext)639 os_hwGetRegistersAddr(
640 TI_HANDLE OsContext
641 )
642 {
643 return (PVOID)OS_API_REG_ADRR;
644 }
645
646 /****************************************************************************************
647 * os_hwGetMemoryAddr()
648 ****************************************************************************************
649 DESCRIPTION:
650
651 ARGUMENTS:
652
653 RETURN:
654
655 NOTES:
656 *****************************************************************************************/
657 PVOID
os_hwGetMemoryAddr(TI_HANDLE OsContext)658 os_hwGetMemoryAddr(
659 TI_HANDLE OsContext
660 )
661 {
662 return (PVOID)OS_API_MEM_ADRR;
663 }
664
665 /****************************************************************************************
666 * os_memoryGetPhysicalLow()
667 ****************************************************************************************
668 DESCRIPTION: return the lower 32 bits of a 64bit number / address *
669
670 ARGUMENTS:
671
672 RETURN:
673
674 NOTES:
675 *****************************************************************************************/
os_memoryGetPhysicalLow(OS_PHYSICAL_ADDRESS pAddr)676 UINT32 os_memoryGetPhysicalLow (OS_PHYSICAL_ADDRESS pAddr)
677 {
678 UINT32 res;
679 res = pAddr & 0xffffffff;
680 ti_dprintf(TIWLAN_LOG_ERROR, "\n 64bit low. Got 0x%x; Returning 0x%x \n", (UINT32)pAddr, res);
681 return res;
682 }
683
684 /****************************************************************************************
685 * os_memoryGetPhysicalHigh()
686 ****************************************************************************************
687 DESCRIPTION: return the higher order 32 bits of a 64bit number / address *
688
689 ARGUMENTS:
690
691 RETURN:
692
693 NOTES:
694 *****************************************************************************************/
os_memoryGetPhysicalHigh(OS_PHYSICAL_ADDRESS pAddr)695 UINT32 os_memoryGetPhysicalHigh (OS_PHYSICAL_ADDRESS pAddr)
696 {
697 UINT32 res;
698 res = pAddr >> 32;
699 ti_dprintf(TIWLAN_LOG_ERROR, "\n 64bit high. Got 0x%x; Returning 0x%x \n", (UINT32)pAddr, res);
700 return res;
701 }
702
703
704 /****************************************************************************************
705 * *
706 * Protection services API *
707 * *
708 ****************************************************************************************
709 * OS protection is implemented as dummy functions because *
710 * all driver code is executed in context of a single tasklet, *
711 * except IOCTL handlers and xmition. *
712 * Protection in IOCTL handlers and hard_start_xmit is done by different *
713 * means. *
714 ****************************************************************************************/
715
716
717 /****************************************************************************************
718 * os_protectCreate()
719 ****************************************************************************************
720 DESCRIPTION:
721
722 ARGUMENTS: OsContext - our adapter context.
723
724 RETURN: A handle of the created mutex/spinlock.
725 TI_HANDLE_INVALID if there is insufficient memory available or problems
726 initializing the mutex
727
728 NOTES:
729 *****************************************************************************************/
730 TI_HANDLE
os_protectCreate(TI_HANDLE OsContext)731 os_protectCreate(
732 TI_HANDLE OsContext
733 )
734 {
735 return (TI_HANDLE)OS_PROTECT_HANDLE;
736 }
737
738
739
740 /****************************************************************************************
741 * os_protectDestroy()
742 ****************************************************************************************
743 DESCRIPTION:
744
745 ARGUMENTS: OsContext - our adapter context.
746
747 RETURN: None - This had better work since there is not a return value to the user
748
749 NOTES:
750 *****************************************************************************************/
751 VOID
os_protectDestroy(TI_HANDLE OsContext,TI_HANDLE ProtectCtx)752 os_protectDestroy(
753 TI_HANDLE OsContext,
754 TI_HANDLE ProtectCtx
755 )
756 {
757 return;
758 }
759
760
761 /****************************************************************************************
762 * os_protectLock()
763 ****************************************************************************************
764 DESCRIPTION:
765
766 ARGUMENTS: OsContext - our adapter context.
767
768 RETURN: None - This had better work since there is not a return value to the user
769
770 NOTES:
771 *****************************************************************************************/
772 VOID
os_protectLock(TI_HANDLE OsContext,TI_HANDLE ProtectContext)773 os_protectLock(
774 TI_HANDLE OsContext,
775 TI_HANDLE ProtectContext
776 )
777 {
778 #if 1 /* uncomment for work in INDIRECT mode (HwACXAccessMethod=0) */
779 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
780 spin_lock_irqsave(&drv->lock, drv->flags);
781 #endif
782 }
783
784
785 /****************************************************************************************
786 * os_protectUnlock()
787 ****************************************************************************************
788 DESCRIPTION:
789
790 ARGUMENTS: OsContext - our adapter context.
791
792 RETURN: None - This had better work since there is not a return value to the user
793
794 NOTES:
795 *****************************************************************************************/
796 VOID
os_protectUnlock(TI_HANDLE OsContext,TI_HANDLE ProtectContext)797 os_protectUnlock(
798 TI_HANDLE OsContext,
799 TI_HANDLE ProtectContext
800 )
801 {
802 #if 1 /* uncomment for work in INDIRECT mode (HwACXAccessMethod=0) */
803 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
804 spin_unlock_irqrestore(&drv->lock, drv->flags);
805 #endif
806 }
807
808
809 /*-----------------------------------------------------------------------------
810
811 Routine Name:
812
813 os_resetWakeOnGpio
814
815 Routine Description:
816
817 set the GPIO to low after awaking the TNET from ELP.
818
819 Arguments:
820
821 OsContext - our adapter context.
822
823
824 Return Value:
825
826 None
827
828 -----------------------------------------------------------------------------*/
829 VOID
os_hardResetTnetw(void)830 os_hardResetTnetw( void )
831 {
832 /*
833 * Define the OMAP GPIO registers, the TNETW reset is currently connected
834 * to GPIO 16, this logic assumes that the loading code had muxed the
835 * GPIO 16 to the Y1 pinout.
836 */
837 /* direction out */
838 #ifdef TIWLAN_OMAP1610
839 omap_set_gpio_direction(GPIO_16, GPIO_16_DIRECTION_OUTPUT);
840
841 /* clear reset WLAN chip */
842 omap_set_gpio_dataout(GPIO_16, GPIO_16_CLEAR);
843
844 /* wait for 50msec */
845 mdelay(50);
846 omap_set_gpio_dataout(GPIO_16, GPIO_16_SET);
847
848 /* wait for 50msec */
849 mdelay(50);
850 #endif /* Dm: */
851 #ifdef TIWLAN_MSM7000
852 msm_wifi_reset(1); /* Reset active */
853 msm_wifi_power(0); /* Power disable */
854 msm_wifi_power(1); /* Power enable */
855 msm_wifi_reset(0); /* Reset clear */
856 #endif
857 }
858
859
860 #ifndef GWSI_DRIVER
861
862 /****************************************************************************************
863 START OF TI DRIVER API
864 *****************************************************************************************/
865
866 /****************************************************************************************
867 * os_setWakeOnGpio()
868 ****************************************************************************************
869 DESCRIPTION: set the GPIO to high for awaking the TNET from ELP.
870
871 ARGUMENTS: OsContext - our adapter context.
872
873 RETURN: None
874
875 NOTES:
876 *****************************************************************************************/
877 VOID
os_setWakeOnGpio(TI_HANDLE OsContext)878 os_setWakeOnGpio(
879 TI_HANDLE OsContext
880 )
881 {
882 #ifdef TIWLAN_OMAP1610
883 /*
884 Clear ELP_REQ by GPIO_CLEAR_DATAOUT
885 */
886 os_resetWakeOnGpio(OsContext);
887
888 /*
889 Rising edge on ELP_REQ by GPIO_SET_DATAOUT
890 */
891 omap_writel(0x00000200, 0xFFFBBCF0);
892 #endif
893 }
894
895 /****************************************************************************************
896 * os_resetWakeOnGpio()
897 ****************************************************************************************
898 DESCRIPTION: set the GPIO to low after awaking the TNET from ELP.
899
900 ARGUMENTS: OsContext - our adapter context.
901
902 RETURN: None
903
904 NOTES:
905 *****************************************************************************************/
906 VOID
os_resetWakeOnGpio(TI_HANDLE OsContext)907 os_resetWakeOnGpio(
908 TI_HANDLE OsContext
909 )
910 {
911 /*
912 Clear ELP_REQ by GPIO_CLEAR_DATAOUT
913 */
914 #ifdef TIWLAN_OMAP1610
915 omap_writel(0x00000200, 0xFFFBBCB0);
916 #endif
917 }
918
919 /****************************************************************************************
920 * _os_memorySharedFree()
921 ****************************************************************************************
922 DESCRIPTION:
923
924 ARGUMENTS:
925
926 RETURN:
927
928 NOTES:
929 *****************************************************************************************/
930 VOID
_os_memorySharedFree(TI_HANDLE OsContext,PVOID pVirtual,UINT32 Size,OS_PHYSICAL_ADDRESS pPhysical)931 _os_memorySharedFree(
932 TI_HANDLE OsContext,
933 PVOID pVirtual,
934 UINT32 Size,
935 OS_PHYSICAL_ADDRESS pPhysical
936 )
937 {
938 ti_dprintf(TIWLAN_LOG_ERROR, "\n\n\n %s is not implemented\n\n\n", __FUNCTION__);
939 }
940
941 /****************************************************************************************
942 * _os_memorySharedAlloc()
943 ****************************************************************************************
944 DESCRIPTION:
945
946 ARGUMENTS:
947
948 RETURN:
949
950 NOTES:
951 *****************************************************************************************/
952 PVOID
_os_memorySharedAlloc(TI_HANDLE OsContext,UINT32 Size,OS_PHYSICAL_ADDRESS * pPhysical)953 _os_memorySharedAlloc(
954 TI_HANDLE OsContext,
955 UINT32 Size,
956 OS_PHYSICAL_ADDRESS *pPhysical
957 )
958 {
959 ti_dprintf(TIWLAN_LOG_ERROR, "\n\n\n %s is not implemented\n\n\n", __FUNCTION__);
960 return NULL;
961 }
962
963 /****************************************************************************************
964 * os_powerStateBusy()
965 ****************************************************************************************
966 DESCRIPTION: notify to the host that the TI_WLAN application is busy.
967
968 ARGUMENTS: OsContext - our adapter context.
969
970 RETURN:
971
972 NOTES:
973 *****************************************************************************************/
974 VOID
os_powerStateBusy(TI_HANDLE OsContext)975 os_powerStateBusy(
976 TI_HANDLE OsContext
977 )
978 {
979 #if 0
980 ti_dprintf(TIWLAN_LOG_INFO,
981 "%s(%d) - os_powerStateBusy: TI_WLAN is busy!\n",
982 __FILE__,__LINE__);
983 #endif
984 }
985
986 /****************************************************************************************
987 * os_powerStateIdle()
988 ****************************************************************************************
989 DESCRIPTION: notify to the host that the TI_WLAN application is idle.
990
991 ARGUMENTS: OsContext - our adapter context.
992
993 RETURN:
994
995 NOTES:
996 *****************************************************************************************/
997 VOID
os_powerStateIdle(TI_HANDLE OsContext)998 os_powerStateIdle(
999 TI_HANDLE OsContext
1000 )
1001 {
1002 #if 0
1003 ti_dprintf(TIWLAN_LOG_INFO,
1004 "%s(%d) - os_powerStateIdle: TI_WLAN is idle!\n",
1005 __FILE__,__LINE__);
1006 #endif
1007 }
1008
1009 /****************************************************************************************
1010 * os_memoryMove()
1011 ****************************************************************************************
1012 DESCRIPTION: Move memory block from pSource to pDestination
1013
1014 ARGUMENTS: OsContext - Our adapter context.
1015 pDestination - destination
1016 pSource - source
1017 Size - Number of characters
1018 RETURN:
1019
1020 NOTES:
1021 *****************************************************************************************/
1022 VOID
os_memoryMove(TI_HANDLE pOsContext,PVOID pDestination,PVOID pSource,UINT32 Size)1023 os_memoryMove(
1024 TI_HANDLE pOsContext,
1025 PVOID pDestination,
1026 PVOID pSource,
1027 UINT32 Size
1028 )
1029 {
1030 memmove(pDestination, pSource, Size);
1031 }
1032
1033
1034 /****************************************************************************************
1035 * os_memoryMoveToHw()
1036 ****************************************************************************************
1037 DESCRIPTION: This function copies data from a system-space buffer to device memory.
1038
1039 ARGUMENTS: OsContext - Our adapter context.
1040
1041 pTarget - Specifies the base address within a device memory range where
1042 the copy should begin.
1043
1044 pSource - Pointer to a system-space buffer from which this function copies
1045 data to the destination range.
1046
1047 Size - Specifies the number of bytes to copy.
1048
1049 RETURN: None
1050
1051 NOTES:
1052 *****************************************************************************************/
1053 VOID
os_memoryMoveToHw(TI_HANDLE OsContext,PVOID pTarget,PVOID pSource,UINT32 Size)1054 os_memoryMoveToHw(
1055 TI_HANDLE OsContext,
1056 PVOID pTarget,
1057 PVOID pSource,
1058 UINT32 Size
1059 )
1060 {
1061 print_info("\nos_memoryMoveToHw pTarget 0x%08x pSource 0x%08x Size 0x%08x",(int)pTarget, (int)pSource,(int)Size);
1062 print_info("\n-------------------------> Not Implemented <--------------------------------------------------- ");
1063 }
1064
1065 /****************************************************************************************
1066 * os_memoryMoveFromHw()
1067 ****************************************************************************************
1068 DESCRIPTION: This function copies data from a system-space buffer to device memory.
1069
1070 ARGUMENTS: OsContext - Our adapter context.
1071
1072 pTarget - Pointer to a system-space buffer into which this function copies
1073 data from device memory.
1074
1075 pSource - Specifies the base virtual address within device memory from
1076 which to copy the data.
1077
1078 Size - Specifies the number of bytes to copy.
1079
1080 RETURN: None
1081
1082 NOTES:
1083 *****************************************************************************************/
1084 VOID
os_memoryMoveFromHw(TI_HANDLE OsContext,PVOID pTarget,PVOID pSource,UINT32 Size)1085 os_memoryMoveFromHw(
1086 TI_HANDLE OsContext,
1087 PVOID pTarget,
1088 PVOID pSource,
1089 UINT32 Size
1090 )
1091 {
1092 print_info("\nos_memoryMoveFromHw pTarget 0x%08x pSource 0x%08x Size 0x%08x",(int)pTarget, (int)pSource,(int)Size);
1093 print_info("\n-------------------------> Not Implemented <--------------------------------------------------- ");
1094 }
1095
1096 /****************************************************************************************
1097 * os_hwReadMemRegisterUINT8()
1098 ****************************************************************************************
1099 DESCRIPTION: Reads a UINT8 from a memory-mapped device register.
1100
1101 ARGUMENTS: OsContext - our adapter context.
1102
1103 Register - Pointer to the memory-mapped register.
1104
1105 Data - Pointer to the caller-supplied variable in which this function
1106 returns the UINT8 read from Register.
1107
1108 RETURN: None
1109
1110 NOTES:
1111 *****************************************************************************************/
1112 VOID
os_hwReadMemRegisterUINT8(TI_HANDLE OsContext,PUCHAR Register,PUINT8 Data)1113 os_hwReadMemRegisterUINT8(
1114 TI_HANDLE OsContext,
1115 PUCHAR Register,
1116 PUINT8 Data
1117 )
1118 {
1119 *Data = *Register;
1120 PRINT_REG("R8: %p=0x%x\n", Register, *Data);
1121 return;
1122 }
1123
1124 /****************************************************************************************
1125 * os_hwWriteMemRegisterUINT16()
1126 ****************************************************************************************
1127 DESCRIPTION: Writes a 'unsigned short' to a memory-mapped device register.
1128
1129 ARGUMENTS: OsContext - our adapter context.
1130
1131 Register - Pointer to the memory-mapped register.
1132
1133 Data - Specifies the caller-supplied UINT16 that this function transfers
1134 to the Register.
1135
1136 RETURN: None
1137
1138 NOTES:
1139 *****************************************************************************************/
1140 VOID
os_hwWriteMemRegisterUINT16(TI_HANDLE OsContext,PUINT16 Register,UINT16 Data)1141 os_hwWriteMemRegisterUINT16(
1142 TI_HANDLE OsContext,
1143 PUINT16 Register,
1144 UINT16 Data
1145 )
1146 {
1147 PRINT_REG("W16: %p=0x%x\n", Register, Data);
1148 *Register = Data;
1149 return;
1150 }
1151
1152 /****************************************************************************************
1153 * os_hwReadMemRegisterUINT16()
1154 ****************************************************************************************
1155 DESCRIPTION: Reads a UINT16 from a memory-mapped device register.
1156
1157 ARGUMENTS: OsContext - our adapter context.
1158
1159 Register - Pointer to the memory-mapped register.
1160
1161 Data - Pointer to the caller-supplied variable in which this function
1162 returns the UINT16 read from Register.
1163
1164 RETURN: None
1165
1166 NOTES:
1167 *****************************************************************************************/
1168 VOID
os_hwReadMemRegisterUINT16(TI_HANDLE OsContext,PUINT16 Register,PUINT16 Data)1169 os_hwReadMemRegisterUINT16(
1170 TI_HANDLE OsContext,
1171 PUINT16 Register,
1172 PUINT16 Data
1173 )
1174 {
1175 *Data = *Register;
1176 PRINT_REG("R16: %p=0x%x\n", Register, *Data);
1177 return;
1178 }
1179
1180 /****************************************************************************************
1181 * os_hwWriteMemRegisterUINT32()
1182 ****************************************************************************************
1183 DESCRIPTION: Writes a 'unsigned long' to a memory-mapped device register.
1184
1185 ARGUMENTS: OsContext - our adapter context.
1186
1187 Register - Pointer to the memory-mapped register.
1188
1189 Data - Specifies the caller-supplied UINT32 that this function transfers
1190 to the Register.
1191
1192 RETURN: None
1193
1194 NOTES:
1195 *****************************************************************************************/
1196 VOID
os_hwWriteMemRegisterUINT32(TI_HANDLE OsContext,PUINT32 Register,UINT32 Data)1197 os_hwWriteMemRegisterUINT32(
1198 TI_HANDLE OsContext,
1199 PUINT32 Register,
1200 UINT32 Data
1201 )
1202 {
1203 PRINT_REG("W32: %p=0x%x\n", Register, Data);
1204 *Register = Data;
1205 return;
1206 }
1207
1208
1209 /****************************************************************************************
1210 * os_hwReadMemRegisterUINT32()
1211 ****************************************************************************************
1212 DESCRIPTION: Reads a UINT32 from a memory-mapped device register.
1213
1214 ARGUMENTS: OsContext - our adapter context.
1215
1216 Register - Pointer to the memory-mapped register.
1217
1218 Data - Pointer to the caller-supplied variable in which this function
1219 returns the UINT32 read from Register.
1220
1221 RETURN: None
1222
1223 NOTES:
1224 *****************************************************************************************/
1225 VOID
os_hwReadMemRegisterUINT32(TI_HANDLE OsContext,PUINT32 Register,PUINT32 Data)1226 os_hwReadMemRegisterUINT32(
1227 TI_HANDLE OsContext,
1228 PUINT32 Register,
1229 PUINT32 Data
1230 )
1231 {
1232 *Data = *Register;
1233 PRINT_REG("R32: %p=0x%x\n", Register, *Data);
1234 return;
1235 }
1236
1237
1238 /****************************************************************************************
1239 * os_receivePacket()
1240 ****************************************************************************************
1241 DESCRIPTION:
1242
1243 ARGUMENTS:
1244
1245 RETURN:
1246
1247 NOTES:
1248 *****************************************************************************************/
1249 BOOL
os_receivePacket(TI_HANDLE OsContext,PVOID pPacket,UINT16 Length)1250 os_receivePacket(
1251 TI_HANDLE OsContext,
1252 PVOID pPacket,
1253 UINT16 Length
1254 )
1255 {
1256 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
1257 struct sk_buff *skb;
1258 mem_MSDU_T* pMsdu = (mem_MSDU_T*)pPacket;
1259 mem_BD_T *pCurBd;
1260 ti_nodprintf(TIWLAN_LOG_INFO, "os_receivePacket - Received EAPOL len-%d\n", pMsdu->firstBDPtr->length );
1261
1262 bm_trace(10, Length, 0);
1263
1264 if (pMsdu->firstBDPtr->length > Length) { /* Dm: Security fix */
1265 ti_dprintf(TIWLAN_LOG_ERROR, " TI: %s - Security Error\n", __FUNCTION__);
1266 return FALSE;
1267 }
1268
1269 skb = dev_alloc_skb(Length+2);
1270 if(!skb) {
1271 print_deb(" os_receivePacket() : dev_alloc_skb failed!\n");
1272 configMgr_memMngrFreeMSDU(drv->adapter.CoreHalCtx, memMgr_MsduHandle(pPacket));
1273 drv->stats.rx_dropped++;
1274 return FALSE;
1275 }
1276 skb_reserve(skb, 2);
1277
1278 pCurBd = pMsdu->firstBDPtr;
1279 while (pCurBd) {
1280 memcpy(skb_put(skb,pCurBd->length),pCurBd->data+pCurBd->dataOffset,pCurBd->length);
1281 pCurBd = pCurBd->nextBDPtr;
1282 }
1283
1284 skb->dev = drv->netdev;
1285 skb->protocol = eth_type_trans(skb, drv->netdev);
1286 skb->ip_summed = CHECKSUM_NONE;
1287
1288 drv->stats.rx_packets++;
1289 drv->stats.rx_bytes += skb->len;
1290
1291 bm_trace(11, Length, 0);
1292 #ifdef CONFIG_ANDROID_POWER
1293 drv->receive_packet = 1; /* Remember to stay awake */
1294 #endif
1295 netif_rx(skb);
1296
1297 configMgr_memMngrFreeMSDU(drv->adapter.CoreHalCtx, memMgr_MsduHandle(pPacket));
1298
1299 bm_trace(12, Length, 0);
1300
1301 return TRUE;
1302 }
1303
1304 /****************************************************************************************
1305 * os_sendPacket()
1306 ****************************************************************************************
1307 DESCRIPTION: send EAPOL packet from Supplicant
1308
1309 ARGUMENTS:
1310
1311 RETURN:
1312
1313 NOTES:
1314 *****************************************************************************************/
1315 INT32
os_sendPacket(TI_HANDLE OsContext,PVOID pPacket,UINT16 Length)1316 os_sendPacket(
1317 TI_HANDLE OsContext,
1318 PVOID pPacket,
1319 UINT16 Length
1320 )
1321 {
1322 struct net_device *dev = (struct net_device *)OsContext;
1323 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)NETDEV_GET_PRIVATE(dev);
1324
1325 INT32 status;
1326 mem_MSDU_T* pMsdu;
1327 char *pMsduData;
1328 UINT32 packetHeaderLength;
1329
1330 ti_nodprintf(TIWLAN_LOG_INFO, "os_sendPacket - Transmit EAPOL len-%x\n",Length );
1331
1332 /*
1333 * Allocate enough place also for 802.11 header (24 bytes) and LLC (8 bytes)
1334 * to replace the Ethernet header (14 bytes)
1335 */
1336 if(!Length)
1337 {
1338 ti_dprintf(TIWLAN_LOG_ERROR, " EAPOL Packet Length = 0 \n");
1339 return -1;
1340 }
1341 /*
1342 * Retrieve the Packet Header length
1343 * from QoS Manager (through configMgr) and RSN
1344 */
1345 packetHeaderLength = configMgr_getPacketHeaderLength(drv->adapter.CoreHalCtx,pPacket,TX_DATA_EAPOL_MSDU);
1346
1347 /*
1348 * need to reserve enough space for header translation
1349 * in the same first Bd.
1350 * Allocate enough place also for 802.11 header (24 bytes or 26 for QoS) and LLC (8 bytes)
1351 * to replace the Ethernet header (14 bytes)
1352 */
1353
1354 status = configMgr_allocMSDU(drv->adapter.CoreHalCtx, &pMsdu,
1355 Length + packetHeaderLength , OS_ABS_TX_MODULE);
1356 if(status != OK)
1357 {
1358 ti_dprintf(TIWLAN_LOG_ERROR, " configMgr_allocMSDU failed !!!\n");
1359 ++drv->alloc_msdu_failures;
1360 return -ENOMEM;
1361 }
1362
1363 /*
1364 * case 1: only legacy wlan header
1365 *
1366 * case 2: only QoS wlan header
1367 *
1368 * case 3: only legacy wlan header with new snap
1369 *
1370 * case 4: only QoS wlan header with new snap
1371 */
1372 pMsdu->firstBDPtr->dataOffset = packetHeaderLength - ETHERNET_HDR_LEN;
1373 pMsduData = pMsdu->firstBDPtr->data + pMsdu->firstBDPtr->dataOffset;
1374 memcpy(pMsduData, pPacket, Length);
1375 pMsdu->dataLen = Length;
1376 pMsdu->firstBDPtr->length = pMsdu->dataLen + pMsdu->firstBDPtr->dataOffset;
1377 pMsdu->freeFunc = 0;
1378 pMsdu->freeArgs[0] = 0;
1379 pMsdu->freeArgs[1] = 0;
1380
1381 /*
1382 * Propagate Msdu through Config Manager.
1383 * Set DTag to 0
1384 * (note that classification is further handled in the Core)
1385 */
1386 status = configMgr_sendMsdu(drv->adapter.CoreHalCtx, pMsdu, 0);
1387
1388 return status;
1389 }
1390
1391
1392 #endif /* NDEF GWSI_DRIVER*/
1393
1394
1395
1396 /*******************************************************************************************************
1397
1398 LOCAL FUNCTIONS
1399
1400 ********************************************************************************************************/
1401
1402 /*-----------------------------------------------------------------------------
1403 Routine Name:
1404
1405 os_timer_dec_use_count
1406
1407 Routine Description:
1408
1409 This function is decrements timer use count.
1410 When use_count becomes 0, the timer block is destroyed
1411 -----------------------------------------------------------------------------*/
os_timer_dec_use_count(timer_obj_t * tmr)1412 static inline void os_timer_dec_use_count(timer_obj_t *tmr)
1413 {
1414 if (unlikely(!tmr->use_count)) {
1415 ti_dprintf(TIWLAN_LOG_ERROR, "\n\n\n %s: attempt to delete a deleted timer %p\n\n\n", __FUNCTION__, tmr);
1416 tmr->use_count = 1;
1417 }
1418 if (!(--tmr->use_count))
1419 os_memoryFree(tmr->req.drv, tmr, sizeof(timer_obj_t));
1420 }
1421
1422
1423 /*-----------------------------------------------------------------------------
1424
1425 Routine Name:
1426
1427 os_tl_timerHandlr
1428
1429 Routine Description:
1430
1431 This function is called in context of the control tasklet.
1432 It evokes user timer handler and restarts the timer if periodic
1433
1434 Arguments:
1435 p1 - user handler
1436 p2 - user parameter
1437 p3 - periodic
1438 p4 - jiffies
1439
1440 Return Value:
1441
1442 None.
1443
1444 Notes:
1445
1446 -----------------------------------------------------------------------------*/
os_tl_timerHandlr(struct tiwlan_req * req)1447 static int os_tl_timerHandlr(struct tiwlan_req *req)
1448 {
1449 timer_obj_t *tmr= (timer_obj_t *)req;
1450 PTIMER_FUNCTION f = (PTIMER_FUNCTION)req->u.req.p1;
1451 TI_HANDLE parm = (TI_HANDLE)req->u.req.p2;
1452
1453 esta_timer_log("%s: req=0x%x f=0x%p parm=0x%p\n", __FUNCTION__, req, f, parm);
1454 ++tmr->use_count;
1455 f(parm);
1456 if (req->u.req.p3) /* Periodic ? */
1457 mod_timer(&tmr->timer, jiffies + req->u.req.p4);
1458 os_timer_dec_use_count(tmr);
1459
1460 return 0;
1461 }
1462
1463
1464 /*-----------------------------------------------------------------------------
1465
1466 Routine Name:
1467
1468 os_timerHandlr
1469
1470 Routine Description:
1471
1472 This function is called on timer expiration in context of
1473 softIsr. It delegates the timer handling to the control tasklet.
1474
1475 Arguments:
1476 parm - timer object handle
1477
1478 Return Value:
1479
1480 None.
1481
1482 Notes:
1483
1484 -----------------------------------------------------------------------------*/
os_timerHandlr(unsigned long parm)1485 static void os_timerHandlr(unsigned long parm)
1486 {
1487 timer_obj_t *tmr= (timer_obj_t *)parm;
1488 tiwlan_net_dev_t *drv = tmr->req.drv;
1489 unsigned long flags;
1490
1491 esta_timer_log("%s: drv=%p f=0x%x ctx=0x%x\n",
1492 __FUNCTION__, tmr->req.drv, tmr->req.u.req.p1, tmr->req.u.req.p2);
1493
1494 spin_lock_irqsave(&drv->lock, flags);
1495 list_del(&tmr->req.list);
1496 list_add_tail(&tmr->req.list, &drv->request_q);
1497 spin_unlock_irqrestore(&drv->lock, flags);
1498 #ifdef DM_USE_WORKQUEUE
1499 /* printk("TI: %s:\t%lu\n", __FUNCTION__, jiffies); */
1500 #ifdef CONFIG_ANDROID_POWER
1501 android_lock_suspend( &drv->timer_wake_lock );
1502 #endif
1503 queue_work( drv->tiwlan_wq, &drv->tw );
1504 #else
1505 tasklet_schedule(&drv->tl);
1506 #endif
1507 }
1508
1509
1510 /*-----------------------------------------------------------------------------
1511
1512 Routine Name:
1513
1514 os_connectionStatus
1515
1516 Routine Description:
1517
1518 The eSTA-DK will call this API so the OS stack is aware that the
1519 WLAN layer is ready to function.
1520
1521 Arguments:
1522 cStatus = 1; WLAN in ready for network packets
1523 cStatus = 0; WLAN in not ready for network packets
1524
1525 Return Value:
1526
1527 None
1528
1529 -----------------------------------------------------------------------------*/
1530
1531 tiINT32
os_IndicateEvent(IPC_EV_DATA * pData)1532 os_IndicateEvent(IPC_EV_DATA* pData)
1533 {
1534 IPC_EVENT_PARAMS * pInParam = (IPC_EVENT_PARAMS *)pData;
1535 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)(pInParam->hUserParam);
1536 /*UCHAR AuthBuf[sizeof(ULONG) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)];*/
1537
1538 ti_nodprintf(TIWLAN_LOG_INFO, "\n os_ConnectionStatus Event 0x%08x \n", CsStatus->Event);
1539
1540 switch(pInParam->uEventType)
1541 {
1542 case IPC_EVENT_ASSOCIATED:
1543 if (drv->netdev != NULL) {
1544 netif_carrier_on(drv->netdev);
1545 #if defined(CONFIG_TROUT_PWRSINK) || defined(CONFIG_HTC_PWRSINK)
1546 queue_delayed_work(drv->tiwlan_wq, &drv->trxw, 0);
1547 #endif
1548 }
1549 break;
1550
1551 case IPC_EVENT_DISASSOCIATED:
1552 if (drv->netdev != NULL) {
1553 #if defined(CONFIG_TROUT_PWRSINK) || defined(CONFIG_HTC_PWRSINK)
1554 unsigned percent;
1555
1556 cancel_delayed_work_sync(&drv->trxw);
1557 percent = ( drv->started ) ? PWRSINK_WIFI_PERCENT_BASE : 0;
1558 #ifdef CONFIG_HTC_PWRSINK
1559 htc_pwrsink_set(PWRSINK_WIFI, percent);
1560 #else
1561 trout_pwrsink_set(PWRSINK_WIFI, percent);
1562 #endif
1563 #endif
1564 netif_carrier_off(drv->netdev);
1565 }
1566 break;
1567
1568 case IPC_EVENT_LINK_SPEED:
1569 drv->adapter.LinkSpeed = (*(PULONG)pData->uBuffer * 10000) / 2;
1570 ti_nodprintf(TIWLAN_LOG_INFO, "\n Link Speed = 0x%08x \n",drv->adapter.LinkSpeed);
1571 break;
1572
1573 case IPC_EVENT_AUTH_SUCC:
1574 /* *(PULONG)AuthBuf = os802_11StatusType_Authentication;
1575 memcpy((PUCHAR)&AuthBuf[sizeof(ULONG)], pData->uBuffer,sizeof(OS_802_11_AUTHENTICATION_REQUEST));*/
1576 ti_dprintf(TIWLAN_LOG_OTHER, "\n Auth Succ Event from Driver to another BSSID. \n");
1577 break;
1578
1579 case IPC_EVENT_SCAN_COMPLETE:
1580 ti_dprintf(TIWLAN_LOG_OTHER, "\n Driver Event = Scan Complete. \n");
1581 break;
1582
1583 case IPC_EVENT_TIMEOUT:
1584 ti_dprintf(TIWLAN_LOG_OTHER, "\n Driver Event = Timeout. \n");
1585 break;
1586
1587 case IPC_EVENT_CCKM_START:
1588 ti_dprintf(TIWLAN_LOG_OTHER, "\n Driver Event = IPC_EVENT_CCKM_START \n");
1589 break;
1590
1591 default:
1592 ti_dprintf(TIWLAN_LOG_ERROR, "\n Unrecognized driver event. \n");
1593 break;
1594
1595 }
1596
1597 return OK;
1598 }
1599
1600
1601 /****************************************************************************/
1602 /* The following 4 functions are debug functions that enable the user
1603 to set/reset GPIO_25 and GPIO_27 in the OMAP - for debug purposes.
1604 Note: In order to enable GPIO_25/GPIO_27 the user must enable the define
1605 TIWLAN_OMAP1610_CRTWIPP_GPIO_DEBUG in the esta_drv.c/osapi.c files. */
1606
os_ToggleDebugGPIO(int count)1607 void os_ToggleDebugGPIO(int count)
1608 {
1609 #if 0
1610 int i,j;
1611
1612 omap_writel(0x00000200, 0xFFFBBCB0 );/* 0 */
1613 for(i=0;i<count;i++)
1614 {
1615 omap_writel(0x00000200, 0xFFFBBCF0 );/* 1 */
1616 for(j=0;j<100;j++);
1617 omap_writel(0x00000200, 0xFFFBBCB0 );/* 0 */
1618 for(j=0;j<100;j++);
1619 }
1620 #endif
1621 }
1622 #ifdef TIWLAN_OMAP1610_CRTWIPP_GPIO_DEBUG
1623 VOID
os_SetGpio_25(TI_HANDLE OsContext)1624 os_SetGpio_25(
1625 TI_HANDLE OsContext
1626 )
1627 {
1628 /*
1629 Setting GPIO_25 by GPIO_SET_DATAOUT
1630 */
1631 omap_writel(0x00000200, 0xFFFBECF0 );
1632 }
1633
1634
1635 VOID
os_ResetGpio25(TI_HANDLE OsContext)1636 os_ResetGpio25(
1637 TI_HANDLE OsContext
1638 )
1639 {
1640 /*
1641 Clear GPIO_25 by GPIO_CLEAR_DATAOUT
1642 */
1643 omap_writel(0x00000200, 0xFFFBECB0 );
1644 }
1645
1646
1647 VOID
os_SetGpio27(TI_HANDLE OsContext)1648 os_SetGpio27(
1649 TI_HANDLE OsContext
1650 )
1651 {
1652 /*
1653 Setting GPIO_27 by GPIO_SET_DATAOUT
1654 */
1655 omap_writel(0x00000800, 0xFFFBECF0 );
1656 }
1657
1658
1659 VOID
os_ResetGpio27(TI_HANDLE OsContext)1660 os_ResetGpio27(
1661 TI_HANDLE OsContext
1662 )
1663 {
1664 /*
1665 Clear GPIO_27 by GPIO_CLEAR_DATAOUT
1666 */
1667 omap_writel(0x00000800, 0xFFFBECB0 );
1668 }
1669 #endif
1670 /******************************************************************************/
1671
1672 VOID
os_disableIrq(TI_HANDLE OsContext)1673 os_disableIrq( TI_HANDLE OsContext)
1674 {
1675 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
1676 disable_irq (drv->irq);
1677 }
1678
1679 VOID
os_enableIrq(TI_HANDLE OsContext)1680 os_enableIrq( TI_HANDLE OsContext)
1681 {
1682 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
1683 enable_irq (drv->irq);
1684 }
1685
1686 int
os_getFirmwareImage(TI_HANDLE OsContext,PUINT8 * pBuffer,PUINT32 Length,UINT8 RadioType)1687 os_getFirmwareImage(
1688 TI_HANDLE OsContext,
1689 PUINT8 *pBuffer,
1690 PUINT32 Length,
1691 UINT8 RadioType
1692 )
1693 {
1694 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
1695
1696 *pBuffer = drv->firmware_image.va;
1697 *Length = drv->firmware_image.size;
1698
1699 return OK;
1700 }
1701
1702
1703 /*-----------------------------------------------------------------------------
1704
1705 Routine Name:
1706
1707 os_getRadioImage
1708
1709 Routine Description:
1710
1711
1712 Arguments:
1713
1714
1715 Return Value:
1716
1717 OK
1718
1719 -----------------------------------------------------------------------------*/
1720 int
os_getRadioImage(TI_HANDLE OsContext,PUINT8 * pBuffer,PUINT32 Length,UINT8 RadioType)1721 os_getRadioImage(
1722 TI_HANDLE OsContext,
1723 PUINT8 *pBuffer,
1724 PUINT32 Length,
1725 UINT8 RadioType
1726 )
1727 {
1728
1729 #ifdef FIRMWARE_DYNAMIC_LOAD
1730 tiwlan_net_dev_t *drv = (tiwlan_net_dev_t *)OsContext;
1731
1732 *pBuffer = drv->eeprom_image.va;
1733 *Length = drv->eeprom_image.size;
1734 #else
1735 extern unsigned char tiwlan_radimage[];
1736 extern unsigned int sizeof_tiwlan_radimage;
1737 *pBuffer = (PUINT8)tiwlan_radimage;
1738 *Length = sizeof_tiwlan_radimage;
1739 #endif
1740 ti_dprintf(TIWLAN_LOG_INFO, "%s: radio type: 0x%x\n", __FUNCTION__, RadioType);
1741
1742 return OK;
1743 }
1744
1745
1746 #ifdef DRIVER_PROFILING
_os_profile(TI_HANDLE OsContext,UINT32 fn,UINT32 par)1747 void _os_profile (TI_HANDLE OsContext, UINT32 fn, UINT32 par)
1748 {
1749 tiwlan_profile (OsContext, fn, par);
1750 }
1751 #endif
1752
1753 VOID
os_closeFirmwareImage(TI_HANDLE OsContext)1754 os_closeFirmwareImage( TI_HANDLE OsContext )
1755 {
1756 return;
1757 }
1758
1759 VOID
os_closeRadioImage(TI_HANDLE OsContext)1760 os_closeRadioImage( TI_HANDLE OsContext )
1761 {
1762 return;
1763 }
1764