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