/******************************************************************************
*
* Copyright 2009-2012 Broadcom Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/******************************************************************************
*
* This is the implementation file for the MCAP Main Control Block and
* Utility functions.
*
******************************************************************************/
#include <base/logging.h>
#include <string.h>
#include "bt_common.h"
#include "bt_target.h"
#include "l2c_api.h"
#include "mca_api.h"
#include "mca_defs.h"
#include "mca_int.h"
/* Main Control block for MCA */
tMCA_CB mca_cb;
/*****************************************************************************
* constants
****************************************************************************/
/* table of standard opcode message size */
const uint8_t mca_std_msg_len[MCA_NUM_STANDARD_OPCODE] = {
4, /* MCA_OP_ERROR_RSP */
5, /* MCA_OP_MDL_CREATE_REQ */
5, /* MCA_OP_MDL_CREATE_RSP */
3, /* MCA_OP_MDL_RECONNECT_REQ */
4, /* MCA_OP_MDL_RECONNECT_RSP */
3, /* MCA_OP_MDL_ABORT_REQ */
4, /* MCA_OP_MDL_ABORT_RSP */
3, /* MCA_OP_MDL_DELETE_REQ */
4 /* MCA_OP_MDL_DELETE_RSP */
};
/*******************************************************************************
*
* Function mca_handle_by_cpsm
*
* Description This function returns the handle for the given control
* channel PSM. 0, if not found.
*
* Returns the MCA handle.
*
******************************************************************************/
tMCA_HANDLE mca_handle_by_cpsm(uint16_t psm) {
int i;
tMCA_HANDLE handle = 0;
tMCA_RCB* p_rcb = &mca_cb.rcb[0];
for (i = 0; i < MCA_NUM_REGS; i++, p_rcb++) {
if (p_rcb->p_cback && p_rcb->reg.ctrl_psm == psm) {
handle = i + 1;
break;
}
}
return handle;
}
/*******************************************************************************
*
* Function mca_handle_by_dpsm
*
* Description This function returns the handle for the given data
* channel PSM. 0, if not found.
*
* Returns the MCA handle.
*
******************************************************************************/
tMCA_HANDLE mca_handle_by_dpsm(uint16_t psm) {
int i;
tMCA_HANDLE handle = 0;
tMCA_RCB* p_rcb = &mca_cb.rcb[0];
for (i = 0; i < MCA_NUM_REGS; i++, p_rcb++) {
if (p_rcb->p_cback && p_rcb->reg.data_psm == psm) {
handle = i + 1;
break;
}
}
return handle;
}
/*******************************************************************************
*
* Function mca_tc_tbl_calloc
*
* Description This function allocates a transport table for the given
* control channel.
*
* Returns The tranport table.
*
******************************************************************************/
tMCA_TC_TBL* mca_tc_tbl_calloc(tMCA_CCB* p_ccb) {
tMCA_TC_TBL* p_tbl = mca_cb.tc.tc_tbl;
int i;
/* find next free entry in tc table */
for (i = 0; i < MCA_NUM_TC_TBL; i++, p_tbl++) {
if (p_tbl->state == MCA_TC_ST_UNUSED) {
break;
}
}
/* sanity check */
CHECK(i != MCA_NUM_TC_TBL);
/* initialize entry */
p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
p_tbl->cfg_flags = 0;
p_tbl->cb_idx = mca_ccb_to_hdl(p_ccb);
p_tbl->tcid = MCA_CTRL_TCID;
p_tbl->my_mtu = MCA_CTRL_MTU;
p_tbl->state = MCA_TC_ST_IDLE;
p_tbl->lcid = p_ccb->lcid;
mca_cb.tc.lcid_tbl[p_ccb->lcid - L2CAP_BASE_APPL_CID] = i;
MCA_TRACE_DEBUG("%s() - cb_idx: %d", __func__, p_tbl->cb_idx);
return p_tbl;
}
/*******************************************************************************
*
* Function mca_tc_tbl_dalloc
*
* Description This function allocates a transport table for the given
* data channel.
*
* Returns The tranport table.
*
******************************************************************************/
tMCA_TC_TBL* mca_tc_tbl_dalloc(tMCA_DCB* p_dcb) {
tMCA_TC_TBL* p_tbl = mca_cb.tc.tc_tbl;
int i;
/* find next free entry in tc table */
for (i = 0; i < MCA_NUM_TC_TBL; i++, p_tbl++) {
if (p_tbl->state == MCA_TC_ST_UNUSED) {
break;
}
}
/* sanity check */
CHECK(i != MCA_NUM_TC_TBL);
/* initialize entry */
p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
p_tbl->cfg_flags = 0;
p_tbl->cb_idx = mca_dcb_to_hdl(p_dcb);
p_tbl->tcid = p_dcb->p_cs->type + 1;
p_tbl->my_mtu = p_dcb->p_chnl_cfg->data_mtu;
p_tbl->state = MCA_TC_ST_IDLE;
p_tbl->lcid = p_dcb->lcid;
mca_cb.tc.lcid_tbl[p_dcb->lcid - L2CAP_BASE_APPL_CID] = i;
MCA_TRACE_DEBUG("%s() - tcid: %d, cb_idx: %d", __func__, p_tbl->tcid,
p_tbl->cb_idx);
return p_tbl;
}
/*******************************************************************************
*
* Function mca_tc_tbl_by_lcid
*
* Description Find the transport channel table entry by LCID.
*
*
* Returns The tranport table.
*
******************************************************************************/
tMCA_TC_TBL* mca_tc_tbl_by_lcid(uint16_t lcid) {
uint8_t idx;
if (lcid >= L2CAP_BASE_APPL_CID) {
idx = mca_cb.tc.lcid_tbl[lcid - L2CAP_BASE_APPL_CID];
if (idx < MCA_NUM_TC_TBL) {
return &mca_cb.tc.tc_tbl[idx];
}
}
return NULL;
}
/*******************************************************************************
*
* Function mca_free_tc_tbl_by_lcid
*
* Description Find the transport table entry by LCID
* and free the tc_tbl
*
* Returns void.
*
******************************************************************************/
void mca_free_tc_tbl_by_lcid(uint16_t lcid) {
uint8_t idx;
if (lcid >= L2CAP_BASE_APPL_CID) {
idx = mca_cb.tc.lcid_tbl[lcid - L2CAP_BASE_APPL_CID];
if (idx < MCA_NUM_TC_TBL) {
mca_cb.tc.tc_tbl[idx].state = MCA_TC_ST_UNUSED;
}
}
}
/*******************************************************************************
*
* Function mca_set_cfg_by_tbl
*
* Description Set the L2CAP configuration information
*
* Returns none.
*
******************************************************************************/
void mca_set_cfg_by_tbl(tL2CAP_CFG_INFO* p_cfg, tMCA_TC_TBL* p_tbl) {
tMCA_DCB* p_dcb;
const tL2CAP_FCR_OPTS* p_opt;
tMCA_FCS_OPT fcs = MCA_FCS_NONE;
if (p_tbl->tcid == MCA_CTRL_TCID) {
p_opt = &mca_l2c_fcr_opts_def;
} else {
p_dcb = mca_dcb_by_hdl(p_tbl->cb_idx);
if (p_dcb) {
p_opt = &p_dcb->p_chnl_cfg->fcr_opt;
fcs = p_dcb->p_chnl_cfg->fcs;
}
}
memset(p_cfg, 0, sizeof(tL2CAP_CFG_INFO));
p_cfg->mtu_present = true;
p_cfg->mtu = p_tbl->my_mtu;
p_cfg->fcr_present = true;
memcpy(&p_cfg->fcr, p_opt, sizeof(tL2CAP_FCR_OPTS));
if (fcs & MCA_FCS_PRESNT_MASK) {
p_cfg->fcs_present = true;
p_cfg->fcs = (fcs & MCA_FCS_USE_MASK);
}
}
/*******************************************************************************
*
* Function mca_tc_close_ind
*
* Description This function is called by the L2CAP interface when the
* L2CAP channel is closed. It looks up the CCB or DCB for
* the channel and sends it a close event. The reason
* parameter is the same value passed by the L2CAP
* callback function.
*
* Returns Nothing.
*
******************************************************************************/
void mca_tc_close_ind(tMCA_TC_TBL* p_tbl, uint16_t reason) {
tMCA_CCB* p_ccb;
tMCA_DCB* p_dcb;
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 of the channel close */
if (p_tbl->tcid == MCA_CTRL_TCID) {
p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
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) {
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;
}
/*******************************************************************************
*
* Function mca_tc_open_ind
*
* Description This function is called by the L2CAP interface when
* the L2CAP channel is opened. It looks up the CCB or DCB
* for the channel and sends it an open event.
*
* Returns Nothing.
*
******************************************************************************/
void mca_tc_open_ind(tMCA_TC_TBL* p_tbl) {
tMCA_CCB* p_ccb;
tMCA_DCB* p_dcb;
tMCA_OPEN open;
MCA_TRACE_DEBUG("mca_tc_open_ind tcid: %d, cb_idx: %d", p_tbl->tcid,
p_tbl->cb_idx);
p_tbl->state = MCA_TC_ST_OPEN;
open.peer_mtu = p_tbl->peer_mtu;
open.lcid = p_tbl->lcid;
/* use param to indicate the role of connection.
* MCA_ACP, if ACP */
open.param = MCA_INT;
if (p_tbl->cfg_flags & MCA_L2C_CFG_CONN_ACP) {
open.param = MCA_ACP;
}
/* 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);
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) {
tMCA_DCB_EVT mca_dcb_evt;
mca_dcb_evt.open = open;
mca_dcb_event(p_dcb, MCA_DCB_TC_OPEN_EVT, &mca_dcb_evt);
}
}
}
/*******************************************************************************
*
* Function mca_tc_cong_ind
*
* Description This function is called by the L2CAP interface layer when
* L2CAP calls the congestion callback. It looks up the CCB
* or DCB for the channel and sends it a congestion event.
* The is_congested parameter is the same value passed by
* the L2CAP callback function.
*
*
* Returns Nothing.
*
******************************************************************************/
void mca_tc_cong_ind(tMCA_TC_TBL* p_tbl, bool is_congested) {
tMCA_CCB* p_ccb;
tMCA_DCB* p_dcb;
MCA_TRACE_DEBUG("%s() - tcid: %d, cb_idx: %d", __func__, p_tbl->tcid,
p_tbl->cb_idx);
/* 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);
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) {
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);
}
}
}
/*******************************************************************************
*
* Function mca_tc_data_ind
*
* Description This function is called by the L2CAP interface layer when
* incoming data is received from L2CAP. It looks up the CCB
* or DCB for the channel and routes the data accordingly.
*
* Returns Nothing.
*
******************************************************************************/
void mca_tc_data_ind(tMCA_TC_TBL* p_tbl, BT_HDR* p_buf) {
tMCA_CCB* p_ccb;
tMCA_DCB* p_dcb;
uint8_t event = MCA_CCB_MSG_RSP_EVT;
uint8_t* p;
uint8_t rej_rsp_code = MCA_RSP_SUCCESS;
MCA_TRACE_DEBUG("%s: tcid: %d, cb_idx: %d", __func__, p_tbl->tcid,
p_tbl->cb_idx);
/* if control channel, handle control message */
if (p_tbl->tcid == MCA_CTRL_TCID) {
p_ccb = mca_ccb_by_hdl((tMCA_CL)p_tbl->cb_idx);
if (p_ccb) {
p = (uint8_t*)(p_buf + 1) + p_buf->offset;
/* all the request opcode has bit 0 set. response code has bit 0 clear */
if ((*p) & 0x01) event = MCA_CCB_MSG_REQ_EVT;
if (*p < MCA_NUM_STANDARD_OPCODE) {
if (p_buf->len != mca_std_msg_len[*p]) {
MCA_TRACE_ERROR("%s: opcode 0x%02x required len: %d, got len: %d",
__func__, *p, mca_std_msg_len[*p], p_buf->len);
rej_rsp_code = MCA_RSP_BAD_PARAM;
}
} else if ((*p >= MCA_FIRST_SYNC_OP) && (*p <= MCA_LAST_SYNC_OP)) {
MCA_TRACE_ERROR("%s: unsupported SYNC opcode: 0x%02x len:%d", __func__,
*p, p_buf->len);
/* reject unsupported request */
rej_rsp_code = MCA_RSP_NO_SUPPORT;
} else {
MCA_TRACE_ERROR("%s: bad opcode: 0x%02x len:%d", __func__, *p,
p_buf->len);
/* reject unsupported request */
rej_rsp_code = MCA_RSP_BAD_OPCODE;
}
p_buf->layer_specific = rej_rsp_code;
/* forward the request/response to state machine */
mca_ccb_event(p_ccb, event, (tMCA_CCB_EVT*)p_buf);
} else {
osi_free(p_buf);
}
} else {
/* send event to dcb */
p_dcb = mca_dcb_by_hdl(p_tbl->cb_idx);
if (p_dcb != NULL) {
mca_dcb_event(p_dcb, MCA_DCB_TC_DATA_EVT, (tMCA_DCB_EVT*)p_buf);
} else {
osi_free(p_buf);
}
}
}
/*******************************************************************************
*
* Function mca_rcb_alloc
*
* Description This function allocates a registration control block.
* If no free RCB is available, it returns NULL.
*
* Returns tMCA_RCB *
*
******************************************************************************/
tMCA_RCB* mca_rcb_alloc(tMCA_REG* p_reg) {
int i;
tMCA_RCB* p_rcb = NULL;
for (i = 0; i < MCA_NUM_REGS; i++) {
if (mca_cb.rcb[i].p_cback == NULL) {
p_rcb = &mca_cb.rcb[i];
memcpy(&p_rcb->reg, p_reg, sizeof(tMCA_REG));
break;
}
}
return p_rcb;
}
/*******************************************************************************
*
* Function mca_rcb_dealloc
*
* Description This function deallocates the RCB with the given handle.
*
* Returns void.
*
******************************************************************************/
void mca_rcb_dealloc(tMCA_HANDLE handle) {
int i;
bool done = true;
tMCA_RCB* p_rcb;
tMCA_CCB* p_ccb;
if (handle && (handle <= MCA_NUM_REGS)) {
handle--;
p_rcb = &mca_cb.rcb[handle];
if (p_rcb->p_cback) {
p_ccb = &mca_cb.ccb[handle * MCA_NUM_LINKS];
/* check if all associated CCB are disconnected */
for (i = 0; i < MCA_NUM_LINKS; i++, p_ccb++) {
if (p_ccb->p_rcb) {
done = false;
mca_ccb_event(p_ccb, MCA_CCB_API_DISCONNECT_EVT, NULL);
}
}
if (done) {
memset(p_rcb, 0, sizeof(tMCA_RCB));
MCA_TRACE_DEBUG("%s() - reset MCA_RCB index=%d", __func__, handle);
}
}
}
}
/*******************************************************************************
*
* Function mca_rcb_to_handle
*
* Description This function converts a pointer to an RCB to
* a handle (tMCA_HANDLE). It returns the handle.
*
* Returns void.
*
******************************************************************************/
tMCA_HANDLE mca_rcb_to_handle(tMCA_RCB* p_rcb) {
return (uint8_t)(p_rcb - mca_cb.rcb + 1);
}
/*******************************************************************************
*
* Function mca_rcb_by_handle
*
* Description This function finds the RCB for a handle (tMCA_HANDLE).
* It returns a pointer to the RCB. If no RCB matches the
* handle it returns NULL.
*
* Returns tMCA_RCB *
*
******************************************************************************/
tMCA_RCB* mca_rcb_by_handle(tMCA_HANDLE handle) {
tMCA_RCB* p_rcb = NULL;
if (handle && (handle <= MCA_NUM_REGS) && mca_cb.rcb[handle - 1].p_cback) {
p_rcb = &mca_cb.rcb[handle - 1];
}
return p_rcb;
}
/*******************************************************************************
*
* Function mca_is_valid_dep_id
*
* Description This function checks if the given dep_id is valid.
*
* Returns true, if this is a valid local dep_id
*
******************************************************************************/
bool mca_is_valid_dep_id(tMCA_RCB* p_rcb, tMCA_DEP dep) {
bool valid = false;
if (dep < MCA_NUM_DEPS && p_rcb->dep[dep].p_data_cback) {
valid = true;
}
return valid;
}