1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
4 *
5 ******************************************************************************/
6
7 #include <osdep_service.h>
8 #if defined(CONFIG_USE_TCM_HEAP) && CONFIG_USE_TCM_HEAP
9 #include "tcm_heap.h"
10 #endif
11
12 #define OSDEP_DBG(x, ...) do {} while(0)
13
14 extern struct osdep_service_ops osdep_service;
15
16 #ifdef CONFIG_LITTLE_ENDIAN
17 u16
_htons(u16 n)18 _htons(u16 n)
19 {
20 return ((n & 0xff) << 8) | ((n & 0xff00) >> 8);
21 }
22
23 u16
_ntohs(u16 n)24 _ntohs(u16 n)
25 {
26 return _htons(n);
27 }
28
29 u32
_htonl(u32 n)30 _htonl(u32 n)
31 {
32 return ((n & 0xff) << 24) |
33 ((n & 0xff00) << 8) |
34 ((n & 0xff0000UL) >> 8) |
35 ((n & 0xff000000UL) >> 24);
36 }
37
38 u32
_ntohl(u32 n)39 _ntohl(u32 n)
40 {
41 return _htonl(n);
42 }
43
44 #endif /* CONFIG_LITTLE_ENDIAN */
45 /*
46 * Translate the OS dependent @param error_code to OS independent RTW_STATUS_CODE
47 * @return: one of RTW_STATUS_CODE
48 */
RTW_STATUS_CODE(int error_code)49 int RTW_STATUS_CODE(int error_code)
50 {
51 if(error_code >= 0)
52 return _SUCCESS;
53
54 return _FAIL;
55 }
56
rtw_atoi(u8 * s)57 u32 rtw_atoi(u8* s)
58 {
59 int num=0,flag=0;
60 u32 i;
61
62 for(i=0;i<=strlen((char *)s);i++)
63 {
64 if(s[i] >= '0' && s[i] <= '9')
65 num = num * 10 + s[i] -'0';
66 else if(s[0] == '-' && i==0)
67 flag =1;
68 else
69 break;
70 }
71
72 if(flag == 1)
73 num = num * -1;
74
75 return(num);
76 }
77 #if defined(CONFIG_USE_TCM_HEAP) && CONFIG_USE_TCM_HEAP
78 void *tcm_heap_malloc(int size);
79 void *tcm_heap_calloc(int size);
80 #endif
_rtw_vmalloc(u32 sz)81 u8* _rtw_vmalloc(u32 sz)
82 {
83 u8 *pbuf = NULL;
84 #if defined(CONFIG_USE_TCM_HEAP) && CONFIG_USE_TCM_HEAP
85 pbuf = tcm_heap_malloc(sz);
86 #endif
87 if(pbuf==NULL){
88 if(osdep_service.rtw_vmalloc) {
89 pbuf = osdep_service.rtw_vmalloc(sz);
90 } else
91 OSDEP_DBG("Not implement osdep service: rtw_vmalloc");
92 }
93 return pbuf;
94 }
95
_rtw_zvmalloc(u32 sz)96 u8* _rtw_zvmalloc(u32 sz)
97 {
98 u8 *pbuf = NULL;
99 #if defined(CONFIG_USE_TCM_HEAP) && CONFIG_USE_TCM_HEAP
100 pbuf = tcm_heap_calloc(sz);
101 #endif
102 if(pbuf==NULL){
103 if(osdep_service.rtw_zvmalloc) {
104 pbuf = osdep_service.rtw_zvmalloc(sz);
105 } else
106 OSDEP_DBG("Not implement osdep service: rtw_zvmalloc");
107 }
108 return pbuf;
109 }
110
_rtw_vmfree(u8 * pbuf,u32 sz)111 void _rtw_vmfree(u8 *pbuf, u32 sz)
112 {
113
114 #if defined(CONFIG_USE_TCM_HEAP) && CONFIG_USE_TCM_HEAP
115 if( (u32)pbuf > 0x1FFF0000 && (u32)pbuf < 0x20000000 )
116 tcm_heap_free(pbuf);
117 else
118 #endif
119 {
120 if(osdep_service.rtw_vmfree) {
121 osdep_service.rtw_vmfree(pbuf, sz);
122 } else
123 OSDEP_DBG("Not implement osdep service: rtw_vmfree");
124 }
125 }
126
_rtw_malloc(u32 sz)127 u8* _rtw_malloc(u32 sz)
128 {
129 if(osdep_service.rtw_malloc) {
130 u8 *pbuf = osdep_service.rtw_malloc(sz);
131 return pbuf;
132 } else
133 OSDEP_DBG("Not implement osdep service: rtw_malloc");
134
135 return NULL;
136 }
137
_rtw_zmalloc(u32 sz)138 u8* _rtw_zmalloc(u32 sz)
139 {
140 if(osdep_service.rtw_zmalloc) {
141 u8 *pbuf = osdep_service.rtw_zmalloc(sz);
142 return pbuf;
143 } else
144 OSDEP_DBG("Not implement osdep service: rtw_zmalloc");
145
146 return NULL;
147 }
148
_rtw_calloc(u32 nelements,u32 elementSize)149 u8* _rtw_calloc(u32 nelements, u32 elementSize)
150 {
151 u32 sz = nelements*elementSize;
152 u8* pbuf = _rtw_zmalloc(sz);
153 return pbuf;
154 }
155
_rtw_mfree(u8 * pbuf,u32 sz)156 void _rtw_mfree(u8 *pbuf, u32 sz)
157 {
158 if(osdep_service.rtw_mfree) {
159 osdep_service.rtw_mfree(pbuf, sz);
160 } else
161 OSDEP_DBG("Not implement osdep service: rtw_mfree");
162 }
163
164 #ifdef CONFIG_MEM_MONITOR
165 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
166 _list mem_table;
167 int mem_used_num;
168 #endif
169 int min_free_heap_size;
170
init_mem_monitor(_list * pmem_table,int * used_num)171 void init_mem_monitor(_list *pmem_table, int *used_num)
172 {
173 /* To avoid gcc warnings */
174 ( void ) pmem_table;
175 ( void ) used_num;
176 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
177 rtw_init_listhead(pmem_table);
178 *used_num = 0;
179 #endif
180 min_free_heap_size = rtw_getFreeHeapSize();
181 }
182
deinit_mem_monitor(_list * pmem_table,int * used_num)183 void deinit_mem_monitor(_list *pmem_table, int *used_num)
184 {
185 /* To avoid gcc warnings */
186 ( void ) pmem_table;
187 ( void ) used_num;
188 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
189 _list *plist;
190 struct mem_entry *mem_entry;
191
192 if(*used_num > 0)
193 DBG_ERR("Have %d mem_entry kept in monitor", *used_num);
194 else
195 DBG_INFO("No mem_entry kept in monitor");
196
197 save_and_cli();
198
199 while (rtw_end_of_queue_search(pmem_table, get_next(pmem_table)) == _FALSE) {
200 plist = get_next(pmem_table);
201 mem_entry = LIST_CONTAINOR(plist, struct mem_entry, list);
202
203 DBG_ERR("Not release memory at %p with size of %d", mem_entry->ptr, mem_entry->size);
204
205 rtw_list_delete(plist);
206 _rtw_mfree((u8 *) mem_entry, sizeof(struct mem_entry));
207 }
208
209 restore_flags();
210 #endif
211 }
212
add_mem_usage(_list * pmem_table,void * ptr,int size,int * used_num,int flag)213 void add_mem_usage(_list *pmem_table, void *ptr, int size, int *used_num, int flag)
214 {
215 /* To avoid gcc warnings */
216 ( void ) pmem_table;
217 ( void ) used_num;
218
219 int free_heap_size = rtw_getFreeHeapSize();
220 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
221 struct mem_entry *mem_entry;
222 #endif
223 if(ptr == NULL) {
224 DBG_ERR("Catch a mem alloc fail with size of %d, current heap free size = %d", size, free_heap_size);
225 return;
226 }
227 else{
228 if(flag == MEM_MONITOR_FLAG_WPAS)
229 DBG_INFO("Alloc memory at %p with size of %d", ptr, size);
230 else {
231 DBG_INFO("Alloc memory at %p with size of %d", ptr, size);
232 }
233 }
234 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
235 mem_entry = (struct mem_entry *) _rtw_malloc(sizeof(struct mem_entry));
236
237 if(mem_entry == NULL) {
238 DBG_ERR("Fail to alloc mem_entry");
239 return;
240 }
241
242 memset(mem_entry, 0, sizeof(struct mem_entry));
243 mem_entry->ptr = ptr;
244 mem_entry->size = size;
245
246 save_and_cli();
247 rtw_list_insert_head(&mem_entry->list, pmem_table);
248 restore_flags();
249
250 *used_num ++;
251 #endif
252 if(min_free_heap_size > free_heap_size)
253 min_free_heap_size = free_heap_size;
254 }
255
del_mem_usage(_list * pmem_table,void * ptr,int * used_num,int flag)256 void del_mem_usage(_list *pmem_table, void *ptr, int *used_num, int flag)
257 {
258 /* To avoid gcc warnings */
259 ( void ) pmem_table;
260 ( void ) ptr;
261 ( void ) used_num;
262 ( void ) flag;
263 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
264 _list *plist;
265 struct mem_entry *mem_entry = NULL;
266
267 if(ptr == NULL)
268 return;
269
270 if(flag == MEM_MONITOR_FLAG_WPAS)
271 DBG_INFO("Free memory at %p", ptr);
272 else
273 DBG_INFO("Free memory at %p", ptr);
274
275 save_and_cli();
276
277 plist = get_next(pmem_table);
278 while ((rtw_end_of_queue_search(pmem_table, plist)) == _FALSE)
279 {
280 mem_entry = LIST_CONTAINOR(plist, struct mem_entry, list);
281 if(mem_entry->ptr == ptr) {
282 rtw_list_delete(plist);
283 break;
284 }
285 plist = get_next(plist);
286 }
287
288 restore_flags();
289
290 if(plist == pmem_table)
291 DBG_ERR("Fail to find the mem_entry in mem table");
292 else {
293 *used_num --;
294 _rtw_mfree((u8 *) mem_entry, sizeof(struct mem_entry));
295 }
296 #endif
297 }
298
299 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
get_mem_usage(_list * pmem_table)300 int get_mem_usage(_list *pmem_table)
301 {
302 _list *plist;
303 struct mem_entry *mem_entry;
304 int mem_usage = 0;
305 int entry_num = 0;
306
307 save_and_cli();
308
309 if((plist = get_next(pmem_table)) == NULL) {
310 DBG_ERR("No mem table available\n");
311 restore_flags();
312 return 0;
313 }
314
315 while (rtw_end_of_queue_search(pmem_table, plist) == _FALSE) {
316 entry_num ++;
317 mem_entry = LIST_CONTAINOR(plist, struct mem_entry, list);
318 mem_usage += mem_entry->size;
319
320 DBG_INFO("size of mem_entry(%d)=%d\n", entry_num, mem_entry->size);
321 plist = get_next(plist);
322 }
323
324 restore_flags();
325
326 DBG_INFO("Get %d mem_entry\n", entry_num);
327
328 return mem_usage;
329 }
330 #endif
331
332
rtw_vmalloc(u32 sz)333 u8* rtw_vmalloc(u32 sz)
334 {
335 u8 *pbuf = _rtw_vmalloc(sz);
336 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
337 add_mem_usage(&mem_table, pbuf, sz, &mem_used_num, MEM_MONITOR_FLAG_WIFI_DRV);
338 #else
339 add_mem_usage(NULL, pbuf, sz, NULL, MEM_MONITOR_FLAG_WIFI_DRV);
340 #endif
341 return pbuf;
342 }
343
rtw_zvmalloc(u32 sz)344 u8* rtw_zvmalloc(u32 sz)
345 {
346 u8 *pbuf = _rtw_zvmalloc(sz);
347 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
348 add_mem_usage(&mem_table, pbuf, sz, &mem_used_num, MEM_MONITOR_FLAG_WIFI_DRV);
349 #else
350 add_mem_usage(NULL, pbuf, sz, NULL, MEM_MONITOR_FLAG_WIFI_DRV);
351 #endif
352 return pbuf;
353 }
354
rtw_vmfree(u8 * pbuf,u32 sz)355 void rtw_vmfree(u8 *pbuf, u32 sz)
356 {
357 _rtw_vmfree(pbuf, sz);
358 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
359 del_mem_usage(&mem_table, pbuf, &mem_used_num, MEM_MONITOR_FLAG_WIFI_DRV);
360 #else
361 del_mem_usage(NULL, pbuf, NULL, MEM_MONITOR_FLAG_WIFI_DRV);
362 #endif
363 }
364
rtw_malloc(u32 sz)365 u8* rtw_malloc(u32 sz)
366 {
367 u8 *pbuf = _rtw_malloc(sz);
368 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
369 add_mem_usage(&mem_table, pbuf, sz, &mem_used_num, MEM_MONITOR_FLAG_WIFI_DRV);
370 #else
371 add_mem_usage(NULL, pbuf, sz, NULL, MEM_MONITOR_FLAG_WIFI_DRV);
372 #endif
373 return pbuf;
374 }
375
rtw_zmalloc(u32 sz)376 u8* rtw_zmalloc(u32 sz)
377 {
378 u8 *pbuf = _rtw_zmalloc(sz);
379 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
380 add_mem_usage(&mem_table, pbuf, sz, &mem_used_num, MEM_MONITOR_FLAG_WIFI_DRV);
381 #else
382 add_mem_usage(NULL, pbuf, sz, NULL, MEM_MONITOR_FLAG_WIFI_DRV);
383 #endif
384 return pbuf;
385 }
386
rtw_calloc(u32 nelements,u32 elementSize)387 u8* rtw_calloc(u32 nelements, u32 elementSize)
388 {
389 u8 *pbuf = _rtw_calloc(nelements, elementSize);
390
391 u32 sz = nelements*elementSize;
392 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
393 add_mem_usage(&mem_table, pbuf, sz, &mem_used_num, MEM_MONITOR_FLAG_WIFI_DRV);
394 #else
395 add_mem_usage(NULL, pbuf, sz, NULL, MEM_MONITOR_FLAG_WIFI_DRV);
396 #endif
397 return pbuf;
398 }
399
rtw_mfree(u8 * pbuf,u32 sz)400 void rtw_mfree(u8 *pbuf, u32 sz)
401 {
402 _rtw_mfree(pbuf, sz);
403 #if CONFIG_MEM_MONITOR & MEM_MONITOR_LEAK
404 del_mem_usage(&mem_table, pbuf, &mem_used_num, MEM_MONITOR_FLAG_WIFI_DRV);
405 #else
406 del_mem_usage(NULL, pbuf, NULL, MEM_MONITOR_FLAG_WIFI_DRV);
407 #endif
408 }
409 #endif
410
rtw_malloc2d(int h,int w,int size)411 void* rtw_malloc2d(int h, int w, int size)
412 {
413 int j;
414
415 void **a = (void **) rtw_zmalloc( h*sizeof(void *) + h*w*size );
416 if(a == NULL)
417 {
418 OSDEP_DBG("%s: alloc memory fail!\n", __FUNCTION__);
419 return NULL;
420 }
421
422 for( j=0; j<h; j++ )
423 a[j] = ((char *)(a+h)) + j*w*size;
424
425 return a;
426 }
427
rtw_mfree2d(void * pbuf,int h,int w,int size)428 void rtw_mfree2d(void *pbuf, int h, int w, int size)
429 {
430 rtw_mfree((u8 *)pbuf, h*sizeof(void*) + w*h*size);
431 }
432
rtw_memcpy(void * dst,void * src,u32 sz)433 void rtw_memcpy(void* dst, void* src, u32 sz)
434 {
435 if(osdep_service.rtw_memcpy)
436 osdep_service.rtw_memcpy(dst, src, sz);
437 else
438 OSDEP_DBG("Not implement osdep service: rtw_memcpy");
439 }
440
rtw_memcmp(void * dst,void * src,u32 sz)441 int rtw_memcmp(void *dst, void *src, u32 sz)
442 {
443 if(osdep_service.rtw_memcmp)
444 return osdep_service.rtw_memcmp(dst, src, sz);
445 else
446 OSDEP_DBG("Not implement osdep service: rtw_memcmp");
447
448 return _FALSE;
449 }
450
rtw_memset(void * pbuf,int c,u32 sz)451 void rtw_memset(void *pbuf, int c, u32 sz)
452 {
453 if(osdep_service.rtw_memset)
454 osdep_service.rtw_memset(pbuf, c, sz);
455 else
456 OSDEP_DBG("Not implement osdep service: rtw_memset");
457 }
458
rtw_init_listhead(_list * list)459 void rtw_init_listhead(_list *list)
460 {
461 INIT_LIST_HEAD(list);
462 }
463
464 /*
465 For the following list_xxx operations,
466 caller must guarantee the atomic context.
467 Otherwise, there will be racing condition.
468 */
rtw_is_list_empty(_list * phead)469 u32 rtw_is_list_empty(_list *phead)
470 {
471 if(list_empty(phead))
472 return _TRUE;
473
474 return _FALSE;
475 }
476
rtw_list_insert_head(_list * plist,_list * phead)477 void rtw_list_insert_head(_list *plist, _list *phead)
478 {
479 list_add(plist, phead);
480 }
481
rtw_list_insert_tail(_list * plist,_list * phead)482 void rtw_list_insert_tail(_list *plist, _list *phead)
483 {
484 list_add_tail(plist, phead);
485 }
486
487 /*
488
489 Caller must check if the list is empty before calling rtw_list_delete
490
491 */
rtw_list_delete(_list * plist)492 void rtw_list_delete(_list *plist)
493 {
494 list_del_init(plist);
495 }
496
497
498
rtw_init_sema(_sema * sema,int init_val)499 void rtw_init_sema(_sema *sema, int init_val)
500 {
501 if(osdep_service.rtw_init_sema)
502 osdep_service.rtw_init_sema(sema, init_val);
503 else
504 OSDEP_DBG("Not implement osdep service: rtw_init_sema");
505 }
506
rtw_free_sema(_sema * sema)507 void rtw_free_sema(_sema *sema)
508 {
509 if(osdep_service.rtw_free_sema)
510 osdep_service.rtw_free_sema(sema);
511 else
512 OSDEP_DBG("Not implement osdep service: rtw_free_sema");
513 }
514
515
516 #if defined(__GNUC__)
517 #include <cmsis.h>
518 #endif
519
rtw_in_interrupt(void)520 int rtw_in_interrupt(void)
521 {
522 #if defined(__ICCARM__)
523 return (__get_PSR()&0x1FF)!=0;
524 #elif defined(__GNUC__)
525 return (__get_xPSR()&0x1FF)!=0;
526 #endif
527 }
528
529
rtw_up_sema(_sema * sema)530 void rtw_up_sema(_sema *sema)
531 {
532 if(rtw_in_interrupt()){
533 if(osdep_service.rtw_up_sema_from_isr)
534 osdep_service.rtw_up_sema_from_isr(sema);
535 else
536 OSDEP_DBG("Not implement osdep service: rtw_up_sema_from_isr");
537 }else{
538 if(osdep_service.rtw_up_sema)
539 osdep_service.rtw_up_sema(sema);
540 else
541 OSDEP_DBG("Not implement osdep service: rtw_up_sema");
542 }
543 }
544
rtw_up_sema_from_isr(_sema * sema)545 void rtw_up_sema_from_isr(_sema *sema)
546 {
547 if(osdep_service.rtw_up_sema_from_isr)
548 osdep_service.rtw_up_sema_from_isr(sema);
549 else
550 OSDEP_DBG("Not implement osdep service: rtw_up_sema_from_isr");
551 }
552
rtw_down_timeout_sema(_sema * sema,u32 timeout)553 u32 rtw_down_timeout_sema(_sema *sema, u32 timeout)
554 {
555 if(osdep_service.rtw_down_timeout_sema)
556 return osdep_service.rtw_down_timeout_sema(sema, timeout);
557 else
558 OSDEP_DBG("Not implement osdep service: rtw_down_timeout_sema");
559
560 return _FAIL;
561 }
562
rtw_down_sema(_sema * sema)563 u32 rtw_down_sema(_sema *sema)
564 {
565 while(rtw_down_timeout_sema(sema, RTW_MAX_DELAY) != _TRUE)
566 // rom_e_rtw_msg_871X_LEVEL(DOWN_SEMA_1, _drv_always_, "%s(%p) failed, retry\n", __FUNCTION__, sema);
567 //OSDEP_DBG_LEVEL(_drv_always_, "%s(%p) failed, retry\n", __FUNCTION__, sema);
568 OSDEP_DBG("%s(%p) failed, retry\n", __FUNCTION__, sema);
569 return _TRUE;
570 }
571
rtw_mutex_init(_mutex * pmutex)572 void rtw_mutex_init(_mutex *pmutex)
573 {
574 if(osdep_service.rtw_mutex_init)
575 osdep_service.rtw_mutex_init(pmutex);
576 else
577 OSDEP_DBG("Not implement osdep service: rtw_mutex_init");
578 }
579
rtw_mutex_free(_mutex * pmutex)580 void rtw_mutex_free(_mutex *pmutex)
581 {
582 if(osdep_service.rtw_mutex_free)
583 osdep_service.rtw_mutex_free(pmutex);
584 else
585 OSDEP_DBG("Not implement osdep service: rtw_mutex_free");
586 }
587
rtw_mutex_put(_mutex * pmutex)588 void rtw_mutex_put(_mutex *pmutex)
589 {
590 if(osdep_service.rtw_mutex_put)
591 osdep_service.rtw_mutex_put(pmutex);
592 else
593 OSDEP_DBG("Not implement osdep service: rtw_mutex_put");
594 }
595
rtw_mutex_get(_mutex * pmutex)596 void rtw_mutex_get(_mutex *pmutex)
597 {
598 if(osdep_service.rtw_mutex_get)
599 osdep_service.rtw_mutex_get(pmutex);
600 else
601 OSDEP_DBG("Not implement osdep service: rtw_mutex_get");
602 }
603
rtw_mutex_get_timeout(_mutex * pmutex,u32 timeout_ms)604 int rtw_mutex_get_timeout(_mutex *pmutex, u32 timeout_ms)
605 {
606 if(osdep_service.rtw_mutex_get_timeout)
607 return osdep_service.rtw_mutex_get_timeout(pmutex, timeout_ms);
608 else{
609 OSDEP_DBG("Not implement osdep service: rtw_mutex_get_timeout");
610 return -1;
611 }
612 }
613
rtw_enter_critical(_lock * plock,_irqL * pirqL)614 void rtw_enter_critical(_lock *plock, _irqL *pirqL)
615 {
616 if(rtw_in_interrupt()){
617 if(osdep_service.rtw_enter_critical_from_isr)
618 osdep_service.rtw_enter_critical_from_isr(plock, pirqL);
619 else
620 OSDEP_DBG("Not implement osdep service: rtw_enter_critical_from_isr");
621 }else{
622 if(osdep_service.rtw_enter_critical)
623 osdep_service.rtw_enter_critical(plock, pirqL);
624 else
625 OSDEP_DBG("Not implement osdep service: rtw_enter_critical");
626 }
627 }
628
rtw_exit_critical(_lock * plock,_irqL * pirqL)629 void rtw_exit_critical(_lock *plock, _irqL *pirqL)
630 {
631 if(rtw_in_interrupt()){
632 if(osdep_service.rtw_exit_critical_from_isr)
633 osdep_service.rtw_exit_critical_from_isr(plock, pirqL);
634 else
635 OSDEP_DBG("Not implement osdep service: rtw_exit_critical_from_isr");
636 }else{
637 if(osdep_service.rtw_exit_critical)
638 osdep_service.rtw_exit_critical(plock, pirqL);
639 else
640 OSDEP_DBG("Not implement osdep service: rtw_exit_critical");
641 }
642 }
643
rtw_enter_critical_from_isr(_lock * plock,_irqL * pirqL)644 void rtw_enter_critical_from_isr(_lock *plock, _irqL *pirqL)
645 {
646 if(osdep_service.rtw_enter_critical)
647 osdep_service.rtw_enter_critical(plock, pirqL);
648 else
649 OSDEP_DBG("Not implement osdep service: rtw_enter_critical_from_isr");
650 }
651
rtw_exit_critical_from_isr(_lock * plock,_irqL * pirqL)652 void rtw_exit_critical_from_isr(_lock *plock, _irqL *pirqL)
653 {
654 if(osdep_service.rtw_exit_critical)
655 osdep_service.rtw_exit_critical(plock, pirqL);
656 else
657 OSDEP_DBG("Not implement osdep service: rtw_exit_critical_from_isr");
658 }
659
rtw_enter_critical_bh(_lock * plock,_irqL * pirqL)660 void rtw_enter_critical_bh(_lock *plock, _irqL *pirqL)
661 {
662 /* To avoid gcc warnings */
663 ( void ) pirqL;
664 rtw_spin_lock(plock);
665 }
666
rtw_exit_critical_bh(_lock * plock,_irqL * pirqL)667 void rtw_exit_critical_bh(_lock *plock, _irqL *pirqL)
668 {
669 /* To avoid gcc warnings */
670 ( void ) pirqL;
671
672 rtw_spin_unlock(plock);
673 }
674
rtw_enter_critical_mutex(_mutex * pmutex,_irqL * pirqL)675 int rtw_enter_critical_mutex(_mutex *pmutex, _irqL *pirqL)
676 {
677 if(osdep_service.rtw_enter_critical_mutex)
678 return osdep_service.rtw_enter_critical_mutex(pmutex, pirqL);
679 else
680 OSDEP_DBG("Not implement osdep service: rtw_enter_critical_mutex");
681
682 return 0;
683 }
684
rtw_exit_critical_mutex(_mutex * pmutex,_irqL * pirqL)685 void rtw_exit_critical_mutex(_mutex *pmutex, _irqL *pirqL)
686 {
687 if(osdep_service.rtw_exit_critical_mutex)
688 osdep_service.rtw_exit_critical_mutex(pmutex, pirqL);
689 else
690 OSDEP_DBG("Not implement osdep service: rtw_exit_critical_mutex");
691 }
692
693 #if 0
694 void rtw_cpu_lock(void)
695 {
696 if(osdep_service.rtw_cpu_lock)
697 osdep_service.rtw_cpu_lock();
698 else
699 OSDEP_DBG("Not implement osdep service: rtw_cpu_lock");
700 }
701
702 void rtw_cpu_unlock(void)
703 {
704 if(osdep_service.rtw_cpu_unlock)
705 osdep_service.rtw_cpu_unlock();
706 else
707 OSDEP_DBG("Not implement osdep service: rtw_cpu_unlock");
708 }
709 #endif
rtw_init_queue(_queue * pqueue)710 void rtw_init_queue(_queue *pqueue)
711 {
712 rtw_init_listhead(&(pqueue->queue));
713 rtw_spinlock_init(&(pqueue->lock));
714 }
715
rtw_queue_empty(_queue * pqueue)716 u32 rtw_queue_empty(_queue *pqueue)
717 {
718 return (rtw_is_list_empty(&(pqueue->queue)));
719 }
720
721
rtw_end_of_queue_search(_list * head,_list * plist)722 u32 rtw_end_of_queue_search(_list *head, _list *plist)
723 {
724 if (head == plist)
725 return _TRUE;
726 else
727 return _FALSE;
728 }
729
730 #if 1
rtw_spinlock_init(_lock * plock)731 void rtw_spinlock_init(_lock *plock)
732 {
733 if(osdep_service.rtw_spinlock_init)
734 osdep_service.rtw_spinlock_init(plock);
735 else
736 OSDEP_DBG("Not implement osdep service: rtw_spinlock_init");
737 }
738
rtw_spinlock_free(_lock * plock)739 void rtw_spinlock_free(_lock *plock)
740 {
741 if(osdep_service.rtw_spinlock_free)
742 osdep_service.rtw_spinlock_free(plock);
743 else
744 OSDEP_DBG("Not implement osdep service: rtw_spinlock_free");
745 }
746
rtw_spin_lock(_lock * plock)747 void rtw_spin_lock(_lock *plock)
748 {
749 if(osdep_service.rtw_spin_lock)
750 osdep_service.rtw_spin_lock(plock);
751 else
752 OSDEP_DBG("Not implement osdep service: rtw_spin_lock");
753 }
754
rtw_spin_unlock(_lock * plock)755 void rtw_spin_unlock(_lock *plock)
756 {
757 if(osdep_service.rtw_spin_unlock)
758 osdep_service.rtw_spin_unlock(plock);
759 else
760 OSDEP_DBG("Not implement osdep service: rtw_spin_unlock");
761 }
762
rtw_spinlock_irqsave(_lock * plock,_irqL * irqL)763 void rtw_spinlock_irqsave(_lock *plock, _irqL *irqL)
764 {
765 if(osdep_service.rtw_spinlock_irqsave)
766 osdep_service.rtw_spinlock_irqsave(plock, irqL);
767 else
768 OSDEP_DBG("Not implement osdep service: rtw_spinlock_irqsave");
769 }
770
rtw_spinunlock_irqsave(_lock * plock,_irqL * irqL)771 void rtw_spinunlock_irqsave(_lock *plock, _irqL *irqL)
772 {
773 if(osdep_service.rtw_spinunlock_irqsave)
774 osdep_service.rtw_spinunlock_irqsave(plock, irqL);
775 else
776 OSDEP_DBG("Not implement osdep service: rtw_spinunlock_irqsave");
777 }
778 #endif
779
rtw_init_xqueue(_xqueue * queue,const char * name,u32 message_size,u32 number_of_messages)780 int rtw_init_xqueue( _xqueue* queue, const char* name, u32 message_size, u32 number_of_messages )
781 {
782 if(osdep_service.rtw_init_xqueue)
783 return (int)osdep_service.rtw_init_xqueue(queue, name, message_size, number_of_messages);
784 else
785 OSDEP_DBG("Not implement osdep service: rtw_init_xqueue");
786
787 return FAIL;
788 }
789
rtw_push_to_xqueue(_xqueue * queue,void * message,u32 timeout_ms)790 int rtw_push_to_xqueue( _xqueue* queue, void* message, u32 timeout_ms )
791 {
792 if(osdep_service.rtw_push_to_xqueue)
793 return (int)osdep_service.rtw_push_to_xqueue(queue, message, timeout_ms);
794 else
795 OSDEP_DBG("Not implement osdep service: rtw_push_to_xqueue");
796
797 return FAIL;
798 }
799
rtw_pop_from_xqueue(_xqueue * queue,void * message,u32 timeout_ms)800 int rtw_pop_from_xqueue( _xqueue* queue, void* message, u32 timeout_ms )
801 {
802 if(osdep_service.rtw_pop_from_xqueue)
803 return (int)osdep_service.rtw_pop_from_xqueue(queue, message, timeout_ms);
804 else
805 OSDEP_DBG("Not implement osdep service: rtw_pop_from_xqueue");
806
807 return FAIL;
808 }
809
rtw_deinit_xqueue(_xqueue * queue)810 int rtw_deinit_xqueue( _xqueue* queue )
811 {
812 if(osdep_service.rtw_deinit_xqueue)
813 return (int)osdep_service.rtw_deinit_xqueue(queue);
814 else
815 OSDEP_DBG("Not implement osdep service: rtw_deinit_xqueue");
816
817 return FAIL;
818 }
819
820 #if 0
821 void rtw_init_queue(_queue *pqueue)
822 {
823 rtw_init_listhead(&(pqueue->queue));
824 rtw_mutex_init(&(pqueue->lock));
825 }
826
827 void rtw_deinit_queue(_queue *pqueue)
828 {
829 rtw_mutex_free(&(pqueue->lock));
830 }
831
832 u32 rtw_is_queue_empty(_queue *pqueue)
833 {
834 return (rtw_is_list_empty(&(pqueue->queue)));
835 }
836
837 u32 rtw_end_of_queue_search(_list *head, _list *plist)
838 {
839 if (head == plist)
840 return _TRUE;
841
842 return _FALSE;
843 }
844
845 _list *rtw_get_queue_head(_queue *queue)
846 {
847 return (&(queue->queue));
848 }
849 #endif
850
rtw_get_current_time(void)851 u32 rtw_get_current_time(void)
852 {
853 if(osdep_service.rtw_get_current_time)
854 return osdep_service.rtw_get_current_time();
855 else
856 OSDEP_DBG("Not implement osdep service: rtw_get_current_time");
857
858 return 0;
859 }
860
rtw_systime_to_ms(u32 systime)861 u32 rtw_systime_to_ms(u32 systime)
862 {
863 if(osdep_service.rtw_systime_to_ms)
864 return osdep_service.rtw_systime_to_ms(systime);
865 else
866 OSDEP_DBG("Not implement osdep service: rtw_systime_to_ms");
867
868 return 0;
869 }
870
rtw_systime_to_sec(u32 systime)871 u32 rtw_systime_to_sec(u32 systime)
872 {
873 if(osdep_service.rtw_systime_to_sec)
874 return osdep_service.rtw_systime_to_sec(systime);
875 else
876 OSDEP_DBG("Not implement osdep service: rtw_systime_to_sec");
877
878 return 0;
879 }
880
rtw_ms_to_systime(u32 ms)881 u32 rtw_ms_to_systime(u32 ms)
882 {
883 if(osdep_service.rtw_ms_to_systime)
884 return osdep_service.rtw_ms_to_systime(ms);
885 else
886 OSDEP_DBG("Not implement osdep service: rtw_ms_to_systime");
887
888 return 0;
889 }
890
rtw_sec_to_systime(u32 sec)891 u32 rtw_sec_to_systime(u32 sec)
892 {
893 if(osdep_service.rtw_sec_to_systime)
894 return osdep_service.rtw_sec_to_systime(sec);
895 else
896 OSDEP_DBG("Not implement osdep service: rtw_sec_to_systime");
897
898 return 0;
899 }
900
901 // the input parameter start use the same unit as returned by rtw_get_current_time
rtw_get_passing_time_ms(u32 start)902 s32 rtw_get_passing_time_ms(u32 start)
903 {
904 return rtw_systime_to_ms(rtw_get_current_time() - start);
905 }
906
rtw_get_time_interval_ms(u32 start,u32 end)907 s32 rtw_get_time_interval_ms(u32 start, u32 end)
908 {
909 return rtw_systime_to_ms(end - start);
910 }
911
rtw_msleep_os(int ms)912 void rtw_msleep_os(int ms)
913 {
914 if(osdep_service.rtw_msleep_os)
915 osdep_service.rtw_msleep_os(ms);
916 else
917 OSDEP_DBG("Not implement osdep service: rtw_msleep_os");
918 }
919
rtw_usleep_os(int us)920 void rtw_usleep_os(int us)
921 {
922 if(osdep_service.rtw_usleep_os)
923 osdep_service.rtw_usleep_os(us);
924 else
925 OSDEP_DBG("Not implement osdep service: rtw_usleep_os");
926 }
927
rtw_mdelay_os(int ms)928 void rtw_mdelay_os(int ms)
929 {
930 if(osdep_service.rtw_mdelay_os)
931 osdep_service.rtw_mdelay_os(ms);
932 else
933 OSDEP_DBG("Not implement osdep service: rtw_mdelay_os");
934 }
935
rtw_udelay_os(int us)936 void rtw_udelay_os(int us)
937 {
938 if(osdep_service.rtw_udelay_os)
939 osdep_service.rtw_udelay_os(us);
940 else
941 OSDEP_DBG("Not implement osdep service: rtw_udelay_os");
942 }
943
rtw_yield_os(void)944 void rtw_yield_os(void)
945 {
946 if(osdep_service.rtw_yield_os)
947 osdep_service.rtw_yield_os();
948 else
949 OSDEP_DBG("Not implement osdep service: rtw_yield_os");
950 }
951
ATOMIC_SET(ATOMIC_T * v,int i)952 void ATOMIC_SET(ATOMIC_T *v, int i)
953 {
954 if(osdep_service.ATOMIC_SET)
955 osdep_service.ATOMIC_SET(v, i);
956 else
957 OSDEP_DBG("Not implement osdep service: ATOMIC_SET");
958 }
959
ATOMIC_READ(ATOMIC_T * v)960 int ATOMIC_READ(ATOMIC_T *v)
961 {
962 if(osdep_service.ATOMIC_READ)
963 return osdep_service.ATOMIC_READ(v);
964 else
965 OSDEP_DBG("Not implement osdep service: ATOMIC_READ");
966
967 return 0;
968 }
969
ATOMIC_ADD(ATOMIC_T * v,int i)970 void ATOMIC_ADD(ATOMIC_T *v, int i)
971 {
972 if(osdep_service.ATOMIC_ADD)
973 osdep_service.ATOMIC_ADD(v, i);
974 else
975 OSDEP_DBG("Not implement osdep service: ATOMIC_ADD");
976 }
977
ATOMIC_SUB(ATOMIC_T * v,int i)978 void ATOMIC_SUB(ATOMIC_T *v, int i)
979 {
980 if(osdep_service.ATOMIC_SUB)
981 osdep_service.ATOMIC_SUB(v, i);
982 else
983 OSDEP_DBG("Not implement osdep service: ATOMIC_SUB");
984 }
985
ATOMIC_INC(ATOMIC_T * v)986 void ATOMIC_INC(ATOMIC_T *v)
987 {
988 if(osdep_service.ATOMIC_INC)
989 osdep_service.ATOMIC_INC(v);
990 else
991 OSDEP_DBG("Not implement osdep service: ATOMIC_INC");
992 }
993
ATOMIC_DEC(ATOMIC_T * v)994 void ATOMIC_DEC(ATOMIC_T *v)
995 {
996 if(osdep_service.ATOMIC_DEC)
997 osdep_service.ATOMIC_DEC(v);
998 else
999 OSDEP_DBG("Not implement osdep service: ATOMIC_DEC");
1000 }
1001
ATOMIC_ADD_RETURN(ATOMIC_T * v,int i)1002 int ATOMIC_ADD_RETURN(ATOMIC_T *v, int i)
1003 {
1004 if(osdep_service.ATOMIC_ADD_RETURN)
1005 return osdep_service.ATOMIC_ADD_RETURN(v, i);
1006 else
1007 OSDEP_DBG("Not implement osdep service: ATOMIC_ADD_RETURN");
1008
1009 return 0;
1010 }
1011
ATOMIC_SUB_RETURN(ATOMIC_T * v,int i)1012 int ATOMIC_SUB_RETURN(ATOMIC_T *v, int i)
1013 {
1014 if(osdep_service.ATOMIC_SUB_RETURN)
1015 return osdep_service.ATOMIC_SUB_RETURN(v, i);
1016 else
1017 OSDEP_DBG("Not implement osdep service: ATOMIC_SUB_RETURN");
1018
1019 return 0;
1020 }
1021
ATOMIC_INC_RETURN(ATOMIC_T * v)1022 int ATOMIC_INC_RETURN(ATOMIC_T *v)
1023 {
1024 if(osdep_service.ATOMIC_INC_RETURN)
1025 return osdep_service.ATOMIC_INC_RETURN(v);
1026 else
1027 OSDEP_DBG("Not implement osdep service: ATOMIC_INC_RETURN");
1028
1029 return 0;
1030 }
1031
ATOMIC_DEC_RETURN(ATOMIC_T * v)1032 int ATOMIC_DEC_RETURN(ATOMIC_T *v)
1033 {
1034 if(osdep_service.ATOMIC_DEC_RETURN)
1035 return osdep_service.ATOMIC_DEC_RETURN(v);
1036 else
1037 OSDEP_DBG("Not implement osdep service: ATOMIC_DEC_RETURN");
1038
1039 return 0;
1040 }
1041
ATOMIC_DEC_AND_TEST(ATOMIC_T * v)1042 int ATOMIC_DEC_AND_TEST(ATOMIC_T *v)
1043 {
1044 return ATOMIC_DEC_RETURN(v) == 0;
1045 }
1046
rtw_modular64(u64 x,u64 y)1047 u64 rtw_modular64(u64 x, u64 y)
1048 {
1049 if(osdep_service.rtw_modular64)
1050 return osdep_service.rtw_modular64(x, y);
1051 else
1052 OSDEP_DBG("Not implement osdep service: rtw_modular64");
1053
1054 return 0;
1055 }
1056
rtw_get_random_bytes(void * dst,u32 size)1057 int rtw_get_random_bytes(void* dst, u32 size)
1058 {
1059 if(osdep_service.rtw_get_random_bytes)
1060 return osdep_service.rtw_get_random_bytes(dst, size);
1061 else
1062 OSDEP_DBG("Not implement osdep service: rtw_get_random_bytes");
1063
1064 return 0;
1065 }
1066
rtw_getFreeHeapSize(void)1067 u32 rtw_getFreeHeapSize(void)
1068 {
1069 if(osdep_service.rtw_getFreeHeapSize)
1070 return osdep_service.rtw_getFreeHeapSize();
1071 else
1072 OSDEP_DBG("Not implement osdep service: rtw_getFreeHeapSize");
1073
1074 return 0;
1075 }
1076
rtw_netif_queue_stopped(void * pnetdev)1077 int rtw_netif_queue_stopped(void *pnetdev)
1078 {
1079 /* To avoid gcc warnings */
1080 ( void ) pnetdev;
1081
1082 return 0;
1083 }
1084
rtw_netif_wake_queue(void * pnetdev)1085 void rtw_netif_wake_queue(void *pnetdev)
1086 {
1087 /* To avoid gcc warnings */
1088 ( void ) pnetdev;
1089 }
1090
rtw_netif_start_queue(void * pnetdev)1091 void rtw_netif_start_queue(void *pnetdev)
1092 {
1093 /* To avoid gcc warnings */
1094 ( void ) pnetdev;
1095 }
1096
rtw_netif_stop_queue(void * pnetdev)1097 void rtw_netif_stop_queue(void *pnetdev)
1098 {
1099 /* To avoid gcc warnings */
1100 ( void ) pnetdev;
1101 }
1102
flush_signals_thread(void)1103 void flush_signals_thread(void)
1104 {
1105 }
1106
rtw_acquire_wakelock(void)1107 void rtw_acquire_wakelock(void)
1108 {
1109 if (osdep_service.rtw_acquire_wakelock)
1110 osdep_service.rtw_acquire_wakelock();
1111 else
1112 OSDEP_DBG("Not implement osdep service: rtw_acquire_wakelock");
1113 }
1114
rtw_release_wakelock(void)1115 void rtw_release_wakelock(void)
1116 {
1117 if (osdep_service.rtw_release_wakelock)
1118 osdep_service.rtw_release_wakelock();
1119 else
1120 OSDEP_DBG("Not implement osdep service: rtw_release_wakelock");
1121 }
1122
rtw_wakelock_timeout(u32 timeoutms)1123 void rtw_wakelock_timeout(u32 timeoutms)
1124 {
1125 if (osdep_service.rtw_wakelock_timeout)
1126 osdep_service.rtw_wakelock_timeout(timeoutms);
1127 else
1128 OSDEP_DBG("Not implement osdep service: rtw_wakelock_timeout");
1129 }
1130
rtw_create_task(struct task_struct * task,const char * name,u32 stack_size,u32 priority,thread_func_t func,void * thctx)1131 int rtw_create_task(struct task_struct *task, const char *name,
1132 u32 stack_size, u32 priority, thread_func_t func, void *thctx)
1133 {
1134 if(osdep_service.rtw_create_task)
1135 return osdep_service.rtw_create_task(task, name, stack_size, priority, func, thctx);
1136 else
1137 OSDEP_DBG("Not implement osdep service: rtw_create_task");
1138 return 1;
1139 }
rtw_delete_task(struct task_struct * task)1140 void rtw_delete_task(struct task_struct *task)
1141 {
1142 if(osdep_service.rtw_delete_task)
1143 osdep_service.rtw_delete_task(task);
1144 else
1145 OSDEP_DBG("Not implement osdep service: rtw_delete_task");
1146
1147 return;
1148 }
rtw_wakeup_task(struct task_struct * task)1149 void rtw_wakeup_task(struct task_struct *task)
1150 {
1151 if(osdep_service.rtw_wakeup_task)
1152 osdep_service.rtw_wakeup_task(task);
1153 else
1154 OSDEP_DBG("Not implement osdep service: rtw_wakeup_task");
1155
1156 return;
1157 }
1158
rtw_set_priority_task(void * task,u32 NewPriority)1159 void rtw_set_priority_task(void* task, u32 NewPriority)
1160 {
1161 if(osdep_service.rtw_set_priority_task)
1162 osdep_service.rtw_set_priority_task(task,NewPriority);
1163 else
1164 OSDEP_DBG("Not implement osdep service: rtw_set_priority_task");
1165
1166 return;
1167 }
1168
rtw_get_priority_task(void * task)1169 int rtw_get_priority_task(void* task)
1170 {
1171 if(osdep_service.rtw_get_priority_task)
1172 return osdep_service.rtw_get_priority_task(task);
1173 else
1174 OSDEP_DBG("Not implement osdep service: rtw_get_priority_task");
1175
1176 return -1;
1177 }
rtw_suspend_task(void * task)1178 void rtw_suspend_task(void * task)
1179 {
1180 if(osdep_service.rtw_suspend_task)
1181 osdep_service.rtw_suspend_task(task);
1182 else
1183 OSDEP_DBG("Not implement osdep service: rtw_suspend_task");
1184
1185 return;
1186 }
1187
rtw_resume_task(void * task)1188 void rtw_resume_task(void * task)
1189 {
1190 if(osdep_service.rtw_resume_task)
1191 osdep_service.rtw_resume_task(task);
1192 else
1193 OSDEP_DBG("Not implement osdep service: rtw_resume_task");
1194
1195 return;
1196 }
1197
worker_thread_main(void * arg)1198 static void worker_thread_main( void *arg )
1199 {
1200 rtw_worker_thread_t* worker_thread = (rtw_worker_thread_t*) arg;
1201
1202 while ( 1 )
1203 {
1204 rtw_event_message_t message;
1205
1206 if ( rtw_pop_from_xqueue( &worker_thread->event_queue, &message, RTW_WAIT_FOREVER ) == SUCCESS )
1207 {
1208 message.function(message.buf, message.buf_len, message.flags, message.user_data);
1209 if(message.buf){
1210 //printf("\n!!!!!Free %p(%d)\n", message.buf, message.buf_len);
1211 _rtw_mfree((u8 *)message.buf, message.buf_len);
1212 }
1213 }
1214 }
1215 }
1216
rtw_create_worker_thread(rtw_worker_thread_t * worker_thread,u8 priority,u32 stack_size,u32 event_queue_size)1217 int rtw_create_worker_thread( rtw_worker_thread_t* worker_thread, u8 priority, u32 stack_size, u32 event_queue_size )
1218 {
1219 if(NULL == worker_thread)
1220 return FAIL;
1221
1222 memset( worker_thread, 0, sizeof( *worker_thread ) );
1223
1224 if ( rtw_init_xqueue( &worker_thread->event_queue, "worker queue", sizeof(rtw_event_message_t), event_queue_size ) != SUCCESS )
1225 {
1226 return FAIL;
1227 }
1228
1229 if ( !rtw_create_task( &worker_thread->thread, "worker thread", stack_size, priority, (thread_func_t)worker_thread_main, (void*) worker_thread ) )
1230 {
1231 rtw_deinit_xqueue( &worker_thread->event_queue );
1232 return FAIL;
1233 }
1234
1235 return SUCCESS;
1236 }
1237
rtw_delete_worker_thread(rtw_worker_thread_t * worker_thread)1238 int rtw_delete_worker_thread( rtw_worker_thread_t* worker_thread )
1239 {
1240 if(NULL == worker_thread)
1241 return FAIL;
1242
1243 rtw_deinit_xqueue( &worker_thread->event_queue );
1244
1245 rtw_delete_task(&worker_thread->thread);
1246
1247 return SUCCESS;
1248 }
1249
rtw_timerCreate(const signed char * pcTimerName,osdepTickType xTimerPeriodInTicks,u32 uxAutoReload,void * pvTimerID,TIMER_FUN pxCallbackFunction)1250 _timerHandle rtw_timerCreate( const signed char *pcTimerName,
1251 osdepTickType xTimerPeriodInTicks,
1252 u32 uxAutoReload,
1253 void * pvTimerID,
1254 TIMER_FUN pxCallbackFunction )
1255 {
1256 if(osdep_service.rtw_timerCreate)
1257 return osdep_service.rtw_timerCreate(pcTimerName, xTimerPeriodInTicks, uxAutoReload,
1258 pvTimerID, pxCallbackFunction);
1259 else
1260 OSDEP_DBG("Not implement osdep service: rtw_timerCreate");
1261
1262 return 0;
1263 }
1264
rtw_timerDelete(_timerHandle xTimer,osdepTickType xBlockTime)1265 u32 rtw_timerDelete( _timerHandle xTimer,
1266 osdepTickType xBlockTime )
1267 {
1268 if(osdep_service.rtw_timerDelete)
1269 return osdep_service.rtw_timerDelete( xTimer, xBlockTime );
1270 else
1271 OSDEP_DBG("Not implement osdep service: rtw_timerDelete");
1272
1273 return 0;
1274 }
1275
rtw_timerIsTimerActive(_timerHandle xTimer)1276 u32 rtw_timerIsTimerActive( _timerHandle xTimer )
1277 {
1278 if(osdep_service.rtw_timerIsTimerActive)
1279 return osdep_service.rtw_timerIsTimerActive(xTimer);
1280 else
1281 OSDEP_DBG("Not implement osdep service: rtw_timerIsTimerActive");
1282
1283 return 0;
1284 }
1285
rtw_timerStop(_timerHandle xTimer,osdepTickType xBlockTime)1286 u32 rtw_timerStop( _timerHandle xTimer,
1287 osdepTickType xBlockTime )
1288 {
1289 if(osdep_service.rtw_timerStop)
1290 return osdep_service.rtw_timerStop(xTimer, xBlockTime);
1291 else
1292 OSDEP_DBG("Not implement osdep service: rtw_timerStop");
1293
1294 return 0;
1295 }
1296
rtw_timerChangePeriod(_timerHandle xTimer,osdepTickType xNewPeriod,osdepTickType xBlockTime)1297 u32 rtw_timerChangePeriod( _timerHandle xTimer,
1298 osdepTickType xNewPeriod,
1299 osdepTickType xBlockTime )
1300 {
1301 if(osdep_service.rtw_timerChangePeriod)
1302 return osdep_service.rtw_timerChangePeriod(xTimer, xNewPeriod, xBlockTime);
1303 else
1304 OSDEP_DBG("Not implement osdep service: rtw_timerChangePeriod");
1305
1306 return 0;
1307 }
1308
rtw_timerGetID(_timerHandle xTimer)1309 void *rtw_timerGetID( _timerHandle xTimer )
1310 {
1311 if(osdep_service.rtw_timerGetID)
1312 return osdep_service.rtw_timerGetID(xTimer);
1313 else
1314 OSDEP_DBG("Not implement osdep service: rtw_timerGetID");
1315
1316 return NULL;
1317 }
1318
rtw_timerStart(_timerHandle xTimer,osdepTickType xBlockTime)1319 u32 rtw_timerStart( _timerHandle xTimer, osdepTickType xBlockTime )
1320 {
1321 if(osdep_service.rtw_timerStart)
1322 return osdep_service.rtw_timerStart(xTimer, xBlockTime);
1323 else
1324 OSDEP_DBG("Not implement osdep service: rtw_timerStart");
1325
1326 return 0;
1327 }
1328
rtw_timerStartFromISR(_timerHandle xTimer,osdepBASE_TYPE * pxHigherPriorityTaskWoken)1329 u32 rtw_timerStartFromISR( _timerHandle xTimer,
1330 osdepBASE_TYPE *pxHigherPriorityTaskWoken )
1331 {
1332 if(osdep_service.rtw_timerStartFromISR)
1333 return osdep_service.rtw_timerStartFromISR(xTimer, pxHigherPriorityTaskWoken);
1334 else
1335 OSDEP_DBG("Not implement osdep service: rtw_timerStartFromISR");
1336
1337 return 0;
1338 }
1339
rtw_timerStopFromISR(_timerHandle xTimer,osdepBASE_TYPE * pxHigherPriorityTaskWoken)1340 u32 rtw_timerStopFromISR( _timerHandle xTimer,
1341 osdepBASE_TYPE *pxHigherPriorityTaskWoken )
1342 {
1343 if(osdep_service.rtw_timerStopFromISR)
1344 return osdep_service.rtw_timerStopFromISR(xTimer, pxHigherPriorityTaskWoken);
1345 else
1346 OSDEP_DBG("Not implement osdep service: rtw_timerStopFromISR");
1347
1348 return 0;
1349 }
1350
rtw_timerResetFromISR(_timerHandle xTimer,osdepBASE_TYPE * pxHigherPriorityTaskWoken)1351 u32 rtw_timerResetFromISR( _timerHandle xTimer,
1352 osdepBASE_TYPE *pxHigherPriorityTaskWoken )
1353 {
1354 if(osdep_service.rtw_timerResetFromISR)
1355 return osdep_service.rtw_timerResetFromISR(xTimer, pxHigherPriorityTaskWoken);
1356 else
1357 OSDEP_DBG("Not implement osdep service: rtw_timerResetFromISR");
1358
1359 return 0;
1360 }
1361
rtw_timerChangePeriodFromISR(_timerHandle xTimer,osdepTickType xNewPeriod,osdepBASE_TYPE * pxHigherPriorityTaskWoken)1362 u32 rtw_timerChangePeriodFromISR( _timerHandle xTimer,
1363 osdepTickType xNewPeriod,
1364 osdepBASE_TYPE *pxHigherPriorityTaskWoken )
1365 {
1366 if(osdep_service.rtw_timerChangePeriodFromISR)
1367 return osdep_service.rtw_timerChangePeriodFromISR(xTimer, xNewPeriod, pxHigherPriorityTaskWoken);
1368 else
1369 OSDEP_DBG("Not implement osdep service: rtw_timerChangePeriodFromISR");
1370
1371 return 0;
1372 }
1373
rtw_timerReset(_timerHandle xTimer,osdepTickType xBlockTime)1374 u32 rtw_timerReset( _timerHandle xTimer,
1375 osdepTickType xBlockTime )
1376 {
1377 if(osdep_service.rtw_timerReset)
1378 return osdep_service.rtw_timerReset(xTimer, xBlockTime);
1379 else
1380 OSDEP_DBG("Not implement osdep service: rtw_timerReset");
1381
1382 return 0;
1383 }
1384
1385
1386 #if 0 //TODO
1387 void rtw_init_delayed_work(struct delayed_work *dwork, work_func_t func, const char *name)
1388 {
1389 if(osdep_service.rtw_init_delayed_work)
1390 osdep_service.rtw_init_delayed_work(dwork, func, name);
1391 else
1392 OSDEP_DBG("Not implement osdep service: rtw_init_delayed_work");
1393
1394 return;
1395 }
1396
1397 void rtw_deinit_delayed_work(struct delayed_work *dwork)
1398 {
1399 if(osdep_service.rtw_deinit_delayed_work)
1400 osdep_service.rtw_deinit_delayed_work(dwork);
1401 else
1402 OSDEP_DBG("Not implement osdep service: rtw_deinit_delayed_work");
1403
1404 return;
1405 }
1406
1407 int rtw_queue_delayed_work(struct workqueue_struct *wq,
1408 struct delayed_work *dwork, u32 delay, void* context)
1409 {
1410 if(osdep_service.rtw_queue_delayed_work)
1411 osdep_service.rtw_queue_delayed_work(wq, dwork, delay, context);
1412 else
1413 OSDEP_DBG("Not implement osdep service: rtw_queue_delayed_work");
1414
1415 return;
1416 }
1417
1418 BOOLEAN rtw_cancel_delayed_work(struct delayed_work *dwork)
1419 {
1420 if(osdep_service.rtw_cancel_delayed_work)
1421 osdep_service.rtw_cancel_delayed_work(dwork);
1422 else
1423 OSDEP_DBG("Not implement osdep service: rtw_cancel_delayed_work");
1424
1425 return;
1426 }
1427 #endif
rtw_thread_enter(char * name)1428 void rtw_thread_enter(char *name)
1429 {
1430 if(osdep_service.rtw_thread_enter)
1431 osdep_service.rtw_thread_enter(name);
1432 else
1433 OSDEP_DBG("Not implement osdep service: rtw_thread_enter");
1434 }
1435
rtw_thread_exit()1436 void rtw_thread_exit()
1437 {
1438 if(osdep_service.rtw_thread_exit)
1439 osdep_service.rtw_thread_exit();
1440 else
1441 OSDEP_DBG("Not implement osdep service: rtw_thread_exit");
1442 }
1443
rtw_get_scheduler_state()1444 u8 rtw_get_scheduler_state()
1445 {
1446 // OS_SCHEDULER_NOT_STARTED 0
1447 // OS_SCHEDULER_RUNNING 1
1448 // OS_SCHEDULER_SUSPENDED 2
1449 // OS_SCHEDULER_UNREACHABLE 3
1450 if(osdep_service.rtw_get_scheduler_state)
1451 return osdep_service.rtw_get_scheduler_state();
1452 else{
1453 OSDEP_DBG("Not implement osdep service: rtw_get_scheduler_state");
1454 return 3;
1455 }
1456 }
1457