stack/mcap/mca_main.cc - platform/system/bt - Git at Google

 /******************************************************************************
  *
  *  Copyright (C) 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);
     } /* got a valid ccb */
     else
       osi_free(p_buf);
   }
   /* else send event to dcb */
   else {
     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;
 }
	/******************************************************************************
	*
	* Copyright (C) 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);
	} /* got a valid ccb */
	else
	osi_free(p_buf);
	}
	/* else send event to dcb */
	else {
	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;
	}