stack/mcap/mca_api.cc

/******************************************************************************
 *
 *  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 API implementation file for the Multi-Channel Adaptation
 *  Protocol (MCAP).
 *
 ******************************************************************************/
#include <base/logging.h>
#include <string.h>

#include "bt_target.h"
#include "btm_api.h"
#include "btm_int.h"
#include "mca_api.h"
#include "mca_defs.h"
#include "mca_int.h"

#include "btu.h"

/*******************************************************************************
 *
 * Function         mca_process_timeout
 *
 * Description      This function is called by BTU when an MCA timer
 *                  expires.
 *
 *                  This function is for use internal to the stack only.
 *
 * Returns          void
 *
 ******************************************************************************/
void mca_ccb_timer_timeout(void* data) {
  tMCA_CCB* p_ccb = (tMCA_CCB*)data;

  mca_ccb_event(p_ccb, MCA_CCB_RSP_TOUT_EVT, NULL);
}

/*******************************************************************************
 *
 * Function         MCA_Init
 *
 * Description      Initialize MCAP main control block.
 *                  This function is called at stack start up.
 *
 * Returns          void
 *
 ******************************************************************************/
void MCA_Init(void) {
  memset(&mca_cb, 0, sizeof(tMCA_CB));

#if defined(MCA_INITIAL_TRACE_LEVEL)
  mca_cb.trace_level = MCA_INITIAL_TRACE_LEVEL;
#else
  mca_cb.trace_level = BT_TRACE_LEVEL_NONE;
#endif
}

/*******************************************************************************
 *
 * Function         MCA_SetTraceLevel
 *
 * Description      This function sets the debug trace level for MCA.
 *                  If 0xff is passed, the current trace level is returned.
 *
 *                  Input Parameters:
 *                      level:  The level to set the MCA tracing to:
 *                      0xff-returns the current setting.
 *                      0-turns off tracing.
 *                      >= 1-Errors.
 *                      >= 2-Warnings.
 *                      >= 3-APIs.
 *                      >= 4-Events.
 *                      >= 5-Debug.
 *
 * Returns          The new trace level or current trace level if
 *                  the input parameter is 0xff.
 *
 ******************************************************************************/
uint8_t MCA_SetTraceLevel(uint8_t level) {
  if (level != 0xFF) mca_cb.trace_level = level;

  return (mca_cb.trace_level);
}

/*******************************************************************************
 *
 * Function         MCA_Register
 *
 * Description      This function registers an MCAP implementation.
 *                  It is assumed that the control channel PSM and data channel
 *                  PSM are not used by any other instances of the stack.
 *                  If the given p_reg->ctrl_psm is 0, this handle is INT only.
 *
 * Returns          0, if failed. Otherwise, the MCA handle.
 *
 ******************************************************************************/
