stack/mcap/mca_dsm.cc

   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_t 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_t 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_t 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_t (*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_t event, tMCA_DCB_EVT *p_data)
 138 {
 139     tMCA_DCB_ST_TBL    state_table;
 140     uint8_t            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_t 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_t count = 0;
 220     uint8_t 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_t  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_t) (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_t 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 }