avdt_ccb.cc revision 5ce0116fbf5b530d5b93f11312096eade1021c1e 
1/******************************************************************************
2 *
3 *  Copyright (C) 2002-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 channel control block state machine and
22 *  functions which operate on the channel control block.
23 *
24 ******************************************************************************/
25
26#include <string.h>
27#include "avdt_api.h"
28#include "avdt_int.h"
29#include "avdtc_api.h"
30#include "bt_common.h"
31#include "bt_target.h"
32#include "bt_types.h"
33#include "bt_utils.h"
34#include "btu.h"
35#include "osi/include/osi.h"
36
37/*****************************************************************************
38 * state machine constants and types
39 ****************************************************************************/
40#if (AVDT_DEBUG == TRUE)
41
42/* verbose state strings for trace */
43const char* const avdt_ccb_st_str[] = {"CCB_IDLE_ST", "CCB_OPENING_ST",
44                                       "CCB_OPEN_ST", "CCB_CLOSING_ST"};
45
46/* verbose event strings for trace */
47const char* const avdt_ccb_evt_str[] = {
48    "API_DISCOVER_REQ_EVT", "API_GETCAP_REQ_EVT",
49    "API_START_REQ_EVT",    "API_SUSPEND_REQ_EVT",
50    "API_DISCOVER_RSP_EVT", "API_GETCAP_RSP_EVT",
51    "API_START_RSP_EVT",    "API_SUSPEND_RSP_EVT",
52    "API_CONNECT_REQ_EVT",  "API_DISCONNECT_REQ_EVT",
53    "MSG_DISCOVER_CMD_EVT", "MSG_GETCAP_CMD_EVT",
54    "MSG_START_CMD_EVT",    "MSG_SUSPEND_CMD_EVT",
55    "MSG_DISCOVER_RSP_EVT", "MSG_GETCAP_RSP_EVT",
56    "MSG_START_RSP_EVT",    "MSG_SUSPEND_RSP_EVT",
57    "RCVRSP_EVT",           "SENDMSG_EVT",
58    "RET_TOUT_EVT",         "RSP_TOUT_EVT",
59    "IDLE_TOUT_EVT",        "UL_OPEN_EVT",
60    "UL_CLOSE_EVT",         "LL_OPEN_EVT",
61    "LL_CLOSE_EVT",         "LL_CONG_EVT"};
62
63#endif
64
65/* action function list */
66const tAVDT_CCB_ACTION avdt_ccb_action[] = {
67    avdt_ccb_chan_open,        avdt_ccb_chan_close,
68    avdt_ccb_chk_close,        avdt_ccb_hdl_discover_cmd,
69    avdt_ccb_hdl_discover_rsp, avdt_ccb_hdl_getcap_cmd,
70    avdt_ccb_hdl_getcap_rsp,   avdt_ccb_hdl_start_cmd,
71    avdt_ccb_hdl_start_rsp,    avdt_ccb_hdl_suspend_cmd,
72    avdt_ccb_hdl_suspend_rsp,  avdt_ccb_snd_discover_cmd,
73    avdt_ccb_snd_discover_rsp, avdt_ccb_snd_getcap_cmd,
74    avdt_ccb_snd_getcap_rsp,   avdt_ccb_snd_start_cmd,
75    avdt_ccb_snd_start_rsp,    avdt_ccb_snd_suspend_cmd,
76    avdt_ccb_snd_suspend_rsp,  avdt_ccb_clear_cmds,
77    avdt_ccb_cmd_fail,         avdt_ccb_free_cmd,
78    avdt_ccb_cong_state,       avdt_ccb_ret_cmd,
79    avdt_ccb_snd_cmd,          avdt_ccb_snd_msg,
80    avdt_ccb_set_reconn,       avdt_ccb_clr_reconn,
81    avdt_ccb_chk_reconn,       avdt_ccb_chk_timer,
82    avdt_ccb_set_conn,         avdt_ccb_set_disconn,
83    avdt_ccb_do_disconn,       avdt_ccb_ll_closed,
84    avdt_ccb_ll_opened,        avdt_ccb_dealloc};
85
86/* state table information */
87#define AVDT_CCB_ACTIONS 2    /* number of actions */
88#define AVDT_CCB_NEXT_STATE 2 /* position of next state */
89#define AVDT_CCB_NUM_COLS 3   /* number of columns in state tables */
90
91/* state table for idle state */
92const uint8_t avdt_ccb_st_idle[][AVDT_CCB_NUM_COLS] = {
93    /* Event */
94    /* Action 1                    Action 2                    Next state */
95    /* API_DISCOVER_REQ_EVT */
96    {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
97    /* API_GETCAP_REQ_EVT */
98    {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
99    /* API_START_REQ_EVT */
100    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
101    /* API_SUSPEND_REQ_EVT */
102    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
103    /* API_DISCOVER_RSP_EVT */
104    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
105    /* API_GETCAP_RSP_EVT */
106    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
107    /* API_START_RSP_EVT */
108    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
109    /* API_SUSPEND_RSP_EVT */
110    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
111    /* API_CONNECT_REQ_EVT */
112    {AVDT_CCB_SET_CONN, AVDT_CCB_CHAN_OPEN, AVDT_CCB_OPENING_ST},
113    /* API_DISCONNECT_REQ_EVT */
114    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
115    /* MSG_DISCOVER_CMD_EVT */
116    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
117    /* MSG_GETCAP_CMD_EVT */
118    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
119    /* MSG_START_CMD_EVT */
120    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
121    /* MSG_SUSPEND_CMD_EVT */
122    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
123    /* MSG_DISCOVER_RSP_EVT */
124    {AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
125    /* MSG_GETCAP_RSP_EVT */
126    {AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
127    /* MSG_START_RSP_EVT */
128    {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
129    /* MSG_SUSPEND_RSP_EVT */
130    {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
131    /* RCVRSP_EVT */
132    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
133    /* SENDMSG_EVT */
134    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
135    /* RET_TOUT_EVT */
136    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
137    /* RSP_TOUT_EVT */
138    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
139    /* IDLE_TOUT_EVT */
140    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
141    /* UL_OPEN_EVT */
142    {AVDT_CCB_CHAN_OPEN, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
143    /* UL_CLOSE_EVT */
144    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
145    /* LL_OPEN_EVT */
146    {AVDT_CCB_LL_OPENED, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
147    /* LL_CLOSE_EVT */
148    {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
149    /* LL_CONG_EVT */
150    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST}};
151
152/* state table for opening state */
153const uint8_t avdt_ccb_st_opening[][AVDT_CCB_NUM_COLS] = {
154    /* Event */
155    /* Action 1                    Action 2                    Next state */
156    /* API_DISCOVER_REQ_EVT */
157    {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
158    /* API_GETCAP_REQ_EVT */
159    {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
160    /* API_START_REQ_EVT */
161    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
162    /* API_SUSPEND_REQ_EVT */
163    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
164    /* API_DISCOVER_RSP_EVT */
165    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
166    /* API_GETCAP_RSP_EVT */
167    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
168    /* API_START_RSP_EVT */
169    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
170    /* API_SUSPEND_RSP_EVT */
171    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
172    /* API_CONNECT_REQ_EVT */
173    {AVDT_CCB_SET_CONN, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
174    /* API_DISCONNECT_REQ_EVT */
175    {AVDT_CCB_SET_DISCONN, AVDT_CCB_DO_DISCONN, AVDT_CCB_CLOSING_ST},
176    /* MSG_DISCOVER_CMD_EVT */
177    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
178    /* MSG_GETCAP_CMD_EVT */
179    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
180    /* MSG_START_CMD_EVT */
181    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
182    /* MSG_SUSPEND_CMD_EVT */
183    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
184    /* MSG_DISCOVER_RSP_EVT */
185    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
186    /* MSG_GETCAP_RSP_EVT */
187    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
188    /* MSG_START_RSP_EVT */
189    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
190    /* MSG_SUSPEND_RSP_EVT */
191    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
192    /* RCVRSP_EVT */
193    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
194    /* SENDMSG_EVT */
195    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
196    /* RET_TOUT_EVT */
197    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
198    /* RSP_TOUT_EVT */
199    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
200    /* IDLE_TOUT_EVT */
201    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
202    /* UL_OPEN_EVT */
203    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST},
204    /* UL_CLOSE_EVT */
205    {AVDT_CCB_CLEAR_CMDS, AVDT_CCB_CHAN_CLOSE, AVDT_CCB_CLOSING_ST},
206    /* LL_OPEN_EVT */
207    {AVDT_CCB_SND_CMD, AVDT_CCB_LL_OPENED, AVDT_CCB_OPEN_ST},
208    /* LL_CLOSE_EVT */
209    {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
210    /* LL_CONG_EVT */
211    {AVDT_CCB_CONG_STATE, AVDT_CCB_IGNORE, AVDT_CCB_OPENING_ST}};
212
213/* state table for open state */
214const uint8_t avdt_ccb_st_open[][AVDT_CCB_NUM_COLS] = {
215    /* Event */
216    /* Action 1                    Action 2                    Next state */
217    /* API_DISCOVER_REQ_EVT */
218    {AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
219    /* API_GETCAP_REQ_EVT */
220    {AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
221    /* API_START_REQ_EVT */
222    {AVDT_CCB_SND_START_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
223    /* API_SUSPEND_REQ_EVT */
224    {AVDT_CCB_SND_SUSPEND_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
225    /* API_DISCOVER_RSP_EVT */
226    {AVDT_CCB_SND_DISCOVER_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
227    /* API_GETCAP_RSP_EVT */
228    {AVDT_CCB_SND_GETCAP_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
229    /* API_START_RSP_EVT */
230    {AVDT_CCB_SND_START_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
231    /* API_SUSPEND_RSP_EVT */
232    {AVDT_CCB_SND_SUSPEND_RSP, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
233    /* API_CONNECT_REQ_EVT */
234    {AVDT_CCB_SET_CONN, AVDT_CCB_LL_OPENED, AVDT_CCB_OPEN_ST},
235    /* API_DISCONNECT_REQ_EVT */
236    {AVDT_CCB_SET_DISCONN, AVDT_CCB_DO_DISCONN, AVDT_CCB_CLOSING_ST},
237    /* MSG_DISCOVER_CMD_EVT */
238    {AVDT_CCB_HDL_DISCOVER_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
239    /* MSG_GETCAP_CMD_EVT */
240    {AVDT_CCB_HDL_GETCAP_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
241    /* MSG_START_CMD_EVT */
242    {AVDT_CCB_HDL_START_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
243    /* MSG_SUSPEND_CMD_EVT */
244    {AVDT_CCB_HDL_SUSPEND_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
245    /* MSG_DISCOVER_RSP_EVT */
246    {AVDT_CCB_CHK_CLOSE, AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_OPEN_ST},
247    /* MSG_GETCAP_RSP_EVT */
248    {AVDT_CCB_CHK_CLOSE, AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_OPEN_ST},
249    /* MSG_START_RSP_EVT */
250    {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
251    /* MSG_SUSPEND_RSP_EVT */
252    {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
253    /* RCVRSP_EVT */
254    {AVDT_CCB_FREE_CMD, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
255    /* SENDMSG_EVT */
256    {AVDT_CCB_SND_MSG, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
257    /* RET_TOUT_EVT */
258    {AVDT_CCB_RET_CMD, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
259    /* RSP_TOUT_EVT */
260    {AVDT_CCB_CMD_FAIL, AVDT_CCB_SND_CMD, AVDT_CCB_OPEN_ST},
261    /* IDLE_TOUT_EVT */
262    {AVDT_CCB_CLEAR_CMDS, AVDT_CCB_CHAN_CLOSE, AVDT_CCB_CLOSING_ST},
263    /* UL_OPEN_EVT */
264    {AVDT_CCB_CHK_TIMER, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
265    /* UL_CLOSE_EVT */
266    {AVDT_CCB_CHK_CLOSE, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
267    /* LL_OPEN_EVT */
268    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_OPEN_ST},
269    /* LL_CLOSE_EVT */
270    {AVDT_CCB_LL_CLOSED, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
271    /* LL_CONG_EVT */
272    {AVDT_CCB_CONG_STATE, AVDT_CCB_SND_MSG, AVDT_CCB_OPEN_ST}};
273
274/* state table for closing state */
275const uint8_t avdt_ccb_st_closing[][AVDT_CCB_NUM_COLS] = {
276    /* Event */
277    /* Action 1                    Action 2                    Next state */
278    /* API_DISCOVER_REQ_EVT */
279    {AVDT_CCB_SET_RECONN, AVDT_CCB_SND_DISCOVER_CMD, AVDT_CCB_CLOSING_ST},
280    /* API_GETCAP_REQ_EVT */
281    {AVDT_CCB_SET_RECONN, AVDT_CCB_SND_GETCAP_CMD, AVDT_CCB_CLOSING_ST},
282    /* API_START_REQ_EVT */
283    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
284    /* API_SUSPEND_REQ_EVT */
285    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
286    /* API_DISCOVER_RSP_EVT */
287    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
288    /* API_GETCAP_RSP_EVT */
289    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
290    /* API_START_RSP_EVT */
291    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
292    /* API_SUSPEND_RSP_EVT */
293    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
294    /* API_CONNECT_REQ_EVT */
295    {AVDT_CCB_SET_RECONN, AVDT_CCB_SET_CONN, AVDT_CCB_CLOSING_ST},
296    /* API_DISCONNECT_REQ_EVT */
297    {AVDT_CCB_CLR_RECONN, AVDT_CCB_SET_DISCONN, AVDT_CCB_CLOSING_ST},
298    /* MSG_DISCOVER_CMD_EVT */
299    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
300    /* MSG_GETCAP_CMD_EVT */
301    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
302    /* MSG_START_CMD_EVT */
303    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
304    /* MSG_SUSPEND_CMD_EVT */
305    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
306    /* MSG_DISCOVER_RSP_EVT */
307    {AVDT_CCB_HDL_DISCOVER_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
308    /* MSG_GETCAP_RSP_EVT */
309    {AVDT_CCB_HDL_GETCAP_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
310    /* MSG_START_RSP_EVT */
311    {AVDT_CCB_HDL_START_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
312    /* MSG_SUSPEND_RSP_EVT */
313    {AVDT_CCB_HDL_SUSPEND_RSP, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
314    /* RCVRSP_EVT */
315    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
316    /* SENDMSG_EVT */
317    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
318    /* RET_TOUT_EVT */
319    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
320    /* RSP_TOUT_EVT */
321    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
322    /* IDLE_TOUT_EVT */
323    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
324    /* UL_OPEN_EVT */
325    {AVDT_CCB_SET_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
326    /* UL_CLOSE_EVT */
327    {AVDT_CCB_CLR_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
328    /* LL_OPEN_EVT */
329    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST},
330    /* LL_CLOSE_EVT */
331    {AVDT_CCB_CHK_RECONN, AVDT_CCB_IGNORE, AVDT_CCB_IDLE_ST},
332    /* LL_CONG_EVT */
333    {AVDT_CCB_IGNORE, AVDT_CCB_IGNORE, AVDT_CCB_CLOSING_ST}};
334
335/* type for state table */
336typedef const uint8_t (*tAVDT_CCB_ST_TBL)[AVDT_CCB_NUM_COLS];
337
338/* state table */
339const tAVDT_CCB_ST_TBL avdt_ccb_st_tbl[] = {
340    avdt_ccb_st_idle, avdt_ccb_st_opening, avdt_ccb_st_open,
341    avdt_ccb_st_closing};
342
343/*******************************************************************************
344 *
345 * Function         avdt_ccb_init
346 *
347 * Description      Initialize channel control block module.
348 *
349 *
350 * Returns          Nothing.
351 *
352 ******************************************************************************/
353void avdt_ccb_init(void) {
354  memset(&avdt_cb.ccb[0], 0, sizeof(tAVDT_CCB) * AVDT_NUM_LINKS);
355  avdt_cb.p_ccb_act = (tAVDT_CCB_ACTION*)avdt_ccb_action;
356}
357
358/*******************************************************************************
359 *
360 * Function         avdt_ccb_event
361 *
362 * Description      State machine event handling function for ccb
363 *
364 *
365 * Returns          Nothing.
366 *
367 ******************************************************************************/
368void avdt_ccb_event(tAVDT_CCB* p_ccb, uint8_t event, tAVDT_CCB_EVT* p_data) {
369  tAVDT_CCB_ST_TBL state_table;
370  uint8_t action;
371  int i;
372
373#if (AVDT_DEBUG == TRUE)
374  AVDT_TRACE_EVENT("%s: CCB ccb=%d event=%s state=%s", __func__,
375                   avdt_ccb_to_idx(p_ccb), avdt_ccb_evt_str[event],
376                   avdt_ccb_st_str[p_ccb->state]);
377#endif
378
379  /* look up the state table for the current state */
380  state_table = avdt_ccb_st_tbl[p_ccb->state];
381
382  /* set next state */
383  if (p_ccb->state != state_table[event][AVDT_CCB_NEXT_STATE]) {
384    p_ccb->state = state_table[event][AVDT_CCB_NEXT_STATE];
385  }
386
387  /* execute action functions */
388  for (i = 0; i < AVDT_CCB_ACTIONS; i++) {
389    action = state_table[event][i];
390    if (action != AVDT_CCB_IGNORE) {
391      (*avdt_cb.p_ccb_act[action])(p_ccb, p_data);
392    } else {
393      break;
394    }
395  }
396}
397
398/*******************************************************************************
399 *
400 * Function         avdt_ccb_by_bd
401 *
402 * Description      This lookup function finds the ccb for a BD address.
403 *
404 *
405 * Returns          pointer to the ccb, or NULL if none found.
406 *
407 ******************************************************************************/
408tAVDT_CCB* avdt_ccb_by_bd(BD_ADDR bd_addr) {
409  tAVDT_CCB* p_ccb = &avdt_cb.ccb[0];
410  int i;
411
412  for (i = 0; i < AVDT_NUM_LINKS; i++, p_ccb++) {
413    /* if allocated ccb has matching ccb */
414    if (p_ccb->allocated && (!memcmp(p_ccb->peer_addr, bd_addr, BD_ADDR_LEN))) {
415      break;
416    }
417  }
418
419  if (i == AVDT_NUM_LINKS) {
420    /* if no ccb found */
421    p_ccb = NULL;
422
423    AVDT_TRACE_DEBUG("No ccb for addr %02x-%02x-%02x-%02x-%02x-%02x",
424                     bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4],
425                     bd_addr[5]);
426  }
427  return p_ccb;
428}
429
430/*******************************************************************************
431 *
432 * Function         avdt_ccb_alloc
433 *
434 * Description      Allocate a channel control block.
435 *
436 *
437 * Returns          pointer to the ccb, or NULL if none could be allocated.
438 *
439 ******************************************************************************/
440tAVDT_CCB* avdt_ccb_alloc(BD_ADDR bd_addr) {
441  tAVDT_CCB* p_ccb = &avdt_cb.ccb[0];
442  int i;
443
444  for (i = 0; i < AVDT_NUM_LINKS; i++, p_ccb++) {
445    if (!p_ccb->allocated) {
446      p_ccb->allocated = true;
447      memcpy(p_ccb->peer_addr, bd_addr, BD_ADDR_LEN);
448      p_ccb->cmd_q = fixed_queue_new(SIZE_MAX);
449      p_ccb->rsp_q = fixed_queue_new(SIZE_MAX);
450      p_ccb->idle_ccb_timer = alarm_new("avdt_ccb.idle_ccb_timer");
451      p_ccb->ret_ccb_timer = alarm_new("avdt_ccb.ret_ccb_timer");
452      p_ccb->rsp_ccb_timer = alarm_new("avdt_ccb.rsp_ccb_timer");
453      AVDT_TRACE_DEBUG("avdt_ccb_alloc %d", i);
454      break;
455    }
456  }
457
458  if (i == AVDT_NUM_LINKS) {
459    /* out of ccbs */
460    p_ccb = NULL;
461    AVDT_TRACE_WARNING("Out of ccbs");
462  }
463  return p_ccb;
464}
465
466/*******************************************************************************
467 *
468 * Function         avdt_ccb_dealloc
469 *
470 * Description      Deallocate a stream control block.
471 *
472 *
473 * Returns          void.
474 *
475 ******************************************************************************/
476void avdt_ccb_dealloc(tAVDT_CCB* p_ccb, UNUSED_ATTR tAVDT_CCB_EVT* p_data) {
477  AVDT_TRACE_DEBUG("avdt_ccb_dealloc %d", avdt_ccb_to_idx(p_ccb));
478  alarm_free(p_ccb->idle_ccb_timer);
479  alarm_free(p_ccb->ret_ccb_timer);
480  alarm_free(p_ccb->rsp_ccb_timer);
481  fixed_queue_free(p_ccb->cmd_q, NULL);
482  fixed_queue_free(p_ccb->rsp_q, NULL);
483  memset(p_ccb, 0, sizeof(tAVDT_CCB));
484}
485
486/*******************************************************************************
487 *
488 * Function         avdt_ccb_to_idx
489 *
490 * Description      Given a pointer to an ccb, return its index.
491 *
492 *
493 * Returns          Index of ccb.
494 *
495 ******************************************************************************/
496uint8_t avdt_ccb_to_idx(tAVDT_CCB* p_ccb) {
497  /* use array arithmetic to determine index */
498  return (uint8_t)(p_ccb - avdt_cb.ccb);
499}
500
501/*******************************************************************************
502 *
503 * Function         avdt_ccb_by_idx
504 *
505 * Description      Return ccb pointer based on ccb index.
506 *
507 *
508 * Returns          pointer to the ccb, or NULL if none found.
509 *
510 ******************************************************************************/
511tAVDT_CCB* avdt_ccb_by_idx(uint8_t idx) {
512  tAVDT_CCB* p_ccb;
513
514  /* verify index */
515  if (idx < AVDT_NUM_LINKS) {
516    p_ccb = &avdt_cb.ccb[idx];
517  } else {
518    p_ccb = NULL;
519    AVDT_TRACE_WARNING("No ccb for idx %d", idx);
520  }
521  return p_ccb;
522}
523