1/******************************************************************************
2 *
3 *  Copyright (C) 2003-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 module contains the link control state machine and functions which
22 *  operate on the link control block.
23 *
24 ******************************************************************************/
25
26#include <string.h>
27#include "bt_types.h"
28#include "bt_target.h"
29#include "bt_utils.h"
30#include "avct_api.h"
31#include "avct_int.h"
32#include "bt_common.h"
33
34/*****************************************************************************
35** state machine constants and types
36*****************************************************************************/
37
38#if BT_TRACE_VERBOSE == TRUE
39
40/* verbose state strings for trace */
41const char * const avct_lcb_st_str[] = {
42    "LCB_IDLE_ST",
43    "LCB_OPENING_ST",
44    "LCB_OPEN_ST",
45    "LCB_CLOSING_ST"
46};
47
48/* verbose event strings for trace */
49const char * const avct_lcb_evt_str[] = {
50    "UL_BIND_EVT",
51    "UL_UNBIND_EVT",
52    "UL_MSG_EVT",
53    "INT_CLOSE_EVT",
54    "LL_OPEN_EVT",
55    "LL_CLOSE_EVT",
56    "LL_MSG_EVT",
57    "LL_CONG_EVT"
58};
59
60#endif
61
62/* lcb state machine states */
63enum {
64    AVCT_LCB_IDLE_ST,
65    AVCT_LCB_OPENING_ST,
66    AVCT_LCB_OPEN_ST,
67    AVCT_LCB_CLOSING_ST
68};
69
70/* state machine action enumeration list */
71enum {
72    AVCT_LCB_CHNL_OPEN,
73    AVCT_LCB_CHNL_DISC,
74    AVCT_LCB_SEND_MSG,
75    AVCT_LCB_OPEN_IND,
76    AVCT_LCB_OPEN_FAIL,
77    AVCT_LCB_CLOSE_IND,
78    AVCT_LCB_CLOSE_CFM,
79    AVCT_LCB_MSG_IND,
80    AVCT_LCB_CONG_IND,
81    AVCT_LCB_BIND_CONN,
82    AVCT_LCB_BIND_FAIL,
83    AVCT_LCB_UNBIND_DISC,
84    AVCT_LCB_CHK_DISC,
85    AVCT_LCB_DISCARD_MSG,
86    AVCT_LCB_DEALLOC,
87    AVCT_LCB_FREE_MSG_IND,
88    AVCT_LCB_NUM_ACTIONS
89};
90
91#define AVCT_LCB_IGNORE     AVCT_LCB_NUM_ACTIONS
92
93/* type for action functions */
94typedef void (*tAVCT_LCB_ACTION)(tAVCT_LCB *p_ccb, tAVCT_LCB_EVT *p_data);
95
96/* action function list */
97const tAVCT_LCB_ACTION avct_lcb_action[] = {
98    avct_lcb_chnl_open,
99    avct_lcb_chnl_disc,
100    avct_lcb_send_msg,
101    avct_lcb_open_ind,
102    avct_lcb_open_fail,
103    avct_lcb_close_ind,
104    avct_lcb_close_cfm,
105    avct_lcb_msg_ind,
106    avct_lcb_cong_ind,
107    avct_lcb_bind_conn,
108    avct_lcb_bind_fail,
109    avct_lcb_unbind_disc,
110    avct_lcb_chk_disc,
111    avct_lcb_discard_msg,
112    avct_lcb_dealloc,
113    avct_lcb_free_msg_ind
114};
115
116/* state table information */
117#define AVCT_LCB_ACTIONS            2       /* number of actions */
118#define AVCT_LCB_NEXT_STATE         2       /* position of next state */
119#define AVCT_LCB_NUM_COLS           3       /* number of columns in state tables */
120
121/* state table for idle state */
122const UINT8 avct_lcb_st_idle[][AVCT_LCB_NUM_COLS] = {
123/* Event                Action 1                    Action 2                    Next state */
124/* UL_BIND_EVT */       {AVCT_LCB_CHNL_OPEN,        AVCT_LCB_IGNORE,            AVCT_LCB_OPENING_ST},
125/* UL_UNBIND_EVT */     {AVCT_LCB_UNBIND_DISC,      AVCT_LCB_IGNORE,            AVCT_LCB_IDLE_ST},
126/* UL_MSG_EVT */        {AVCT_LCB_DISCARD_MSG,      AVCT_LCB_IGNORE,            AVCT_LCB_IDLE_ST},
127/* INT_CLOSE_EVT */     {AVCT_LCB_IGNORE,           AVCT_LCB_IGNORE,            AVCT_LCB_IDLE_ST},
128/* LL_OPEN_EVT */       {AVCT_LCB_OPEN_IND,         AVCT_LCB_IGNORE,            AVCT_LCB_OPEN_ST},
129/* LL_CLOSE_EVT */      {AVCT_LCB_CLOSE_IND,        AVCT_LCB_DEALLOC,           AVCT_LCB_IDLE_ST},
130/* LL_MSG_EVT */        {AVCT_LCB_FREE_MSG_IND,     AVCT_LCB_IGNORE,            AVCT_LCB_IDLE_ST},
131/* LL_CONG_EVT */       {AVCT_LCB_IGNORE,           AVCT_LCB_IGNORE,            AVCT_LCB_IDLE_ST}
132};
133
134/* state table for opening state */
135const UINT8 avct_lcb_st_opening[][AVCT_LCB_NUM_COLS] = {
136/* Event                Action 1                    Action 2                    Next state */
137/* UL_BIND_EVT */       {AVCT_LCB_IGNORE,           AVCT_LCB_IGNORE,            AVCT_LCB_OPENING_ST},
138/* UL_UNBIND_EVT */     {AVCT_LCB_UNBIND_DISC,      AVCT_LCB_IGNORE,            AVCT_LCB_OPENING_ST},
139/* UL_MSG_EVT */        {AVCT_LCB_DISCARD_MSG,      AVCT_LCB_IGNORE,            AVCT_LCB_OPENING_ST},
140/* INT_CLOSE_EVT */     {AVCT_LCB_CHNL_DISC,        AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST},
141/* LL_OPEN_EVT */       {AVCT_LCB_OPEN_IND,         AVCT_LCB_IGNORE,            AVCT_LCB_OPEN_ST},
142/* LL_CLOSE_EVT */      {AVCT_LCB_OPEN_FAIL,        AVCT_LCB_DEALLOC,           AVCT_LCB_IDLE_ST},
143/* LL_MSG_EVT */        {AVCT_LCB_FREE_MSG_IND,     AVCT_LCB_IGNORE,            AVCT_LCB_OPENING_ST},
144/* LL_CONG_EVT */       {AVCT_LCB_CONG_IND,         AVCT_LCB_IGNORE,            AVCT_LCB_OPENING_ST}
145};
146
147/* state table for open state */
148const UINT8 avct_lcb_st_open[][AVCT_LCB_NUM_COLS] = {
149/* Event                Action 1                    Action 2                    Next state */
150/* UL_BIND_EVT */       {AVCT_LCB_BIND_CONN,        AVCT_LCB_IGNORE,            AVCT_LCB_OPEN_ST},
151/* UL_UNBIND_EVT */     {AVCT_LCB_CHK_DISC,         AVCT_LCB_IGNORE,            AVCT_LCB_OPEN_ST},
152/* UL_MSG_EVT */        {AVCT_LCB_SEND_MSG,         AVCT_LCB_IGNORE,            AVCT_LCB_OPEN_ST},
153/* INT_CLOSE_EVT */     {AVCT_LCB_CHNL_DISC,        AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST},
154/* LL_OPEN_EVT */       {AVCT_LCB_IGNORE,           AVCT_LCB_IGNORE,            AVCT_LCB_OPEN_ST},
155/* LL_CLOSE_EVT */      {AVCT_LCB_CLOSE_IND,        AVCT_LCB_DEALLOC,           AVCT_LCB_IDLE_ST},
156/* LL_MSG_EVT */        {AVCT_LCB_MSG_IND,          AVCT_LCB_IGNORE,            AVCT_LCB_OPEN_ST},
157/* LL_CONG_EVT */       {AVCT_LCB_CONG_IND,         AVCT_LCB_IGNORE,            AVCT_LCB_OPEN_ST}
158};
159
160/* state table for closing state */
161const UINT8 avct_lcb_st_closing[][AVCT_LCB_NUM_COLS] = {
162/* Event                Action 1                    Action 2                    Next state */
163/* UL_BIND_EVT */       {AVCT_LCB_BIND_FAIL,        AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST},
164/* UL_UNBIND_EVT */     {AVCT_LCB_IGNORE,           AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST},
165/* UL_MSG_EVT */        {AVCT_LCB_DISCARD_MSG,      AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST},
166/* INT_CLOSE_EVT */     {AVCT_LCB_IGNORE,           AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST},
167/* LL_OPEN_EVT */       {AVCT_LCB_IGNORE,           AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST},
168/* LL_CLOSE_EVT */      {AVCT_LCB_CLOSE_CFM,        AVCT_LCB_DEALLOC,           AVCT_LCB_IDLE_ST},
169/* LL_MSG_EVT */        {AVCT_LCB_FREE_MSG_IND,     AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST},
170/* LL_CONG_EVT */       {AVCT_LCB_IGNORE,           AVCT_LCB_IGNORE,            AVCT_LCB_CLOSING_ST}
171};
172
173/* type for state table */
174typedef const UINT8 (*tAVCT_LCB_ST_TBL)[AVCT_LCB_NUM_COLS];
175
176/* state table */
177const tAVCT_LCB_ST_TBL avct_lcb_st_tbl[] = {
178    avct_lcb_st_idle,
179    avct_lcb_st_opening,
180    avct_lcb_st_open,
181    avct_lcb_st_closing
182};
183
184/*******************************************************************************
185**
186** Function         avct_lcb_event
187**
188** Description      State machine event handling function for lcb
189**
190**
191** Returns          Nothing.
192**
193*******************************************************************************/
194void avct_lcb_event(tAVCT_LCB *p_lcb, UINT8 event, tAVCT_LCB_EVT *p_data)
195{
196    tAVCT_LCB_ST_TBL    state_table;
197    UINT8               action;
198    int                 i;
199
200#if BT_TRACE_VERBOSE == TRUE
201    AVCT_TRACE_EVENT("LCB lcb=%d event=%s state=%s", p_lcb->allocated, avct_lcb_evt_str[event], avct_lcb_st_str[p_lcb->state]);
202#else
203    AVCT_TRACE_EVENT("LCB lcb=%d event=%d state=%d", p_lcb->allocated, event, p_lcb->state);
204#endif
205
206    /* look up the state table for the current state */
207    state_table = avct_lcb_st_tbl[p_lcb->state];
208
209    /* set next state */
210    p_lcb->state = state_table[event][AVCT_LCB_NEXT_STATE];
211
212    /* execute action functions */
213    for (i = 0; i < AVCT_LCB_ACTIONS; i++)
214    {
215        if ((action = state_table[event][i]) != AVCT_LCB_IGNORE)
216        {
217            (*avct_lcb_action[action])(p_lcb, p_data);
218        }
219        else
220        {
221            break;
222        }
223    }
224}
225
226/*******************************************************************************
227**
228** Function         avct_bcb_event
229**
230** Description      State machine event handling function for lcb
231**
232**
233** Returns          Nothing.
234**
235*******************************************************************************/
236#if (AVCT_BROWSE_INCLUDED == TRUE)
237void avct_bcb_event(tAVCT_BCB *p_bcb, UINT8 event, tAVCT_LCB_EVT *p_data)
238{
239    tAVCT_LCB_ST_TBL    state_table;
240    UINT8               action;
241    int                 i;
242
243#if BT_TRACE_VERBOSE == TRUE
244    AVCT_TRACE_EVENT("BCB lcb=%d event=%s state=%s", p_bcb->allocated, avct_lcb_evt_str[event], avct_lcb_st_str[p_bcb->state]);
245#else
246    AVCT_TRACE_EVENT("BCB lcb=%d event=%d state=%d", p_bcb->allocated, event, p_bcb->state);
247#endif
248
249    /* look up the state table for the current state */
250    state_table = avct_lcb_st_tbl[p_bcb->state];
251
252    /* set next state */
253    p_bcb->state = state_table[event][AVCT_LCB_NEXT_STATE];
254
255    /* execute action functions */
256    for (i = 0; i < AVCT_LCB_ACTIONS; i++)
257    {
258        if ((action = state_table[event][i]) != AVCT_LCB_IGNORE)
259        {
260            (*avct_bcb_action[action])(p_bcb, p_data);
261        }
262        else
263        {
264            break;
265        }
266    }
267}
268#endif
269
270/*******************************************************************************
271**
272** Function         avct_lcb_by_bd
273**
274** Description      This lookup function finds the lcb for a BD address.
275**
276**
277** Returns          pointer to the lcb, or NULL if none found.
278**
279*******************************************************************************/
280tAVCT_LCB *avct_lcb_by_bd(BD_ADDR bd_addr)
281{
282    tAVCT_LCB   *p_lcb = &avct_cb.lcb[0];
283    int         i;
284
285    for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++)
286    {
287        /* if allocated lcb has matching lcb */
288        if (p_lcb->allocated && (!memcmp(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN)))
289        {
290            break;
291        }
292    }
293
294    if (i == AVCT_NUM_LINKS)
295    {
296        /* if no lcb found */
297        p_lcb = NULL;
298
299        AVCT_TRACE_DEBUG("No lcb for addr %02x-%02x-%02x-%02x-%02x-%02x",
300                          bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
301    }
302    return p_lcb;
303}
304
305/*******************************************************************************
306**
307** Function         avct_lcb_alloc
308**
309** Description      Allocate a link control block.
310**
311**
312** Returns          pointer to the lcb, or NULL if none could be allocated.
313**
314*******************************************************************************/
315tAVCT_LCB *avct_lcb_alloc(BD_ADDR bd_addr)
316{
317    tAVCT_LCB   *p_lcb = &avct_cb.lcb[0];
318    int         i;
319
320    for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++)
321    {
322        if (!p_lcb->allocated)
323        {
324            p_lcb->allocated = (UINT8)(i + 1);
325            memcpy(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN);
326            AVCT_TRACE_DEBUG("avct_lcb_alloc %d", p_lcb->allocated);
327            p_lcb->tx_q = fixed_queue_new(SIZE_MAX);
328            break;
329        }
330    }
331
332    if (i == AVCT_NUM_LINKS)
333    {
334        /* out of lcbs */
335        p_lcb = NULL;
336        AVCT_TRACE_WARNING("Out of lcbs");
337    }
338    return p_lcb;
339}
340
341/*******************************************************************************
342**
343** Function         avct_lcb_dealloc
344**
345** Description      Deallocate a link control block.
346**
347**
348** Returns          void.
349**
350*******************************************************************************/
351void avct_lcb_dealloc(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
352{
353    UNUSED(p_data);
354
355    AVCT_TRACE_DEBUG("%s allocated: %d", __func__, p_lcb->allocated);
356
357    // Check if the LCB is still referenced
358
359    tAVCT_CCB *p_ccb = &avct_cb.ccb[0];
360    for (size_t i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
361    {
362        if (p_ccb->allocated && p_ccb->p_lcb == p_lcb)
363        {
364            AVCT_TRACE_DEBUG("%s LCB in use; lcb index: %d", __func__, i);
365            return;
366        }
367    }
368
369    // If not, de-allocate now...
370
371    AVCT_TRACE_DEBUG("%s Freeing LCB", __func__);
372    osi_free(p_lcb->p_rx_msg);
373    fixed_queue_free(p_lcb->tx_q, NULL);
374    memset(p_lcb, 0, sizeof(tAVCT_LCB));
375}
376
377/*******************************************************************************
378**
379** Function         avct_lcb_by_lcid
380**
381** Description      Find the LCB associated with the L2CAP LCID
382**
383**
384** Returns          pointer to the lcb, or NULL if none found.
385**
386*******************************************************************************/
387tAVCT_LCB *avct_lcb_by_lcid(UINT16 lcid)
388{
389    tAVCT_LCB   *p_lcb = &avct_cb.lcb[0];
390    int         i;
391
392    for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++)
393    {
394        if (p_lcb->allocated && ((p_lcb->ch_lcid == lcid) || (p_lcb->conflict_lcid == lcid)))
395        {
396            break;
397        }
398    }
399
400    if (i == AVCT_NUM_LINKS)
401    {
402        /* out of lcbs */
403        p_lcb = NULL;
404        AVCT_TRACE_WARNING("No lcb for lcid %x", lcid);
405    }
406
407    return p_lcb;
408}
409
410/*******************************************************************************
411**
412** Function         avct_lcb_has_pid
413**
414** Description      See if any ccbs on this lcb have a particular pid.
415**
416**
417** Returns          Pointer to CCB if PID found, NULL otherwise.
418**
419*******************************************************************************/
420tAVCT_CCB *avct_lcb_has_pid(tAVCT_LCB *p_lcb, UINT16 pid)
421{
422    tAVCT_CCB   *p_ccb = &avct_cb.ccb[0];
423    int         i;
424
425    for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
426    {
427        if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb->cc.pid == pid))
428        {
429            return p_ccb;
430        }
431    }
432    return NULL;
433}
434
435/*******************************************************************************
436**
437** Function         avct_lcb_last_ccb
438**
439** Description      See if given ccb is only one on the lcb.
440**
441**
442** Returns          TRUE if ccb is last, FALSE otherwise.
443**
444*******************************************************************************/
445BOOLEAN avct_lcb_last_ccb(tAVCT_LCB *p_lcb, tAVCT_CCB *p_ccb_last)
446{
447    tAVCT_CCB   *p_ccb = &avct_cb.ccb[0];
448    int         i;
449
450    AVCT_TRACE_WARNING("avct_lcb_last_ccb");
451    for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
452    {
453        AVCT_TRACE_WARNING("%x: aloc:%d, lcb:0x%x/0x%x, ccb:0x%x/0x%x",
454            i, p_ccb->allocated, p_ccb->p_lcb, p_lcb, p_ccb, p_ccb_last);
455        if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb != p_ccb_last))
456        {
457            return FALSE;
458        }
459    }
460    return TRUE;
461}
462
463
464
465