1 /******************************************************************************
2 *
3 * Copyright (C) 2009-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 * Filename: bte_main.c
22 *
23 * Description: Contains BTE core stack initialization and shutdown code
24 *
25 ******************************************************************************/
26 #include <fcntl.h>
27 #include <stdlib.h>
28 #include <assert.h>
29 #include <signal.h>
30 #include <time.h>
31 #include <hardware/bluetooth.h>
32
33 #include "gki.h"
34 #include "bd.h"
35 #include "btu.h"
36 #include "bte.h"
37 #include "bta_api.h"
38 #include "bt_utils.h"
39 #include "bt_hci_bdroid.h"
40
41 /*******************************************************************************
42 ** Constants & Macros
43 *******************************************************************************/
44
45 /* Run-time configuration file */
46 #ifndef BTE_STACK_CONF_FILE
47 #define BTE_STACK_CONF_FILE "/etc/bluetooth/bt_stack.conf"
48 #endif
49 /* Run-time configuration file for BLE*/
50 #ifndef BTE_BLE_STACK_CONF_FILE
51 #define BTE_BLE_STACK_CONF_FILE "/etc/bluetooth/ble_stack.conf"
52 #endif
53
54 /* if not specified in .txt file then use this as default */
55 #ifndef HCI_LOGGING_FILENAME
56 #define HCI_LOGGING_FILENAME "/data/misc/bluedroid/btsnoop_hci.log"
57 #endif
58
59 /* Stack preload process timeout period */
60 #ifndef PRELOAD_START_TIMEOUT_MS
61 #define PRELOAD_START_TIMEOUT_MS 3000 // 3 seconds
62 #endif
63
64 /* Stack preload process maximum retry attempts */
65 #ifndef PRELOAD_MAX_RETRY_ATTEMPTS
66 #define PRELOAD_MAX_RETRY_ATTEMPTS 0
67 #endif
68
69 /*******************************************************************************
70 ** Local type definitions
71 *******************************************************************************/
72 /* Preload retry control block */
73 typedef struct
74 {
75 int retry_counts;
76 BOOLEAN timer_created;
77 timer_t timer_id;
78 } bt_preload_retry_cb_t;
79
80 /******************************************************************************
81 ** Variables
82 ******************************************************************************/
83 BOOLEAN hci_logging_enabled = FALSE; /* by default, turn hci log off */
84 BOOLEAN hci_logging_config = FALSE; /* configured from bluetooth framework */
85 BOOLEAN hci_save_log = FALSE; /* save a copy of the log before starting again */
86 char hci_logfile[256] = HCI_LOGGING_FILENAME;
87
88 /*******************************************************************************
89 ** Static variables
90 *******************************************************************************/
91 static bt_hc_interface_t *bt_hc_if=NULL;
92 static const bt_hc_callbacks_t hc_callbacks;
93 static BOOLEAN lpm_enabled = FALSE;
94 static bt_preload_retry_cb_t preload_retry_cb;
95 // Lock to serialize cleanup requests from upper layer.
96 static pthread_mutex_t cleanup_lock;
97
98 /*******************************************************************************
99 ** Static functions
100 *******************************************************************************/
101 static void bte_main_in_hw_init(void);
102 static void bte_hci_enable(void);
103 static void bte_hci_disable(void);
104 static void preload_start_wait_timer(void);
105 static void preload_stop_wait_timer(void);
106
107 /*******************************************************************************
108 ** Externs
109 *******************************************************************************/
110 BTU_API extern UINT32 btu_task (UINT32 param);
111 BTU_API extern void BTE_Init (void);
112 BT_API extern void BTE_LoadStack(void);
113 BT_API void BTE_UnloadStack(void);
114 extern void scru_flip_bda (BD_ADDR dst, const BD_ADDR src);
115 extern void bte_load_conf(const char *p_path);
116 extern void bte_load_ble_conf(const char *p_path);
117 extern bt_bdaddr_t btif_local_bd_addr;
118
119
120 /*******************************************************************************
121 ** System Task Configuration
122 *******************************************************************************/
123
124 /* bluetooth protocol stack (BTU) task */
125 #ifndef BTE_BTU_STACK_SIZE
126 #define BTE_BTU_STACK_SIZE 0//0x2000 /* In bytes */
127 #endif
128 #define BTE_BTU_TASK_STR ((INT8 *) "BTU")
129 UINT32 bte_btu_stack[(BTE_BTU_STACK_SIZE + 3) / 4];
130
131 /******************************************************************************
132 **
133 ** Function bte_main_in_hw_init
134 **
135 ** Description Internal helper function for chip hardware init
136 **
137 ** Returns None
138 **
139 ******************************************************************************/
bte_main_in_hw_init(void)140 static void bte_main_in_hw_init(void)
141 {
142 if ( (bt_hc_if = (bt_hc_interface_t *) bt_hc_get_interface()) \
143 == NULL)
144 {
145 APPL_TRACE_ERROR("!!! Failed to get BtHostControllerInterface !!!");
146 }
147
148 memset(&preload_retry_cb, 0, sizeof(bt_preload_retry_cb_t));
149 }
150
151 /******************************************************************************
152 **
153 ** Function bte_main_boot_entry
154 **
155 ** Description BTE MAIN API - Entry point for BTE chip/stack initialization
156 **
157 ** Returns None
158 **
159 ******************************************************************************/
bte_main_boot_entry(void)160 void bte_main_boot_entry(void)
161 {
162 /* initialize OS */
163 GKI_init();
164
165 bte_main_in_hw_init();
166
167 bte_load_conf(BTE_STACK_CONF_FILE);
168 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
169 bte_load_ble_conf(BTE_BLE_STACK_CONF_FILE);
170 #endif
171
172 #if (BTTRC_INCLUDED == TRUE)
173 /* Initialize trace feature */
174 BTTRC_TraceInit(MAX_TRACE_RAM_SIZE, &BTE_TraceLogBuf[0], BTTRC_METHOD_RAM);
175 #endif
176
177 pthread_mutex_init(&cleanup_lock, NULL);
178
179 }
180
181 /******************************************************************************
182 **
183 ** Function bte_main_shutdown
184 **
185 ** Description BTE MAIN API - Shutdown code for BTE chip/stack
186 **
187 ** Returns None
188 **
189 ******************************************************************************/
bte_main_shutdown()190 void bte_main_shutdown()
191 {
192 pthread_mutex_destroy(&cleanup_lock);
193
194 GKI_shutdown();
195 }
196
197 /******************************************************************************
198 **
199 ** Function bte_main_enable
200 **
201 ** Description BTE MAIN API - Creates all the BTE tasks. Should be called
202 ** part of the Bluetooth stack enable sequence
203 **
204 ** Returns None
205 **
206 ******************************************************************************/
bte_main_enable()207 void bte_main_enable()
208 {
209 APPL_TRACE_DEBUG("%s", __FUNCTION__);
210
211 /* Initialize BTE control block */
212 BTE_Init();
213
214 lpm_enabled = FALSE;
215
216 GKI_create_task((TASKPTR)btu_task, BTU_TASK, BTE_BTU_TASK_STR,
217 (UINT16 *) ((UINT8 *)bte_btu_stack + BTE_BTU_STACK_SIZE),
218 sizeof(bte_btu_stack));
219
220 bte_hci_enable();
221
222 GKI_run();
223 }
224
225 /******************************************************************************
226 **
227 ** Function bte_main_disable
228 **
229 ** Description BTE MAIN API - Destroys all the BTE tasks. Should be called
230 ** part of the Bluetooth stack disable sequence
231 **
232 ** Returns None
233 **
234 ******************************************************************************/
bte_main_disable(void)235 void bte_main_disable(void)
236 {
237 APPL_TRACE_DEBUG("%s", __FUNCTION__);
238
239 preload_stop_wait_timer();
240 bte_hci_disable();
241 GKI_destroy_task(BTU_TASK);
242 }
243
244 /******************************************************************************
245 **
246 ** Function bte_main_config_hci_logging
247 **
248 ** Description enable or disable HIC snoop logging
249 **
250 ** Returns None
251 **
252 ******************************************************************************/
bte_main_config_hci_logging(BOOLEAN enable,BOOLEAN bt_disabled)253 void bte_main_config_hci_logging(BOOLEAN enable, BOOLEAN bt_disabled)
254 {
255 int old = (hci_logging_enabled == TRUE) || (hci_logging_config == TRUE);
256 int new;
257
258 if (enable) {
259 hci_logging_config = TRUE;
260 } else {
261 hci_logging_config = FALSE;
262 }
263
264 new = (hci_logging_enabled == TRUE) || (hci_logging_config == TRUE);
265
266 if ((old == new) || bt_disabled || (bt_hc_if == NULL)) {
267 return;
268 }
269
270 bt_hc_if->logging(new ? BT_HC_LOGGING_ON : BT_HC_LOGGING_OFF, hci_logfile, hci_save_log);
271 }
272
273 /******************************************************************************
274 **
275 ** Function bte_hci_enable
276 **
277 ** Description Enable HCI & Vendor modules
278 **
279 ** Returns None
280 **
281 ******************************************************************************/
bte_hci_enable(void)282 static void bte_hci_enable(void)
283 {
284 APPL_TRACE_DEBUG("%s", __FUNCTION__);
285
286 preload_start_wait_timer();
287
288 if (bt_hc_if)
289 {
290 int result = bt_hc_if->init(&hc_callbacks, btif_local_bd_addr.address);
291 APPL_TRACE_EVENT("libbt-hci init returns %d", result);
292
293 assert(result == BT_HC_STATUS_SUCCESS);
294
295 if (hci_logging_enabled == TRUE || hci_logging_config == TRUE)
296 bt_hc_if->logging(BT_HC_LOGGING_ON, hci_logfile, hci_save_log);
297
298 #if (defined (BT_CLEAN_TURN_ON_DISABLED) && BT_CLEAN_TURN_ON_DISABLED == TRUE)
299 APPL_TRACE_DEBUG("%s Not Turninig Off the BT before Turninig ON", __FUNCTION__);
300
301 /* Do not power off the chip before powering on if BT_CLEAN_TURN_ON_DISABLED flag
302 is defined and set to TRUE to avoid below mentioned issue.
303
304 Wingray kernel driver maintains a combined counter to keep track of
305 BT-Wifi state. Invoking set_power(BT_HC_CHIP_PWR_OFF) when the BT is already
306 in OFF state causes this counter to be incorrectly decremented and results in undesired
307 behavior of the chip.
308
309 This is only a workaround and when the issue is fixed in the kernel this work around
310 should be removed. */
311 #else
312 /* toggle chip power to ensure we will reset chip in case
313 a previous stack shutdown wasn't completed gracefully */
314 bt_hc_if->set_power(BT_HC_CHIP_PWR_OFF);
315 #endif
316 bt_hc_if->set_power(BT_HC_CHIP_PWR_ON);
317
318 bt_hc_if->preload(NULL);
319 }
320 }
321
322 /******************************************************************************
323 **
324 ** Function bte_hci_disable
325 **
326 ** Description Disable HCI & Vendor modules
327 **
328 ** Returns None
329 **
330 ******************************************************************************/
bte_hci_disable(void)331 static void bte_hci_disable(void)
332 {
333 APPL_TRACE_DEBUG("%s", __FUNCTION__);
334
335 if (!bt_hc_if)
336 return;
337
338 // Cleanup is not thread safe and must be protected.
339 pthread_mutex_lock(&cleanup_lock);
340
341 if (hci_logging_enabled == TRUE || hci_logging_config == TRUE)
342 bt_hc_if->logging(BT_HC_LOGGING_OFF, hci_logfile, hci_save_log);
343 bt_hc_if->cleanup();
344
345 pthread_mutex_unlock(&cleanup_lock);
346 }
347
348 /*******************************************************************************
349 **
350 ** Function preload_wait_timeout
351 **
352 ** Description Timeout thread of preload watchdog timer
353 **
354 ** Returns None
355 **
356 *******************************************************************************/
preload_wait_timeout(union sigval arg)357 static void preload_wait_timeout(union sigval arg)
358 {
359 UNUSED(arg);
360
361 APPL_TRACE_ERROR("...preload_wait_timeout (retried:%d/max-retry:%d)...",
362 preload_retry_cb.retry_counts,
363 PRELOAD_MAX_RETRY_ATTEMPTS);
364
365 if (preload_retry_cb.retry_counts++ < PRELOAD_MAX_RETRY_ATTEMPTS)
366 {
367 bte_hci_disable();
368 GKI_delay(100);
369 bte_hci_enable();
370 }
371 else
372 {
373 /* Notify BTIF_TASK that the init procedure had failed*/
374 GKI_send_event(BTIF_TASK, BT_EVT_HARDWARE_INIT_FAIL);
375 }
376 }
377
378 /*******************************************************************************
379 **
380 ** Function preload_start_wait_timer
381 **
382 ** Description Launch startup watchdog timer
383 **
384 ** Returns None
385 **
386 *******************************************************************************/
preload_start_wait_timer(void)387 static void preload_start_wait_timer(void)
388 {
389 int status;
390 struct itimerspec ts;
391 struct sigevent se;
392 UINT32 timeout_ms = PRELOAD_START_TIMEOUT_MS;
393
394 if (preload_retry_cb.timer_created == FALSE)
395 {
396 se.sigev_notify = SIGEV_THREAD;
397 se.sigev_value.sival_ptr = &preload_retry_cb.timer_id;
398 se.sigev_notify_function = preload_wait_timeout;
399 se.sigev_notify_attributes = NULL;
400
401 status = timer_create(CLOCK_MONOTONIC, &se, &preload_retry_cb.timer_id);
402
403 if (status == 0)
404 preload_retry_cb.timer_created = TRUE;
405 }
406
407 if (preload_retry_cb.timer_created == TRUE)
408 {
409 ts.it_value.tv_sec = timeout_ms/1000;
410 ts.it_value.tv_nsec = 1000000*(timeout_ms%1000);
411 ts.it_interval.tv_sec = 0;
412 ts.it_interval.tv_nsec = 0;
413
414 status = timer_settime(preload_retry_cb.timer_id, 0, &ts, 0);
415 if (status == -1)
416 APPL_TRACE_ERROR("Failed to fire preload watchdog timer");
417 }
418 }
419
420 /*******************************************************************************
421 **
422 ** Function preload_stop_wait_timer
423 **
424 ** Description Stop preload watchdog timer
425 **
426 ** Returns None
427 **
428 *******************************************************************************/
preload_stop_wait_timer(void)429 static void preload_stop_wait_timer(void)
430 {
431 if (preload_retry_cb.timer_created == TRUE)
432 {
433 timer_delete(preload_retry_cb.timer_id);
434 preload_retry_cb.timer_created = FALSE;
435 }
436 }
437
438 /******************************************************************************
439 **
440 ** Function bte_main_postload_cfg
441 **
442 ** Description BTE MAIN API - Stack postload configuration
443 **
444 ** Returns None
445 **
446 ******************************************************************************/
bte_main_postload_cfg(void)447 void bte_main_postload_cfg(void)
448 {
449 if (bt_hc_if)
450 bt_hc_if->postload(NULL);
451 }
452
453 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
454 /******************************************************************************
455 **
456 ** Function bte_main_enable_lpm
457 **
458 ** Description BTE MAIN API - Enable/Disable low power mode operation
459 **
460 ** Returns None
461 **
462 ******************************************************************************/
bte_main_enable_lpm(BOOLEAN enable)463 void bte_main_enable_lpm(BOOLEAN enable)
464 {
465 int result = -1;
466
467 if (bt_hc_if)
468 result = bt_hc_if->lpm( \
469 (enable == TRUE) ? BT_HC_LPM_ENABLE : BT_HC_LPM_DISABLE \
470 );
471
472 APPL_TRACE_EVENT("HC lib lpm enable=%d return %d", enable, result);
473 }
474
475 /******************************************************************************
476 **
477 ** Function bte_main_lpm_allow_bt_device_sleep
478 **
479 ** Description BTE MAIN API - Allow BT controller goest to sleep
480 **
481 ** Returns None
482 **
483 ******************************************************************************/
bte_main_lpm_allow_bt_device_sleep()484 void bte_main_lpm_allow_bt_device_sleep()
485 {
486 int result = -1;
487
488 if ((bt_hc_if) && (lpm_enabled == TRUE))
489 result = bt_hc_if->lpm(BT_HC_LPM_WAKE_DEASSERT);
490
491 APPL_TRACE_DEBUG("HC lib lpm deassertion return %d", result);
492 }
493
494 /******************************************************************************
495 **
496 ** Function bte_main_lpm_wake_bt_device
497 **
498 ** Description BTE MAIN API - Wake BT controller up if it is in sleep mode
499 **
500 ** Returns None
501 **
502 ******************************************************************************/
bte_main_lpm_wake_bt_device()503 void bte_main_lpm_wake_bt_device()
504 {
505 int result = -1;
506
507 if ((bt_hc_if) && (lpm_enabled == TRUE))
508 result = bt_hc_if->lpm(BT_HC_LPM_WAKE_ASSERT);
509
510 APPL_TRACE_DEBUG("HC lib lpm assertion return %d", result);
511 }
512 #endif // HCILP_INCLUDED
513
514
515 /* NOTICE:
516 * Definitions for audio state structure, this type needs to match to
517 * the bt_vendor_op_audio_state_t type defined in bt_vendor_lib.h
518 */
519 typedef struct {
520 UINT16 handle;
521 UINT16 peer_codec;
522 UINT16 state;
523 } bt_hc_audio_state_t;
524
525 struct bt_audio_state_tag {
526 BT_HDR hdr;
527 bt_hc_audio_state_t audio;
528 };
529
530 /******************************************************************************
531 **
532 ** Function set_audio_state
533 **
534 ** Description Sets audio state on controller state for SCO (PCM, WBS, FM)
535 **
536 ** Parameters handle: codec related handle for SCO: sco cb idx, unused for
537 ** codec: BTA_AG_CODEC_MSBC, BTA_AG_CODEC_CSVD or FM codec
538 ** state: codec state, eg. BTA_AG_CO_AUD_STATE_SETUP
539 ** param: future extensions, e.g. call-in structure/event.
540 **
541 ** Returns None
542 **
543 ******************************************************************************/
set_audio_state(UINT16 handle,UINT16 codec,UINT8 state,void * param)544 int set_audio_state(UINT16 handle, UINT16 codec, UINT8 state, void *param)
545 {
546 struct bt_audio_state_tag *p_msg;
547 int result = -1;
548
549 APPL_TRACE_API("set_audio_state(handle: %d, codec: 0x%x, state: %d)", handle,
550 codec, state);
551 if (NULL != param)
552 APPL_TRACE_WARNING("set_audio_state() non-null param not supported");
553 p_msg = (struct bt_audio_state_tag *)GKI_getbuf(sizeof(*p_msg));
554 if (!p_msg)
555 return result;
556 p_msg->audio.handle = handle;
557 p_msg->audio.peer_codec = codec;
558 p_msg->audio.state = state;
559
560 p_msg->hdr.event = MSG_CTRL_TO_HC_CMD | (MSG_SUB_EVT_MASK & BT_HC_AUDIO_STATE);
561 p_msg->hdr.len = sizeof(p_msg->audio);
562 p_msg->hdr.offset = 0;
563 /* layer_specific shall contain return path event! for BTA events!
564 * 0 means no return message is expected. */
565 p_msg->hdr.layer_specific = 0;
566 if (bt_hc_if)
567 {
568 bt_hc_if->tx_cmd((TRANSAC)p_msg, (char *)(&p_msg->audio), sizeof(*p_msg));
569 }
570 return result;
571 }
572
573
574 /******************************************************************************
575 **
576 ** Function bte_main_hci_send
577 **
578 ** Description BTE MAIN API - This function is called by the upper stack to
579 ** send an HCI message. The function displays a protocol trace
580 ** message (if enabled), and then calls the 'transmit' function
581 ** associated with the currently selected HCI transport
582 **
583 ** Returns None
584 **
585 ******************************************************************************/
bte_main_hci_send(BT_HDR * p_msg,UINT16 event)586 void bte_main_hci_send (BT_HDR *p_msg, UINT16 event)
587 {
588 UINT16 sub_event = event & BT_SUB_EVT_MASK; /* local controller ID */
589
590 p_msg->event = event;
591
592
593 if((sub_event == LOCAL_BR_EDR_CONTROLLER_ID) || \
594 (sub_event == LOCAL_BLE_CONTROLLER_ID))
595 {
596 if (bt_hc_if)
597 bt_hc_if->transmit_buf((TRANSAC)p_msg, \
598 (char *) (p_msg + 1), \
599 p_msg->len);
600 else
601 GKI_freebuf(p_msg);
602 }
603 else
604 {
605 APPL_TRACE_ERROR("Invalid Controller ID. Discarding message.");
606 GKI_freebuf(p_msg);
607 }
608 }
609
610 /******************************************************************************
611 **
612 ** Function bte_main_post_reset_init
613 **
614 ** Description BTE MAIN API - This function is mapped to BTM_APP_DEV_INIT
615 ** and shall be automatically called from BTE after HCI_Reset
616 **
617 ** Returns None
618 **
619 ******************************************************************************/
bte_main_post_reset_init()620 void bte_main_post_reset_init()
621 {
622 BTM_ContinueReset();
623 }
624
625 /*****************************************************************************
626 **
627 ** libbt-hci Callback Functions
628 **
629 *****************************************************************************/
630
631 /******************************************************************************
632 **
633 ** Function preload_cb
634 **
635 ** Description HOST/CONTROLLER LIB CALLBACK API - This function is called
636 ** when the libbt-hci completed stack preload process
637 **
638 ** Returns None
639 **
640 ******************************************************************************/
preload_cb(TRANSAC transac,bt_hc_preload_result_t result)641 static void preload_cb(TRANSAC transac, bt_hc_preload_result_t result)
642 {
643 UNUSED(transac);
644
645 APPL_TRACE_EVENT("HC preload_cb %d [0:SUCCESS 1:FAIL]", result);
646
647 if (result == BT_HC_PRELOAD_SUCCESS)
648 {
649 preload_stop_wait_timer();
650
651 /* notify BTU task that libbt-hci is ready */
652 GKI_send_event(BTU_TASK, BT_EVT_PRELOAD_CMPL);
653 }
654 }
655
656 /******************************************************************************
657 **
658 ** Function postload_cb
659 **
660 ** Description HOST/CONTROLLER LIB CALLBACK API - This function is called
661 ** when the libbt-hci lib completed stack postload process
662 **
663 ** Returns None
664 **
665 ******************************************************************************/
postload_cb(TRANSAC transac,bt_hc_postload_result_t result)666 static void postload_cb(TRANSAC transac, bt_hc_postload_result_t result)
667 {
668 UNUSED(transac);
669
670 APPL_TRACE_EVENT("HC postload_cb %d", result);
671 }
672
673 /******************************************************************************
674 **
675 ** Function lpm_cb
676 **
677 ** Description HOST/CONTROLLER LIB CALLBACK API - This function is called
678 ** back from the libbt-hci to indicate the current LPM state
679 **
680 ** Returns None
681 **
682 ******************************************************************************/
lpm_cb(bt_hc_lpm_request_result_t result)683 static void lpm_cb(bt_hc_lpm_request_result_t result)
684 {
685 APPL_TRACE_EVENT("HC lpm_result_cb %d", result);
686 lpm_enabled = (result == BT_HC_LPM_ENABLED) ? TRUE : FALSE;
687 }
688
689 /******************************************************************************
690 **
691 ** Function hostwake_ind
692 **
693 ** Description HOST/CONTROLLER LIB CALLOUT API - This function is called
694 ** from the libbt-hci to indicate the HostWake event
695 **
696 ** Returns None
697 **
698 ******************************************************************************/
hostwake_ind(bt_hc_low_power_event_t event)699 static void hostwake_ind(bt_hc_low_power_event_t event)
700 {
701 APPL_TRACE_EVENT("HC hostwake_ind %d", event);
702 }
703
704 /******************************************************************************
705 **
706 ** Function alloc
707 **
708 ** Description HOST/CONTROLLER LIB CALLOUT API - This function is called
709 ** from the libbt-hci to request for data buffer allocation
710 **
711 ** Returns NULL / pointer to allocated buffer
712 **
713 ******************************************************************************/
alloc(int size)714 static char *alloc(int size)
715 {
716 BT_HDR *p_hdr = NULL;
717
718 /*
719 APPL_TRACE_DEBUG("HC alloc size=%d", size);
720 */
721
722 /* Requested buffer size cannot exceed GKI_MAX_BUF_SIZE. */
723 if (size > GKI_MAX_BUF_SIZE)
724 {
725 APPL_TRACE_ERROR("HCI DATA SIZE %d greater than MAX %d",
726 size, GKI_MAX_BUF_SIZE);
727 return NULL;
728 }
729
730 p_hdr = (BT_HDR *) GKI_getbuf ((UINT16) size);
731
732 if (p_hdr == NULL)
733 {
734 APPL_TRACE_WARNING("alloc returns NO BUFFER! (sz %d)", size);
735 }
736
737 return ((char *) p_hdr);
738 }
739
740 /******************************************************************************
741 **
742 ** Function dealloc
743 **
744 ** Description HOST/CONTROLLER LIB CALLOUT API - This function is called
745 ** from the libbt-hci to release the data buffer allocated
746 ** through the alloc call earlier
747 **
748 ** Bluedroid libbt-hci library uses 'transac' parameter to
749 ** pass data-path buffer/packet across bt_hci_lib interface
750 ** boundary.
751 **
752 ******************************************************************************/
dealloc(TRANSAC transac)753 static void dealloc(TRANSAC transac)
754 {
755 GKI_freebuf(transac);
756 }
757
758 /******************************************************************************
759 **
760 ** Function data_ind
761 **
762 ** Description HOST/CONTROLLER LIB CALLOUT API - This function is called
763 ** from the libbt-hci to pass in the received HCI packets
764 **
765 ** The core stack is responsible for releasing the data buffer
766 ** passed in from the libbt-hci once the core stack has done
767 ** with it.
768 **
769 ** Bluedroid libbt-hci library uses 'transac' parameter to
770 ** pass data-path buffer/packet across bt_hci_lib interface
771 ** boundary. The 'p_buf' and 'len' parameters are not intended
772 ** to be used here but might point to data portion in data-
773 ** path buffer and length of valid data respectively.
774 **
775 ** Returns bt_hc_status_t
776 **
777 ******************************************************************************/
data_ind(TRANSAC transac,char * p_buf,int len)778 static int data_ind(TRANSAC transac, char *p_buf, int len)
779 {
780 BT_HDR *p_msg = (BT_HDR *) transac;
781 UNUSED(p_buf);
782 UNUSED(len);
783
784 /*
785 APPL_TRACE_DEBUG("HC data_ind event=0x%04X (len=%d)", p_msg->event, len);
786 */
787
788 GKI_send_msg (BTU_TASK, BTU_HCI_RCV_MBOX, transac);
789 return BT_HC_STATUS_SUCCESS;
790 }
791
792 /******************************************************************************
793 **
794 ** Function tx_result
795 **
796 ** Description HOST/CONTROLLER LIB CALLBACK API - This function is called
797 ** from the libbt-hci once it has processed/sent the prior data
798 ** buffer which core stack passed to it through transmit_buf
799 ** call earlier.
800 **
801 ** The core stack is responsible for releasing the data buffer
802 ** if it has been completedly processed.
803 **
804 ** Bluedroid libbt-hci library uses 'transac' parameter to
805 ** pass data-path buffer/packet across bt_hci_lib interface
806 ** boundary. The 'p_buf' is not intended to be used here
807 ** but might point to data portion in data-path buffer.
808 **
809 ** Returns bt_hc_status_t
810 **
811 ******************************************************************************/
tx_result(TRANSAC transac,char * p_buf,bt_hc_transmit_result_t result)812 static int tx_result(TRANSAC transac, char *p_buf, bt_hc_transmit_result_t result)
813 {
814 UNUSED(p_buf);
815 /*
816 APPL_TRACE_DEBUG("HC tx_result %d (event=%04X)", result, \
817 ((BT_HDR *)transac)->event);
818 */
819
820 if (result == BT_HC_TX_FRAGMENT)
821 {
822 GKI_send_msg (BTU_TASK, BTU_HCI_RCV_MBOX, transac);
823 }
824 else
825 {
826 GKI_freebuf(transac);
827 }
828
829 return BT_HC_STATUS_SUCCESS;
830 }
831
832 /*****************************************************************************
833 ** The libbt-hci Callback Functions Table
834 *****************************************************************************/
835 static const bt_hc_callbacks_t hc_callbacks = {
836 sizeof(bt_hc_callbacks_t),
837 preload_cb,
838 postload_cb,
839 lpm_cb,
840 hostwake_ind,
841 alloc,
842 dealloc,
843 data_ind,
844 tx_result
845 };
846
847