main/bte_main.c

   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 #include <cutils/properties.h>
  33
  34 #include "gki.h"
  35 #include "bd.h"
  36 #include "btu.h"
  37 #include "bte.h"
  38 #include "bta_api.h"
  39 #include "bt_utils.h"
  40 #include "bt_hci_bdroid.h"
  41
  42 /*******************************************************************************
  43 **  Constants & Macros
  44 *******************************************************************************/
  45
  46 /* Run-time configuration file */
  47 #ifndef BTE_STACK_CONF_FILE
  48 #define BTE_STACK_CONF_FILE "/etc/bluetooth/bt_stack.conf"
  49 #endif
  50 /* Run-time configuration file for BLE*/
  51 #ifndef BTE_BLE_STACK_CONF_FILE
  52 #define BTE_BLE_STACK_CONF_FILE "/etc/bluetooth/ble_stack.conf"
  53 #endif
  54
  55 /* if not specified in .txt file then use this as default  */
  56 #ifndef HCI_LOGGING_FILENAME
  57 #define HCI_LOGGING_FILENAME  "/data/misc/bluedroid/btsnoop_hci.log"
  58 #endif
  59
  60 /* Stack preload process maximum retry attempts  */
  61 #ifndef PRELOAD_MAX_RETRY_ATTEMPTS
  62 #define PRELOAD_MAX_RETRY_ATTEMPTS 0
  63 #endif
  64
  65 /*******************************************************************************
  66 **  Local type definitions
  67 *******************************************************************************/
  68 /* Preload retry control block */
  69 typedef struct
  70 {
  71     int     retry_counts;
  72     BOOLEAN timer_created;
  73     timer_t timer_id;
  74 } bt_preload_retry_cb_t;
  75
  76 /******************************************************************************
  77 **  Variables
  78 ******************************************************************************/
  79 BOOLEAN hci_logging_enabled = FALSE;    /* by default, turn hci log off */
  80 BOOLEAN hci_logging_config = FALSE;    /* configured from bluetooth framework */
  81 BOOLEAN hci_save_log = FALSE; /* save a copy of the log before starting again */
  82 char hci_logfile[256] = HCI_LOGGING_FILENAME;
  83
  84 /*******************************************************************************
  85 **  Static variables
  86 *******************************************************************************/
  87 static bt_hc_interface_t *bt_hc_if=NULL;
  88 static const bt_hc_callbacks_t hc_callbacks;
  89 static BOOLEAN lpm_enabled = FALSE;
  90 static bt_preload_retry_cb_t preload_retry_cb;
  91 // Lock to serialize cleanup requests from upper layer.
  92 static pthread_mutex_t cleanup_lock;
  93
  94 /*******************************************************************************
  95 **  Static functions
  96 *******************************************************************************/
  97 static void bte_main_in_hw_init(void);
  98 static void bte_hci_enable(void);
  99 static void bte_hci_disable(void);
 100 static void preload_start_wait_timer(void);
 101 static void preload_stop_wait_timer(void);
 102
 103 /*******************************************************************************
 104 **  Externs
 105 *******************************************************************************/
 106 BTU_API extern UINT32 btu_task (UINT32 param);
 107 BTU_API extern void BTE_Init (void);
 108 BT_API extern void BTE_LoadStack(void);
 109 BT_API void BTE_UnloadStack(void);
 110 extern void scru_flip_bda (BD_ADDR dst, const BD_ADDR src);
 111 extern void bte_load_conf(const char *p_path);
 112 extern void bte_load_ble_conf(const char *p_path);
 113 extern bt_bdaddr_t btif_local_bd_addr;
 114
 115
 116 /*******************************************************************************
 117 **                        System Task Configuration
 118 *******************************************************************************/
 119
 120 /* bluetooth protocol stack (BTU) task */
 121 #ifndef BTE_BTU_STACK_SIZE
 122 #define BTE_BTU_STACK_SIZE       0//0x2000         /* In bytes */
 123 #endif
 124 #define BTE_BTU_TASK_STR        ((INT8 *) "BTU")
 125 UINT32 bte_btu_stack[(BTE_BTU_STACK_SIZE + 3) / 4];
 126
 127 /******************************************************************************
 128 **
 129 ** Function         bte_main_in_hw_init
 130 **
 131 ** Description      Internal helper function for chip hardware init
 132 **
 133 ** Returns          None
 134 **
 135 ******************************************************************************/
 136 static void bte_main_in_hw_init(void)
 137 {
 138     if ( (bt_hc_if = (bt_hc_interface_t *) bt_hc_get_interface()) \
 139          == NULL)
 140     {
 141         APPL_TRACE_ERROR("!!! Failed to get BtHostControllerInterface !!!");
 142     }
 143
 144     memset(&preload_retry_cb, 0, sizeof(bt_preload_retry_cb_t));
 145 }
 146
 147 /******************************************************************************
 148 **
 149 ** Function         bte_main_boot_entry
 150 **
 151 ** Description      BTE MAIN API - Entry point for BTE chip/stack initialization
 152 **
 153 ** Returns          None
 154 **
 155 ******************************************************************************/
 156 void bte_main_boot_entry(void)
 157 {
 158     /* initialize OS */
 159     GKI_init();
 160
 161     bte_main_in_hw_init();
 162
 163     bte_load_conf(BTE_STACK_CONF_FILE);
 164 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
 165     bte_load_ble_conf(BTE_BLE_STACK_CONF_FILE);
 166 #endif
 167
 168 #if (BTTRC_INCLUDED == TRUE)
 169     /* Initialize trace feature */
 170     BTTRC_TraceInit(MAX_TRACE_RAM_SIZE, &BTE_TraceLogBuf[0], BTTRC_METHOD_RAM);
 171 #endif
 172
 173     pthread_mutex_init(&cleanup_lock, NULL);
 174
 175 }
 176
 177 /******************************************************************************
 178 **
 179 ** Function         bte_main_shutdown
 180 **
 181 ** Description      BTE MAIN API - Shutdown code for BTE chip/stack
 182 **
 183 ** Returns          None
 184 **
 185 ******************************************************************************/
 186 void bte_main_shutdown()
 187 {
 188     pthread_mutex_destroy(&cleanup_lock);
 189
 190     GKI_shutdown();
 191 }
 192
 193 /******************************************************************************
 194 **
 195 ** Function         bte_main_enable
 196 **
 197 ** Description      BTE MAIN API - Creates all the BTE tasks. Should be called
 198 **                  part of the Bluetooth stack enable sequence
 199 **
 200 ** Returns          None
 201 **
 202 ******************************************************************************/
 203 void bte_main_enable()
 204 {
 205     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 206
 207     /* Initialize BTE control block */
 208     BTE_Init();
 209
 210     lpm_enabled = FALSE;
 211
 212     GKI_create_task((TASKPTR)btu_task, BTU_TASK, BTE_BTU_TASK_STR,
 213                     (UINT16 *) ((UINT8 *)bte_btu_stack + BTE_BTU_STACK_SIZE),
 214                     sizeof(bte_btu_stack));
 215
 216     bte_hci_enable();
 217
 218     GKI_run();
 219 }
 220
 221 /******************************************************************************
 222 **
 223 ** Function         bte_main_disable
 224 **
 225 ** Description      BTE MAIN API - Destroys all the BTE tasks. Should be called
 226 **                  part of the Bluetooth stack disable sequence
 227 **
 228 ** Returns          None
 229 **
 230 ******************************************************************************/
 231 void bte_main_disable(void)
 232 {
 233     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 234
 235     preload_stop_wait_timer();
 236     bte_hci_disable();
 237     GKI_destroy_task(BTU_TASK);
 238 }
 239
 240 /******************************************************************************
 241 **
 242 ** Function         bte_main_config_hci_logging
 243 **
 244 ** Description      enable or disable HIC snoop logging
 245 **
 246 ** Returns          None
 247 **
 248 ******************************************************************************/
 249 void bte_main_config_hci_logging(BOOLEAN enable, BOOLEAN bt_disabled)
 250 {
 251     int old = (hci_logging_enabled == TRUE) || (hci_logging_config == TRUE);
 252     int new;
 253
 254     if (enable) {
 255         hci_logging_config = TRUE;
 256     } else {
 257         hci_logging_config = FALSE;
 258     }
 259
 260     new = (hci_logging_enabled == TRUE) || (hci_logging_config == TRUE);
 261
 262     if ((old == new) || bt_disabled || (bt_hc_if == NULL)) {
 263         return;
 264     }
 265
 266     bt_hc_if->logging(new ? BT_HC_LOGGING_ON : BT_HC_LOGGING_OFF, hci_logfile, hci_save_log);
 267 }
 268
 269 /******************************************************************************
 270 **
 271 ** Function         bte_hci_enable
 272 **
 273 ** Description      Enable HCI & Vendor modules
 274 **
 275 ** Returns          None
 276 **
 277 ******************************************************************************/
 278 static void bte_hci_enable(void)
 279 {
 280     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 281
 282     preload_start_wait_timer();
 283
 284     if (bt_hc_if)
 285     {
 286         int result = bt_hc_if->init(&hc_callbacks, btif_local_bd_addr.address);
 287         APPL_TRACE_EVENT("libbt-hci init returns %d", result);
 288
 289         assert(result == BT_HC_STATUS_SUCCESS);
 290
 291         if (hci_logging_enabled == TRUE || hci_logging_config == TRUE)
 292             bt_hc_if->logging(BT_HC_LOGGING_ON, hci_logfile, hci_save_log);
 293
 294 #if (defined (BT_CLEAN_TURN_ON_DISABLED) && BT_CLEAN_TURN_ON_DISABLED == TRUE)
 295         APPL_TRACE_DEBUG("%s  Not Turninig Off the BT before Turninig ON", __FUNCTION__);
 296
 297         /* Do not power off the chip before powering on  if BT_CLEAN_TURN_ON_DISABLED flag
 298          is defined and set to TRUE to avoid below mentioned issue.
 299
 300          Wingray kernel driver maintains a combined  counter to keep track of
 301          BT-Wifi state. Invoking  set_power(BT_HC_CHIP_PWR_OFF) when the BT is already
 302          in OFF state causes this counter to be incorrectly decremented and results in undesired
 303          behavior of the chip.
 304
 305          This is only a workaround and when the issue is fixed in the kernel this work around
 306          should be removed. */
 307 #else
 308         /* toggle chip power to ensure we will reset chip in case
 309            a previous stack shutdown wasn't completed gracefully */
 310         bt_hc_if->set_power(BT_HC_CHIP_PWR_OFF);
 311 #endif
 312         bt_hc_if->set_power(BT_HC_CHIP_PWR_ON);
 313
 314         bt_hc_if->preload(NULL);
 315     }
 316 }
 317
 318 /******************************************************************************
 319 **
 320 ** Function         bte_hci_disable
 321 **
 322 ** Description      Disable HCI & Vendor modules
 323 **
 324 ** Returns          None
 325 **
 326 ******************************************************************************/
 327 static void bte_hci_disable(void)
 328 {
 329     APPL_TRACE_DEBUG("%s", __FUNCTION__);
 330
 331     if (!bt_hc_if)
 332         return;
 333
 334     // Cleanup is not thread safe and must be protected.
 335     pthread_mutex_lock(&cleanup_lock);
 336
 337     if (hci_logging_enabled == TRUE ||  hci_logging_config == TRUE)
 338         bt_hc_if->logging(BT_HC_LOGGING_OFF, hci_logfile, hci_save_log);
 339     bt_hc_if->cleanup();
 340
 341     pthread_mutex_unlock(&cleanup_lock);
 342 }
 343
 344 /*******************************************************************************
 345 **
 346 ** Function        preload_wait_timeout
 347 **
 348 ** Description     Timeout thread of preload watchdog timer
 349 **
 350 ** Returns         None
 351 **
 352 *******************************************************************************/
 353 static void preload_wait_timeout(union sigval arg)
 354 {
 355     UNUSED(arg);
 356
 357     APPL_TRACE_ERROR("...preload_wait_timeout (retried:%d/max-retry:%d)...",
 358                         preload_retry_cb.retry_counts,
 359                         PRELOAD_MAX_RETRY_ATTEMPTS);
 360
 361     if (preload_retry_cb.retry_counts++ < PRELOAD_MAX_RETRY_ATTEMPTS)
 362     {
 363         bte_hci_disable();
 364         GKI_delay(100);
 365         bte_hci_enable();
 366     }
 367     else
 368     {
 369         /* Notify BTIF_TASK that the init procedure had failed*/
 370         GKI_send_event(BTIF_TASK, BT_EVT_HARDWARE_INIT_FAIL);
 371     }
 372 }
 373
 374 /*******************************************************************************
 375 **
 376 ** Function        preload_start_wait_timer
 377 **
 378 ** Description     Launch startup watchdog timer
 379 **
 380 ** Returns         None
 381 **
 382 *******************************************************************************/
 383 static void preload_start_wait_timer(void)
 384 {
 385     int status;
 386     struct itimerspec ts;
 387     struct sigevent se;
 388     UINT32 timeout_ms;
 389     char timeout_prop[PROPERTY_VALUE_MAX];
 390
 391     if (!property_get("bluetooth.enable_timeout_ms", timeout_prop, "3000") || (timeout_ms = atoi(timeout_prop)) < 100)
 392         timeout_ms = 3000;
 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 *******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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 ******************************************************************************/
 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