bluetooth_CFLAGS += -DUSE_AUDIO_TRACK
+ifeq ($(BOARD_USES_WIPOWER),true)
+bluetooth_CFLAGS += -DWIPOWER_SUPPORTED
+endif
+
bluetooth_CFLAGS += -DEXPORT_SYMBOL="__attribute__((visibility(\"default\")))"
#
};
/* move ctrl_fd outside output stream and keep open until HAL unloaded ? */
+#define MAX_CODEC_CFG_SIZE 30
struct a2dp_stream_common {
pthread_mutex_t lock;
size_t buffer_sz;
struct a2dp_config cfg;
a2dp_state_t state;
- uint8_t codec_cfg[20];
+ uint8_t codec_cfg[MAX_CODEC_CFG_SIZE];
};
/*****************************************************************************
** Type definitions for callback functions
char byte,len;
uint8_t *p_cfg = codec_cfg;
INFO("%s",__func__);
- if (codec_cfg[CODEC_OFFSET] == CODEC_TYPE_SBC)
+ if (codec_cfg[CODEC_OFFSET] == CODEC_TYPE_PCM)
+ {
+ *codec_type = AUDIO_FORMAT_PCM_16_BIT;
+ //For the time being Audio does not require any param to be passed for PCM so returning null
+ return NULL;
+ }
+ else if (codec_cfg[CODEC_OFFSET] == CODEC_TYPE_SBC)
{
memset(&sbc_codec,0,sizeof(audio_sbc_encoder_config));
p_cfg++;//skip dev idx
cmd[0] = A2DP_CTRL_GET_CODEC_CONFIG;
cmd[1] = idx;
INFO("%s",__func__);
- memset(p_codec_cfg,0,20);
+ memset(p_codec_cfg,0,MAX_CODEC_CFG_SIZE);
INFO("%s",__func__);
if (send(common->ctrl_fd, cmd, 2, MSG_NOSIGNAL) == -1)
#define CODEC_OFFSET 3
#define VENDOR_ID_OFFSET 4
#define CODEC_ID_OFFSET (VENDOR_ID_OFFSET + 4)
+#define CODEC_TYPE_PCM 0x05
#ifndef VENDOR_APTX
#define VENDOR_APTX 0x4F
break;
case BTA_AG_HF_CMD_BRSF:
- /* store peer features */
+ /* store peer features. */
p_scb->peer_features = (UINT16) int_arg;
features = p_scb->features & BTA_AG_BSRF_FEAT_SPEC;
/* if the devices does not support HFP 1.7, report DUT's HFP version as 1.6 */
- if (p_scb->peer_version < HFP_VERSION_1_7)
+ if ((p_scb->peer_version < HFP_VERSION_1_7) &&
+ (!(p_scb->peer_features & BTA_AG_PEER_FEAT_HFIND)))
{
/* For PTS keep flags as is. */
if (property_get("bt.pts.certification", value, "false") &&
#define BTA_AV_ACCEPT_SIGNALLING_TIMEOUT_MS (2 * 1000) /* 2 seconds */
#endif
+#ifndef AVRC_CONNECT_RETRY_DELAY_MS
+#define AVRC_CONNECT_RETRY_DELAY_MS 2000
+#endif
+
extern fixed_queue_t *btu_bta_alarm_queue;
static void bta_av_accept_signalling_timer_cback(void *data);
}
APPL_TRACE_DEBUG("%s rc_handle %d", __FUNCTION__, rc_handle);
+ if (rc_handle == BTA_AV_RC_HANDLE_NONE)
+ {
+ if (AVRC_CheckIncomingConn(p_scb->peer_addr) == TRUE)
+ {
+ bta_sys_start_timer(p_scb->avrc_ct_timer, AVRC_CONNECT_RETRY_DELAY_MS,
+ BTA_AV_SDP_AVRC_DISC_EVT,p_scb->hndl);
+ }
+ }
+
#if (BTA_AV_SINK_INCLUDED == TRUE)
if (p_cb->sdp_a2d_snk_handle)
{
continue;
}
}
+ } else if (codec_type == AAC) {
+ //Don't add AAC in Non split mode
+ index++;
+ continue;
}
if(AVDT_CreateStream(&p_scb->seps[index - startIndex].av_handle, &cs) ==
/* Disable SOC Logging */
if (soc_type == BT_SOC_SMD)
{
- UINT8 param[5] = {0x10,0x02,0x00,0x00,0x01};
- BTM_VendorSpecificCommand(HCI_VS_HOST_LOG_OPCODE,5,param,NULL);
+ UINT8 param[5] = {0x10, 0x02, 0x00, 0x00, 0x01};
+ BTM_VendorSpecificCommand(HCI_VS_HOST_LOG_OPCODE, 5, param, NULL);
+ }
+ else if (soc_type == BT_SOC_CHEROKEE)
+ {
+ UINT8 param_cherokee[2] = {0x14, 0x00};
+ BTM_VendorSpecificCommand(HCI_VS_HOST_LOG_OPCODE, 2, param_cherokee, NULL);
}
if(BTM_GetNumAclLinks()==0)
tBTA_DM_API_VENDOR_SPECIFIC_COMMAND vendor_command;
} tBTA_DM_MSG;
-
+#ifndef MAX_ACL_CONNECTIONS
#define BTA_DM_NUM_PEER_DEVICE 7
+#else
+#define BTA_DM_NUM_PEER_DEVICE MAX_ACL_CONNECTIONS
+#endif
+
#define BTA_DM_NOT_CONNECTED 0
#define BTA_DM_CONNECTED 1
/* max known devices GATTC can support */
#ifndef BTA_GATTC_KNOWN_SR_MAX
+#ifndef MAX_ACL_CONNECTIONS
#define BTA_GATTC_KNOWN_SR_MAX 10
+#else
+#define BTA_GATTC_KNOWN_SR_MAX MAX_ACL_CONNECTIONS
+#endif
#endif
#define BTA_GATTC_CONN_MAX GATT_MAX_PHY_CHANNEL
} tBTA_GATTC_SERV;
#ifndef BTA_GATTC_NOTIF_REG_MAX
+#ifndef MAX_ACL_CONNECTIONS
#define BTA_GATTC_NOTIF_REG_MAX 15
+#else
+#define BTA_GATTC_NOTIF_REG_MAX MAX_ACL_CONNECTIONS*3
+#endif
#endif
typedef struct
static BOOLEAN bta_av_co_audio_codec_build_config(const UINT8 *p_codec_caps, UINT8 *p_codec_cfg)
{
FUNC_TRACE();
+ tA2D_AAC_CIE peer_aac_cfg;
+ tA2D_AAC_CIE aac_cfg_selected;
memset(p_codec_cfg, 0, AVDT_CODEC_SIZE);
case BTIF_AV_CODEC_M24:
/* only copy the relevant portions for this codec to avoid issues when
comparing codec configs covering larger codec sets than SBC (7 bytes) */
+ A2D_ParsAacInfo (&peer_aac_cfg ,(UINT8*)p_codec_caps, FALSE);
+ A2D_ParsAacInfo (&aac_cfg_selected ,bta_av_co_cb.codec_cfg->info, FALSE);
+
+ aac_cfg_selected.bit_rate =
+ BTA_AV_CO_MIN(peer_aac_cfg.bit_rate,
+ aac_cfg_selected.bit_rate);
+ APPL_TRACE_EVENT("%s AAC bitrate selected %d", __func__,
+ aac_cfg_selected.bit_rate);
+ //update with new value
+ A2D_BldAacInfo (AVDT_MEDIA_AUDIO, &aac_cfg_selected, bta_av_co_cb.codec_cfg->info);
+
memcpy(p_codec_cfg, bta_av_co_cb.codec_cfg->info, A2D_AAC_INFO_LEN+1);
APPL_TRACE_DEBUG("%s AAC", __func__);
break;
** Constants & Macros
********************************************************************************/
+#ifndef MAX_ACL_CONNECTIONS
#define BTIF_HH_MAX_HID 8
+#else
+#define BTIF_HH_MAX_HID MAX_ACL_CONNECTIONS
+#endif
+
#define BTIF_HH_MAX_ADDED_DEV 32
#define BTIF_HH_MAX_KEYSTATES 3
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <cutils/properties.h>
#include <hardware/bluetooth.h>
#include <hardware/bt_av.h>
#include <hardware/bt_gatt.h>
#include <hardware/bt_sdp.h>
#include <hardware/bt_sock.h>
#include <hardware/vendor.h>
+#ifdef WIPOWER_SUPPORTED
+#include <hardware/wipower.h>
+#endif
#include "bt_utils.h"
#include "btif_api.h"
#include "btif/include/btif_media.h"
#include "l2cdefs.h"
#include "l2c_api.h"
+#include "stack_config.h"
#if TEST_APP_INTERFACE == TRUE
#include <bt_testapp.h>
/* avrc target */
extern btrc_interface_t *btif_rc_get_interface();
/* avrc controller */
+#ifdef WIPOWER_SUPPORTED
+extern wipower_interface_t *get_wipower_interface();
+#endif
extern btrc_interface_t *btif_rc_ctrl_get_interface();
/*SDP search client*/
extern btsdp_interface_t *btif_sdp_get_interface();
return strlen(p1) == strlen(p2) && strncmp(p1, p2, strlen(p2)) == 0;
}
+void get_logger_config_value()
+{
+ bool hci_ext_dump_enabled = false;
+ bool btsnoop_conf_from_file = false;
+ stack_config_get_interface()->get_btsnoop_ext_options(&hci_ext_dump_enabled, &btsnoop_conf_from_file);
+
+ /* ToDo: Chnage dependency to work on one config option*/
+ if(!btsnoop_conf_from_file)
+ hci_ext_dump_enabled = true;
+
+ if(hci_ext_dump_enabled)
+ bt_logger_enabled = true;
+}
+
/*****************************************************************************
**
** BLUETOOTH HAL INTERFACE FUNCTIONS
bt_hal_cbacks = callbacks;
stack_manager_get_interface()->init_stack();
+ get_logger_config_value();
+
+ if(bt_logger_enabled)
+ property_set("bluetooth.startbtlogger", "true");
btif_debug_init();
return BT_STATUS_SUCCESS;
}
static void cleanup(void) {
stack_manager_get_interface()->clean_up_stack();
+
+ if(bt_logger_enabled)
+ property_set("bluetooth.startbtlogger", "false");
}
bool is_restricted_mode() {
if (is_profile(profile_id, BT_PROFILE_AV_RC_ID))
return btif_rc_get_interface();
+#ifdef WIPOWER_SUPPORTED
+ if (is_profile(profile_id, BT_PROFILE_WIPOWER_VENDOR_ID))
+ return get_wipower_interface();
+#endif
+
if (is_profile(profile_id, BT_PROFILE_AV_RC_CTRL_ID))
return btif_rc_ctrl_get_interface();
if (enable_multicast == FALSE)
{
APPL_TRACE_WARNING("other Idx is connected, move to SUSPENDED");
- btif_rc_send_pause_command();
+ if (!bt_split_a2dp_enabled) {
+ btif_rc_send_pause_command();
+ }
btif_a2dp_on_stopped(&p_av->suspend);
}
}
if (p_av->suspend.status == BTA_AV_SUCCESS)
btif_sm_change_state(btif_av_cb[index].sm_handle, BTIF_AV_STATE_OPENED);
+ if (bt_split_a2dp_enabled &&
+ btif_av_is_connected_on_other_idx(index))
+ {
+ /*Fake handoff state to switch streaming to other coddeced
+ device */
+ btif_av_cb[index].dual_handoff = TRUE;
+ BTIF_TRACE_DEBUG("%s: Notify framework to reconfig",__func__);
+ int idx = btif_av_get_other_connected_idx(index);
+ /* Fix for below Klockwork Issue
+ * Array 'btif_av_cb' of size 2 may use index value(s) -1 */
+ if (idx != INVALID_INDEX)
+ {
+ HAL_CBACK(bt_av_src_callbacks, reconfig_a2dp_trigger_cb, 1,
+ &(btif_av_cb[idx].peer_bda));
+ }
+ }
+
break;
case BTA_AV_CLOSE_EVT:
BOOLEAN tx_started;
BOOLEAN tx_stop_initiated;
BOOLEAN tx_start_initiated;
+ BOOLEAN tx_enc_update_initiated;
//#endif
#endif
case A2DP_CTRL_GET_CODEC_CONFIG:
{
UINT16 min_mtu;
- uint8_t param[20],idx,bta_hdl,codec_id = 0;
+ uint8_t param[MAX_CODEC_CFG_SIZE],idx,bta_hdl,codec_id = 0;
uint32_t bitrate = 0;
uint8_t i = 0;
UIPC_Read(UIPC_CH_ID_AV_CTRL, NULL, &idx, 1);
- memset(param,0,20);
+ memset(param,0,MAX_CODEC_CFG_SIZE);
if (btif_av_stream_started_ready() == FALSE)
{
a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
BTIF_TRACE_DEBUG("codec_id = %x",codec_id);
- if (codec_id == BTIF_AV_CODEC_SBC)
+
+ if (get_soc_type() == BT_SOC_SMD)
+ {
+ //For Pronto PLs Audio pumps raw PCM data for others its encoded data to SOC
+ param[1] = 4; //RAW PCM
+ param[2] = AVDT_MEDIA_AUDIO;
+ param[3] = BTIF_AV_CODEC_PCM;
+ param[4] = btif_media_cb.media_feeding.cfg.pcm.sampling_freq;
+ param[5] = btif_media_cb.media_feeding.cfg.pcm.num_channel;
+ }
+ else if (codec_id == BTIF_AV_CODEC_SBC)
{
tA2D_SBC_CIE codec_cfg;
bta_av_co_audio_get_sbc_config(&codec_cfg, &min_mtu);
{
tA2D_APTX_CIE* codecInfo = 0;
codecInfo = (tA2D_APTX_CIE*) &ptr[BTA_AV_CFG_START_IDX];
- if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID
+ if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID
&& codecInfo->codecId == A2D_APTX_CODEC_ID_BLUETOOTH)
{
tA2D_APTX_CIE aptx_config;
BTIF_TRACE_DEBUG("sample rate = %x",aptx_config.sampleRate);
BTIF_TRACE_DEBUG("ch mode = %x",aptx_config.channelMode);
A2D_BldAptxInfo(AVDT_MEDIA_AUDIO,&aptx_config,¶m[1]);
- }
+
+ /* For aptxClassic BR = (Sampl_Rate * PCM_DEPTH * CHNL)/Compression_Ratio */
+ bitrate = ((btif_media_cb.media_feeding.cfg.pcm.sampling_freq * 16 * 2)/4);
+ } else {
+ tA2D_APTX_HD_CIE* cI = 0;
+ cI = (tA2D_APTX_HD_CIE*) &ptr[BTA_AV_CFG_START_IDX];
+ if (cI && cI->vendorId == A2D_APTX_HD_VENDOR_ID
+ && cI->codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH)
+ {
+ tA2D_APTX_HD_CIE aptxhd_config;
+ memset(&aptxhd_config,0,sizeof(tA2D_APTX_HD_CIE));
+ aptxhd_config.vendorId = codecInfo->vendorId;
+ aptxhd_config.codecId = codecInfo->codecId;
+ aptxhd_config.sampleRate = codecInfo->sampleRate;
+ aptxhd_config.channelMode = codecInfo->channelMode;
+ BTIF_TRACE_DEBUG("vendor id = %x",aptxhd_config.vendorId);
+ BTIF_TRACE_DEBUG("codec id = %x",aptxhd_config.codecId);
+ BTIF_TRACE_DEBUG("sample rate = %x",aptxhd_config.sampleRate);
+ BTIF_TRACE_DEBUG("ch mode = %x",aptxhd_config.channelMode);
+ A2D_BldAptx_hdInfo(AVDT_MEDIA_AUDIO,&aptxhd_config,¶m[1]);
+
+ /* For aptxHD BR = (Sampl_Rate * PCM_DEPTH * CHNL)/Compression_Ratio,
+ derived from classic */
+ bitrate = ((btif_media_cb.media_feeding.cfg.pcm.sampling_freq * 16 * 2)/4);
+ }
+ }
}
- /* For aptxClassic BR = (Sampl_Rate * PCM_DEPTH * CHNL)/Compression_Ratio */
- bitrate = ((btif_media_cb.media_feeding.cfg.pcm.sampling_freq * 16 * 2)/4);
}
param[0] = btif_get_latest_playing_device_idx();
i = param[1] + 2; //LOSC
tA2D_APTX_CIE* codecInfo = 0;
APPL_TRACE_DEBUG("btif_a2dp_encoder_update");
+ btif_media_cb.tx_enc_update_initiated = TRUE;
UINT8 codectype = 0;
codectype = bta_av_co_get_current_codec();
btif_media_cb.tx_stop_initiated = FALSE;
btif_media_cb.vs_configs_exchanged = FALSE;
btif_media_cb.tx_start_initiated = FALSE;
+ btif_media_cb.tx_enc_update_initiated = FALSE;
break;
case BTIF_MEDIA_START_VS_CMD:
- if (!btif_media_cb.tx_started && !btif_media_cb.tx_start_initiated)
+ if (!btif_media_cb.tx_started
+ && (!btif_media_cb.tx_start_initiated || btif_media_cb.tx_enc_update_initiated))
{
btif_a2dp_encoder_update();
btif_media_start_vendor_command();
case BTIF_MEDIA_STOP_VS_CMD:
if (btif_media_cb.tx_started && !btif_media_cb.tx_stop_initiated)
btif_media_send_vendor_stop();
- else if(btif_media_cb.tx_start_initiated && !btif_media_cb.tx_started)
+ else if((btif_media_cb.tx_start_initiated || btif_media_cb.tx_enc_update_initiated)
+ && !btif_media_cb.tx_started)
{
APPL_TRACE_IMP("Suspend Req when VSC exchange in progress,reset VSC");
btif_media_send_reset_vendor_state();
APPL_TRACE_IMP("btif_media_start_vendor_command_exchange:\
vs_configs_exchanged:%u", btif_media_cb.vs_configs_exchanged);
btif_media_cb.tx_start_initiated = TRUE;
+ btif_media_cb.tx_enc_update_initiated = FALSE;
if(btif_media_cb.vs_configs_exchanged)
{
btif_media_send_vendor_start();
}
else
{
-#if 0
- btif_media_send_vendor_write_sbc_cfg();
-#else
- btif_media_send_vendor_selected_codec();
-#endif
+ if (get_soc_type() == BT_SOC_SMD)
+ {
+ btif_media_send_vendor_write_sbc_cfg();
+ }
+ else
+ {
+ btif_media_send_vendor_selected_codec();
+ }
}
}
#define UUID_MAX_LENGTH 16
#define UUID_MATCHES(u1, u2) !memcmp(u1, u2, UUID_MAX_LENGTH)
+#define SPP_PROFILE_VERSION 0x0102
// Adds a protocol list and service name (if provided) to an SDP record given by
// |sdp_handle|, and marks it as browseable. This is a shortcut for defining a
if (!SDP_AddServiceClassIdList(handle, 1, &service))
goto error;
+ // Add the FTP profile descriptor.
+ stage = "profile_descriptor_list";
+ if (!SDP_AddProfileDescriptorList(handle, UUID_SERVCLASS_SERIAL_PORT,
+ SPP_PROFILE_VERSION))
+ goto error;
APPL_TRACE_DEBUG("add_spp_sdp: service registered successfully, "
"service_name: %s, handle 0x%08x)", name, handle);
ensure_stack_is_initialized();
+ init_vnd_Logger();
LOG_INFO(LOG_TAG, "%s is bringing up the stack", __func__);
future_t *local_hack_future = future_new();
hack_future = local_hack_future;
hack_future = future_new();
btif_thread_post(event_signal_stack_down, NULL);
future_await(hack_future);
+ clean_vnd_logger();
}
static void ensure_stack_is_not_running(void) {
ensure_stack_is_not_running();
LOG_INFO(LOG_TAG, "%s is cleaning up the stack", __func__);
- future_t *local_hack_future = future_new();
- hack_future = local_hack_future;
stack_is_initialized = false;
btif_cleanup_bluetooth();
// to preferred conn params immediately post connection. Disable automatic switching to
// preferred conn params for such devices and allow them to explicity ask for it.
INTEROP_DISABLE_LE_CONN_PREFERRED_PARAMS,
+
+ // Few remote devices do not understand AVRCP version greater than 1.3. For these
+ // devices, we would like to blacklist them and advertise AVRCP version as 1.3
+ INTEROP_ADV_AVRCP_VER_1_3,
} interop_feature_t;
// Check if a given |addr| matches a known interoperability workaround as identified
// Dialog Keyboard and mouse
{{{0x80, 0xea, 0xca, 0,0,0}}, 3, INTEROP_DISABLE_LE_SECURE_CONNECTIONS},
+ // Marvel CK used in Mercedes C300/BMW 640i
+ // For a more specific black listing(e.g. just for Mercedes), both BD addr
+ // and device name has to be added for AVRCP 1.3 blacklisting
+ {{{0xa0, 0x56, 0xb2, 0,0,0}}, 3, INTEROP_ADV_AVRCP_VER_1_3},
+
+ // Mazda Atenza
+ {{{0x04, 0xf8, 0xc2, 0,0,0}}, 3, INTEROP_DISABLE_ABSOLUTE_VOLUME},
};
typedef struct {
// HID Moto KZ500 Keyboard - Problematic SDP digitizer descriptor
{"Motorola Keyboard KZ500", 23, INTEROP_REMOVE_HID_DIG_DESCRIPTOR},
{"Motorola Keyboard KZ500 v122", 28, INTEROP_REMOVE_HID_DIG_DESCRIPTOR},
+ {"MB Bluetooth", 12, INTEROP_ADV_AVRCP_VER_1_3},
};
typedef struct {
void send_soc_log_command(bool value) {
int soc_type = get_soc_type();
- UINT8 param[5] = {0x10,0x03,0x00,0x00,0x01};
- if (!value)
+ UINT8 param[5] = {0x10, 0x03, 0x00, 0x00, 0x01};
+ UINT8 param_cherokee[2] = {0x14, 0x01};
+ if (!value) {
// Disable SoC logging
param[1] = 0x02;
+ param_cherokee[1] = 0x00;
+ }
if (soc_type == BT_SOC_SMD) {
LOG_INFO(LOG_TAG, "%s for BT_SOC_SMD.", __func__);
- BTM_VendorSpecificCommand(HCI_VS_HOST_LOG_OPCODE,5,param,NULL);
+ BTM_VendorSpecificCommand(HCI_VS_HOST_LOG_OPCODE, 5, param, NULL);
+ } else if (soc_type == BT_SOC_CHEROKEE) {
+ LOG_INFO(LOG_TAG, "%s for BT_SOC_CHEROKEE.", __func__);
+ BTM_VendorSpecificCommand(HCI_VS_HOST_LOG_OPCODE, 2, param_cherokee, NULL);
}
+
}
static future_t *start_up(void) {
CASE_RETURN_STR(INTEROP_DISABLE_SNIFF_DURING_SCO)
CASE_RETURN_STR(INTEROP_INCREASE_AG_CONN_TIMEOUT)
CASE_RETURN_STR(INTEROP_DISABLE_LE_CONN_PREFERRED_PARAMS)
+ CASE_RETURN_STR(INTEROP_ADV_AVRCP_VER_1_3)
}
return "UNKNOWN";
LOCAL_CFLAGS += -DBTSNOOP_DEFAULT=TRUE
endif
+ifneq (,$(filter userdebug eng,$(TARGET_BUILD_VARIANT)))
+LOCAL_CFLAGS += -DENABLE_DBG_FLAGS
+endif
+
LOCAL_CFLAGS += $(bluetooth_CFLAGS)
LOCAL_CONLYFLAGS += $(bluetooth_CONLYFLAGS)
LOCAL_CPPFLAGS += $(bluetooth_CPPFLAGS)
module_started = true;
stack_config->get_btsnoop_ext_options(&hci_ext_dump_enabled, &btsnoop_conf_from_file);
-#if (BTSNOOP_DEFAULT == TRUE)
if (btsnoop_conf_from_file == false) {
hci_ext_dump_enabled = true;
}
-#endif
update_logging();
return NULL;
static future_t *shut_down(void) {
module_started = false;
if (hci_ext_dump_enabled == true) {
- property_set("bluetooth.startbtsnoop", "false");
+ STOP_SNOOP_LOGGING();
}
update_logging();
btsnoop_net_open();
if (hci_ext_dump_enabled == true) {
- property_set("bluetooth.startbtsnoop", "true");
+ START_SNOOP_LOGGING();
}
const char *log_path = stack_config->get_btsnoop_log_path();
}
static void packet_finished(serial_data_type_t type) {
- if (!stream_has_interpretation)
+ if (!stream_has_interpretation) {
LOG_ERROR(LOG_TAG, "%s with no existing stream interpretation.", __func__);
- else if (current_data_type != type)
+ } else if (current_data_type != type) {
LOG_ERROR(LOG_TAG, "%s with different type than existing interpretation.", __func__);
+ }
#if (defined(REMOVE_EAGER_THREADS) && (REMOVE_EAGER_THREADS == TRUE))
if (uart_stream->rd_ptr == uart_stream->wr_ptr) {
static const uint32_t COMMAND_PENDING_TIMEOUT_MS = 8000;
extern int soc_type;
-static uint32_t HARDWARE_ERROR_TIMEOUT_MS = 2000;
// Our interface
static bool interface_created;
if (soc_type == BT_SOC_ROME || soc_type == BT_SOC_CHEROKEE) {
char value[PROPERTY_VALUE_MAX] = {0};
- if( property_get("wc_transport.force_special_byte", value, "false") && !strcmp(value,"true")) {
+ uint32_t hardware_error_timeout_ms = 2000;
+ bool enabled = false;
+#ifdef ENABLE_DBG_FLAGS
+ enabled = true;
+#endif
+ if (property_get("wc_transport.force_special_byte", value, NULL))
+ enabled = (strcmp(value, "false") == 0) ? false : true;
+ if (enabled) {
hardware_error_timer = alarm_new("hci.hardware_error_timer");
if (!hardware_error_timer) {
LOG_ERROR("%s unable to create hardware error timer.", __func__);
usleep(2000000);
kill(getpid(), SIGKILL);
}
- if(soc_type == BT_SOC_ROME)
- HARDWARE_ERROR_TIMEOUT_MS = 2000000;
- else if(soc_type == BT_SOC_CHEROKEE)
- HARDWARE_ERROR_TIMEOUT_MS = 5000000;
- alarm_set(hardware_error_timer, HARDWARE_ERROR_TIMEOUT_MS, hardware_error_timer_expired, NULL);
+ if(soc_type == BT_SOC_CHEROKEE)
+ hardware_error_timeout_ms = 5000;
+ alarm_set(hardware_error_timer, hardware_error_timeout_ms, hardware_error_timer_expired, NULL);
return;
}
}
// If a command generates a command status event, it won't be getting a command complete event
wait_entry = get_waiting_command(opcode);
- if (!wait_entry)
+ if (!wait_entry) {
LOG_WARN(LOG_TAG, "%s command status event with no matching command. opcode: 0x%x", __func__, opcode);
- else if (wait_entry->status_callback)
+ } else if (wait_entry->status_callback)
wait_entry->status_callback(status, wait_entry->command, wait_entry->context);
goto intercepted;
}
if (vendor != NULL) {
vendor->ssr_cleanup(reason);
- hal->close(); //clean up the UART stream
} else {
LOG_ERROR("%s: vendor is NULL", __func__);
}
static void enable(bool enable) {
if (state == LPM_DISABLING) {
- if (enable)
+ if (enable) {
LOG_ERROR(LOG_TAG, "%s still processing prior disable request, cannot enable.", __func__);
- else
+ } else {
LOG_WARN(LOG_TAG, "%s still processing prior disable request, ignoring new request to disable.", __func__);
+ }
} else if (state == LPM_ENABLING) {
- if (enable)
+ if (enable) {
LOG_ERROR(LOG_TAG, "%s still processing prior enable request, ignoring new request to enable.", __func__);
- else
+ } else {
LOG_WARN(LOG_TAG, "%s still processing prior enable request, cannot disable.", __func__);
+ }
} else if (state == LPM_ENABLED && enable) {
LOG_INFO(LOG_TAG, "%s already enabled.", __func__);
} else if (state == LPM_DISABLED && !enable) {
--- /dev/null
+/*********************************************************************
+*
+* Copyright (c) 2016, The Linux Foundation. All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+*
+* * Redistributions of source code must retain the above copyright
+* notice, this list of conditions and the following disclaimer.
+* * Redistributions in binary form must reproduce the above
+* copyright notice, this list of conditions and the following
+* disclaimer in the documentation and/or other materials provided
+* with the distribution.
+* * Neither the name of The Linux Foundation nor the names of its
+* contributors may be used to endorse or promote products derived
+* from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+************************************************************************/
+
+#include <stdio.h>
+#include <sys/types.h>
+
+/**
+ * Commands
+ */
+typedef enum {
+ VENDOR_LOGGER_LOGS = 201, // Signifies Packet containing Logger Log
+ GENERATE_VND_LOG_SIGNAL, // Signifies command to generate logs
+ START_SNOOP_SIGNAL,
+ STOP_SNOOP_SIGNAL,
+ STOP_LOGGING_SIGNAL,
+} CommandTypes;
+
+void init_vnd_Logger(void);
+void clean_vnd_logger(void);
+
+typedef struct {
+ /** Set to sizeof(bt_vndor_interface_t) */
+ size_t size;
+
+ /*
+ * Functions need to be implemented in Logger libray (libbt-logClient.so).
+ */
+
+ /*
+ * Initialize logging by conneting client socket
+ * to Logger process
+ */
+ int (*init)(void);
+
+ /** Sending Logs of Logger process */
+ void (*send_log_msg)(const char *tag, const char *fmt_str, va_list ap);
+ void (*send_log_data)(const char *tag, const char *fmt_str, ...);
+
+ /** Sending Logs of Logger process */
+ void (*send_event)(char evt);
+
+ /** Closes the socket connection to logger process */
+ int (*cleanup)(void);
+
+} bt_logger_interface_t;
+
+#define GENERATE_VND_LOGS() if(logger_interface)logger_interface->send_event(GENERATE_VND_LOG_SIGNAL)
+#define START_SNOOP_LOGGING() if(logger_interface)logger_interface->send_event(START_SNOOP_SIGNAL)
+#define STOP_SNOOP_LOGGING() if(logger_interface)logger_interface->send_event(STOP_SNOOP_SIGNAL)
**
******************************************************************************/
-/* The maximum number of simultaneous links that L2CAP can support. */
-#ifndef MAX_ACL_CONNECTIONS
-#define MAX_L2CAP_LINKS 7
-#else
-#define MAX_L2CAP_LINKS MAX_ACL_CONNECTIONS
-#endif
-
/* The maximum number of simultaneous channels that L2CAP can support. */
#ifndef MAX_L2CAP_CHANNELS
#define MAX_L2CAP_CHANNELS 16
#endif
+/* The maximum number of simultaneous links that L2CAP can support. */
+#ifndef MAX_L2CAP_CHANNELS
+#define MAX_L2CAP_LINKS 7
+#else
+#define MAX_L2CAP_LINKS MAX_L2CAP_CHANNELS
+#endif
+
/* The maximum number of simultaneous applications that can register with L2CAP. */
#ifndef MAX_L2CAP_CLIENTS
#define MAX_L2CAP_CLIENTS 15
#endif
#ifndef GATT_MAX_PHY_CHANNEL
+#ifndef MAX_L2CAP_CHANNELS
#define GATT_MAX_PHY_CHANNEL 7
+#else
+#define GATT_MAX_PHY_CHANNEL MAX_L2CAP_CHANNELS
+#endif
#endif
/* Used for conformance testing ONLY */
#endif
#ifndef HID_HOST_MAX_DEVICES
+#ifndef MAX_L2CAP_CHANNELS
#define HID_HOST_MAX_DEVICES 7
+#else
+#define HID_HOST_MAX_DEVICES MAX_L2CAP_CHANNELS
+#endif
#endif
#ifndef HID_HOST_MTU
#define BT_TRACE(l,t,...) LogMsg((TRACE_CTRL_GENERAL | (l) | TRACE_ORG_STACK | (t)), ##__VA_ARGS__)
#define BT_ERROR_TRACE(l,...) LogMsg(TRACE_CTRL_GENERAL | (l) | TRACE_ORG_STACK | TRACE_TYPE_ERROR, ##__VA_ARGS__)
+#define VND_TRACE(l,t,...) vnd_LogMsg((TRACE_CTRL_GENERAL | (l) | TRACE_ORG_STACK | (t)), ##__VA_ARGS__)
+
/* Define tracing for the HCI unit
*/
-#define HCI_TRACE_ERROR(...) {if (btu_trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define HCI_TRACE_WARNING(...) {if (btu_trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define HCI_TRACE_EVENT(...) {if (btu_trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define HCI_TRACE_DEBUG(...) {if (btu_trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define HCI_TRACE_ERROR(...) {if (btu_trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define HCI_TRACE_WARNING(...) {if (btu_trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define HCI_TRACE_EVENT(...) {if (btu_trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define HCI_TRACE_DEBUG(...) {if (btu_trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HCI, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* Define tracing for BTM
*/
-#define BTM_TRACE_ERROR(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define BTM_TRACE_WARNING(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define BTM_TRACE_API(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define BTM_TRACE_EVENT(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define BTM_TRACE_DEBUG(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define BTM_TRACE_ERROR(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define BTM_TRACE_WARNING(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define BTM_TRACE_API(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define BTM_TRACE_EVENT(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define BTM_TRACE_DEBUG(...) {if (btm_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BTM, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* Define tracing for the L2CAP unit
*/
-#define L2CAP_TRACE_ERROR(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define L2CAP_TRACE_WARNING(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define L2CAP_TRACE_API(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define L2CAP_TRACE_EVENT(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define L2CAP_TRACE_DEBUG(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define L2CAP_TRACE_ERROR(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define L2CAP_TRACE_WARNING(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define L2CAP_TRACE_API(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define L2CAP_TRACE_EVENT(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define L2CAP_TRACE_DEBUG(...) {if (l2cb.l2cap_trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_L2CAP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* Define tracing for the SDP unit
*/
-#define SDP_TRACE_ERROR(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define SDP_TRACE_WARNING(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define SDP_TRACE_API(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define SDP_TRACE_EVENT(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define SDP_TRACE_DEBUG(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define SDP_TRACE_ERROR(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define SDP_TRACE_WARNING(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define SDP_TRACE_API(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define SDP_TRACE_EVENT(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define SDP_TRACE_DEBUG(...) {if (sdp_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SDP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* Define tracing for the RFCOMM unit
*/
-#define RFCOMM_TRACE_ERROR(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define RFCOMM_TRACE_WARNING(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define RFCOMM_TRACE_API(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define RFCOMM_TRACE_EVENT(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define RFCOMM_TRACE_DEBUG(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define RFCOMM_TRACE_ERROR(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define RFCOMM_TRACE_WARNING(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define RFCOMM_TRACE_API(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define RFCOMM_TRACE_EVENT(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define RFCOMM_TRACE_DEBUG(...) {if (rfc_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_RFCOMM, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* Generic Access Profile traces */
-#define GAP_TRACE_ERROR(...) {if (gap_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define GAP_TRACE_EVENT(...) {if (gap_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define GAP_TRACE_API(...) {if (gap_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define GAP_TRACE_WARNING(...) {if (gap_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define GAP_TRACE_ERROR(...) {if (gap_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define GAP_TRACE_EVENT(...) {if (gap_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define GAP_TRACE_API(...) {if (gap_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define GAP_TRACE_WARNING(...) {if (gap_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_GAP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
/* define traces for HID Host */
-#define HIDH_TRACE_ERROR(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define HIDH_TRACE_WARNING(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define HIDH_TRACE_API(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define HIDH_TRACE_EVENT(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define HIDH_TRACE_DEBUG(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define HIDH_TRACE_ERROR(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HID, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define HIDH_TRACE_WARNING(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HID, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define HIDH_TRACE_API(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HID, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define HIDH_TRACE_EVENT(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HID, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define HIDH_TRACE_DEBUG(...) {if (hh_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_HID, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_HID, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* define traces for BNEP */
-#define BNEP_TRACE_ERROR(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define BNEP_TRACE_WARNING(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define BNEP_TRACE_API(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define BNEP_TRACE_EVENT(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define BNEP_TRACE_DEBUG(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define BNEP_TRACE_ERROR(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define BNEP_TRACE_WARNING(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define BNEP_TRACE_API(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define BNEP_TRACE_EVENT(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define BNEP_TRACE_DEBUG(...) {if (bnep_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_BNEP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* define traces for PAN */
-#define PAN_TRACE_ERROR(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define PAN_TRACE_WARNING(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define PAN_TRACE_API(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define PAN_TRACE_EVENT(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define PAN_TRACE_DEBUG(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define PAN_TRACE_ERROR(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define PAN_TRACE_WARNING(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define PAN_TRACE_API(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define PAN_TRACE_EVENT(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define PAN_TRACE_DEBUG(...) {if (pan_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_PAN, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* Define tracing for the A2DP profile
*/
-#define A2D_TRACE_ERROR(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_ERROR,##__VA_ARGS__);}
-#define A2D_TRACE_WARNING(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_WARNING,##__VA_ARGS__);}
-#define A2D_TRACE_EVENT(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_EVENT,##__VA_ARGS__);}
-#define A2D_TRACE_DEBUG(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_DEBUG,##__VA_ARGS__);}
-#define A2D_TRACE_API(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_API,##__VA_ARGS__);}
+#define A2D_TRACE_ERROR(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_ERROR,##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_ERROR,##__VA_ARGS__);}
+#define A2D_TRACE_WARNING(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_WARNING,##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_WARNING,##__VA_ARGS__);}
+#define A2D_TRACE_EVENT(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_EVENT,##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_EVENT,##__VA_ARGS__);}
+#define A2D_TRACE_DEBUG(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_DEBUG,##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_DEBUG,##__VA_ARGS__);}
+#define A2D_TRACE_API(...) {if (a2d_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_API,##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_A2D, TRACE_TYPE_API,##__VA_ARGS__);}
/* AVDTP
*/
-#define AVDT_TRACE_ERROR(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define AVDT_TRACE_WARNING(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define AVDT_TRACE_EVENT(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define AVDT_TRACE_DEBUG(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
-#define AVDT_TRACE_API(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define AVDT_TRACE_ERROR(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define AVDT_TRACE_WARNING(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define AVDT_TRACE_EVENT(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define AVDT_TRACE_DEBUG(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define AVDT_TRACE_API(...) {if (avdt_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__);}
/* Define tracing for the AVCTP protocol
*/
-#define AVCT_TRACE_ERROR(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define AVCT_TRACE_WARNING(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define AVCT_TRACE_EVENT(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define AVCT_TRACE_DEBUG(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
-#define AVCT_TRACE_API(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define AVCT_TRACE_ERROR(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define AVCT_TRACE_WARNING(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define AVCT_TRACE_EVENT(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define AVCT_TRACE_DEBUG(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define AVCT_TRACE_API(...) {if (avct_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__);}
/* Define tracing for the AVRCP profile
*/
-#define AVRC_TRACE_ERROR(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define AVRC_TRACE_WARNING(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define AVRC_TRACE_EVENT(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define AVRC_TRACE_DEBUG(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
-#define AVRC_TRACE_API(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define AVRC_TRACE_ERROR(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define AVRC_TRACE_WARNING(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define AVRC_TRACE_EVENT(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define AVRC_TRACE_DEBUG(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define AVRC_TRACE_API(...) {if (avrc_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_AVP, TRACE_TYPE_API, ##__VA_ARGS__);}
/* MCAP
*/
-#define MCA_TRACE_ERROR(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define MCA_TRACE_WARNING(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define MCA_TRACE_EVENT(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define MCA_TRACE_DEBUG(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
-#define MCA_TRACE_API(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define MCA_TRACE_ERROR(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define MCA_TRACE_WARNING(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define MCA_TRACE_EVENT(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define MCA_TRACE_DEBUG(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define MCA_TRACE_API(...) {if (mca_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_MCA, TRACE_TYPE_API, ##__VA_ARGS__);}
/* Define tracing for the ATT/GATT unit
*/
-#define GATT_TRACE_ERROR(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define GATT_TRACE_WARNING(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define GATT_TRACE_API(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define GATT_TRACE_EVENT(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define GATT_TRACE_DEBUG(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define GATT_TRACE_ERROR(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define GATT_TRACE_WARNING(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define GATT_TRACE_API(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define GATT_TRACE_EVENT(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define GATT_TRACE_DEBUG(...) {if (gatt_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_ATT, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* Define tracing for the SMP unit
*/
-#define SMP_TRACE_ERROR(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define SMP_TRACE_WARNING(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define SMP_TRACE_API(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_API, ##__VA_ARGS__);}
-#define SMP_TRACE_EVENT(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define SMP_TRACE_DEBUG(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define SMP_TRACE_ERROR(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_ERROR) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_ERROR, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define SMP_TRACE_WARNING(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_WARNING) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_WARNING, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define SMP_TRACE_API(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_API) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_API, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_API, ##__VA_ARGS__);}
+#define SMP_TRACE_EVENT(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_EVENT) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_EVENT, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define SMP_TRACE_DEBUG(...) {if (smp_cb.trace_level >= BT_TRACE_LEVEL_DEBUG) BT_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_DEBUG, ##__VA_ARGS__); else VND_TRACE(TRACE_LAYER_SMP, TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
extern UINT8 btif_trace_level;
extern UINT8 audio_latency_trace_level;
/* define traces for application */
#define BTIF_TRACE_IMP(...) {LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
-#define BTIF_TRACE_ERROR(...) {if (btif_trace_level >= BT_TRACE_LEVEL_ERROR) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define BTIF_TRACE_WARNING(...) {if (btif_trace_level >= BT_TRACE_LEVEL_WARNING) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define BTIF_TRACE_API(...) {if (btif_trace_level >= BT_TRACE_LEVEL_API) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_API, ##__VA_ARGS__);}
-#define BTIF_TRACE_EVENT(...) {if (btif_trace_level >= BT_TRACE_LEVEL_EVENT) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define BTIF_TRACE_DEBUG(...) {if (btif_trace_level >= BT_TRACE_LEVEL_DEBUG) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define BTIF_TRACE_ERROR(...) {if (btif_trace_level >= BT_TRACE_LEVEL_ERROR) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_ERROR, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define BTIF_TRACE_WARNING(...) {if (btif_trace_level >= BT_TRACE_LEVEL_WARNING) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_WARNING, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_WARNING, ##__VA_ARGS__);}
+#define BTIF_TRACE_API(...) {if (btif_trace_level >= BT_TRACE_LEVEL_API) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_API, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_API, ##__VA_ARGS__);}
+#define BTIF_TRACE_EVENT(...) {if (btif_trace_level >= BT_TRACE_LEVEL_EVENT) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_EVENT, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define BTIF_TRACE_DEBUG(...) {if (btif_trace_level >= BT_TRACE_LEVEL_DEBUG) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
#define BTIF_TRACE_VERBOSE(...) {if (btif_trace_level >= BT_TRACE_LEVEL_VERBOSE) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
/* define traces for application */
#define APPL_TRACE_IMP(...) {LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
-#define APPL_TRACE_ERROR(...) {if (appl_trace_level >= BT_TRACE_LEVEL_ERROR) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_ERROR, ##__VA_ARGS__);}
-#define APPL_TRACE_WARNING(...) {if (appl_trace_level >= BT_TRACE_LEVEL_WARNING) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_WARNING, ##__VA_ARGS__);}
-#define APPL_TRACE_API(...) {if (appl_trace_level >= BT_TRACE_LEVEL_API) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_API, ##__VA_ARGS__);}
-#define APPL_TRACE_EVENT(...) {if (appl_trace_level >= BT_TRACE_LEVEL_EVENT) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_EVENT, ##__VA_ARGS__);}
-#define APPL_TRACE_DEBUG(...) {if (appl_trace_level >= BT_TRACE_LEVEL_DEBUG) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
+#define APPL_TRACE_ERROR(...) {if (appl_trace_level >= BT_TRACE_LEVEL_ERROR) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_ERROR, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define APPL_TRACE_WARNING(...) {if (appl_trace_level >= BT_TRACE_LEVEL_WARNING) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_WARNING, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_ERROR, ##__VA_ARGS__);}
+#define APPL_TRACE_API(...) {if (appl_trace_level >= BT_TRACE_LEVEL_API) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_API, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_API, ##__VA_ARGS__);}
+#define APPL_TRACE_EVENT(...) {if (appl_trace_level >= BT_TRACE_LEVEL_EVENT) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_EVENT, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_EVENT, ##__VA_ARGS__);}
+#define APPL_TRACE_DEBUG(...) {if (appl_trace_level >= BT_TRACE_LEVEL_DEBUG) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__); else vnd_LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
#define APPL_TRACE_VERBOSE(...) {if (appl_trace_level >= BT_TRACE_LEVEL_VERBOSE) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
#define APPL_TRACE_LATENCY_AUDIO(...) {if (audio_latency_trace_level >= BT_TRACE_LEVEL_VERBOSE) LogMsg(TRACE_CTRL_GENERAL | TRACE_LAYER_NONE | TRACE_ORG_APPL | TRACE_TYPE_DEBUG, ##__VA_ARGS__);}
extern UINT8 appl_trace_level;
void LogMsg (UINT32 trace_set_mask, const char *fmt_str, ...);
+void vnd_LogMsg (UINT32 trace_set_mask, const char *fmt_str, ...);
LOCAL_SRC_FILES+= \
../udrv/ulinux/uipc.c
+ifeq ($(BOARD_USES_WIPOWER),true)
+LOCAL_SRC_FILES += \
+ ../../../vendor/qcom/opensource/bluetooth/wipower-host/core/src/wipower.c
+endif
+
LOCAL_C_INCLUDES+= . \
$(LOCAL_PATH)/../ \
$(LOCAL_PATH)/../bta/include \
external/zlib \
$(call include-path-for, audio-utils)
+ifeq ($(BOARD_USES_WIPOWER),true)
+LOCAL_C_INCLUDES+= \
+ vendor/qcom/opensource/bluetooth/hal/include \
+ vendor/qcom/opensource/bluetooth/wipower-host/core/include
+endif
+
LOCAL_SHARED_LIBRARIES := \
libcutils \
libdl \
#include <stdarg.h>
#include <sys/time.h>
#include <time.h>
+#include <dlfcn.h>
#include "avrc_api.h"
#include "bta_api.h"
#define BTE_LOG_BUF_SIZE 1024
#endif
+#define VND_PKT_SIZE_BLOCKS 4
+#define VND_PKT_HEADER_SIZE 5 //(VND_PKT_SIZE_BLOCKS + 1)
+#define VND_PKT_BODY_SIZE 1021
+
#define BTE_LOG_MAX_SIZE (BTE_LOG_BUF_SIZE - 12)
#define MSG_BUFFER_OFFSET 0
}
}
+void vnd_LogMsg(uint32_t trace_set_mask, const char *fmt_str, ...) {
+ int trace_layer = TRACE_GET_LAYER(trace_set_mask);
+ const char *tag;
+ if (trace_layer >= TRACE_LAYER_MAX_NUM)
+ trace_layer = 0;
+
+ tag = bt_layer_tags[trace_layer];
+
+ va_list ap;
+ va_start(ap, fmt_str);
+ if(logger_interface)
+ logger_interface->send_log_msg(tag, fmt_str, ap);
+ va_end(ap);
+}
+
/* this function should go into BTAPP_DM for example */
static uint8_t BTAPP_SetTraceLevel(uint8_t new_level) {
if (new_level != 0xFF)
./src/socket_utils/socket_local_server.c \
./src/thread.c \
./src/time.c \
- ./src/wakelock.c
+ ./src/wakelock.c \
+ ./src/vnd_log.c
btosiCommonTestSrc := \
./test/AlarmTestHarness.cpp \
******************************************************************************/
#pragma once
+#include <string.h>
+#include <stdbool.h>
+#include "include/bt_logger_lib.h"
+
+extern bt_logger_interface_t *logger_interface;
+extern bool bt_logger_enabled;
/*
* TODO(armansito): Work-around until we figure out a way to generate logs in a
#include <cutils/log.h>
+//#define VNDLOG(tag, fmt, ## args) if(logger_interface)logger_interface->send_log_data(tag, fmt, ## args)
+
#if LOG_NDEBUG
#define LOG_VERBOSE(...) ((void)0)
#else // LOG_NDEBUG
#define LOG_VERBOSE(tag, fmt, args...) ALOG(LOG_VERBOSE, tag, fmt, ## args)
#endif // !LOG_NDEBUG
-#define LOG_DEBUG(tag, fmt, args...) ALOG(LOG_DEBUG, tag, fmt, ## args )
-#define LOG_INFO(tag, fmt, args...) ALOG(LOG_INFO, tag, fmt, ## args)
-#define LOG_WARN(tag, fmt, args...) ALOG(LOG_WARN, tag, fmt, ## args)
-#define LOG_ERROR(tag, fmt, args...) ALOG(LOG_ERROR, tag, fmt, ## args)
+#define LOG_DEBUG(tag, fmt, args...) {if(logger_interface)logger_interface->send_log_data(tag, fmt, ## args);ALOG(LOG_DEBUG, tag, fmt, ## args);}
+#define LOG_INFO(tag, fmt, args...) {if(logger_interface)logger_interface->send_log_data(tag, fmt, ## args);ALOG(LOG_INFO, tag, fmt, ## args);}
+#define LOG_WARN(tag, fmt, args...) {if(logger_interface)logger_interface->send_log_data(tag, fmt, ## args);ALOG(LOG_WARN, tag, fmt, ## args);}
+#define LOG_ERROR(tag, fmt, args...) {if(logger_interface)logger_interface->send_log_data(tag, fmt, ## args);ALOG(LOG_ERROR, tag, fmt, ## args);}
#endif /* defined(OS_GENERIC) */
// the semaphore by the number of bytes we just read
eventfd_write(reader->bytes_available_fd, bytes_read);
} else {
- if (bytes_read == 0)
+ if (bytes_read == 0){
LOG_WARN(LOG_TAG, "%s fd said bytes existed, but none were found.", __func__);
- else
+ } else
LOG_WARN(LOG_TAG, "%s unable to read from file descriptor: %s", __func__, strerror(errno));
reader->allocator->free(buffer);
--- /dev/null
+/******************************************************************************
+Copyright (c) 2016, The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of The Linux Foundation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************/
+
+#define LOG_TAG "bt_vnd_log"
+
+#include <errno.h>
+#include <string.h>
+#include <dlfcn.h>
+#include "osi/include/log.h"
+#include "osi/include/osi.h"
+
+static const char *LOGGER_LIBRARY_NAME = "libbt-logClient.so";
+static const char *LOGGER_LIBRARY_SYMBOL_NAME = "BLUETOOTH_LOGGER_LIB_INTERFACE";
+
+static void *lib_handle;
+bt_logger_interface_t *logger_interface;
+bool bt_logger_enabled = false;
+
+void init_vnd_Logger(void)
+{
+ if(!bt_logger_enabled)
+ {
+ LOG_ERROR(LOG_TAG, "%s, Logger Not enabled from config file", __func__);
+ return;
+ }
+
+ lib_handle = dlopen(LOGGER_LIBRARY_NAME, RTLD_NOW);
+
+ if (!lib_handle) {
+ LOG_ERROR(LOG_TAG, "%s unable to open %s: %s", __func__, LOGGER_LIBRARY_NAME, dlerror());
+ return;
+ }
+
+ logger_interface = (bt_logger_interface_t *)dlsym(lib_handle, LOGGER_LIBRARY_SYMBOL_NAME);
+ if (!logger_interface) {
+ LOG_ERROR(LOG_TAG, "%s unable to find symbol %s in %s: %s", __func__, LOGGER_LIBRARY_SYMBOL_NAME, LOGGER_LIBRARY_NAME, dlerror());
+ return;
+ }
+
+ logger_interface->init();
+}
+
+void clean_vnd_logger()
+{
+ if(!bt_logger_enabled)
+ return;
+
+ if(logger_interface)
+ logger_interface->cleanup();
+
+ if(lib_handle)
+ dlclose(lib_handle);
+
+ logger_interface = NULL;
+ lib_handle = NULL;
+}
#include "osi/include/osi.h"
} // extern "C"
+bt_logger_interface_t *logger_interface = NULL;
+
namespace {
const size_t kMaxGattAttributeSize = 512;
return result;
}
+/*******************************************************************************
+**
+** Function AVCT_CheckIncomingConn
+**
+** Description Check for incoming connection in progress
+**
+** Return TRUE if incoming connection in progress, FALSE otherwise
+******************************************************************************/
+BOOLEAN AVCT_CheckIncomingConn(BD_ADDR peer_addr)
+{
+ tAVCT_LCB *p_lcb;
+
+ p_lcb = avct_lcb_by_bd(peer_addr);
+ if (p_lcb != NULL)
+ {
+ if (p_lcb->ch_state != AVCT_CH_IDLE)
+ {
+ AVCT_TRACE_ERROR("%s: Incoming AVCT connection in progress",__func__);
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
/******************************************************************************
**
** Function AVCT_SetTraceLevel
}
AVCT_TRACE_DEBUG("ch_state cfi: %d ", p_lcb->ch_state);
}
+ else
+ {
+ AVCT_TRACE_ERROR("%s: p_lcb is null",__func__);
+ L2CA_DisconnectReq(lcid);
+ }
}
#if (AVCT_BROWSE_INCLUDED == TRUE)
return AVRC_NO_RESOURCES;
}
+/******************************************************************************
+**
+** Function AVRC_CheckIncomfingConn
+**
+** Description Check for incoming connection in progress
+**
+** Returns TRUE if incoming ocnnection in progress, FALSE otherwise
+******************************************************************************/
+BOOLEAN AVRC_CheckIncomingConn(BD_ADDR peer_addr)
+{
+ return AVCT_CheckIncomingConn(peer_addr);
+}
,{0x00, 0x1b, 0xdc} /* BSHSBE20 */
,{0x00, 0x07, 0x04} /* Infiniti G37 2011 */
,{0xa4, 0x15, 0x66} /* Motorola Whisper */
+ ,{0x00, 0x54, 0xaf} /* Jeep Uconnect */
};
/* Black listed car kits/headsets for outgoing role switch */
static const UINT8 btm_role_switch_black_list_prefix2[][3] = {{0xfc, 0xc2, 0xde} /* Toyota Prius 2015 */
,{0x00, 0x23, 0x01} /* Roman R9020 */
,{0x00, 0x26, 0xb4} /* NAC FORD,2013 Lincoln */
,{0x1c, 0x48, 0xf9} /* Jabra Storm */
+ ,{0x00, 0x54, 0xaf} /* Jeep Uconnect */
};
/*******************************************************************************
#define BTM_BLE_MULTI_ADV_CB_EVT_MASK 0xF0
#define BTM_BLE_MULTI_ADV_SUBCODE_MASK 0x0F
+#ifdef WIPOWER_SUPPORTED
+#define WIPOWER_16_UUID_LSB 0xFE
+#define WIPOWER_16_UUID_MSB 0xFF
+static bool is_wipower_adv = false;
+#endif
+
/************************************************************************************
** Static variables
************************************************************************************/
tBTM_BLE_MULTI_ADV_INST_IDX_Q btm_multi_adv_idx_q;
pthread_mutex_t btm_multi_adv_lock = PTHREAD_MUTEX_INITIALIZER;
+#ifdef WIPOWER_SUPPORTED
+UINT8 wipower_inst_id = BTM_BLE_MULTI_ADV_DEFAULT_STD;
+#endif
+
/************************************************************************************
** Externs
************************************************************************************/
btm_ble_build_adv_data(&data_mask, &pp, p_data);
*p_len = (UINT8)(pp - param - 2);
UINT8_TO_STREAM(pp_temp, inst_id);
+#ifdef WIPOWER_SUPPORTED
+ if (param[7] == WIPOWER_16_UUID_LSB && param[8] == WIPOWER_16_UUID_MSB)
+ {
+ is_wipower_adv = true;
+ wipower_inst_id = inst_id;
+ }
+#endif
if ((rt = BTM_VendorSpecificCommand (HCI_BLE_MULTI_ADV_OCF,
(UINT8)BTM_BLE_MULTI_ADV_WRITE_DATA_LEN,
adv_inst != BTM_BLE_MULTI_ADV_DEFAULT_STD)
{
BTM_TRACE_EVENT("btm_ble_multi_adv_reenable called");
- btm_ble_multi_adv_reenable(adv_inst);
+#ifdef WIPOWER_SUPPORTED
+ if (!(is_wipower_adv && (adv_inst == wipower_inst_id))) {
+ btm_ble_multi_adv_reenable(adv_inst);
+ }
+#else
+ btm_ble_multi_adv_reenable(adv_inst);
+#endif
}
/* re-enable connectibility */
else if (adv_inst == BTM_BLE_MULTI_ADV_DEFAULT_STD)
*******************************************************************************/
void btm_ble_multi_adv_cleanup(void)
{
+#ifdef WIPOWER_SUPPORTED
+ is_wipower_adv = false;
+ wipower_inst_id = BTM_BLE_MULTI_ADV_DEFAULT_STD;
+#endif
+
pthread_mutex_lock(&btm_multi_adv_lock);
if (btm_multi_adv_cb.p_adv_inst) {
for (size_t i = 0; i < btm_cb.cmn_ble_vsc_cb.adv_inst_max; i++) {
tBTM_BD_NAME sec_bd_name; /* User friendly name of the device. (may be truncated to save space in dev_rec table) */
BD_FEATURES features[HCI_EXT_FEATURES_PAGE_MAX + 1]; /* Features supported by the device */
UINT8 num_read_pages;
+ UINT8 rnr_retry_cnt;
+ UINT8 cc_retry_cnt;
#define BTM_SEC_STATE_IDLE 0
#define BTM_SEC_STATE_AUTHENTICATING 1
tBTM_SEC_DEV_REC *p_collided_dev_rec;
alarm_t *sec_collision_timer;
+ tBTM_SEC_DEV_REC *p_cc_retry_dev_rec;
UINT32 collision_start_time;
UINT32 max_collision_delay;
UINT32 dev_rec_count; /* Counter used for device record timestamp */
BOOLEAN (APPL_AUTH_WRITE_EXCEPTION)(BD_ADDR bd_addr);
#endif
+#define RNR_MAX_RETRY_ATTEMPTS 1
+#define CC_MAX_RETRY_ATTEMPTS 1
+
/********************************************************************************
** L O C A L F U N C T I O N P R O T O T Y P E S *
*********************************************************************************/
return;
}
+ /* Handle RNR with retry mechanism */
+ if((status == HCI_ERR_PAGE_TIMEOUT) && (p_dev_rec->rnr_retry_cnt < RNR_MAX_RETRY_ATTEMPTS))
+ {
+ BTM_TRACE_WARNING ("btm_sec_rmt_name_request_complete() Retrying RNR due to page timeout");
+ if ((BTM_ReadRemoteDeviceName(p_bd_addr, NULL, BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED)
+ {
+ p_dev_rec->rnr_retry_cnt++;
+ return;
+ }
+ }
+ else
+ {
+ BTM_TRACE_EVENT ("btm_sec_rmt_name_request_complete() reset RNR retry count ");
+ p_dev_rec->rnr_retry_cnt = 0;
+ }
+
if (status != HCI_SUCCESS)
{
btm_sec_change_pairing_state (BTM_PAIR_STATE_IDLE);
/*******************************************************************************
**
+** Function btm_sec_connect_after_cc_page_tout
+**
+** Description This function is called to retry the connection if the
+** create connection fails as part of pairing procedure.
+**
+** Returns Pointer to the TLE struct
+**
+*******************************************************************************/
+static void btm_sec_connect_after_cc_page_tout (UNUSED_ATTR void *data)
+{
+ tBTM_SEC_DEV_REC *p_dev_rec = btm_cb.p_cc_retry_dev_rec;
+
+ BTM_TRACE_EVENT("%s", __func__);
+ btm_cb.p_cc_retry_dev_rec = 0;
+
+ if ((btm_cb.pairing_state != BTM_PAIR_STATE_IDLE) &&
+ (memcmp (btm_cb.pairing_bda, p_dev_rec->bd_addr, BD_ADDR_LEN) == 0) &&
+ (btm_sec_dd_create_conn(p_dev_rec) != BTM_CMD_STARTED))
+ {
+ BTM_TRACE_WARNING ("Security Manager: btm_sec_connect_after_cc_page_tout: failed to start connection");
+
+ btm_sec_change_pairing_state (BTM_PAIR_STATE_IDLE);
+
+ if (btm_cb.api.p_auth_complete_callback)
+ (*btm_cb.api.p_auth_complete_callback) (p_dev_rec->bd_addr, p_dev_rec->dev_class,
+ p_dev_rec->sec_bd_name, HCI_ERR_MEMORY_FULL);
+ btm_sec_dev_rec_cback_event (p_dev_rec, BTM_DEVICE_TIMEOUT, FALSE);
+ }
+}
+
+/*******************************************************************************
+**
** Function btm_sec_connected
**
** Description This function is when a connection to the peer device is
return;
}
+ /* retry again */
+ else if((status == HCI_ERR_PAGE_TIMEOUT) &&
+ (btm_cb.pairing_flags & BTM_PAIR_FLAGS_WE_STARTED_DD))
+ {
+ /* Handle CC with retry mechanism */
+ if(p_dev_rec->cc_retry_cnt < CC_MAX_RETRY_ATTEMPTS)
+ {
+ /* Start timer with 0 to initiate connection with new LCB */
+ btm_cb.p_cc_retry_dev_rec = p_dev_rec;
+
+ alarm_set_on_queue(btm_cb.sec_collision_timer, 0,
+ btm_sec_connect_after_cc_page_tout,
+ NULL, btu_general_alarm_queue);
+
+ p_dev_rec->cc_retry_cnt++;
+ return;
+ }
+ }
/* wait for incoming connection without resetting pairing state */
else if (status == HCI_ERR_CONNECTION_EXISTS)
{
BTM_TRACE_WARNING ("Security Manager: btm_sec_connected: Wait for incoming connection");
return;
}
+ p_dev_rec->cc_retry_cnt = 0;
is_pairing_device = TRUE;
}
*******************************************************************************/
extern BOOLEAN avct_get_peer_addr_by_ccb (UINT8 idx, BD_ADDR addr);
+/*******************************************************************************
+**
+** Function AVCT_CheckIncomingConn
+**
+**
+** Description Check if remote AVCTP incoming connection in progress
+**
+** Returns TRUE if icoming connection is in progress,
+**
+*******************************************************************************/
+extern BOOLEAN AVCT_CheckIncomingConn(BD_ADDR peer_addr);
+
#ifdef __cplusplus
}
#endif
*******************************************************************************/
extern BOOLEAN AVRC_IsValidPlayerAttr(UINT8 attr);
+/*******************************************************************************
+**
+** Function AVRC_CheckIncomingConn
+**
+** Description Check if AVRC incoming connection in progress
+**
+**
+** Returns returns TRUE if incoming connection in progress
+**
+*******************************************************************************/
+extern BOOLEAN AVRC_CheckIncomingConn(BD_ADDR peer_addr);
+
#ifdef __cplusplus
}
#endif
}
return;
- } else {
+ } else if (handle != 0xedc) { /* Handle 0xedc used for SOC Logging */
L2CAP_TRACE_ERROR ("L2CAP - rcvd ACL for unknown handle:%d ls:%d cid:%d"
" opcode:%d cur count:%d", handle, p_msg->layer_specific, rcv_cid,
cmd_code, list_length(l2cb.rcv_pending_q));
#include "sdp_api.h"
#include "sdpint.h"
+#include "device/include/interop.h"
+#include "btif/include/btif_storage.h"
#include <errno.h>
#include <cutils/properties.h>
+#include <hardware/bluetooth.h>
#if SDP_SERVER_ENABLED == TRUE
#define AVRCP_BROWSE_SUPPORT_BITMASK 0x40
#define AVRCP_CA_SUPPORT_BITMASK 0x01
-/* Few remote device does not understand AVRCP version greater
- * than 1.3 and falls back to 1.0, we would like to blacklist
- * and send AVRCP versio as 1.3.
- */
-static const UINT8 sdp_black_list_prefix[][3] = {};
-
/********************************************************************************/
/* L O C A L F U N C T I O N P R O T O T Y P E S */
/********************************************************************************/
*******************************************************************************/
BOOLEAN sdp_dev_blacklisted_for_avrcp15 (BD_ADDR addr)
{
- int blacklistsize = 0;
- int i =0;
+ bt_bdaddr_t remote_bdaddr;
+ bdcpy(remote_bdaddr.address, addr);
- if(sizeof(sdp_black_list_prefix) == 0)
- {
- SDP_TRACE_ERROR("No AVRCP Black Listed Device");
- return FALSE;
- }
+ if (interop_match_addr(INTEROP_ADV_AVRCP_VER_1_3, &remote_bdaddr)) {
+ bt_property_t prop_name;
+ bt_bdname_t bdname;
- blacklistsize = sizeof(sdp_black_list_prefix)/sizeof(sdp_black_list_prefix[0]);
- for (i=0; i < blacklistsize; i++)
- {
- if (0 == memcmp(sdp_black_list_prefix[i], addr, 3))
+ BTIF_STORAGE_FILL_PROPERTY(&prop_name, BT_PROPERTY_BDNAME,
+ sizeof(bt_bdname_t), &bdname);
+ if (btif_storage_get_remote_device_property(&remote_bdaddr,
+ &prop_name) != BT_STATUS_SUCCESS)
{
- SDP_TRACE_ERROR("SDP Avrcp Version Black List Device");
+ SDP_TRACE_ERROR("%s: BT_PROPERTY_BDNAME failed, returning false", __func__);
+ return FALSE;
+ }
+
+ if (strlen((const char *)bdname.name) != 0 &&
+ interop_match_name(INTEROP_ADV_AVRCP_VER_1_3, (const char *)bdname.name))
+ {
+ SDP_TRACE_DEBUG("%s: advertise AVRCP version 1.3 for device", __func__);
return TRUE;
}
}
+
return FALSE;
}
OSDN Git Service
