1 /*
2 // Copyright (C) 2022 Beken Corporation
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <common/bk_include.h>
17 #include <os/os.h>
18 #include "los_config.h"
19 #include "los_context.h"
20 #include "los_task.h"
21 #include "los_queue.h"
22 #include "los_sem.h"
23 #include "los_mux.h"
24 #include "los_memory.h"
25 #include "los_interrupt.h"
26 #include "los_swtmr.h"
27 #include "los_timer.h"
28 #include "portmacro.h"
29
30 /* OS_TASK_PRIORITY_HIGHEST and OS_TASK_PRIORITY_LOWEST is reserved for internal TIMER and IDLE task use only. */
31 #define ISVALID_LOS_PRIORITY(losPrio) ((losPrio) > OS_TASK_PRIORITY_HIGHEST && (losPrio) < OS_TASK_PRIORITY_LOWEST)
32 /**
33 * @brief Enumerates thread states.
34 *
35 */
36 typedef enum {
37 /** The thread is inactive. */
38 osThreadInactive = 0,
39 /** The thread is ready. */
40 osThreadReady = 1,
41 /** The thread is running. */
42 osThreadRunning = 2,
43 /** The thread is blocked. */
44 osThreadBlocked = 3,
45 /** The thread is terminated. */
46 osThreadTerminated = 4,
47 /** The thread is abnormal. */
48 osThreadError = -1,
49 /** Reserved */
50 osThreadReserved = 0x7FFFFFFF
51 } osThreadState_t;
52
53 #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
54 /**
55 * @brief Enumerates timer permissions.
56 *
57 * @since 1.0
58 * @version 1.0
59 */
60 typedef enum {
61 /** The timer is not allowed to wake up the RTOS. */
62 osTimerRousesIgnore = 0,
63 /** The timer is allowed to wake up the RTOS. */
64 osTimerRousesAllow = 1
65 } osTimerRouses_t;
66
67 /**
68 * @brief Enumerates timer alignment modes.
69 *
70 */
71 typedef enum {
72 /** The timer ignores alignment. */
73 osTimerAlignIgnore = 0,
74 /** The timer allows alignment. */
75 osTimerAlignAllow = 1
76 } osTimerAlign_t;
77 #endif //(LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
78
79 /******************************************************
80 * Variable Define
81 ******************************************************/
82 uint32_t ms_to_tick_ratio = LOS_TICK_MS;
83 beken_time_t beken_time_offset = 0;
84 static bool s_is_started_scheduler = false;
85
86 /******************************************************
87 * Function Declarations
88 ******************************************************/
89 extern void arch_wait_for_interrupt(void);
90 extern VOID OsMemInfoPrint(VOID *pool);
91 extern uint32_t platform_cpsr_content(void);
92
93 /******************************************************
94 * Function Definitions
95 ******************************************************/
rtos_create_thread(beken_thread_t * thread,uint8_t priority,const char * name,beken_thread_function_t function,uint32_t stack_size,beken_thread_arg_t arg)96 bk_err_t rtos_create_thread( beken_thread_t *thread, uint8_t priority, const char *name,
97 beken_thread_function_t function, uint32_t stack_size, beken_thread_arg_t arg )
98 {
99 uint32_t uwTid;
100 UINT32 uwRet = LOS_OK;
101 bk_err_t ret;
102 LosTaskCB *pstTaskCB = NULL;
103 TSK_INIT_PARAM_S stTskInitParam = {NULL};
104 UINT16 usPriority;
105
106 ret = kNoErr;
107 if (OS_INT_ACTIVE) {
108 ret = kGeneralErr;
109 goto tinit_exit;
110 }
111
112 usPriority = priority;
113 if (!ISVALID_LOS_PRIORITY(usPriority)) {
114 ret = kUnsupportedErr;/* unsupported priority */
115 goto tinit_exit;
116 }
117
118 stTskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)function;
119 stTskInitParam.uwArg = (uint32_t)arg;
120 //NOTES:Special code:Lite OS uses stack size more then freertos about 300 Bytes base on RISC-V.
121 stTskInitParam.uwStackSize = stack_size + 0x180;
122 stTskInitParam.pcName = (CHAR *)name;
123 stTskInitParam.usTaskPrio = usPriority;
124
125 uwRet = LOS_TaskCreate((UINT32 *)&uwTid, &stTskInitParam);
126 RTOS_LOGI("[debug]LOS_TaskCreate:%s:%d\r\n", name, uwRet);
127 if(LOS_OK != uwRet)
128 {
129 ret = kGeneralErr;
130 goto tinit_exit;
131 }
132 pstTaskCB = OS_TCB_FROM_TID(uwTid);
133
134 if(thread)
135 {
136 *thread = (beken_thread_t *)pstTaskCB;
137 }
138
139 tinit_exit:
140 BK_ASSERT(LOS_OK == uwRet); /* ASSERT VERIFIED */
141 return ret;
142 }
143
rtos_delete_thread(beken_thread_t * thread)144 bk_err_t rtos_delete_thread(beken_thread_t *thread)
145 {
146 UINT32 uwRet;
147 uint32_t selfTid;
148 LosTaskCB *pstTaskCB = NULL;
149
150 if (OS_INT_ACTIVE) {
151 return kUnknownErr;
152 }
153
154 if (thread && (*thread == NULL)) {
155 return kParamErr;
156 }
157
158 if(NULL == thread)
159 {
160 selfTid = LOS_CurTaskIDGet();
161 pstTaskCB = OS_TCB_FROM_TID(selfTid);
162 }
163 else
164 {
165 pstTaskCB = (LosTaskCB *)*thread;
166 }
167
168 uwRet = LOS_TaskDelete(pstTaskCB->taskID);
169
170 switch (uwRet) {
171 case LOS_ERRNO_TSK_OPERATE_IDLE:
172 case LOS_ERRNO_TSK_SUSPEND_SWTMR_NOT_ALLOWED:
173 case LOS_ERRNO_TSK_ID_INVALID:
174 return kParamErr;
175
176 case LOS_ERRNO_TSK_NOT_CREATED:
177 return kNoResourcesErr;
178
179 default:
180 return kNoErr;
181 }
182 }
183
_thread_get_status(beken_thread_t * thread)184 uint32_t _thread_get_status(beken_thread_t *thread)
185 {
186 UINT16 taskStatus;
187 osThreadState_t stState;
188 LosTaskCB *pstTaskCB = NULL;
189
190 BK_ASSERT(thread); /* ASSERT VERIFIED */
191 if (OS_INT_ACTIVE || *thread == NULL) {
192 return osThreadError;
193 }
194
195 pstTaskCB = (LosTaskCB *)*thread;
196 taskStatus = pstTaskCB->taskStatus;
197
198 if (taskStatus & OS_TASK_STATUS_RUNNING) {
199 stState = osThreadRunning;
200 } else if (taskStatus & OS_TASK_STATUS_READY) {
201 stState = osThreadReady;
202 } else if (taskStatus &
203 (OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND | OS_TASK_STATUS_SUSPEND)) {
204 stState = osThreadBlocked;
205 } else if (taskStatus & OS_TASK_STATUS_UNUSED) {
206 stState = osThreadInactive;
207 } else {
208 stState = osThreadError;
209 }
210
211 return stState;
212 }
213
rtos_thread_join(beken_thread_t * thread)214 bk_err_t rtos_thread_join(beken_thread_t *thread)
215 {
216 BK_ASSERT(thread); /* ASSERT VERIFIED */
217 while ( _thread_get_status( *thread ) != osThreadInactive )
218 {
219 rtos_delay_milliseconds(10);
220 }
221
222 return kNoErr;
223 }
224
rtos_is_current_thread(beken_thread_t * thread)225 bool rtos_is_current_thread( beken_thread_t *thread )
226 {
227 uint32_t selfTid = LOS_CurTaskIDGet();
228 LosTaskCB *tcb = OS_TCB_FROM_TID(selfTid);
229
230 if ( tcb == (LosTaskCB *)*thread )
231 {
232 return true;
233 }
234 else
235 {
236 return false;
237 }
238 }
239
rtos_get_current_thread(void)240 beken_thread_t *rtos_get_current_thread(void)
241 {
242 uint32_t selfTid = LOS_CurTaskIDGet();
243 LosTaskCB *tcb = OS_TCB_FROM_TID(selfTid);
244
245 return (beken_thread_t *)tcb;
246 }
247
248 /* Re-write vTaskList to add a buffer size parameter */
rtos_print_thread_status(char * pcWriteBuffer,int xWriteBufferLen)249 bk_err_t rtos_print_thread_status( char* pcWriteBuffer, int xWriteBufferLen )
250 {
251 // TODO
252 return kNoErr;
253 }
254
rtos_check_stack(void)255 bk_err_t rtos_check_stack(void)
256 {
257 // TODO: Add stack checking here.
258 return kNoErr;
259 }
260
rtos_thread_force_awake(beken_thread_t * thread)261 bk_err_t rtos_thread_force_awake( beken_thread_t *thread )
262 {
263 return kNoErr;
264 }
265
rtos_thread_sleep(uint32_t seconds)266 void rtos_thread_sleep(uint32_t seconds)
267 {
268 UINT32 uwRet = LOS_OK;
269
270 uwRet = LOS_TaskDelay(seconds * LOS_TICKS_PER_SECOND);
271 (void)uwRet;
272 }
273
rtos_suspend_thread(beken_thread_t * thread)274 void rtos_suspend_thread(beken_thread_t *thread)
275 {
276 UINT32 uwRet;
277 LosTaskCB *pstTaskCB = NULL;
278 beken_thread_t bk_thread;
279
280 if (OS_INT_ACTIVE) {
281 return;
282 }
283
284 bk_thread = *thread;
285 if (bk_thread == NULL) {
286 bk_thread = rtos_get_current_thread();
287 }
288
289 pstTaskCB = (LosTaskCB *)bk_thread;
290 uwRet = LOS_TaskSuspend(pstTaskCB->taskID);
291 switch (uwRet) {
292 case LOS_ERRNO_TSK_OPERATE_IDLE:
293 case LOS_ERRNO_TSK_SUSPEND_SWTMR_NOT_ALLOWED:
294 case LOS_ERRNO_TSK_ID_INVALID:
295 return;
296
297 case LOS_ERRNO_TSK_NOT_CREATED:
298 case LOS_ERRNO_TSK_ALREADY_SUSPENDED:
299 case LOS_ERRNO_TSK_SUSPEND_LOCKED:
300 return;
301
302 default:
303 return;
304 }
305 }
306
rtos_resume_thread(beken_thread_t * thread)307 void rtos_resume_thread(beken_thread_t *thread)
308 {
309 UINT32 uwRet;
310 LosTaskCB *pstTaskCB = NULL;
311 beken_thread_t bk_thread;
312
313 if (OS_INT_ACTIVE) {
314 return;
315 }
316
317 bk_thread = *thread;
318 if (bk_thread == NULL) {
319 bk_thread = rtos_get_current_thread();
320 }
321
322
323 pstTaskCB = (LosTaskCB *)bk_thread;
324 uwRet = LOS_TaskResume(pstTaskCB->taskID);
325
326 switch (uwRet) {
327 case LOS_ERRNO_TSK_ID_INVALID:
328 return;
329
330 case LOS_ERRNO_TSK_NOT_CREATED:
331 case LOS_ERRNO_TSK_NOT_SUSPENDED:
332 return;
333
334 default:
335 return;
336 }
337 }
338
rtos_get_tick_count(void)339 uint32_t rtos_get_tick_count(void)
340 {
341 return (uint32_t)LOS_TickCountGet();
342 }
343
beken_ms_per_tick(void)344 uint32_t beken_ms_per_tick(void)
345 {
346 return ms_to_tick_ratio;
347 }
348
beken_time_get_time(beken_time_t * time_ptr)349 bk_err_t beken_time_get_time(beken_time_t* time_ptr)
350 {
351 *time_ptr = (beken_time_t) ( LOS_TickCountGet() * ms_to_tick_ratio ) + beken_time_offset;
352 return kNoErr;
353 }
354
beken_time_set_time(beken_time_t * time_ptr)355 bk_err_t beken_time_set_time(beken_time_t* time_ptr)
356 {
357 beken_time_offset = *time_ptr - (beken_time_t) ( LOS_TickCountGet() * ms_to_tick_ratio );
358 return kNoErr;
359 }
360
rtos_init_semaphore(beken_semaphore_t * semaphore,int max_count)361 bk_err_t rtos_init_semaphore(beken_semaphore_t *semaphore, int max_count )
362 {
363 return rtos_init_semaphore_ex(semaphore, max_count, 0);
364 }
365
rtos_init_semaphore_ex(beken_semaphore_t * semaphore,int max_count,int init_count)366 bk_err_t rtos_init_semaphore_ex(beken_semaphore_t *semaphore, int max_count, int init_count)
367 {
368 UINT32 uwRet;
369 UINT32 uwSemId;
370
371 if (OS_INT_ACTIVE) {
372 *semaphore = (beken_semaphore_t)NULL;
373 goto init_aexit;
374 }
375
376 if (1 == max_count) {
377 uwRet = LOS_BinarySemCreate((UINT16)init_count, &uwSemId);
378 } else {
379 uwRet = LOS_SemCreate((UINT16)init_count, &uwSemId);
380 }
381 BK_ASSERT(LOS_OK == uwRet); /* ASSERT VERIFIED */
382
383 if (uwRet == LOS_OK) {
384 *semaphore = (beken_semaphore_t)(GET_SEM(uwSemId));
385 } else {
386 *semaphore = (beken_semaphore_t)NULL;
387 }
388
389 init_aexit:
390 return ( *semaphore != NULL ) ? kNoErr : kGeneralErr;
391 }
392
rtos_get_semaphore(beken_semaphore_t * semaphore,uint32_t timeout_ms)393 bk_err_t rtos_get_semaphore(beken_semaphore_t *semaphore, uint32_t timeout_ms )
394 {
395 UINT32 uwRet;
396 uint32_t timeout;
397
398 BK_ASSERT(semaphore); /* ASSERT VERIFIED */
399 if(timeout_ms == BEKEN_WAIT_FOREVER)
400 timeout = LOS_WAIT_FOREVER;
401 else
402 timeout = timeout_ms / ms_to_tick_ratio;
403
404 if (*semaphore == NULL) {
405 return kParamErr;
406 }
407
408 if (OS_INT_ACTIVE && (timeout != LOS_NO_WAIT)) {
409 return kUnknownErr;
410 }
411
412 uwRet = LOS_SemPend(((LosSemCB *)*semaphore)->semID, timeout);
413 if (uwRet == LOS_OK) {
414 return kNoErr;
415 } else if (uwRet == LOS_ERRNO_SEM_TIMEOUT) {
416 return kTimeoutErr;
417 } else if (uwRet == LOS_ERRNO_SEM_INVALID) {
418 return kParamErr;
419 } else if (uwRet == LOS_ERRNO_SEM_PEND_INTERR) {
420 return kInProgressErr;
421 } else {
422 return kGeneralErr;
423 }
424 }
425
rtos_get_semaphore_count(beken_semaphore_t * semaphore)426 int rtos_get_semaphore_count(beken_semaphore_t *semaphore )
427 {
428 uint32_t uwIntSave;
429 uint32_t uwCount;
430
431 if (OS_INT_ACTIVE) {
432 return 0;
433 }
434
435 BK_ASSERT(semaphore); /* ASSERT VERIFIED */
436
437 if (*semaphore == NULL) {
438 return 0;
439 }
440
441 uwIntSave = LOS_IntLock();
442 uwCount = ((LosSemCB *)*semaphore)->semCount;
443 LOS_IntRestore(uwIntSave);
444
445 return uwCount;
446 }
447
rtos_set_semaphore(beken_semaphore_t * semaphore)448 int rtos_set_semaphore(beken_semaphore_t *semaphore )
449 {
450 UINT32 uwRet;
451
452 BK_ASSERT(semaphore); /* ASSERT VERIFIED */
453
454 if (*semaphore == NULL) {
455 return kParamErr;
456 }
457
458 uwRet = LOS_SemPost(((LosSemCB *)*semaphore)->semID);
459 if (uwRet == LOS_OK) {
460 return kNoErr;
461 } else if (uwRet == LOS_ERRNO_SEM_INVALID) {
462 return kParamErr;
463 } else {
464 return kGeneralErr;
465 }
466 }
467
rtos_deinit_semaphore(beken_semaphore_t * semaphore)468 bk_err_t rtos_deinit_semaphore(beken_semaphore_t *semaphore )
469 {
470 UINT32 uwRet;
471
472 if (OS_INT_ACTIVE) {
473 return kGeneralErr;
474 }
475
476 BK_ASSERT(semaphore); /* ASSERT VERIFIED */
477
478 if (*semaphore == NULL) {
479 return kParamErr;
480 }
481
482 uwRet = LOS_SemDelete(((LosSemCB *)*semaphore)->semID);
483 *semaphore = (beken_semaphore_t) NULL;
484 if (uwRet == LOS_OK) {
485 return kNoErr;
486 } else if (uwRet == LOS_ERRNO_SEM_INVALID) {
487 return kParamErr;
488 } else {
489 return kGeneralErr;
490 }
491 }
492
rtos_enter_critical(void)493 void rtos_enter_critical(void)
494 {
495 }
496
rtos_exit_critical(void)497 void rtos_exit_critical(void)
498 {
499 }
500
rtos_init_mutex(beken_mutex_t * mutex)501 bk_err_t rtos_init_mutex(beken_mutex_t *mutex)
502 {
503 UINT32 uwRet;
504 UINT32 uwMuxId;
505
506 if (OS_INT_ACTIVE) {
507 *mutex = NULL;
508 goto init_exit;
509 }
510
511 BK_ASSERT(mutex); /* ASSERT VERIFIED */
512
513 uwRet = LOS_MuxCreate(&uwMuxId);
514 if (uwRet == LOS_OK) {
515 *mutex = (beken_mutex_t)(GET_MUX(uwMuxId));
516 } else {
517 *mutex = (beken_mutex_t)NULL;
518 }
519 BK_ASSERT(LOS_OK == uwRet); /* ASSERT VERIFIED */
520
521 init_exit:
522 if ( *mutex == NULL )
523 {
524 RTOS_LOGI("rtos_init_mutex:failed,mutex = %p\r\n", *mutex);
525 return kGeneralErr;
526 }
527
528 RTOS_LOGD("rtos_init_mutex:success,mutex = %p\r\n", *mutex);
529 return kNoErr;
530 }
531
rtos_trylock_mutex(beken_mutex_t * mutex)532 bk_err_t rtos_trylock_mutex(beken_mutex_t *mutex)
533 {
534 UINT32 uwRet;
535
536 if (*mutex == NULL) {
537 return kParamErr;
538 }
539
540 BK_ASSERT(mutex); /* ASSERT VERIFIED */
541
542 uwRet = LOS_MuxPend(((LosMuxCB *)*mutex)->muxID, 0);
543 if (uwRet == LOS_OK) {
544 return kNoErr;
545 } else if (uwRet == LOS_ERRNO_MUX_TIMEOUT) {
546 return kTimeoutErr;
547 } else if (uwRet == LOS_ERRNO_MUX_INVALID) {
548 return kParamErr;
549 } else {
550 return kGeneralErr;
551 }
552 }
553
rtos_lock_mutex(beken_mutex_t * mutex)554 bk_err_t rtos_lock_mutex(beken_mutex_t *mutex)
555 {
556 UINT32 uwRet;
557
558 BK_ASSERT(mutex); /* ASSERT VERIFIED */
559
560 if (*mutex == NULL) {
561 return kParamErr;
562 }
563
564 uwRet = LOS_MuxPend(((LosMuxCB *)*mutex)->muxID, LOS_WAIT_FOREVER);
565 if (uwRet == LOS_OK) {
566 return kNoErr;
567 } else if (uwRet == LOS_ERRNO_MUX_TIMEOUT) {
568 return kTimeoutErr;
569 } else if (uwRet == LOS_ERRNO_MUX_INVALID) {
570 return kParamErr;
571 } else {
572 return kGeneralErr;
573 }
574 }
575
rtos_unlock_mutex(beken_mutex_t * mutex)576 bk_err_t rtos_unlock_mutex(beken_mutex_t *mutex)
577 {
578 UINT32 uwRet;
579
580 if (*mutex == NULL) {
581 return kParamErr;
582 }
583
584 BK_ASSERT(mutex); /* ASSERT VERIFIED */
585
586 uwRet = LOS_MuxPost(((LosMuxCB *)*mutex)->muxID);
587 if (uwRet == LOS_OK) {
588 return kNoErr;
589 } else {
590 return kGeneralErr;
591 }
592 }
593
rtos_deinit_mutex(beken_mutex_t * mutex)594 bk_err_t rtos_deinit_mutex(beken_mutex_t *mutex)
595 {
596 UINT32 uwRet;
597
598 if (OS_INT_ACTIVE) {
599 RTOS_LOGI("rtos_deinit_mutex:failed(int active), mutex = %p\r\n", *mutex);
600 return kStateErr;
601 }
602
603 BK_ASSERT(mutex); /* ASSERT VERIFIED */
604
605 if (*mutex == NULL) {
606 RTOS_LOGI("rtos_deinit_mutex:failed(mutex is null).\r\n");
607 return kParamErr;
608 }
609
610 rtos_unlock_mutex(mutex);
611
612 uwRet = LOS_MuxDelete(((LosMuxCB *)*mutex)->muxID);
613 if (uwRet == LOS_OK) {
614 RTOS_LOGD("rtos_deinit_mutex:success, mutex = %p\r\n", *mutex);
615 return kNoErr;
616 } else if (uwRet == LOS_ERRNO_MUX_INVALID) {
617 RTOS_LOGI("rtos_deinit_mutex:failed(invalid mux), mutex = %p\r\n", *mutex);
618 return kParamErr;
619 } else {
620 RTOS_LOGI("rtos_deinit_mutex:failed(other), mutex = %p\r\n", *mutex);
621 return kGeneralErr;
622 }
623 }
624
rtos_init_queue(beken_queue_t * queue,const char * name,uint32_t msg_size,uint32_t msg_count)625 bk_err_t rtos_init_queue( beken_queue_t *queue, const char* name, uint32_t msg_size, uint32_t msg_count )
626 {
627 UINT32 uwRet;
628 UINT32 uwQueueID;
629 bk_err_t ret = kNoErr;
630
631 BK_ASSERT(queue); /* ASSERT VERIFIED */
632
633 if (0 == msg_count || 0 == msg_size || OS_INT_ACTIVE) {
634 *queue = (beken_queue_t)NULL;
635 ret = kParamErr;
636 goto qinit_exit;
637 }
638
639 uwRet = LOS_QueueCreate((char *)name, (UINT16)msg_count, &uwQueueID, 0, (UINT16)msg_size);
640 RTOS_LOGI("[debug]LOS_QueueCreate:%s:%d\r\n", name, uwRet);
641 if (uwRet == LOS_OK) {
642 *queue = (beken_queue_t)(GET_QUEUE_HANDLE(uwQueueID));
643 } else {
644 *queue = (beken_queue_t)NULL;
645 ret = kNoResourcesErr;
646 }
647 BK_ASSERT(LOS_OK == uwRet); /* ASSERT VERIFIED */
648
649 qinit_exit:
650 return ret;
651 }
652
rtos_push_to_queue(beken_queue_t * queue,void * msg_ptr,uint32_t timeout_ms)653 bk_err_t rtos_push_to_queue( beken_queue_t *queue, void* msg_ptr, uint32_t timeout_ms )
654 {
655 UINT32 uwRet;
656 uint32_t timeout;
657 uint32_t uwBufferSize;
658 LosQueueCB *pstQueue = (LosQueueCB *)*queue;
659
660 BK_ASSERT(queue); /* ASSERT VERIFIED */
661
662 if(timeout_ms == BEKEN_WAIT_FOREVER)
663 timeout = LOS_WAIT_FOREVER;
664 else
665 timeout = timeout_ms / ms_to_tick_ratio;
666
667 if (pstQueue == NULL || msg_ptr == NULL || ((OS_INT_ACTIVE) && (0 != timeout))) {
668 return kParamErr;
669 }
670 if (pstQueue->queueSize < sizeof(uint32_t)) {
671 return kParamErr;
672 }
673 uwBufferSize = (uint32_t)(pstQueue->queueSize - sizeof(uint32_t));
674 uwRet = LOS_QueueWriteCopy((uint32_t)pstQueue->queueID, (void *)msg_ptr, uwBufferSize, timeout);
675 if (uwRet == LOS_OK) {
676 return kNoErr;
677 } else if (uwRet == LOS_ERRNO_QUEUE_INVALID || uwRet == LOS_ERRNO_QUEUE_NOT_CREATE) {
678 return kParamErr;
679 } else if (uwRet == LOS_ERRNO_QUEUE_TIMEOUT) {
680 return kTimeoutErr;
681 } else {
682 return kGeneralErr;
683 }
684 }
685
rtos_push_to_queue_front(beken_queue_t * queue,void * msg_ptr,uint32_t timeout_ms)686 bk_err_t rtos_push_to_queue_front( beken_queue_t *queue, void *msg_ptr, uint32_t timeout_ms )
687 {
688 UINT32 uwRet;
689 uint32_t timeout;
690 uint32_t uwBufferSize;
691 LosQueueCB *pstQueue = (LosQueueCB *)*queue;
692
693 BK_ASSERT(queue); /* ASSERT VERIFIED */
694
695 if(timeout_ms == BEKEN_WAIT_FOREVER)
696 timeout = LOS_WAIT_FOREVER;
697 else
698 timeout = timeout_ms / ms_to_tick_ratio;
699
700 if (pstQueue == NULL || msg_ptr == NULL || ((OS_INT_ACTIVE) && (0 != timeout))) {
701 return kParamErr;
702 }
703 if (pstQueue->queueSize < sizeof(uint32_t)) {
704 return kParamErr;
705 }
706 uwBufferSize = (uint32_t)(pstQueue->queueSize - sizeof(uint32_t));
707 uwRet = LOS_QueueWriteHeadCopy((uint32_t)pstQueue->queueID, (void *)msg_ptr, uwBufferSize, timeout);
708 if (uwRet == LOS_OK) {
709 return kNoErr;
710 } else if (uwRet == LOS_ERRNO_QUEUE_INVALID || uwRet == LOS_ERRNO_QUEUE_NOT_CREATE) {
711 return kParamErr;
712 } else if (uwRet == LOS_ERRNO_QUEUE_TIMEOUT) {
713 return kTimeoutErr;
714 } else {
715 return kGeneralErr;
716 }
717 }
718
rtos_pop_from_queue(beken_queue_t * queue,void * msg_ptr,uint32_t timeout_ms)719 bk_err_t rtos_pop_from_queue( beken_queue_t *queue, void *msg_ptr, uint32_t timeout_ms )
720 {
721 UINT32 uwRet;
722 uint32_t timeout;
723 UINT32 uwBufferSize;
724 LosQueueCB *pstQueue = (LosQueueCB *)*queue;
725
726 BK_ASSERT(queue); /* ASSERT VERIFIED */
727
728 if(timeout_ms == BEKEN_WAIT_FOREVER)
729 timeout = LOS_WAIT_FOREVER;
730 else
731 timeout = timeout_ms / ms_to_tick_ratio;
732
733 if (pstQueue == NULL || msg_ptr == NULL || ((OS_INT_ACTIVE) && (0 != timeout))) {
734 return kParamErr;
735 }
736
737 uwBufferSize = (uint32_t)(pstQueue->queueSize - sizeof(uint32_t));
738 uwRet = LOS_QueueReadCopy((uint32_t)pstQueue->queueID, msg_ptr, &uwBufferSize, timeout);
739 if (uwRet == LOS_OK) {
740 return kNoErr;
741 } else if (uwRet == LOS_ERRNO_QUEUE_INVALID || uwRet == LOS_ERRNO_QUEUE_NOT_CREATE) {
742 return kParamErr;
743 } else if (uwRet == LOS_ERRNO_QUEUE_TIMEOUT) {
744 return kTimeoutErr;
745 } else {
746 return kGeneralErr;
747 }
748 }
749
rtos_deinit_queue(beken_queue_t * queue)750 bk_err_t rtos_deinit_queue(beken_queue_t *queue)
751 {
752 UINT32 uwRet;
753 LosQueueCB *pstQueue = (LosQueueCB *)*queue;
754
755 BK_ASSERT(queue); /* ASSERT VERIFIED */
756
757 if (pstQueue == NULL) {
758 return kParamErr;
759 }
760
761 if (OS_INT_ACTIVE) {
762 return kGeneralErr;
763 }
764
765 uwRet = LOS_QueueDelete((uint32_t)pstQueue->queueID);
766 if (uwRet == LOS_OK) {
767 return kNoErr;
768 } else if (uwRet == LOS_ERRNO_QUEUE_NOT_FOUND || uwRet == LOS_ERRNO_QUEUE_NOT_CREATE) {
769 return kParamErr;
770 } else {
771 return kUnknownErr;
772 }
773 }
774
_queue_get_capacity(beken_queue_t * queue)775 uint32_t _queue_get_capacity(beken_queue_t *queue)
776 {
777 uint32_t capacity;
778 LosQueueCB *pstQueue = (LosQueueCB *)*queue;
779
780 if (pstQueue == NULL) {
781 capacity = 0U;
782 } else {
783 capacity = pstQueue->queueLen;
784 }
785
786 return (capacity);
787 }
788
_queue_get_count(beken_queue_t * queue)789 uint32_t _queue_get_count(beken_queue_t *queue)
790 {
791 uint32_t count;
792 UINTPTR uwIntSave;
793 LosQueueCB *pstQueue = (LosQueueCB *)*queue;
794
795 BK_ASSERT(queue); /* ASSERT VERIFIED */
796
797 if (pstQueue == NULL) {
798 count = 0U;
799 } else {
800 uwIntSave = LOS_IntLock();
801 count = (uint32_t)(pstQueue->readWriteableCnt[OS_QUEUE_READ]);
802 LOS_IntRestore(uwIntSave);
803 }
804 return count;
805 }
806
rtos_is_queue_full(beken_queue_t * queue)807 bool rtos_is_queue_full(beken_queue_t *queue)
808 {
809 BK_ASSERT(queue); /* ASSERT VERIFIED */
810 return ( _queue_get_capacity(queue) == _queue_get_count(queue) ) ? true : false;
811 }
812
rtos_is_queue_empty(beken_queue_t * queue)813 bool rtos_is_queue_empty(beken_queue_t *queue)
814 {
815 BK_ASSERT(queue); /* ASSERT VERIFIED */
816 return ( 0 == _queue_get_count(queue) ) ? true : false;
817 }
818
timer_callback2(void * handle)819 static void timer_callback2( void *handle )
820 {
821 beken2_timer_t *timer = (beken2_timer_t *) handle;
822
823 if(BEKEN_MAGIC_WORD != timer->beken_magic)
824 {
825 return;
826 }
827 if ( timer->function )
828 {
829 timer->function( timer->left_arg, timer->right_arg );
830 }
831 }
832
timer_callback1(void * handle)833 static void timer_callback1( void *handle )
834 {
835 beken_timer_t *timer = (beken_timer_t*) handle;
836
837 if ( timer->function )
838 {
839 timer->function( timer->arg);
840 }
841 }
842
rtos_init_oneshot_timer(beken2_timer_t * timer,uint32_t time_ms,timer_2handler_t func,void * larg,void * rarg)843 bk_err_t rtos_init_oneshot_timer( beken2_timer_t *timer,
844 uint32_t time_ms,
845 timer_2handler_t func,
846 void* larg,
847 void* rarg )
848 {
849 SWTMR_CTRL_S *pstSwtmr;
850 bk_err_t ret = kNoErr;
851 UINT32 usSwTmrID;
852 UINT8 mode;
853
854 timer->handle = NULL;
855 if (NULL == func) {
856 ret = kParamErr;
857 goto tinit_exit;
858 }
859
860 mode = LOS_SWTMR_MODE_NO_SELFDELETE;
861 timer->beken_magic = BEKEN_MAGIC_WORD;
862 timer->function = func;
863 timer->left_arg = larg;
864 timer->right_arg = rarg;
865
866 #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
867 if (LOS_OK != LOS_SwtmrCreate(1, mode, (SWTMR_PROC_FUNC)timer_callback2, &usSwTmrID, (uint32_t)(UINTPTR)timer,
868 osTimerRousesAllow, osTimerAlignIgnore)) {
869 ret = kGeneralErr;
870 goto tinit_exit;
871 }
872 #else
873 if (LOS_OK != LOS_SwtmrCreate(1, mode, (SWTMR_PROC_FUNC)func, &usSwTmrID, (uint32_t)(UINTPTR)larg)) {
874 ret = kGeneralErr;
875 goto tinit_exit;
876 }
877 #endif
878
879 pstSwtmr = (SWTMR_CTRL_S *)OS_SWT_FROM_SID(usSwTmrID);
880 timer->handle = (void *)pstSwtmr;
881
882 if(pstSwtmr){
883 pstSwtmr->uwInterval = time_ms / ms_to_tick_ratio;
884 }
885
886 tinit_exit:
887 return ret;
888 }
889
rtos_start_oneshot_timer(beken2_timer_t * timer)890 bk_err_t rtos_start_oneshot_timer(beken2_timer_t *timer)
891 {
892 return rtos_start_timer((beken_timer_t *)timer);
893 }
894
rtos_deinit_oneshot_timer(beken2_timer_t * timer)895 bk_err_t rtos_deinit_oneshot_timer(beken2_timer_t *timer)
896 {
897 timer->beken_magic = 0;
898 timer->left_arg = 0;
899 timer->right_arg = 0;
900 timer->function = NULL;
901
902 return rtos_deinit_timer((beken_timer_t *)timer);
903 }
904
rtos_stop_oneshot_timer(beken2_timer_t * timer)905 bk_err_t rtos_stop_oneshot_timer(beken2_timer_t *timer)
906 {
907 return rtos_stop_timer((beken_timer_t *)timer);
908 }
909
rtos_is_oneshot_timer_init(beken2_timer_t * timer)910 bool rtos_is_oneshot_timer_init(beken2_timer_t *timer)
911 {
912 return (NULL != timer->handle) ? true : false;
913 }
914
rtos_is_oneshot_timer_running(beken2_timer_t * timer)915 bool rtos_is_oneshot_timer_running(beken2_timer_t *timer)
916 {
917 return rtos_is_timer_running((beken_timer_t *)timer);
918 }
919
rtos_oneshot_reload_timer(beken2_timer_t * timer)920 bk_err_t rtos_oneshot_reload_timer(beken2_timer_t *timer)
921 {
922 return rtos_start_timer((beken_timer_t *)timer);
923 }
924
rtos_oneshot_reload_timer_ex(beken2_timer_t * timer,uint32_t time_ms,timer_2handler_t function,void * larg,void * rarg)925 bk_err_t rtos_oneshot_reload_timer_ex(beken2_timer_t *timer,
926 uint32_t time_ms,
927 timer_2handler_t function,
928 void *larg,
929 void *rarg)
930 {
931 return kUnsupportedErr;
932 }
933
rtos_init_timer(beken_timer_t * timer,uint32_t time_ms,timer_handler_t func,void * argument)934 bk_err_t rtos_init_timer(beken_timer_t *timer,
935 uint32_t time_ms,
936 timer_handler_t func,
937 void* argument )
938 {
939 SWTMR_CTRL_S *pstSwtmr;
940 bk_err_t ret = kNoErr;
941 UINT32 usSwTmrID;
942 UINT8 mode;
943
944 timer->handle = NULL;
945
946 if (NULL == func) {
947 ret = kParamErr;
948 goto tinit_exit;
949 }
950
951 mode = LOS_SWTMR_MODE_PERIOD;
952 timer->function = func;
953 timer->arg = argument;
954
955 #if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
956 if (LOS_OK != LOS_SwtmrCreate(1, mode, (SWTMR_PROC_FUNC)timer_callback1, &usSwTmrID, (uint32_t)(UINTPTR)timer,
957 osTimerRousesAllow, osTimerAlignIgnore)) {
958 ret = kGeneralErr;
959 RTOS_LOGI("rtos_init_timer: Err LOSCFG_BASE_CORE_SWTMR_ALIGN == 1.\n");
960 goto tinit_exit;
961 }
962 #else
963 if (LOS_OK != LOS_SwtmrCreate(1, mode, (SWTMR_PROC_FUNC)timer_callback1, &usSwTmrID, (uint32_t)(UINTPTR)timer)) {
964 ret = kGeneralErr;
965 RTOS_LOGI("rtos_init_timer: Err.\n");
966 goto tinit_exit;
967 }
968 #endif
969
970 timer->handle = (void *)OS_SWT_FROM_SID(usSwTmrID);
971 pstSwtmr = (SWTMR_CTRL_S *)timer->handle;
972
973
974 if(pstSwtmr){
975 pstSwtmr->uwInterval = time_ms / ms_to_tick_ratio;
976 }
977
978 tinit_exit:
979 return ret;
980 }
981
rtos_start_timer(beken_timer_t * timer)982 bk_err_t rtos_start_timer(beken_timer_t *timer)
983 {
984 UINT32 uwRet;
985 SWTMR_CTRL_S *pstSwtmr;
986
987 if (NULL == timer) {
988 return kParamErr;
989 }
990
991 UINTPTR intSave = LOS_IntLock();
992 pstSwtmr = (SWTMR_CTRL_S *)timer->handle;
993 uwRet = LOS_SwtmrStart(pstSwtmr->usTimerID);
994 LOS_IntRestore(intSave);
995 if (LOS_OK == uwRet) {
996 return kNoErr;
997 } else if (LOS_ERRNO_SWTMR_ID_INVALID == uwRet) {
998 return kParamErr;
999 } else {
1000 return kTimeoutErr;
1001 }
1002 }
1003
rtos_stop_timer(beken_timer_t * timer)1004 bk_err_t rtos_stop_timer(beken_timer_t *timer)
1005 {
1006 UINT32 uwRet;
1007 SWTMR_CTRL_S *pstSwtmr;
1008
1009 if (NULL == timer) {
1010 return kParamErr;
1011 }
1012
1013 pstSwtmr = (SWTMR_CTRL_S *)timer->handle;
1014 uwRet = LOS_SwtmrStop(pstSwtmr->usTimerID);
1015 if (LOS_OK == uwRet) {
1016 return kNoErr;
1017 } else if (LOS_ERRNO_SWTMR_ID_INVALID == uwRet) {
1018 return kParamErr;
1019 } else {
1020 return kGeneralErr;
1021 }
1022 }
1023
rtos_reload_timer(beken_timer_t * timer)1024 bk_err_t rtos_reload_timer(beken_timer_t *timer)
1025 {
1026 return rtos_start_timer(timer);
1027 }
1028
rtos_change_period(beken_timer_t * timer,uint32_t time_ms)1029 bk_err_t rtos_change_period(beken_timer_t *timer, uint32_t time_ms)
1030 {
1031 UINT32 uwRet;
1032 UINTPTR intSave;
1033 SWTMR_CTRL_S *pstSwtmr;
1034
1035 if (NULL == timer) {
1036 return kParamErr;
1037 }
1038 rtos_stop_timer(timer);
1039
1040 intSave = LOS_IntLock();
1041 pstSwtmr = (SWTMR_CTRL_S *)timer->handle;
1042 pstSwtmr->uwInterval = time_ms / ms_to_tick_ratio;
1043 uwRet = LOS_SwtmrStart(pstSwtmr->usTimerID);
1044 LOS_IntRestore(intSave);
1045 if (LOS_OK == uwRet) {
1046 return kNoErr;
1047 } else if (LOS_ERRNO_SWTMR_ID_INVALID == uwRet) {
1048 return kParamErr;
1049 } else {
1050 return kGeneralErr;
1051 }
1052 }
1053
rtos_deinit_timer(beken_timer_t * timer)1054 bk_err_t rtos_deinit_timer(beken_timer_t *timer)
1055 {
1056 UINT32 uwRet;
1057 SWTMR_CTRL_S *pstSwtmr;
1058
1059 pstSwtmr = (SWTMR_CTRL_S *)timer->handle;
1060 if (NULL == pstSwtmr) {
1061 return kParamErr;
1062 }
1063
1064 uwRet = LOS_SwtmrDelete(pstSwtmr->usTimerID);
1065 if (LOS_OK == uwRet) {
1066 timer->handle = NULL;
1067 timer->arg = 0;
1068 timer->function = NULL;
1069 return kNoErr;
1070 } else if (LOS_ERRNO_SWTMR_ID_INVALID == uwRet) {
1071 return kParamErr;
1072 } else {
1073 return kGeneralErr;
1074 }
1075 }
1076
rtos_get_timer_expiry_time(beken_timer_t * timer)1077 uint32_t rtos_get_timer_expiry_time(beken_timer_t *timer)
1078 {
1079 uint32_t val;
1080 UINTPTR intSave;
1081 SWTMR_CTRL_S *pstSwtmr;
1082
1083 intSave = LOS_IntLock();
1084 pstSwtmr = (SWTMR_CTRL_S *)timer->handle;
1085 val = pstSwtmr->uwInterval;
1086 LOS_IntRestore(intSave);
1087
1088 return val;
1089 }
1090
rtos_get_next_expire_time(void)1091 uint32_t rtos_get_next_expire_time(void)
1092 {
1093 return kGeneralErr;
1094 }
1095
rtos_get_current_timer_count(void)1096 uint32_t rtos_get_current_timer_count(void)
1097 {
1098 return kGeneralErr;
1099 }
1100
rtos_is_timer_init(beken_timer_t * timer)1101 bool rtos_is_timer_init(beken_timer_t *timer)
1102 {
1103 return (NULL != timer->handle) ? true : false;
1104 }
1105
rtos_is_timer_running(beken_timer_t * timer)1106 bool rtos_is_timer_running(beken_timer_t *timer)
1107 {
1108 if (NULL == timer->handle) {
1109 return 0;
1110 }
1111
1112 return (OS_SWTMR_STATUS_TICKING == ((SWTMR_CTRL_S *)timer->handle)->ucState);
1113 }
1114
rtos_init_event_flags(beken_event_flags_t * event_flags)1115 bk_err_t rtos_init_event_flags( beken_event_flags_t* event_flags )
1116 {
1117 __maybe_unused_var( event_flags );
1118
1119 return kUnsupportedErr;
1120 }
1121
rtos_wait_for_event_flags(beken_event_flags_t * event_flags,uint32_t flags_to_wait_for,uint32_t * flags_set,beken_bool_t clear_set_flags,beken_event_flags_wait_option_t wait_option,uint32_t timeout_ms)1122 bk_err_t rtos_wait_for_event_flags( beken_event_flags_t* event_flags, uint32_t flags_to_wait_for, uint32_t* flags_set, beken_bool_t clear_set_flags, beken_event_flags_wait_option_t wait_option, uint32_t timeout_ms )
1123 {
1124 __maybe_unused_var( event_flags );
1125 __maybe_unused_var( flags_to_wait_for );
1126 __maybe_unused_var( flags_set );
1127 __maybe_unused_var( clear_set_flags );
1128 __maybe_unused_var( wait_option );
1129 __maybe_unused_var( timeout_ms );
1130
1131 return kUnsupportedErr;
1132 }
1133
rtos_set_event_flags(beken_event_flags_t * event_flags,uint32_t flags_to_set)1134 bk_err_t rtos_set_event_flags( beken_event_flags_t* event_flags, uint32_t flags_to_set )
1135 {
1136 __maybe_unused_var( event_flags );
1137 __maybe_unused_var( flags_to_set );
1138
1139 return kUnsupportedErr;
1140 }
1141
rtos_deinit_event_flags(beken_event_flags_t * event_flags)1142 bk_err_t rtos_deinit_event_flags( beken_event_flags_t* event_flags )
1143 {
1144 __maybe_unused_var( event_flags );
1145
1146 return kUnsupportedErr;
1147 }
1148
1149 /**
1150 * Gets time in milliseconds since RTOS start
1151 *
1152 * @Note: since this is only 32 bits, it will roll over every 49 days, 17 hours.
1153 *
1154 * @returns Time in milliseconds since RTOS started.
1155 */
rtos_get_time(void)1156 beken_time_t rtos_get_time(void)
1157 {
1158 return (beken_time_t) ( LOS_TickCountGet() * ms_to_tick_ratio );
1159 }
1160
1161 /**
1162 * Delay for a number of milliseconds
1163 *
1164 * Processing of this function depends on the minimum sleep
1165 * time resolution of the RTOS.
1166 * The current thread sleeps for the longest period possible which
1167 * is less than the delay required, then makes up the difference
1168 * with a tight loop
1169 *
1170 * @return bk_err_t : kNoErr if delay was successful
1171 *
1172 */
rtos_delay_milliseconds(uint32_t num_ms)1173 bk_err_t rtos_delay_milliseconds( uint32_t num_ms )
1174 {
1175 uint32_t ticks;
1176
1177 ticks = num_ms / ms_to_tick_ratio;
1178 if (ticks == 0)
1179 ticks = 1;
1180
1181 LOS_TaskDelay( ticks );
1182
1183 return kNoErr;
1184 }
1185
1186 /*-----------------------------------------------------------*/
beken_malloc(size_t xWantedSize)1187 void *beken_malloc( size_t xWantedSize )
1188 {
1189 return (void *)LOS_MemAlloc(m_aucSysMem0, xWantedSize);;
1190 }
1191
beken_free(void * pv)1192 void beken_free( void *pv )
1193 {
1194 LOS_MemFree(m_aucSysMem0, pv);
1195 }
1196
beken_realloc(void * pv,size_t xWantedSize)1197 void *beken_realloc( void *pv, size_t xWantedSize )
1198 {
1199 return LOS_MemRealloc(m_aucSysMem0, pv, xWantedSize);
1200 }
1201 /*-----------------------------------------------------------*/
1202
rtos_start_scheduler(void)1203 void rtos_start_scheduler(void)
1204 {
1205 s_is_started_scheduler = true;
1206 LOS_Start();
1207 }
1208
rtos_is_scheduler_started(void)1209 bool rtos_is_scheduler_started(void)
1210 {
1211 return s_is_started_scheduler;
1212 }
1213
1214 #if (!CONFIG_ARCH_RISCV)
rtos_get_cpsr(void)1215 uint32_t rtos_get_cpsr(void)
1216 {
1217
1218 return platform_cpsr_content();
1219
1220 }
1221 #endif
1222
rtos_disable_int(void)1223 uint32_t rtos_disable_int(void)
1224 {
1225 return port_disable_interrupts_flag();
1226 }
1227
rtos_enable_int(uint32_t int_level)1228 void rtos_enable_int(uint32_t int_level)
1229 {
1230 port_enable_interrupts_flag(int_level);
1231 }
rtos_disable_mie_int(void)1232 uint32_t rtos_disable_mie_int(void)
1233 {
1234 return port_disable_mie_flag();
1235 }
1236
rtos_enable_mie_int(uint32_t int_level)1237 void rtos_enable_mie_int(uint32_t int_level)
1238 {
1239 port_enable_mie_flag(int_level);
1240 }
1241
rtos_stop_int(void)1242 void rtos_stop_int(void)
1243 {
1244 portDISABLE_INTERRUPTS();
1245 }
1246
rtos_start_int(void)1247 void rtos_start_int(void)
1248 {
1249 portENABLE_INTERRUPTS();
1250 }
1251
rtos_is_in_interrupt_context(void)1252 bool rtos_is_in_interrupt_context(void)
1253 {
1254 return platform_is_in_interrupt_context();
1255 }
1256
rtos_wait_for_interrupt(void)1257 void rtos_wait_for_interrupt(void)
1258 {
1259 arch_wait_for_interrupt();
1260 }
1261
rtos_dump_task_backtrace(beken_thread_t * task)1262 void rtos_dump_task_backtrace(beken_thread_t *task)
1263 {
1264 // TODO
1265 }
1266
rtos_dump_backtrace(void)1267 void rtos_dump_backtrace(void)
1268 {
1269 rtos_dump_task_backtrace(NULL);
1270 }
1271
rtos_dump_task_list(void)1272 void rtos_dump_task_list(void)
1273 {
1274 OsGetAllTskInfo();
1275 }
1276 #if CONFIG_LITEOS_M_BK
rtos_get_free_heap_size(void)1277 size_t rtos_get_free_heap_size(void)
1278 {
1279 return 0x1000;
1280 }
1281 #else
rtos_get_free_heap_size(void)1282 size_t rtos_get_free_heap_size(void)
1283 {
1284 UINT32 OsMemGetFreeSize(VOID *pool);
1285
1286 OsMemInfoPrint(m_aucSysMem0);
1287 LOS_MemFreeNodeShow(m_aucSysMem0);
1288 return OsMemGetFreeSize(m_aucSysMem0);
1289 }
1290 #endif
1291 // eof
1292
1293