/*******************************************************************************
**
** Function bta_av_co_peer_cp_supported
**
** Description Checks if the peer supports CP
**
** Returns TRUE if the peer supports CP
**
*******************************************************************************/
BOOLEAN bta_av_co_peer_cp_supported(tBTA_AV_HNDL hndl)
{
tBTA_AV_CO_PEER *p_peer;
tBTA_AV_CO_SINK *p_sink;
UINT8 index;
FUNC_TRACE();
/* Find the peer info */
p_peer = bta_av_co_get_peer(hndl);
if (p_peer == NULL)
{
APPL_TRACE_ERROR0("bta_av_co_peer_cp_supported could not find peer entry");
return FALSE;
}
for (index = 0; index < p_peer->num_sup_snks; index++)
{
p_sink = &p_peer->snks[index];
if (p_sink->codec_type == A2D_MEDIA_CT_SBC)
{
return bta_av_co_audio_sink_has_scmst(p_sink);
}
}
APPL_TRACE_ERROR0("bta_av_co_peer_cp_supported did not find SBC sink");
return FALSE;
}
/*******************************************************************************
**
** Function bta_av_co_audio_disc_res
**
** Description This callout function is executed by AV to report the
** number of stream end points (SEP) were found during the
** AVDT stream discovery process.
**
**
** Returns void.
**
*******************************************************************************/
BTA_API void bta_av_co_audio_disc_res(tBTA_AV_HNDL hndl, UINT8 num_seps, UINT8 num_snk,
BD_ADDR addr)
{
tBTA_AV_CO_PEER *p_peer;
FUNC_TRACE();
APPL_TRACE_DEBUG3("bta_av_co_audio_disc_res h:x%x num_seps:%d num_snk:%d",
hndl, num_seps, num_snk);
/* Find the peer info */
p_peer = bta_av_co_get_peer(hndl);
if (p_peer == NULL)
{
APPL_TRACE_ERROR0("bta_av_co_audio_disc_res could not find peer entry");
return;
}
/* Sanity check : this should never happen */
if (p_peer->opened)
{
APPL_TRACE_ERROR0("bta_av_co_audio_disc_res peer already opened");
}
/* Copy the discovery results */
bdcpy(p_peer->addr, addr);
p_peer->num_snks = num_snk;
p_peer->num_seps = num_seps;
p_peer->num_rx_snks = 0;
p_peer->num_sup_snks = 0;
}
/*******************************************************************************
**
** Function bta_av_alloc_scb
**
** Description allocate stream control block,
** register the service to stack
** create SDP record
**
** Returns void
**
*******************************************************************************/
static tBTA_AV_SCB * bta_av_alloc_scb(tBTA_AV_CHNL chnl)
{
tBTA_AV_SCB *p_ret = NULL;
int xx;
tBTA_AV_STATUS sts = BTA_AV_SUCCESS;
if(chnl == BTA_AV_CHNL_VIDEO)
{
if(p_bta_av_cfg->p_act_tbl == NULL || p_bta_av_cfg->p_reg == NULL)
{
APPL_TRACE_ERROR0("Video streaming not supported");
sts = BTA_AV_FAIL;
}
else
{
/* allow only one Video channel */
if(bta_av_cb.reg_video)
{
APPL_TRACE_ERROR0("Already registered");
sts = BTA_AV_FAIL;
}
}
}
else if(chnl != BTA_AV_CHNL_AUDIO)
{
APPL_TRACE_ERROR1("bad channel: %d", chnl);
sts = BTA_AV_FAIL;
}
if(sts == BTA_AV_SUCCESS)
{
for(xx=0; xx<BTA_AV_NUM_STRS; xx++)
{
if(bta_av_cb.p_scb[xx] == NULL)
{
/* found an empty spot */
p_ret = (tBTA_AV_SCB *)GKI_getbuf(sizeof(tBTA_AV_SCB));
if(p_ret)
{
memset(p_ret, 0, sizeof(tBTA_AV_SCB));
p_ret->rc_handle = BTA_AV_RC_HANDLE_NONE;
p_ret->chnl = chnl;
p_ret->hndl = (tBTA_AV_HNDL)((xx + 1) | chnl);
p_ret->hdi = xx;
bta_av_cb.p_scb[xx] = p_ret;
}
break;
}
}
}
return p_ret;
}
/*******************************************************************************
**
** Function BTA_HfClientEnable
**
** Description Enable the HF CLient service. When the enable
** operation is complete the callback function will be
** called with a BTA_HF_CLIENT_ENABLE_EVT. This function must
** be called before other function in the HF CLient API are
** called.
**
** Returns BTA_SUCCESS if OK, BTA_FAILURE otherwise.
**
*******************************************************************************/
BTA_API tBTA_STATUS BTA_HfClientEnable(tBTA_HF_CLIENT_CBACK *p_cback)
{
tBTA_HF_CLIENT_API_ENABLE *p_buf;
UINT8 idx;
if (bta_sys_is_register (BTA_ID_HS))
{
APPL_TRACE_ERROR0("BTA HF Client is already enabled, ignoring ...");
return BTA_FAILURE;
}
/* register with BTA system manager */
GKI_sched_lock();
bta_sys_register(BTA_ID_HS, &bta_hf_client_reg);
GKI_sched_unlock();
if ((p_buf = (tBTA_HF_CLIENT_API_ENABLE *) GKI_getbuf(sizeof(tBTA_HF_CLIENT_API_ENABLE))) != NULL)
{
p_buf->hdr.event = BTA_HF_CLIENT_API_ENABLE_EVT;
p_buf->p_cback = p_cback;
bta_sys_sendmsg(p_buf);
}
return BTA_SUCCESS;
}
/*******************************************************************************
**
** Function BTA_AgEnable
**
** Description Enable the audio gateway service. When the enable
** operation is complete the callback function will be
** called with a BTA_AG_ENABLE_EVT. This function must
** be called before other function in the AG API are
** called.
**
** Returns BTA_SUCCESS if OK, BTA_FAILURE otherwise.
**
*******************************************************************************/
tBTA_STATUS BTA_AgEnable(tBTA_AG_PARSE_MODE parse_mode, tBTA_AG_CBACK *p_cback)
{
tBTA_AG_API_ENABLE *p_buf;
UINT8 idx;
/* Error if AG is already enabled, or AG is in the middle of disabling. */
for (idx = 0; idx < BTA_AG_NUM_SCB; idx++)
{
if (bta_ag_cb.scb[idx].in_use)
{
APPL_TRACE_ERROR0 ("BTA_AgEnable: FAILED, AG already enabled.");
return BTA_FAILURE;
}
}
/* register with BTA system manager */
GKI_sched_lock();
bta_sys_register(BTA_ID_AG, &bta_ag_reg);
GKI_sched_unlock();
if ((p_buf = (tBTA_AG_API_ENABLE *) GKI_getbuf(sizeof(tBTA_AG_API_ENABLE))) != NULL)
{
p_buf->hdr.event = BTA_AG_API_ENABLE_EVT;
p_buf->parse_mode = parse_mode;
p_buf->p_cback = p_cback;
bta_sys_sendmsg(p_buf);
}
return BTA_SUCCESS;
}
void bta_hf_client_send_at_bia(void)
{
char buf[BTA_HF_CLIENT_AT_MAX_LEN];
int at_len;
int i;
APPL_TRACE_DEBUG1("%s", __FUNCTION__);
if (bta_hf_client_cb.scb.peer_version < HFP_VERSION_1_6)
{
APPL_TRACE_DEBUG0("Remote does not Support AT+BIA");
return;
}
at_len = snprintf(buf, sizeof(buf), "AT+BIA=");
for(i = 0; i < BTA_HF_CLIENT_AT_INDICATOR_COUNT; i++)
{
int sup = bta_hf_client_cb.scb.at_cb.indicator_lookup[i] == -1 ? 0 : 1;
at_len += snprintf(buf + at_len, sizeof(buf) - at_len, "%u,", sup);
}
buf[at_len - 1] = '\r';
if (at_len < 0)
{
APPL_TRACE_ERROR0("HFPClient: AT command Framing error");
return;
}
bta_hf_client_send_at(BTA_HF_CLIENT_AT_BIA, buf, at_len);
}
/*******************************************************************************
**
** Function preload_start_wait_timer
**
** Description Launch startup watchdog timer
**
** Returns None
**
*******************************************************************************/
static void preload_start_wait_timer(void)
{
int status;
struct itimerspec ts;
struct sigevent se;
UINT32 timeout_ms = PRELOAD_START_TIMEOUT_MS;
if (preload_retry_cb.timer_created == FALSE)
{
se.sigev_notify = SIGEV_THREAD;
se.sigev_value.sival_ptr = &preload_retry_cb.timer_id;
se.sigev_notify_function = preload_wait_timeout;
se.sigev_notify_attributes = NULL;
status = timer_create(CLOCK_MONOTONIC, &se, &preload_retry_cb.timer_id);
if (status == 0)
preload_retry_cb.timer_created = TRUE;
}
if (preload_retry_cb.timer_created == TRUE)
{
ts.it_value.tv_sec = timeout_ms/1000;
ts.it_value.tv_nsec = 1000000*(timeout_ms%1000);
ts.it_interval.tv_sec = 0;
ts.it_interval.tv_nsec = 0;
status = timer_settime(preload_retry_cb.timer_id, 0, &ts, 0);
if (status == -1)
APPL_TRACE_ERROR0("Failed to fire preload watchdog timer");
}
}
int btsock_thread_add_fd(int h, int fd, int type, int flags, uint32_t user_id)
{
if(h < 0 || h >= MAX_THREAD)
{
APPL_TRACE_ERROR1("invalid bt thread handle:%d", h);
return FALSE;
}
if(ts[h].cmd_fdw == -1)
{
APPL_TRACE_ERROR0("cmd socket is not created. socket thread may not initialized");
return FALSE;
}
if(flags & SOCK_THREAD_ADD_FD_SYNC)
{
//must executed in socket poll thread
if(ts[h].thread_id == pthread_self())
{
//cleanup one-time flags
flags &= ~SOCK_THREAD_ADD_FD_SYNC;
add_poll(h, fd, type, flags, user_id);
return TRUE;
}
APPL_TRACE_DEBUG0("THREAD_ADD_FD_SYNC is not called in poll thread, fallback to async");
}
sock_cmd_t cmd = {CMD_ADD_FD, fd, type, flags, user_id};
APPL_TRACE_DEBUG2("adding fd:%d, flags:0x%x", fd, flags);
return send(ts[h].cmd_fdw, &cmd, sizeof(cmd), 0) == sizeof(cmd);
}
int btsock_thread_post_cmd(int h, int type, const unsigned char* data, int size, uint32_t user_id)
{
if(h < 0 || h >= MAX_THREAD)
{
APPL_TRACE_ERROR1("invalid bt thread handle:%d", h);
return FALSE;
}
if(ts[h].cmd_fdw == -1)
{
APPL_TRACE_ERROR0("cmd socket is not created. socket thread may not initialized");
return FALSE;
}
sock_cmd_t cmd = {CMD_USER_PRIVATE, 0, type, size, user_id};
APPL_TRACE_DEBUG3("post cmd type:%d, size:%d, h:%d, ", type, size, h);
sock_cmd_t* cmd_send = &cmd;
int size_send = sizeof(cmd);
if(data && size)
{
size_send = sizeof(cmd) + size;
cmd_send = (sock_cmd_t*)alloca(size_send);
if(cmd_send)
{
*cmd_send = cmd;
memcpy(cmd_send + 1, data, size);
}
else
{
APPL_TRACE_ERROR3("alloca failed at h:%d, cmd type:%d, size:%d", h, type, size_send);
return FALSE;
}
}
return send(ts[h].cmd_fdw, cmd_send, size_send, 0) == size_send;
}
/*******************************************************************************
**
** Function bta_ag_api_disable
**
** Description Handle an API disable event.
**
**
** Returns void
**
*******************************************************************************/
static void bta_ag_api_disable(tBTA_AG_DATA *p_data)
{
/* deregister all scbs in use */
tBTA_AG_SCB *p_scb = &bta_ag_cb.scb[0];
BOOLEAN do_dereg = FALSE;
int i;
if (!bta_sys_is_register (BTA_ID_AG))
{
APPL_TRACE_ERROR0("BTA AG is already disabled, ignoring ...");
return;
}
/* De-register with BTA system manager */
GKI_sched_lock();
bta_sys_deregister(BTA_ID_AG);
GKI_sched_unlock();
for (i = 0; i < BTA_AG_NUM_SCB; i++, p_scb++)
{
if (p_scb->in_use)
{
bta_ag_sm_execute(p_scb, BTA_AG_API_DEREGISTER_EVT, p_data);
do_dereg = TRUE;
}
}
if (!do_dereg)
{
/* Done, send callback evt to app */
(*bta_ag_cb.p_cback)(BTA_AG_DISABLE_EVT, NULL);
}
bta_sys_collision_register (BTA_ID_AG, NULL);
}
static void bta_hf_client_at_parse_start(void)
{
char *buf = bta_hf_client_cb.scb.at_cb.buf;
APPL_TRACE_DEBUG1("%s", __FUNCTION__);
#ifdef BTA_HF_CLIENT_AT_DUMP
bta_hf_client_dump_at();
#endif
while(*buf != '\0')
{
int i;
char *tmp = NULL;
for(i = 0; i < bta_hf_client_psraser_cb_count; i++)
{
tmp = bta_hf_client_parser_cb[i](buf);
if (tmp == NULL)
{
APPL_TRACE_ERROR0("HFPCient: AT event/reply parsing failed, skipping");
tmp = bta_hf_client_skip_unknown(buf);
break;
}
/* matched or unknown skipped, if unknown failed tmp is NULL so
this is also handled */
if (tmp != buf)
{
buf = tmp;
break;
}
}
/* could not skip unknown (received garbage?)... disconnect */
if (tmp == NULL)
{
APPL_TRACE_ERROR0("HFPCient: could not skip unknown AT event, disconnecting");
bta_hf_client_at_reset();
bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL);
return;
}
buf = tmp;
}
}
/*******************************************************************************
**
** Function bta_ag_sm_execute
**
** Description State machine event handling function for AG
**
**
** Returns void
**
*******************************************************************************/
void bta_ag_sm_execute(tBTA_AG_SCB *p_scb, UINT16 event, tBTA_AG_DATA *p_data)
{
tBTA_AG_ST_TBL state_table;
UINT8 action;
int i;
#if BTA_AG_DEBUG == TRUE
UINT16 in_event = event;
UINT8 in_state = p_scb->state;
/* Ignore displaying of AT results when not connected (Ignored in state machine) */
if (in_event != BTA_AG_API_RESULT_EVT || p_scb->state == BTA_AG_OPEN_ST)
{
APPL_TRACE_EVENT5("AG evt (hdl 0x%04x): State %d (%s), Event 0x%04x (%s)",
bta_ag_scb_to_idx(p_scb),
p_scb->state, bta_ag_state_str(p_scb->state),
event, bta_ag_evt_str(event, p_data->api_result.result));
}
#else
APPL_TRACE_EVENT3("AG evt (hdl 0x%04x): State %d, Event 0x%04x",
bta_ag_scb_to_idx(p_scb), p_scb->state, event);
#endif
event &= 0x00FF;
if (event >= (BTA_AG_MAX_EVT & 0x00FF))
{
APPL_TRACE_ERROR0("AG evt out of range, ignoring...");
return;
}
/* look up the state table for the current state */
state_table = bta_ag_st_tbl[p_scb->state];
/* set next state */
p_scb->state = state_table[event][BTA_AG_NEXT_STATE];
/* execute action functions */
for (i = 0; i < BTA_AG_ACTIONS; i++)
{
if ((action = state_table[event][i]) != BTA_AG_IGNORE)
{
(*bta_ag_action[action])(p_scb, p_data);
}
else
{
break;
}
}
#if BTA_AG_DEBUG == TRUE
if (p_scb->state != in_state)
{
APPL_TRACE_EVENT3("BTA AG State Change: [%s] -> [%s] after Event [%s]",
bta_ag_state_str(in_state),
bta_ag_state_str(p_scb->state),
bta_ag_evt_str(in_event, p_data->api_result.result));
}
#endif
}
/******************************************************************************
**
** MAIN PARSING FUNCTION
**
**
*******************************************************************************/
void bta_hf_client_at_parse(char *buf, unsigned int len)
{
APPL_TRACE_DEBUG3("%s offset: %u len: %u", __FUNCTION__, bta_hf_client_cb.scb.at_cb.offset, len);
if (len + bta_hf_client_cb.scb.at_cb.offset > BTA_HF_CLIENT_AT_PARSER_MAX_LEN)
{
char tmp_buff[BTA_HF_CLIENT_AT_PARSER_MAX_LEN];
unsigned int tmp = bta_hf_client_cb.scb.at_cb.offset;
unsigned int space_left = BTA_HF_CLIENT_AT_PARSER_MAX_LEN - bta_hf_client_cb.scb.at_cb.offset;
APPL_TRACE_DEBUG1("%s overrun, trying to recover", __FUNCTION__);
/* fill up parser buffer */
memcpy(bta_hf_client_cb.scb.at_cb.buf + bta_hf_client_cb.scb.at_cb.offset, buf, space_left);
len -= space_left;
buf += space_left;
bta_hf_client_cb.scb.at_cb.offset += space_left;
/* find end of last complete command before proceeding */
while(bta_hf_client_check_at_complete() == FALSE)
{
if (bta_hf_client_cb.scb.at_cb.offset == 0) {
APPL_TRACE_ERROR0("HFPClient: AT parser buffer overrun, disconnecting");
bta_hf_client_at_reset();
bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL);
return;
}
bta_hf_client_cb.scb.at_cb.offset--;
}
/* cut buffer to complete AT event and keep cut data */
tmp += space_left - bta_hf_client_cb.scb.at_cb.offset;
memcpy(tmp_buff, bta_hf_client_cb.scb.at_cb.buf + bta_hf_client_cb.scb.at_cb.offset, tmp);
bta_hf_client_cb.scb.at_cb.buf[bta_hf_client_cb.scb.at_cb.offset] = '\0';
/* parse */
bta_hf_client_at_parse_start();
bta_hf_client_at_clear_buf();
/* recover cut data */
memcpy(bta_hf_client_cb.scb.at_cb.buf, tmp_buff, tmp);
bta_hf_client_cb.scb.at_cb.offset += tmp;
}
memcpy(bta_hf_client_cb.scb.at_cb.buf + bta_hf_client_cb.scb.at_cb.offset, buf, len);
bta_hf_client_cb.scb.at_cb.offset += len;
/* If last event is complete, parsing can be started */
if (bta_hf_client_check_at_complete() == TRUE)
{
bta_hf_client_at_parse_start();
bta_hf_client_at_clear_buf();
}
}
/******************************************************************************
**
** Function bte_main_in_hw_init
**
** Description Internal helper function for chip hardware init
**
** Returns None
**
******************************************************************************/
static void bte_main_in_hw_init(void)
{
if ( (bt_hc_if = (bt_hc_interface_t *) bt_hc_get_interface()) \
== NULL)
{
APPL_TRACE_ERROR0("!!! Failed to get BtHostControllerInterface !!!");
}
memset(&preload_retry_cb, 0, sizeof(bt_preload_retry_cb_t));
}
static void bta_hf_client_at_resp_timer_cback (TIMER_LIST_ENT *p_tle)
{
if (p_tle)
{
bta_hf_client_cb.scb.at_cb.resp_timer_on = FALSE;
APPL_TRACE_ERROR0("HFPClient: AT response timeout, disconnecting");
bta_hf_client_sm_execute(BTA_HF_CLIENT_API_CLOSE_EVT, NULL);
}
}
/*******************************************************************************
**
** Function bta_av_co_audio_codec_reset
**
** Description Reset the current codec configuration
**
** Returns void
**
*******************************************************************************/
void bta_av_co_audio_codec_reset(void)
{
GKI_disable();
FUNC_TRACE();
/* Reset the current configuration to SBC */
bta_av_co_cb.codec_cfg.id = BTIF_AV_CODEC_SBC;
if (A2D_BldSbcInfo(A2D_MEDIA_TYPE_AUDIO, (tA2D_SBC_CIE *)&btif_av_sbc_default_config, bta_av_co_cb.codec_cfg.info) != A2D_SUCCESS)
{
APPL_TRACE_ERROR0("bta_av_co_audio_codec_reset A2D_BldSbcInfo failed");
}
GKI_enable();
}
void bta_hf_client_send_at_brsf(void)
{
char buf[BTA_HF_CLIENT_AT_MAX_LEN];
int at_len;
APPL_TRACE_DEBUG1("%s", __FUNCTION__);
at_len = snprintf(buf, sizeof(buf), "AT+BRSF=%lu\r", bta_hf_client_cb.scb.features);
if (at_len < 0)
{
APPL_TRACE_ERROR0("HFPClient: AT command Framing error");
return;
}
bta_hf_client_send_at(BTA_HF_CLIENT_AT_BRSF , buf, at_len);
}
void bta_hf_client_send_at_vts(char code)
{
char buf[BTA_HF_CLIENT_AT_MAX_LEN];
int at_len;
APPL_TRACE_DEBUG1("%s", __FUNCTION__);
at_len = snprintf(buf, sizeof(buf), "AT+VTS=%c\r", code);
if (at_len < 0)
{
APPL_TRACE_ERROR0("HFPClient: AT command Framing error");
return;
}
bta_hf_client_send_at(BTA_HF_CLIENT_AT_VTS, buf, at_len);
}
void bta_hf_client_send_at_binp(UINT32 action)
{
char buf[BTA_HF_CLIENT_AT_MAX_LEN];
int at_len;
APPL_TRACE_DEBUG1("%s", __FUNCTION__);
at_len = snprintf(buf, sizeof(buf), "AT+BINP=%lu\r", action);
if (at_len < 0)
{
APPL_TRACE_ERROR0("HFPClient: AT command Framing error");
return;
}
bta_hf_client_send_at(BTA_HF_CLIENT_AT_BINP, buf, at_len);
}
static int alloc_thread_slot()
{
int i;
//revserd order to save guard uninitialized access to 0 index
for(i = MAX_THREAD - 1; i >=0; i--)
{
APPL_TRACE_DEBUG2("ts[%d].used:%d", i, ts[i].used);
if(!ts[i].used)
{
ts[i].used = 1;
return i;
}
}
APPL_TRACE_ERROR0("execeeded max thread count");
return -1;
}
/*******************************************************************************
**
** Function bta_av_co_audio_discard_config
**
** Description Discard the codec configuration of a connection
**
** Returns Nothing
**
*******************************************************************************/
void bta_av_co_audio_discard_config(tBTA_AV_HNDL hndl)
{
tBTA_AV_CO_PEER *p_peer;
FUNC_TRACE();
/* Find the peer info */
p_peer = bta_av_co_get_peer(hndl);
if (p_peer == NULL)
{
APPL_TRACE_ERROR0("bta_av_co_audio_discard_config could not find peer entry");
return;
}
/* Reset the peer codec configuration */
bta_av_co_audio_peer_reset_config(p_peer);
}
/*******************************************************************************
**
** Function bta_ag_resume_open
**
** Description Resume opening process.
**
**
** Returns void
**
*******************************************************************************/
void bta_ag_resume_open (tBTA_AG_SCB *p_scb)
{
if (p_scb)
{
APPL_TRACE_DEBUG1 ("bta_ag_resume_open, Handle(%d)", bta_ag_scb_to_idx(p_scb));
/* resume opening process. */
if (p_scb->state == BTA_AG_INIT_ST)
{
p_scb->state = BTA_AG_OPENING_ST;
bta_ag_start_open (p_scb, NULL);
}
}
else
{
APPL_TRACE_ERROR0 ("bta_ag_resume_open, Null p_scb");
}
}
void bta_hf_client_send_at_chld(char cmd, UINT32 idx)
{
char buf[BTA_HF_CLIENT_AT_MAX_LEN];
int at_len;
APPL_TRACE_DEBUG1("%s", __FUNCTION__);
if (idx > 0)
at_len = snprintf(buf, sizeof(buf), "AT+CHLD=%c%lu\r", cmd, idx);
else
at_len = snprintf(buf, sizeof(buf), "AT+CHLD=%c\r", cmd);
if (at_len < 0)
{
APPL_TRACE_ERROR0("HFPClient: AT command Framing error");
return;
}
bta_hf_client_send_at(BTA_HF_CLIENT_AT_CHLD, buf, at_len);
}
static inline rfc_slot_t* find_rfc_slot_by_fd(int fd)
{
int i;
if(fd >= 0)
{
for(i = 0; i < MAX_RFC_CHANNEL; i++)
{
if(rfc_slots[i].fd == fd)
{
if(rfc_slots[i].id)
return &rfc_slots[i];
else
{
APPL_TRACE_ERROR0("invalid rfc slot id, cannot be 0");
break;
}
}
}
}
return NULL;
}
/*******************************************************************************
**
** Function bta_av_co_audio_open
**
** Description This function is called by AV when the audio stream connection
** is opened.
**
**
** Returns void
**
*******************************************************************************/
BTA_API void bta_av_co_audio_open(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, UINT8 *p_codec_info,
UINT16 mtu)
{
tBTA_AV_CO_PEER *p_peer;
FUNC_TRACE();
APPL_TRACE_DEBUG2("bta_av_co_audio_open mtu:%d codec_type:%d", mtu, codec_type);
/* Retrieve the peer info */
p_peer = bta_av_co_get_peer(hndl);
if (p_peer == NULL)
{
APPL_TRACE_ERROR0("bta_av_co_audio_setconfig could not find peer entry");
}
else
{
p_peer->opened = TRUE;
p_peer->mtu = mtu;
}
}
static int create_server_sdp_record(rfc_slot_t* rs)
{
int scn = rs->scn;
if(rs->scn > 0)
{
if(BTM_TryAllocateSCN(rs->scn) == FALSE)
{
APPL_TRACE_ERROR1("rfc channel:%d already in use", scn);
return FALSE;
}
}
else if((rs->scn = BTM_AllocateSCN()) == 0)
{
APPL_TRACE_ERROR0("run out of rfc channels");
return FALSE;
}
if((rs->sdp_handle = add_rfc_sdp_rec(rs->service_name, rs->service_uuid, rs->scn)) <= 0)
{
return FALSE;
}
return TRUE;
}
/*******************************************************************************
**
** Function BTA_HhEnable
**
** Description Enable the HID host. This function must be called before
** any other functions in the HID host API are called. When the
** enable operation is complete the callback function will be
** called with BTA_HH_ENABLE_EVT.
**
**
** Returns void
**
*******************************************************************************/
void BTA_HhEnable(tBTA_SEC sec_mask, tBTA_HH_CBACK *p_cback)
{
tBTA_HH_API_ENABLE *p_buf;
/* register with BTA system manager */
GKI_sched_lock();
bta_sys_register(BTA_ID_HH, &bta_hh_reg);
GKI_sched_unlock();
APPL_TRACE_ERROR0("Calling BTA_HhEnable");
p_buf = (tBTA_HH_API_ENABLE *)GKI_getbuf((UINT16)sizeof(tBTA_HH_API_ENABLE));
if (p_buf != NULL)
{
memset(p_buf, 0, sizeof(tBTA_HH_API_ENABLE));
p_buf->hdr.event = BTA_HH_API_ENABLE_EVT;
p_buf->p_cback = p_cback;
p_buf->sec_mask = sec_mask;
bta_sys_sendmsg(p_buf);
}
}
/*******************************************************************************
**
** Function BTA_HhOpen
**
** Description Connect to a device of specified BD address in specified
** protocol mode and security level.
**
** Returns void
**
*******************************************************************************/
void BTA_HhOpen(BD_ADDR dev_bda, tBTA_HH_PROTO_MODE mode, tBTA_SEC sec_mask)
{
tBTA_HH_API_CONN *p_buf;
p_buf = (tBTA_HH_API_CONN *)GKI_getbuf((UINT16)sizeof(tBTA_HH_API_CONN));
if (p_buf!= NULL)
{
memset((void *)p_buf, 0, sizeof(tBTA_HH_API_CONN));
p_buf->hdr.event = BTA_HH_API_OPEN_EVT;
p_buf->hdr.layer_specific = BTA_HH_INVALID_HANDLE;
p_buf->sec_mask = sec_mask;
p_buf->mode = mode;
bdcpy(p_buf->bd_addr, dev_bda);
bta_sys_sendmsg((void *)p_buf);
}
else
{
APPL_TRACE_ERROR0("No resource to send HID host Connect request.");
}
}
int btsock_thread_exit(int h)
{
if(h < 0 || h >= MAX_THREAD)
{
APPL_TRACE_ERROR1("invalid bt thread handle:%d", h);
return FALSE;
}
if(ts[h].cmd_fdw == -1)
{
APPL_TRACE_ERROR0("cmd socket is not created");
return FALSE;
}
sock_cmd_t cmd = {CMD_EXIT, 0, 0, 0, 0};
if(send(ts[h].cmd_fdw, &cmd, sizeof(cmd), 0) == sizeof(cmd))
{
pthread_join(ts[h].thread_id, 0);
lock_slot(&thread_slot_lock);
free_thread_slot(h);
unlock_slot(&thread_slot_lock);
return TRUE;
}
return FALSE;
}
/******************************************************************************
**
** Function bte_main_hci_send
**
** Description BTE MAIN API - This function is called by the upper stack to
** send an HCI message. The function displays a protocol trace
** message (if enabled), and then calls the 'transmit' function
** associated with the currently selected HCI transport
**
** Returns None
**
******************************************************************************/
void bte_main_hci_send (BT_HDR *p_msg, UINT16 event)
{
UINT16 sub_event = event & BT_SUB_EVT_MASK; /* local controller ID */
p_msg->event = event;
if((sub_event == LOCAL_BR_EDR_CONTROLLER_ID) || \
(sub_event == LOCAL_BLE_CONTROLLER_ID))
{
if (bt_hc_if)
bt_hc_if->transmit_buf((TRANSAC)p_msg, \
(char *) (p_msg + 1), \
p_msg->len);
else
GKI_freebuf(p_msg);
}
else
{
APPL_TRACE_ERROR0("Invalid Controller ID. Discarding message.");
GKI_freebuf(p_msg);
}
}
