void bta_jv_enable(tBTA_JV_MSG* p_data) {
tBTA_JV_STATUS status = BTA_JV_SUCCESS;
bta_jv_cb.p_dm_cback = p_data->enable.p_cback;
- bta_jv_cb.p_dm_cback(BTA_JV_ENABLE_EVT, (tBTA_JV*)&status, 0);
+ tBTA_JV bta_jv;
+ bta_jv.status = status;
+ bta_jv_cb.p_dm_cback(BTA_JV_ENABLE_EVT, &bta_jv, 0);
memset(bta_jv_cb.free_psm_list, 0, sizeof(bta_jv_cb.free_psm_list));
}
bta_jv_cb.scn[channel - 1] = true;
scn = (uint8_t)channel;
}
- if (bta_jv_cb.p_dm_cback)
- bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, (tBTA_JV*)&scn,
+ if (bta_jv_cb.p_dm_cback) {
+ tBTA_JV bta_jv;
+ bta_jv.scn = scn;
+ bta_jv_cb.p_dm_cback(BTA_JV_GET_SCN_EVT, &bta_jv,
p_data->alloc_channel.rfcomm_slot_id);
+ }
return;
}
case BTA_JV_CONN_TYPE_L2CAP:
break;
}
- if (bta_jv_cb.p_dm_cback)
- bta_jv_cb.p_dm_cback(BTA_JV_GET_PSM_EVT, (tBTA_JV*)&psm,
+ if (bta_jv_cb.p_dm_cback) {
+ tBTA_JV bta_jv;
+ bta_jv.psm = psm;
+ bta_jv_cb.p_dm_cback(BTA_JV_GET_PSM_EVT, &bta_jv,
p_data->alloc_channel.l2cap_socket_id);
+ }
}
/*******************************************************************************
}
dcomp.status = status;
- bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV*)&dcomp,
- *p_rfcomm_slot_id);
+ tBTA_JV bta_jv;
+ bta_jv.disc_comp = dcomp;
+ bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv, *p_rfcomm_slot_id);
osi_free(p_rfcomm_slot_id);
}
}
if (bta_jv_cb.sdp_active != BTA_JV_SDP_ACT_NONE) {
/* SDP is still in progress */
status = BTA_JV_BUSY;
- if (bta_jv_cb.p_dm_cback)
- bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV*)&status,
+ if (bta_jv_cb.p_dm_cback) {
+ tBTA_JV bta_jv;
+ bta_jv.status = status;
+ bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv,
p_data->start_discovery.rfcomm_slot_id);
+ }
return;
}
bta_jv_start_discovery_cback, (void*)rfcomm_slot_id)) {
bta_jv_cb.sdp_active = BTA_JV_SDP_ACT_NONE;
/* failed to start SDP. report the failure right away */
- if (bta_jv_cb.p_dm_cback)
- bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, (tBTA_JV*)&status,
+ if (bta_jv_cb.p_dm_cback) {
+ tBTA_JV bta_jv;
+ bta_jv.status = status;
+ bta_jv_cb.p_dm_cback(BTA_JV_DISCOVERY_COMP_EVT, &bta_jv,
p_data->start_discovery.rfcomm_slot_id);
+ }
}
/*
else report the result when the cback is called
tBTA_JV_API_CREATE_RECORD* cr = &(p_data->create_record);
tBTA_JV_CREATE_RECORD evt_data;
evt_data.status = BTA_JV_SUCCESS;
- if (bta_jv_cb.p_dm_cback)
- // callback user immediately to create his own sdp record in stack thread
- // context
- bta_jv_cb.p_dm_cback(BTA_JV_CREATE_RECORD_EVT, (tBTA_JV*)&evt_data,
- cr->rfcomm_slot_id);
+ if (bta_jv_cb.p_dm_cback) {
+ // callback immediately to create the sdp record in stack thread context
+ tBTA_JV bta_jv;
+ bta_jv.create_rec = evt_data;
+ bta_jv_cb.p_dm_cback(BTA_JV_CREATE_RECORD_EVT, &bta_jv, cr->rfcomm_slot_id);
+ }
}
/*******************************************************************************
}
evt_data.handle = handle;
- if (cc->p_cback)
- cc->p_cback(BTA_JV_L2CAP_CL_INIT_EVT, (tBTA_JV*)&evt_data,
- cc->l2cap_socket_id);
+ if (cc->p_cback) {
+ tBTA_JV bta_jv;
+ bta_jv.l2c_cl_init = evt_data;
+ cc->p_cback(BTA_JV_L2CAP_CL_INIT_EVT, &bta_jv, cc->l2cap_socket_id);
+ }
}
/*******************************************************************************
evt_data.status = bta_jv_free_l2c_cb(cc->p_cb);
evt_data.async = false;
- if (p_cback)
- p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV*)&evt_data, l2cap_socket_id);
+ if (p_cback) {
+ tBTA_JV bta_jv;
+ bta_jv.l2c_close = evt_data;
+ p_cback(BTA_JV_L2CAP_CLOSE_EVT, &bta_jv, l2cap_socket_id);
+ }
}
/*******************************************************************************
p_cb->psm = ls->local_psm;
}
- if (ls->p_cback)
- ls->p_cback(BTA_JV_L2CAP_START_EVT, (tBTA_JV*)&evt_data,
- ls->l2cap_socket_id);
+ if (ls->p_cback) {
+ tBTA_JV bta_jv;
+ bta_jv.l2c_start = evt_data;
+ ls->p_cback(BTA_JV_L2CAP_START_EVT, &bta_jv, ls->l2cap_socket_id);
+ }
}
/*******************************************************************************
evt_data.handle = p_cb->handle;
evt_data.status = bta_jv_free_l2c_cb(p_cb);
evt_data.async = false;
- if (p_cback)
- p_cback(BTA_JV_L2CAP_CLOSE_EVT, (tBTA_JV*)&evt_data, l2cap_socket_id);
+ if (p_cback) {
+ tBTA_JV bta_jv;
+ bta_jv.l2c_close = evt_data;
+ p_cback(BTA_JV_L2CAP_CLOSE_EVT, &bta_jv, l2cap_socket_id);
+ }
break;
}
}
evt_data.status = BTA_JV_SUCCESS;
}
- rc->p_cback(BTA_JV_L2CAP_READ_EVT, (tBTA_JV*)&evt_data, rc->l2cap_socket_id);
+ tBTA_JV bta_jv;
+ bta_jv.l2c_read = evt_data;
+ rc->p_cback(BTA_JV_L2CAP_READ_EVT, &bta_jv, rc->l2cap_socket_id);
}
/*******************************************************************************
GAP_ConnWriteData(ls->handle, ls->p_data, ls->len, &evt_data.len)) {
evt_data.status = BTA_JV_SUCCESS;
}
- ls->p_cb->p_cback(BTA_JV_L2CAP_WRITE_EVT, (tBTA_JV*)&evt_data, ls->user_id);
+ tBTA_JV bta_jv;
+ bta_jv.l2c_write = evt_data;
+ ls->p_cb->p_cback(BTA_JV_L2CAP_WRITE_EVT, &bta_jv, ls->user_id);
} else {
/* As this pointer is checked in the API function, this occurs only when the
* channel is
L2CA_SendFixedChnlData(ls->channel, ls->addr, msg);
- ls->p_cback(BTA_JV_L2CAP_WRITE_FIXED_EVT, (tBTA_JV*)&evt_data, ls->user_id);
+ tBTA_JV bta_jv;
+ bta_jv.l2c_write_fixed = evt_data;
+ ls->p_cback(BTA_JV_L2CAP_WRITE_FIXED_EVT, &bta_jv, ls->user_id);
}
/*******************************************************************************
APPL_TRACE_ERROR("run out of rfc control block");
}
}
- cc->p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, (tBTA_JV*)&evt_data,
- cc->rfcomm_slot_id);
- if (evt_data.status == BTA_JV_FAILURE) {
+ tBTA_JV bta_jv;
+ bta_jv.rfc_cl_init = evt_data;
+ cc->p_cback(BTA_JV_RFCOMM_CL_INIT_EVT, &bta_jv, cc->rfcomm_slot_id);
+ if (bta_jv.rfc_cl_init.status == BTA_JV_FAILURE) {
if (sec_id) bta_jv_free_sec_id(&sec_id);
if (handle) RFCOMM_RemoveConnection(handle);
}
PORT_SetState(handle, &port_state);
} while (0);
- rs->p_cback(BTA_JV_RFCOMM_START_EVT, (tBTA_JV*)&evt_data, rs->rfcomm_slot_id);
- if (evt_data.status == BTA_JV_SUCCESS) {
+ tBTA_JV bta_jv;
+ bta_jv.rfc_start = evt_data;
+ rs->p_cback(BTA_JV_RFCOMM_START_EVT, &bta_jv, rs->rfcomm_slot_id);
+ if (bta_jv.rfc_start.status == BTA_JV_SUCCESS) {
PORT_SetDataCOCallback(handle, bta_jv_port_data_co_cback);
} else {
if (sec_id) bta_jv_free_sec_id(&sec_id);
evt_data.cong = p_pcb->cong;
if (p_cb->p_cback) {
- p_cb->p_cback(BTA_JV_RFCOMM_WRITE_EVT, (tBTA_JV*)&evt_data,
- p_pcb->rfcomm_slot_id);
+ tBTA_JV bta_jv;
+ bta_jv.rfc_write = evt_data;
+ p_cb->p_cback(BTA_JV_RFCOMM_WRITE_EVT, &bta_jv, p_pcb->rfcomm_slot_id);
} else {
APPL_TRACE_ERROR("%s No JV callback set", __func__);
}
evt_data.sec_id = t->sec_id;
out:
- ss->p_cback(BTA_JV_L2CAP_START_EVT, (tBTA_JV*)&evt_data, ss->l2cap_socket_id);
+ tBTA_JV bta_jv;
+ bta_jv.l2c_start = evt_data;
+ ss->p_cback(BTA_JV_L2CAP_START_EVT, &bta_jv, ss->l2cap_socket_id);
}
/*******************************************************************************
evt_data.status = BTA_MCE_SUCCESS;
}
- bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, (tBTA_MCE*)&evt_data,
- user_data);
+ tBTA_MCE bta_mce;
+ bta_mce.mas_disc_comp = evt_data;
+ bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, &bta_mce, user_data);
}
/*******************************************************************************
void bta_mce_enable(tBTA_MCE_MSG* p_data) {
tBTA_MCE_STATUS status = BTA_MCE_SUCCESS;
bta_mce_cb.p_dm_cback = p_data->enable.p_cback;
- bta_mce_cb.p_dm_cback(BTA_MCE_ENABLE_EVT, (tBTA_MCE*)&status, NULL);
+ tBTA_MCE bta_mce;
+ bta_mce.status = status;
+ bta_mce_cb.p_dm_cback(BTA_MCE_ENABLE_EVT, &bta_mce, NULL);
}
/*******************************************************************************
if (bta_mce_cb.sdp_active != BTA_MCE_SDP_ACT_NONE) {
/* SDP is still in progress */
status = BTA_MCE_BUSY;
- if (bta_mce_cb.p_dm_cback)
- bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, (tBTA_MCE*)&status,
- NULL);
+ if (bta_mce_cb.p_dm_cback) {
+ tBTA_MCE bta_mce;
+ bta_mce.status = status;
+ bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, &bta_mce, NULL);
+ }
return;
}
bta_mce_cb.sdp_active = BTA_MCE_SDP_ACT_NONE;
/* failed to start SDP. report the failure right away */
- if (bta_mce_cb.p_dm_cback)
- bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, (tBTA_MCE*)&status,
- NULL);
+ if (bta_mce_cb.p_dm_cback) {
+ tBTA_MCE bta_mce;
+ bta_mce.status = status;
+ bta_mce_cb.p_dm_cback(BTA_MCE_MAS_DISCOVERY_COMP_EVT, &bta_mce, NULL);
+ }
}
/*
else report the result when the cback is called
}
evt_data.status = status;
- bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, (tBTA_SDP*)&evt_data,
+ tBTA_SDP bta_sdp;
+ bta_sdp.sdp_search_comp = evt_data;
+ bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp,
(void*)&uuid->uu.uuid128);
osi_free(user_data); // We no longer need the user data to track the search
}
APPL_TRACE_DEBUG("%s in, sdp_active:%d", __func__, bta_sdp_cb.sdp_active);
tBTA_SDP_STATUS status = BTA_SDP_SUCCESS;
bta_sdp_cb.p_dm_cback = p_data->enable.p_cback;
- bta_sdp_cb.p_dm_cback(BTA_SDP_ENABLE_EVT, (tBTA_SDP*)&status, NULL);
+ tBTA_SDP bta_sdp;
+ bta_sdp.status = status;
+ bta_sdp_cb.p_dm_cback(BTA_SDP_ENABLE_EVT, &bta_sdp, NULL);
}
/*******************************************************************************
result.uuid = p_data->get_search.uuid;
result.remote_addr = p_data->get_search.bd_addr;
result.status = status;
- bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, (tBTA_SDP*)&result, NULL);
+ tBTA_SDP bta_sdp;
+ bta_sdp.sdp_search_comp = result;
+ bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp, NULL);
}
return;
}
result.uuid = p_data->get_search.uuid;
result.remote_addr = p_data->get_search.bd_addr;
result.status = status;
- bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, (tBTA_SDP*)&result, NULL);
+ tBTA_SDP bta_sdp;
+ bta_sdp.sdp_search_comp = result;
+ bta_sdp_cb.p_dm_cback(BTA_SDP_SEARCH_COMP_EVT, &bta_sdp, NULL);
}
}
/*
/* bind lcb to ccb */
p_ccb->p_lcb = p_lcb;
AVCT_TRACE_DEBUG("ch_state: %d", p_lcb->ch_state);
- avct_lcb_event(p_lcb, AVCT_LCB_UL_BIND_EVT, (tAVCT_LCB_EVT*)&p_ccb);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.p_ccb = p_ccb;
+ avct_lcb_event(p_lcb, AVCT_LCB_UL_BIND_EVT, &avct_lcb_evt);
}
}
}
}
/* send unbind event to lcb */
else {
- avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_UNBIND_EVT,
- (tAVCT_LCB_EVT*)&p_ccb);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.p_ccb = p_ccb;
+ avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_UNBIND_EVT, &avct_lcb_evt);
}
return result;
}
p_ccb->p_bcb = p_bcb;
p_bcb->peer_addr = p_ccb->p_lcb->peer_addr;
AVCT_TRACE_DEBUG("ch_state: %d", p_bcb->ch_state);
- avct_bcb_event(p_bcb, AVCT_LCB_UL_BIND_EVT, (tAVCT_LCB_EVT*)&p_ccb);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.p_ccb = p_ccb;
+ avct_bcb_event(p_bcb, AVCT_LCB_UL_BIND_EVT, &avct_lcb_evt);
}
}
} else if (p_ccb->p_bcb != NULL)
/* send unbind event to bcb */
{
- avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_UNBIND_EVT,
- (tAVCT_LCB_EVT*)&p_ccb);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.p_ccb = p_ccb;
+ avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_UNBIND_EVT, &avct_lcb_evt);
}
return result;
osi_free(p_msg);
} else {
p_ccb->p_bcb = avct_bcb_by_lcb(p_ccb->p_lcb);
- avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_MSG_EVT,
- (tAVCT_LCB_EVT*)&ul_msg);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.ul_msg = ul_msg;
+ avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_MSG_EVT, &avct_lcb_evt);
}
}
/* send msg event to lcb */
else {
- avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_MSG_EVT,
- (tAVCT_LCB_EVT*)&ul_msg);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.ul_msg = ul_msg;
+ avct_lcb_event(p_ccb->p_lcb, AVCT_LCB_UL_MSG_EVT, &avct_lcb_evt);
}
}
return result;
L2CA_ErtmConnectReq(AVCT_BR_PSM, p_lcb->peer_addr, &ertm_info);
if (p_bcb->ch_lcid == 0) {
/* if connect req failed, send ourselves close event */
- avct_bcb_event(p_bcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.result = result;
+ avct_bcb_event(p_bcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
}
}
p_bcb->p_tx_msg = NULL;
/* send msg event to bcb */
- avct_bcb_event(p_bcb, AVCT_LCB_UL_MSG_EVT, (tAVCT_LCB_EVT*)&ul_msg);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.ul_msg = ul_msg;
+ avct_bcb_event(p_bcb, AVCT_LCB_UL_MSG_EVT, &avct_lcb_evt);
}
/*******************************************************************************
else {
AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback conflict_lcid:0x%x",
p_lcb->conflict_lcid);
- if (p_lcb->conflict_lcid == lcid)
+ if (p_lcb->conflict_lcid == lcid) {
p_lcb->conflict_lcid = 0;
- else
- avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+ } else {
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.result = result;
+ avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
+ }
}
} else if (p_lcb->conflict_lcid == lcid) {
/* we must be in AVCT_CH_CFG state for the ch_lcid channel */
L2CA_DisconnectRsp(lcid);
}
- avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.result = result;
+ avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
AVCT_TRACE_DEBUG("ch_state di: %d ", p_lcb->ch_state);
}
}
res = (p_lcb->ch_result != 0) ? p_lcb->ch_result : result;
p_lcb->ch_result = 0;
- avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&res);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.result = res;
+ avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
AVCT_TRACE_DEBUG("ch_state dc: %d ", p_lcb->ch_state);
}
}
/* look up lcb for this channel */
p_lcb = avct_lcb_by_lcid(lcid);
if (p_lcb != NULL) {
- avct_lcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, (tAVCT_LCB_EVT*)&is_congested);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.cong = is_congested;
+ avct_lcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, &avct_lcb_evt);
}
}
if (result != L2CAP_CONN_OK) {
/* failure */
- avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.result = result;
+ avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
return;
}
L2CA_DisconnectRsp(lcid);
}
- avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.result = result;
+ avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
}
/*******************************************************************************
res = (p_lcb->ch_result != 0) ? p_lcb->ch_result : result;
p_lcb->ch_result = 0;
- avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&res);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.result = res;
+ avct_bcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
}
/*******************************************************************************
p_lcb = avct_bcb_by_lcid(lcid);
if (p_lcb == NULL) return;
- avct_bcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, (tAVCT_LCB_EVT*)&is_congested);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.cong = is_congested;
+ avct_bcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, &avct_lcb_evt);
}
/*******************************************************************************
p_lcb->ch_lcid = L2CA_ConnectReq(AVCT_PSM, p_lcb->peer_addr);
if (p_lcb->ch_lcid == 0) {
/* if connect req failed, send ourselves close event */
- avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT*)&result);
+ tAVCT_LCB_EVT avct_lcb_evt;
+ avct_lcb_evt.result = result;
+ avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, &avct_lcb_evt);
}
}
if (p_scb != NULL) {
close.tcid = p_tbl->tcid;
close.type = avdt_ad_tcid_to_type(p_tbl->tcid);
- avdt_scb_event(p_scb, AVDT_SCB_TC_CLOSE_EVT, (tAVDT_SCB_EVT*)&close);
+ tAVDT_SCB_EVT avdt_scb_evt;
+ avdt_scb_evt.close = close;
+ avdt_scb_event(p_scb, AVDT_SCB_TC_CLOSE_EVT, &avdt_scb_evt);
}
}
}
if (p_tbl->cfg_flags & AVDT_L2C_CFG_CONN_ACP) {
evt.err_param = AVDT_ACP;
}
- avdt_ccb_event(p_ccb, AVDT_CCB_LL_OPEN_EVT, (tAVDT_CCB_EVT*)&evt);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.msg.hdr = evt;
+ avdt_ccb_event(p_ccb, AVDT_CCB_LL_OPEN_EVT, &avdt_ccb_evt);
}
/* if media or other channel, notify scb that channel open */
else {
open.peer_mtu = p_tbl->peer_mtu;
open.lcid = avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].lcid;
open.hdr.err_code = avdt_ad_tcid_to_type(p_tbl->tcid);
- avdt_scb_event(p_scb, AVDT_SCB_TC_OPEN_EVT, (tAVDT_SCB_EVT*)&open);
+ tAVDT_SCB_EVT avdt_scb_evt;
+ avdt_scb_evt.open = open;
+ avdt_scb_event(p_scb, AVDT_SCB_TC_OPEN_EVT, &avdt_scb_evt);
}
}
}
/* if signaling channel, notify ccb of congestion */
if (p_tbl->tcid == 0) {
p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
- avdt_ccb_event(p_ccb, AVDT_CCB_LL_CONG_EVT, (tAVDT_CCB_EVT*)&is_congested);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.llcong = is_congested;
+ avdt_ccb_event(p_ccb, AVDT_CCB_LL_CONG_EVT, &avdt_ccb_evt);
}
/* if media or other channel, notify scb that channel open */
else {
p_scb =
avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
if (p_scb != NULL) {
- avdt_scb_event(p_scb, AVDT_SCB_TC_CONG_EVT,
- (tAVDT_SCB_EVT*)&is_congested);
+ tAVDT_SCB_EVT avdt_scb_evt;
+ avdt_scb_evt.llcong = is_congested;
+ avdt_scb_event(p_scb, AVDT_SCB_TC_CONG_EVT, &avdt_scb_evt);
}
}
}
uint8_t avdt_event = AVDT_CCB_IDLE_TOUT_EVT;
uint8_t err_code = AVDT_ERR_TIMEOUT;
- avdt_ccb_event(p_ccb, avdt_event, (tAVDT_CCB_EVT*)&err_code);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.err_code = err_code;
+ avdt_ccb_event(p_ccb, avdt_event, &avdt_ccb_evt);
}
void avdt_ccb_ret_ccb_timer_timeout(void* data) {
uint8_t avdt_event = AVDT_CCB_RET_TOUT_EVT;
uint8_t err_code = AVDT_ERR_TIMEOUT;
- avdt_ccb_event(p_ccb, avdt_event, (tAVDT_CCB_EVT*)&err_code);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.err_code = err_code;
+ avdt_ccb_event(p_ccb, avdt_event, &avdt_ccb_evt);
}
void avdt_ccb_rsp_ccb_timer_timeout(void* data) {
uint8_t avdt_event = AVDT_CCB_RSP_TOUT_EVT;
uint8_t err_code = AVDT_ERR_TIMEOUT;
- avdt_ccb_event(p_ccb, avdt_event, (tAVDT_CCB_EVT*)&err_code);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.err_code = err_code;
+ avdt_ccb_event(p_ccb, avdt_event, &avdt_ccb_evt);
}
void avdt_scb_transport_channel_timer_timeout(void* data) {
p_scb = avdt_scb_by_hdl(seid_list[i]);
if (p_scb != NULL) {
AVDT_TRACE_DEBUG("%s: AVDT_SCB_MSG_START_REJ_EVT: i=%d", __func__, i);
- avdt_scb_event(p_scb, AVDT_SCB_MSG_START_REJ_EVT,
- (tAVDT_SCB_EVT*)&avdt_msg.hdr);
+ tAVDT_SCB_EVT avdt_scb_evt;
+ avdt_scb_evt.msg.hdr = avdt_msg.hdr;
+ avdt_scb_event(p_scb, AVDT_SCB_MSG_START_REJ_EVT, &avdt_scb_evt);
}
}
}
for (i = 0; i < p_data->msg.multi.num_seps; i++) {
p_scb = avdt_scb_by_hdl(seid_list[i]);
if (p_scb != NULL) {
- avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_REJ_EVT,
- (tAVDT_SCB_EVT*)&avdt_msg.hdr);
+ tAVDT_SCB_EVT avdt_scb_evt;
+ avdt_scb_evt.msg.hdr = avdt_msg.hdr;
+ avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_REJ_EVT, &avdt_scb_evt);
}
}
}
*/
do {
/* we know p_curr_cmd = NULL after this */
- avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT*)&err_code);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.err_code = err_code;
+ avdt_ccb_cmd_fail(p_ccb, &avdt_ccb_evt);
/* set up next message */
p_ccb->p_curr_cmd = (BT_HDR*)fixed_queue_try_dequeue(p_ccb->cmd_q);
evt = avdt_msg_rej_2_evt[p_ccb->p_curr_cmd->event - 1];
if (evt & AVDT_CCB_MKR) {
- avdt_ccb_event(p_ccb, (uint8_t)(evt & ~AVDT_CCB_MKR),
- (tAVDT_CCB_EVT*)&msg);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.msg = msg;
+ avdt_ccb_event(p_ccb, (uint8_t)(evt & ~AVDT_CCB_MKR), &avdt_ccb_evt);
} else {
/* we get the scb out of the current cmd */
p_scb = avdt_scb_by_hdl(*((uint8_t*)(p_ccb->p_curr_cmd + 1)));
if (p_scb != NULL) {
- avdt_scb_event(p_scb, evt, (tAVDT_SCB_EVT*)&msg);
+ tAVDT_SCB_EVT avdt_scb_evt;
+ avdt_scb_evt.msg = msg;
+ avdt_scb_event(p_scb, evt, &avdt_scb_evt);
}
}
*
******************************************************************************/
void avdt_ccb_ret_cmd(tAVDT_CCB* p_ccb, tAVDT_CCB_EVT* p_data) {
- uint8_t err_code = AVDT_ERR_TIMEOUT;
-
p_ccb->ret_count++;
if (p_ccb->ret_count == AVDT_RET_MAX) {
/* command failed */
p_ccb->ret_count = 0;
- avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT*)&err_code);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.err_code = AVDT_ERR_TIMEOUT;
+ avdt_ccb_cmd_fail(p_ccb, &avdt_ccb_evt);
/* go to next queued command */
avdt_ccb_snd_cmd(p_ccb, p_data);
*
******************************************************************************/
void avdt_ccb_chk_reconn(tAVDT_CCB* p_ccb, UNUSED_ATTR tAVDT_CCB_EVT* p_data) {
- uint8_t err_code = AVDT_ERR_CONNECT;
-
if (p_ccb->reconn) {
p_ccb->reconn = false;
avdt_ccb_clear_ccb(p_ccb);
/* clear out current command, if any */
- avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT*)&err_code);
+ uint8_t err_code = AVDT_ERR_CONNECT;
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.err_code = err_code;
+ avdt_ccb_cmd_fail(p_ccb, &avdt_ccb_evt);
/* reopen the signaling channel */
avdt_ccb_event(p_ccb, AVDT_CCB_UL_OPEN_EVT, NULL);
if (ok) {
/* if it's a ccb event send to ccb */
if (evt & AVDT_CCB_MKR) {
- avdt_ccb_event(p_ccb, (uint8_t)(evt & ~AVDT_CCB_MKR),
- (tAVDT_CCB_EVT*)&msg);
+ tAVDT_CCB_EVT avdt_ccb_evt;
+ avdt_ccb_evt.msg = msg;
+ avdt_ccb_event(p_ccb, (uint8_t)(evt & ~AVDT_CCB_MKR), &avdt_ccb_evt);
}
/* if it's a scb event */
else {
if (evt) {
p_scb = avdt_scb_by_hdl(scb_hdl);
if (p_scb != NULL) {
- avdt_scb_event(p_scb, evt, (tAVDT_SCB_EVT*)&msg);
+ tAVDT_SCB_EVT avdt_scb_evt;
+ avdt_scb_evt.msg = msg;
+ avdt_scb_event(p_scb, evt, &avdt_scb_evt);
}
}
}
uint32_t ssrc;
uint8_t o_v, o_p, o_cc;
AVDT_REPORT_TYPE pt;
- tAVDT_REPORT_DATA report, *p_rpt;
+ tAVDT_REPORT_DATA report;
AVDT_TRACE_DEBUG("%s", __func__);
if (p_scb->cs.p_report_cback) {
- p_rpt = &report;
/* parse report packet header */
AVDT_MSG_PRS_RPT_OCTET1(p, o_v, o_p, o_cc);
pt = *p++;
break;
case AVDT_RTCP_PT_SDES: /* the packet type - SDES (Source Description) */
- if (*p == AVDT_RTCP_SDES_CNAME) {
- p_rpt = (tAVDT_REPORT_DATA*)(p + 2);
+ uint8_t sdes_type;
+ BE_STREAM_TO_UINT8(sdes_type, p);
+ if (sdes_type == AVDT_RTCP_SDES_CNAME) {
+ uint8_t name_length;
+ BE_STREAM_TO_UINT8(name_length, p);
+ if (name_length > len - 2 || name_length > AVDT_MAX_CNAME_SIZE) {
+ result = AVDT_BAD_PARAMS;
+ } else {
+ BE_STREAM_TO_ARRAY(p, &(report.cname[0]), name_length);
+ }
} else {
AVDT_TRACE_WARNING(" - SDES SSRC=0x%08x sc=%d %d len=%d %s", ssrc,
o_cc, *p, *(p + 1), p + 2);
}
if (result == AVDT_SUCCESS)
- (*p_scb->cs.p_report_cback)(avdt_scb_to_hdl(p_scb), pt, p_rpt);
+ (*p_scb->cs.p_report_cback)(avdt_scb_to_hdl(p_scb), pt, &report);
}
p_start += len;
return p_start;
/* initiate open */
single.seid = p_scb->peer_seid;
- avdt_scb_event(p_scb, AVDT_SCB_API_OPEN_REQ_EVT, (tAVDT_SCB_EVT*)&single);
+ tAVDT_SCB_EVT avdt_scb_evt;
+ avdt_scb_evt.msg.single = single;
+ avdt_scb_event(p_scb, AVDT_SCB_API_OPEN_REQ_EVT, &avdt_scb_evt);
}
}
hdr.seid = p_scb->peer_seid;
- avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_ABORT, (tAVDT_MSG*)&hdr);
+ tAVDT_MSG avdt_msg;
+ avdt_msg.hdr = hdr;
+ avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_ABORT, &avdt_msg);
}
}
hdr.seid = p_scb->peer_seid;
- avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_CLOSE, (tAVDT_MSG*)&hdr);
+ tAVDT_MSG avdt_msg;
+ avdt_msg.hdr = hdr;
+ avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_CLOSE, &avdt_msg);
}
/*******************************************************************************
hdr.seid = p_scb->peer_seid;
- avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_GETCONFIG, (tAVDT_MSG*)&hdr);
+ tAVDT_MSG avdt_msg;
+ avdt_msg.hdr = hdr;
+ avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_GETCONFIG, &avdt_msg);
}
/*******************************************************************************
hdr.seid = p_scb->peer_seid;
- avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_OPEN, (tAVDT_MSG*)&hdr);
+ tAVDT_MSG avdt_msg;
+ avdt_msg.hdr = hdr;
+ avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_OPEN, &avdt_msg);
}
/*******************************************************************************
}
avrc_cmd.status = AVRC_STS_NO_ERROR;
avrc_cmd.target_pdu = p_rcb->rasm_pdu;
- status = AVRC_BldCommand((tAVRC_COMMAND*)&avrc_cmd, &p_cmd);
+
+ tAVRC_COMMAND avrc_command;
+ avrc_command.continu = avrc_cmd;
+ status = AVRC_BldCommand(&avrc_command, &p_cmd);
if (status == AVRC_STS_NO_ERROR) {
AVRC_MsgReq(handle, (uint8_t)(label), AVRC_CMD_CTRL, p_cmd);
}
evt.busy_level = busy_level;
btm_cb.busy_level = busy_level;
if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_UPDATE_MASK)) {
- (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA*)&evt);
+ tBTM_BL_EVENT_DATA btm_bl_event_data;
+ btm_bl_event_data.update = evt;
+ (*btm_cb.p_bl_changed_cb)(&btm_bl_event_data);
}
}
}
evt.new_role = btm_cb.devcb.switch_role_ref_data.role;
evt.p_bda = &btm_cb.devcb.switch_role_ref_data.remote_bd_addr;
evt.hci_status = btm_cb.devcb.switch_role_ref_data.hci_status;
- (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA*)&evt);
+ tBTM_BL_EVENT_DATA btm_bl_event_data;
+ btm_bl_event_data.role_chg = evt;
+ (*btm_cb.p_bl_changed_cb)(&btm_bl_event_data);
BTM_TRACE_DEBUG(
"Role Switch Event: new_role 0x%02x, HCI Status 0x%02x, rs_st:%d",
evt.new_role = new_role;
evt.p_bda = p_bda;
evt.hci_status = hci_status;
- (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA*)&evt);
+ tBTM_BL_EVENT_DATA btm_bl_event_data;
+ btm_bl_event_data.role_chg = evt;
+ (*btm_cb.p_bl_changed_cb)(&btm_bl_event_data);
}
BTM_TRACE_DEBUG(
memcpy(evt_data.dev_class, dev_class, DEV_CLASS_LEN);
evt_data.link_type = link_type;
evt_data.sco_inx = xx;
- p->esco.p_esco_cback(BTM_ESCO_CONN_REQ_EVT,
- (tBTM_ESCO_EVT_DATA*)&evt_data);
+ tBTM_ESCO_EVT_DATA btm_esco_evt_data;
+ btm_esco_evt_data.conn_evt = evt_data;
+ p->esco.p_esco_cback(BTM_ESCO_CONN_REQ_EVT, &btm_esco_evt_data);
}
return;
data.tx_interval = p->esco.data.tx_interval = tx_interval;
data.retrans_window = p->esco.data.retrans_window = retrans_window;
- (*p->esco.p_esco_cback)(BTM_ESCO_CHG_EVT, (tBTM_ESCO_EVT_DATA*)&data);
+ tBTM_ESCO_EVT_DATA btm_esco_evt_data;
+ btm_esco_evt_data.chg_evt = data;
+ (*p->esco.p_esco_cback)(BTM_ESCO_CHG_EVT, &btm_esco_evt_data);
}
return;
}
}
if (btm_cb.api.p_sp_callback) {
- status = (*btm_cb.api.p_sp_callback)(event, (tBTM_SP_EVT_DATA*)&evt_data);
+ status = (*btm_cb.api.p_sp_callback)(event, &evt_data);
if (status != BTM_NOT_AUTHORIZED) {
return;
}
} else
evt_data.status = BTM_ERR_PROCESSING;
- if (btm_cb.api.p_sp_callback)
- (*btm_cb.api.p_sp_callback)(BTM_SP_LOC_OOB_EVT,
- (tBTM_SP_EVT_DATA*)&evt_data);
+ if (btm_cb.api.p_sp_callback) {
+ tBTM_SP_EVT_DATA btm_sp_evt_data;
+ btm_sp_evt_data.loc_oob = evt_data;
+ (*btm_cb.api.p_sp_callback)(BTM_SP_LOC_OOB_EVT, &btm_sp_evt_data);
+ }
}
/*******************************************************************************
cmd_status = GATT_NO_RESOURCES;
}
} else {
- p_msg = attp_build_sr_msg(*p_tcb, GATT_HANDLE_VALUE_IND,
- (tGATT_SR_MSG*)&indication);
+ tGATT_SR_MSG gatt_sr_msg;
+ gatt_sr_msg.attr_value = indication;
+ p_msg = attp_build_sr_msg(*p_tcb, GATT_HANDLE_VALUE_IND, &gatt_sr_msg);
if (p_msg != NULL) {
cmd_status = attp_send_sr_msg(*p_tcb, p_msg);
notif.auth_req = GATT_AUTH_REQ_NONE;
tGATT_STATUS cmd_sent;
+ tGATT_SR_MSG gatt_sr_msg;
+ gatt_sr_msg.attr_value = notif;
BT_HDR* p_buf =
- attp_build_sr_msg(*p_tcb, GATT_HANDLE_VALUE_NOTIF, (tGATT_SR_MSG*)¬if);
+ attp_build_sr_msg(*p_tcb, GATT_HANDLE_VALUE_NOTIF, &gatt_sr_msg);
if (p_buf != NULL) {
cmd_sent = attp_send_sr_msg(*p_tcb, p_buf);
} else
p_clcb->p_tcb->payload_size = mtu;
p_clcb->operation = GATTC_OPTYPE_CONFIG;
- return attp_send_cl_msg(*p_clcb->p_tcb, p_clcb, GATT_REQ_MTU,
- (tGATT_CL_MSG*)&mtu);
+ tGATT_CL_MSG gatt_cl_msg;
+ gatt_cl_msg.mtu = mtu;
+ return attp_send_cl_msg(*p_clcb->p_tcb, p_clcb, GATT_REQ_MTU, &gatt_cl_msg);
}
VLOG(1) << "notif_count= " << p_tcb->ind_count;
/* send confirmation now */
- tGATT_STATUS ret = attp_send_cl_msg(*p_tcb, nullptr, GATT_HANDLE_VALUE_CONF,
- (tGATT_CL_MSG*)&handle);
+ tGATT_CL_MSG gatt_cl_msg;
+ gatt_cl_msg.handle = handle;
+ tGATT_STATUS ret =
+ attp_send_cl_msg(*p_tcb, nullptr, GATT_HANDLE_VALUE_CONF, &gatt_cl_msg);
p_tcb->ind_count = 0;
VLOG(1) << __func__;
- rt = attp_send_cl_msg(tcb, p_clcb, GATT_REQ_EXEC_WRITE, (tGATT_CL_MSG*)&flag);
+ tGATT_CL_MSG gatt_cl_msg;
+ gatt_cl_msg.exec_write = flag;
+ rt = attp_send_cl_msg(tcb, p_clcb, GATT_REQ_EXEC_WRITE, &gatt_cl_msg);
if (rt != GATT_SUCCESS) {
gatt_end_operation(p_clcb, rt, NULL);
}
encrypt_status = gatt_get_link_encrypt_status(tcb);
+ tGATT_CL_COMPLETE gatt_cl_complete;
+ gatt_cl_complete.att_value = value;
for (i = 0, p_reg = gatt_cb.cl_rcb; i < GATT_MAX_APPS; i++, p_reg++) {
if (p_reg->in_use && p_reg->app_cb.p_cmpl_cb) {
conn_id = GATT_CREATE_CONN_ID(tcb.tcb_idx, p_reg->gatt_if);
(*p_reg->app_cb.p_cmpl_cb)(conn_id, event, encrypt_status,
- (tGATT_CL_COMPLETE*)&value);
+ &gatt_cl_complete);
}
}
}
if (tcb.prep_cnt[i]) {
gatt_if = (tGATT_IF)(i + 1);
conn_id = GATT_CREATE_CONN_ID(tcb.tcb_idx, gatt_if);
+ tGATTS_DATA gatts_data;
+ gatts_data.exec_write = flag;
gatt_sr_send_req_callback(conn_id, trans_id, GATTS_REQ_TYPE_WRITE_EXEC,
- (tGATTS_DATA*)&flag);
+ &gatts_data);
tcb.prep_cnt[i] = 0;
}
}
l2cble_set_fixed_channel_tx_data_length(tcb.peer_bda, L2CAP_ATT_CID,
tcb.payload_size);
- BT_HDR* p_buf =
- attp_build_sr_msg(tcb, GATT_RSP_MTU, (tGATT_SR_MSG*)&tcb.payload_size);
+ tGATT_SR_MSG gatt_sr_msg;
+ gatt_sr_msg.mtu = tcb.payload_size;
+ BT_HDR* p_buf = attp_build_sr_msg(tcb, GATT_RSP_MTU, &gatt_sr_msg);
attp_send_sr_msg(tcb, p_buf);
+ tGATTS_DATA gatts_data;
+ gatts_data.mtu = tcb.payload_size;
/* Notify all registered applicaiton with new MTU size. Us a transaction ID */
/* of 0, as no response is allowed from applcations */
for (int i = 0; i < GATT_MAX_APPS; i++) {
if (gatt_cb.cl_rcb[i].in_use) {
uint16_t conn_id =
GATT_CREATE_CONN_ID(tcb.tcb_idx, gatt_cb.cl_rcb[i].gatt_if);
- gatt_sr_send_req_callback(conn_id, 0, GATTS_REQ_TYPE_MTU,
- (tGATTS_DATA*)&tcb.payload_size);
+ gatt_sr_send_req_callback(conn_id, 0, GATTS_REQ_TYPE_MTU, &gatts_data);
}
}
}
bool continue_processing = gatts_proc_ind_ack(tcb, handle);
if (continue_processing) {
+ tGATTS_DATA gatts_data;
+ gatts_data.handle = handle;
for (auto& el : *gatt_cb.srv_list_info) {
if (el.s_hdl <= handle && el.e_hdl >= handle) {
uint32_t trans_id = gatt_sr_enqueue_cmd(tcb, op_code, handle);
uint16_t conn_id = GATT_CREATE_CONN_ID(tcb.tcb_idx, el.gatt_if);
gatt_sr_send_req_callback(conn_id, trans_id, GATTS_REQ_TYPE_CONF,
- (tGATTS_DATA*)&handle);
+ &gatts_data);
}
}
}
******************************************************************************/
tGATT_STATUS gatt_send_error_rsp(tGATT_TCB& tcb, uint8_t err_code,
uint8_t op_code, uint16_t handle, bool deq) {
- tGATT_ERROR error;
tGATT_STATUS status;
BT_HDR* p_buf;
- error.cmd_code = op_code;
- error.reason = err_code;
- error.handle = handle;
+ tGATT_SR_MSG msg;
+ msg.error.cmd_code = op_code;
+ msg.error.reason = err_code;
+ msg.error.handle = handle;
- p_buf = attp_build_sr_msg(tcb, GATT_RSP_ERROR, (tGATT_SR_MSG*)&error);
+ p_buf = attp_build_sr_msg(tcb, GATT_RSP_ERROR, &msg);
if (p_buf != NULL) {
status = attp_send_sr_msg(tcb, p_buf);
} else
/* save the info required by dcb connection */
p_dcb->p_chnl_cfg = p_chnl_cfg;
p_dcb->mdl_id = mdl_id;
- tMCA_CCB_MSG* p_evt_data =
- (tMCA_CCB_MSG*)osi_malloc(sizeof(tMCA_CCB_MSG));
if (!p_ccb->data_vpsm)
p_ccb->data_vpsm =
L2CA_Register(data_psm, (tL2CAP_APPL_INFO*)&mca_l2c_int_appl);
if (p_ccb->data_vpsm) {
+ tMCA_CCB_EVT* mca_ccb_evt =
+ (tMCA_CCB_EVT*)osi_malloc(sizeof(tMCA_CCB_EVT));
+ tMCA_CCB_MSG* p_evt_data = &mca_ccb_evt->api;
p_evt_data->dcb_idx = mca_dcb_to_hdl(p_dcb);
p_evt_data->mdep_id = peer_dep_id;
p_evt_data->mdl_id = mdl_id;
p_evt_data->op_code = MCA_OP_MDL_CREATE_REQ;
p_evt_data->hdr.event = MCA_CCB_API_REQ_EVT;
p_evt_data->hdr.layer_specific = false;
- mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, (tMCA_CCB_EVT*)p_evt_data);
+ mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, mca_ccb_evt);
return MCA_SUCCESS;
- } else {
- osi_free(p_evt_data);
}
mca_dcb_dealloc(p_dcb, NULL);
const tMCA_CHNL_CFG* p_chnl_cfg) {
tMCA_RESULT result = MCA_BAD_HANDLE;
tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
- tMCA_CCB_MSG evt_data;
- tMCA_DCB* p_dcb;
MCA_TRACE_API("MCA_CreateMdlRsp: %d dep=%d mdl_id=%d cfg=%d rsp_code=%d", mcl,
dep, mdl_id, cfg, rsp_code);
if (p_ccb->p_rx_msg && (p_ccb->p_rx_msg->mdep_id == dep) &&
(p_ccb->p_rx_msg->mdl_id == mdl_id) &&
(p_ccb->p_rx_msg->op_code == MCA_OP_MDL_CREATE_REQ)) {
+ tMCA_CCB_MSG evt_data;
result = MCA_SUCCESS;
evt_data.dcb_idx = 0;
if (rsp_code == MCA_RSP_SUCCESS) {
- p_dcb = mca_dcb_alloc(p_ccb, dep);
+ tMCA_DCB* p_dcb = mca_dcb_alloc(p_ccb, dep);
if (p_dcb) {
evt_data.dcb_idx = mca_dcb_to_hdl(p_dcb);
p_dcb->p_chnl_cfg = p_chnl_cfg;
evt_data.param = cfg;
evt_data.rsp_code = rsp_code;
evt_data.op_code = MCA_OP_MDL_CREATE_RSP;
- mca_ccb_event(p_ccb, MCA_CCB_API_RSP_EVT, (tMCA_CCB_EVT*)&evt_data);
+ tMCA_CCB_EVT mca_ccb_evt;
+ mca_ccb_evt.api = evt_data;
+ mca_ccb_event(p_ccb, MCA_CCB_API_RSP_EVT, &mca_ccb_evt);
}
} else {
MCA_TRACE_ERROR(
p_dcb = mca_dcb_alloc(p_ccb, dep);
result = MCA_NO_RESOURCES;
if (p_dcb) {
- tMCA_CCB_MSG* p_evt_data =
- (tMCA_CCB_MSG*)osi_malloc(sizeof(tMCA_CCB_MSG));
+ tMCA_CCB_EVT* mca_ccb_evt =
+ (tMCA_CCB_EVT*)osi_malloc(sizeof(tMCA_CCB_EVT));
+ tMCA_CCB_MSG* p_evt_data = &mca_ccb_evt->api;
p_dcb->p_chnl_cfg = p_chnl_cfg;
p_dcb->mdl_id = mdl_id;
p_evt_data->mdl_id = mdl_id;
p_evt_data->op_code = MCA_OP_MDL_RECONNECT_REQ;
p_evt_data->hdr.event = MCA_CCB_API_REQ_EVT;
- mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, (tMCA_CCB_EVT*)p_evt_data);
+ mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, mca_ccb_evt);
return MCA_SUCCESS;
}
}
const tMCA_CHNL_CFG* p_chnl_cfg) {
tMCA_RESULT result = MCA_BAD_HANDLE;
tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
- tMCA_CCB_MSG evt_data;
tMCA_DCB* p_dcb;
MCA_TRACE_API("MCA_ReconnectMdlRsp: %d ", mcl);
if (p_ccb->p_rx_msg && (p_ccb->p_rx_msg->mdl_id == mdl_id) &&
(p_ccb->p_rx_msg->op_code == MCA_OP_MDL_RECONNECT_REQ)) {
result = MCA_SUCCESS;
+ tMCA_CCB_MSG evt_data;
evt_data.dcb_idx = 0;
if (rsp_code == MCA_RSP_SUCCESS) {
p_dcb = mca_dcb_alloc(p_ccb, dep);
evt_data.mdl_id = mdl_id;
evt_data.rsp_code = rsp_code;
evt_data.op_code = MCA_OP_MDL_RECONNECT_RSP;
- mca_ccb_event(p_ccb, MCA_CCB_API_RSP_EVT, (tMCA_CCB_EVT*)&evt_data);
+ tMCA_CCB_EVT mca_ccb_evt;
+ mca_ccb_evt.api = evt_data;
+ mca_ccb_event(p_ccb, MCA_CCB_API_RSP_EVT, &mca_ccb_evt);
} else {
MCA_TRACE_ERROR(
"The given MCL is not expecting a MCA_ReconnectMdlRsp with the given "
return MCA_BUSY;
}
- tMCA_CCB_MSG* p_evt_data = (tMCA_CCB_MSG*)osi_malloc(sizeof(tMCA_CCB_MSG));
+ tMCA_CCB_EVT* mca_ccb_evt = (tMCA_CCB_EVT*)osi_malloc(sizeof(tMCA_CCB_EVT));
+ tMCA_CCB_MSG* p_evt_data = &mca_ccb_evt->api;
result = MCA_SUCCESS;
p_evt_data->op_code = MCA_OP_MDL_ABORT_REQ;
p_evt_data->hdr.event = MCA_CCB_API_REQ_EVT;
- mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, (tMCA_CCB_EVT*)p_evt_data);
+ mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, mca_ccb_evt);
}
return result;
}
return MCA_BAD_PARAMS;
}
- tMCA_CCB_MSG* p_evt_data = (tMCA_CCB_MSG*)osi_malloc(sizeof(tMCA_CCB_MSG));
+ tMCA_CCB_EVT* mca_ccb_evt = (tMCA_CCB_EVT*)osi_malloc(sizeof(tMCA_CCB_EVT));
+ tMCA_CCB_MSG* p_evt_data = &mca_ccb_evt->api;
result = MCA_SUCCESS;
p_evt_data->mdl_id = mdl_id;
p_evt_data->op_code = MCA_OP_MDL_DELETE_REQ;
p_evt_data->hdr.event = MCA_CCB_API_REQ_EVT;
- mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, (tMCA_CCB_EVT*)p_evt_data);
+ mca_ccb_event(p_ccb, MCA_CCB_API_REQ_EVT, mca_ccb_evt);
}
return result;
}
*
******************************************************************************/
void mca_dcb_do_disconn(tMCA_DCB* p_dcb, UNUSED_ATTR tMCA_DCB_EVT* p_data) {
- tMCA_CLOSE close;
-
if ((p_dcb->lcid == 0) || (L2CA_DisconnectReq(p_dcb->lcid) == false)) {
+ tMCA_CLOSE close;
close.param = MCA_INT;
close.reason = L2CAP_DISC_OK;
close.lcid = 0;
- mca_dcb_event(p_dcb, MCA_DCB_TC_CLOSE_EVT, (tMCA_DCB_EVT*)&close);
+ tMCA_DCB_EVT mca_dcb_evt;
+ mca_dcb_evt.close = close;
+ mca_dcb_event(p_dcb, MCA_DCB_TC_CLOSE_EVT, &mca_dcb_evt);
}
}
void mca_tc_close_ind(tMCA_TC_TBL* p_tbl, uint16_t reason) {
tMCA_CCB* p_ccb;
tMCA_DCB* p_dcb;
- tMCA_CLOSE close;
-
- close.param = MCA_ACP;
- close.reason = reason;
- close.lcid = p_tbl->lcid;
MCA_TRACE_DEBUG("%s() - tcid: %d, cb_idx:%d, old: %d", __func__, p_tbl->tcid,
p_tbl->cb_idx, p_tbl->state);
/* Check if the transport channel is in use */
if (p_tbl->state == MCA_TC_ST_UNUSED) return;
+ tMCA_CLOSE close;
+
+ close.param = MCA_ACP;
+ close.reason = reason;
+ close.lcid = p_tbl->lcid;
+
/* clear mca_tc_tbl entry */
if (p_tbl->cfg_flags & MCA_L2C_CFG_DISCN_INT) close.param = MCA_INT;
p_tbl->cfg_flags = 0;
p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
- /* if control channel, notify ccb that channel close */
+ /* if control channel, notify ccb of the channel close */
if (p_tbl->tcid == MCA_CTRL_TCID) {
p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
- mca_ccb_event(p_ccb, MCA_CCB_LL_CLOSE_EVT, (tMCA_CCB_EVT*)&close);
- }
- /* notify dcb that channel close */
- else {
- /* look up dcb */
+ tMCA_CCB_EVT mca_ccb_evt;
+ mca_ccb_evt.close = close;
+ mca_ccb_event(p_ccb, MCA_CCB_LL_CLOSE_EVT, &mca_ccb_evt);
+ } else {
+ /* notify dcb of the channel close */
p_dcb = mca_dcb_by_hdl(p_tbl->cb_idx);
if (p_dcb != NULL) {
- mca_dcb_event(p_dcb, MCA_DCB_TC_CLOSE_EVT, (tMCA_DCB_EVT*)&close);
+ tMCA_DCB_EVT mca_dcb_evt;
+ mca_dcb_evt.close = close;
+ mca_dcb_event(p_dcb, MCA_DCB_TC_CLOSE_EVT, &mca_dcb_evt);
}
}
p_tbl->state = MCA_TC_ST_UNUSED;
open.param = MCA_ACP;
}
- /* if control channel, notify ccb that channel open */
+ /* if control channel, notify ccb that the channel is open */
if (p_tbl->tcid == MCA_CTRL_TCID) {
p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
-
- mca_ccb_event(p_ccb, MCA_CCB_LL_OPEN_EVT, (tMCA_CCB_EVT*)&open);
- }
- /* must be data channel, notify dcb that channel open */
- else {
- /* look up dcb */
+ tMCA_CCB_EVT mca_ccb_evt;
+ mca_ccb_evt.open = open;
+ mca_ccb_event(p_ccb, MCA_CCB_LL_OPEN_EVT, &mca_ccb_evt);
+ } else {
+ /* must be data channel, notify dcb that the channel is open */
p_dcb = mca_dcb_by_hdl(p_tbl->cb_idx);
/* put lcid in event data */
if (p_dcb != NULL) {
- mca_dcb_event(p_dcb, MCA_DCB_TC_OPEN_EVT, (tMCA_DCB_EVT*)&open);
+ tMCA_DCB_EVT mca_dcb_evt;
+ mca_dcb_evt.open = open;
+ mca_dcb_event(p_dcb, MCA_DCB_TC_OPEN_EVT, &mca_dcb_evt);
}
}
}
/* if control channel, notify ccb of congestion */
if (p_tbl->tcid == MCA_CTRL_TCID) {
p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
- mca_ccb_event(p_ccb, MCA_CCB_LL_CONG_EVT, (tMCA_CCB_EVT*)&is_congested);
- }
- /* notify dcb that channel open */
- else {
- /* look up dcb by cb_idx */
+ tMCA_CCB_EVT mca_ccb_evt;
+ mca_ccb_evt.llcong = is_congested;
+ mca_ccb_event(p_ccb, MCA_CCB_LL_CONG_EVT, &mca_ccb_evt);
+ } else {
+ /* notify dcb that channel open */
p_dcb = mca_dcb_by_hdl(p_tbl->cb_idx);
if (p_dcb != NULL) {
- mca_dcb_event(p_dcb, MCA_DCB_TC_CONG_EVT, (tMCA_DCB_EVT*)&is_congested);
+ tMCA_DCB_EVT mca_dcb_evt;
+ mca_dcb_evt.llcong = is_congested;
+ mca_dcb_event(p_dcb, MCA_DCB_TC_CONG_EVT, &mca_dcb_evt);
}
}
}
OSDN Git Service
