370 lines
12 KiB
C
370 lines
12 KiB
C
/******************************************************************************
|
|
*
|
|
* 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 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 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 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 (*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
|
|
};
|
|
|
|
#if (BT_TRACE_VERBOSE == TRUE)
|
|
/* 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"
|
|
};
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** 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 event, tMCA_DCB_EVT *p_data)
|
|
{
|
|
tMCA_DCB_ST_TBL state_table;
|
|
UINT8 action;
|
|
|
|
if (p_dcb == NULL)
|
|
return;
|
|
#if (BT_TRACE_VERBOSE == TRUE)
|
|
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]);
|
|
#else
|
|
MCA_TRACE_EVENT("DCB dcb=%d event=%d state=%d", mca_dcb_to_hdl(p_dcb), event, p_dcb->state);
|
|
#endif
|
|
|
|
/* 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 */
|
|
if ((action = state_table[event][MCA_DCB_ACT_COL]) < 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;
|
|
unsigned int i, max;
|
|
|
|
if (dep < MCA_NUM_DEPS)
|
|
{
|
|
p_cs = &p_rcb->dep[dep];
|
|
i = mca_ccb_to_hdl(p_ccb)-1;
|
|
if( i*MCA_NUM_MDLS < MCA_NUM_DCBS)
|
|
{
|
|
p_dcb_tmp = &mca_cb.dcb[i*MCA_NUM_MDLS];
|
|
}
|
|
else
|
|
{
|
|
MCA_TRACE_WARNING("dcb index out of range");
|
|
return NULL;
|
|
}
|
|
/* 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 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;
|
|
unsigned int i, max;
|
|
UINT8 count = 0;
|
|
UINT8 left;
|
|
|
|
if (dep < MCA_NUM_DEPS)
|
|
{
|
|
p_cs = &p_rcb->dep[dep];
|
|
i = mca_ccb_to_hdl(p_ccb)-1;
|
|
if( i*MCA_NUM_MDLS < MCA_NUM_DCBS)
|
|
{
|
|
p_dcb = &mca_cb.dcb[i * MCA_NUM_MDLS];
|
|
}
|
|
else
|
|
{
|
|
MCA_TRACE_WARNING("dcb index out of range");
|
|
return 0;
|
|
}
|
|
/* 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 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 This function converts a pointer to an 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) (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 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;
|
|
if( i*MCA_NUM_MDLS < MCA_NUM_DCBS)
|
|
{
|
|
p_dcb = &mca_cb.dcb[i * MCA_NUM_MDLS];
|
|
}
|
|
else
|
|
{
|
|
MCA_TRACE_WARNING("dcb index out of range");
|
|
return;
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|