/******************************************************************************
|
*
|
* Copyright (C) 2020-2021 SeekWave Technology
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
*
|
******************************************************************************/
|
|
/******************************************************************************
|
*
|
* Filename: bt_vendor_skw.c
|
*
|
* Description: SeekWave vendor specific library implementation
|
*
|
******************************************************************************/
|
|
#undef NDEBUG
|
#define LOG_TAG "libbt_vendor"
|
|
|
#include <utils/Log.h>
|
#include "bt_vendor_skw.h"
|
#include "scom_vendor.h"
|
#include "skw_btsnoop.h"
|
#include "skw_log.h"
|
#include "skw_gen_addr.h"
|
#include "skw_common.h"
|
#include <cutils/properties.h>
|
#include "skw_ext.h"
|
|
#define SKWBT_CONFIG_FILE "/vendor/etc/bluetooth/skwbt.conf"
|
|
bt_vendor_callbacks_t *bt_vendor_cbacks = NULL;
|
uint8_t vnd_local_bd_addr[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
uint8_t port_cnts = 0;
|
|
char skwbt_transtype = 0;
|
static char skwbt_device_node[BT_COM_PORT_SIZE][DEVICE_NODE_MAX_LEN + 1];
|
|
int btboot_fp = -1;
|
int btpw_fp = -1;
|
char btsnoop_log_en = FALSE;
|
char btcp_log_en = FALSE;
|
char skwlog_slice = FALSE;
|
char skwdriverlog_en = TRUE;
|
char skwbtuartonly = TRUE;
|
char skwbtNoSleep = FALSE; //No Sleep
|
|
extern char skw_btsnoop_path[];
|
extern char btsnoop_save_log;
|
extern Wakeup_ADV_Info_St wakeup_ADV_Info;
|
|
static char *trim(char *str)
|
{
|
while (isspace(*str))
|
{
|
++str;
|
}
|
|
if (!*str)
|
{
|
return str;
|
}
|
|
char *end_str = str + strlen(str) - 1;
|
while (end_str > str && isspace(*end_str))
|
{
|
--end_str;
|
}
|
|
end_str[1] = '\0';
|
return str;
|
}
|
|
|
static void load_skwbt_conf()
|
{
|
memset(skwbt_device_node, 0, sizeof(skwbt_device_node));
|
FILE *fp = fopen(SKWBT_CONFIG_FILE, "rt");
|
if (!fp)
|
{
|
//ALOGE("%s unable to open file '%s': %s", __func__, SKWBT_CONFIG_FILE, strerror(errno));
|
strcpy(skwbt_device_node[0], "/dev/ttyS0");
|
return ;
|
}
|
|
char *split;
|
char line[1024];
|
int port_index = BT_COM_PORT_CMDEVT;
|
|
while (fgets(line, sizeof(line), fp))
|
{
|
char *line_ptr = trim(line);
|
|
// Skip blank and comment lines.
|
if (*line_ptr == '\0' || *line_ptr == '#' || *line_ptr == '[')
|
{
|
continue;
|
}
|
|
split = strchr(line_ptr, '=');
|
if (!split)
|
{
|
ALOGE("%s no key/value separator found", __func__);
|
fclose(fp);
|
return;
|
}
|
|
*split = '\0';
|
split ++;
|
if((!strcmp(trim(line_ptr), "BtDeviceNode")) && (port_index < BT_COM_PORT_SIZE))
|
{
|
int mode = O_RDWR;
|
char *str_ptr = trim(split);
|
int len = strlen(str_ptr);
|
#if 0
|
if(strstr(split, "BTDATA"))
|
{
|
port_index = BT_COM_PORT_ACL;
|
}
|
else if(strstr(split, "BTAUDIO"))
|
{
|
port_index = BT_COM_PORT_AUDIO;
|
}
|
else if(strstr(split, "BTISOC"))
|
{
|
port_index = BT_COM_PORT_ISO;
|
}
|
#endif
|
if(len > DEVICE_NODE_MAX_LEN)
|
{
|
len = DEVICE_NODE_MAX_LEN;
|
str_ptr[DEVICE_NODE_MAX_LEN] = 0x00;
|
}
|
memcpy(skwbt_device_node[port_index], str_ptr, len);
|
scomm_vendor_set_port_name(port_index, skwbt_device_node[port_index], mode);
|
|
port_index ++;
|
}
|
}
|
|
|
fclose(fp);
|
|
skwbt_transtype = SKWBT_TRANS_TYPE_H4;
|
if(skwbt_device_node[0][0] == '?')
|
{
|
int i = 0;
|
while(skwbt_device_node[0][i] != '\0')
|
{
|
skwbt_device_node[0][i] = skwbt_device_node[0][i + 1];
|
i++;
|
}
|
scomm_vendor_set_port_name(0, skwbt_device_node[0], O_RDWR);
|
skwbt_transtype |= SKWBT_TRANS_TYPE_UART;
|
}
|
}
|
|
char skwbt_boot_open()
|
{
|
btboot_fp = open("/dev/BTBOOT", O_RDWR);
|
if (btboot_fp < 0)
|
{
|
ALOGE("%s: unable to open : %s", __func__, strerror(errno));
|
return FALSE;
|
}
|
return TRUE;
|
}
|
|
|
static void load_skwbt_stack_conf()
|
{
|
FILE *fp = fopen(SKWBT_CONFIG_FILE, "rt");
|
if (!fp)
|
{
|
ALOGE("%s unable to open file '%s': %s", __func__, SKWBT_CONFIG_FILE, strerror(errno));
|
return;
|
}
|
char *split;
|
int line_num = 0;
|
char line[1024];
|
while (fgets(line, sizeof(line), fp))
|
{
|
char *line_ptr = trim(line);
|
++line_num;
|
|
// Skip blank and comment lines.
|
if (*line_ptr == '\0' || *line_ptr == '#' || *line_ptr == '[')
|
{
|
continue;
|
}
|
|
split = strchr(line_ptr, '=');
|
if (!split)
|
{
|
ALOGE("%s no key/value separator found on line %d.", __func__, line_num);
|
continue;
|
}
|
|
*split = '\0';
|
|
if(!strcmp(trim(line_ptr), "SkwBtsnoopDump"))
|
{
|
if(!strcmp(trim(split + 1), "true"))
|
{
|
btsnoop_log_en = TRUE;
|
}
|
else
|
{
|
btsnoop_log_en = FALSE;
|
}
|
}
|
else if(!strcmp(trim(line_ptr), "BtSnoopFileName"))
|
{
|
sprintf(skw_btsnoop_path, "%s", trim(split + 1));
|
}
|
else if(!strcmp(trim(line_ptr), "BtSnoopSaveLog"))
|
{
|
if(!strcmp(trim(split + 1), "true"))
|
{
|
btsnoop_save_log = TRUE;
|
}
|
else
|
{
|
btsnoop_save_log = FALSE;
|
}
|
}
|
else if(!strcmp(trim(line_ptr), "SkwBtcplog"))
|
{
|
if(!strcmp(trim(split + 1), "true"))
|
{
|
btcp_log_en = TRUE;
|
}
|
else
|
{
|
btcp_log_en = FALSE;
|
}
|
}
|
else if(!strcmp(trim(line_ptr), "SkwLogSlice"))
|
{
|
if(!strcmp(trim(split + 1), "true"))
|
{
|
skwlog_slice = TRUE;
|
}
|
else
|
{
|
skwlog_slice = FALSE;
|
}
|
}
|
else if(!strcmp(trim(line_ptr), "SkwBtDrvlog"))
|
{
|
if(!strcmp(trim(split + 1), "false"))
|
{
|
skwdriverlog_en = FALSE;
|
}
|
}
|
else if(!strcmp(trim(line_ptr), "SkwBtUartOnly"))
|
{
|
if(!strcmp(trim(split + 1), "false"))//SkwBtUartOnly is false
|
{
|
skwbtuartonly = FALSE;
|
}
|
}
|
else if(!strcmp(trim(line_ptr), "SkwBtNoSleep"))
|
{
|
if(strcmp(trim(split + 1), "true") == 0)//SkwBtNoSleep is true
|
{
|
skwbtNoSleep = TRUE;
|
}
|
}
|
else if(!strcmp(trim(line_ptr), "WakeupADVData"))
|
{
|
char *data_str = trim(split + 1);
|
if(data_str)
|
{
|
scomm_vendor_parse_wakeup_adv_conf(data_str);
|
}
|
}
|
|
|
}
|
|
fclose(fp);
|
}
|
|
|
|
|
/*****************************************************************************
|
**
|
** BLUETOOTH VENDOR INTERFACE LIBRARY FUNCTIONS
|
**
|
*****************************************************************************/
|
|
|
|
/** initialise **/
|
static int init(const bt_vendor_callbacks_t *p_cb, unsigned char *local_bdaddr)
|
{
|
ALOGI("SeekWave BlueTooth Version: %s", SKW_LIBBT_VERSION);
|
if (p_cb == NULL)
|
{
|
ALOGE("init failed with no user callbacks!");
|
return -1;
|
}
|
|
scomm_vendor_init();
|
|
load_skwbt_conf();
|
load_skwbt_stack_conf();
|
skwlog_init();
|
|
|
bt_vendor_cbacks = (bt_vendor_callbacks_t *) p_cb;//save callback
|
memcpy(vnd_local_bd_addr, local_bdaddr, 6);
|
|
if(btsnoop_log_en)
|
{
|
//enable btsnoop log
|
skw_btsnoop_init();
|
}
|
skw_addr_gen_init();
|
|
return 0;
|
}
|
|
/** operations **/
|
static int op(bt_vendor_opcode_t opcode, void *param)
|
{
|
int retval = 0;
|
|
ALOGD("op for %d", opcode);
|
|
switch(opcode)
|
{
|
case BT_VND_OP_POWER_CTRL:
|
{
|
if(skwbt_transtype & SKWBT_TRANS_TYPE_UART)
|
{
|
int *state = (int *) param;
|
if (*state == BT_VND_PWR_OFF)
|
{
|
usleep(200000);
|
ALOGD("set power off and delay 200ms");
|
}
|
else if (*state == BT_VND_PWR_ON)
|
{
|
usleep(200000);
|
ALOGD("set power on and delay 200ms");
|
}
|
}
|
}
|
break;
|
|
case BT_VND_OP_FW_CFG:
|
{
|
scomm_vendor_config_start();
|
}
|
break;
|
|
case BT_VND_OP_SCO_CFG:
|
{
|
retval = -1;
|
}
|
break;
|
|
case BT_VND_OP_USERIAL_OPEN:
|
{
|
int fd = -1, idx = 0;
|
int (*fd_array)[] = (int (*)[]) param;
|
|
|
if(skwbt_transtype & SKWBT_TRANS_TYPE_UART)
|
{
|
if(skwbtuartonly == FALSE)
|
{
|
SKWBT_LOG("open boot");
|
if(!skwbt_boot_open())
|
{
|
retval = 0;
|
break;
|
}
|
btpw_fp = open("/dev/BTDATA", O_RDWR);
|
}
|
if(scomm_vendor_uart_open(0) != -1)
|
{
|
retval = 1;
|
fd = scomm_vendor_socket_open(0);
|
}
|
}
|
else
|
{
|
int tFd = -1;
|
//uint8_t log_enable = 0;
|
if(!skwbt_boot_open())
|
{
|
retval = 0;
|
break;
|
}
|
#if 0
|
if(ioctl(btboot_fp, IOCTL_CMD_LOG_EN_GET, &log_enable) == 0)
|
{
|
ALOGD("SKWBT log_enable res:%d, btcp_log_en:%d, btsnoop_log_en:%d", log_enable, btcp_log_en, btsnoop_log_en);
|
if(btcp_log_en && log_enable)//0:default, 1:release version; 2:debug version
|
{
|
btcp_log_en = log_enable == 2;
|
}
|
if(btsnoop_log_en && log_enable)
|
{
|
btsnoop_log_en = log_enable == 2;
|
}
|
}
|
#endif
|
|
#ifdef IOCTL_CMD_WAKEUP_ADV_EN
|
if(wakeup_ADV_Info.grp_nums > 0)
|
{
|
int res = ioctl(btboot_fp, IOCTL_CMD_WAKEUP_ADV_EN);
|
ALOGD("%s, wakeup adv en res:%d", __func__, res);
|
}
|
#endif
|
for (idx = 0; idx < BT_COM_PORT_SIZE; idx++)
|
{
|
if(scomm_vendor_check_port_valid(idx) == FALSE)
|
{
|
continue;
|
}
|
if(scomm_vendor_usbsdio_open(idx) != -1)
|
{
|
tFd = scomm_vendor_socket_open(idx);
|
|
ALOGD("idx:%d, tFd:%d, fd:%d", idx, tFd, fd);
|
if((tFd != -1) && (fd == -1))
|
{
|
fd = tFd;
|
}
|
}
|
else
|
{
|
break;
|
}
|
}
|
|
if(idx <= BT_COM_PORT_ACL)
|
{
|
skwbt_transtype |= SKWBT_TRANS_TYPE_USB;
|
}
|
else
|
{
|
skwbt_transtype |= SKWBT_TRANS_TYPE_SDIO;
|
}
|
}
|
ALOGD("retval:%d, fd:%d, idx:%d", retval, fd, idx);
|
|
if (fd != -1)
|
{
|
retval = 1;
|
for (idx = 0; idx < CH_MAX; idx++)
|
{
|
(*fd_array)[idx] = fd;
|
}
|
skw_ext_inotify_thread_init();
|
property_set("SKWBT.OPEN.STATE", "1");
|
}
|
else
|
{
|
retval = 0;
|
}
|
}
|
break;
|
|
case BT_VND_OP_USERIAL_CLOSE:
|
{
|
if(btboot_fp > 0)
|
{
|
scomm_vendor_write_bt_state();
|
close(btboot_fp);
|
btboot_fp = -1;
|
}
|
scomm_vendor_close();
|
skw_ext_inotify_thread_exit();
|
property_set("SKWBT.OPEN.STATE", "0");
|
}
|
break;
|
|
case BT_VND_OP_GET_LPM_IDLE_TIMEOUT:
|
{
|
|
}
|
break;
|
|
case BT_VND_OP_LPM_SET_MODE:
|
{
|
|
}
|
break;
|
|
case BT_VND_OP_LPM_WAKE_SET_STATE:
|
{
|
|
}
|
break;
|
case BT_VND_OP_EPILOG:
|
{
|
if(bt_vendor_cbacks)
|
{
|
bt_vendor_cbacks->epilog_cb(BT_VND_OP_RESULT_SUCCESS);
|
}
|
}
|
break;
|
|
default:
|
break;
|
}
|
|
return retval;
|
}
|
|
|
/** Close **/
|
static void cleanup( void )
|
{
|
ALOGD("bt_vendor_skw.c cleanup");
|
|
if(btsnoop_log_en)
|
{
|
skw_btsnoop_close();
|
}
|
skwlog_close();
|
|
btsnoop_log_en = FALSE;
|
bt_vendor_cbacks = NULL;
|
skwbt_transtype = 0;
|
}
|
|
|
|
// Entry point
|
const bt_vendor_interface_t BLUETOOTH_VENDOR_LIB_INTERFACE = {sizeof(bt_vendor_interface_t),
|
init,
|
op,
|
cleanup
|
};
|
