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