tMCA_HANDLE MCA_Register(tMCA_REG* p_reg, tMCA_CTRL_CBACK* p_cback) {
  tMCA_RCB* p_rcb;
  tMCA_HANDLE handle = 0;
  tL2CAP_APPL_INFO l2c_cacp_appl;
  tL2CAP_APPL_INFO l2c_dacp_appl;

  CHECK(p_reg != NULL);
  CHECK(p_cback != NULL);

  MCA_TRACE_API("MCA_Register: ctrl_psm:0x%x, data_psm:0x%x", p_reg->ctrl_psm,
                p_reg->data_psm);

  p_rcb = mca_rcb_alloc(p_reg);
  if (p_rcb != NULL) {
    if (p_reg->ctrl_psm) {
      if (L2C_INVALID_PSM(p_reg->ctrl_psm) ||
          L2C_INVALID_PSM(p_reg->data_psm)) {
        MCA_TRACE_ERROR("INVALID_PSM");
        return 0;
      }

      l2c_cacp_appl = *(tL2CAP_APPL_INFO*)&mca_l2c_int_appl;
      l2c_cacp_appl.pL2CA_ConnectCfm_Cb = NULL;
      l2c_dacp_appl = *(tL2CAP_APPL_INFO*)&l2c_cacp_appl;
      l2c_cacp_appl.pL2CA_ConnectInd_Cb = mca_l2c_cconn_ind_cback;
      l2c_dacp_appl.pL2CA_ConnectInd_Cb = mca_l2c_dconn_ind_cback;
      if (L2CA_Register(p_reg->ctrl_psm, (tL2CAP_APPL_INFO*)&l2c_cacp_appl) &&
          L2CA_Register(p_reg->data_psm, (tL2CAP_APPL_INFO*)&l2c_dacp_appl)) {
        /* set security level */
        BTM_SetSecurityLevel(false, "", BTM_SEC_SERVICE_MCAP_CTRL,
                             p_reg->sec_mask, p_reg->ctrl_psm,
                             BTM_SEC_PROTO_MCA, MCA_CTRL_TCID);

        /* in theory, we do not need this one for data_psm
         * If we don't, L2CAP rejects with security block (3),
         * which is different reject code from what MCAP spec suggests.
         * we set this one, so mca_l2c_dconn_ind_cback can reject /w no
         * resources (4) */
        BTM_SetSecurityLevel(false, "", BTM_SEC_SERVICE_MCAP_DATA,
                             p_reg->sec_mask, p_reg->data_psm,
                             BTM_SEC_PROTO_MCA, MCA_CTRL_TCID);
      } else {
        MCA_TRACE_ERROR("Failed to register to L2CAP");
        return 0;
      }
    } else
      p_rcb->reg.data_psm = 0;
    handle = mca_rcb_to_handle(p_rcb);
    p_rcb->p_cback = p_cback;
    p_rcb->reg.rsp_tout = p_reg->rsp_tout;
  }
  return handle;
}

/*******************************************************************************
 *
 * Function         MCA_Deregister
 *
 * Description      Deregister an MCAP implementation.  Before this function can
 *                  be called, all control and data channels must be removed
 *                  with MCA_DisconnectReq and MCA_CloseReq.
 *
 * Returns          void
 *
 ******************************************************************************/
void MCA_Deregister(tMCA_HANDLE handle) {
  tMCA_RCB* p_rcb = mca_rcb_by_handle(handle);

  MCA_TRACE_API("MCA_Deregister: %d", handle);
  if (p_rcb && p_rcb->reg.ctrl_psm) {
    L2CA_Deregister(p_rcb->reg.ctrl_psm);
    L2CA_Deregister(p_rcb->reg.data_psm);
    btm_sec_clr_service_by_psm(p_rcb->reg.ctrl_psm);
    btm_sec_clr_service_by_psm(p_rcb->reg.data_psm);
  }
  mca_rcb_dealloc(handle);
}

