Home | History | Annotate | Download | only in mcap
      1 /******************************************************************************
      2  *
      3  *  Copyright (C) 2009-2012 Broadcom Corporation
      4  *
      5  *  Licensed under the Apache License, Version 2.0 (the "License");
      6  *  you may not use this file except in compliance with the License.
      7  *  You may obtain a copy of the License at:
      8  *
      9  *  http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  *  Unless required by applicable law or agreed to in writing, software
     12  *  distributed under the License is distributed on an "AS IS" BASIS,
     13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  *  See the License for the specific language governing permissions and
     15  *  limitations under the License.
     16  *
     17  ******************************************************************************/
     18 
     19 /******************************************************************************
     20  *
     21  *  This is the implementation file for the MCAP Data chahnel state machine.
     22  *
     23  ******************************************************************************/
     24 #include <string.h>
     25 
     26 #include "bt_target.h"
     27 #include "mca_api.h"
     28 #include "mca_defs.h"
     29 #include "mca_int.h"
     30 
     31 /*****************************************************************************
     32 ** data channel state machine constants and types
     33 *****************************************************************************/
     34 enum
     35 {
     36     MCA_DCB_TC_OPEN,
     37     MCA_DCB_CONG,
     38     MCA_DCB_FREE_DATA,
     39     MCA_DCB_DEALLOC,
     40     MCA_DCB_DO_DISCONN,
     41     MCA_DCB_SND_DATA,
     42     MCA_DCB_HDL_DATA,
     43     MCA_DCB_NUM_ACTIONS
     44 };
     45 #define MCA_DCB_IGNORE     MCA_DCB_NUM_ACTIONS
     46 
     47 /* action function list */
     48 const tMCA_DCB_ACTION mca_dcb_action[] = {
     49     mca_dcb_tc_open,
     50     mca_dcb_cong,
     51     mca_dcb_free_data,
     52     mca_dcb_dealloc,
     53     mca_dcb_do_disconn,
     54     mca_dcb_snd_data,
     55     mca_dcb_hdl_data
     56 };
     57 
     58 /* state table information */
     59 #define MCA_DCB_ACTIONS            1       /* number of actions */
     60 #define MCA_DCB_ACT_COL            0       /* position of action function */
     61 #define MCA_DCB_NEXT_STATE         1       /* position of next state */
     62 #define MCA_DCB_NUM_COLS           2       /* number of columns in state tables */
     63 
     64 /* state table for opening state */
     65 const UINT8 mca_dcb_st_opening[][MCA_DCB_NUM_COLS] = {
     66 /* Event                            Action              Next State */
     67 /* MCA_DCB_API_CLOSE_EVT    */   {MCA_DCB_DO_DISCONN,   MCA_DCB_CLOSING_ST},
     68 /* MCA_DCB_API_WRITE_EVT    */   {MCA_DCB_IGNORE,       MCA_DCB_OPENING_ST},
     69 /* MCA_DCB_TC_OPEN_EVT      */   {MCA_DCB_TC_OPEN,      MCA_DCB_OPEN_ST},
     70 /* MCA_DCB_TC_CLOSE_EVT     */   {MCA_DCB_DEALLOC,      MCA_DCB_NULL_ST},
     71 /* MCA_DCB_TC_CONG_EVT      */   {MCA_DCB_CONG,         MCA_DCB_OPENING_ST},
     72 /* MCA_DCB_TC_DATA_EVT      */   {MCA_DCB_FREE_DATA,    MCA_DCB_OPENING_ST}
     73 };
     74 
     75 /* state table for open state */
     76 const UINT8 mca_dcb_st_open[][MCA_DCB_NUM_COLS] = {
     77 /* Event                            Action              Next State */
     78 /* MCA_DCB_API_CLOSE_EVT    */   {MCA_DCB_DO_DISCONN,   MCA_DCB_CLOSING_ST},
     79 /* MCA_DCB_API_WRITE_EVT    */   {MCA_DCB_SND_DATA,     MCA_DCB_OPEN_ST},
     80 /* MCA_DCB_TC_OPEN_EVT      */   {MCA_DCB_IGNORE,       MCA_DCB_OPEN_ST},
     81 /* MCA_DCB_TC_CLOSE_EVT     */   {MCA_DCB_DEALLOC,      MCA_DCB_NULL_ST},
     82 /* MCA_DCB_TC_CONG_EVT      */   {MCA_DCB_CONG,         MCA_DCB_OPEN_ST},
     83 /* MCA_DCB_TC_DATA_EVT      */   {MCA_DCB_HDL_DATA,     MCA_DCB_OPEN_ST}
     84 };
     85 
     86 /* state table for closing state */
     87 const UINT8 mca_dcb_st_closing[][MCA_DCB_NUM_COLS] = {
     88 /* Event                            Action              Next State */
     89 /* MCA_DCB_API_CLOSE_EVT    */   {MCA_DCB_IGNORE,       MCA_DCB_CLOSING_ST},
     90 /* MCA_DCB_API_WRITE_EVT    */   {MCA_DCB_IGNORE,       MCA_DCB_CLOSING_ST},
     91 /* MCA_DCB_TC_OPEN_EVT      */   {MCA_DCB_TC_OPEN,      MCA_DCB_OPEN_ST},
     92 /* MCA_DCB_TC_CLOSE_EVT     */   {MCA_DCB_DEALLOC,      MCA_DCB_NULL_ST},
     93 /* MCA_DCB_TC_CONG_EVT      */   {MCA_DCB_IGNORE,       MCA_DCB_CLOSING_ST},
     94 /* MCA_DCB_TC_DATA_EVT      */   {MCA_DCB_FREE_DATA,    MCA_DCB_CLOSING_ST}
     95 };
     96 
     97 /* type for state table */
     98 typedef const UINT8 (*tMCA_DCB_ST_TBL)[MCA_DCB_NUM_COLS];
     99 
    100 /* state table */
    101 const tMCA_DCB_ST_TBL mca_dcb_st_tbl[] = {
    102     mca_dcb_st_opening,
    103     mca_dcb_st_open,
    104     mca_dcb_st_closing
    105 };
    106 
    107 #if (BT_TRACE_VERBOSE == TRUE)
    108 /* verbose event strings for trace */
    109 const char * const mca_dcb_evt_str[] = {
    110     "API_CLOSE_EVT",
    111     "API_WRITE_EVT",
    112     "TC_OPEN_EVT",
    113     "TC_CLOSE_EVT",
    114     "TC_CONG_EVT",
    115     "TC_DATA_EVT"
    116 };
    117 /* verbose state strings for trace */
    118 const char * const mca_dcb_st_str[] = {
    119     "NULL_ST",
    120     "OPENING_ST",
    121     "OPEN_ST",
    122     "CLOSING_ST"
    123 };
    124 #endif
    125 
    126 /*******************************************************************************
    127 **
    128 ** Function         mca_dcb_event
    129 **
    130 ** Description      This function is the DCB state machine main function.
    131 **                  It uses the state and action function tables to execute
    132 **                  action functions.
    133 **
    134 ** Returns          void.
    135 **
    136 *******************************************************************************/
    137 void mca_dcb_event(tMCA_DCB *p_dcb, UINT8 event, tMCA_DCB_EVT *p_data)
    138 {
    139     tMCA_DCB_ST_TBL    state_table;
    140     UINT8              action;
    141 
    142     if (p_dcb == NULL)
    143         return;
    144 #if (BT_TRACE_VERBOSE == TRUE)
    145     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]);
    146 #else
    147     MCA_TRACE_EVENT("DCB dcb=%d event=%d state=%d", mca_dcb_to_hdl(p_dcb), event, p_dcb->state);
    148 #endif
    149 
    150     /* look up the state table for the current state */
    151     state_table = mca_dcb_st_tbl[p_dcb->state - 1];
    152 
    153     /* set next state */
    154     p_dcb->state = state_table[event][MCA_DCB_NEXT_STATE];
    155 
    156     /* execute action functions */
    157     if ((action = state_table[event][MCA_DCB_ACT_COL]) != MCA_DCB_IGNORE)
    158     {
    159         (*mca_dcb_action[action])(p_dcb, p_data);
    160     }
    161 }
    162 
    163 /*******************************************************************************
    164 **
    165 ** Function         mca_dcb_alloc
    166 **
    167 ** Description      This function is called to allocate an DCB.
    168 **                  It initializes the DCB with the data passed to the function.
    169 **
    170 ** Returns          tMCA_DCB *
    171 **
    172 *******************************************************************************/
    173 tMCA_DCB *mca_dcb_alloc(tMCA_CCB*p_ccb, tMCA_DEP dep)
    174 {
    175     tMCA_DCB *p_dcb = NULL, *p_dcb_tmp;
    176     tMCA_RCB *p_rcb = p_ccb->p_rcb;
    177     tMCA_CS  *p_cs;
    178     int       i, max;
    179 
    180     if (dep < MCA_NUM_DEPS)
    181     {
    182         p_cs = &p_rcb->dep[dep];
    183         i = mca_ccb_to_hdl(p_ccb)-1;
    184         p_dcb_tmp = &mca_cb.dcb[i*MCA_NUM_MDLS];
    185         /* make sure p_cs->max_mdl is smaller than MCA_NUM_MDLS at MCA_CreateDep */
    186         max = p_cs->max_mdl;
    187         for (i=0; i<max; i++, p_dcb_tmp++)
    188         {
    189             if (p_dcb_tmp->state == MCA_DCB_NULL_ST)
    190             {
    191                 p_dcb_tmp->p_ccb = p_ccb;
    192                 p_dcb_tmp->state = MCA_DCB_OPENING_ST;
    193                 p_dcb_tmp->cong  = TRUE;
    194                 p_dcb_tmp->p_cs  = p_cs;
    195                 p_dcb = p_dcb_tmp;
    196                 break;
    197             }
    198         }
    199     }
    200     return p_dcb;
    201 }
    202 
    203 /*******************************************************************************
    204 **
    205 ** Function         mca_dep_free_mdl
    206 **
    207 ** Description      This function is called to check the number of free mdl for
    208 **                  the given dep.
    209 **
    210 ** Returns          the number of free mdl for the given dep
    211 **
    212 *******************************************************************************/
    213 UINT8 mca_dep_free_mdl(tMCA_CCB *p_ccb, tMCA_DEP dep)
    214 {
    215     tMCA_DCB *p_dcb;
    216     tMCA_RCB *p_rcb = p_ccb->p_rcb;
    217     tMCA_CS  *p_cs;
    218     int       i, max;
    219     UINT8   count = 0;
    220     UINT8   left;
    221 
    222     if (dep < MCA_NUM_DEPS)
    223     {
    224         p_cs = &p_rcb->dep[dep];
    225         i = mca_ccb_to_hdl(p_ccb)-1;
    226         p_dcb = &mca_cb.dcb[i * MCA_NUM_MDLS];
    227         /* make sure p_cs->max_mdl is smaller than MCA_NUM_MDLS at MCA_CreateDep */
    228         max = p_cs->max_mdl;
    229         for (i=0; i<max; i++, p_dcb++)
    230         {
    231             if ((p_dcb->state != MCA_DCB_NULL_ST) && (p_dcb->p_cs == p_cs))
    232             {
    233                 count++;
    234                 break;
    235             }
    236         }
    237     }
    238     else
    239     {
    240         max = 0;
    241         MCA_TRACE_WARNING("Invalid Dep ID");
    242     }
    243     left = max - count;
    244     return left;
    245 }
    246 
    247 /*******************************************************************************
    248 **
    249 ** Function         mca_dcb_dealloc
    250 **
    251 ** Description      This function deallocates an DCB.
    252 **
    253 ** Returns          void.
    254 **
    255 *******************************************************************************/
    256 void mca_dcb_dealloc(tMCA_DCB *p_dcb, tMCA_DCB_EVT *p_data)
    257 {
    258     tMCA_CCB *p_ccb = p_dcb->p_ccb;
    259     UINT8    event = MCA_CLOSE_IND_EVT;
    260     tMCA_CTRL   evt_data;
    261 
    262     MCA_TRACE_DEBUG("mca_dcb_dealloc");
    263     osi_free_and_reset((void **)&p_dcb->p_data);
    264     if (p_data)
    265     {
    266         /* non-NULL -> an action function -> report disconnect event */
    267         evt_data.close_cfm.mdl      = mca_dcb_to_hdl(p_dcb);
    268         evt_data.close_cfm.reason   = p_data->close.reason;
    269         evt_data.close_cfm.mdl_id   = p_dcb->mdl_id;
    270         if (p_data->close.param == MCA_INT)
    271             event = MCA_CLOSE_CFM_EVT;
    272         if (p_data->close.lcid)
    273             mca_ccb_report_event(p_ccb, event, &evt_data);
    274     }
    275     mca_free_tc_tbl_by_lcid (p_dcb->lcid);
    276     memset (p_dcb, 0, sizeof (tMCA_DCB));
    277 }
    278 
    279 /*******************************************************************************
    280 **
    281 ** Function         mca_dcb_to_hdl
    282 **
    283 ** Description      This function converts a pointer to an DCB to a handle (tMCA_DL).
    284 **                  It returns the handle.
    285 **
    286 ** Returns          tMCA_DL.
    287 **
    288 *******************************************************************************/
    289 tMCA_DL mca_dcb_to_hdl(tMCA_DCB *p_dcb)
    290 {
    291     return (UINT8) (p_dcb - mca_cb.dcb + 1);
    292 }
    293 
    294 /*******************************************************************************
    295 **
    296 ** Function         mca_dcb_by_hdl
    297 **
    298 ** Description      This function finds the DCB for a handle (tMCA_DL).
    299 **                  It returns a pointer to the DCB.
    300 **                  If no DCB matches the handle it returns NULL.
    301 **
    302 ** Returns          tMCA_DCB *
    303 **
    304 *******************************************************************************/
    305 tMCA_DCB *mca_dcb_by_hdl(tMCA_DL hdl)
    306 {
    307     tMCA_DCB * p_dcb = NULL;
    308     if (hdl && hdl <= MCA_NUM_DCBS && mca_cb.dcb[hdl-1].state)
    309         p_dcb = &mca_cb.dcb[hdl-1];
    310     return p_dcb;
    311 }
    312 
    313 /*******************************************************************************
    314 **
    315 ** Function         mca_dcb_close_by_mdl_id
    316 **
    317 ** Description      This function finds the DCB for a mdl_id and
    318 **                  disconnect the mdl
    319 **
    320 ** Returns          void
    321 **
    322 *******************************************************************************/
    323 void mca_dcb_close_by_mdl_id(tMCA_CCB*p_ccb, UINT16 mdl_id)
    324 {
    325     tMCA_DCB *p_dcb;
    326     int       i;
    327 
    328     MCA_TRACE_DEBUG("mca_dcb_close_by_mdl_id mdl_id=%d", mdl_id);
    329     i = mca_ccb_to_hdl(p_ccb)-1;
    330     p_dcb = &mca_cb.dcb[i*MCA_NUM_MDLS];
    331     for (i=0; i<MCA_NUM_MDLS; i++, p_dcb++)
    332     {
    333         if (p_dcb->state)
    334         {
    335             if (p_dcb->mdl_id == mdl_id)
    336             {
    337                 mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
    338                 break;
    339             }
    340             else if (mdl_id == MCA_ALL_MDL_ID)
    341             {
    342                 mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL);
    343             }
    344         }
    345     }
    346 }
    347