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: hardware.c 22 * 23 * Description: Contains controller-specific functions, like 24 * firmware patch download 25 * low power mode operations 26 * 27 ******************************************************************************/ 28 29 #define LOG_TAG "bt_hwcfg" 30 31 #include <utils/Log.h> 32 #include <sys/types.h> 33 #include <stdbool.h> 34 #include <sys/stat.h> 35 #include <signal.h> 36 #include <time.h> 37 #include <errno.h> 38 #include <fcntl.h> 39 #include <dirent.h> 40 #include <ctype.h> 41 #include <cutils/properties.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include "bt_hci_bdroid.h" 45 #include "bt_vendor_brcm.h" 46 #include "hci_audio.h" 47 #include "userial.h" 48 #include "userial_vendor.h" 49 #include "upio.h" 50 51 /****************************************************************************** 52 ** Constants & Macros 53 ******************************************************************************/ 54 55 #ifndef BTHW_DBG 56 #define BTHW_DBG FALSE 57 #endif 58 59 #if (BTHW_DBG == TRUE) 60 #define BTHWDBG(param, ...) {ALOGD(param, ## __VA_ARGS__);} 61 #else 62 #define BTHWDBG(param, ...) {} 63 #endif 64 65 #define FW_PATCHFILE_EXTENSION ".hcd" 66 #define FW_PATCHFILE_EXTENSION_LEN 4 67 #define FW_PATCHFILE_PATH_MAXLEN 248 /* Local_Name length of return of 68 HCI_Read_Local_Name */ 69 70 #define HCI_CMD_MAX_LEN 258 71 72 #define HCI_RESET 0x0C03 73 #define HCI_VSC_WRITE_UART_CLOCK_SETTING 0xFC45 74 #define HCI_VSC_UPDATE_BAUDRATE 0xFC18 75 #define HCI_READ_LOCAL_NAME 0x0C14 76 #define HCI_VSC_DOWNLOAD_MINIDRV 0xFC2E 77 #define HCI_VSC_WRITE_BD_ADDR 0xFC01 78 #define HCI_VSC_WRITE_SLEEP_MODE 0xFC27 79 #define HCI_VSC_WRITE_SCO_PCM_INT_PARAM 0xFC1C 80 #define HCI_VSC_WRITE_PCM_DATA_FORMAT_PARAM 0xFC1E 81 #define HCI_VSC_WRITE_I2SPCM_INTERFACE_PARAM 0xFC6D 82 #define HCI_VSC_ENABLE_WBS 0xFC7E 83 #define HCI_VSC_LAUNCH_RAM 0xFC4E 84 #define HCI_READ_LOCAL_BDADDR 0x1009 85 86 #define HCI_EVT_CMD_CMPL_STATUS_RET_BYTE 5 87 #define HCI_EVT_CMD_CMPL_LOCAL_NAME_STRING 6 88 #define HCI_EVT_CMD_CMPL_LOCAL_BDADDR_ARRAY 6 89 #define HCI_EVT_CMD_CMPL_OPCODE 3 90 #define LPM_CMD_PARAM_SIZE 12 91 #define UPDATE_BAUDRATE_CMD_PARAM_SIZE 6 92 #define HCI_CMD_PREAMBLE_SIZE 3 93 #define HCD_REC_PAYLOAD_LEN_BYTE 2 94 #define BD_ADDR_LEN 6 95 #define LOCAL_NAME_BUFFER_LEN 32 96 #define LOCAL_BDADDR_PATH_BUFFER_LEN 256 97 98 #define STREAM_TO_UINT16(u16, p) {u16 = ((uint16_t)(*(p)) + (((uint16_t)(*((p) + 1))) << 8)); (p) += 2;} 99 #define UINT8_TO_STREAM(p, u8) {*(p)++ = (uint8_t)(u8);} 100 #define UINT16_TO_STREAM(p, u16) {*(p)++ = (uint8_t)(u16); *(p)++ = (uint8_t)((u16) >> 8);} 101 #define UINT32_TO_STREAM(p, u32) {*(p)++ = (uint8_t)(u32); *(p)++ = (uint8_t)((u32) >> 8); *(p)++ = (uint8_t)((u32) >> 16); *(p)++ = (uint8_t)((u32) >> 24);} 102 103 #define SCO_INTERFACE_PCM 0 104 #define SCO_INTERFACE_I2S 1 105 106 /* one byte is for enable/disable 107 next 2 bytes are for codec type */ 108 #define SCO_CODEC_PARAM_SIZE 3 109 110 /****************************************************************************** 111 ** Local type definitions 112 ******************************************************************************/ 113 114 /* Hardware Configuration State */ 115 enum { 116 HW_CFG_START = 1, 117 HW_CFG_SET_UART_CLOCK, 118 HW_CFG_SET_UART_BAUD_1, 119 HW_CFG_READ_LOCAL_NAME, 120 HW_CFG_DL_MINIDRIVER, 121 HW_CFG_DL_FW_PATCH, 122 HW_CFG_SET_UART_BAUD_2, 123 HW_CFG_SET_BD_ADDR 124 #if (USE_CONTROLLER_BDADDR == TRUE) 125 , HW_CFG_READ_BD_ADDR 126 #endif 127 }; 128 129 /* h/w config control block */ 130 typedef struct 131 { 132 uint8_t state; /* Hardware configuration state */ 133 int fw_fd; /* FW patch file fd */ 134 uint8_t f_set_baud_2; /* Baud rate switch state */ 135 char local_chip_name[LOCAL_NAME_BUFFER_LEN]; 136 } bt_hw_cfg_cb_t; 137 138 /* low power mode parameters */ 139 typedef struct 140 { 141 uint8_t sleep_mode; /* 0(disable),1(UART),9(H5) */ 142 uint8_t host_stack_idle_threshold; /* Unit scale 300ms/25ms */ 143 uint8_t host_controller_idle_threshold; /* Unit scale 300ms/25ms */ 144 uint8_t bt_wake_polarity; /* 0=Active Low, 1= Active High */ 145 uint8_t host_wake_polarity; /* 0=Active Low, 1= Active High */ 146 uint8_t allow_host_sleep_during_sco; 147 uint8_t combine_sleep_mode_and_lpm; 148 uint8_t enable_uart_txd_tri_state; /* UART_TXD Tri-State */ 149 uint8_t sleep_guard_time; /* sleep guard time in 12.5ms */ 150 uint8_t wakeup_guard_time; /* wakeup guard time in 12.5ms */ 151 uint8_t txd_config; /* TXD is high in sleep state */ 152 uint8_t pulsed_host_wake; /* pulsed host wake if mode = 1 */ 153 } bt_lpm_param_t; 154 155 /* Firmware re-launch settlement time */ 156 typedef struct { 157 const char *chipset_name; 158 const uint32_t delay_time; 159 } fw_settlement_entry_t; 160 161 162 /****************************************************************************** 163 ** Externs 164 ******************************************************************************/ 165 166 void hw_config_cback(void *p_evt_buf); 167 extern uint8_t vnd_local_bd_addr[BD_ADDR_LEN]; 168 169 170 /****************************************************************************** 171 ** Static variables 172 ******************************************************************************/ 173 174 static char fw_patchfile_path[256] = FW_PATCHFILE_LOCATION; 175 static char fw_patchfile_name[128] = { 0 }; 176 #if (VENDOR_LIB_RUNTIME_TUNING_ENABLED == TRUE) 177 static int fw_patch_settlement_delay = -1; 178 #endif 179 180 static int wbs_sample_rate = SCO_WBS_SAMPLE_RATE; 181 static bt_hw_cfg_cb_t hw_cfg_cb; 182 183 static bt_lpm_param_t lpm_param = 184 { 185 LPM_SLEEP_MODE, 186 LPM_IDLE_THRESHOLD, 187 LPM_HC_IDLE_THRESHOLD, 188 LPM_BT_WAKE_POLARITY, 189 LPM_HOST_WAKE_POLARITY, 190 LPM_ALLOW_HOST_SLEEP_DURING_SCO, 191 LPM_COMBINE_SLEEP_MODE_AND_LPM, 192 LPM_ENABLE_UART_TXD_TRI_STATE, 193 0, /* not applicable */ 194 0, /* not applicable */ 195 0, /* not applicable */ 196 LPM_PULSED_HOST_WAKE 197 }; 198 199 /* need to update the bt_sco_i2spcm_param as well 200 bt_sco_i2spcm_param will be used for WBS setting 201 update the bt_sco_param and bt_sco_i2spcm_param */ 202 static uint8_t bt_sco_param[SCO_PCM_PARAM_SIZE] = 203 { 204 SCO_PCM_ROUTING, 205 SCO_PCM_IF_CLOCK_RATE, 206 SCO_PCM_IF_FRAME_TYPE, 207 SCO_PCM_IF_SYNC_MODE, 208 SCO_PCM_IF_CLOCK_MODE 209 }; 210 211 static uint8_t bt_pcm_data_fmt_param[PCM_DATA_FORMAT_PARAM_SIZE] = 212 { 213 PCM_DATA_FMT_SHIFT_MODE, 214 PCM_DATA_FMT_FILL_BITS, 215 PCM_DATA_FMT_FILL_METHOD, 216 PCM_DATA_FMT_FILL_NUM, 217 PCM_DATA_FMT_JUSTIFY_MODE 218 }; 219 220 static uint8_t bt_sco_i2spcm_param[SCO_I2SPCM_PARAM_SIZE] = 221 { 222 SCO_I2SPCM_IF_MODE, 223 SCO_I2SPCM_IF_ROLE, 224 SCO_I2SPCM_IF_SAMPLE_RATE, 225 SCO_I2SPCM_IF_CLOCK_RATE 226 }; 227 228 /* 229 * The look-up table of recommended firmware settlement delay (milliseconds) on 230 * known chipsets. 231 */ 232 static const fw_settlement_entry_t fw_settlement_table[] = { 233 {"BCM43241", 200}, 234 {"BCM43341", 100}, 235 {(const char *) NULL, 100} // Giving the generic fw settlement delay setting. 236 }; 237 238 239 /* 240 * NOTICE: 241 * If the platform plans to run I2S interface bus over I2S/PCM port of the 242 * BT Controller with the Host AP, explicitly set "SCO_USE_I2S_INTERFACE = TRUE" 243 * in the correspodning include/vnd_<target>.txt file. 244 * Otherwise, leave SCO_USE_I2S_INTERFACE undefined in the vnd_<target>.txt file. 245 * And, PCM interface will be set as the default bus format running over I2S/PCM 246 * port. 247 */ 248 #if (defined(SCO_USE_I2S_INTERFACE) && SCO_USE_I2S_INTERFACE == TRUE) 249 static uint8_t sco_bus_interface = SCO_INTERFACE_I2S; 250 #else 251 static uint8_t sco_bus_interface = SCO_INTERFACE_PCM; 252 #endif 253 254 #define INVALID_SCO_CLOCK_RATE 0xFF 255 static uint8_t sco_bus_clock_rate = INVALID_SCO_CLOCK_RATE; 256 static uint8_t sco_bus_wbs_clock_rate = INVALID_SCO_CLOCK_RATE; 257 258 /****************************************************************************** 259 ** Static functions 260 ******************************************************************************/ 261 static void hw_sco_i2spcm_config(uint16_t codec); 262 static void hw_sco_i2spcm_config_from_command(void *p_mem, uint16_t codec); 263 264 /****************************************************************************** 265 ** Controller Initialization Static Functions 266 ******************************************************************************/ 267 268 /******************************************************************************* 269 ** 270 ** Function look_up_fw_settlement_delay 271 ** 272 ** Description If FW_PATCH_SETTLEMENT_DELAY_MS has not been explicitly 273 ** re-defined in the platform specific build-time configuration 274 ** file, we will search into the look-up table for a 275 ** recommended firmware settlement delay value. 276 ** 277 ** Although the settlement time might be also related to board 278 ** configurations such as the crystal clocking speed. 279 ** 280 ** Returns Firmware settlement delay 281 ** 282 *******************************************************************************/ 283 uint32_t look_up_fw_settlement_delay (void) 284 { 285 uint32_t ret_value; 286 fw_settlement_entry_t *p_entry; 287 288 if (FW_PATCH_SETTLEMENT_DELAY_MS > 0) 289 { 290 ret_value = FW_PATCH_SETTLEMENT_DELAY_MS; 291 } 292 #if (VENDOR_LIB_RUNTIME_TUNING_ENABLED == TRUE) 293 else if (fw_patch_settlement_delay >= 0) 294 { 295 ret_value = fw_patch_settlement_delay; 296 } 297 #endif 298 else 299 { 300 p_entry = (fw_settlement_entry_t *)fw_settlement_table; 301 302 while (p_entry->chipset_name != NULL) 303 { 304 if (strstr(hw_cfg_cb.local_chip_name, p_entry->chipset_name)!=NULL) 305 { 306 break; 307 } 308 309 p_entry++; 310 } 311 312 ret_value = p_entry->delay_time; 313 } 314 315 BTHWDBG( "Settlement delay -- %d ms", ret_value); 316 317 return (ret_value); 318 } 319 320 /******************************************************************************* 321 ** 322 ** Function ms_delay 323 ** 324 ** Description sleep unconditionally for timeout milliseconds 325 ** 326 ** Returns None 327 ** 328 *******************************************************************************/ 329 void ms_delay (uint32_t timeout) 330 { 331 struct timespec delay; 332 int err; 333 334 if (timeout == 0) 335 return; 336 337 delay.tv_sec = timeout / 1000; 338 delay.tv_nsec = 1000 * 1000 * (timeout%1000); 339 340 /* [u]sleep can't be used because it uses SIGALRM */ 341 do { 342 err = nanosleep(&delay, &delay); 343 } while (err < 0 && errno ==EINTR); 344 } 345 346 /******************************************************************************* 347 ** 348 ** Function line_speed_to_userial_baud 349 ** 350 ** Description helper function converts line speed number into USERIAL baud 351 ** rate symbol 352 ** 353 ** Returns unit8_t (USERIAL baud symbol) 354 ** 355 *******************************************************************************/ 356 uint8_t line_speed_to_userial_baud(uint32_t line_speed) 357 { 358 uint8_t baud; 359 360 if (line_speed == 4000000) 361 baud = USERIAL_BAUD_4M; 362 else if (line_speed == 3000000) 363 baud = USERIAL_BAUD_3M; 364 else if (line_speed == 2000000) 365 baud = USERIAL_BAUD_2M; 366 else if (line_speed == 1000000) 367 baud = USERIAL_BAUD_1M; 368 else if (line_speed == 921600) 369 baud = USERIAL_BAUD_921600; 370 else if (line_speed == 460800) 371 baud = USERIAL_BAUD_460800; 372 else if (line_speed == 230400) 373 baud = USERIAL_BAUD_230400; 374 else if (line_speed == 115200) 375 baud = USERIAL_BAUD_115200; 376 else if (line_speed == 57600) 377 baud = USERIAL_BAUD_57600; 378 else if (line_speed == 19200) 379 baud = USERIAL_BAUD_19200; 380 else if (line_speed == 9600) 381 baud = USERIAL_BAUD_9600; 382 else if (line_speed == 1200) 383 baud = USERIAL_BAUD_1200; 384 else if (line_speed == 600) 385 baud = USERIAL_BAUD_600; 386 else 387 { 388 ALOGE( "userial vendor: unsupported baud speed %d", line_speed); 389 baud = USERIAL_BAUD_115200; 390 } 391 392 return baud; 393 } 394 395 396 /******************************************************************************* 397 ** 398 ** Function hw_strncmp 399 ** 400 ** Description Used to compare two strings in caseless 401 ** 402 ** Returns 0: match, otherwise: not match 403 ** 404 *******************************************************************************/ 405 static int hw_strncmp (const char *p_str1, const char *p_str2, const int len) 406 { 407 int i; 408 409 if (!p_str1 || !p_str2) 410 return (1); 411 412 for (i = 0; i < len; i++) 413 { 414 if (toupper(p_str1[i]) != toupper(p_str2[i])) 415 return (i+1); 416 } 417 418 return 0; 419 } 420 421 /******************************************************************************* 422 ** 423 ** Function hw_config_findpatch 424 ** 425 ** Description Search for a proper firmware patch file 426 ** The selected firmware patch file name with full path 427 ** will be stored in the input string parameter, i.e. 428 ** p_chip_id_str, when returns. 429 ** 430 ** Returns TRUE when found the target patch file, otherwise FALSE 431 ** 432 *******************************************************************************/ 433 static uint8_t hw_config_findpatch(char *p_chip_id_str) 434 { 435 DIR *dirp; 436 struct dirent *dp; 437 int filenamelen; 438 uint8_t retval = FALSE; 439 440 BTHWDBG("Target name = [%s]", p_chip_id_str); 441 442 if (strlen(fw_patchfile_name)> 0) 443 { 444 /* If specific filepath and filename have been given in run-time 445 * configuration /etc/bluetooth/bt_vendor.conf file, we will use them 446 * to concatenate the filename to open rather than searching a file 447 * matching to chipset name in the fw_patchfile_path folder. 448 */ 449 sprintf(p_chip_id_str, "%s", fw_patchfile_path); 450 if (fw_patchfile_path[strlen(fw_patchfile_path)- 1] != '/') 451 { 452 strcat(p_chip_id_str, "/"); 453 } 454 strcat(p_chip_id_str, fw_patchfile_name); 455 456 ALOGI("FW patchfile: %s", p_chip_id_str); 457 return TRUE; 458 } 459 460 if ((dirp = opendir(fw_patchfile_path)) != NULL) 461 { 462 /* Fetch next filename in patchfile directory */ 463 while ((dp = readdir(dirp)) != NULL) 464 { 465 /* Check if filename starts with chip-id name */ 466 if ((hw_strncmp(dp->d_name, p_chip_id_str, strlen(p_chip_id_str)) \ 467 ) == 0) 468 { 469 /* Check if it has .hcd extenstion */ 470 filenamelen = strlen(dp->d_name); 471 if ((filenamelen >= FW_PATCHFILE_EXTENSION_LEN) && 472 ((hw_strncmp( 473 &dp->d_name[filenamelen-FW_PATCHFILE_EXTENSION_LEN], \ 474 FW_PATCHFILE_EXTENSION, \ 475 FW_PATCHFILE_EXTENSION_LEN) \ 476 ) == 0)) 477 { 478 ALOGI("Found patchfile: %s/%s", \ 479 fw_patchfile_path, dp->d_name); 480 481 /* Make sure length does not exceed maximum */ 482 if ((filenamelen + strlen(fw_patchfile_path)) > \ 483 FW_PATCHFILE_PATH_MAXLEN) 484 { 485 ALOGE("Invalid patchfile name (too long)"); 486 } 487 else 488 { 489 memset(p_chip_id_str, 0, FW_PATCHFILE_PATH_MAXLEN); 490 /* Found patchfile. Store location and name */ 491 strcpy(p_chip_id_str, fw_patchfile_path); 492 if (fw_patchfile_path[ \ 493 strlen(fw_patchfile_path)- 1 \ 494 ] != '/') 495 { 496 strcat(p_chip_id_str, "/"); 497 } 498 strcat(p_chip_id_str, dp->d_name); 499 retval = TRUE; 500 } 501 break; 502 } 503 } 504 } 505 506 closedir(dirp); 507 508 if (retval == FALSE) 509 { 510 /* Try again chip name without revision info */ 511 512 int len = strlen(p_chip_id_str); 513 char *p = p_chip_id_str + len - 1; 514 515 /* Scan backward and look for the first alphabet 516 which is not M or m 517 */ 518 while (len > 3) // BCM**** 519 { 520 if ((isdigit(*p)==0) && (*p != 'M') && (*p != 'm')) 521 break; 522 523 p--; 524 len--; 525 } 526 527 if (len > 3) 528 { 529 *p = 0; 530 retval = hw_config_findpatch(p_chip_id_str); 531 } 532 } 533 } 534 else 535 { 536 ALOGE("Could not open %s", fw_patchfile_path); 537 } 538 539 return (retval); 540 } 541 542 /******************************************************************************* 543 ** 544 ** Function hw_config_set_bdaddr 545 ** 546 ** Description Program controller's Bluetooth Device Address 547 ** 548 ** Returns TRUE, if valid address is sent 549 ** FALSE, otherwise 550 ** 551 *******************************************************************************/ 552 static uint8_t hw_config_set_bdaddr(HC_BT_HDR *p_buf) 553 { 554 uint8_t retval = FALSE; 555 uint8_t *p = (uint8_t *) (p_buf + 1); 556 557 ALOGI("Setting local bd addr to %02X:%02X:%02X:%02X:%02X:%02X", 558 vnd_local_bd_addr[0], vnd_local_bd_addr[1], vnd_local_bd_addr[2], 559 vnd_local_bd_addr[3], vnd_local_bd_addr[4], vnd_local_bd_addr[5]); 560 561 UINT16_TO_STREAM(p, HCI_VSC_WRITE_BD_ADDR); 562 *p++ = BD_ADDR_LEN; /* parameter length */ 563 *p++ = vnd_local_bd_addr[5]; 564 *p++ = vnd_local_bd_addr[4]; 565 *p++ = vnd_local_bd_addr[3]; 566 *p++ = vnd_local_bd_addr[2]; 567 *p++ = vnd_local_bd_addr[1]; 568 *p = vnd_local_bd_addr[0]; 569 570 p_buf->len = HCI_CMD_PREAMBLE_SIZE + BD_ADDR_LEN; 571 hw_cfg_cb.state = HW_CFG_SET_BD_ADDR; 572 573 retval = bt_vendor_cbacks->xmit_cb(HCI_VSC_WRITE_BD_ADDR, p_buf, \ 574 hw_config_cback); 575 576 return (retval); 577 } 578 579 #if (USE_CONTROLLER_BDADDR == TRUE) 580 /******************************************************************************* 581 ** 582 ** Function hw_config_read_bdaddr 583 ** 584 ** Description Read controller's Bluetooth Device Address 585 ** 586 ** Returns TRUE, if valid address is sent 587 ** FALSE, otherwise 588 ** 589 *******************************************************************************/ 590 static uint8_t hw_config_read_bdaddr(HC_BT_HDR *p_buf) 591 { 592 uint8_t retval = FALSE; 593 uint8_t *p = (uint8_t *) (p_buf + 1); 594 595 UINT16_TO_STREAM(p, HCI_READ_LOCAL_BDADDR); 596 *p = 0; /* parameter length */ 597 598 p_buf->len = HCI_CMD_PREAMBLE_SIZE; 599 hw_cfg_cb.state = HW_CFG_READ_BD_ADDR; 600 601 retval = bt_vendor_cbacks->xmit_cb(HCI_READ_LOCAL_BDADDR, p_buf, \ 602 hw_config_cback); 603 604 return (retval); 605 } 606 #endif // (USE_CONTROLLER_BDADDR == TRUE) 607 608 /******************************************************************************* 609 ** 610 ** Function hw_config_cback 611 ** 612 ** Description Callback function for controller configuration 613 ** 614 ** Returns None 615 ** 616 *******************************************************************************/ 617 void hw_config_cback(void *p_mem) 618 { 619 HC_BT_HDR *p_evt_buf = (HC_BT_HDR *) p_mem; 620 char *p_name, *p_tmp; 621 uint8_t *p, status; 622 uint16_t opcode; 623 HC_BT_HDR *p_buf=NULL; 624 uint8_t is_proceeding = FALSE; 625 int i; 626 int delay=100; 627 #if (USE_CONTROLLER_BDADDR == TRUE) 628 const uint8_t null_bdaddr[BD_ADDR_LEN] = {0,0,0,0,0,0}; 629 #endif 630 631 status = *((uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_STATUS_RET_BYTE); 632 p = (uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_OPCODE; 633 STREAM_TO_UINT16(opcode,p); 634 635 /* Ask a new buffer big enough to hold any HCI commands sent in here */ 636 if ((status == 0) && bt_vendor_cbacks) 637 p_buf = (HC_BT_HDR *) bt_vendor_cbacks->alloc(BT_HC_HDR_SIZE + \ 638 HCI_CMD_MAX_LEN); 639 640 if (p_buf != NULL) 641 { 642 p_buf->event = MSG_STACK_TO_HC_HCI_CMD; 643 p_buf->offset = 0; 644 p_buf->len = 0; 645 p_buf->layer_specific = 0; 646 647 p = (uint8_t *) (p_buf + 1); 648 649 switch (hw_cfg_cb.state) 650 { 651 case HW_CFG_SET_UART_BAUD_1: 652 /* update baud rate of host's UART port */ 653 ALOGI("bt vendor lib: set UART baud %i", UART_TARGET_BAUD_RATE); 654 userial_vendor_set_baud( \ 655 line_speed_to_userial_baud(UART_TARGET_BAUD_RATE) \ 656 ); 657 658 /* read local name */ 659 UINT16_TO_STREAM(p, HCI_READ_LOCAL_NAME); 660 *p = 0; /* parameter length */ 661 662 p_buf->len = HCI_CMD_PREAMBLE_SIZE; 663 hw_cfg_cb.state = HW_CFG_READ_LOCAL_NAME; 664 665 is_proceeding = bt_vendor_cbacks->xmit_cb(HCI_READ_LOCAL_NAME, \ 666 p_buf, hw_config_cback); 667 break; 668 669 case HW_CFG_READ_LOCAL_NAME: 670 p_tmp = p_name = (char *) (p_evt_buf + 1) + \ 671 HCI_EVT_CMD_CMPL_LOCAL_NAME_STRING; 672 673 for (i=0; (i < LOCAL_NAME_BUFFER_LEN)||(*(p_name+i) != 0); i++) 674 *(p_name+i) = toupper(*(p_name+i)); 675 676 if ((p_name = strstr(p_name, "BCM")) != NULL) 677 { 678 strncpy(hw_cfg_cb.local_chip_name, p_name, \ 679 LOCAL_NAME_BUFFER_LEN-1); 680 } 681 #ifdef USE_BLUETOOTH_BCM4343 682 else if ((p_name = strstr(p_tmp, "4343")) != NULL) 683 { 684 snprintf(hw_cfg_cb.local_chip_name, 685 LOCAL_NAME_BUFFER_LEN-1, "BCM%s", p_name); 686 strncpy(p_name, hw_cfg_cb.local_chip_name, 687 LOCAL_NAME_BUFFER_LEN-1); 688 } 689 #endif 690 else 691 { 692 strncpy(hw_cfg_cb.local_chip_name, "UNKNOWN", \ 693 LOCAL_NAME_BUFFER_LEN-1); 694 p_name = p_tmp; 695 } 696 697 hw_cfg_cb.local_chip_name[LOCAL_NAME_BUFFER_LEN-1] = 0; 698 699 BTHWDBG("Chipset %s", hw_cfg_cb.local_chip_name); 700 701 if ((status = hw_config_findpatch(p_name)) == TRUE) 702 { 703 if ((hw_cfg_cb.fw_fd = open(p_name, O_RDONLY)) == -1) 704 { 705 ALOGE("vendor lib preload failed to open [%s]", p_name); 706 } 707 else 708 { 709 /* vsc_download_minidriver */ 710 UINT16_TO_STREAM(p, HCI_VSC_DOWNLOAD_MINIDRV); 711 *p = 0; /* parameter length */ 712 713 p_buf->len = HCI_CMD_PREAMBLE_SIZE; 714 hw_cfg_cb.state = HW_CFG_DL_MINIDRIVER; 715 716 is_proceeding = bt_vendor_cbacks->xmit_cb( \ 717 HCI_VSC_DOWNLOAD_MINIDRV, p_buf, \ 718 hw_config_cback); 719 } 720 } 721 else 722 { 723 ALOGE( \ 724 "vendor lib preload failed to locate firmware patch file" \ 725 ); 726 } 727 728 if (is_proceeding == FALSE) 729 { 730 is_proceeding = hw_config_set_bdaddr(p_buf); 731 } 732 break; 733 734 case HW_CFG_DL_MINIDRIVER: 735 /* give time for placing firmware in download mode */ 736 ms_delay(50); 737 hw_cfg_cb.state = HW_CFG_DL_FW_PATCH; 738 /* fall through intentionally */ 739 case HW_CFG_DL_FW_PATCH: 740 p_buf->len = read(hw_cfg_cb.fw_fd, p, HCI_CMD_PREAMBLE_SIZE); 741 if (p_buf->len > 0) 742 { 743 if ((p_buf->len < HCI_CMD_PREAMBLE_SIZE) || \ 744 (opcode == HCI_VSC_LAUNCH_RAM)) 745 { 746 ALOGW("firmware patch file might be altered!"); 747 } 748 else 749 { 750 p_buf->len += read(hw_cfg_cb.fw_fd, \ 751 p+HCI_CMD_PREAMBLE_SIZE,\ 752 *(p+HCD_REC_PAYLOAD_LEN_BYTE)); 753 STREAM_TO_UINT16(opcode,p); 754 is_proceeding = bt_vendor_cbacks->xmit_cb(opcode, \ 755 p_buf, hw_config_cback); 756 break; 757 } 758 } 759 760 close(hw_cfg_cb.fw_fd); 761 hw_cfg_cb.fw_fd = -1; 762 763 /* Normally the firmware patch configuration file 764 * sets the new starting baud rate at 115200. 765 * So, we need update host's baud rate accordingly. 766 */ 767 ALOGI("bt vendor lib: set UART baud 115200"); 768 userial_vendor_set_baud(USERIAL_BAUD_115200); 769 770 /* Next, we would like to boost baud rate up again 771 * to desired working speed. 772 */ 773 hw_cfg_cb.f_set_baud_2 = TRUE; 774 775 /* Check if we need to pause a few hundred milliseconds 776 * before sending down any HCI command. 777 */ 778 delay = look_up_fw_settlement_delay(); 779 ALOGI("Setting fw settlement delay to %d ", delay); 780 ms_delay(delay); 781 782 p_buf->len = HCI_CMD_PREAMBLE_SIZE; 783 UINT16_TO_STREAM(p, HCI_RESET); 784 *p = 0; /* parameter length */ 785 hw_cfg_cb.state = HW_CFG_START; 786 is_proceeding = bt_vendor_cbacks->xmit_cb(HCI_RESET, p_buf, hw_config_cback); 787 break; 788 789 case HW_CFG_START: 790 if (UART_TARGET_BAUD_RATE > 3000000) 791 { 792 /* set UART clock to 48MHz */ 793 UINT16_TO_STREAM(p, HCI_VSC_WRITE_UART_CLOCK_SETTING); 794 *p++ = 1; /* parameter length */ 795 *p = 1; /* (1,"UART CLOCK 48 MHz")(2,"UART CLOCK 24 MHz") */ 796 797 p_buf->len = HCI_CMD_PREAMBLE_SIZE + 1; 798 hw_cfg_cb.state = HW_CFG_SET_UART_CLOCK; 799 800 is_proceeding = bt_vendor_cbacks->xmit_cb( \ 801 HCI_VSC_WRITE_UART_CLOCK_SETTING, \ 802 p_buf, hw_config_cback); 803 break; 804 } 805 /* fall through intentionally */ 806 case HW_CFG_SET_UART_CLOCK: 807 /* set controller's UART baud rate to 3M */ 808 UINT16_TO_STREAM(p, HCI_VSC_UPDATE_BAUDRATE); 809 *p++ = UPDATE_BAUDRATE_CMD_PARAM_SIZE; /* parameter length */ 810 *p++ = 0; /* encoded baud rate */ 811 *p++ = 0; /* use encoded form */ 812 UINT32_TO_STREAM(p, UART_TARGET_BAUD_RATE); 813 814 p_buf->len = HCI_CMD_PREAMBLE_SIZE + \ 815 UPDATE_BAUDRATE_CMD_PARAM_SIZE; 816 hw_cfg_cb.state = (hw_cfg_cb.f_set_baud_2) ? \ 817 HW_CFG_SET_UART_BAUD_2 : HW_CFG_SET_UART_BAUD_1; 818 819 is_proceeding = bt_vendor_cbacks->xmit_cb(HCI_VSC_UPDATE_BAUDRATE, \ 820 p_buf, hw_config_cback); 821 break; 822 823 case HW_CFG_SET_UART_BAUD_2: 824 /* update baud rate of host's UART port */ 825 ALOGI("bt vendor lib: set UART baud %i", UART_TARGET_BAUD_RATE); 826 userial_vendor_set_baud( \ 827 line_speed_to_userial_baud(UART_TARGET_BAUD_RATE) \ 828 ); 829 830 #if (USE_CONTROLLER_BDADDR == TRUE) 831 if ((is_proceeding = hw_config_read_bdaddr(p_buf)) == TRUE) 832 break; 833 #else 834 if ((is_proceeding = hw_config_set_bdaddr(p_buf)) == TRUE) 835 break; 836 #endif 837 /* fall through intentionally */ 838 case HW_CFG_SET_BD_ADDR: 839 ALOGI("vendor lib fwcfg completed"); 840 bt_vendor_cbacks->dealloc(p_buf); 841 bt_vendor_cbacks->fwcfg_cb(BT_VND_OP_RESULT_SUCCESS); 842 843 hw_cfg_cb.state = 0; 844 845 if (hw_cfg_cb.fw_fd != -1) 846 { 847 close(hw_cfg_cb.fw_fd); 848 hw_cfg_cb.fw_fd = -1; 849 } 850 851 is_proceeding = TRUE; 852 break; 853 854 #if (USE_CONTROLLER_BDADDR == TRUE) 855 case HW_CFG_READ_BD_ADDR: 856 p_tmp = (char *) (p_evt_buf + 1) + \ 857 HCI_EVT_CMD_CMPL_LOCAL_BDADDR_ARRAY; 858 859 if (memcmp(p_tmp, null_bdaddr, BD_ADDR_LEN) == 0) 860 { 861 // Controller does not have a valid OTP BDADDR! 862 // Set the BTIF initial BDADDR instead. 863 if ((is_proceeding = hw_config_set_bdaddr(p_buf)) == TRUE) 864 break; 865 } 866 else 867 { 868 ALOGI("Controller OTP bdaddr %02X:%02X:%02X:%02X:%02X:%02X", 869 *(p_tmp+5), *(p_tmp+4), *(p_tmp+3), 870 *(p_tmp+2), *(p_tmp+1), *p_tmp); 871 } 872 873 ALOGI("vendor lib fwcfg completed"); 874 bt_vendor_cbacks->dealloc(p_buf); 875 bt_vendor_cbacks->fwcfg_cb(BT_VND_OP_RESULT_SUCCESS); 876 877 hw_cfg_cb.state = 0; 878 879 if (hw_cfg_cb.fw_fd != -1) 880 { 881 close(hw_cfg_cb.fw_fd); 882 hw_cfg_cb.fw_fd = -1; 883 } 884 885 is_proceeding = TRUE; 886 break; 887 #endif // (USE_CONTROLLER_BDADDR == TRUE) 888 } // switch(hw_cfg_cb.state) 889 } // if (p_buf != NULL) 890 891 /* Free the RX event buffer */ 892 if (bt_vendor_cbacks) 893 bt_vendor_cbacks->dealloc(p_evt_buf); 894 895 if (is_proceeding == FALSE) 896 { 897 ALOGE("vendor lib fwcfg aborted!!!"); 898 if (bt_vendor_cbacks) 899 { 900 if (p_buf != NULL) 901 bt_vendor_cbacks->dealloc(p_buf); 902 903 bt_vendor_cbacks->fwcfg_cb(BT_VND_OP_RESULT_FAIL); 904 } 905 906 if (hw_cfg_cb.fw_fd != -1) 907 { 908 close(hw_cfg_cb.fw_fd); 909 hw_cfg_cb.fw_fd = -1; 910 } 911 912 hw_cfg_cb.state = 0; 913 } 914 } 915 916 /****************************************************************************** 917 ** LPM Static Functions 918 ******************************************************************************/ 919 920 /******************************************************************************* 921 ** 922 ** Function hw_lpm_ctrl_cback 923 ** 924 ** Description Callback function for lpm enable/disable rquest 925 ** 926 ** Returns None 927 ** 928 *******************************************************************************/ 929 void hw_lpm_ctrl_cback(void *p_mem) 930 { 931 HC_BT_HDR *p_evt_buf = (HC_BT_HDR *) p_mem; 932 bt_vendor_op_result_t status = BT_VND_OP_RESULT_FAIL; 933 934 if (*((uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_STATUS_RET_BYTE) == 0) 935 { 936 status = BT_VND_OP_RESULT_SUCCESS; 937 } 938 939 if (bt_vendor_cbacks) 940 { 941 bt_vendor_cbacks->lpm_cb(status); 942 bt_vendor_cbacks->dealloc(p_evt_buf); 943 } 944 } 945 946 947 #if (SCO_CFG_INCLUDED == TRUE) 948 /***************************************************************************** 949 ** SCO Configuration Static Functions 950 *****************************************************************************/ 951 952 /******************************************************************************* 953 ** 954 ** Function hw_sco_i2spcm_cfg_cback 955 ** 956 ** Description Callback function for SCO I2S/PCM configuration rquest 957 ** 958 ** Returns None 959 ** 960 *******************************************************************************/ 961 static void hw_sco_i2spcm_cfg_cback(void *p_mem) 962 { 963 HC_BT_HDR *p_evt_buf = (HC_BT_HDR *)p_mem; 964 uint8_t *p; 965 uint16_t opcode; 966 HC_BT_HDR *p_buf = NULL; 967 bt_vendor_op_result_t status = BT_VND_OP_RESULT_FAIL; 968 969 p = (uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_OPCODE; 970 STREAM_TO_UINT16(opcode,p); 971 972 if (*((uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_STATUS_RET_BYTE) == 0) 973 { 974 status = BT_VND_OP_RESULT_SUCCESS; 975 } 976 977 /* Free the RX event buffer */ 978 if (bt_vendor_cbacks) 979 bt_vendor_cbacks->dealloc(p_evt_buf); 980 981 if (status == BT_VND_OP_RESULT_SUCCESS) 982 { 983 if ((opcode == HCI_VSC_WRITE_I2SPCM_INTERFACE_PARAM) && 984 (SCO_INTERFACE_PCM == sco_bus_interface)) 985 { 986 uint8_t ret = FALSE; 987 988 /* Ask a new buffer to hold WRITE_SCO_PCM_INT_PARAM command */ 989 if (bt_vendor_cbacks) 990 p_buf = (HC_BT_HDR *)bt_vendor_cbacks->alloc( 991 BT_HC_HDR_SIZE + HCI_CMD_PREAMBLE_SIZE + SCO_PCM_PARAM_SIZE); 992 if (p_buf) 993 { 994 p_buf->event = MSG_STACK_TO_HC_HCI_CMD; 995 p_buf->offset = 0; 996 p_buf->layer_specific = 0; 997 p_buf->len = HCI_CMD_PREAMBLE_SIZE + SCO_PCM_PARAM_SIZE; 998 p = (uint8_t *)(p_buf + 1); 999 1000 /* do we need this VSC for I2S??? */ 1001 UINT16_TO_STREAM(p, HCI_VSC_WRITE_SCO_PCM_INT_PARAM); 1002 *p++ = SCO_PCM_PARAM_SIZE; 1003 memcpy(p, &bt_sco_param, SCO_PCM_PARAM_SIZE); 1004 ALOGI("SCO PCM configure {0x%x, 0x%x, 0x%x, 0x%x, 0x%x}", 1005 bt_sco_param[0], bt_sco_param[1], bt_sco_param[2], bt_sco_param[3], 1006 bt_sco_param[4]); 1007 if ((ret = bt_vendor_cbacks->xmit_cb(HCI_VSC_WRITE_SCO_PCM_INT_PARAM, p_buf, 1008 hw_sco_i2spcm_cfg_cback)) == FALSE) 1009 { 1010 bt_vendor_cbacks->dealloc(p_buf); 1011 } 1012 else 1013 return; 1014 } 1015 status = BT_VND_OP_RESULT_FAIL; 1016 } 1017 else if ((opcode == HCI_VSC_WRITE_SCO_PCM_INT_PARAM) && 1018 (SCO_INTERFACE_PCM == sco_bus_interface)) 1019 { 1020 uint8_t ret = FALSE; 1021 1022 /* Ask a new buffer to hold WRITE_PCM_DATA_FORMAT_PARAM command */ 1023 if (bt_vendor_cbacks) 1024 p_buf = (HC_BT_HDR *)bt_vendor_cbacks->alloc( 1025 BT_HC_HDR_SIZE + HCI_CMD_PREAMBLE_SIZE + PCM_DATA_FORMAT_PARAM_SIZE); 1026 if (p_buf) 1027 { 1028 p_buf->event = MSG_STACK_TO_HC_HCI_CMD; 1029 p_buf->offset = 0; 1030 p_buf->layer_specific = 0; 1031 p_buf->len = HCI_CMD_PREAMBLE_SIZE + PCM_DATA_FORMAT_PARAM_SIZE; 1032 1033 p = (uint8_t *)(p_buf + 1); 1034 UINT16_TO_STREAM(p, HCI_VSC_WRITE_PCM_DATA_FORMAT_PARAM); 1035 *p++ = PCM_DATA_FORMAT_PARAM_SIZE; 1036 memcpy(p, &bt_pcm_data_fmt_param, PCM_DATA_FORMAT_PARAM_SIZE); 1037 1038 ALOGI("SCO PCM data format {0x%x, 0x%x, 0x%x, 0x%x, 0x%x}", 1039 bt_pcm_data_fmt_param[0], bt_pcm_data_fmt_param[1], 1040 bt_pcm_data_fmt_param[2], bt_pcm_data_fmt_param[3], 1041 bt_pcm_data_fmt_param[4]); 1042 1043 if ((ret = bt_vendor_cbacks->xmit_cb(HCI_VSC_WRITE_PCM_DATA_FORMAT_PARAM, 1044 p_buf, hw_sco_i2spcm_cfg_cback)) == FALSE) 1045 { 1046 bt_vendor_cbacks->dealloc(p_buf); 1047 } 1048 else 1049 return; 1050 } 1051 status = BT_VND_OP_RESULT_FAIL; 1052 } 1053 } 1054 1055 ALOGI("sco I2S/PCM config result %d [0-Success, 1-Fail]", status); 1056 if (bt_vendor_cbacks) 1057 { 1058 bt_vendor_cbacks->audio_state_cb(status); 1059 } 1060 } 1061 1062 /******************************************************************************* 1063 ** 1064 ** Function hw_set_MSBC_codec_cback 1065 ** 1066 ** Description Callback function for setting WBS codec 1067 ** 1068 ** Returns None 1069 ** 1070 *******************************************************************************/ 1071 static void hw_set_MSBC_codec_cback(void *p_mem) 1072 { 1073 /* whenever update the codec enable/disable, need to update I2SPCM */ 1074 ALOGI("SCO I2S interface change the sample rate to 16K"); 1075 hw_sco_i2spcm_config_from_command(p_mem, SCO_CODEC_MSBC); 1076 } 1077 1078 /******************************************************************************* 1079 ** 1080 ** Function hw_set_CVSD_codec_cback 1081 ** 1082 ** Description Callback function for setting NBS codec 1083 ** 1084 ** Returns None 1085 ** 1086 *******************************************************************************/ 1087 static void hw_set_CVSD_codec_cback(void *p_mem) 1088 { 1089 /* whenever update the codec enable/disable, need to update I2SPCM */ 1090 ALOGI("SCO I2S interface change the sample rate to 8K"); 1091 hw_sco_i2spcm_config_from_command(p_mem, SCO_CODEC_CVSD); 1092 } 1093 1094 #endif // SCO_CFG_INCLUDED 1095 1096 /***************************************************************************** 1097 ** Hardware Configuration Interface Functions 1098 *****************************************************************************/ 1099 1100 1101 /******************************************************************************* 1102 ** 1103 ** Function hw_config_start 1104 ** 1105 ** Description Kick off controller initialization process 1106 ** 1107 ** Returns None 1108 ** 1109 *******************************************************************************/ 1110 void hw_config_start(void) 1111 { 1112 HC_BT_HDR *p_buf = NULL; 1113 uint8_t *p; 1114 1115 hw_cfg_cb.state = 0; 1116 hw_cfg_cb.fw_fd = -1; 1117 hw_cfg_cb.f_set_baud_2 = FALSE; 1118 1119 /* Start from sending HCI_RESET */ 1120 1121 if (bt_vendor_cbacks) 1122 { 1123 p_buf = (HC_BT_HDR *) bt_vendor_cbacks->alloc(BT_HC_HDR_SIZE + \ 1124 HCI_CMD_PREAMBLE_SIZE); 1125 } 1126 1127 if (p_buf) 1128 { 1129 p_buf->event = MSG_STACK_TO_HC_HCI_CMD; 1130 p_buf->offset = 0; 1131 p_buf->layer_specific = 0; 1132 p_buf->len = HCI_CMD_PREAMBLE_SIZE; 1133 1134 p = (uint8_t *) (p_buf + 1); 1135 UINT16_TO_STREAM(p, HCI_RESET); 1136 *p = 0; /* parameter length */ 1137 1138 hw_cfg_cb.state = HW_CFG_START; 1139 1140 bt_vendor_cbacks->xmit_cb(HCI_RESET, p_buf, hw_config_cback); 1141 } 1142 else 1143 { 1144 if (bt_vendor_cbacks) 1145 { 1146 ALOGE("vendor lib fw conf aborted [no buffer]"); 1147 bt_vendor_cbacks->fwcfg_cb(BT_VND_OP_RESULT_FAIL); 1148 } 1149 } 1150 } 1151 1152 /******************************************************************************* 1153 ** 1154 ** Function hw_lpm_enable 1155 ** 1156 ** Description Enalbe/Disable LPM 1157 ** 1158 ** Returns TRUE/FALSE 1159 ** 1160 *******************************************************************************/ 1161 uint8_t hw_lpm_enable(uint8_t turn_on) 1162 { 1163 HC_BT_HDR *p_buf = NULL; 1164 uint8_t *p; 1165 uint8_t ret = FALSE; 1166 1167 if (bt_vendor_cbacks) 1168 p_buf = (HC_BT_HDR *) bt_vendor_cbacks->alloc(BT_HC_HDR_SIZE + \ 1169 HCI_CMD_PREAMBLE_SIZE + \ 1170 LPM_CMD_PARAM_SIZE); 1171 1172 if (p_buf) 1173 { 1174 p_buf->event = MSG_STACK_TO_HC_HCI_CMD; 1175 p_buf->offset = 0; 1176 p_buf->layer_specific = 0; 1177 p_buf->len = HCI_CMD_PREAMBLE_SIZE + LPM_CMD_PARAM_SIZE; 1178 1179 p = (uint8_t *) (p_buf + 1); 1180 UINT16_TO_STREAM(p, HCI_VSC_WRITE_SLEEP_MODE); 1181 *p++ = LPM_CMD_PARAM_SIZE; /* parameter length */ 1182 1183 if (turn_on) 1184 { 1185 memcpy(p, &lpm_param, LPM_CMD_PARAM_SIZE); 1186 upio_set(UPIO_LPM_MODE, UPIO_ASSERT, 0); 1187 } 1188 else 1189 { 1190 memset(p, 0, LPM_CMD_PARAM_SIZE); 1191 upio_set(UPIO_LPM_MODE, UPIO_DEASSERT, 0); 1192 } 1193 1194 if ((ret = bt_vendor_cbacks->xmit_cb(HCI_VSC_WRITE_SLEEP_MODE, p_buf, \ 1195 hw_lpm_ctrl_cback)) == FALSE) 1196 { 1197 bt_vendor_cbacks->dealloc(p_buf); 1198 } 1199 } 1200 1201 if ((ret == FALSE) && bt_vendor_cbacks) 1202 bt_vendor_cbacks->lpm_cb(BT_VND_OP_RESULT_FAIL); 1203 1204 return ret; 1205 } 1206 1207 /******************************************************************************* 1208 ** 1209 ** Function hw_lpm_get_idle_timeout 1210 ** 1211 ** Description Calculate idle time based on host stack idle threshold 1212 ** 1213 ** Returns idle timeout value 1214 ** 1215 *******************************************************************************/ 1216 uint32_t hw_lpm_get_idle_timeout(void) 1217 { 1218 uint32_t timeout_ms; 1219 1220 /* set idle time to be LPM_IDLE_TIMEOUT_MULTIPLE times of 1221 * host stack idle threshold (in 300ms/25ms) 1222 */ 1223 timeout_ms = (uint32_t)lpm_param.host_stack_idle_threshold \ 1224 * LPM_IDLE_TIMEOUT_MULTIPLE; 1225 if (strstr(hw_cfg_cb.local_chip_name, "BCM4325") != NULL) 1226 timeout_ms *= 25; // 12.5 or 25 ? 1227 else if (strstr(hw_cfg_cb.local_chip_name, "BCM4358") != NULL) 1228 timeout_ms *= 50; 1229 else 1230 timeout_ms *= 300; 1231 1232 return timeout_ms; 1233 } 1234 1235 /******************************************************************************* 1236 ** 1237 ** Function hw_lpm_set_wake_state 1238 ** 1239 ** Description Assert/Deassert BT_WAKE 1240 ** 1241 ** Returns None 1242 ** 1243 *******************************************************************************/ 1244 void hw_lpm_set_wake_state(uint8_t wake_assert) 1245 { 1246 uint8_t state = (wake_assert) ? UPIO_ASSERT : UPIO_DEASSERT; 1247 1248 upio_set(UPIO_BT_WAKE, state, lpm_param.bt_wake_polarity); 1249 } 1250 1251 #if (SCO_CFG_INCLUDED == TRUE) 1252 /******************************************************************************* 1253 ** 1254 ** Function hw_sco_config 1255 ** 1256 ** Description Configure SCO related hardware settings 1257 ** 1258 ** Returns None 1259 ** 1260 *******************************************************************************/ 1261 void hw_sco_config(void) 1262 { 1263 if (SCO_INTERFACE_I2S == sco_bus_interface) 1264 { 1265 /* 'Enable' I2S mode */ 1266 bt_sco_i2spcm_param[0] = 1; 1267 1268 /* set nbs clock rate as the value in SCO_I2SPCM_IF_CLOCK_RATE field */ 1269 sco_bus_clock_rate = bt_sco_i2spcm_param[3]; 1270 } 1271 else 1272 { 1273 /* 'Disable' I2S mode */ 1274 bt_sco_i2spcm_param[0] = 0; 1275 1276 /* set nbs clock rate as the value in SCO_PCM_IF_CLOCK_RATE field */ 1277 sco_bus_clock_rate = bt_sco_param[1]; 1278 1279 /* sync up clock mode setting */ 1280 bt_sco_i2spcm_param[1] = bt_sco_param[4]; 1281 } 1282 1283 if (sco_bus_wbs_clock_rate == INVALID_SCO_CLOCK_RATE) 1284 { 1285 /* set default wbs clock rate */ 1286 sco_bus_wbs_clock_rate = SCO_I2SPCM_IF_CLOCK_RATE4WBS; 1287 1288 if (sco_bus_wbs_clock_rate < sco_bus_clock_rate) 1289 sco_bus_wbs_clock_rate = sco_bus_clock_rate; 1290 } 1291 1292 /* 1293 * To support I2S/PCM port multiplexing signals for sharing Bluetooth audio 1294 * and FM on the same PCM pins, we defer Bluetooth audio (SCO/eSCO) 1295 * configuration till SCO/eSCO is being established; 1296 * i.e. in hw_set_audio_state() call. 1297 * When configured as I2S only, Bluetooth audio configuration is executed 1298 * immediately with SCO_CODEC_CVSD by default. 1299 */ 1300 1301 if (SCO_INTERFACE_I2S == sco_bus_interface) { 1302 hw_sco_i2spcm_config(SCO_CODEC_CVSD); 1303 } 1304 1305 if (bt_vendor_cbacks) 1306 { 1307 bt_vendor_cbacks->scocfg_cb(BT_VND_OP_RESULT_SUCCESS); 1308 } 1309 } 1310 1311 static void hw_sco_i2spcm_config_from_command(void *p_mem, uint16_t codec) { 1312 HC_BT_HDR *p_evt_buf = (HC_BT_HDR *)p_mem; 1313 bool command_success = *((uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_STATUS_RET_BYTE) == 0; 1314 1315 /* Free the RX event buffer */ 1316 if (bt_vendor_cbacks) 1317 bt_vendor_cbacks->dealloc(p_evt_buf); 1318 1319 if (command_success) 1320 hw_sco_i2spcm_config(codec); 1321 else if (bt_vendor_cbacks) 1322 bt_vendor_cbacks->audio_state_cb(BT_VND_OP_RESULT_FAIL); 1323 } 1324 1325 1326 /******************************************************************************* 1327 ** 1328 ** Function hw_sco_i2spcm_config 1329 ** 1330 ** Description Configure SCO over I2S or PCM 1331 ** 1332 ** Returns None 1333 ** 1334 *******************************************************************************/ 1335 static void hw_sco_i2spcm_config(uint16_t codec) 1336 { 1337 HC_BT_HDR *p_buf = NULL; 1338 uint8_t *p, ret; 1339 uint16_t cmd_u16 = HCI_CMD_PREAMBLE_SIZE + SCO_I2SPCM_PARAM_SIZE; 1340 1341 if (bt_vendor_cbacks) 1342 p_buf = (HC_BT_HDR *)bt_vendor_cbacks->alloc(BT_HC_HDR_SIZE + cmd_u16); 1343 1344 if (p_buf) 1345 { 1346 p_buf->event = MSG_STACK_TO_HC_HCI_CMD; 1347 p_buf->offset = 0; 1348 p_buf->layer_specific = 0; 1349 p_buf->len = cmd_u16; 1350 1351 p = (uint8_t *)(p_buf + 1); 1352 1353 UINT16_TO_STREAM(p, HCI_VSC_WRITE_I2SPCM_INTERFACE_PARAM); 1354 *p++ = SCO_I2SPCM_PARAM_SIZE; 1355 if (codec == SCO_CODEC_CVSD) 1356 { 1357 bt_sco_i2spcm_param[2] = 0; /* SCO_I2SPCM_IF_SAMPLE_RATE 8k */ 1358 bt_sco_i2spcm_param[3] = bt_sco_param[1] = sco_bus_clock_rate; 1359 } 1360 else if (codec == SCO_CODEC_MSBC) 1361 { 1362 bt_sco_i2spcm_param[2] = wbs_sample_rate; /* SCO_I2SPCM_IF_SAMPLE_RATE 16K */ 1363 bt_sco_i2spcm_param[3] = bt_sco_param[1] = sco_bus_wbs_clock_rate; 1364 } 1365 else 1366 { 1367 bt_sco_i2spcm_param[2] = 0; /* SCO_I2SPCM_IF_SAMPLE_RATE 8k */ 1368 bt_sco_i2spcm_param[3] = bt_sco_param[1] = sco_bus_clock_rate; 1369 ALOGE("wrong codec is use in hw_sco_i2spcm_config, goes default NBS"); 1370 } 1371 memcpy(p, &bt_sco_i2spcm_param, SCO_I2SPCM_PARAM_SIZE); 1372 cmd_u16 = HCI_VSC_WRITE_I2SPCM_INTERFACE_PARAM; 1373 ALOGI("I2SPCM config {0x%x, 0x%x, 0x%x, 0x%x}", 1374 bt_sco_i2spcm_param[0], bt_sco_i2spcm_param[1], 1375 bt_sco_i2spcm_param[2], bt_sco_i2spcm_param[3]); 1376 1377 if ((ret = bt_vendor_cbacks->xmit_cb(cmd_u16, p_buf, hw_sco_i2spcm_cfg_cback)) == FALSE) 1378 { 1379 bt_vendor_cbacks->dealloc(p_buf); 1380 } 1381 else 1382 return; 1383 } 1384 1385 bt_vendor_cbacks->audio_state_cb(BT_VND_OP_RESULT_FAIL); 1386 } 1387 1388 /******************************************************************************* 1389 ** 1390 ** Function hw_set_SCO_codec 1391 ** 1392 ** Description This functgion sends command to the controller to setup 1393 ** WBS/NBS codec for the upcoming eSCO connection. 1394 ** 1395 ** Returns -1 : Failed to send VSC 1396 ** 0 : Success 1397 ** 1398 *******************************************************************************/ 1399 static int hw_set_SCO_codec(uint16_t codec) 1400 { 1401 HC_BT_HDR *p_buf = NULL; 1402 uint8_t *p; 1403 uint8_t ret; 1404 int ret_val = 0; 1405 tINT_CMD_CBACK p_set_SCO_codec_cback; 1406 1407 BTHWDBG( "hw_set_SCO_codec 0x%x", codec); 1408 1409 if (bt_vendor_cbacks) 1410 p_buf = (HC_BT_HDR *)bt_vendor_cbacks->alloc( 1411 BT_HC_HDR_SIZE + HCI_CMD_PREAMBLE_SIZE + SCO_CODEC_PARAM_SIZE); 1412 1413 if (p_buf) 1414 { 1415 p_buf->event = MSG_STACK_TO_HC_HCI_CMD; 1416 p_buf->offset = 0; 1417 p_buf->layer_specific = 0; 1418 p = (uint8_t *)(p_buf + 1); 1419 1420 UINT16_TO_STREAM(p, HCI_VSC_ENABLE_WBS); 1421 1422 if (codec == SCO_CODEC_MSBC) 1423 { 1424 /* Enable mSBC */ 1425 *p++ = SCO_CODEC_PARAM_SIZE; /* set the parameter size */ 1426 UINT8_TO_STREAM(p,1); /* enable */ 1427 UINT16_TO_STREAM(p, codec); 1428 1429 /* set the totall size of this packet */ 1430 p_buf->len = HCI_CMD_PREAMBLE_SIZE + SCO_CODEC_PARAM_SIZE; 1431 1432 p_set_SCO_codec_cback = hw_set_MSBC_codec_cback; 1433 } 1434 else 1435 { 1436 /* Disable mSBC */ 1437 *p++ = (SCO_CODEC_PARAM_SIZE - 2); /* set the parameter size */ 1438 UINT8_TO_STREAM(p,0); /* disable */ 1439 1440 /* set the totall size of this packet */ 1441 p_buf->len = HCI_CMD_PREAMBLE_SIZE + SCO_CODEC_PARAM_SIZE - 2; 1442 1443 p_set_SCO_codec_cback = hw_set_CVSD_codec_cback; 1444 if ((codec != SCO_CODEC_CVSD) && (codec != SCO_CODEC_NONE)) 1445 { 1446 ALOGW("SCO codec setting is wrong: codec: 0x%x", codec); 1447 } 1448 } 1449 1450 if ((ret = bt_vendor_cbacks->xmit_cb(HCI_VSC_ENABLE_WBS, p_buf, p_set_SCO_codec_cback))\ 1451 == FALSE) 1452 { 1453 bt_vendor_cbacks->dealloc(p_buf); 1454 ret_val = -1; 1455 } 1456 } 1457 else 1458 { 1459 ret_val = -1; 1460 } 1461 1462 return ret_val; 1463 } 1464 1465 /******************************************************************************* 1466 ** 1467 ** Function hw_set_audio_state 1468 ** 1469 ** Description This function configures audio base on provided audio state 1470 ** 1471 ** Paramters pointer to audio state structure 1472 ** 1473 ** Returns 0: ok, -1: error 1474 ** 1475 *******************************************************************************/ 1476 int hw_set_audio_state(bt_vendor_op_audio_state_t *p_state) 1477 { 1478 int ret_val = -1; 1479 1480 if (!bt_vendor_cbacks) 1481 return ret_val; 1482 1483 ret_val = hw_set_SCO_codec(p_state->peer_codec); 1484 return ret_val; 1485 } 1486 1487 #else // SCO_CFG_INCLUDED 1488 int hw_set_audio_state(bt_vendor_op_audio_state_t *p_state) 1489 { 1490 return -256; 1491 } 1492 #endif 1493 /******************************************************************************* 1494 ** 1495 ** Function hw_set_patch_file_path 1496 ** 1497 ** Description Set the location of firmware patch file 1498 ** 1499 ** Returns 0 : Success 1500 ** Otherwise : Fail 1501 ** 1502 *******************************************************************************/ 1503 int hw_set_patch_file_path(char *p_conf_name, char *p_conf_value, int param) 1504 { 1505 1506 strcpy(fw_patchfile_path, p_conf_value); 1507 1508 return 0; 1509 } 1510 1511 /******************************************************************************* 1512 ** 1513 ** Function hw_set_patch_file_name 1514 ** 1515 ** Description Give the specific firmware patch filename 1516 ** 1517 ** Returns 0 : Success 1518 ** Otherwise : Fail 1519 ** 1520 *******************************************************************************/ 1521 int hw_set_patch_file_name(char *p_conf_name, char *p_conf_value, int param) 1522 { 1523 1524 strcpy(fw_patchfile_name, p_conf_value); 1525 1526 return 0; 1527 } 1528 1529 #if (VENDOR_LIB_RUNTIME_TUNING_ENABLED == TRUE) 1530 /******************************************************************************* 1531 ** 1532 ** Function hw_set_patch_settlement_delay 1533 ** 1534 ** Description Give the specific firmware patch settlement time in milliseconds 1535 ** 1536 ** Returns 0 : Success 1537 ** Otherwise : Fail 1538 ** 1539 *******************************************************************************/ 1540 int hw_set_patch_settlement_delay(char *p_conf_name, char *p_conf_value, int param) 1541 { 1542 fw_patch_settlement_delay = atoi(p_conf_value); 1543 1544 return 0; 1545 } 1546 #endif //VENDOR_LIB_RUNTIME_TUNING_ENABLED 1547 1548 /***************************************************************************** 1549 ** Sample Codes Section 1550 *****************************************************************************/ 1551 1552 #if (HW_END_WITH_HCI_RESET == TRUE) 1553 /******************************************************************************* 1554 ** 1555 ** Function hw_epilog_cback 1556 ** 1557 ** Description Callback function for Command Complete Events from HCI 1558 ** commands sent in epilog process. 1559 ** 1560 ** Returns None 1561 ** 1562 *******************************************************************************/ 1563 void hw_epilog_cback(void *p_mem) 1564 { 1565 HC_BT_HDR *p_evt_buf = (HC_BT_HDR *) p_mem; 1566 uint8_t *p, status; 1567 uint16_t opcode; 1568 1569 status = *((uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_STATUS_RET_BYTE); 1570 p = (uint8_t *)(p_evt_buf + 1) + HCI_EVT_CMD_CMPL_OPCODE; 1571 STREAM_TO_UINT16(opcode,p); 1572 1573 BTHWDBG("%s Opcode:0x%04X Status: %d", __FUNCTION__, opcode, status); 1574 1575 if (bt_vendor_cbacks) 1576 { 1577 /* Must free the RX event buffer */ 1578 bt_vendor_cbacks->dealloc(p_evt_buf); 1579 1580 /* Once epilog process is done, must call epilog_cb callback 1581 to notify caller */ 1582 bt_vendor_cbacks->epilog_cb(BT_VND_OP_RESULT_SUCCESS); 1583 } 1584 } 1585 1586 /******************************************************************************* 1587 ** 1588 ** Function hw_epilog_process 1589 ** 1590 ** Description Sample implementation of epilog process 1591 ** 1592 ** Returns None 1593 ** 1594 *******************************************************************************/ 1595 void hw_epilog_process(void) 1596 { 1597 HC_BT_HDR *p_buf = NULL; 1598 uint8_t *p; 1599 1600 BTHWDBG("hw_epilog_process"); 1601 1602 /* Sending a HCI_RESET */ 1603 if (bt_vendor_cbacks) 1604 { 1605 /* Must allocate command buffer via HC's alloc API */ 1606 p_buf = (HC_BT_HDR *) bt_vendor_cbacks->alloc(BT_HC_HDR_SIZE + \ 1607 HCI_CMD_PREAMBLE_SIZE); 1608 } 1609 1610 if (p_buf) 1611 { 1612 p_buf->event = MSG_STACK_TO_HC_HCI_CMD; 1613 p_buf->offset = 0; 1614 p_buf->layer_specific = 0; 1615 p_buf->len = HCI_CMD_PREAMBLE_SIZE; 1616 1617 p = (uint8_t *) (p_buf + 1); 1618 UINT16_TO_STREAM(p, HCI_RESET); 1619 *p = 0; /* parameter length */ 1620 1621 /* Send command via HC's xmit_cb API */ 1622 bt_vendor_cbacks->xmit_cb(HCI_RESET, p_buf, hw_epilog_cback); 1623 } 1624 else 1625 { 1626 if (bt_vendor_cbacks) 1627 { 1628 ALOGE("vendor lib epilog process aborted [no buffer]"); 1629 bt_vendor_cbacks->epilog_cb(BT_VND_OP_RESULT_FAIL); 1630 } 1631 } 1632 } 1633 #endif // (HW_END_WITH_HCI_RESET == TRUE) 1634
