stack/mcap/mca_dsm.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 Data chahnel state machine.
  *
  ******************************************************************************/
 #include <string.h>

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

 /*****************************************************************************
  * data channel state machine constants and types
  ****************************************************************************/
 enum {
   MCA_DCB_TC_OPEN,
   MCA_DCB_CONG,
   MCA_DCB_FREE_DATA,
   MCA_DCB_DEALLOC,
   MCA_DCB_DO_DISCONN,
   MCA_DCB_SND_DATA,
   MCA_DCB_HDL_DATA,
   MCA_DCB_NUM_ACTIONS
 };
 #define MCA_DCB_IGNORE MCA_DCB_NUM_ACTIONS

 /* action function list */
 const tMCA_DCB_ACTION mca_dcb_action[] = {
     mca_dcb_tc_open,    mca_dcb_cong,     mca_dcb_free_data, mca_dcb_dealloc,
     mca_dcb_do_disconn, mca_dcb_snd_data, mca_dcb_hdl_data};

 /* state table information */
 #define MCA_DCB_ACTIONS 1    /* number of actions */
 #define MCA_DCB_ACT_COL 0    /* position of action function */
 #define MCA_DCB_NEXT_STATE 1 /* position of next state */
 #define MCA_DCB_NUM_COLS 2   /* number of columns in state tables */

 /* state table for opening state */
 const uint8_t mca_dcb_st_opening[][MCA_DCB_NUM_COLS] = {
     /* Event                            Action              Next State */
     /* MCA_DCB_API_CLOSE_EVT    */ {MCA_DCB_DO_DISCONN, MCA_DCB_CLOSING_ST},
     /* MCA_DCB_API_WRITE_EVT    */ {MCA_DCB_IGNORE, MCA_DCB_OPENING_ST},
     /* MCA_DCB_TC_OPEN_EVT      */ {MCA_DCB_TC_OPEN, MCA_DCB_OPEN_ST},
     /* MCA_DCB_TC_CLOSE_EVT     */ {MCA_DCB_DEALLOC, MCA_DCB_NULL_ST},
     /* MCA_DCB_TC_CONG_EVT      */ {MCA_DCB_CONG, MCA_DCB_OPENING_ST},
     /* MCA_DCB_TC_DATA_EVT      */ {MCA_DCB_FREE_DATA, MCA_DCB_OPENING_ST}};

 /* state table for open state */
 const uint8_t mca_dcb_st_open[][MCA_DCB_NUM_COLS] = {
     /* Event                            Action              Next State */
     /* MCA_DCB_API_CLOSE_EVT    */ {MCA_DCB_DO_DISCONN, MCA_DCB_CLOSING_ST},
     /* MCA_DCB_API_WRITE_EVT    */ {MCA_DCB_SND_DATA, MCA_DCB_OPEN_ST},
     /* MCA_DCB_TC_OPEN_EVT      */ {MCA_DCB_IGNORE, MCA_DCB_OPEN_ST},
     /* MCA_DCB_TC_CLOSE_EVT     */ {MCA_DCB_DEALLOC, MCA_DCB_NULL_ST},
     /* MCA_DCB_TC_CONG_EVT      */ {MCA_DCB_CONG, MCA_DCB_OPEN_ST},
     /* MCA_DCB_TC_DATA_EVT      */ {MCA_DCB_HDL_DATA, MCA_DCB_OPEN_ST}};

 /* state table for closing state */
 const uint8_t mca_dcb_st_closing[][MCA_DCB_NUM_COLS] = {
     /* Event                            Action              Next State */
     /* MCA_DCB_API_CLOSE_EVT    */ {MCA_DCB_IGNORE, MCA_DCB_CLOSING_ST},
     /* MCA_DCB_API_WRITE_EVT    */ {MCA_DCB_IGNORE, MCA_DCB_CLOSING_ST},
     /* MCA_DCB_TC_OPEN_EVT      */ {MCA_DCB_TC_OPEN, MCA_DCB_OPEN_ST},
     /* MCA_DCB_TC_CLOSE_EVT     */ {MCA_DCB_DEALLOC, MCA_DCB_NULL_ST},
     /* MCA_DCB_TC_CONG_EVT      */ {MCA_DCB_IGNORE, MCA_DCB_CLOSING_ST},
     /* MCA_DCB_TC_DATA_EVT      */ {MCA_DCB_FREE_DATA, MCA_DCB_CLOSING_ST}};

 /* type for state table */
 typedef const uint8_t (*tMCA_DCB_ST_TBL)[MCA_DCB_NUM_COLS];

 /* state table */
 const tMCA_DCB_ST_TBL mca_dcb_st_tbl[] = {mca_dcb_st_opening, mca_dcb_st_open,
                                           mca_dcb_st_closing};

 /* verbose event strings for trace */
 const char* const mca_dcb_evt_str[] = {"API_CLOSE_EVT", "API_WRITE_EVT",
                                        "TC_OPEN_EVT",   "TC_CLOSE_EVT",
                                        "TC_CONG_EVT",   "TC_DATA_EVT"};
 /* verbose state strings for trace */
 const char* const mca_dcb_st_str[] = {"NULL_ST", "OPENING_ST", "OPEN_ST",
                                       "CLOSING_ST"};

 /*******************************************************************************
  *
  * Function         mca_dcb_event
  *
  * Description      This function is the DCB state machine main function.
  *                  It uses the state and action function tables to execute
  *                  action functions.
  *
  * Returns          void.
  *
  ******************************************************************************/
 void mca_dcb_event(tMCA_DCB* p_dcb, uint8_t event, tMCA_DCB_EVT* p_data) {
   tMCA_DCB_ST_TBL state_table;
   uint8_t action;

   if (p_dcb == NULL) return;
   MCA_TRACE_EVENT("DCB dcb=%d event=%s state=%s", mca_dcb_to_hdl(p_dcb),
                   mca_dcb_evt_str[event], mca_dcb_st_str[p_dcb->state]);

   /* look up the state table for the current state */
   state_table = mca_dcb_st_tbl[p_dcb->state - 1];

   /* set next state */
   p_dcb->state = state_table[event][MCA_DCB_NEXT_STATE];

   /* execute action functions */
   action = state_table[event][MCA_DCB_ACT_COL];
   if (action != MCA_DCB_IGNORE) {
     (*mca_dcb_action[action])(p_dcb, p_data);
   }
 }

 /*******************************************************************************
  *
  * Function         mca_dcb_alloc
  *
  * Description      This function is called to allocate an DCB.
  *                  It initializes the DCB with the data passed to the function.
  *
  * Returns          tMCA_DCB *
  *
  ******************************************************************************/
 tMCA_DCB* mca_dcb_alloc(tMCA_CCB* p_ccb, tMCA_DEP dep) {
   tMCA_DCB *p_dcb = NULL, *p_dcb_tmp;
   tMCA_RCB* p_rcb = p_ccb->p_rcb;
   tMCA_CS* p_cs;
   int i, max;

   if (dep < MCA_NUM_DEPS) {
     p_cs = &p_rcb->dep[dep];
     i = mca_ccb_to_hdl(p_ccb) - 1;
     p_dcb_tmp = &mca_cb.dcb[i * MCA_NUM_MDLS];
     /* make sure p_cs->max_mdl is smaller than MCA_NUM_MDLS at MCA_CreateDep */
     max = p_cs->max_mdl;
     for (i = 0; i < max; i++, p_dcb_tmp++) {
       if (p_dcb_tmp->state == MCA_DCB_NULL_ST) {
         p_dcb_tmp->p_ccb = p_ccb;
         p_dcb_tmp->state = MCA_DCB_OPENING_ST;
         p_dcb_tmp->cong = true;
         p_dcb_tmp->p_cs = p_cs;
         p_dcb = p_dcb_tmp;
         break;
       }
     }
   }
   return p_dcb;
 }

 /*******************************************************************************
  *
  * Function         mca_dep_free_mdl
  *
  * Description      This function is called to check the number of free mdl for
  *                  the given dep.
  *
  * Returns          the number of free mdl for the given dep
  *
  ******************************************************************************/
 uint8_t mca_dep_free_mdl(tMCA_CCB* p_ccb, tMCA_DEP dep) {
   tMCA_DCB* p_dcb;
   tMCA_RCB* p_rcb = p_ccb->p_rcb;
   tMCA_CS* p_cs;
   int i, max;
   uint8_t count = 0;
   uint8_t left;

   if (dep < MCA_NUM_DEPS) {
     p_cs = &p_rcb->dep[dep];
     i = mca_ccb_to_hdl(p_ccb) - 1;
     p_dcb = &mca_cb.dcb[i * MCA_NUM_MDLS];
     /* make sure p_cs->max_mdl is smaller than MCA_NUM_MDLS at MCA_CreateDep */
     max = p_cs->max_mdl;
     for (i = 0; i < max; i++, p_dcb++) {
       if ((p_dcb->state != MCA_DCB_NULL_ST) && (p_dcb->p_cs == p_cs)) {
         count++;
         break;
       }
     }
   } else {
     max = 0;
     MCA_TRACE_WARNING("Invalid Dep ID");
   }
   left = max - count;
   return left;
 }

 /*******************************************************************************
  *
  * Function         mca_dcb_dealloc
  *
  * Description      This function deallocates an DCB.
  *
  * Returns          void.
  *
  ******************************************************************************/
 void mca_dcb_dealloc(tMCA_DCB* p_dcb, tMCA_DCB_EVT* p_data) {
   tMCA_CCB* p_ccb = p_dcb->p_ccb;
   uint8_t event = MCA_CLOSE_IND_EVT;
   tMCA_CTRL evt_data;

   MCA_TRACE_DEBUG("mca_dcb_dealloc");
   osi_free_and_reset((void**)&p_dcb->p_data);
   if (p_data) {
     /* non-NULL -> an action function -> report disconnect event */
     evt_data.close_cfm.mdl = mca_dcb_to_hdl(p_dcb);
     evt_data.close_cfm.reason = p_data->close.reason;
     evt_data.close_cfm.mdl_id = p_dcb->mdl_id;
     if (p_data->close.param == MCA_INT) event = MCA_CLOSE_CFM_EVT;
     if (p_data->close.lcid) mca_ccb_report_event(p_ccb, event, &evt_data);
   }
   mca_free_tc_tbl_by_lcid(p_dcb->lcid);
   memset(p_dcb, 0, sizeof(tMCA_DCB));
 }

 /*******************************************************************************
  *
  * Function         mca_dcb_to_hdl
  *
  * Description      Convert a pointer to a DCB to a handle (tMCA_DL).
  *                  It returns the handle.
  *
  * Returns          tMCA_DL.
  *
  ******************************************************************************/
 tMCA_DL mca_dcb_to_hdl(tMCA_DCB* p_dcb) {
   return (uint8_t)(p_dcb - mca_cb.dcb + 1);
 }

 /*******************************************************************************
  *
  * Function         mca_dcb_by_hdl
  *
  * Description      This function finds the DCB for a handle (tMCA_DL).
  *                  It returns a pointer to the DCB.
  *                  If no DCB matches the handle it returns NULL.
  *
  * Returns          tMCA_DCB *
  *
  ******************************************************************************/
 tMCA_DCB* mca_dcb_by_hdl(tMCA_DL hdl) {
   tMCA_DCB* p_dcb = NULL;
   if (hdl && hdl <= MCA_NUM_DCBS && mca_cb.dcb[hdl - 1].state)
     p_dcb = &mca_cb.dcb[hdl - 1];
   return p_dcb;
 }

 /*******************************************************************************
  *
  * Function         mca_dcb_close_by_mdl_id
  *
  * Description      This function finds the DCB for a mdl_id and
  *                  disconnect the mdl
  *
  * Returns          void
  *
  ******************************************************************************/
 void mca_dcb_close_by_mdl_id(tMCA_CCB* p_ccb, uint16_t mdl_id) {
   tMCA_DCB* p_dcb;
   int i;

   MCA_TRACE_DEBUG("mca_dcb_close_by_mdl_id mdl_id=%d", mdl_id);
   i = mca_ccb_to_hdl(p_ccb) - 1;
   p_dcb = &mca_cb.dcb[i * MCA_NUM_MDLS];
   for (i = 0; i < MCA_NUM_MDLS; i++, p_dcb++) {
     if (p_dcb->state) {
       if (p_dcb->mdl_id == mdl_id) {
         mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
         break;
       } else if (mdl_id == MCA_ALL_MDL_ID) {
         mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
       }
     }
   }
 }
	/******************************************************************************
	*
	* 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 Data chahnel state machine.
	*
	******************************************************************************/
	#include <string.h>

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

	/*****************************************************************************
	* data channel state machine constants and types
	****************************************************************************/
	enum {
	MCA_DCB_TC_OPEN,
	MCA_DCB_CONG,
	MCA_DCB_FREE_DATA,
	MCA_DCB_DEALLOC,
	MCA_DCB_DO_DISCONN,
	MCA_DCB_SND_DATA,
	MCA_DCB_HDL_DATA,
	MCA_DCB_NUM_ACTIONS
	};
	#define MCA_DCB_IGNORE MCA_DCB_NUM_ACTIONS

	/* action function list */
	const tMCA_DCB_ACTION mca_dcb_action[] = {
	mca_dcb_tc_open, mca_dcb_cong, mca_dcb_free_data, mca_dcb_dealloc,
	mca_dcb_do_disconn, mca_dcb_snd_data, mca_dcb_hdl_data};

	/* state table information */
	#define MCA_DCB_ACTIONS 1 /* number of actions */
	#define MCA_DCB_ACT_COL 0 /* position of action function */
	#define MCA_DCB_NEXT_STATE 1 /* position of next state */
	#define MCA_DCB_NUM_COLS 2 /* number of columns in state tables */

	/* state table for opening state */
	const uint8_t mca_dcb_st_opening[][MCA_DCB_NUM_COLS] = {
	/* Event Action Next State */
	/* MCA_DCB_API_CLOSE_EVT */ {MCA_DCB_DO_DISCONN, MCA_DCB_CLOSING_ST},
	/* MCA_DCB_API_WRITE_EVT */ {MCA_DCB_IGNORE, MCA_DCB_OPENING_ST},
	/* MCA_DCB_TC_OPEN_EVT */ {MCA_DCB_TC_OPEN, MCA_DCB_OPEN_ST},
	/* MCA_DCB_TC_CLOSE_EVT */ {MCA_DCB_DEALLOC, MCA_DCB_NULL_ST},
	/* MCA_DCB_TC_CONG_EVT */ {MCA_DCB_CONG, MCA_DCB_OPENING_ST},
	/* MCA_DCB_TC_DATA_EVT */ {MCA_DCB_FREE_DATA, MCA_DCB_OPENING_ST}};

	/* state table for open state */
	const uint8_t mca_dcb_st_open[][MCA_DCB_NUM_COLS] = {
	/* Event Action Next State */
	/* MCA_DCB_API_CLOSE_EVT */ {MCA_DCB_DO_DISCONN, MCA_DCB_CLOSING_ST},
	/* MCA_DCB_API_WRITE_EVT */ {MCA_DCB_SND_DATA, MCA_DCB_OPEN_ST},
	/* MCA_DCB_TC_OPEN_EVT */ {MCA_DCB_IGNORE, MCA_DCB_OPEN_ST},
	/* MCA_DCB_TC_CLOSE_EVT */ {MCA_DCB_DEALLOC, MCA_DCB_NULL_ST},
	/* MCA_DCB_TC_CONG_EVT */ {MCA_DCB_CONG, MCA_DCB_OPEN_ST},
	/* MCA_DCB_TC_DATA_EVT */ {MCA_DCB_HDL_DATA, MCA_DCB_OPEN_ST}};

	/* state table for closing state */
	const uint8_t mca_dcb_st_closing[][MCA_DCB_NUM_COLS] = {
	/* Event Action Next State */
	/* MCA_DCB_API_CLOSE_EVT */ {MCA_DCB_IGNORE, MCA_DCB_CLOSING_ST},
	/* MCA_DCB_API_WRITE_EVT */ {MCA_DCB_IGNORE, MCA_DCB_CLOSING_ST},
	/* MCA_DCB_TC_OPEN_EVT */ {MCA_DCB_TC_OPEN, MCA_DCB_OPEN_ST},
	/* MCA_DCB_TC_CLOSE_EVT */ {MCA_DCB_DEALLOC, MCA_DCB_NULL_ST},
	/* MCA_DCB_TC_CONG_EVT */ {MCA_DCB_IGNORE, MCA_DCB_CLOSING_ST},
	/* MCA_DCB_TC_DATA_EVT */ {MCA_DCB_FREE_DATA, MCA_DCB_CLOSING_ST}};

	/* type for state table */
	typedef const uint8_t (*tMCA_DCB_ST_TBL)[MCA_DCB_NUM_COLS];

	/* state table */
	const tMCA_DCB_ST_TBL mca_dcb_st_tbl[] = {mca_dcb_st_opening, mca_dcb_st_open,
	mca_dcb_st_closing};

	/* verbose event strings for trace */
	const char* const mca_dcb_evt_str[] = {"API_CLOSE_EVT", "API_WRITE_EVT",
	"TC_OPEN_EVT", "TC_CLOSE_EVT",
	"TC_CONG_EVT", "TC_DATA_EVT"};
	/* verbose state strings for trace */
	const char* const mca_dcb_st_str[] = {"NULL_ST", "OPENING_ST", "OPEN_ST",
	"CLOSING_ST"};

	/*******************************************************************************
	*
	* Function mca_dcb_event
	*
	* Description This function is the DCB state machine main function.
	* It uses the state and action function tables to execute
	* action functions.
	*
	* Returns void.
	*
	******************************************************************************/
	void mca_dcb_event(tMCA_DCB* p_dcb, uint8_t event, tMCA_DCB_EVT* p_data) {
	tMCA_DCB_ST_TBL state_table;
	uint8_t action;

	if (p_dcb == NULL) return;
	MCA_TRACE_EVENT("DCB dcb=%d event=%s state=%s", mca_dcb_to_hdl(p_dcb),
	mca_dcb_evt_str[event], mca_dcb_st_str[p_dcb->state]);

	/* look up the state table for the current state */
	state_table = mca_dcb_st_tbl[p_dcb->state - 1];

	/* set next state */
	p_dcb->state = state_table[event][MCA_DCB_NEXT_STATE];

	/* execute action functions */
	action = state_table[event][MCA_DCB_ACT_COL];
	if (action != MCA_DCB_IGNORE) {
	(*mca_dcb_action[action])(p_dcb, p_data);
	}
	}

	/*******************************************************************************
	*
	* Function mca_dcb_alloc
	*
	* Description This function is called to allocate an DCB.
	* It initializes the DCB with the data passed to the function.
	*
	* Returns tMCA_DCB *
	*
	******************************************************************************/
	tMCA_DCB* mca_dcb_alloc(tMCA_CCB* p_ccb, tMCA_DEP dep) {
	tMCA_DCB p_dcb = NULL, p_dcb_tmp;
	tMCA_RCB* p_rcb = p_ccb->p_rcb;
	tMCA_CS* p_cs;
	int i, max;

	if (dep < MCA_NUM_DEPS) {
	p_cs = &p_rcb->dep[dep];
	i = mca_ccb_to_hdl(p_ccb) - 1;
	p_dcb_tmp = &mca_cb.dcb[i * MCA_NUM_MDLS];
	/* make sure p_cs->max_mdl is smaller than MCA_NUM_MDLS at MCA_CreateDep */
	max = p_cs->max_mdl;
	for (i = 0; i < max; i++, p_dcb_tmp++) {
	if (p_dcb_tmp->state == MCA_DCB_NULL_ST) {
	p_dcb_tmp->p_ccb = p_ccb;
	p_dcb_tmp->state = MCA_DCB_OPENING_ST;
	p_dcb_tmp->cong = true;
	p_dcb_tmp->p_cs = p_cs;
	p_dcb = p_dcb_tmp;
	break;
	}
	}
	}
	return p_dcb;
	}

	/*******************************************************************************
	*
	* Function mca_dep_free_mdl
	*
	* Description This function is called to check the number of free mdl for
	* the given dep.
	*
	* Returns the number of free mdl for the given dep
	*
	******************************************************************************/
	uint8_t mca_dep_free_mdl(tMCA_CCB* p_ccb, tMCA_DEP dep) {
	tMCA_DCB* p_dcb;
	tMCA_RCB* p_rcb = p_ccb->p_rcb;
	tMCA_CS* p_cs;
	int i, max;
	uint8_t count = 0;
	uint8_t left;

	if (dep < MCA_NUM_DEPS) {
	p_cs = &p_rcb->dep[dep];
	i = mca_ccb_to_hdl(p_ccb) - 1;
	p_dcb = &mca_cb.dcb[i * MCA_NUM_MDLS];
	/* make sure p_cs->max_mdl is smaller than MCA_NUM_MDLS at MCA_CreateDep */
	max = p_cs->max_mdl;
	for (i = 0; i < max; i++, p_dcb++) {
	if ((p_dcb->state != MCA_DCB_NULL_ST) && (p_dcb->p_cs == p_cs)) {
	count++;
	break;
	}
	}
	} else {
	max = 0;
	MCA_TRACE_WARNING("Invalid Dep ID");
	}
	left = max - count;
	return left;
	}

	/*******************************************************************************
	*
	* Function mca_dcb_dealloc
	*
	* Description This function deallocates an DCB.
	*
	* Returns void.
	*
	******************************************************************************/
	void mca_dcb_dealloc(tMCA_DCB* p_dcb, tMCA_DCB_EVT* p_data) {
	tMCA_CCB* p_ccb = p_dcb->p_ccb;
	uint8_t event = MCA_CLOSE_IND_EVT;
	tMCA_CTRL evt_data;

	MCA_TRACE_DEBUG("mca_dcb_dealloc");
	osi_free_and_reset((void**)&p_dcb->p_data);
	if (p_data) {
	/* non-NULL -> an action function -> report disconnect event */
	evt_data.close_cfm.mdl = mca_dcb_to_hdl(p_dcb);
	evt_data.close_cfm.reason = p_data->close.reason;
	evt_data.close_cfm.mdl_id = p_dcb->mdl_id;
	if (p_data->close.param == MCA_INT) event = MCA_CLOSE_CFM_EVT;
	if (p_data->close.lcid) mca_ccb_report_event(p_ccb, event, &evt_data);
	}
	mca_free_tc_tbl_by_lcid(p_dcb->lcid);
	memset(p_dcb, 0, sizeof(tMCA_DCB));
	}

	/*******************************************************************************
	*
	* Function mca_dcb_to_hdl
	*
	* Description Convert a pointer to a DCB to a handle (tMCA_DL).
	* It returns the handle.
	*
	* Returns tMCA_DL.
	*
	******************************************************************************/
	tMCA_DL mca_dcb_to_hdl(tMCA_DCB* p_dcb) {
	return (uint8_t)(p_dcb - mca_cb.dcb + 1);
	}

	/*******************************************************************************
	*
	* Function mca_dcb_by_hdl
	*
	* Description This function finds the DCB for a handle (tMCA_DL).
	* It returns a pointer to the DCB.
	* If no DCB matches the handle it returns NULL.
	*
	* Returns tMCA_DCB *
	*
	******************************************************************************/
	tMCA_DCB* mca_dcb_by_hdl(tMCA_DL hdl) {
	tMCA_DCB* p_dcb = NULL;
	if (hdl && hdl <= MCA_NUM_DCBS && mca_cb.dcb[hdl - 1].state)
	p_dcb = &mca_cb.dcb[hdl - 1];
	return p_dcb;
	}

	/*******************************************************************************
	*
	* Function mca_dcb_close_by_mdl_id
	*
	* Description This function finds the DCB for a mdl_id and
	* disconnect the mdl
	*
	* Returns void
	*
	******************************************************************************/
	void mca_dcb_close_by_mdl_id(tMCA_CCB* p_ccb, uint16_t mdl_id) {
	tMCA_DCB* p_dcb;
	int i;

	MCA_TRACE_DEBUG("mca_dcb_close_by_mdl_id mdl_id=%d", mdl_id);
	i = mca_ccb_to_hdl(p_ccb) - 1;
	p_dcb = &mca_cb.dcb[i * MCA_NUM_MDLS];
	for (i = 0; i < MCA_NUM_MDLS; i++, p_dcb++) {
	if (p_dcb->state) {
	if (p_dcb->mdl_id == mdl_id) {
	mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
	break;
	} else if (mdl_id == MCA_ALL_MDL_ID) {
	mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
	}
	}
	}
	}