android-8.1.0_r81/s

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