/*******************************************************************************
 *
 * Function         MCA_CreateDep
 *
 * Description      Create a data endpoint. If the MDEP is created successfully,
 *                  the MDEP ID is returned in *p_dep. After a data endpoint is
 *                  created, an application can initiate a connection between
 *                  this endpoint and an endpoint on a peer device.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_CreateDep(tMCA_HANDLE handle, tMCA_DEP* p_dep, tMCA_CS* p_cs) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  int i;
  tMCA_RCB* p_rcb = mca_rcb_by_handle(handle);
  tMCA_CS* p_depcs;

  CHECK(p_dep != NULL);
  CHECK(p_cs != NULL);
  CHECK(p_cs->p_data_cback != NULL);

  MCA_TRACE_API("MCA_CreateDep: %d", handle);
  if (p_rcb) {
    if (p_cs->max_mdl > MCA_NUM_MDLS) {
      MCA_TRACE_ERROR("max_mdl: %d is too big", p_cs->max_mdl);
      result = MCA_BAD_PARAMS;
    } else {
      p_depcs = p_rcb->dep;
      if (p_cs->type == MCA_TDEP_ECHO) {
        if (p_depcs->p_data_cback) {
          MCA_TRACE_ERROR("Already has ECHO MDEP");
          return MCA_NO_RESOURCES;
        }
        memcpy(p_depcs, p_cs, sizeof(tMCA_CS));
        *p_dep = 0;
        result = MCA_SUCCESS;
      } else {
        result = MCA_NO_RESOURCES;
        /* non-echo MDEP starts from 1 */
        p_depcs++;
        for (i = 1; i < MCA_NUM_DEPS; i++, p_depcs++) {
          if (p_depcs->p_data_cback == NULL) {
            memcpy(p_depcs, p_cs, sizeof(tMCA_CS));
            /* internally use type as the mdep id */
            p_depcs->type = i;
            *p_dep = i;
            result = MCA_SUCCESS;
            break;
          }
        }
      }
    }
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_DeleteDep
 *
 * Description      Delete a data endpoint.  This function is called when
 *                  the implementation is no longer using a data endpoint.
 *                  If this function is called when the endpoint is connected
 *                  the connection is closed and the data endpoint
 *                  is removed.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_DeleteDep(tMCA_HANDLE handle, tMCA_DEP dep) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_RCB* p_rcb = mca_rcb_by_handle(handle);
  tMCA_DCB* p_dcb;
  int i, max;
  tMCA_CS* p_depcs;

  MCA_TRACE_API("MCA_DeleteDep: %d dep:%d", handle, dep);
  if (p_rcb) {
    if (dep < MCA_NUM_DEPS && p_rcb->dep[dep].p_data_cback) {
      result = MCA_SUCCESS;
      p_rcb->dep[dep].p_data_cback = NULL;
      p_depcs = &(p_rcb->dep[dep]);
      i = handle - 1;
      max = MCA_NUM_MDLS * MCA_NUM_LINKS;
      p_dcb = &mca_cb.dcb[i * max];
      /* make sure no MDL exists for this MDEP */
      for (i = 0; i < max; i++, p_dcb++) {
        if (p_dcb->state && p_dcb->p_cs == p_depcs) {
          mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
        }
      }
    }
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_ConnectReq
 *
 * Description      This function initiates an MCAP control channel connection
 *                  to the peer device.  When the connection is completed, an
 *                  MCA_CONNECT_IND_EVT is reported to the application via its
 *                  control callback function.
 *                  This control channel is identified by the tMCA_CL.
 *                  If the connection attempt fails, an MCA_DISCONNECT_IND_EVT
 *                  is reported. The security mask parameter overrides the
 *                  outgoing security mask set in MCA_Register().
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_ConnectReq(tMCA_HANDLE handle, const RawAddress& bd_addr,
                           uint16_t ctrl_psm, uint16_t sec_mask) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb;
  tMCA_TC_TBL* p_tbl;

  MCA_TRACE_API("MCA_ConnectReq: %d psm:0x%x", handle, ctrl_psm);
  p_ccb = mca_ccb_by_bd(handle, bd_addr);
  if (p_ccb == NULL)
    p_ccb = mca_ccb_alloc(handle, bd_addr);
  else {
    MCA_TRACE_ERROR("control channel already exists");
    return MCA_BUSY;
  }

  if (p_ccb) {
    p_ccb->ctrl_vpsm =
        L2CA_Register(ctrl_psm, (tL2CAP_APPL_INFO*)&mca_l2c_int_appl);
    result = MCA_NO_RESOURCES;
    if (p_ccb->ctrl_vpsm) {
      BTM_SetSecurityLevel(true, "", BTM_SEC_SERVICE_MCAP_CTRL, sec_mask,
                           p_ccb->ctrl_vpsm, BTM_SEC_PROTO_MCA, MCA_CTRL_TCID);
      p_ccb->lcid = mca_l2c_open_req(bd_addr, p_ccb->ctrl_vpsm, NULL);
      if (p_ccb->lcid) {
        p_tbl = mca_tc_tbl_calloc(p_ccb);
        if (p_tbl) {
          p_tbl->state = MCA_TC_ST_CONN;
          p_ccb->sec_mask = sec_mask;
          result = MCA_SUCCESS;
        }
      }
    }
    if (result != MCA_SUCCESS) mca_ccb_dealloc(p_ccb, NULL);
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_DisconnectReq
 *
 * Description      This function disconnect an MCAP control channel
 *                  to the peer device.
 *                  If associated data channel exists, they are disconnected.
 *                  When the MCL is disconnected an MCA_DISCONNECT_IND_EVT is
 *                  reported to the application via its control callback
 *                  function.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_DisconnectReq(tMCA_CL mcl) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);

  MCA_TRACE_API("MCA_DisconnectReq: %d ", mcl);
  if (p_ccb) {
    result = MCA_SUCCESS;
    mca_ccb_event(p_ccb, MCA_CCB_API_DISCONNECT_EVT, NULL);
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_CreateMdl
 *
 * Description      This function sends a CREATE_MDL request to the peer device.
 *                  When the response is received, a MCA_CREATE_CFM_EVT is
 *                  reported with the given MDL ID.
 *                  If the response is successful, a data channel is open
 *                  with the given p_chnl_cfg
 *                  If p_chnl_cfg is NULL, the data channel is not initiated
 *                  until MCA_DataChnlCfg is called to provide the p_chnl_cfg.
 *                  When the data channel is open successfully, a
 *                  MCA_OPEN_CFM_EVT is reported. This data channel is
 *                  identified as tMCA_DL.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_CreateMdl(tMCA_CL mcl, tMCA_DEP dep, uint16_t data_psm,
                          uint16_t mdl_id, uint8_t peer_dep_id, uint8_t cfg,
                          const tMCA_CHNL_CFG* p_chnl_cfg) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
  tMCA_DCB* p_dcb;

  MCA_TRACE_API("MCA_CreateMdl: %d dep=%d mdl_id=%d peer_dep_id=%d", mcl, dep,
                mdl_id, peer_dep_id);
  if (p_ccb) {
    if (p_ccb->p_tx_req || p_ccb->p_rx_msg || p_ccb->cong) {
      MCA_TRACE_ERROR("pending req");
      return MCA_BUSY;
    }

    if ((peer_dep_id > MCA_MAX_MDEP_ID) || (!MCA_IS_VALID_MDL_ID(mdl_id))) {
      MCA_TRACE_ERROR("bad peer dep id:%d or bad mdl id: %d ", peer_dep_id,
                      mdl_id);
      return MCA_BAD_PARAMS;
    }

    if (mca_ccb_uses_mdl_id(p_ccb, mdl_id)) {
      MCA_TRACE_ERROR("mdl id: %d is used in the control link", mdl_id);
      return MCA_BAD_MDL_ID;
    }

    p_dcb = mca_dcb_alloc(p_ccb, dep);
    result = MCA_NO_RESOURCES;
    if (p_dcb) {
      /* save the info required by dcb connection */
      p_dcb->p_chnl_cfg = p_chnl_cfg;
      p_dcb->mdl_id = mdl_id;
      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->param = cfg;
        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, mca_ccb_evt);
        return MCA_SUCCESS;
      }

      mca_dcb_dealloc(p_dcb, NULL);
    }
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_CreateMdlRsp
 *
 * Description      This function sends a CREATE_MDL response to the peer device
 *                  in response to a received MCA_CREATE_IND_EVT.
 *                  If the rsp_code is successful, a data channel is open
 *                  with the given p_chnl_cfg
 *                  When the data channel is open successfully, a
 *                  MCA_OPEN_IND_EVT
 *                  is reported. This data channel is identified as tMCA_DL.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_CreateMdlRsp(tMCA_CL mcl, tMCA_DEP dep, uint16_t mdl_id,
                             uint8_t cfg, uint8_t rsp_code,
                             const tMCA_CHNL_CFG* p_chnl_cfg) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);

  MCA_TRACE_API("MCA_CreateMdlRsp: %d dep=%d mdl_id=%d cfg=%d rsp_code=%d", mcl,
                dep, mdl_id, cfg, rsp_code);
  CHECK(p_chnl_cfg != NULL);
  if (p_ccb) {
    if (p_ccb->cong) {
      MCA_TRACE_ERROR("congested");
      return MCA_BUSY;
    }
    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) {
        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;
          p_dcb->mdl_id = mdl_id;
        } else {
          rsp_code = MCA_RSP_MDEP_BUSY;
          result = MCA_NO_RESOURCES;
        }
      }

      if (result == MCA_SUCCESS) {
        evt_data.mdl_id = mdl_id;
        evt_data.param = cfg;
        evt_data.rsp_code = rsp_code;
        evt_data.op_code = MCA_OP_MDL_CREATE_RSP;
        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_CreateMdlRsp with the given "
          "parameters");
      result = MCA_BAD_PARAMS;
    }
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_CloseReq
 *
 * Description      Close a data channel.  When the channel is closed, an
 *                  MCA_CLOSE_CFM_EVT is sent to the application via the
 *                  control callback function for this handle.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_CloseReq(tMCA_DL mdl) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_DCB* p_dcb = mca_dcb_by_hdl(mdl);

  MCA_TRACE_API("MCA_CloseReq: %d ", mdl);
  if (p_dcb) {
    result = MCA_SUCCESS;
    mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_ReconnectMdl
 *
 * Description      This function sends a RECONNECT_MDL request to the peer
 *                  device. When the response is received, a
 *                  MCA_RECONNECT_CFM_EVT is reported. If p_chnl_cfg is NULL,
 *                  the data channel is not initiated until MCA_DataChnlCfg is
 *                  called to provide the p_chnl_cfg. If the response is
 *                  successful, a data channel is open. When the data channel is
 *                  open successfully, a MCA_OPEN_CFM_EVT is reported.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_ReconnectMdl(tMCA_CL mcl, tMCA_DEP dep, uint16_t data_psm,
                             uint16_t mdl_id, const tMCA_CHNL_CFG* p_chnl_cfg) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
  tMCA_DCB* p_dcb;

  MCA_TRACE_API("MCA_ReconnectMdl: %d ", mcl);
  CHECK(p_chnl_cfg != NULL);
  if (p_ccb) {
    if (p_ccb->p_tx_req || p_ccb->p_rx_msg || p_ccb->cong) {
      MCA_TRACE_ERROR("pending req");
      return MCA_BUSY;
    }

    if (!MCA_IS_VALID_MDL_ID(mdl_id)) {
      MCA_TRACE_ERROR("bad mdl id: %d ", mdl_id);
      return MCA_BAD_PARAMS;
    }

    if (mca_ccb_uses_mdl_id(p_ccb, mdl_id)) {
      MCA_TRACE_ERROR("mdl id: %d is used in the control link", mdl_id);
      return MCA_BAD_MDL_ID;
    }

    p_dcb = mca_dcb_alloc(p_ccb, dep);
    result = MCA_NO_RESOURCES;
    if (p_dcb) {
      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;
      if (!p_ccb->data_vpsm)
        p_ccb->data_vpsm =
            L2CA_Register(data_psm, (tL2CAP_APPL_INFO*)&mca_l2c_int_appl);
      p_evt_data->dcb_idx = mca_dcb_to_hdl(p_dcb);
      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, mca_ccb_evt);
      return MCA_SUCCESS;
    }
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_ReconnectMdlRsp
 *
 * Description      This function sends a RECONNECT_MDL response to the peer
 *                  device in response to a MCA_RECONNECT_IND_EVT event.
 *                  If the response is successful, a data channel is open.
 *                  When the data channel is open successfully, a
 *                  MCA_OPEN_IND_EVT is reported.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_ReconnectMdlRsp(tMCA_CL mcl, tMCA_DEP dep, uint16_t mdl_id,
                                uint8_t rsp_code,
                                const tMCA_CHNL_CFG* p_chnl_cfg) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
  tMCA_DCB* p_dcb;

  MCA_TRACE_API("MCA_ReconnectMdlRsp: %d ", mcl);
  CHECK(p_chnl_cfg != NULL);
  if (p_ccb) {
    if (p_ccb->cong) {
      MCA_TRACE_ERROR("congested");
      return MCA_BUSY;
    }
    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);
        if (p_dcb) {
          evt_data.dcb_idx = mca_dcb_to_hdl(p_dcb);
          p_dcb->p_chnl_cfg = p_chnl_cfg;
          p_dcb->mdl_id = mdl_id;
        } else {
          MCA_TRACE_ERROR("Out of MDL for this MDEP");
          rsp_code = MCA_RSP_MDEP_BUSY;
          result = MCA_NO_RESOURCES;
        }
      }

      evt_data.mdl_id = mdl_id;
      evt_data.rsp_code = rsp_code;
      evt_data.op_code = MCA_OP_MDL_RECONNECT_RSP;
      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 "
          "parameters");
      result = MCA_BAD_PARAMS;
    }
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_DataChnlCfg
 *
 * Description      This function initiates a data channel connection toward the
 *                  connected peer device.
 *                  When the data channel is open successfully, a
 *                  MCA_OPEN_CFM_EVT is reported. This data channel is
 *                  identified as tMCA_DL.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_DataChnlCfg(tMCA_CL mcl, const tMCA_CHNL_CFG* p_chnl_cfg) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
  tMCA_DCB* p_dcb;
  tMCA_TC_TBL* p_tbl;

  MCA_TRACE_API("MCA_DataChnlCfg: %d ", mcl);
  CHECK(p_chnl_cfg != NULL);
  if (p_ccb) {
    result = MCA_NO_RESOURCES;
    if ((p_ccb->p_tx_req == NULL) || (p_ccb->status != MCA_CCB_STAT_PENDING) ||
        ((p_dcb = mca_dcb_by_hdl(p_ccb->p_tx_req->dcb_idx)) == NULL)) {
      MCA_TRACE_ERROR("The given MCL is not expecting this API:%d",
                      p_ccb->status);
      return result;
    }

    p_dcb->p_chnl_cfg = p_chnl_cfg;
    BTM_SetSecurityLevel(true, "", BTM_SEC_SERVICE_MCAP_DATA, p_ccb->sec_mask,
                         p_ccb->data_vpsm, BTM_SEC_PROTO_MCA,
                         p_ccb->p_tx_req->dcb_idx);
    p_dcb->lcid =
        mca_l2c_open_req(p_ccb->peer_addr, p_ccb->data_vpsm, p_dcb->p_chnl_cfg);
    if (p_dcb->lcid) {
      p_tbl = mca_tc_tbl_dalloc(p_dcb);
      if (p_tbl) {
        p_tbl->state = MCA_TC_ST_CONN;
        result = MCA_SUCCESS;
      }
    }
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_Abort
 *
 * Description      This function sends a ABORT_MDL request to the peer device.
 *                  When the response is received, a MCA_ABORT_CFM_EVT is
 *                  reported.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_Abort(tMCA_CL mcl) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);
  tMCA_DCB* p_dcb;

  MCA_TRACE_API("MCA_Abort: %d", mcl);
  if (p_ccb) {
    result = MCA_NO_RESOURCES;
    /* verify that we are waiting for data channel to come up with the given mdl
     */
    if ((p_ccb->p_tx_req == NULL) || (p_ccb->status != MCA_CCB_STAT_PENDING) ||
        ((p_dcb = mca_dcb_by_hdl(p_ccb->p_tx_req->dcb_idx)) == NULL)) {
      MCA_TRACE_ERROR("The given MCL is not expecting this API:%d",
                      p_ccb->status);
      return result;
    }

    if (p_ccb->cong) {
      MCA_TRACE_ERROR("congested");
      return MCA_BUSY;
    }

    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, mca_ccb_evt);
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_Delete
 *
 * Description      This function sends a DELETE_MDL request to the peer device.
 *                  When the response is received, a MCA_DELETE_CFM_EVT is
 *                  reported.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_Delete(tMCA_CL mcl, uint16_t mdl_id) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_CCB* p_ccb = mca_ccb_by_hdl(mcl);

  MCA_TRACE_API("MCA_Delete: %d ", mcl);
  if (p_ccb) {
    if (p_ccb->cong) {
      MCA_TRACE_ERROR("congested");
      return MCA_BUSY;
    }
    if (!MCA_IS_VALID_MDL_ID(mdl_id) && (mdl_id != MCA_ALL_MDL_ID)) {
      MCA_TRACE_ERROR("bad mdl id: %d ", mdl_id);
      return MCA_BAD_PARAMS;
    }

    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, mca_ccb_evt);
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_WriteReq
 *
 * Description      Send a data packet to the peer device.
 *
 *                  The application passes the packet using the BT_HDR
 *                  structure. The offset field must be equal to or greater than
 *                  L2CAP_MIN_OFFSET. This allows enough space in the buffer for
 *                  the L2CAP header.
 *
 *                  The memory pointed to by p_pkt must be a GKI buffer
 *                  allocated by the application.  This buffer will be freed
 *                  by the protocol stack; the application must not free
 *                  this buffer.
 *
 * Returns          MCA_SUCCESS if successful, otherwise error.
 *
 ******************************************************************************/
