/******************************************************************************* ** ** 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); } }