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 Control channel state
22 *  machine.
23 *
24 ******************************************************************************/
25#include <string.h>
26
27#include "bt_target.h"
28#include "mca_api.h"
29#include "mca_defs.h"
30#include "mca_int.h"
31#include  "btu.h"
32
33/*****************************************************************************
34** data channel state machine constants and types
35*****************************************************************************/
36enum
37{
38    MCA_CCB_FREE_MSG,
39    MCA_CCB_SND_REQ,
40    MCA_CCB_SND_RSP,
41    MCA_CCB_DO_DISCONN,
42    MCA_CCB_CONG,
43    MCA_CCB_HDL_REQ,
44    MCA_CCB_HDL_RSP,
45    MCA_CCB_LL_OPEN,
46    MCA_CCB_DL_OPEN,
47    MCA_CCB_DEALLOC,
48    MCA_CCB_RSP_TOUT,
49    MCA_CCB_NUM_ACTIONS
50};
51#define MCA_CCB_IGNORE     MCA_CCB_NUM_ACTIONS
52
53/* action function list */
54const tMCA_CCB_ACTION mca_ccb_action[] = {
55    mca_ccb_free_msg,
56    mca_ccb_snd_req,
57    mca_ccb_snd_rsp,
58    mca_ccb_do_disconn,
59    mca_ccb_cong,
60    mca_ccb_hdl_req,
61    mca_ccb_hdl_rsp,
62    mca_ccb_ll_open,
63    mca_ccb_dl_open,
64    mca_ccb_dealloc,
65    mca_ccb_rsp_tout,
66};
67
68/* state table information */
69#define MCA_CCB_ACTIONS            1       /* number of actions */
70#define MCA_CCB_ACT_COL            0       /* position of action function */
71#define MCA_CCB_NEXT_STATE         1       /* position of next state */
72#define MCA_CCB_NUM_COLS           2       /* number of columns in state tables */
73
74/* state table for opening state */
75const UINT8 mca_ccb_st_opening[][MCA_CCB_NUM_COLS] = {
76/* Event                            Action              Next State */
77/* MCA_CCB_API_CONNECT_EVT    */   {MCA_CCB_IGNORE,     MCA_CCB_OPENING_ST},
78/* MCA_CCB_API_DISCONNECT_EVT */   {MCA_CCB_DO_DISCONN, MCA_CCB_CLOSING_ST},
79/* MCA_CCB_API_REQ_EVT        */   {MCA_CCB_FREE_MSG,   MCA_CCB_OPENING_ST},
80/* MCA_CCB_API_RSP_EVT        */   {MCA_CCB_IGNORE,     MCA_CCB_OPENING_ST},
81/* MCA_CCB_MSG_REQ_EVT        */   {MCA_CCB_FREE_MSG,   MCA_CCB_OPENING_ST},
82/* MCA_CCB_MSG_RSP_EVT        */   {MCA_CCB_FREE_MSG,   MCA_CCB_OPENING_ST},
83/* MCA_CCB_DL_OPEN_EVT        */   {MCA_CCB_IGNORE,     MCA_CCB_OPENING_ST},
84/* MCA_CCB_LL_OPEN_EVT        */   {MCA_CCB_LL_OPEN,    MCA_CCB_OPEN_ST},
85/* MCA_CCB_LL_CLOSE_EVT       */   {MCA_CCB_DEALLOC,    MCA_CCB_NULL_ST},
86/* MCA_CCB_LL_CONG_EVT        */   {MCA_CCB_CONG,       MCA_CCB_OPENING_ST},
87/* MCA_CCB_RSP_TOUT_EVT       */   {MCA_CCB_IGNORE,     MCA_CCB_OPENING_ST}
88};
89
90/* state table for open state */
91const UINT8 mca_ccb_st_open[][MCA_CCB_NUM_COLS] = {
92/* Event                            Action              Next State */
93/* MCA_CCB_API_CONNECT_EVT    */   {MCA_CCB_IGNORE,     MCA_CCB_OPEN_ST},
94/* MCA_CCB_API_DISCONNECT_EVT */   {MCA_CCB_DO_DISCONN, MCA_CCB_CLOSING_ST},
95/* MCA_CCB_API_REQ_EVT        */   {MCA_CCB_SND_REQ,    MCA_CCB_OPEN_ST},
96/* MCA_CCB_API_RSP_EVT        */   {MCA_CCB_SND_RSP,    MCA_CCB_OPEN_ST},
97/* MCA_CCB_MSG_REQ_EVT        */   {MCA_CCB_HDL_REQ,    MCA_CCB_OPEN_ST},
98/* MCA_CCB_MSG_RSP_EVT        */   {MCA_CCB_HDL_RSP,    MCA_CCB_OPEN_ST},
99/* MCA_CCB_DL_OPEN_EVT        */   {MCA_CCB_DL_OPEN,    MCA_CCB_OPEN_ST},
100/* MCA_CCB_LL_OPEN_EVT        */   {MCA_CCB_IGNORE,     MCA_CCB_OPEN_ST},
101/* MCA_CCB_LL_CLOSE_EVT       */   {MCA_CCB_DEALLOC,    MCA_CCB_NULL_ST},
102/* MCA_CCB_LL_CONG_EVT        */   {MCA_CCB_CONG,       MCA_CCB_OPEN_ST},
103/* MCA_CCB_RSP_TOUT_EVT       */   {MCA_CCB_RSP_TOUT,   MCA_CCB_OPEN_ST}
104};
105
106/* state table for closing state */
107const UINT8 mca_ccb_st_closing[][MCA_CCB_NUM_COLS] = {
108/* Event                            Action              Next State */
109/* MCA_CCB_API_CONNECT_EVT    */   {MCA_CCB_IGNORE,     MCA_CCB_CLOSING_ST},
110/* MCA_CCB_API_DISCONNECT_EVT */   {MCA_CCB_IGNORE,     MCA_CCB_CLOSING_ST},
111/* MCA_CCB_API_REQ_EVT        */   {MCA_CCB_FREE_MSG,   MCA_CCB_CLOSING_ST},
112/* MCA_CCB_API_RSP_EVT        */   {MCA_CCB_IGNORE,     MCA_CCB_CLOSING_ST},
113/* MCA_CCB_MSG_REQ_EVT        */   {MCA_CCB_FREE_MSG,   MCA_CCB_CLOSING_ST},
114/* MCA_CCB_MSG_RSP_EVT        */   {MCA_CCB_FREE_MSG,   MCA_CCB_CLOSING_ST},
115/* MCA_CCB_DL_OPEN_EVT        */   {MCA_CCB_IGNORE,     MCA_CCB_CLOSING_ST},
116/* MCA_CCB_LL_OPEN_EVT        */   {MCA_CCB_IGNORE,     MCA_CCB_CLOSING_ST},
117/* MCA_CCB_LL_CLOSE_EVT       */   {MCA_CCB_DEALLOC,    MCA_CCB_NULL_ST},
118/* MCA_CCB_LL_CONG_EVT        */   {MCA_CCB_IGNORE,     MCA_CCB_CLOSING_ST},
119/* MCA_CCB_RSP_TOUT_EVT       */   {MCA_CCB_IGNORE,     MCA_CCB_CLOSING_ST}
120};
121
122/* type for state table */
123typedef const UINT8 (*tMCA_CCB_ST_TBL)[MCA_CCB_NUM_COLS];
124
125/* state table */
126const tMCA_CCB_ST_TBL mca_ccb_st_tbl[] = {
127    mca_ccb_st_opening,
128    mca_ccb_st_open,
129    mca_ccb_st_closing
130};
131
132#if (BT_TRACE_VERBOSE == TRUE)
133/* verbose event strings for trace */
134static const char * const mca_ccb_evt_str[] = {
135    "API_CONNECT_EVT",
136    "API_DISCONNECT_EVT",
137    "API_REQ_EVT",
138    "API_RSP_EVT",
139    "MSG_REQ_EVT",
140    "MSG_RSP_EVT",
141    "DL_OPEN_EVT",
142    "LL_OPEN_EVT",
143    "LL_CLOSE_EVT",
144    "LL_CONG_EVT",
145    "RSP_TOUT_EVT"
146};
147/* verbose state strings for trace */
148static const char * const mca_ccb_st_str[] = {
149    "NULL_ST",
150    "OPENING_ST",
151    "OPEN_ST",
152    "CLOSING_ST"
153};
154#endif
155
156/*******************************************************************************
157**
158** Function         mca_stop_timer
159**
160** Description      This function is stop a MCAP timer
161**
162**                  This function is for use internal to MCAP only.
163**
164** Returns          void
165**
166*******************************************************************************/
167void mca_stop_timer(tMCA_CCB *p_ccb)
168{
169    if (p_ccb->timer_entry.event == BTU_TTYPE_MCA_CCB_RSP)
170    {
171        btu_stop_timer(&p_ccb->timer_entry);
172        p_ccb->timer_entry.event = 0;
173    }
174}
175
176/*******************************************************************************
177**
178** Function         mca_ccb_event
179**
180** Description      This function is the CCB state machine main function.
181**                  It uses the state and action function tables to execute
182**                  action functions.
183**
184** Returns          void.
185**
186*******************************************************************************/
187void mca_ccb_event(tMCA_CCB *p_ccb, UINT8 event, tMCA_CCB_EVT *p_data)
188{
189    tMCA_CCB_ST_TBL    state_table;
190    UINT8              action;
191
192#if (BT_TRACE_VERBOSE == TRUE)
193    MCA_TRACE_EVENT("CCB ccb=%d event=%s state=%s", mca_ccb_to_hdl(p_ccb), mca_ccb_evt_str[event], mca_ccb_st_str[p_ccb->state]);
194#else
195    MCA_TRACE_EVENT("CCB ccb=%d event=%d state=%d", mca_ccb_to_hdl(p_ccb), event, p_ccb->state);
196#endif
197
198    /* look up the state table for the current state */
199    state_table = mca_ccb_st_tbl[p_ccb->state - 1];
200
201    /* set next state */
202    p_ccb->state = state_table[event][MCA_CCB_NEXT_STATE];
203
204    /* execute action functions */
205    if ((action = state_table[event][MCA_CCB_ACT_COL]) != MCA_CCB_IGNORE)
206    {
207        (*mca_ccb_action[action])(p_ccb, p_data);
208    }
209}
210
211/*******************************************************************************
212**
213** Function         mca_ccb_by_bd
214**
215** Description      This function looks up the CCB based on the BD address.
216**                  It returns a pointer to the CCB.
217**                  If no CCB is found it returns NULL.
218**
219** Returns          void.
220**
221*******************************************************************************/
222tMCA_CCB *mca_ccb_by_bd(tMCA_HANDLE handle, BD_ADDR bd_addr)
223{
224    tMCA_CCB *p_ccb = NULL;
225    tMCA_RCB *p_rcb = mca_rcb_by_handle(handle);
226    tMCA_CCB *p_ccb_tmp;
227    int       i;
228
229    if (p_rcb)
230    {
231        i = handle-1;
232        p_ccb_tmp = &mca_cb.ccb[i*MCA_NUM_LINKS];
233        for (i=0; i<MCA_NUM_LINKS; i++, p_ccb_tmp++)
234        {
235            if (p_ccb_tmp->state != MCA_CCB_NULL_ST && memcmp(p_ccb_tmp->peer_addr, bd_addr, BD_ADDR_LEN) == 0)
236            {
237                p_ccb = p_ccb_tmp;
238                break;
239            }
240        }
241    }
242    return p_ccb;
243}
244
245/*******************************************************************************
246**
247** Function         mca_ccb_alloc
248**
249** Description      This function allocates a CCB and copies the BD address to
250**                  the CCB.  It returns a pointer to the CCB.  If no CCB can
251**                  be allocated it returns NULL.
252**
253** Returns          void.
254**
255*******************************************************************************/
256tMCA_CCB *mca_ccb_alloc(tMCA_HANDLE handle, BD_ADDR bd_addr)
257{
258    tMCA_CCB *p_ccb = NULL;
259    tMCA_RCB *p_rcb = mca_rcb_by_handle(handle);
260    tMCA_CCB *p_ccb_tmp;
261    int       i;
262
263    MCA_TRACE_DEBUG("mca_ccb_alloc handle:0x%x", handle);
264    if (p_rcb)
265    {
266        i = handle-1;
267        p_ccb_tmp = &mca_cb.ccb[i*MCA_NUM_LINKS];
268        for (i=0; i<MCA_NUM_LINKS; i++, p_ccb_tmp++)
269        {
270            if (p_ccb_tmp->state == MCA_CCB_NULL_ST)
271            {
272                p_ccb_tmp->p_rcb = p_rcb;
273                p_ccb_tmp->state = MCA_CCB_OPENING_ST;
274                p_ccb_tmp->cong  = TRUE;
275                memcpy(p_ccb_tmp->peer_addr, bd_addr, BD_ADDR_LEN);
276                p_ccb = p_ccb_tmp;
277                break;
278            }
279        }
280    }
281    return p_ccb;
282}
283
284
285/*******************************************************************************
286**
287** Function         mca_ccb_dealloc
288**
289** Description      This function deallocates a CCB.
290**
291** Returns          void.
292**
293*******************************************************************************/
294void mca_ccb_dealloc(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data)
295{
296    tMCA_CTRL   evt_data;
297
298    MCA_TRACE_DEBUG("mca_ccb_dealloc ctrl_vpsm:0x%x", p_ccb->ctrl_vpsm);
299    mca_dcb_close_by_mdl_id (p_ccb, MCA_ALL_MDL_ID);
300    if (p_ccb->ctrl_vpsm)
301    {
302        L2CA_Deregister (p_ccb->ctrl_vpsm);
303    }
304    if (p_ccb->data_vpsm)
305    {
306        L2CA_Deregister (p_ccb->data_vpsm);
307    }
308    mca_free_buf ((void **)&p_ccb->p_rx_msg);
309    mca_free_buf ((void **)&p_ccb->p_tx_req);
310    mca_stop_timer(p_ccb);
311
312    if (p_data)
313    {
314        /* non-NULL -> an action function -> report disconnect event */
315        memcpy (evt_data.disconnect_ind.bd_addr, p_ccb->peer_addr, BD_ADDR_LEN);
316        evt_data.disconnect_ind.reason = p_data->close.reason;
317        mca_ccb_report_event(p_ccb, MCA_DISCONNECT_IND_EVT, &evt_data);
318    }
319    mca_free_tc_tbl_by_lcid (p_ccb->lcid);
320    memset (p_ccb, 0, sizeof (tMCA_CCB));
321}
322
323/*******************************************************************************
324**
325** Function         mca_ccb_to_hdl
326**
327** Description      This function converts a pointer to a CCB to a tMCA_CL
328**                  and returns the value.
329**
330** Returns          void.
331**
332*******************************************************************************/
333tMCA_CL mca_ccb_to_hdl(tMCA_CCB *p_ccb)
334{
335    return (UINT8) (p_ccb - mca_cb.ccb + 1);
336}
337
338/*******************************************************************************
339**
340** Function         mca_ccb_by_hdl
341**
342** Description      This function converts an index value to a CCB.  It returns
343**                  a pointer to the CCB.  If no valid CCB matches the index it
344**                  returns NULL.
345**
346** Returns          void.
347**
348*******************************************************************************/
349tMCA_CCB *mca_ccb_by_hdl(tMCA_CL mcl)
350{
351    tMCA_CCB * p_ccb = NULL;
352    if (mcl && mcl <= MCA_NUM_CCBS && mca_cb.ccb[mcl-1].state)
353        p_ccb = &mca_cb.ccb[mcl-1];
354    return p_ccb;
355}
356
357
358/*******************************************************************************
359**
360** Function         mca_ccb_uses_mdl_id
361**
362** Description      This function checkes if a given mdl_id is in use.
363**
364** Returns          TRUE, if the given mdl_id is currently used in the MCL.
365**
366*******************************************************************************/
367BOOLEAN mca_ccb_uses_mdl_id(tMCA_CCB *p_ccb, UINT16 mdl_id)
368{
369    BOOLEAN uses = FALSE;
370    tMCA_DCB *p_dcb;
371    int       i;
372
373    i = mca_ccb_to_hdl(p_ccb)-1;
374    p_dcb = &mca_cb.dcb[i*MCA_NUM_MDLS];
375    for (i=0; i<MCA_NUM_MDLS; i++, p_dcb++)
376    {
377        if (p_dcb->state != MCA_DCB_NULL_ST && p_dcb->mdl_id == mdl_id)
378        {
379            uses = TRUE;
380            break;
381        }
382    }
383
384    return uses;
385}
386