1 /******************************************************************************
2 *
3 * Copyright (C) 1999-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18 #include <stdio.h>
19 #include <stdarg.h>
20 #include <errno.h>
21
22 #define GKI_DEBUG FALSE
23
24 #include <pthread.h> /* must be 1st header defined */
25 #include <time.h>
26 #include "gki_int.h"
27 #include "gki_target.h"
28
29 /* Temp android logging...move to android tgt config file */
30
31 #ifndef LINUX_NATIVE
32 #include <cutils/log.h>
33 #else
34 #define LOGV(format, ...) fprintf (stdout, LOG_TAG format, ## __VA_ARGS__)
35 #define LOGE(format, ...) fprintf (stderr, LOG_TAG format, ## __VA_ARGS__)
36 #define LOGI(format, ...) fprintf (stdout, LOG_TAG format, ## __VA_ARGS__)
37
38 #define SCHED_NORMAL 0
39 #define SCHED_FIFO 1
40 #define SCHED_RR 2
41 #define SCHED_BATCH 3
42
43 #define pthread_cond_timedwait_monotonic pthread_cond_timedwait
44
45 #endif
46
47 /* Define the structure that holds the GKI variables
48 */
49 #if GKI_DYNAMIC_MEMORY == FALSE
50 tGKI_CB gki_cb;
51 #endif
52
53 #define NANOSEC_PER_MILLISEC (1000000)
54 #define NSEC_PER_SEC (1000*NANOSEC_PER_MILLISEC)
55
56 /* works only for 1ms to 1000ms heart beat ranges */
57 #define LINUX_SEC (1000/TICKS_PER_SEC)
58 // #define GKI_TICK_TIMER_DEBUG
59
60 #define LOCK(m) pthread_mutex_lock(&m)
61 #define UNLOCK(m) pthread_mutex_unlock(&m)
62 #define INIT(m) pthread_mutex_init(&m, NULL)
63
64
65 /* this kind of mutex go into tGKI_OS control block!!!! */
66 /* static pthread_mutex_t GKI_sched_mutex; */
67 /*static pthread_mutex_t thread_delay_mutex;
68 static pthread_cond_t thread_delay_cond;
69 static pthread_mutex_t gki_timer_update_mutex;
70 static pthread_cond_t gki_timer_update_cond;
71 */
72 #ifdef NO_GKI_RUN_RETURN
73 static pthread_t timer_thread_id = 0;
74 #endif
75
76
77 /* For Android */
78
79 #ifndef GKI_SHUTDOWN_EVT
80 #define GKI_SHUTDOWN_EVT APPL_EVT_7
81 #endif
82
83 typedef struct
84 {
85 UINT8 task_id; /* GKI task id */
86 TASKPTR task_entry; /* Task entry function*/
87 UINT32 params; /* Extra params to pass to task entry function */
88 pthread_cond_t* pCond; /* for android*/
89 pthread_mutex_t* pMutex; /* for android*/
90 } gki_pthread_info_t;
91 gki_pthread_info_t gki_pthread_info[GKI_MAX_TASKS];
92
93 /*******************************************************************************
94 **
95 ** Function gki_task_entry
96 **
97 ** Description entry point of GKI created tasks
98 **
99 ** Returns void
100 **
101 *******************************************************************************/
gki_task_entry(UINT32 params)102 void gki_task_entry(UINT32 params)
103 {
104 pthread_t thread_id = pthread_self();
105 gki_pthread_info_t *p_pthread_info = (gki_pthread_info_t *)params;
106 GKI_TRACE_5("gki_task_entry task_id=%i, thread_id=%x/%x, pCond/pMutex=%x/%x", p_pthread_info->task_id,
107 gki_cb.os.thread_id[p_pthread_info->task_id], pthread_self(),
108 p_pthread_info->pCond, p_pthread_info->pMutex);
109
110 gki_cb.os.thread_id[p_pthread_info->task_id] = thread_id;
111 /* Call the actual thread entry point */
112 (p_pthread_info->task_entry)(p_pthread_info->params);
113
114 GKI_TRACE_1("gki_task task_id=%i terminating", p_pthread_info->task_id);
115 gki_cb.os.thread_id[p_pthread_info->task_id] = 0;
116
117 pthread_exit(0); /* GKI tasks have no return value */
118 }
119 /* end android */
120
121 #ifndef ANDROID
GKI_TRACE(char * fmt,...)122 void GKI_TRACE(char *fmt, ...)
123 {
124 LOCK(gki_cb.os.GKI_trace_mutex);
125 va_list ap;
126
127 va_start(ap, fmt);
128 vfprintf(stderr, fmt, ap);
129 fprintf(stderr, "\n");
130
131 va_end(ap);
132 UNLOCK(gki_cb.os.GKI_trace_mutex);
133 }
134 #endif
135
136 /*******************************************************************************
137 **
138 ** Function GKI_init
139 **
140 ** Description This function is called once at startup to initialize
141 ** all the timer structures.
142 **
143 ** Returns void
144 **
145 *******************************************************************************/
146
GKI_init(void)147 void GKI_init(void)
148 {
149 pthread_mutexattr_t attr;
150 tGKI_OS *p_os;
151
152 memset (&gki_cb, 0, sizeof (gki_cb));
153
154 gki_buffer_init();
155 gki_timers_init();
156 gki_cb.com.OSTicks = (UINT32) times(0);
157
158 pthread_mutexattr_init(&attr);
159
160 #ifndef __CYGWIN__
161 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
162 #endif
163 p_os = &gki_cb.os;
164 pthread_mutex_init(&p_os->GKI_mutex, &attr);
165 /* pthread_mutex_init(&GKI_sched_mutex, NULL); */
166 #if (GKI_DEBUG == TRUE)
167 pthread_mutex_init(&p_os->GKI_trace_mutex, NULL);
168 #endif
169 /* pthread_mutex_init(&thread_delay_mutex, NULL); */ /* used in GKI_delay */
170 /* pthread_cond_init (&thread_delay_cond, NULL); */
171
172 /* Initialiase GKI_timer_update suspend variables & mutexes to be in running state.
173 * this works too even if GKI_NO_TICK_STOP is defined in btld.txt */
174 p_os->no_timer_suspend = GKI_TIMER_TICK_RUN_COND;
175 pthread_mutex_init(&p_os->gki_timer_mutex, NULL);
176 pthread_cond_init(&p_os->gki_timer_cond, NULL);
177 }
178
179
180 /*******************************************************************************
181 **
182 ** Function GKI_get_os_tick_count
183 **
184 ** Description This function is called to retrieve the native OS system tick.
185 **
186 ** Returns Tick count of native OS.
187 **
188 *******************************************************************************/
GKI_get_os_tick_count(void)189 UINT32 GKI_get_os_tick_count(void)
190 {
191
192 /* TODO - add any OS specific code here
193 **/
194 return (gki_cb.com.OSTicks);
195 }
196
197 /*******************************************************************************
198 **
199 ** Function GKI_create_task
200 **
201 ** Description This function is called to create a new OSS task.
202 **
203 ** Parameters: task_entry - (input) pointer to the entry function of the task
204 ** task_id - (input) Task id is mapped to priority
205 ** taskname - (input) name given to the task
206 ** stack - (input) pointer to the top of the stack (highest memory location)
207 ** stacksize - (input) size of the stack allocated for the task
208 **
209 ** Returns GKI_SUCCESS if all OK, GKI_FAILURE if any problem
210 **
211 ** NOTE This function take some parameters that may not be needed
212 ** by your particular OS. They are here for compatability
213 ** of the function prototype.
214 **
215 *******************************************************************************/
GKI_create_task(TASKPTR task_entry,UINT8 task_id,INT8 * taskname,UINT16 * stack,UINT16 stacksize,void * pCondVar,void * pMutex)216 UINT8 GKI_create_task (TASKPTR task_entry, UINT8 task_id, INT8 *taskname, UINT16 *stack, UINT16 stacksize, void* pCondVar, void* pMutex)
217 {
218 UINT16 i;
219 UINT8 *p;
220 struct sched_param param;
221 int policy, ret = 0;
222 pthread_attr_t attr1;
223
224 GKI_TRACE_5 ("GKI_create_task func=0x%x id=%d name=%s stack=0x%x stackSize=%d", task_entry, task_id, taskname, stack, stacksize);
225
226 if (task_id >= GKI_MAX_TASKS)
227 {
228 GKI_TRACE_0("Error! task ID > max task allowed");
229 return (GKI_FAILURE);
230 }
231
232
233 gki_cb.com.OSRdyTbl[task_id] = TASK_READY;
234 gki_cb.com.OSTName[task_id] = taskname;
235 gki_cb.com.OSWaitTmr[task_id] = 0;
236 gki_cb.com.OSWaitEvt[task_id] = 0;
237
238 /* Initialize mutex and condition variable objects for events and timeouts */
239 pthread_mutex_init(&gki_cb.os.thread_evt_mutex[task_id], NULL);
240 pthread_cond_init (&gki_cb.os.thread_evt_cond[task_id], NULL);
241 pthread_mutex_init(&gki_cb.os.thread_timeout_mutex[task_id], NULL);
242 pthread_cond_init (&gki_cb.os.thread_timeout_cond[task_id], NULL);
243
244 pthread_attr_init(&attr1);
245 /* by default, pthread creates a joinable thread */
246 #if ( FALSE == GKI_PTHREAD_JOINABLE )
247 pthread_attr_setdetachstate(&attr1, PTHREAD_CREATE_DETACHED);
248
249 GKI_TRACE_3("GKI creating task %i, pCond/pMutex=%x/%x", task_id, pCondVar, pMutex);
250 #else
251 GKI_TRACE_1("GKI creating JOINABLE task %i", task_id);
252 #endif
253
254 /* On Android, the new tasks starts running before 'gki_cb.os.thread_id[task_id]' is initialized */
255 /* Pass task_id to new task so it can initialize gki_cb.os.thread_id[task_id] for it calls GKI_wait */
256 gki_pthread_info[task_id].task_id = task_id;
257 gki_pthread_info[task_id].task_entry = task_entry;
258 gki_pthread_info[task_id].params = 0;
259 gki_pthread_info[task_id].pCond = (pthread_cond_t*)pCondVar;
260 gki_pthread_info[task_id].pMutex = (pthread_mutex_t*)pMutex;
261
262 ret = pthread_create( &gki_cb.os.thread_id[task_id],
263 &attr1,
264 (void *)gki_task_entry,
265 &gki_pthread_info[task_id]);
266
267 if (ret != 0)
268 {
269 GKI_TRACE_2("pthread_create failed(%d), %s!", ret, taskname);
270 return GKI_FAILURE;
271 }
272
273 if(pthread_getschedparam(gki_cb.os.thread_id[task_id], &policy, ¶m)==0)
274 {
275 #if defined(PBS_SQL_TASK)
276 if (task_id == PBS_SQL_TASK)
277 {
278 GKI_TRACE_0("PBS SQL lowest priority task");
279 policy = SCHED_NORMAL;
280 }
281 else
282 #endif
283 {
284 policy = SCHED_RR;
285 param.sched_priority = 30 - task_id - 2;
286 }
287 pthread_setschedparam(gki_cb.os.thread_id[task_id], policy, ¶m);
288 }
289
290 GKI_TRACE_6( "Leaving GKI_create_task %x %d %x %s %x %d",
291 task_entry,
292 task_id,
293 gki_cb.os.thread_id[task_id],
294 taskname,
295 stack,
296 stacksize);
297
298 return (GKI_SUCCESS);
299 }
300
301 /*******************************************************************************
302 **
303 ** Function GKI_shutdown
304 **
305 ** Description shutdowns the GKI tasks/threads in from max task id to 0 and frees
306 ** pthread resources!
307 ** IMPORTANT: in case of join method, GKI_shutdown must be called outside
308 ** a GKI thread context!
309 **
310 ** Returns void
311 **
312 *******************************************************************************/
313 #define WAKE_LOCK_ID "brcm_nfca"
314 #define PARTIAL_WAKE_LOCK 1
315 extern int acquire_wake_lock(int lock, const char* id);
316 extern int release_wake_lock(const char* id);
317
GKI_shutdown(void)318 void GKI_shutdown(void)
319 {
320 UINT8 task_id;
321 volatile int *p_run_cond = &gki_cb.os.no_timer_suspend;
322 int oldCOnd = 0;
323 #if ( FALSE == GKI_PTHREAD_JOINABLE )
324 int i = 0;
325 #else
326 int result;
327 #endif
328
329 /* release threads and set as TASK_DEAD. going from low to high priority fixes
330 * GKI_exception problem due to btu->hci sleep request events */
331 for (task_id = GKI_MAX_TASKS; task_id > 0; task_id--)
332 {
333 if (gki_cb.com.OSRdyTbl[task_id - 1] != TASK_DEAD)
334 {
335 gki_cb.com.OSRdyTbl[task_id - 1] = TASK_DEAD;
336
337 /* paranoi settings, make sure that we do not execute any mailbox events */
338 gki_cb.com.OSWaitEvt[task_id-1] &= ~(TASK_MBOX_0_EVT_MASK|TASK_MBOX_1_EVT_MASK|
339 TASK_MBOX_2_EVT_MASK|TASK_MBOX_3_EVT_MASK);
340 GKI_send_event(task_id - 1, EVENT_MASK(GKI_SHUTDOWN_EVT));
341
342 #if ( FALSE == GKI_PTHREAD_JOINABLE )
343 i = 0;
344
345 while ((gki_cb.com.OSWaitEvt[task_id - 1] != 0) && (++i < 10))
346 usleep(100 * 1000);
347 #else
348 /* wait for proper Arnold Schwarzenegger task state */
349 result = pthread_join( gki_cb.os.thread_id[task_id-1], NULL );
350 if ( result < 0 )
351 {
352 GKI_TRACE_1( "pthread_join() FAILED: result: %d", result );
353 }
354 #endif
355 GKI_TRACE_1( "GKI_shutdown(): task %s dead", gki_cb.com.OSTName[task_id]);
356 GKI_exit_task(task_id - 1);
357 }
358 }
359
360 /* Destroy mutex and condition variable objects */
361 pthread_mutex_destroy(&gki_cb.os.GKI_mutex);
362 /* pthread_mutex_destroy(&GKI_sched_mutex); */
363 #if (GKI_DEBUG == TRUE)
364 pthread_mutex_destroy(&gki_cb.os.GKI_trace_mutex);
365 #endif
366 /* pthread_mutex_destroy(&thread_delay_mutex);
367 pthread_cond_destroy (&thread_delay_cond); */
368 #if ( FALSE == GKI_PTHREAD_JOINABLE )
369 i = 0;
370 #endif
371
372 #ifdef NO_GKI_RUN_RETURN
373 shutdown_timer = 1;
374 #endif
375 if (gki_cb.os.gki_timer_wake_lock_on)
376 {
377 GKI_TRACE_0("GKI_shutdown : release_wake_lock(brcm_btld)");
378 release_wake_lock(WAKE_LOCK_ID);
379 gki_cb.os.gki_timer_wake_lock_on = 0;
380 }
381 oldCOnd = *p_run_cond;
382 *p_run_cond = GKI_TIMER_TICK_EXIT_COND;
383 if (oldCOnd == GKI_TIMER_TICK_STOP_COND)
384 pthread_cond_signal( &gki_cb.os.gki_timer_cond );
385
386 }
387
388 /*******************************************************************************
389 **
390 ** Function GKI_run
391 **
392 ** Description This function runs a task
393 **
394 ** Parameters: start: TRUE start system tick (again), FALSE stop
395 **
396 ** Returns void
397 **
398 *********************************************************************************/
gki_system_tick_start_stop_cback(BOOLEAN start)399 void gki_system_tick_start_stop_cback(BOOLEAN start)
400 {
401 tGKI_OS *p_os = &gki_cb.os;
402 volatile int *p_run_cond = &p_os->no_timer_suspend;
403 volatile static int wake_lock_count;
404 if ( FALSE == start )
405 {
406 /* this can lead to a race condition. however as we only read this variable in the timer loop
407 * we should be fine with this approach. otherwise uncomment below mutexes.
408 */
409 /* GKI_disable(); */
410 *p_run_cond = GKI_TIMER_TICK_STOP_COND;
411 /* GKI_enable(); */
412 #ifdef GKI_TICK_TIMER_DEBUG
413 BT_TRACE_1( TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, ">>> STOP GKI_timer_update(), wake_lock_count:%d", --wake_lock_count);
414 #endif
415 release_wake_lock(WAKE_LOCK_ID);
416 gki_cb.os.gki_timer_wake_lock_on = 0;
417 }
418 else
419 {
420 /* restart GKI_timer_update() loop */
421 acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
422 gki_cb.os.gki_timer_wake_lock_on = 1;
423 *p_run_cond = GKI_TIMER_TICK_RUN_COND;
424 pthread_mutex_lock( &p_os->gki_timer_mutex );
425 pthread_cond_signal( &p_os->gki_timer_cond );
426 pthread_mutex_unlock( &p_os->gki_timer_mutex );
427
428 #ifdef GKI_TICK_TIMER_DEBUG
429 BT_TRACE_1( TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, ">>> START GKI_timer_update(), wake_lock_count:%d", ++wake_lock_count );
430 #endif
431 }
432 }
433
434
435 /*******************************************************************************
436 **
437 ** Function timer_thread
438 **
439 ** Description Timer thread
440 **
441 ** Parameters: id - (input) timer ID
442 **
443 ** Returns void
444 **
445 *********************************************************************************/
446 #ifdef NO_GKI_RUN_RETURN
timer_thread(signed long id)447 void timer_thread(signed long id)
448 {
449 GKI_TRACE_1("%s enter", __func__);
450 struct timespec delay;
451 int timeout = 1000; /* 10 ms per system tick */
452 int err;
453
454 while(!shutdown_timer)
455 {
456 delay.tv_sec = timeout / 1000;
457 delay.tv_nsec = 1000 * 1000 * (timeout%1000);
458
459 /* [u]sleep can't be used because it uses SIGALRM */
460
461 do
462 {
463 err = nanosleep(&delay, &delay);
464 } while (err < 0 && errno ==EINTR);
465
466 GKI_timer_update(1);
467 }
468 GKI_TRACE_1("%s exit", __func__);
469 pthread_exit(NULL);
470 }
471 #endif
472
473 /*******************************************************************************
474 **
475 ** Function GKI_run
476 **
477 ** Description This function runs a task
478 **
479 ** Parameters: p_task_id - (input) pointer to task id
480 **
481 ** Returns void
482 **
483 ** NOTE This function is only needed for operating systems where
484 ** starting a task is a 2-step process. Most OS's do it in
485 ** one step, If your OS does it in one step, this function
486 ** should be empty.
487 *********************************************************************************/
GKI_run(void * p_task_id)488 void GKI_run (void *p_task_id)
489 {
490 GKI_TRACE_1("%s enter", __func__);
491 struct timespec delay;
492 int err = 0;
493 volatile int * p_run_cond = &gki_cb.os.no_timer_suspend;
494
495 #ifndef GKI_NO_TICK_STOP
496 /* register start stop function which disable timer loop in GKI_run() when no timers are
497 * in any GKI/BTA/BTU this should save power when BTLD is idle! */
498 GKI_timer_queue_register_callback( gki_system_tick_start_stop_cback );
499 APPL_TRACE_DEBUG0( "GKI_run(): Start/Stop GKI_timer_update_registered!" );
500 #endif
501
502 #ifdef NO_GKI_RUN_RETURN
503 GKI_TRACE_0("GKI_run == NO_GKI_RUN_RETURN");
504 pthread_attr_t timer_attr;
505
506 shutdown_timer = 0;
507
508 pthread_attr_init(&timer_attr);
509 pthread_attr_setdetachstate(&timer_attr, PTHREAD_CREATE_DETACHED);
510 if (pthread_create( &timer_thread_id,
511 &timer_attr,
512 timer_thread,
513 NULL) != 0 )
514 {
515 GKI_TRACE_0("GKI_run: pthread_create failed to create timer_thread!");
516 return GKI_FAILURE;
517 }
518 #else
519 GKI_TRACE_2("GKI_run, run_cond(%x)=%d ", p_run_cond, *p_run_cond);
520 for (;GKI_TIMER_TICK_EXIT_COND != *p_run_cond;)
521 {
522 do
523 {
524 /* adjust hear bit tick in btld by changning TICKS_PER_SEC!!!!! this formula works only for
525 * 1-1000ms heart beat units! */
526 delay.tv_sec = LINUX_SEC / 1000;
527 delay.tv_nsec = 1000 * 1000 * (LINUX_SEC % 1000);
528
529 /* [u]sleep can't be used because it uses SIGALRM */
530 do
531 {
532 err = nanosleep(&delay, &delay);
533 } while (err < 0 && errno == EINTR);
534
535 if (GKI_TIMER_TICK_RUN_COND != *p_run_cond)
536 break; //GKI has shutdown
537
538 /* the unit should be alsways 1 (1 tick). only if you vary for some reason heart beat tick
539 * e.g. power saving you may want to provide more ticks
540 */
541 GKI_timer_update( 1 );
542 /* BT_TRACE_2( TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, "update: tv_sec: %d, tv_nsec: %d", delay.tv_sec, delay.tv_nsec ); */
543 } while ( GKI_TIMER_TICK_RUN_COND == *p_run_cond);
544
545 /* currently on reason to exit above loop is no_timer_suspend == GKI_TIMER_TICK_STOP_COND
546 * block timer main thread till re-armed by */
547 #ifdef GKI_TICK_TIMER_DEBUG
548 BT_TRACE_0( TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, ">>> SUSPENDED GKI_timer_update()" );
549 #endif
550 if (GKI_TIMER_TICK_EXIT_COND != *p_run_cond) {
551 GKI_TRACE_1("%s waiting timer mutex", __func__);
552 pthread_mutex_lock( &gki_cb.os.gki_timer_mutex );
553 pthread_cond_wait( &gki_cb.os.gki_timer_cond, &gki_cb.os.gki_timer_mutex );
554 pthread_mutex_unlock( &gki_cb.os.gki_timer_mutex );
555 GKI_TRACE_1("%s exited timer mutex", __func__);
556 }
557 /* potentially we need to adjust os gki_cb.com.OSTicks */
558
559 #ifdef GKI_TICK_TIMER_DEBUG
560 BT_TRACE_1( TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, ">>> RESTARTED GKI_timer_update(): run_cond: %d",
561 *p_run_cond );
562 #endif
563 } /* for */
564 #endif
565 GKI_TRACE_1("%s exit", __func__);
566 return(0);
567 }
568
569
570 /*******************************************************************************
571 **
572 ** Function GKI_stop
573 **
574 ** Description This function is called to stop
575 ** the tasks and timers when the system is being stopped
576 **
577 ** Returns void
578 **
579 ** NOTE This function is NOT called by the Widcomm stack and
580 ** profiles. If you want to use it in your own implementation,
581 ** put specific code here.
582 **
583 *******************************************************************************/
GKI_stop(void)584 void GKI_stop (void)
585 {
586 UINT8 task_id;
587
588 /* gki_queue_timer_cback(FALSE); */
589 /* TODO - add code here if needed*/
590
591 for(task_id = 0; task_id<GKI_MAX_TASKS; task_id++)
592 {
593 if(gki_cb.com.OSRdyTbl[task_id] != TASK_DEAD)
594 {
595 GKI_exit_task(task_id);
596 }
597 }
598 }
599
600
601 /*******************************************************************************
602 **
603 ** Function GKI_wait
604 **
605 ** Description This function is called by tasks to wait for a specific
606 ** event or set of events. The task may specify the duration
607 ** that it wants to wait for, or 0 if infinite.
608 **
609 ** Parameters: flag - (input) the event or set of events to wait for
610 ** timeout - (input) the duration that the task wants to wait
611 ** for the specific events (in system ticks)
612 **
613 **
614 ** Returns the event mask of received events or zero if timeout
615 **
616 *******************************************************************************/
GKI_wait(UINT16 flag,UINT32 timeout)617 UINT16 GKI_wait (UINT16 flag, UINT32 timeout)
618 {
619 UINT16 evt;
620 UINT8 rtask;
621 struct timespec abstime = { 0, 0 };
622 int sec;
623 int nano_sec;
624
625 rtask = GKI_get_taskid();
626 GKI_TRACE_3("GKI_wait %d %x %d", rtask, flag, timeout);
627 if (rtask >= GKI_MAX_TASKS) {
628 pthread_exit(NULL);
629 return 0;
630 }
631
632 gki_pthread_info_t* p_pthread_info = &gki_pthread_info[rtask];
633 if (p_pthread_info->pCond != NULL && p_pthread_info->pMutex != NULL) {
634 int ret;
635 GKI_TRACE_3("GKI_wait task=%i, pCond/pMutex = %x/%x", rtask, p_pthread_info->pCond, p_pthread_info->pMutex);
636 ret = pthread_mutex_lock(p_pthread_info->pMutex);
637 ret = pthread_cond_signal(p_pthread_info->pCond);
638 ret = pthread_mutex_unlock(p_pthread_info->pMutex);
639 p_pthread_info->pMutex = NULL;
640 p_pthread_info->pCond = NULL;
641 }
642 gki_cb.com.OSWaitForEvt[rtask] = flag;
643
644 /* protect OSWaitEvt[rtask] from modification from an other thread */
645 pthread_mutex_lock(&gki_cb.os.thread_evt_mutex[rtask]);
646
647 #if 0 /* for clean scheduling we probably should always call pthread_cond_wait() */
648 /* Check if anything in any of the mailboxes. There is a potential race condition where OSTaskQFirst[rtask]
649 has been modified. however this should only result in addtional call to pthread_cond_wait() but as
650 the cond is met, it will exit immediately (depending on schedulling) */
651 if (gki_cb.com.OSTaskQFirst[rtask][0])
652 gki_cb.com.OSWaitEvt[rtask] |= TASK_MBOX_0_EVT_MASK;
653 if (gki_cb.com.OSTaskQFirst[rtask][1])
654 gki_cb.com.OSWaitEvt[rtask] |= TASK_MBOX_1_EVT_MASK;
655 if (gki_cb.com.OSTaskQFirst[rtask][2])
656 gki_cb.com.OSWaitEvt[rtask] |= TASK_MBOX_2_EVT_MASK;
657 if (gki_cb.com.OSTaskQFirst[rtask][3])
658 gki_cb.com.OSWaitEvt[rtask] |= TASK_MBOX_3_EVT_MASK;
659 #endif
660
661 if (!(gki_cb.com.OSWaitEvt[rtask] & flag))
662 {
663 if (timeout)
664 {
665 // timeout = GKI_MS_TO_TICKS(timeout); /* convert from milliseconds to ticks */
666
667 /* get current system time */
668 // clock_gettime(CLOCK_MONOTONIC, &currSysTime);
669 // abstime.tv_sec = currSysTime.time;
670 // abstime.tv_nsec = NANOSEC_PER_MILLISEC * currSysTime.millitm;
671 clock_gettime(CLOCK_MONOTONIC, &abstime);
672
673 /* add timeout */
674 sec = timeout / 1000;
675 nano_sec = (timeout % 1000) * NANOSEC_PER_MILLISEC;
676 abstime.tv_nsec += nano_sec;
677 if (abstime.tv_nsec > NSEC_PER_SEC)
678 {
679 abstime.tv_sec += (abstime.tv_nsec / NSEC_PER_SEC);
680 abstime.tv_nsec = abstime.tv_nsec % NSEC_PER_SEC;
681 }
682 abstime.tv_sec += sec;
683
684 pthread_cond_timedwait_monotonic(&gki_cb.os.thread_evt_cond[rtask],
685 &gki_cb.os.thread_evt_mutex[rtask], &abstime);
686
687 }
688 else
689 {
690 pthread_cond_wait(&gki_cb.os.thread_evt_cond[rtask], &gki_cb.os.thread_evt_mutex[rtask]);
691 }
692
693 /* TODO: check, this is probably neither not needed depending on phtread_cond_wait() implmentation,
694 e.g. it looks like it is implemented as a counter in which case multiple cond_signal
695 should NOT be lost! */
696 // we are waking up after waiting for some events, so refresh variables
697 // no need to call GKI_disable() here as we know that we will have some events as we've been waking up after condition pending or timeout
698 if (gki_cb.com.OSTaskQFirst[rtask][0])
699 gki_cb.com.OSWaitEvt[rtask] |= TASK_MBOX_0_EVT_MASK;
700 if (gki_cb.com.OSTaskQFirst[rtask][1])
701 gki_cb.com.OSWaitEvt[rtask] |= TASK_MBOX_1_EVT_MASK;
702 if (gki_cb.com.OSTaskQFirst[rtask][2])
703 gki_cb.com.OSWaitEvt[rtask] |= TASK_MBOX_2_EVT_MASK;
704 if (gki_cb.com.OSTaskQFirst[rtask][3])
705 gki_cb.com.OSWaitEvt[rtask] |= TASK_MBOX_3_EVT_MASK;
706
707 if (gki_cb.com.OSRdyTbl[rtask] == TASK_DEAD)
708 {
709 gki_cb.com.OSWaitEvt[rtask] = 0;
710 /* unlock thread_evt_mutex as pthread_cond_wait() does auto lock when cond is met */
711 pthread_mutex_unlock(&gki_cb.os.thread_evt_mutex[rtask]);
712 BT_TRACE_1( TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, "GKI TASK_DEAD received. exit thread %d...", rtask );
713
714 gki_cb.os.thread_id[rtask] = 0;
715 pthread_exit(NULL);
716 return (EVENT_MASK(GKI_SHUTDOWN_EVT));
717 }
718 }
719
720 /* Clear the wait for event mask */
721 gki_cb.com.OSWaitForEvt[rtask] = 0;
722
723 /* Return only those bits which user wants... */
724 evt = gki_cb.com.OSWaitEvt[rtask] & flag;
725
726 /* Clear only those bits which user wants... */
727 gki_cb.com.OSWaitEvt[rtask] &= ~flag;
728
729 /* unlock thread_evt_mutex as pthread_cond_wait() does auto lock mutex when cond is met */
730 pthread_mutex_unlock(&gki_cb.os.thread_evt_mutex[rtask]);
731 GKI_TRACE_4("GKI_wait %d %x %d %x resumed", rtask, flag, timeout, evt);
732
733 return (evt);
734 }
735
736
737 /*******************************************************************************
738 **
739 ** Function GKI_delay
740 **
741 ** Description This function is called by tasks to sleep unconditionally
742 ** for a specified amount of time. The duration is in milliseconds
743 **
744 ** Parameters: timeout - (input) the duration in milliseconds
745 **
746 ** Returns void
747 **
748 *******************************************************************************/
749
GKI_delay(UINT32 timeout)750 void GKI_delay (UINT32 timeout)
751 {
752 UINT8 rtask = GKI_get_taskid();
753 struct timespec delay;
754 int err;
755
756 GKI_TRACE_2("GKI_delay %d %d", rtask, timeout);
757
758 delay.tv_sec = timeout / 1000;
759 delay.tv_nsec = 1000 * 1000 * (timeout%1000);
760
761 /* [u]sleep can't be used because it uses SIGALRM */
762
763 do {
764 err = nanosleep(&delay, &delay);
765 } while (err < 0 && errno ==EINTR);
766
767 /* Check if task was killed while sleeping */
768 /* NOTE
769 ** if you do not implement task killing, you do not
770 ** need this check.
771 */
772 if (rtask && gki_cb.com.OSRdyTbl[rtask] == TASK_DEAD)
773 {
774 }
775
776 GKI_TRACE_2("GKI_delay %d %d done", rtask, timeout);
777 return;
778 }
779
780
781 /*******************************************************************************
782 **
783 ** Function GKI_send_event
784 **
785 ** Description This function is called by tasks to send events to other
786 ** tasks. Tasks can also send events to themselves.
787 **
788 ** Parameters: task_id - (input) The id of the task to which the event has to
789 ** be sent
790 ** event - (input) The event that has to be sent
791 **
792 **
793 ** Returns GKI_SUCCESS if all OK, else GKI_FAILURE
794 **
795 *******************************************************************************/
GKI_send_event(UINT8 task_id,UINT16 event)796 UINT8 GKI_send_event (UINT8 task_id, UINT16 event)
797 {
798 GKI_TRACE_2("GKI_send_event %d %x", task_id, event);
799
800 /* use efficient coding to avoid pipeline stalls */
801 if (task_id < GKI_MAX_TASKS)
802 {
803 /* protect OSWaitEvt[task_id] from manipulation in GKI_wait() */
804 pthread_mutex_lock(&gki_cb.os.thread_evt_mutex[task_id]);
805
806 /* Set the event bit */
807 gki_cb.com.OSWaitEvt[task_id] |= event;
808
809 pthread_cond_signal(&gki_cb.os.thread_evt_cond[task_id]);
810
811 pthread_mutex_unlock(&gki_cb.os.thread_evt_mutex[task_id]);
812
813 GKI_TRACE_2("GKI_send_event %d %x done", task_id, event);
814 return ( GKI_SUCCESS );
815 }
816 return (GKI_FAILURE);
817 }
818
819
820 /*******************************************************************************
821 **
822 ** Function GKI_isend_event
823 **
824 ** Description This function is called from ISRs to send events to other
825 ** tasks. The only difference between this function and GKI_send_event
826 ** is that this function assumes interrupts are already disabled.
827 **
828 ** Parameters: task_id - (input) The destination task Id for the event.
829 ** event - (input) The event flag
830 **
831 ** Returns GKI_SUCCESS if all OK, else GKI_FAILURE
832 **
833 ** NOTE This function is NOT called by the Widcomm stack and
834 ** profiles. If you want to use it in your own implementation,
835 ** put your code here, otherwise you can delete the entire
836 ** body of the function.
837 **
838 *******************************************************************************/
GKI_isend_event(UINT8 task_id,UINT16 event)839 UINT8 GKI_isend_event (UINT8 task_id, UINT16 event)
840 {
841
842 GKI_TRACE_2("GKI_isend_event %d %x", task_id, event);
843 GKI_TRACE_2("GKI_isend_event %d %x done", task_id, event);
844 return GKI_send_event(task_id, event);
845 }
846
847
848 /*******************************************************************************
849 **
850 ** Function GKI_get_taskid
851 **
852 ** Description This function gets the currently running task ID.
853 **
854 ** Returns task ID
855 **
856 ** NOTE The Widcomm upper stack and profiles may run as a single task.
857 ** If you only have one GKI task, then you can hard-code this
858 ** function to return a '1'. Otherwise, you should have some
859 ** OS-specific method to determine the current task.
860 **
861 *******************************************************************************/
GKI_get_taskid(void)862 UINT8 GKI_get_taskid (void)
863 {
864 int i;
865
866 pthread_t thread_id = pthread_self( );
867 for (i = 0; i < GKI_MAX_TASKS; i++) {
868 if (gki_cb.os.thread_id[i] == thread_id) {
869 GKI_TRACE_2("GKI_get_taskid %x %d done", thread_id, i);
870 return(i);
871 }
872 }
873
874 GKI_TRACE_1("GKI_get_taskid: thread id = %x, task id = -1", thread_id);
875
876 return(-1);
877 }
878
879 /*******************************************************************************
880 **
881 ** Function GKI_map_taskname
882 **
883 ** Description This function gets the task name of the taskid passed as arg.
884 ** If GKI_MAX_TASKS is passed as arg the currently running task
885 ** name is returned
886 **
887 ** Parameters: task_id - (input) The id of the task whose name is being
888 ** sought. GKI_MAX_TASKS is passed to get the name of the
889 ** currently running task.
890 **
891 ** Returns pointer to task name
892 **
893 ** NOTE this function needs no customization
894 **
895 *******************************************************************************/
GKI_map_taskname(UINT8 task_id)896 INT8 *GKI_map_taskname (UINT8 task_id)
897 {
898 GKI_TRACE_1("GKI_map_taskname %d", task_id);
899
900 if (task_id < GKI_MAX_TASKS)
901 {
902 GKI_TRACE_2("GKI_map_taskname %d %s done", task_id, gki_cb.com.OSTName[task_id]);
903 return (gki_cb.com.OSTName[task_id]);
904 }
905 else if (task_id == GKI_MAX_TASKS )
906 {
907 return (gki_cb.com.OSTName[GKI_get_taskid()]);
908 }
909 else
910 {
911 return "BAD";
912 }
913 }
914
915
916 /*******************************************************************************
917 **
918 ** Function GKI_enable
919 **
920 ** Description This function enables interrupts.
921 **
922 ** Returns void
923 **
924 *******************************************************************************/
GKI_enable(void)925 void GKI_enable (void)
926 {
927 GKI_TRACE_0("GKI_enable");
928 pthread_mutex_unlock(&gki_cb.os.GKI_mutex);
929 /* pthread_mutex_xx is nesting save, no need for this: already_disabled = 0; */
930 GKI_TRACE_0("Leaving GKI_enable");
931 return;
932 }
933
934
935 /*******************************************************************************
936 **
937 ** Function GKI_disable
938 **
939 ** Description This function disables interrupts.
940 **
941 ** Returns void
942 **
943 *******************************************************************************/
944
GKI_disable(void)945 void GKI_disable (void)
946 {
947 //GKI_TRACE_0("GKI_disable");
948
949 /* pthread_mutex_xx is nesting save, no need for this: if (!already_disabled) {
950 already_disabled = 1; */
951 pthread_mutex_lock(&gki_cb.os.GKI_mutex);
952 /* } */
953 //GKI_TRACE_0("Leaving GKI_disable");
954 return;
955 }
956
957
958 /*******************************************************************************
959 **
960 ** Function GKI_exception
961 **
962 ** Description This function throws an exception.
963 ** This is normally only called for a nonrecoverable error.
964 **
965 ** Parameters: code - (input) The code for the error
966 ** msg - (input) The message that has to be logged
967 **
968 ** Returns void
969 **
970 *******************************************************************************/
971
GKI_exception(UINT16 code,char * msg)972 void GKI_exception (UINT16 code, char *msg)
973 {
974 UINT8 task_id;
975 int i = 0;
976
977 GKI_TRACE_ERROR_0( "GKI_exception(): Task State Table");
978
979 for(task_id = 0; task_id < GKI_MAX_TASKS; task_id++)
980 {
981 GKI_TRACE_ERROR_3( "TASK ID [%d] task name [%s] state [%d]",
982 task_id,
983 gki_cb.com.OSTName[task_id],
984 gki_cb.com.OSRdyTbl[task_id]);
985 }
986
987 GKI_TRACE_ERROR_2("GKI_exception %d %s", code, msg);
988 GKI_TRACE_ERROR_0( "********************************************************************");
989 GKI_TRACE_ERROR_2( "* GKI_exception(): %d %s", code, msg);
990 GKI_TRACE_ERROR_0( "********************************************************************");
991
992 #if (GKI_DEBUG == TRUE)
993 GKI_disable();
994
995 if (gki_cb.com.ExceptionCnt < GKI_MAX_EXCEPTION)
996 {
997 EXCEPTION_T *pExp;
998
999 pExp = &gki_cb.com.Exception[gki_cb.com.ExceptionCnt++];
1000 pExp->type = code;
1001 pExp->taskid = GKI_get_taskid();
1002 strncpy((char *)pExp->msg, msg, GKI_MAX_EXCEPTION_MSGLEN - 1);
1003 }
1004
1005 GKI_enable();
1006 #endif
1007
1008 GKI_TRACE_ERROR_2("GKI_exception %d %s done", code, msg);
1009
1010
1011 return;
1012 }
1013
1014
1015 /*******************************************************************************
1016 **
1017 ** Function GKI_get_time_stamp
1018 **
1019 ** Description This function formats the time into a user area
1020 **
1021 ** Parameters: tbuf - (output) the address to the memory containing the
1022 ** formatted time
1023 **
1024 ** Returns the address of the user area containing the formatted time
1025 ** The format of the time is ????
1026 **
1027 ** NOTE This function is only called by OBEX.
1028 **
1029 *******************************************************************************/
GKI_get_time_stamp(INT8 * tbuf)1030 INT8 *GKI_get_time_stamp (INT8 *tbuf)
1031 {
1032 UINT32 ms_time;
1033 UINT32 s_time;
1034 UINT32 m_time;
1035 UINT32 h_time;
1036 INT8 *p_out = tbuf;
1037
1038 gki_cb.com.OSTicks = times(0);
1039 ms_time = GKI_TICKS_TO_MS(gki_cb.com.OSTicks);
1040 s_time = ms_time/100; /* 100 Ticks per second */
1041 m_time = s_time/60;
1042 h_time = m_time/60;
1043
1044 ms_time -= s_time*100;
1045 s_time -= m_time*60;
1046 m_time -= h_time*60;
1047
1048 *p_out++ = (INT8)((h_time / 10) + '0');
1049 *p_out++ = (INT8)((h_time % 10) + '0');
1050 *p_out++ = ':';
1051 *p_out++ = (INT8)((m_time / 10) + '0');
1052 *p_out++ = (INT8)((m_time % 10) + '0');
1053 *p_out++ = ':';
1054 *p_out++ = (INT8)((s_time / 10) + '0');
1055 *p_out++ = (INT8)((s_time % 10) + '0');
1056 *p_out++ = ':';
1057 *p_out++ = (INT8)((ms_time / 10) + '0');
1058 *p_out++ = (INT8)((ms_time % 10) + '0');
1059 *p_out++ = ':';
1060 *p_out = 0;
1061
1062 return (tbuf);
1063 }
1064
1065
1066 /*******************************************************************************
1067 **
1068 ** Function GKI_register_mempool
1069 **
1070 ** Description This function registers a specific memory pool.
1071 **
1072 ** Parameters: p_mem - (input) pointer to the memory pool
1073 **
1074 ** Returns void
1075 **
1076 ** NOTE This function is NOT called by the Widcomm stack and
1077 ** profiles. If your OS has different memory pools, you
1078 ** can tell GKI the pool to use by calling this function.
1079 **
1080 *******************************************************************************/
GKI_register_mempool(void * p_mem)1081 void GKI_register_mempool (void *p_mem)
1082 {
1083 gki_cb.com.p_user_mempool = p_mem;
1084
1085 return;
1086 }
1087
1088 /*******************************************************************************
1089 **
1090 ** Function GKI_os_malloc
1091 **
1092 ** Description This function allocates memory
1093 **
1094 ** Parameters: size - (input) The size of the memory that has to be
1095 ** allocated
1096 **
1097 ** Returns the address of the memory allocated, or NULL if failed
1098 **
1099 ** NOTE This function is called by the Widcomm stack when
1100 ** dynamic memory allocation is used. (see dyn_mem.h)
1101 **
1102 *******************************************************************************/
GKI_os_malloc(UINT32 size)1103 void *GKI_os_malloc (UINT32 size)
1104 {
1105 return (malloc(size));
1106 }
1107
1108 /*******************************************************************************
1109 **
1110 ** Function GKI_os_free
1111 **
1112 ** Description This function frees memory
1113 **
1114 ** Parameters: size - (input) The address of the memory that has to be
1115 ** freed
1116 **
1117 ** Returns void
1118 **
1119 ** NOTE This function is NOT called by the Widcomm stack and
1120 ** profiles. It is only called from within GKI if dynamic
1121 **
1122 *******************************************************************************/
GKI_os_free(void * p_mem)1123 void GKI_os_free (void *p_mem)
1124 {
1125 if(p_mem != NULL)
1126 free(p_mem);
1127 return;
1128 }
1129
1130
1131 /*******************************************************************************
1132 **
1133 ** Function GKI_suspend_task()
1134 **
1135 ** Description This function suspends the task specified in the argument.
1136 **
1137 ** Parameters: task_id - (input) the id of the task that has to suspended
1138 **
1139 ** Returns GKI_SUCCESS if all OK, else GKI_FAILURE
1140 **
1141 ** NOTE This function is NOT called by the Widcomm stack and
1142 ** profiles. If you want to implement task suspension capability,
1143 ** put specific code here.
1144 **
1145 *******************************************************************************/
GKI_suspend_task(UINT8 task_id)1146 UINT8 GKI_suspend_task (UINT8 task_id)
1147 {
1148 GKI_TRACE_1("GKI_suspend_task %d - NOT implemented", task_id);
1149
1150
1151 GKI_TRACE_1("GKI_suspend_task %d done", task_id);
1152
1153 return (GKI_SUCCESS);
1154 }
1155
1156
1157 /*******************************************************************************
1158 **
1159 ** Function GKI_resume_task()
1160 **
1161 ** Description This function resumes the task specified in the argument.
1162 **
1163 ** Parameters: task_id - (input) the id of the task that has to resumed
1164 **
1165 ** Returns GKI_SUCCESS if all OK
1166 **
1167 ** NOTE This function is NOT called by the Widcomm stack and
1168 ** profiles. If you want to implement task suspension capability,
1169 ** put specific code here.
1170 **
1171 *******************************************************************************/
GKI_resume_task(UINT8 task_id)1172 UINT8 GKI_resume_task (UINT8 task_id)
1173 {
1174 GKI_TRACE_1("GKI_resume_task %d - NOT implemented", task_id);
1175
1176
1177 GKI_TRACE_1("GKI_resume_task %d done", task_id);
1178
1179 return (GKI_SUCCESS);
1180 }
1181
1182
1183 /*******************************************************************************
1184 **
1185 ** Function GKI_exit_task
1186 **
1187 ** Description This function is called to stop a GKI task.
1188 **
1189 ** Parameters: task_id - (input) the id of the task that has to be stopped
1190 **
1191 ** Returns void
1192 **
1193 ** NOTE This function is NOT called by the Widcomm stack and
1194 ** profiles. If you want to use it in your own implementation,
1195 ** put specific code here to kill a task.
1196 **
1197 *******************************************************************************/
GKI_exit_task(UINT8 task_id)1198 void GKI_exit_task (UINT8 task_id)
1199 {
1200 GKI_disable();
1201 gki_cb.com.OSRdyTbl[task_id] = TASK_DEAD;
1202
1203 /* Destroy mutex and condition variable objects */
1204 pthread_mutex_destroy(&gki_cb.os.thread_evt_mutex[task_id]);
1205 pthread_cond_destroy (&gki_cb.os.thread_evt_cond[task_id]);
1206 pthread_mutex_destroy(&gki_cb.os.thread_timeout_mutex[task_id]);
1207 pthread_cond_destroy (&gki_cb.os.thread_timeout_cond[task_id]);
1208
1209 GKI_enable();
1210
1211 //GKI_send_event(task_id, EVENT_MASK(GKI_SHUTDOWN_EVT));
1212
1213 GKI_TRACE_1("GKI_exit_task %d done", task_id);
1214 return;
1215 }
1216
1217
1218 /*******************************************************************************
1219 **
1220 ** Function GKI_sched_lock
1221 **
1222 ** Description This function is called by tasks to disable scheduler
1223 ** task context switching.
1224 **
1225 ** Returns void
1226 **
1227 ** NOTE This function is NOT called by the Widcomm stack and
1228 ** profiles. If you want to use it in your own implementation,
1229 ** put code here to tell the OS to disable context switching.
1230 **
1231 *******************************************************************************/
GKI_sched_lock(void)1232 void GKI_sched_lock(void)
1233 {
1234 GKI_TRACE_0("GKI_sched_lock");
1235 GKI_disable ();
1236 return;
1237 }
1238
1239
1240 /*******************************************************************************
1241 **
1242 ** Function GKI_sched_unlock
1243 **
1244 ** Description This function is called by tasks to enable scheduler switching.
1245 **
1246 ** Returns void
1247 **
1248 ** NOTE This function is NOT called by the Widcomm stack and
1249 ** profiles. If you want to use it in your own implementation,
1250 ** put code here to tell the OS to re-enable context switching.
1251 **
1252 *******************************************************************************/
GKI_sched_unlock(void)1253 void GKI_sched_unlock(void)
1254 {
1255 GKI_TRACE_0("GKI_sched_unlock");
1256 GKI_enable ();
1257 }
1258
1259 /*******************************************************************************
1260 **
1261 ** Function GKI_shiftdown
1262 **
1263 ** Description shift memory down (to make space to insert a record)
1264 **
1265 *******************************************************************************/
GKI_shiftdown(UINT8 * p_mem,UINT32 len,UINT32 shift_amount)1266 void GKI_shiftdown (UINT8 *p_mem, UINT32 len, UINT32 shift_amount)
1267 {
1268 register UINT8 *ps = p_mem + len - 1;
1269 register UINT8 *pd = ps + shift_amount;
1270 register UINT32 xx;
1271
1272 for (xx = 0; xx < len; xx++)
1273 *pd-- = *ps--;
1274 }
1275
1276 /*******************************************************************************
1277 **
1278 ** Function GKI_shiftup
1279 **
1280 ** Description shift memory up (to delete a record)
1281 **
1282 *******************************************************************************/
GKI_shiftup(UINT8 * p_dest,UINT8 * p_src,UINT32 len)1283 void GKI_shiftup (UINT8 *p_dest, UINT8 *p_src, UINT32 len)
1284 {
1285 register UINT8 *ps = p_src;
1286 register UINT8 *pd = p_dest;
1287 register UINT32 xx;
1288
1289 for (xx = 0; xx < len; xx++)
1290 *pd++ = *ps++;
1291 }
1292
1293
1294