bta/pan/bta_pan_main.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2004-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 file contains the PAN main functions and state machine.
  22  *
  23  ******************************************************************************/
  24
  25 #include "bt_target.h"
  26
  27 #if defined(BTA_PAN_INCLUDED) && (BTA_PAN_INCLUDED == TRUE)
  28
  29 #include <string.h>
  30 #include "bta_api.h"
  31 #include "bta_sys.h"
  32 #include "bt_common.h"
  33 #include "pan_api.h"
  34 #include "bta_pan_api.h"
  35 #include "bta_pan_int.h"
  36 #include "utl.h"
  37
  38 /*****************************************************************************
  39 ** Constants and types
  40 *****************************************************************************/
  41
  42
  43
  44 /* state machine action enumeration list */
  45 enum
  46 {
  47     BTA_PAN_API_CLOSE,
  48     BTA_PAN_TX_PATH,
  49     BTA_PAN_RX_PATH,
  50     BTA_PAN_TX_FLOW,
  51     BTA_PAN_WRITE_BUF,
  52     BTA_PAN_CONN_OPEN,
  53     BTA_PAN_CONN_CLOSE,
  54     BTA_PAN_FREE_BUF,
  55     BTA_PAN_IGNORE
  56 };
  57
  58
  59
  60 /* type for action functions */
  61 typedef void (*tBTA_PAN_ACTION)(tBTA_PAN_SCB *p_scb, tBTA_PAN_DATA *p_data);
  62
  63
  64
  65
  66 /* action function list */
  67 const tBTA_PAN_ACTION bta_pan_action[] =
  68 {
  69     bta_pan_api_close,
  70     bta_pan_tx_path,
  71     bta_pan_rx_path,
  72     bta_pan_tx_flow,
  73     bta_pan_write_buf,
  74     bta_pan_conn_open,
  75     bta_pan_conn_close,
  76     bta_pan_free_buf,
  77
  78 };
  79
  80 /* state table information */
  81 #define BTA_PAN_ACTIONS              1       /* number of actions */
  82 #define BTA_PAN_NEXT_STATE           1       /* position of next state */
  83 #define BTA_PAN_NUM_COLS             2       /* number of columns in state tables */
  84
  85
  86
  87 /* state table for listen state */
  88 const UINT8 bta_pan_st_idle[][BTA_PAN_NUM_COLS] =
  89 {
  90    /* API_CLOSE */          {BTA_PAN_API_CLOSE,              BTA_PAN_IDLE_ST},
  91    /* CI_TX_READY */        {BTA_PAN_IGNORE,                 BTA_PAN_IDLE_ST},
  92    /* CI_RX_READY */        {BTA_PAN_IGNORE,                 BTA_PAN_IDLE_ST},
  93    /* CI_TX_FLOW */         {BTA_PAN_IGNORE,                 BTA_PAN_IDLE_ST},
  94    /* CI_RX_WRITE */        {BTA_PAN_IGNORE,                 BTA_PAN_IDLE_ST},
  95    /* CI_RX_WRITEBUF */     {BTA_PAN_IGNORE,                 BTA_PAN_IDLE_ST},
  96    /* PAN_CONN_OPEN */      {BTA_PAN_CONN_OPEN,              BTA_PAN_OPEN_ST},
  97    /* PAN_CONN_CLOSE */     {BTA_PAN_CONN_OPEN,              BTA_PAN_IDLE_ST},
  98    /* FLOW_ENABLE */        {BTA_PAN_IGNORE,                 BTA_PAN_IDLE_ST},
  99    /* BNEP_DATA */          {BTA_PAN_IGNORE,                 BTA_PAN_IDLE_ST}
 100
 101 };
 102
 103
 104
 105 /* state table for open state */
 106 const UINT8 bta_pan_st_open[][BTA_PAN_NUM_COLS] =
 107 {
 108    /* API_CLOSE */          {BTA_PAN_API_CLOSE,               BTA_PAN_OPEN_ST},
 109    /* CI_TX_READY */        {BTA_PAN_TX_PATH,                 BTA_PAN_OPEN_ST},
 110    /* CI_RX_READY */        {BTA_PAN_RX_PATH,                 BTA_PAN_OPEN_ST},
 111    /* CI_TX_FLOW */         {BTA_PAN_TX_FLOW,                 BTA_PAN_OPEN_ST},
 112    /* CI_RX_WRITE */        {BTA_PAN_IGNORE,                  BTA_PAN_OPEN_ST},
 113    /* CI_RX_WRITEBUF */     {BTA_PAN_WRITE_BUF,               BTA_PAN_OPEN_ST},
 114    /* PAN_CONN_OPEN */      {BTA_PAN_IGNORE,                  BTA_PAN_OPEN_ST},
 115    /* PAN_CONN_CLOSE */     {BTA_PAN_CONN_CLOSE,              BTA_PAN_IDLE_ST},
 116    /* FLOW_ENABLE */        {BTA_PAN_RX_PATH,                 BTA_PAN_OPEN_ST},
 117    /* BNEP_DATA */          {BTA_PAN_TX_PATH,                 BTA_PAN_OPEN_ST}
 118 };
 119
 120 /* state table for closing state */
 121 const UINT8 bta_pan_st_closing[][BTA_PAN_NUM_COLS] =
 122 {
 123    /* API_CLOSE */          {BTA_PAN_IGNORE,                   BTA_PAN_CLOSING_ST},
 124    /* CI_TX_READY */        {BTA_PAN_TX_PATH,                  BTA_PAN_CLOSING_ST},
 125    /* CI_RX_READY */        {BTA_PAN_RX_PATH,                  BTA_PAN_CLOSING_ST},
 126    /* CI_TX_FLOW */         {BTA_PAN_TX_FLOW,                  BTA_PAN_CLOSING_ST},
 127    /* CI_RX_WRITE */        {BTA_PAN_IGNORE,                   BTA_PAN_CLOSING_ST},
 128    /* CI_RX_WRITEBUF */     {BTA_PAN_FREE_BUF,                 BTA_PAN_CLOSING_ST},
 129    /* PAN_CONN_OPEN */      {BTA_PAN_IGNORE,                   BTA_PAN_CLOSING_ST},
 130    /* PAN_CONN_CLOSE */     {BTA_PAN_CONN_CLOSE,               BTA_PAN_IDLE_ST},
 131    /* FLOW_ENABLE */        {BTA_PAN_RX_PATH,                  BTA_PAN_CLOSING_ST},
 132    /* BNEP_DATA */          {BTA_PAN_TX_PATH,                  BTA_PAN_CLOSING_ST}
 133 };
 134
 135 /* type for state table */
 136 typedef const UINT8 (*tBTA_PAN_ST_TBL)[BTA_PAN_NUM_COLS];
 137
 138 /* state table */
 139 const tBTA_PAN_ST_TBL bta_pan_st_tbl[] = {
 140     bta_pan_st_idle,
 141     bta_pan_st_open,
 142     bta_pan_st_closing
 143 };
 144
 145 /*****************************************************************************
 146 ** Global data
 147 *****************************************************************************/
 148
 149 /* PAN control block */
 150 #if BTA_DYNAMIC_MEMORY == FALSE
 151 tBTA_PAN_CB  bta_pan_cb;
 152 #endif
 153
 154 /*******************************************************************************
 155 **
 156 ** Function         bta_pan_scb_alloc
 157 **
 158 ** Description      Allocate a PAN server control block.
 159 **
 160 **
 161 ** Returns          pointer to the scb, or NULL if none could be allocated.
 162 **
 163 *******************************************************************************/
 164 tBTA_PAN_SCB *bta_pan_scb_alloc(void)
 165 {
 166     tBTA_PAN_SCB     *p_scb = &bta_pan_cb.scb[0];
 167     int             i;
 168
 169     for (i = 0; i < BTA_PAN_NUM_CONN; i++, p_scb++)
 170     {
 171         if (!p_scb->in_use)
 172         {
 173             p_scb->in_use = TRUE;
 174             APPL_TRACE_DEBUG("bta_pan_scb_alloc %d", i);
 175             break;
 176         }
 177     }
 178
 179     if (i == BTA_PAN_NUM_CONN)
 180     {
 181         /* out of scbs */
 182         p_scb = NULL;
 183         APPL_TRACE_WARNING("Out of scbs");
 184     }
 185     return p_scb;
 186 }
 187
 188 /*******************************************************************************
 189 **
 190 ** Function         bta_pan_sm_execute
 191 **
 192 ** Description      State machine event handling function for PAN
 193 **
 194 **
 195 ** Returns          void
 196 **
 197 *******************************************************************************/
 198 static void bta_pan_sm_execute(tBTA_PAN_SCB *p_scb, UINT16 event, tBTA_PAN_DATA *p_data)
 199 {
 200     tBTA_PAN_ST_TBL      state_table;
 201     UINT8               action;
 202     int                 i;
 203
 204     APPL_TRACE_EVENT("PAN scb=%d event=0x%x state=%d", bta_pan_scb_to_idx(p_scb), event, p_scb->state);
 205
 206     /* look up the state table for the current state */
 207     state_table = bta_pan_st_tbl[p_scb->state];
 208
 209     event &= 0x00FF;
 210
 211     /* set next state */
 212     p_scb->state = state_table[event][BTA_PAN_NEXT_STATE];
 213
 214     /* execute action functions */
 215     for (i = 0; i < BTA_PAN_ACTIONS; i++)
 216     {
 217         if ((action = state_table[event][i]) != BTA_PAN_IGNORE)
 218         {
 219             (*bta_pan_action[action])(p_scb, p_data);
 220         }
 221         else
 222         {
 223             break;
 224         }
 225     }
 226 }
 227
 228 /*******************************************************************************
 229 **
 230 ** Function         bta_pan_api_enable
 231 **
 232 ** Description      Handle an API enable event.
 233 **
 234 **
 235 ** Returns          void
 236 **
 237 *******************************************************************************/
 238 static void bta_pan_api_enable(tBTA_PAN_DATA *p_data)
 239 {
 240     /* initialize control block */
 241     memset(&bta_pan_cb, 0, sizeof(bta_pan_cb));
 242
 243     /* store callback function */
 244     bta_pan_cb.p_cback = p_data->api_enable.p_cback;
 245     bta_pan_enable(p_data);
 246 }
 247
 248 /*******************************************************************************
 249 **
 250 ** Function         bta_pan_api_disable
 251 **
 252 ** Description      Handle an API disable event.
 253 **
 254 **
 255 ** Returns          void
 256 **
 257 *******************************************************************************/
 258 static void bta_pan_api_disable(tBTA_PAN_DATA *p_data)
 259 {
 260     UNUSED(p_data);
 261
 262     bta_pan_disable();
 263 }
 264
 265
 266 /*******************************************************************************
 267 **
 268 ** Function         bta_pan_api_open
 269 **
 270 ** Description      Handle an API listen event.
 271 **
 272 **
 273 ** Returns          void
 274 **
 275 *******************************************************************************/
 276 static void bta_pan_api_open(tBTA_PAN_DATA *p_data)
 277 {
 278     tBTA_PAN_SCB     *p_scb;
 279     tBTA_PAN_OPEN data;
 280
 281     /* allocate an scb */
 282     if ((p_scb = bta_pan_scb_alloc()) != NULL)
 283     {
 284         bta_pan_open(p_scb, p_data);
 285     }
 286     else
 287     {
 288         bdcpy(data.bd_addr, p_data->api_open.bd_addr);
 289         data.status = BTA_PAN_FAIL;
 290         bta_pan_cb.p_cback(BTA_PAN_OPEN_EVT, (tBTA_PAN *)&data);
 291
 292     }
 293 }
 294 /*******************************************************************************
 295 **
 296 ** Function         bta_pan_scb_dealloc
 297 **
 298 ** Description      Deallocate a link control block.
 299 **
 300 **
 301 ** Returns          void
 302 **
 303 *******************************************************************************/
 304 void bta_pan_scb_dealloc(tBTA_PAN_SCB *p_scb)
 305 {
 306     APPL_TRACE_DEBUG("bta_pan_scb_dealloc %d", bta_pan_scb_to_idx(p_scb));
 307     fixed_queue_free(p_scb->data_queue, NULL);
 308     memset(p_scb, 0, sizeof(tBTA_PAN_SCB));
 309 }
 310
 311 /*******************************************************************************
 312 **
 313 ** Function         bta_pan_scb_to_idx
 314 **
 315 ** Description      Given a pointer to an scb, return its index.
 316 **
 317 **
 318 ** Returns          Index of scb.
 319 **
 320 *******************************************************************************/
 321 UINT8 bta_pan_scb_to_idx(tBTA_PAN_SCB *p_scb)
 322 {
 323
 324     return ((UINT8) (p_scb - bta_pan_cb.scb)) + 1;
 325 }
 326
 327
 328
 329 /*******************************************************************************
 330 **
 331 ** Function         bta_pan_scb_by_handle
 332 **
 333 ** Description      Find scb associated with handle.
 334 **
 335 **
 336 ** Returns          Pointer to scb or NULL if not found.
 337 **
 338 *******************************************************************************/
 339 tBTA_PAN_SCB *bta_pan_scb_by_handle(UINT16 handle)
 340 {
 341     tBTA_PAN_SCB     *p_scb = &bta_pan_cb.scb[0];
 342     UINT8 i;
 343
 344     for (i = 0; i < BTA_PAN_NUM_CONN; i++, p_scb++)
 345     {
 346         if (p_scb->handle == handle)
 347         {
 348             return p_scb;;
 349         }
 350     }
 351
 352
 353     APPL_TRACE_WARNING("No scb for handle %d", handle);
 354
 355     return NULL;
 356 }
 357
 358 /*******************************************************************************
 359 **
 360 ** Function         bta_pan_hdl_event
 361 **
 362 ** Description      Data gateway main event handling function.
 363 **
 364 **
 365 ** Returns          void
 366 **
 367 *******************************************************************************/
 368 BOOLEAN bta_pan_hdl_event(BT_HDR *p_msg)
 369 {
 370     tBTA_PAN_SCB *p_scb;
 371     BOOLEAN     freebuf = TRUE;
 372
 373     switch (p_msg->event)
 374     {
 375         /* handle enable event */
 376         case BTA_PAN_API_ENABLE_EVT:
 377             bta_pan_api_enable((tBTA_PAN_DATA *) p_msg);
 378             break;
 379
 380         /* handle disable event */
 381         case BTA_PAN_API_DISABLE_EVT:
 382             bta_pan_api_disable((tBTA_PAN_DATA *) p_msg);
 383             break;
 384
 385         /* handle set role event */
 386         case BTA_PAN_API_SET_ROLE_EVT:
 387             bta_pan_set_role((tBTA_PAN_DATA *) p_msg);
 388             break;
 389
 390         /* handle open event */
 391         case BTA_PAN_API_OPEN_EVT:
 392             bta_pan_api_open((tBTA_PAN_DATA *) p_msg);
 393             break;
 394
 395
 396         /* events that require buffer not be released */
 397         case BTA_PAN_CI_RX_WRITEBUF_EVT:
 398             freebuf = FALSE;
 399             if ((p_scb = bta_pan_scb_by_handle(p_msg->layer_specific)) != NULL)
 400             {
 401                 bta_pan_sm_execute(p_scb, p_msg->event, (tBTA_PAN_DATA *) p_msg);
 402             }
 403             break;
 404
 405         /* all other events */
 406         default:
 407             if ((p_scb = bta_pan_scb_by_handle(p_msg->layer_specific)) != NULL)
 408             {
 409                 bta_pan_sm_execute(p_scb, p_msg->event, (tBTA_PAN_DATA *) p_msg);
 410             }
 411             break;
 412
 413     }
 414     return freebuf;
 415 }
 416 #endif /* BTA_PAN_INCLUDED */