1 /******************************************************************************
2 *
3 * Copyright (C) 2003-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
19 /******************************************************************************
20 *
21 * This is the main implementation file for the BTA system manager.
22 *
23 ******************************************************************************/
24
25 #include "btm_api.h"
26 #include "bta_api.h"
27 #include "bta_sys.h"
28 #include "bta_sys_int.h"
29 #include "bta_sys_ci.h"
30 #include "bta_sys_co.h"
31 #if BTA_FM_INCLUDED == TRUE
32 #include "bta_fm_api.h"
33 #endif
34 #if BTA_FMTX_INCLUDED == TRUE
35 #include "bta_fmtx_api.h"
36 #endif
37 #if GPS_INCLUDED == TRUE
38 #include "bta_gps_api.h"
39 #endif
40
41 #include "gki.h"
42 #include "ptim.h"
43 #include <string.h>
44 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
45 #include "bta_ar_api.h"
46 #endif
47 #include "utl.h"
48
49 /* protocol timer update period, in milliseconds */
50 #ifndef BTA_SYS_TIMER_PERIOD
51 #define BTA_SYS_TIMER_PERIOD 1000
52 #endif
53
54 /* system manager control block definition */
55 #if BTA_DYNAMIC_MEMORY == FALSE
56 tBTA_SYS_CB bta_sys_cb;
57 #endif
58
59 /* trace level */
60 /* TODO Bluedroid - Hard-coded trace levels - Needs to be configurable */
61 UINT8 appl_trace_level = BT_TRACE_LEVEL_WARNING; //APPL_INITIAL_TRACE_LEVEL;
62 UINT8 btif_trace_level = BT_TRACE_LEVEL_WARNING;
63
64 static const tBTA_SYS_REG bta_sys_hw_reg =
65 {
66 bta_sys_sm_execute,
67 NULL
68 };
69
70
71 /* type for action functions */
72 typedef void (*tBTA_SYS_ACTION)(tBTA_SYS_HW_MSG *p_data);
73
74 /* action function list */
75 const tBTA_SYS_ACTION bta_sys_action[] =
76 {
77 /* device manager local device API events - cf bta_sys.h for events */
78 bta_sys_hw_api_enable, /* 0 BTA_SYS_HW_API_ENABLE_EVT */
79 bta_sys_hw_evt_enabled, /* 1 BTA_SYS_HW_EVT_ENABLED_EVT */
80 bta_sys_hw_evt_stack_enabled, /* 2 BTA_SYS_HW_EVT_STACK_ENABLED_EVT */
81 bta_sys_hw_api_disable, /* 3 BTA_SYS_HW_API_DISABLE_EVT */
82 bta_sys_hw_evt_disabled, /* 4 BTA_SYS_HW_EVT_DISABLED_EVT */
83 bta_sys_hw_error /* 5 BTA_SYS_HW_ERROR_EVT */
84 };
85
86 /* state machine action enumeration list */
87 enum
88 {
89 /* device manager local device API events */
90 BTA_SYS_HW_API_ENABLE,
91 BTA_SYS_HW_EVT_ENABLED,
92 BTA_SYS_HW_EVT_STACK_ENABLED,
93 BTA_SYS_HW_API_DISABLE,
94 BTA_SYS_HW_EVT_DISABLED,
95 BTA_SYS_HW_ERROR
96 };
97
98 #define BTA_SYS_NUM_ACTIONS (BTA_SYS_MAX_EVT & 0x00ff)
99 #define BTA_SYS_IGNORE BTA_SYS_NUM_ACTIONS
100
101 /* state table information */
102 #define BTA_SYS_ACTIONS 2 /* number of actions */
103 #define BTA_SYS_NEXT_STATE 2 /* position of next state */
104 #define BTA_SYS_NUM_COLS 3 /* number of columns in state tables */
105
106
107 /* state table for OFF state */
108 const UINT8 bta_sys_hw_off[][BTA_SYS_NUM_COLS] =
109 {
110 /* Event Action 1 Action 2 Next State */
111 /* API_ENABLE */ {BTA_SYS_HW_API_ENABLE, BTA_SYS_IGNORE, BTA_SYS_HW_STARTING},
112 /* EVT_ENABLED */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_STARTING},
113 /* STACK_ENABLED */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_ON},
114 /* API_DISABLE */ {BTA_SYS_HW_EVT_DISABLED, BTA_SYS_IGNORE, BTA_SYS_HW_OFF},
115 /* EVT_DISABLED */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_OFF},
116 /* EVT_ERROR */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_OFF}
117 };
118
119 const UINT8 bta_sys_hw_starting[][BTA_SYS_NUM_COLS] =
120 {
121 /* Event Action 1 Action 2 Next State */
122 /* API_ENABLE */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_STARTING}, /* wait for completion event */
123 /* EVT_ENABLED */ {BTA_SYS_HW_EVT_ENABLED, BTA_SYS_IGNORE, BTA_SYS_HW_STARTING},
124 /* STACK_ENABLED */ {BTA_SYS_HW_EVT_STACK_ENABLED, BTA_SYS_IGNORE, BTA_SYS_HW_ON},
125 /* API_DISABLE */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_STOPPING}, /* successive disable/enable: change state wait for completion to disable */
126 /* EVT_DISABLED */ {BTA_SYS_HW_EVT_DISABLED, BTA_SYS_HW_API_ENABLE, BTA_SYS_HW_STARTING}, /* successive enable/disable: notify, then restart HW */
127 /* EVT_ERROR */ {BTA_SYS_HW_ERROR, BTA_SYS_IGNORE, BTA_SYS_HW_ON}
128 };
129
130 const UINT8 bta_sys_hw_on[][BTA_SYS_NUM_COLS] =
131 {
132 /* Event Action 1 Action 2 Next State */
133 /* API_ENABLE */ {BTA_SYS_HW_API_ENABLE, BTA_SYS_IGNORE, BTA_SYS_HW_ON},
134 /* EVT_ENABLED */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_ON},
135 /* STACK_ENABLED */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_ON},
136 /* API_DISABLE */ {BTA_SYS_HW_API_DISABLE, BTA_SYS_IGNORE, BTA_SYS_HW_ON}, /* don't change the state here, as some other modules might be active */
137 /* EVT_DISABLED */ {BTA_SYS_HW_ERROR, BTA_SYS_IGNORE, BTA_SYS_HW_ON},
138 /* EVT_ERROR */ {BTA_SYS_HW_ERROR, BTA_SYS_IGNORE, BTA_SYS_HW_ON}
139 };
140
141 const UINT8 bta_sys_hw_stopping[][BTA_SYS_NUM_COLS] =
142 {
143 /* Event Action 1 Action 2 Next State */
144 /* API_ENABLE */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_STARTING}, /* change state, and wait for completion event to enable */
145 /* EVT_ENABLED */ {BTA_SYS_HW_EVT_ENABLED, BTA_SYS_IGNORE, BTA_SYS_HW_STOPPING}, /* successive enable/disable: finish the enable before disabling */
146 /* STACK_ENABLED */ {BTA_SYS_HW_EVT_STACK_ENABLED, BTA_SYS_HW_API_DISABLE, BTA_SYS_HW_STOPPING}, /* successive enable/disable: notify, then stop */
147 /* API_DISABLE */ {BTA_SYS_IGNORE, BTA_SYS_IGNORE, BTA_SYS_HW_STOPPING}, /* wait for completion event */
148 /* EVT_DISABLED */ {BTA_SYS_HW_EVT_DISABLED, BTA_SYS_IGNORE, BTA_SYS_HW_OFF},
149 /* EVT_ERROR */ {BTA_SYS_HW_API_DISABLE, BTA_SYS_IGNORE, BTA_SYS_HW_STOPPING}
150 };
151
152 typedef const UINT8 (*tBTA_SYS_ST_TBL)[BTA_SYS_NUM_COLS];
153
154 /* state table */
155 const tBTA_SYS_ST_TBL bta_sys_st_tbl[] = {
156 bta_sys_hw_off,
157 bta_sys_hw_starting,
158 bta_sys_hw_on,
159 bta_sys_hw_stopping
160 };
161
162 /*******************************************************************************
163 **
164 ** Function bta_sys_init
165 **
166 ** Description BTA initialization; called from task initialization.
167 **
168 **
169 ** Returns void
170 **
171 *******************************************************************************/
bta_sys_init(void)172 BTA_API void bta_sys_init(void)
173 {
174 memset(&bta_sys_cb, 0, sizeof(tBTA_SYS_CB));
175 ptim_init(&bta_sys_cb.ptim_cb, BTA_SYS_TIMER_PERIOD, p_bta_sys_cfg->timer);
176 bta_sys_cb.task_id = GKI_get_taskid();
177 appl_trace_level = p_bta_sys_cfg->trace_level;
178
179 /* register BTA SYS message handler */
180 bta_sys_register( BTA_ID_SYS, &bta_sys_hw_reg);
181
182 /* register for BTM notifications */
183 BTM_RegisterForDeviceStatusNotif ((tBTM_DEV_STATUS_CB*)&bta_sys_hw_btm_cback );
184
185 #if( defined BTA_AR_INCLUDED ) && (BTA_AR_INCLUDED == TRUE)
186 bta_ar_init();
187 #endif
188
189 }
190
191 /*******************************************************************************
192 **
193 ** Function bta_dm_sm_execute
194 **
195 ** Description State machine event handling function for DM
196 **
197 **
198 ** Returns void
199 **
200 *******************************************************************************/
bta_sys_sm_execute(BT_HDR * p_msg)201 BOOLEAN bta_sys_sm_execute(BT_HDR *p_msg)
202 {
203 BOOLEAN freebuf = TRUE;
204 tBTA_SYS_ST_TBL state_table;
205 UINT8 action;
206 int i;
207
208 APPL_TRACE_EVENT("bta_sys_sm_execute state:%d, event:0x%x", bta_sys_cb.state, p_msg->event);
209
210 /* look up the state table for the current state */
211 state_table = bta_sys_st_tbl[bta_sys_cb.state];
212 /* update state */
213 bta_sys_cb.state = state_table[p_msg->event & 0x00ff][BTA_SYS_NEXT_STATE];
214
215 /* execute action functions */
216 for (i = 0; i < BTA_SYS_ACTIONS; i++)
217 {
218 if ((action = state_table[p_msg->event & 0x00ff][i]) != BTA_SYS_IGNORE)
219 {
220 (*bta_sys_action[action])( (tBTA_SYS_HW_MSG*) p_msg);
221 }
222 else
223 {
224 break;
225 }
226 }
227 return freebuf;
228
229 }
230
231
bta_sys_hw_register(tBTA_SYS_HW_MODULE module,tBTA_SYS_HW_CBACK * cback)232 void bta_sys_hw_register( tBTA_SYS_HW_MODULE module, tBTA_SYS_HW_CBACK *cback)
233 {
234 bta_sys_cb.sys_hw_cback[module]=cback;
235 }
236
237
bta_sys_hw_unregister(tBTA_SYS_HW_MODULE module)238 void bta_sys_hw_unregister( tBTA_SYS_HW_MODULE module )
239 {
240 bta_sys_cb.sys_hw_cback[module]=NULL;
241 }
242
243 /*******************************************************************************
244 **
245 ** Function bta_sys_hw_btm_cback
246 **
247 ** Description This function is registered by BTA SYS to BTM in order to get status notifications
248 **
249 **
250 ** Returns
251 **
252 *******************************************************************************/
bta_sys_hw_btm_cback(tBTM_DEV_STATUS status)253 void bta_sys_hw_btm_cback( tBTM_DEV_STATUS status )
254 {
255
256 tBTA_SYS_HW_MSG *sys_event;
257
258 APPL_TRACE_DEBUG(" bta_sys_hw_btm_cback was called with parameter: %i" , status );
259
260 /* send a message to BTA SYS */
261 if ((sys_event = (tBTA_SYS_HW_MSG *) GKI_getbuf(sizeof(tBTA_SYS_HW_MSG))) != NULL)
262 {
263 if (status == BTM_DEV_STATUS_UP)
264 sys_event->hdr.event = BTA_SYS_EVT_STACK_ENABLED_EVT;
265 else if (status == BTM_DEV_STATUS_DOWN)
266 sys_event->hdr.event = BTA_SYS_ERROR_EVT;
267 else
268 {
269 /* BTM_DEV_STATUS_CMD_TOUT is ignored for now. */
270 GKI_freebuf (sys_event);
271 sys_event = NULL;
272 }
273
274 if (sys_event)
275 {
276 bta_sys_sendmsg(sys_event);
277 }
278 }
279 else
280 {
281 APPL_TRACE_DEBUG("ERROR bta_sys_hw_btm_cback couldn't send msg" );
282 }
283 }
284
285
286
287 /*******************************************************************************
288 **
289 ** Function bta_sys_hw_error
290 **
291 ** Description In case the HW device stops answering... Try to turn it off, then re-enable all
292 ** previously active SW modules.
293 **
294 ** Returns success or failure
295 **
296 *******************************************************************************/
bta_sys_hw_error(tBTA_SYS_HW_MSG * p_sys_hw_msg)297 void bta_sys_hw_error(tBTA_SYS_HW_MSG *p_sys_hw_msg)
298 {
299 UINT8 module_index;
300 UNUSED(p_sys_hw_msg);
301
302 APPL_TRACE_DEBUG("%s", __FUNCTION__);
303
304 for (module_index = 0; module_index < BTA_SYS_MAX_HW_MODULES; module_index++)
305 {
306 if( bta_sys_cb.sys_hw_module_active & ((UINT32)1 << module_index )) {
307 switch( module_index)
308 {
309 case BTA_SYS_HW_BLUETOOTH:
310 /* Send BTA_SYS_HW_ERROR_EVT to DM */
311 if (bta_sys_cb.sys_hw_cback[module_index] != NULL)
312 bta_sys_cb.sys_hw_cback[module_index] (BTA_SYS_HW_ERROR_EVT);
313 break;
314 default:
315 /* not yet supported */
316 break;
317 }
318 }
319 }
320 }
321
322
323
324 /*******************************************************************************
325 **
326 ** Function bta_sys_hw_enable
327 **
328 ** Description this function is called after API enable and HW has been turned on
329 **
330 **
331 ** Returns success or failure
332 **
333 *******************************************************************************/
334
bta_sys_hw_api_enable(tBTA_SYS_HW_MSG * p_sys_hw_msg)335 void bta_sys_hw_api_enable( tBTA_SYS_HW_MSG *p_sys_hw_msg )
336 {
337 if ((!bta_sys_cb.sys_hw_module_active) && (bta_sys_cb.state != BTA_SYS_HW_ON))
338 {
339 /* register which HW module was turned on */
340 bta_sys_cb.sys_hw_module_active |= ((UINT32)1 << p_sys_hw_msg->hw_module );
341
342 /* use call-out to power-up HW */
343 bta_sys_hw_co_enable(p_sys_hw_msg->hw_module);
344 }
345 else
346 {
347 /* register which HW module was turned on */
348 bta_sys_cb.sys_hw_module_active |= ((UINT32)1 << p_sys_hw_msg->hw_module );
349
350 /* HW already in use, so directly notify the caller */
351 if (bta_sys_cb.sys_hw_cback[p_sys_hw_msg->hw_module ]!= NULL )
352 bta_sys_cb.sys_hw_cback[p_sys_hw_msg->hw_module ]( BTA_SYS_HW_ON_EVT );
353 }
354
355 APPL_TRACE_EVENT ("bta_sys_hw_api_enable for %d, active modules 0x%04X",
356 p_sys_hw_msg->hw_module, bta_sys_cb.sys_hw_module_active);
357
358 }
359
360 /*******************************************************************************
361 **
362 ** Function bta_sys_hw_disable
363 **
364 ** Description if no other module is using the HW, this function will call ( if defined ) a user-macro to turn off the HW
365 **
366 **
367 ** Returns success or failure
368 **
369 *******************************************************************************/
bta_sys_hw_api_disable(tBTA_SYS_HW_MSG * p_sys_hw_msg)370 void bta_sys_hw_api_disable(tBTA_SYS_HW_MSG *p_sys_hw_msg)
371 {
372 APPL_TRACE_DEBUG("bta_sys_hw_api_disable for %d, active modules: 0x%04X",
373 p_sys_hw_msg->hw_module, bta_sys_cb.sys_hw_module_active );
374
375 /* make sure the related SW blocks were stopped */
376 bta_sys_disable( p_sys_hw_msg->hw_module );
377
378
379 /* register which module we turn off */
380 bta_sys_cb.sys_hw_module_active &= ~((UINT32)1 << p_sys_hw_msg->hw_module );
381
382
383 /* if there are still some SW modules using the HW, just provide an answer to the calling */
384 if( bta_sys_cb.sys_hw_module_active != 0 )
385 {
386 /* if there are still some SW modules using the HW, directly notify the caller */
387 if( bta_sys_cb.sys_hw_cback[p_sys_hw_msg->hw_module ]!= NULL )
388 bta_sys_cb.sys_hw_cback[p_sys_hw_msg->hw_module ]( BTA_SYS_HW_OFF_EVT );
389 }
390 else
391 {
392 /* manually update the state of our system */
393 bta_sys_cb.state = BTA_SYS_HW_STOPPING;
394 /* and use the call-out to disable HW */
395 bta_sys_hw_co_disable(p_sys_hw_msg->hw_module);
396 }
397
398 }
399
400
401 /*******************************************************************************
402 **
403 ** Function bta_sys_hw_event_enabled
404 **
405 ** Description
406 **
407 **
408 ** Returns success or failure
409 **
410 *******************************************************************************/
bta_sys_hw_evt_enabled(tBTA_SYS_HW_MSG * p_sys_hw_msg)411 void bta_sys_hw_evt_enabled(tBTA_SYS_HW_MSG *p_sys_hw_msg)
412 {
413 APPL_TRACE_EVENT("bta_sys_hw_evt_enabled for %i", p_sys_hw_msg->hw_module);
414
415 #if ( defined BTM_AUTOMATIC_HCI_RESET && BTM_AUTOMATIC_HCI_RESET == TRUE )
416 /* If device is already up, send a fake "BTM DEVICE UP" using BTA SYS state machine */
417 /* If we are in the middle device initialization, BTM_DEVICE_UP will be issued */
418 /* by BTM once initialization is done. */
419 if (BTA_DmIsDeviceUp())
420 {
421 bta_sys_hw_btm_cback (BTM_DEV_STATUS_UP);
422 }
423 #else
424
425 /* if HCI reset was not sent during stack start-up */
426 BTM_DeviceReset( NULL );
427
428 #endif
429 }
430
431
432 /*******************************************************************************
433 **
434 ** Function bta_sys_hw_event_disabled
435 **
436 ** Description
437 **
438 **
439 ** Returns success or failure
440 **
441 *******************************************************************************/
bta_sys_hw_evt_disabled(tBTA_SYS_HW_MSG * p_sys_hw_msg)442 void bta_sys_hw_evt_disabled(tBTA_SYS_HW_MSG *p_sys_hw_msg)
443 {
444 UINT8 hw_module_index;
445
446 APPL_TRACE_DEBUG("bta_sys_hw_evt_disabled - module 0x%X", p_sys_hw_msg->hw_module);
447
448 for (hw_module_index = 0; hw_module_index < BTA_SYS_MAX_HW_MODULES; hw_module_index++)
449 {
450 if (bta_sys_cb.sys_hw_cback[hw_module_index] != NULL)
451 bta_sys_cb.sys_hw_cback[hw_module_index] (BTA_SYS_HW_OFF_EVT);
452 }
453 }
454
455 /*******************************************************************************
456 **
457 ** Function bta_sys_hw_event_stack_enabled
458 **
459 ** Description we receive this event once the SW side is ready ( stack, FW download,... ),
460 ** i.e. we can really start using the device. So notify the app.
461 **
462 ** Returns success or failure
463 **
464 *******************************************************************************/
bta_sys_hw_evt_stack_enabled(tBTA_SYS_HW_MSG * p_sys_hw_msg)465 void bta_sys_hw_evt_stack_enabled(tBTA_SYS_HW_MSG *p_sys_hw_msg)
466 {
467 UINT8 hw_module_index;
468 UNUSED(p_sys_hw_msg);
469
470 APPL_TRACE_DEBUG(" bta_sys_hw_evt_stack_enabled!notify the callers");
471
472 for (hw_module_index = 0; hw_module_index < BTA_SYS_MAX_HW_MODULES; hw_module_index++ )
473 {
474 if (bta_sys_cb.sys_hw_cback[hw_module_index] != NULL)
475 bta_sys_cb.sys_hw_cback[hw_module_index] (BTA_SYS_HW_ON_EVT);
476 }
477 }
478
479
480
481
482 /*******************************************************************************
483 **
484 ** Function bta_sys_event
485 **
486 ** Description BTA event handler; called from task event handler.
487 **
488 **
489 ** Returns void
490 **
491 *******************************************************************************/
bta_sys_event(BT_HDR * p_msg)492 BTA_API void bta_sys_event(BT_HDR *p_msg)
493 {
494 UINT8 id;
495 BOOLEAN freebuf = TRUE;
496
497 APPL_TRACE_EVENT("BTA got event 0x%x", p_msg->event);
498
499 /* get subsystem id from event */
500 id = (UINT8) (p_msg->event >> 8);
501
502 /* verify id and call subsystem event handler */
503 if ((id < BTA_ID_MAX) && (bta_sys_cb.reg[id] != NULL))
504 {
505 freebuf = (*bta_sys_cb.reg[id]->evt_hdlr)(p_msg);
506 }
507 else
508 {
509 APPL_TRACE_WARNING("BTA got unregistered event id %d", id);
510 }
511
512 if (freebuf)
513 {
514 GKI_freebuf(p_msg);
515 }
516
517 }
518
519 /*******************************************************************************
520 **
521 ** Function bta_sys_timer_update
522 **
523 ** Description Update the BTA timer list and handle expired timers.
524 **
525 ** Returns void
526 **
527 *******************************************************************************/
bta_sys_timer_update(void)528 BTA_API void bta_sys_timer_update(void)
529 {
530 if (!bta_sys_cb.timers_disabled)
531 {
532 ptim_timer_update(&bta_sys_cb.ptim_cb);
533 }
534 }
535
536 /*******************************************************************************
537 **
538 ** Function bta_sys_register
539 **
540 ** Description Called by other BTA subsystems to register their event
541 ** handler.
542 **
543 **
544 ** Returns void
545 **
546 *******************************************************************************/
bta_sys_register(UINT8 id,const tBTA_SYS_REG * p_reg)547 void bta_sys_register(UINT8 id, const tBTA_SYS_REG *p_reg)
548 {
549 bta_sys_cb.reg[id] = (tBTA_SYS_REG *) p_reg;
550 bta_sys_cb.is_reg[id] = TRUE;
551 }
552
553 /*******************************************************************************
554 **
555 ** Function bta_sys_deregister
556 **
557 ** Description Called by other BTA subsystems to de-register
558 ** handler.
559 **
560 **
561 ** Returns void
562 **
563 *******************************************************************************/
bta_sys_deregister(UINT8 id)564 void bta_sys_deregister(UINT8 id)
565 {
566 bta_sys_cb.is_reg[id] = FALSE;
567 }
568
569 /*******************************************************************************
570 **
571 ** Function bta_sys_is_register
572 **
573 ** Description Called by other BTA subsystems to get registeration
574 ** status.
575 **
576 **
577 ** Returns void
578 **
579 *******************************************************************************/
bta_sys_is_register(UINT8 id)580 BOOLEAN bta_sys_is_register(UINT8 id)
581 {
582 return bta_sys_cb.is_reg[id];
583 }
584
585 /*******************************************************************************
586 **
587 ** Function bta_sys_sendmsg
588 **
589 ** Description Send a GKI message to BTA. This function is designed to
590 ** optimize sending of messages to BTA. It is called by BTA
591 ** API functions and call-in functions.
592 **
593 **
594 ** Returns void
595 **
596 *******************************************************************************/
bta_sys_sendmsg(void * p_msg)597 void bta_sys_sendmsg(void *p_msg)
598 {
599 GKI_send_msg(bta_sys_cb.task_id, p_bta_sys_cfg->mbox, p_msg);
600 }
601
602 /*******************************************************************************
603 **
604 ** Function bta_sys_start_timer
605 **
606 ** Description Start a protocol timer for the specified amount
607 ** of time in milliseconds.
608 **
609 ** Returns void
610 **
611 *******************************************************************************/
bta_sys_start_timer(TIMER_LIST_ENT * p_tle,UINT16 type,INT32 timeout)612 void bta_sys_start_timer(TIMER_LIST_ENT *p_tle, UINT16 type, INT32 timeout)
613 {
614 ptim_start_timer(&bta_sys_cb.ptim_cb, p_tle, type, timeout);
615 }
616
617 /*******************************************************************************
618 **
619 ** Function bta_sys_stop_timer
620 **
621 ** Description Stop a BTA timer.
622 **
623 ** Returns void
624 **
625 *******************************************************************************/
bta_sys_stop_timer(TIMER_LIST_ENT * p_tle)626 void bta_sys_stop_timer(TIMER_LIST_ENT *p_tle)
627 {
628 ptim_stop_timer(&bta_sys_cb.ptim_cb, p_tle);
629 }
630
631 /*******************************************************************************
632 **
633 ** Function bta_sys_disable
634 **
635 ** Description For each registered subsystem execute its disable function.
636 **
637 ** Returns void
638 **
639 *******************************************************************************/
bta_sys_disable(tBTA_SYS_HW_MODULE module)640 void bta_sys_disable(tBTA_SYS_HW_MODULE module)
641 {
642 int bta_id = 0;
643 int bta_id_max = 0;
644
645 APPL_TRACE_DEBUG("bta_sys_disable: module %i", module);
646
647 switch( module )
648 {
649 case BTA_SYS_HW_BLUETOOTH:
650 bta_id = BTA_ID_DM;
651 bta_id_max = BTA_ID_BLUETOOTH_MAX;
652 break;
653 case BTA_SYS_HW_FMRX:
654 bta_id = BTA_ID_FM;
655 bta_id_max = BTA_ID_FM;
656 break;
657 case BTA_SYS_HW_FMTX:
658 bta_id = BTA_ID_FMTX;
659 bta_id_max = BTA_ID_FMTX;
660 break;
661 case BTA_SYS_HW_GPS:
662 bta_id = BTA_ID_GPS;
663 bta_id_max = BTA_ID_GPS;
664 break;
665 default:
666 APPL_TRACE_WARNING("bta_sys_disable: unkown module");
667 return;
668 }
669
670 for ( ; bta_id <= bta_id_max; bta_id++)
671 {
672 if (bta_sys_cb.reg[bta_id] != NULL)
673 {
674 if (bta_sys_cb.is_reg[bta_id] == TRUE && bta_sys_cb.reg[bta_id]->disable != NULL)
675 {
676 (*bta_sys_cb.reg[bta_id]->disable)();
677 }
678 }
679 }
680 }
681
682 /*******************************************************************************
683 **
684 ** Function bta_sys_disable_timers
685 **
686 ** Description Disable sys timer event handling
687 **
688 ** Returns void
689 **
690 *******************************************************************************/
bta_sys_disable_timers(void)691 void bta_sys_disable_timers(void)
692 {
693 bta_sys_cb.timers_disabled = TRUE;
694 }
695
696 /*******************************************************************************
697 **
698 ** Function bta_sys_set_trace_level
699 **
700 ** Description Set trace level for BTA
701 **
702 ** Returns void
703 **
704 *******************************************************************************/
bta_sys_set_trace_level(UINT8 level)705 void bta_sys_set_trace_level(UINT8 level)
706 {
707 appl_trace_level = level;
708 }
709
710 /*******************************************************************************
711 **
712 ** Function bta_sys_get_sys_features
713 **
714 ** Description Returns sys_features to other BTA modules.
715 **
716 ** Returns sys_features
717 **
718 *******************************************************************************/
bta_sys_get_sys_features(void)719 UINT16 bta_sys_get_sys_features (void)
720 {
721 return bta_sys_cb.sys_features;
722 }
723
724
725