tMCA_RESULT MCA_WriteReq(tMCA_DL mdl, BT_HDR* p_pkt) {
  tMCA_RESULT result = MCA_BAD_HANDLE;
  tMCA_DCB* p_dcb = mca_dcb_by_hdl(mdl);
  tMCA_DCB_EVT evt_data;

  MCA_TRACE_API("MCA_WriteReq: %d ", mdl);
  if (p_dcb) {
    if (p_dcb->cong) {
      result = MCA_BUSY;
    } else {
      evt_data.p_pkt = p_pkt;
      result = MCA_SUCCESS;
      mca_dcb_event(p_dcb, MCA_DCB_API_WRITE_EVT, &evt_data);
    }
  }
  return result;
}

/*******************************************************************************
 *
 * Function         MCA_GetL2CapChannel
 *
 * Description      Get the L2CAP CID used by the given data channel handle.
 *
 * Returns          L2CAP channel ID if successful, otherwise 0.
 *
 ******************************************************************************/
uint16_t MCA_GetL2CapChannel(tMCA_DL mdl) {
  uint16_t lcid = 0;
  tMCA_DCB* p_dcb = mca_dcb_by_hdl(mdl);

  MCA_TRACE_API("MCA_GetL2CapChannel: %d ", mdl);
  if (p_dcb) lcid = p_dcb->lcid;
  return lcid;
}

static const btmcap_test_interface_t mcap_test_interface = {
    sizeof(btmcap_test_interface_t),
    MCA_Init,
    MCA_Register,
    MCA_Deregister,
    MCA_CreateDep,
    MCA_DeleteDep,
    MCA_ConnectReq,
    MCA_DisconnectReq,
    MCA_CreateMdl,
    MCA_CreateMdlRsp,
    MCA_CloseReq,
    MCA_ReconnectMdl,
    MCA_ReconnectMdlRsp,
    MCA_DataChnlCfg,
    MCA_Abort,
    MCA_Delete,
    MCA_WriteReq,
    MCA_GetL2CapChannel,
};

const btmcap_test_interface_t* stack_mcap_get_interface(void) {
  BTIF_TRACE_EVENT("%s", __func__);
  return &mcap_test_interface;
}