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