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