1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "avdtp_ctrl.h"
17 #include "avdtp_impl.h"
18 #include "avdtp_message.h"
19 #include "btm.h"
20 #include "btm/btm_thread.h"
21 #include "log.h"
22 #include "securec.h"
23
24 /**
25 * Action function list
26 */
27 const AvdtStreamAction AVDT_STREAM_ACTION[] = {
28 AvdtActSetConfigReq, /* 0 */
29 AvdtActSetConfigRsp,
30 AvdtActSetConfigInd,
31 AvdtActSetConfigCfm,
32 AvdtActGetConfigReq,
33 AvdtActGetConfigRsp,
34 AvdtActGetConfigInd,
35 AvdtActGetConfigCfm,
36 AvdtActOpenReq,
37 AvdtActOpenRsp,
38 AvdtActOpenInd, /* 10 */
39 AvdtActOpenCfm,
40 AvdtActReconfigReq,
41 AvdtActReconfigRsp,
42 AvdtActReconfigInd,
43 AvdtActReconfigCfm,
44 AvdtActStartReq,
45 AvdtActStartRsp,
46 AvdtActStartInd,
47 AvdtActStartCfm,
48 AvdtActSuspendReq, /* 20 */
49 AvdtActSuspendRsp,
50 AvdtActSuspendInd,
51 AvdtActSuspendCfm,
52 AvdtActCloseReq,
53 AvdtActCloseRsp,
54 AvdtActCloseInd,
55 AvdtActCloseCfm,
56 AvdtActAbortReq,
57 AvdtActAbortRsp,
58 AvdtActAbortInd, /* 30 */
59 AvdtActAbortCfm,
60 AvdtActDelayRptReq,
61 AvdtActDelayRptRsp,
62 AvdtActDelayRptInd,
63 AvdtActDelayRptCfm,
64 AvdtActWriteReq,
65 AvdtActWriteCfm,
66 AvdtActReadInd,
67 AvdtActStreamOpenReq,
68 AvdtActStreamOpenRsp, /* 40 */
69 AvdtActStreamOpenInd,
70 AvdtActStreamOpenCfm,
71 AvdtActStreamCloseReq,
72 AvdtActStreamCloseRsp,
73 AvdtActStreamCloseInd,
74 AvdtActStreamCloseCfm,
75 AvdtActBadStateRej, /* 47 */
76 };
77 const AvdtSigAction AVDT_SIG_ACTION[] = {
78 AvdtActDiscoverReq, /* 0 */
79 AvdtActDiscoverRsp,
80 AvdtActDiscoverInd,
81 AvdtActDiscoverCfm,
82 AvdtActGetCapReq,
83 AvdtActGetCapRsp,
84 AvdtActGetCapInd,
85 AvdtActGetCapCfm,
86 AvdtActGetAllCapReq,
87 AvdtActGetAllCapRsp,
88 AvdtActGetAllCapInd, /* 10 */
89 AvdtActGetAllCapCfm,
90 AvdtActConnReq,
91 AvdtActConnRsp,
92 AvdtActConnInd,
93 AvdtActConnCfm,
94 AvdtActDisconnReq,
95 AvdtActDisconnRsp,
96 AvdtActDisconnInd,
97 AvdtActDisconnCfm,
98 AvdtActSndMsg, /* 20 */
99 };
100
101 AvdtCB g_avdtCb;
102 /**
103 * State table information
104 */
105 #define AVDT_STREAM_NEXT_STATE 1
106 #define AVDT_STREAM_NUM_COLS 2
107
108 #define AVDT_2MB_MODE 1
109 #define AVDT_3MB_MODE 2
110 /**
111 * Init status: Idle
112 */
113 const uint8_t AVDT_STREAM_ST_IDLE[][AVDT_STREAM_NUM_COLS] = {
114 /* AVDT_SETCONFIGURE_CMD_REQ_EVENT */
115 {AVDT_SETCONFIGURE_REQ, AVDT_IDLE_ST},
116 /* AVDT_SETCONFIGURE_CMD_RSP_EVENT */
117 {AVDT_SETCONFIGURE_RSP, AVDT_CONFIGURE_ST},
118 /* AVDT_SETCONFIGURE_CMD_IND_EVENT */
119 {AVDT_SETCONFIGURE_IND, AVDT_IDLE_ST},
120 /* AVDT_SETCONFIGURE_CMD_CFM_EVENT */
121 {AVDT_SETCONFIGURE_CFM, AVDT_CONFIGURE_ST},
122 /* AVDT_GETCONFIGURE_CMD_REQ_EVENT */
123 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
124 /* AVDT_GETCONFIGURE_CMD_RSP_EVENT */
125 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
126 /* AVDT_GETCONFIGURE_CMD_IND_EVENT */
127 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
128 /* AVDT_GETCONFIGURE_CMD_CFM_EVENT */
129 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
130 /* AVDT_OPEN_CMD_REQ_EVENT */
131 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
132 /* AVDT_OPEN_CMD_RSP_EVENT */
133 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
134 /* AVDT_OPEN_CMD_IND_EVENT */
135 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
136 /* AVDT_OPEN_CMD_CFM_EVENT */
137 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
138 /* AVDT_RECONFIGURE_CMD_REQ_EVENT */
139 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
140 /* AVDT_RECONFIGURE_CMD_RSP_EVENT */
141 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
142 /* AVDT_RECONFIGURE_CMD_IND_EVENT */
143 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
144 /* AVDT_RECONFIGURE_CMD_CFM_EVENT */
145 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
146 /* AVDT_START_CMD_REQ_EVENT */
147 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
148 /* AVDT_START_CMD_RSP_EVENT */
149 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
150 /* AVDT_START_CMD_IND_EVENT */
151 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
152 /* AVDT_START_CMD_CFM_EVENT */
153 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
154 /* AVDT_SUSPEND_CMD_REQ_EVENT */
155 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
156 /* AVDT_SUSPEND_CMD_RSP_EVENT */
157 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
158 /* AVDT_SUSPEND_CMD_IND_EVENT */
159 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
160 /* AVDT_SUSPEND_CMD_CFM_EVENT */
161 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
162 /* AVDT_CLOSE_CMD_REQ_EVENT */
163 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
164 /* AVDT_CLOSE_CMD_RSP_EVENT */
165 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
166 /* AVDT_CLOSE_CMD_IND_EVENT */
167 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
168 /* AVDT_CLOSE_CMD_CFM_EVENT */
169 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
170 /* AVDT_ABORT_CMD_REQ_EVENT */
171 {AVDT_ABORT_REQ, AVDT_IDLE_ST},
172 /* AVDT_ABORT_CMD_RSP_EVENT */
173 {AVDT_ABORT_RSP, AVDT_IDLE_ST},
174 /* AVDT_ABORT_CMD_IND_EVENT */
175 {AVDT_ABORT_IND, AVDT_IDLE_ST},
176 /* AVDT_ABORT_CMD_CFM_EVENT */
177 {AVDT_ABORT_CFM, AVDT_IDLE_ST},
178 /* AVDT_DELAY_CMD_REQ_EVENT */
179 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
180 /* AVDT_DELAY_CMD_RSP_EVENT */
181 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
182 /* AVDT_DELAY_CMD_IND_EVENT */
183 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
184 /* AVDT_DELAY_CMD_CFM_EVENT */
185 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
186 /* AVDT_WRITE_CMD_REQ_EVENT */
187 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
188 /* AVDT_WRITE_CMD_CFM_EVENT */
189 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
190 /* AVDT_READ_CMD_IND_EVENT */
191 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
192 /* AVDT_STREAM_OPEN_CMD_REQ_EVENT */
193 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
194 /* AVDT_STREAM_OPEN_CMD_RSP_EVENT */
195 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
196 /* AVDT_STREAM_OPEN_CMD_IND_EVENT */
197 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
198 /* AVDT_STREAM_OPEN_CMD_CFM_EVENT */
199 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
200 /* AVDT_STREAM_CLOSE_CMD_REQ_EVENT */
201 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
202 /* AVDT_STREAM_CLOSE_CMD_RSP_EVENT */
203 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
204 /* AVDT_STREAM_CLOSE_CMD_IND_EVENT */
205 {AVDT_BAD_STATE_REJ, AVDT_IDLE_ST},
206 /* AVDT_STREAM_CLOSE_CMD_CFM_EVENT */
207 {AVDT_SSM_IGNORE, AVDT_IDLE_ST},
208 };
209
210 /**
211 * Configure Status
212 */
213 const uint8_t AVDT_STREAM_ST_CONFIG[][AVDT_STREAM_NUM_COLS] = {
214 /* AVDT_SETCONFIGURE_CMD_REQ_EVENT */
215 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
216 /* AVDT_SETCONFIGURE_CMD_RSP_EVENT */
217 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
218 /* AVDT_SETCONFIGURE_CMD_IND_EVENT */
219 {AVDT_SETCONFIGURE_IND, AVDT_CONFIGURE_ST},
220 /* AVDT_SETCONFIGURE_CMD_CFM_EVENT */
221 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
222 /* AVDT_GETCONFIGURE_CMD_REQ_EVENT */
223 {AVDT_GETCONFIGURE_REQ, AVDT_CONFIGURE_ST},
224 /* AVDT_GETCONFIGURE_CMD_RSP_EVENT */
225 {AVDT_GETCONFIGURE_RSP, AVDT_CONFIGURE_ST},
226 /* AVDT_GETCONFIGURE_CMD_IND_EVENT */
227 {AVDT_GETCONFIGURE_IND, AVDT_CONFIGURE_ST},
228 /* AVDT_GETCONFIGURE_CMD_CFM_EVENT */
229 {AVDT_GETCONFIGURE_CFM, AVDT_CONFIGURE_ST},
230 /* AVDT_OPEN_CMD_REQ_EVENT */
231 {AVDT_OPEN_REQ, AVDT_OPENING_ST},
232 /* AVDT_OPEN_CMD_RSP_EVENT */
233 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
234 /* AVDT_OPEN_CMD_IND_EVENT */
235 {AVDT_OPEN_IND, AVDT_OPENING_ST},
236 /* AVDT_OPEN_CMD_CFM_EVENT */
237 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
238 /* AVDT_RECONFIGURE_CMD_REQ_EVENT */
239 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
240 /* AVDT_RECONFIGURE_CMD_RSP_EVENT */
241 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
242 /* AVDT_RECONFIGURE_CMD_IND_EVENT */
243 {AVDT_BAD_STATE_REJ, AVDT_CONFIGURE_ST},
244 /* AVDT_RECONFIGURE_CMD_CFM_EVENT */
245 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
246 /* AVDT_START_CMD_REQ_EVENT */
247 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
248 /* AVDT_START_CMD_RSP_EVENT */
249 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
250 /* AVDT_START_CMD_IND_EVENT */
251 {AVDT_BAD_STATE_REJ, AVDT_CONFIGURE_ST},
252 /* AVDT_START_CMD_CFM_EVENT */
253 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
254 /* AVDT_SUSPEND_CMD_REQ_EVENT */
255 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
256 /* AVDT_SUSPEND_CMD_RSP_EVENT */
257 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
258 /* AVDT_SUSPEND_CMD_IND_EVENT */
259 {AVDT_BAD_STATE_REJ, AVDT_CONFIGURE_ST},
260 /* AVDT_SUSPEND_CMD_CFM_EVENT */
261 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
262 /* AVDT_CLOSE_CMD_REQ_EVENT */
263 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
264 /* AVDT_CLOSE_CMD_RSP_EVENT */
265 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
266 /* AVDT_CLOSE_CMD_IND_EVENT */
267 {AVDT_BAD_STATE_REJ, AVDT_CONFIGURE_ST},
268 /* AVDT_CLOSE_CMD_CFM_EVENT */
269 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
270 /* AVDT_ABORT_CMD_REQ_EVENT */
271 {AVDT_ABORT_REQ, AVDT_CONFIGURE_ST},
272 /* AVDT_ABORT_CMD_RSP_EVENT */
273 {AVDT_ABORT_RSP, AVDT_CLOSING_ST},
274 /* AVDT_ABORT_CMD_IND_EVENT */
275 {AVDT_ABORT_IND, AVDT_CONFIGURE_ST},
276 /* AVDT_ABORT_CMD_CFM_EVENT */
277 {AVDT_ABORT_CFM, AVDT_CLOSING_ST},
278 /* AVDT_DELAY_CMD_REQ_EVENT */
279 {AVDT_DELAY_REQ, AVDT_CONFIGURE_ST},
280 /* AVDT_DELAY_CMD_RSP_EVENT */
281 {AVDT_DELAY_RSP, AVDT_CONFIGURE_ST},
282 /* AVDT_DELAY_CMD_IND_EVENT */
283 {AVDT_DELAY_IND, AVDT_CONFIGURE_ST},
284 /* AVDT_DELAY_CMD_CFM_EVENT */
285 {AVDT_DELAY_CFM, AVDT_CONFIGURE_ST},
286 /* AVDT_WRITE_CMD_REQ_EVENT */
287 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
288 /* AVDT_WRITE_CMD_CFM_EVENT */
289 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
290 /* AVDT_READ_CMD_IND_EVENT */
291 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
292 /* AVDT_STREAM_OPEN_CMD_REQ_EVENT */
293 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
294 /* AVDT_STREAM_OPEN_CMD_RSP_EVENT */
295 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
296 /* AVDT_STREAM_OPEN_CMD_IND_EVENT */
297 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
298 /* AVDT_STREAM_OPEN_CMD_CFM_EVENT */
299 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
300 /* AVDT_STREAM_CLOSE_CMD_REQ_EVENT */
301 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
302 /* AVDT_STREAM_CLOSE_CMD_RSP_EVENT */
303 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
304 /* AVDT_STREAM_CLOSE_CMD_IND_EVENT */
305 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
306 /* AVDT_STREAM_CLOSE_CMD_CFM_EVENT */
307 {AVDT_SSM_IGNORE, AVDT_CONFIGURE_ST},
308 };
309
310 /**
311 * Opening Status
312 */
313 const uint8_t AVDT_STREAM_ST_OPENING[][AVDT_STREAM_NUM_COLS] = {
314 /* AVDT_SETCONFIGURE_CMD_REQ_EVENT */
315 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
316 /* AVDT_SETCONFIGURE_CMD_RSP_EVENT */
317 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
318 /* AVDT_SETCONFIGURE_CMD_IND_EVENT */
319 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
320 /* AVDT_SETCONFIGURE_CMD_CFM_EVENT */
321 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
322 /* AVDT_GETCONFIGURE_CMD_REQ_EVENT */
323 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
324 /* AVDT_GETCONFIGURE_CMD_RSP_EVENT */
325 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
326 /* AVDT_GETCONFIGURE_CMD_IND_EVENT */
327 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
328 /* AVDT_GETCONFIGURE_CMD_CFM_EVENT */
329 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
330 /* AVDT_OPEN_CMD_REQ_EVENT */
331 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
332 /* AVDT_OPEN_CMD_RSP_EVENT */
333 {AVDT_OPEN_RSP, AVDT_OPENING_ST},
334 /* AVDT_OPEN_CMD_IND_EVENT */
335 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
336 /* AVDT_OPEN_CMD_CFM_EVENT */
337 {AVDT_OPEN_CFM, AVDT_OPENING_ST},
338 /* AVDT_RECONFIGURE_CMD_REQ_EVENT */
339 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
340 /* AVDT_RECONFIGURE_CMD_RSP_EVENT */
341 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
342 /* AVDT_RECONFIGURE_CMD_IND_EVENT */
343 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
344 /* AVDT_RECONFIGURE_CMD_CFM_EVENT */
345 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
346 /* AVDT_START_CMD_REQ_EVENT */
347 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
348 /* AVDT_START_CMD_RSP_EVENT */
349 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
350 /* AVDT_START_CMD_IND_EVENT */
351 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
352 /* AVDT_START_CMD_CFM_EVENT */
353 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
354 /* AVDT_SUSPEND_CMD_REQ_EVENT */
355 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
356 /* AVDT_SUSPEND_CMD_RSP_EVENT */
357 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
358 /* AVDT_SUSPEND_CMD_IND_EVENT */
359 {AVDT_BAD_STATE_REJ, AVDT_OPENING_ST},
360 /* AVDT_SUSPEND_CMD_CFM_EVENT */
361 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
362 /* AVDT_CLOSE_CMD_REQ_EVENT */
363 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
364 /* AVDT_CLOSE_CMD_RSP_EVENT */
365 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
366 /* AVDT_CLOSE_CMD_IND_EVENT */
367 {AVDT_BAD_STATE_REJ, AVDT_OPENING_ST},
368 /* AVDT_CLOSE_CMD_CFM_EVENT */
369 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
370 /* AVDT_ABORT_CMD_REQ_EVENT */
371 {AVDT_ABORT_REQ, AVDT_OPENING_ST},
372 /* AVDT_ABORT_CMD_RSP_EVENT */
373 {AVDT_ABORT_RSP, AVDT_CLOSING_ST},
374 /* AVDT_ABORT_CMD_IND_EVENT */
375 {AVDT_ABORT_IND, AVDT_OPENING_ST},
376 /* AVDT_ABORT_CMD_CFM_EVENT */
377 {AVDT_ABORT_CFM, AVDT_CLOSING_ST},
378 /* AVDT_DELAY_CMD_REQ_EVENT */
379 {AVDT_DELAY_REQ, AVDT_OPENING_ST},
380 /* AVDT_DELAY_CMD_RSP_EVENT */
381 {AVDT_DELAY_RSP, AVDT_OPENING_ST},
382 /* AVDT_DELAY_CMD_IND_EVENT */
383 {AVDT_DELAY_IND, AVDT_OPENING_ST},
384 /* AVDT_DELAY_CMD_CFM_EVENT */
385 {AVDT_DELAY_CFM, AVDT_OPENING_ST},
386 /* AVDT_WRITE_CMD_REQ_EVENT */
387 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
388 /* AVDT_WRITE_CMD_CFM_EVENT */
389 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
390 /* AVDT_READ_CMD_IND_EVENT */
391 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
392 /* AVDT_STREAM_OPEN_CMD_REQ_EVENT */
393 {AVDT_STREAM_OPEN_REQ, AVDT_OPEN_ST},
394 /* AVDT_STREAM_OPEN_CMD_RSP_EVENT */
395 {AVDT_STREAM_OPEN_RSP, AVDT_OPEN_ST},
396 /* AVDT_STREAM_OPEN_CMD_IND_EVENT */
397 {AVDT_STREAM_OPEN_IND, AVDT_OPENING_ST},
398 /* AVDT_STREAM_OPEN_CMD_CFM_EVENT */
399 {AVDT_STREAM_OPEN_CFM, AVDT_OPEN_ST},
400 /* AVDT_STREAM_CLOSE_CMD_REQ_EVENT */
401 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
402 /* AVDT_STREAM_CLOSE_CMD_RSP_EVENT */
403 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
404 /* AVDT_STREAM_CLOSE_CMD_IND_EVENT */
405 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
406 /* AVDT_STREAM_CLOSE_CMD_CFM_EVENT */
407 {AVDT_SSM_IGNORE, AVDT_OPENING_ST},
408 };
409
410 /**
411 * Open status
412 */
413 const uint8_t AVDT_STREAM_ST_OPEN[][AVDT_STREAM_NUM_COLS] = {
414 /* AVDT_SETCONFIGURE_CMD_REQ_EVENT */
415 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
416 /* AVDT_SETCONFIGURE_CMD_RSP_EVENT */
417 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
418 /* AVDT_SETCONFIGURE_CMD_IND_EVENT */
419 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
420 /* AVDT_SETCONFIGURE_CMD_CFM_EVENT */
421 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
422 /* AVDT_GETCONFIGURE_CMD_REQ_EVENT */
423 {AVDT_GETCONFIGURE_REQ, AVDT_OPEN_ST},
424 /* AVDT_GETCONFIGURE_CMD_RSP_EVENT */
425 {AVDT_GETCONFIGURE_RSP, AVDT_OPEN_ST},
426 /* AVDT_GETCONFIGURE_CMD_IND_EVENT */
427 {AVDT_GETCONFIGURE_IND, AVDT_OPEN_ST},
428 /* AVDT_GETCONFIGURE_CMD_CFM_EVENT */
429 {AVDT_GETCONFIGURE_CFM, AVDT_OPEN_ST},
430 /* AVDT_OPEN_CMD_REQ_EVENT */
431 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
432 /* AVDT_OPEN_CMD_RSP_EVENT */
433 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
434 /* AVDT_OPEN_CMD_IND_EVENT */
435 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
436 /* AVDT_OPEN_CMD_CFM_EVENT */
437 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
438 /* AVDT_RECONFIGURE_CMD_REQ_EVENT */
439 {AVDT_RECONFIGURE_REQ, AVDT_OPEN_ST},
440 /* AVDT_RECONFIGURE_CMD_RSP_EVENT */
441 {AVDT_RECONFIGURE_RSP, AVDT_OPEN_ST},
442 /* AVDT_RECONFIGURE_CMD_IND_EVENT */
443 {AVDT_RECONFIGURE_IND, AVDT_OPEN_ST},
444 /* AVDT_RECONFIGURE_CMD_CFM_EVENT */
445 {AVDT_RECONFIGURE_CFM, AVDT_OPEN_ST},
446 /* AVDT_START_CMD_REQ_EVENT */
447 {AVDT_START_REQ, AVDT_OPEN_ST},
448 /* AVDT_START_CMD_RSP_EVENT */
449 {AVDT_START_RSP, AVDT_STREAMING_ST},
450 /* AVDT_START_CMD_IND_EVENT */
451 {AVDT_START_IND, AVDT_OPEN_ST},
452 /* AVDT_START_CMD_CFM_EVENT */
453 {AVDT_START_CFM, AVDT_STREAMING_ST},
454 /* AVDT_SUSPEND_CMD_REQ_EVENT */
455 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
456 /* AVDT_SUSPEND_CMD_RSP_EVENT */
457 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
458 /* AVDT_SUSPEND_CMD_IND_EVENT */
459 {AVDT_BAD_STATE_REJ, AVDT_OPEN_ST},
460 /* AVDT_SUSPEND_CMD_CFM_EVENT */
461 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
462 /* AVDT_CLOSE_CMD_REQ_EVENT */
463 {AVDT_CLOSE_REQ, AVDT_OPEN_ST},
464 /* AVDT_CLOSE_CMD_RSP_EVENT */
465 {AVDT_CLOSE_RSP, AVDT_CLOSING_ST},
466 /* AVDT_CLOSE_CMD_IND_EVENT */
467 {AVDT_CLOSE_IND, AVDT_OPEN_ST},
468 /* AVDT_CLOSE_CMD_CFM_EVENT */
469 {AVDT_CLOSE_CFM, AVDT_CLOSING_ST},
470 /* AVDT_ABORT_CMD_REQ_EVENT */
471 {AVDT_ABORT_REQ, AVDT_OPEN_ST},
472 /* AVDT_ABORT_CMD_RSP_EVENT */
473 {AVDT_ABORT_RSP, AVDT_CLOSING_ST},
474 /* AVDT_ABORT_CMD_IND_EVENT */
475 {AVDT_ABORT_IND, AVDT_OPEN_ST},
476 /* AVDT_ABORT_CMD_CFM_EVENT */
477 {AVDT_ABORT_CFM, AVDT_CLOSING_ST},
478 /* AVDT_DELAY_CMD_REQ_EVENT */
479 {AVDT_DELAY_REQ, AVDT_OPEN_ST},
480 /* AVDT_DELAY_CMD_RSP_EVENT */
481 {AVDT_DELAY_RSP, AVDT_OPEN_ST},
482 /* AVDT_DELAY_CMD_IND_EVENT */
483 {AVDT_DELAY_IND, AVDT_OPEN_ST},
484 /* AVDT_DELAY_CMD_CFM_EVENT */
485 {AVDT_DELAY_CFM, AVDT_OPEN_ST},
486 /* AVDT_WRITE_CMD_REQ_EVENT */
487 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
488 /* AVDT_WRITE_CMD_CFM_EVENT */
489 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
490 /* AVDT_READ_CMD_IND_EVENT */
491 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
492 /* AVDT_STREAM_OPEN_CMD_REQ_EVENT */
493 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
494 /* AVDT_STREAM_OPEN_CMD_RSP_EVENT */
495 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
496 /* AVDT_STREAM_OPEN_CMD_IND_EVENT */
497 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
498 /* AVDT_STREAM_OPEN_CMD_CFM_EVENT */
499 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
500 /* AVDT_STREAM_CLOSE_CMD_REQ_EVENT */
501 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
502 /* AVDT_STREAM_CLOSE_CMD_RSP_EVENT */
503 {AVDT_SSM_IGNORE, AVDT_OPEN_ST},
504 /* AVDT_STREAM_CLOSE_CMD_IND_EVENT */
505 {AVDT_STREAM_CLOSE_IND, AVDT_CLOSING_ST},
506 /* AVDT_STREAM_CLOSE_CMD_CFM_EVENT */
507 {AVDT_STREAM_CLOSE_CFM, AVDT_CLOSING_ST},
508 };
509
510 /**
511 * Streaming status
512 */
513 const uint8_t AVDT_STREAM_ST_STREAMING[][AVDT_STREAM_NUM_COLS] = {
514 /* AVDT_SETCONFIGURE_CMD_REQ_EVENT */
515 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
516 /* AVDT_SETCONFIGURE_CMD_RSP_EVENT */
517 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
518 /* AVDT_SETCONFIGURE_CMD_IND_EVENT */
519 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
520 /* AVDT_SETCONFIGURE_CMD_CFM_EVENT */
521 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
522 /* AVDT_GETCONFIGURE_CMD_REQ_EVENT */
523 {AVDT_GETCONFIGURE_REQ, AVDT_STREAMING_ST},
524 /* AVDT_GETCONFIGURE_CMD_RSP_EVENT */
525 {AVDT_GETCONFIGURE_RSP, AVDT_STREAMING_ST},
526 /* AVDT_GETCONFIGURE_CMD_IND_EVENT */
527 {AVDT_GETCONFIGURE_IND, AVDT_STREAMING_ST},
528 /* AVDT_GETCONFIGURE_CMD_CFM_EVENT */
529 {AVDT_GETCONFIGURE_CFM, AVDT_STREAMING_ST},
530 /* AVDT_OPEN_CMD_REQ_EVENT */
531 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
532 /* AVDT_OPEN_CMD_RSP_EVENT */
533 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
534 /* AVDT_OPEN_CMD_IND_EVENT */
535 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
536 /* AVDT_OPEN_CMD_CFM_EVENT */
537 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
538 /* AVDT_RECONFIGURE_CMD_REQ_EVENT */
539 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
540 /* AVDT_RECONFIGURE_CMD_RSP_EVENT */
541 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
542 /* AVDT_RECONFIGURE_CMD_IND_EVENT */
543 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
544 /* AVDT_RECONFIGURE_CMD_CFM_EVENT */
545 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
546 /* AVDT_START_CMD_REQ_EVENT */
547 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
548 /* AVDT_START_CMD_RSP_EVENT */
549 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
550 /* AVDT_START_CMD_IND_EVENT */
551 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
552 /* AVDT_START_CMD_CFM_EVENT */
553 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
554 /* AVDT_SUSPEND_CMD_REQ_EVENT */
555 {AVDT_SUSPEND_REQ, AVDT_STREAMING_ST},
556 /* AVDT_SUSPEND_CMD_RSP_EVENT */
557 {AVDT_SUSPEND_RSP, AVDT_OPEN_ST},
558 /* AVDT_SUSPEND_CMD_IND_EVENT */
559 {AVDT_SUSPEND_IND, AVDT_STREAMING_ST},
560 /* AVDT_SUSPEND_CMD_CFM_EVENT */
561 {AVDT_SUSPEND_CFM, AVDT_OPEN_ST},
562 /* AVDT_CLOSE_CMD_REQ_EVENT */
563 {AVDT_CLOSE_REQ, AVDT_STREAMING_ST},
564 /* AVDT_CLOSE_CMD_RSP_EVENT */
565 {AVDT_CLOSE_RSP, AVDT_CLOSING_ST},
566 /* AVDT_CLOSE_CMD_IND_EVENT */
567 {AVDT_CLOSE_IND, AVDT_STREAMING_ST},
568 /* AVDT_CLOSE_CMD_CFM_EVENT */
569 {AVDT_CLOSE_CFM, AVDT_CLOSING_ST},
570 /* AVDT_ABORT_CMD_REQ_EVENT */
571 {AVDT_ABORT_REQ, AVDT_STREAMING_ST},
572 /* AVDT_ABORT_CMD_RSP_EVENT */
573 {AVDT_ABORT_RSP, AVDT_CLOSING_ST},
574 /* AVDT_ABORT_CMD_IND_EVENT */
575 {AVDT_ABORT_IND, AVDT_STREAMING_ST},
576 /* AVDT_ABORT_CMD_CFM_EVENT */
577 {AVDT_ABORT_CFM, AVDT_CLOSING_ST},
578 /* AVDT_DELAY_CMD_REQ_EVENT */
579 {AVDT_DELAY_REQ, AVDT_STREAMING_ST},
580 /* AVDT_DELAY_CMD_RSP_EVENT */
581 {AVDT_DELAY_RSP, AVDT_STREAMING_ST},
582 /* AVDT_DELAY_CMD_IND_EVENT */
583 {AVDT_DELAY_IND, AVDT_STREAMING_ST},
584 /* AVDT_DELAY_CMD_CFM_EVENT */
585 {AVDT_DELAY_CFM, AVDT_STREAMING_ST},
586 /* AVDT_WRITE_CMD_REQ_EVENT */
587 {AVDT_WRITE_REQ, AVDT_STREAMING_ST},
588 /* AVDT_WRITE_CMD_CFM_EVENT */
589 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
590 /* AVDT_READ_CMD_IND_EVENT */
591 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
592 /* AVDT_STREAM_OPEN_CMD_REQ_EVENT */
593 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
594 /* AVDT_STREAM_OPEN_CMD_RSP_EVENT */
595 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
596 /* AVDT_STREAM_OPEN_CMD_IND_EVENT */
597 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
598 /* AVDT_STREAM_OPEN_CMD_CFM_EVENT */
599 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
600 /* AVDT_STREAM_CLOSE_CMD_REQ_EVENT */
601 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
602 /* AVDT_STREAM_CLOSE_CMD_RSP_EVENT */
603 {AVDT_SSM_IGNORE, AVDT_STREAMING_ST},
604 /* AVDT_STREAM_CLOSE_CMD_IND_EVENT */
605 {AVDT_STREAM_CLOSE_IND, AVDT_CLOSING_ST},
606 /* AVDT_STREAM_CLOSE_CMD_CFM_EVENT */
607 {AVDT_STREAM_CLOSE_CFM, AVDT_CLOSING_ST},
608 };
609
610 /* Closing status */
611 const uint8_t AVDT_STREAM_ST_CLOSING[][AVDT_STREAM_NUM_COLS] = {
612 /* AVDT_SETCONFIGURE_CMD_REQ_EVENT */
613 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
614 /* AVDT_SETCONFIGURE_CMD_RSP_EVENT */
615 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
616 /* AVDT_SETCONFIGURE_CMD_IND_EVENT */
617 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
618 /* AVDT_SETCONFIGURE_CMD_CFM_EVENT */
619 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
620 /* AVDT_GETCONFIGURE_CMD_REQ_EVENT */
621 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
622 /* AVDT_GETCONFIGURE_CMD_RSP_EVENT */
623 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
624 /* AVDT_GETCONFIGURE_CMD_IND_EVENT */
625 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
626 /* AVDT_GETCONFIGURE_CMD_CFM_EVENT */
627 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
628 /* AVDT_OPEN_CMD_REQ_EVENT */
629 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
630 /* AVDT_OPEN_CMD_RSP_EVENT */
631 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
632 /* AVDT_OPEN_CMD_IND_EVENT */
633 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
634 /* AVDT_OPEN_CMD_CFM_EVENT */
635 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
636 /* AVDT_RECONFIGURE_CMD_REQ_EVENT */
637 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
638 /* AVDT_RECONFIGURE_CMD_RSP_EVENT */
639 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
640 /* AVDT_RECONFIGURE_CMD_IND_EVENT */
641 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
642 /* AVDT_RECONFIGURE_CMD_CFM_EVENT */
643 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
644 /* AVDT_START_CMD_REQ_EVENT */
645 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
646 /* AVDT_START_CMD_RSP_EVENT */
647 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
648 /* AVDT_START_CMD_IND_EVENT */
649 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
650 /* AVDT_START_CMD_CFM_EVENT */
651 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
652 /* AVDT_SUSPEND_CMD_REQ_EVENT */
653 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
654 /* AVDT_SUSPEND_CMD_RSP_EVENT */
655 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
656 /* AVDT_SUSPEND_CMD_IND_EVENT */
657 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
658 /* AVDT_SUSPEND_CMD_CFM_EVENT */
659 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
660 /* AVDT_CLOSE_CMD_REQ_EVENT */
661 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
662 /* AVDT_CLOSE_CMD_RSP_EVENT */
663 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
664 /* AVDT_CLOSE_CMD_IND_EVENT */
665 {AVDT_BAD_STATE_REJ, AVDT_CLOSING_ST},
666 /* AVDT_CLOSE_CMD_CFM_EVENT */
667 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
668 /* AVDT_ABORT_CMD_REQ_EVENT */
669 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
670 /* AVDT_ABORT_CMD_RSP_EVENT */
671 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
672 /* AVDT_ABORT_CMD_IND_EVENT */
673 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
674 /* AVDT_ABORT_CMD_CFM_EVENT */
675 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
676 /* AVDT_DELAY_CMD_REQ_EVENT */
677 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
678 /* AVDT_DELAY_CMD_RSP_EVENT */
679 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
680 /* AVDT_DELAY_CMD_IND_EVENT */
681 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
682 /* AVDT_DELAY_CMD_CFM_EVENT */
683 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
684 /* AVDT_WRITE_CMD_REQ_EVENT */
685 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
686 /* AVDT_WRITE_CMD_CFM_EVENT */
687 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
688 /* AVDT_READ_CMD_IND_EVENT */
689 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
690 /* AVDT_STREAM_OPEN_CMD_REQ_EVENT */
691 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
692 /* AVDT_STREAM_OPEN_CMD_RSP_EVENT */
693 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
694 /* AVDT_STREAM_OPEN_CMD_IND_EVENT */
695 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
696 /* AVDT_STREAM_OPEN_CMD_CFM_EVENT */
697 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
698 /* AVDT_STREAM_CLOSE_CMD_REQ_EVENT */
699 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
700 /* AVDT_STREAM_CLOSE_CMD_RSP_EVENT */
701 {AVDT_SSM_IGNORE, AVDT_CLOSING_ST},
702 /* AVDT_STREAM_CLOSE_CMD_IND_EVENT */
703 {AVDT_STREAM_CLOSE_IND, AVDT_IDLE_ST},
704 /* AVDT_STREAM_CLOSE_CMD_CFM_EVENT */
705 {AVDT_STREAM_CLOSE_CFM, AVDT_IDLE_ST},
706 };
707
708 /**
709 * Init status: Idle
710 */
711 const uint8_t AVDT_SIG_ST_IDLE[][AVDT_STREAM_NUM_COLS] = {
712 /* AVDT_DISCOVER_CMD_REQ_EVENT */
713 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
714 /* AVDT_DISCOVER_CMD_RSP_EVENT */
715 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
716 /* AVDT_DISCOVER_CMD_IND_EVENT */
717 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
718 /* AVDT_DISCOVER_CMD_CFM_EVENT */
719 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
720 /* AVDT_GETCAP_CMD_REQ_EVENT */
721 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
722 /* AVDT_GETCAP_CMD_RSP_EVENT */
723 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
724 /* AVDT_GETCAP_CMD_IND_EVENT */
725 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
726 /* AVDT_GETCAP_CMD_CFM_EVENT */
727 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
728 /* AVDT_GETALLCAP_CMD_REQ_EVENT */
729 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
730 /* AVDT_GETALLCAP_CMD_RSP_EVENT */
731 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
732 /* AVDT_GETALLCAP_CMD_IND_EVENT */
733 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
734 /* AVDT_GETALLCAP_CMD_CFM_EVENT */
735 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
736 /* AVDT_CONNECT_CMD_REQ_EVENT */
737 {AVDT_CONNECT_REQ, AVDT_SIG_CONFIGURE_ST},
738 /* AVDT_CONNECT_CMD_RSP_EVENT */
739 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
740 /* AVDT_CONNECT_CMD_IND_EVENT */
741 {AVDT_CONNECT_IND, AVDT_SIG_OPEN_ST},
742 /* AVDT_CONNECT_CMD_CFM_EVENT */
743 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
744 /* AVDT_DISCONNECT_CMD_REQ_EVENT */
745 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
746 /* AVDT_DISCONNECT_CMD_RSP_EVENT */
747 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
748 /* AVDT_DISCONNECT_CMD_IND_EVENT */
749 {AVDT_DISCONNECT_IND, AVDT_SIG_IDLE_ST},
750 /* AVDT_DISCONNECT_CMD_CFM_EVENT */
751 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
752 /* AVDT_SND_MSG_EVENT */
753 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
754 };
755
756 /**
757 * Configure Status
758 */
759 const uint8_t AVDT_SIG_ST_CONFIG[][AVDT_STREAM_NUM_COLS] = {
760 /* AVDT_DISCOVER_CMD_REQ_EVENT */
761 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
762 /* AVDT_DISCOVER_CMD_RSP_EVENT */
763 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
764 /* AVDT_DISCOVER_CMD_IND_EVENT */
765 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
766 /* AVDT_DISCOVER_CMD_CFM_EVENT */
767 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
768 /* AVDT_GETCAP_CMD_REQ_EVENT */
769 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
770 /* AVDT_GETCAP_CMD_RSP_EVENT */
771 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
772 /* AVDT_GETCAP_CMD_IND_EVENT */
773 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
774 /* AVDT_GETCAP_CMD_CFM_EVENT */
775 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
776 /* AVDT_GETALLCAP_CMD_REQ_EVENT */
777 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
778 /* AVDT_GETALLCAP_CMD_RSP_EVENT */
779 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
780 /* AVDT_GETALLCAP_CMD_IND_EVENT */
781 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
782 /* AVDT_GETALLCAP_CMD_CFM_EVENT */
783 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
784 /* AVDT_CONNECT_CMD_REQ_EVENT */
785 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
786 /* AVDT_CONNECT_CMD_RSP_EVENT */
787 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
788 /* AVDT_CONNECT_CMD_IND_EVENT */
789 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
790 /* AVDT_CONNECT_CMD_CFM_EVENT */
791 {AVDT_CONNECT_CFM, AVDT_SIG_OPEN_ST},
792 /* AVDT_DISCONNECT_CMD_REQ_EVENT */
793 {AVDT_SSM_IGNORE, AVDT_SIG_CONFIGURE_ST},
794 /* AVDT_DISCONNECT_CMD_RSP_EVENT */
795 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
796 /* AVDT_DISCONNECT_CMD_IND_EVENT */
797 {AVDT_DISCONNECT_IND, AVDT_SIG_IDLE_ST},
798 /* AVDT_DISCONNECT_CMD_CFM_EVENT */
799 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
800 /* AVDT_SND_MSG_EVENT */
801 {AVDT_SSM_IGNORE, AVDT_SIG_IDLE_ST},
802 };
803
804 /**
805 * Open status
806 */
807 const uint8_t AVDT_SIG_ST_OPEN[][AVDT_STREAM_NUM_COLS] = {
808 /* AVDT_DISCOVER_CMD_REQ_EVENT */
809 {AVDT_DISCOVER_REQ, AVDT_SIG_OPEN_ST},
810 /* AVDT_DISCOVER_CMD_RSP_EVENT */
811 {AVDT_DISCOVER_RSP, AVDT_SIG_OPEN_ST},
812 /* AVDT_DISCOVER_CMD_IND_EVENT */
813 {AVDT_DISCOVER_IND, AVDT_SIG_OPEN_ST},
814 /* AVDT_DISCOVER_CMD_CFM_EVENT */
815 {AVDT_DISCOVER_CFM, AVDT_SIG_OPEN_ST},
816 /* AVDT_GETCAP_CMD_REQ_EVENT */
817 {AVDT_GETCAP_REQ, AVDT_SIG_OPEN_ST},
818 /* AVDT_GETCAP_CMD_RSP_EVENT */
819 {AVDT_GETCAP_RSP, AVDT_SIG_OPEN_ST},
820 /* AVDT_GETCAP_CMD_IND_EVENT */
821 {AVDT_GETCAP_IND, AVDT_SIG_OPEN_ST},
822 /* AVDT_GETCAP_CMD_CFM_EVENT */
823 {AVDT_GETCAP_CFM, AVDT_SIG_OPEN_ST},
824 /* AVDT_GETALLCAP_CMD_REQ_EVENT */
825 {AVDT_GETALLCAP_REQ, AVDT_SIG_OPEN_ST},
826 /* AVDT_GETALLCAP_CMD_RSP_EVENT */
827 {AVDT_GETALLCAP_RSP, AVDT_SIG_OPEN_ST},
828 /* AVDT_GETALLCAP_CMD_IND_EVENT */
829 {AVDT_GETALLCAP_IND, AVDT_SIG_OPEN_ST},
830 /* AVDT_GETALLCAP_CMD_CFM_EVENT */
831 {AVDT_GETALLCAP_CFM, AVDT_SIG_OPEN_ST},
832 /* AVDT_CONNECT_CMD_REQ_EVENT */
833 {AVDT_SSM_IGNORE, AVDT_SIG_OPEN_ST},
834 /* AVDT_CONNECT_CMD_RSP_EVENT */
835 {AVDT_SSM_IGNORE, AVDT_SIG_OPEN_ST},
836 /* AVDT_CONNECT_CMD_IND_EVENT */
837 {AVDT_SSM_IGNORE, AVDT_SIG_OPEN_ST},
838 /* AVDT_CONNECT_CMD_CFM_EVENT */
839 {AVDT_SSM_IGNORE, AVDT_SIG_OPEN_ST},
840 /* AVDT_DISCONNECT_CMD_REQ_EVENT */
841 {AVDT_DISCONNECT_REQ, AVDT_SIG_CLOSING_ST},
842 /* AVDT_DISCONNECT_CMD_RSP_EVENT */
843 {AVDT_SSM_IGNORE, AVDT_SIG_OPEN_ST},
844 /* AVDT_DISCONNECT_CMD_IND_EVENT */
845 {AVDT_DISCONNECT_IND, AVDT_SIG_CLOSING_ST},
846 /* AVDT_DISCONNECT_CMD_CFM_EVENT */
847 {AVDT_SSM_IGNORE, AVDT_SIG_OPEN_ST},
848 /* AVDT_SND_MSG_EVENT */
849 {AVDT_SND_MSG, AVDT_SIG_OPEN_ST},
850 };
851
852 /* Closing status */
853 const uint8_t AVDT_SIG_ST_CLOSING[][AVDT_STREAM_NUM_COLS] = {
854 /* AVDT_DISCOVER_CMD_REQ_EVENT */
855 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
856 /* AVDT_DISCOVER_CMD_RSP_EVENT */
857 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
858 /* AVDT_DISCOVER_CMD_IND_EVENT */
859 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
860 /* AVDT_DISCOVER_CMD_CFM_EVENT */
861 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
862 /* AVDT_GETCAP_CMD_REQ_EVENT */
863 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
864 /* AVDT_GETCAP_CMD_RSP_EVENT */
865 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
866 /* AVDT_GETCAP_CMD_IND_EVENT */
867 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
868 /* AVDT_GETCAP_CMD_CFM_EVENT */
869 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
870 /* AVDT_GETALLCAP_CMD_REQ_EVENT */
871 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
872 /* AVDT_GETALLCAP_CMD_RSP_EVENT */
873 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
874 /* AVDT_GETALLCAP_CMD_IND_EVENT */
875 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
876 /* AVDT_GETALLCAP_CMD_CFM_EVENT */
877 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
878 /* AVDT_CONNECT_CMD_REQ_EVENT */
879 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
880 /* AVDT_CONNECT_CMD_RSP_EVENT */
881 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
882 /* AVDT_CONNECT_CMD_IND_EVENT */
883 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
884 /* AVDT_CONNECT_CMD_CFM_EVENT */
885 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
886 /* AVDT_DISCONNECT_CMD_REQ_EVENT */
887 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
888 /* AVDT_DISCONNECT_CMD_RSP_EVENT */
889 {AVDT_DISCONNECT_RSP, AVDT_SIG_IDLE_ST},
890 /* AVDT_DISCONNECT_CMD_IND_EVENT */
891 {AVDT_DISCONNECT_IND, AVDT_SIG_IDLE_ST},
892 /* AVDT_DISCONNECT_CMD_CFM_EVENT */
893 {AVDT_DISCONNECT_CFM, AVDT_SIG_IDLE_ST},
894 /* AVDT_SND_MSG_EVENT */
895 {AVDT_SSM_IGNORE, AVDT_SIG_CLOSING_ST},
896 };
897
898 typedef const uint8_t (*AVDT_STREAM_ST_TBL)[AVDT_STREAM_NUM_COLS];
899 typedef const uint8_t (*AVDT_SIG_ST_TBL)[AVDT_STREAM_NUM_COLS];
900 /**
901 * Stream State table
902 */
903 const AVDT_STREAM_ST_TBL AVDT_STREAM_TBL[] = {
904 AVDT_STREAM_ST_IDLE,
905 AVDT_STREAM_ST_CONFIG,
906 AVDT_STREAM_ST_OPENING,
907 AVDT_STREAM_ST_OPEN,
908 AVDT_STREAM_ST_STREAMING,
909 AVDT_STREAM_ST_CLOSING
910 };
911 /**
912 * Signal State table
913 */
914 const AVDT_SIG_ST_TBL AVDT_SIG_TBL[] = {AVDT_SIG_ST_IDLE, AVDT_SIG_ST_CONFIG, AVDT_SIG_ST_OPEN, AVDT_SIG_ST_CLOSING};
915
916 /**
917 *
918 * @brief AvdtControlBlockInit
919 *
920 * @details Stream control block init functions.
921 *
922 * @return void
923 *
924 */
AvdtControlBlockInit(void)925 void AvdtControlBlockInit(void)
926 {
927 LOG_DEBUG("[AVDT]%{public}s:", __func__);
928 (void)memset_s(&g_avdtCb, sizeof(AvdtCB), 0, sizeof(AvdtCB));
929 g_avdtCb.streamAction = AVDT_STREAM_ACTION;
930 g_avdtCb.sigAction = AVDT_SIG_ACTION;
931 g_avdtCb.avdtRegisted = false;
932 g_avdtCb.sepRegisted = false;
933 for (int j = 0; j < AVDT_MAX_NUM_SEP; j++) {
934 g_avdtCb.streamHandles[j].handle = j + 1;
935 }
936 for (int k = 0; k < AVDT_NUM_LINKS; k++) {
937 g_avdtCb.sigHandles[k].handle = k + 1;
938 }
939 }
940
941 /**
942 *
943 * @brief AvdtStreamProcEvent
944 *
945 * @details State process function for stream channel.
946 *
947 * @return void
948 *
949 */
AvdtStreamProcEvent(AvdtStreamCtrl * streamCtrl,uint8_t event,AvdtEventData * data)950 void AvdtStreamProcEvent(AvdtStreamCtrl *streamCtrl, uint8_t event, AvdtEventData *data)
951 {
952 LOG_DEBUG("[AVDT]%{public}s:event(%hhu),streamCtrl->state(%hhu)", __func__, event, streamCtrl->state);
953 /* get the current state table */
954 AVDT_STREAM_ST_TBL curStatus = AVDT_STREAM_TBL[streamCtrl->state];
955 /* update the status of sigCtrl */
956 if (streamCtrl->state != curStatus[event][AVDT_STREAM_NEXT_STATE]) {
957 streamCtrl->state = curStatus[event][AVDT_STREAM_NEXT_STATE];
958 }
959 /* call the matched action */
960 uint8_t Action = curStatus[event][0];
961 if (AVDT_SSM_IGNORE != Action) {
962 LOG_DEBUG("[AVDT]%{public}s: streamAction[Action:%hhu] nextState(%hhu)", __func__, Action, streamCtrl->state);
963 g_avdtCb.streamAction[Action](streamCtrl, data);
964 }
965 return;
966 }
967 /**
968 *
969 * @brief AvdtSigProcEvent
970 *
971 * @details State process function for signal channel.
972 *
973 * @return void
974 *
975 */
AvdtSigProcEvent(AvdtSigCtrl * sigCtrl,uint8_t event,AvdtEventData * data)976 void AvdtSigProcEvent(AvdtSigCtrl *sigCtrl, uint8_t event, AvdtEventData *data)
977 {
978 LOG_DEBUG("[AVDT]%{public}s:event(%hhu),sigCtrl->state(%hhu)", __func__, event, sigCtrl->state);
979 /* get the current state table */
980 AVDT_STREAM_ST_TBL curStatus = AVDT_SIG_TBL[sigCtrl->state];
981 /* update the status of sigCtrl */
982 if (sigCtrl->state != curStatus[event][AVDT_STREAM_NEXT_STATE]) {
983 sigCtrl->state = curStatus[event][AVDT_STREAM_NEXT_STATE];
984 }
985 /* call the matched action */
986 uint8_t Action = curStatus[event][0];
987 if (Action != AVDT_SSM_IGNORE) {
988 LOG_DEBUG("[AVDT]%{public}s: sigAction[Action:%hhu] nextState(%hhu)", __func__, Action, sigCtrl->state);
989 g_avdtCb.sigAction[Action](sigCtrl, data);
990 }
991 return;
992 }
993
994 /**
995 *
996 * @brief AvdtGetSigCtrlByAddr
997 *
998 * @details Lookup the channel CtrlBlock by address
999 *
1000 * @return NULL: No isAllocated ChannelCtrl; otherwise return the pointer
1001 * of ChannelCtrl.
1002 *
1003 */
AvdtGetSigCtrlByAddr(const BtAddr * bdAddr)1004 AvdtSigCtrl *AvdtGetSigCtrlByAddr(const BtAddr *bdAddr)
1005 {
1006 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1007 AvdtSigCtrl *sigCtrl = NULL;
1008 for (int i = 0; i < AVDT_NUM_LINKS; i++) {
1009 if (g_avdtCb.sigCtrl[i] != NULL &&
1010 !memcmp((char *)g_avdtCb.sigCtrl[i]->peerAddress.addr, (char *)&(bdAddr->addr), BT_ADDR_LENGTH)) {
1011 sigCtrl = g_avdtCb.sigCtrl[i];
1012 break;
1013 }
1014 }
1015 return sigCtrl;
1016 }
1017
1018 /**
1019 *
1020 * @brief AvdtGetSigCtrlByHandle
1021 *
1022 * @details Lookup the ChanelCtrl isAllocated by handle
1023 *
1024 * @return NULL: No isAllocated ChannelCtrl; otherwise the pointer
1025 * of ChannelCtrl.
1026 *
1027 */
AvdtGetSigCtrlByHandle(uint16_t handle)1028 AvdtSigCtrl *AvdtGetSigCtrlByHandle(uint16_t handle)
1029 {
1030 LOG_DEBUG("[AVDT]%{public}s:handle(%hu)", __func__, handle);
1031 AvdtSigCtrl *sigCtrl = NULL;
1032 for (int i = 0; i < AVDT_NUM_LINKS; i++) {
1033 if (g_avdtCb.sigCtrl[i] != NULL && g_avdtCb.sigCtrl[i]->handle == handle) {
1034 sigCtrl = g_avdtCb.sigCtrl[i];
1035 LOG_DEBUG("[AVDT]%{public}s:Get sigCtrl index(%{public}d)", __func__, i);
1036 break;
1037 }
1038 }
1039 return sigCtrl;
1040 }
1041
1042 /**
1043 *
1044 * @brief AvdtSigCtrlAllocate
1045 *
1046 * @details Allocate the ChannelCtrl for peer device.
1047 *
1048 * @return NULL: No reources; otherwise the pointer
1049 * of ChannelCtrl.
1050 *
1051 */
AvdtSigCtrlAllocate(const BtAddr * bdAddr,uint8_t role)1052 AvdtSigCtrl *AvdtSigCtrlAllocate(const BtAddr *bdAddr, uint8_t role)
1053 {
1054 LOG_DEBUG("[AVDT]%{public}s: role is (%hhu)", __func__, role);
1055 AvdtSigCtrl *sigCtrl = NULL;
1056 for (int i = 0; i < AVDT_NUM_LINKS; i++) {
1057 if (g_avdtCb.sigCtrl[i] != NULL) {
1058 continue;
1059 }
1060 sigCtrl = (AvdtSigCtrl *)malloc(sizeof(AvdtSigCtrl));
1061 if (sigCtrl == NULL) {
1062 continue;
1063 }
1064 (void)memset_s(sigCtrl, sizeof(AvdtSigCtrl), 0, sizeof(AvdtSigCtrl));
1065 sigCtrl->peerAddress = *bdAddr;
1066 if (role == AVDT_ROLE_SRC) {
1067 sigCtrl->role = AVDT_ROLE_SRC;
1068 } else {
1069 sigCtrl->role = AVDT_ROLE_SNK;
1070 }
1071 sigCtrl->state = AVDT_SIG_IDLE_ST;
1072 sigCtrl->handle = AvdtAssignSigHandle();
1073 sigCtrl->procCback = g_avdtCb.regInfo.ctrlCallback;
1074 LOG_DEBUG("[AVDT]%{public}s:Connected devices number:(%{public}d),sigCtrl->handle(%hu)",
1075 __func__, i, sigCtrl->handle);
1076 g_avdtCb.sigCtrl[i] = sigCtrl;
1077 break;
1078 }
1079 return sigCtrl;
1080 }
1081
1082 /**
1083 *
1084 * @brief AvdtSigDealloc
1085 *
1086 * @details Deallocate the ChannelCtrl.
1087 *
1088 * @return void
1089 *
1090 */
AvdtSigDealloc(void)1091 void AvdtSigDealloc(void)
1092 {
1093 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1094 for (int i = 0; i < AVDT_NUM_LINKS; i++) {
1095 if (g_avdtCb.sigCtrl[i] != NULL) {
1096 AvdtFreeSigCtrlByHandle(g_avdtCb.sigCtrl[i]->handle);
1097 }
1098 }
1099 return;
1100 }
1101
1102 /**
1103 *
1104 * @brief AvdtGetStreamCtrlByHandle
1105 *
1106 * @details Lookup the StreamCtrl isAllocated by handle
1107 *
1108 * @return NULL: No isAllocated Streamtrl; otherwise the pointer
1109 * of streamCtrl.
1110 *
1111 */
AvdtGetStreamCtrlByHandle(uint16_t handle)1112 AvdtStreamCtrl *AvdtGetStreamCtrlByHandle(uint16_t handle)
1113 {
1114 LOG_DEBUG("[AVDT]%{public}s: handle(%hu)", __func__, handle);
1115 AvdtStreamCtrl *streamCtrl = NULL;
1116 for (int i = 0; i < AVDT_NUM_LINKS; i++) {
1117 for (int j = 0; j < AVDT_NUM_SEPS; j++) {
1118 if (g_avdtCb.sigCtrl[i] != NULL && handle != 0 && handle == g_avdtCb.sigCtrl[i]->streamCtrl[j].handle) {
1119 streamCtrl = &g_avdtCb.sigCtrl[i]->streamCtrl[j];
1120 LOG_DEBUG("[AVDT]%{public}s: chCtrlBlock_i(%{public}d) j(%{public}d), streamhandle(%hu)",
1121 __func__, i, j, streamCtrl->handle);
1122 return streamCtrl;
1123 }
1124 }
1125 }
1126 return streamCtrl;
1127 }
1128
1129 /**
1130 *
1131 * @brief AvdtStreamCtrlAllocate
1132 *
1133 * @details Allocate the stream ctrl block
1134 *
1135 * @return NULL: No reources; otherwise the pointer
1136 * of streamCtrl.
1137 *
1138 */
AvdtStreamCtrlAllocate(AvdtSigCtrl * sigCtrl,uint16_t codecIndex)1139 AvdtStreamCtrl *AvdtStreamCtrlAllocate(AvdtSigCtrl *sigCtrl, uint16_t codecIndex)
1140 {
1141 LOG_DEBUG("[AVDT]%{public}s:codecIndex(%hu)", __func__, codecIndex);
1142 AvdtStreamCtrl *streamCtrl = NULL;
1143 for (int i = 0; i < AVDT_NUM_SEPS; i++) {
1144 if (!sigCtrl->streamCtrl[i].isAllocated) {
1145 AvdtStreamConfig *config = AvdtGetSepConfigByCodecIndex(codecIndex);
1146 if (config != NULL) {
1147 streamCtrl = &sigCtrl->streamCtrl[i];
1148 sigCtrl->streamCtrl[i].handle = AvdtAssignStreamHandle();
1149 sigCtrl->streamCtrl[i].isUsed = false;
1150 sigCtrl->streamCtrl[i].isAllocated = true;
1151 sigCtrl->streamCtrl[i].codecIndex = codecIndex;
1152 sigCtrl->streamCtrl[i].sigHandle = sigCtrl->handle;
1153 LOG_DEBUG("[AVDT]%{public}s:create stream handle %hu [stream Index:%{public}d] [SepType:%hhu]",
1154 __func__,
1155 streamCtrl->handle,
1156 i,
1157 config->sepType);
1158 break;
1159 }
1160 }
1161 }
1162 return streamCtrl;
1163 }
1164
1165 /**
1166 *
1167 * @brief AvdtStreamCtrlDeallocByHandle
1168 *
1169 * @details Deallocate the stream ctrl data
1170 *
1171 * @return void
1172 *
1173 */
AvdtStreamCtrlDeallocByHandle(AvdtSigCtrl * sigCtrl,uint16_t handle)1174 void AvdtStreamCtrlDeallocByHandle(AvdtSigCtrl *sigCtrl, uint16_t handle)
1175 {
1176 LOG_DEBUG("[AVDT]%{public}s: handle(%hu)", __func__, handle);
1177 for (int i = 0; i < AVDT_NUM_SEPS; i++) {
1178 if (sigCtrl->streamCtrl[i].isUsed && sigCtrl->streamCtrl[i].handle == handle) {
1179 if (sigCtrl->streamCtrl[i].pkt != NULL) {
1180 PacketFree(sigCtrl->streamCtrl[i].pkt);
1181 sigCtrl->streamCtrl[i].pkt = NULL;
1182 }
1183 sigCtrl->streamCtrl[i].isUsed = false;
1184 sigCtrl->streamCtrl[i].state = AVDT_IDLE_ST;
1185 }
1186 }
1187 return;
1188 }
1189 /**
1190 *
1191 * @brief AvdtStreamCtrlDeallocAll
1192 *
1193 * @details Deallocate all stream ctrl of the sigCtrl
1194 *
1195 * @return void
1196 *
1197 */
AvdtStreamCtrlDeallocAll(AvdtSigCtrl * sigCtrl)1198 void AvdtStreamCtrlDeallocAll(AvdtSigCtrl *sigCtrl)
1199 {
1200 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1201 for (int i = 0; i < AVDT_NUM_SEPS; i++) {
1202 if (sigCtrl->streamCtrl[i].isAllocated) {
1203 if (sigCtrl->streamCtrl[i].pkt != NULL) {
1204 PacketFree(sigCtrl->streamCtrl[i].pkt);
1205 sigCtrl->streamCtrl[i].pkt = NULL;
1206 }
1207 AvdtFreeStreamHandle(sigCtrl->streamCtrl[i].handle);
1208 sigCtrl->streamCtrl[i].isAllocated = false;
1209 sigCtrl->streamCtrl[i].isUsed = false;
1210 }
1211 }
1212 return;
1213 }
1214 /**
1215 *
1216 * @brief AvdtTransChTabAllocate
1217 *
1218 * @details Allocate the transtation channel ctrl block
1219 *
1220 * @return NULL: No resources; otherwise the pointer of AvdtTransChannel.
1221 *
1222 */
AvdtTransChTabAllocate(uint8_t type,AvdtSigCtrl * sigCtrl,AvdtStreamCtrl * streamCtrl)1223 AvdtTransChannel *AvdtTransChTabAllocate(uint8_t type, AvdtSigCtrl *sigCtrl, AvdtStreamCtrl *streamCtrl)
1224 {
1225 LOG_DEBUG("[AVDT]%{public}s: type(%hhu)", __func__, type);
1226 AvdtTransChannel *transCh = NULL;
1227 for (int i = 0; i < AVDT_CH_TABLE_SIZE; i++) {
1228 if (g_avdtCb.transTable[i] != NULL) {
1229 continue;
1230 }
1231 /* Allocate transcation channel table */
1232 transCh = (AvdtTransChannel *)malloc(sizeof(AvdtTransChannel));
1233 if (transCh == NULL) {
1234 continue;
1235 }
1236 g_avdtCb.transTable[i] = transCh;
1237 (void)memset_s(g_avdtCb.transTable[i], sizeof(AvdtTransChannel), 0, sizeof(AvdtTransChannel));
1238 /* set the information ralted channel ctrl and stream ctrl */
1239 g_avdtCb.transTable[i]->type = type;
1240 g_avdtCb.transTable[i]->cfgFlags = 0;
1241 g_avdtCb.transTable[i]->lcid = 0;
1242 (void)memcpy_s(&g_avdtCb.transTable[i]->addr, sizeof(BtAddr), &sigCtrl->peerAddress, sizeof(BtAddr));
1243 if (type == AVDT_CH_TYPE_SIG) {
1244 g_avdtCb.transTable[i]->sigHandle = sigCtrl->handle;
1245 } else {
1246 g_avdtCb.transTable[i]->streamHandle = streamCtrl->handle;
1247 g_avdtCb.transTable[i]->sigHandle = sigCtrl->handle;
1248 }
1249 break;
1250 }
1251 return transCh;
1252 }
1253
1254 /**
1255 *
1256 * @brief AvdtGetTransChTabByLcid
1257 *
1258 * @details Get the transtation channel by lcid
1259 *
1260 * @return The pointer of transcation channel matched lcid.
1261 *
1262 */
AvdtGetTransChTabByLcid(uint16_t lcid)1263 AvdtTransChannel *AvdtGetTransChTabByLcid(uint16_t lcid)
1264 {
1265 LOG_DEBUG("[AVDT]%{public}s: lcid(0x%x)", __func__, lcid);
1266 AvdtTransChannel *transCh = NULL;
1267 for (int i = 0; i < AVDT_CH_TABLE_SIZE; i++) {
1268 if ((g_avdtCb.transTable[i] != NULL) && (lcid == g_avdtCb.transTable[i]->lcid)) {
1269 transCh = g_avdtCb.transTable[i];
1270 break;
1271 }
1272 }
1273 return transCh;
1274 }
1275
1276 /**
1277 *
1278 * @brief AvdtGetTransChTabByAddr
1279 *
1280 * @details Get the transtation channel by addr
1281 *
1282 * @return The pointer of transcation channel matched lcid.
1283 *
1284 */
AvdtGetTransChTabByAddr(const BtAddr * bdAddr,uint8_t type)1285 AvdtTransChannel *AvdtGetTransChTabByAddr(const BtAddr *bdAddr, uint8_t type)
1286 {
1287 LOG_DEBUG("[AVDT]%{public}s: type(%hhu)", __func__, type);
1288 AvdtTransChannel *transCh = NULL;
1289 for (int i = 0; i < AVDT_CH_TABLE_SIZE; i++) {
1290 if ((g_avdtCb.transTable[i] != NULL) &&
1291 !memcmp((char *)g_avdtCb.transTable[i]->addr.addr, (char *)&(bdAddr->addr), BT_ADDR_LENGTH) &&
1292 type == g_avdtCb.transTable[i]->type) {
1293 transCh = g_avdtCb.transTable[i];
1294 break;
1295 }
1296 }
1297 return transCh;
1298 }
1299 /**
1300 *
1301 * @brief AvdtGetTransChTabByHandle
1302 *
1303 * @details Get the transtation channel pointer by type and handle.
1304 *
1305 * @return The pointer of the transcation channel
1306 *
1307 ******************************************************************************/
AvdtGetTransChTabByHandle(uint8_t type,uint16_t handle)1308 AvdtTransChannel *AvdtGetTransChTabByHandle(uint8_t type, uint16_t handle)
1309 {
1310 LOG_DEBUG("[AVDT]%{public}s: handle(%hu) type(%hhu)", __func__, handle, type);
1311 AvdtTransChannel *transCh = NULL;
1312 for (int i = 0; i < AVDT_CH_TABLE_SIZE; i++) {
1313 if ((g_avdtCb.transTable[i] != NULL) && type == g_avdtCb.transTable[i]->type) {
1314 if (type == AVDT_CH_TYPE_SIG && handle == g_avdtCb.transTable[i]->sigHandle) {
1315 transCh = g_avdtCb.transTable[i];
1316 } else if (type == AVDT_CH_TYPE_STREAM && handle == g_avdtCb.transTable[i]->streamHandle) {
1317 transCh = g_avdtCb.transTable[i];
1318 }
1319 if (transCh != NULL) {
1320 LOG_DEBUG("[AVDT]%{public}s:transCh index(%{public}d)", __func__, i);
1321 break;
1322 }
1323 }
1324 }
1325 return transCh;
1326 }
1327
1328 /**
1329 *
1330 * @brief AvdtTransChTabAllocate
1331 *
1332 * @details deallocate the transtation channel ctrl block
1333 *
1334 * @return void
1335 *
1336 */
AvdtTransChDealloc(uint16_t lcid)1337 void AvdtTransChDealloc(uint16_t lcid)
1338 {
1339 LOG_DEBUG("[AVDT]%{public}s: lcid(0x%x)", __func__, lcid);
1340 for (int i = 0; i < AVDT_CH_TABLE_SIZE; i++) {
1341 if ((g_avdtCb.transTable[i] != NULL) && lcid == g_avdtCb.transTable[i]->lcid) {
1342 free(g_avdtCb.transTable[i]);
1343 g_avdtCb.transTable[i] = NULL;
1344 break;
1345 }
1346 }
1347 return;
1348 }
1349
1350 /**
1351 *
1352 * @brief AvdtTransChDeallocAll
1353 *
1354 * @details deallocate all transtation channel ctrl block
1355 *
1356 * @return void
1357 *
1358 */
AvdtTransChDeallocAll(void)1359 void AvdtTransChDeallocAll(void)
1360 {
1361 LOG_DEBUG("[AVDT]%{public}s", __func__);
1362 for (int i = 0; i < AVDT_CH_TABLE_SIZE; i++) {
1363 if (g_avdtCb.transTable[i] != NULL) {
1364 free(g_avdtCb.transTable[i]);
1365 g_avdtCb.transTable[i] = NULL;
1366 }
1367 }
1368 return;
1369 }
1370
1371 /**
1372 *
1373 * @brief AvdtAssignSigHandle
1374 *
1375 * @details Assign the handle of signal channel control.
1376 *
1377 * @return The handle of signal channel control .
1378 *
1379 */
AvdtAssignSigHandle(void)1380 uint16_t AvdtAssignSigHandle(void)
1381 {
1382 uint16_t Handle = 0;
1383 for (int i = 0; i < AVDT_NUM_LINKS; i++) {
1384 if (!g_avdtCb.sigHandles[i].isUsed) {
1385 Handle = g_avdtCb.sigHandles[i].handle;
1386 g_avdtCb.sigHandles[i].isUsed = true;
1387 break;
1388 }
1389 }
1390 LOG_DEBUG("[AVDT]%{public}s: handle(%hu)", __func__, Handle);
1391 return Handle;
1392 }
1393
1394 /**
1395 *
1396 * @brief AvdtAssignStreamHandle
1397 *
1398 * @details Assign the handle of stream channel control.
1399 *
1400 * @return The handle of stream channel control .
1401 *
1402 */
AvdtAssignStreamHandle(void)1403 uint16_t AvdtAssignStreamHandle(void)
1404 {
1405 uint16_t Handle = 0;
1406 for (int i = 0; i < AVDT_MAX_NUM_SEP; i++) {
1407 if (!g_avdtCb.streamHandles[i].isUsed) {
1408 Handle = g_avdtCb.streamHandles[i].handle;
1409 g_avdtCb.streamHandles[i].isUsed = true;
1410 break;
1411 }
1412 }
1413 LOG_DEBUG("[AVDT]%{public}s: handle(%hu)", __func__, Handle);
1414 return Handle;
1415 }
1416
1417 /**
1418 *
1419 * @brief AvdtFreeSigHandle
1420 *
1421 * @details Free the signal handle.
1422 *
1423 * @return void.
1424 *
1425 */
AvdtFreeSigHandle(uint16_t handle)1426 void AvdtFreeSigHandle(uint16_t handle)
1427 {
1428 LOG_DEBUG("[AVDT]%{public}s: handle(%hu)", __func__, handle);
1429 for (int i = 0; i < AVDT_NUM_LINKS; i++) {
1430 if (g_avdtCb.sigHandles[i].isUsed && g_avdtCb.sigHandles[i].handle == handle) {
1431 g_avdtCb.sigHandles[i].isUsed = false;
1432 break;
1433 }
1434 }
1435 return;
1436 }
1437
1438 /**
1439 *
1440 * @brief AvdtFreeStreamHandle
1441 *
1442 * @details Free the stream handle.
1443 *
1444 * @return void.
1445 *
1446 */
AvdtFreeStreamHandle(uint16_t handle)1447 void AvdtFreeStreamHandle(uint16_t handle)
1448 {
1449 LOG_DEBUG("[AVDT]%{public}s: handle(%hu)", __func__, handle);
1450 for (int i = 0; i < AVDT_MAX_NUM_SEP; i++) {
1451 if (g_avdtCb.streamHandles[i].isUsed && g_avdtCb.streamHandles[i].handle == handle) {
1452 g_avdtCb.streamHandles[i].isUsed = false;
1453 break;
1454 }
1455 }
1456 return;
1457 }
1458
1459 /**
1460 *
1461 * @brief AvdtFreeSigCtrlByHandle
1462 *
1463 * @details Free the channell.
1464 *
1465 * @return
1466 *
1467 */
AvdtFreeSigCtrlByHandle(uint16_t handle)1468 void AvdtFreeSigCtrlByHandle(uint16_t handle)
1469 {
1470 LOG_DEBUG("[AVDT]%{public}s: handle(%hu)", __func__, handle);
1471 for (int i = 0; i < AVDT_NUM_LINKS; i++) {
1472 if ((g_avdtCb.sigCtrl[i] != NULL) && handle == g_avdtCb.sigCtrl[i]->handle) {
1473 AvdtFreeSigHandle(g_avdtCb.sigCtrl[i]->handle);
1474 if (g_avdtCb.sigCtrl[i]->currentMsg != NULL) {
1475 PacketFree(g_avdtCb.sigCtrl[i]->currentMsg);
1476 g_avdtCb.sigCtrl[i]->currentMsg = NULL;
1477 }
1478 if (g_avdtCb.sigCtrl[i]->rxMsg != NULL) {
1479 PacketFree(g_avdtCb.sigCtrl[i]->rxMsg);
1480 g_avdtCb.sigCtrl[i]->rxMsg = NULL;
1481 }
1482 if (g_avdtCb.sigCtrl[i] != NULL) {
1483 free(g_avdtCb.sigCtrl[i]);
1484 g_avdtCb.sigCtrl[i] = NULL;
1485 }
1486 LOG_DEBUG("[AVDT]%{public}s: Free channel handle(%hu)", __func__, handle);
1487 break;
1488 }
1489 }
1490 }
1491
1492 /**
1493 *
1494 * @brief AvdtCreateTransLabel
1495 *
1496 * @details Create the transport label to mark message
1497 *
1498 * @return The transport label of signalling message
1499 *
1500 */
AvdtCreateTransLabel(AvdtSigCtrl * sigCtrl)1501 uint8_t AvdtCreateTransLabel(AvdtSigCtrl *sigCtrl)
1502 {
1503 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1504 uint8_t TransLabel = (++sigCtrl->label) % AVDT_LABEL_MAX;
1505 return TransLabel;
1506 }
1507
1508 /**
1509 *
1510 * @brief AvdtCreateHandle
1511 *
1512 * @details Allocate the sequence number of media packet.
1513 *
1514 * @return The sequence number of media packet.
1515 *
1516 */
AvdtCreateSequenceNo(AvdtStreamCtrl * avdtStreamCtrl)1517 uint16_t AvdtCreateSequenceNo(AvdtStreamCtrl *avdtStreamCtrl)
1518 {
1519 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1520 uint16_t Sn = (avdtStreamCtrl->mediaSeq++) % AVDT_MEDIA_SEQ_MAX;
1521 return Sn;
1522 }
1523
1524 /**
1525 *
1526 * @brief AvdtCtrlEvtCallback
1527 *
1528 * @details Control event callback to upper app.
1529 *
1530 * @return void.
1531 *
1532 */
AvdtCtrlEvtCallback(AvdtSigCtrl * sigCtrl,uint16_t handle,const BtAddr * bdAddr,uint8_t event,const AvdtCtrlData * data,uint8_t role)1533 NO_SANITIZE("cfi") void AvdtCtrlEvtCallback(
1534 AvdtSigCtrl *sigCtrl, uint16_t handle, const BtAddr *bdAddr, uint8_t event, const AvdtCtrlData *data, uint8_t role)
1535 {
1536 if (sigCtrl->procCback != NULL) {
1537 LOG_DEBUG("[AVDT]----------%{public}s: handle(%hu) EventId(%hhu), role(%hhu)", __func__, handle, event, role);
1538 sigCtrl->procCback(handle, bdAddr, event, data, role);
1539 }
1540 return;
1541 }
1542
1543 /**
1544 *
1545 * @brief AvdtCreateSEP
1546 * @details Create a stream endpoint.
1547 * @return AVDT_SUCCESS if successful, otherwise error.
1548 *
1549 */
AvdtCreateSEP(const BtAddr * bdAddr)1550 uint16_t AvdtCreateSEP(const BtAddr *bdAddr)
1551 {
1552 LOG_INFO("[AVDT]%{public}s:bdAddr((%02x:%02x:%02x:%02x:%02x:%02x)", __func__, BT_ADDR_FMT_DSC(bdAddr->addr));
1553 uint16_t Ret = AVDT_SUCCESS;
1554 AvdtSigCtrl *sigCtrl = NULL;
1555 AvdtStreamCtrl *streamCtrl = NULL;
1556 /* Allocate channel ctrl and stream ctrl */
1557 for (int i = 0; i < AVDT_NUM_SEPS; i++) {
1558 if (!g_avdtCb.localSEP[i].isExited) {
1559 continue;
1560 }
1561 sigCtrl = AvdtGetSigCtrlByAddr(bdAddr);
1562 if (sigCtrl == NULL) {
1563 sigCtrl = AvdtSigCtrlAllocate(bdAddr, AVDT_ROLE_UNKOWN);
1564 if (sigCtrl == NULL) {
1565 Ret = AVDT_NO_RESOURCES;
1566 return Ret;
1567 }
1568 }
1569 streamCtrl = AvdtStreamCtrlAllocate(sigCtrl, g_avdtCb.localSEP[i].localConfigure.codecIndex);
1570 if (streamCtrl == NULL) {
1571 Ret = AVDT_NO_RESOURCES;
1572 } else {
1573 LOG_DEBUG("[AVDT]%{public}s: streamCtrl->handle(%hu)", __func__, streamCtrl->handle);
1574 }
1575 if (Ret != AVDT_SUCCESS) {
1576 LOG_WARN("[AVDT]%{public}s: Ret(%hu)", __func__, Ret);
1577 }
1578 }
1579 return Ret;
1580 }
1581
1582 /**
1583 *
1584 * @brief AvdtCheckSepExited
1585 * @details Check the sep is used.
1586 * @return the index of the used sep. else 0
1587 *
1588 */
AvdtCheckSepExited(uint16_t codecIndex)1589 uint16_t AvdtCheckSepExited(uint16_t codecIndex)
1590 {
1591 LOG_DEBUG("[AVDT]%{public}s:codecIndex(%hu)", __func__, codecIndex);
1592 int sepId;
1593 for (sepId = 0; sepId < AVDT_NUM_SEPS; sepId++) {
1594 if (g_avdtCb.localSEP[sepId].isExited) {
1595 if ((codecIndex != 0) && (codecIndex == g_avdtCb.localSEP[sepId].localConfigure.codecIndex)) {
1596 break;
1597 }
1598 }
1599 }
1600 return sepId;
1601 }
1602
1603 /**
1604 *
1605 * @brief AvdtSepAlloc
1606 * @details Allock Sep resourse.
1607 * @return the index of the sep. else 0
1608 *
1609 */
AvdtSepAlloc(AvdtStreamConfig * avdtStreamConfig)1610 uint16_t AvdtSepAlloc(AvdtStreamConfig *avdtStreamConfig)
1611 {
1612 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1613 int sepId;
1614 for (sepId = 0; sepId < AVDT_NUM_SEPS; sepId++) {
1615 if (!g_avdtCb.localSEP[sepId].isExited) {
1616 (void)memcpy_s(&g_avdtCb.localSEP[sepId].localConfigure,
1617 sizeof(AvdtStreamConfig),
1618 avdtStreamConfig,
1619 sizeof(AvdtStreamConfig));
1620 g_avdtCb.localSEP[sepId].isExited = true;
1621 LOG_DEBUG("[AVDT]%{public}s: localSEP(%{public}d): codecIndex(%hu) sepType(%hhu))",
1622 __func__,
1623 sepId,
1624 avdtStreamConfig->codecIndex,
1625 avdtStreamConfig->sepType);
1626 break;
1627 }
1628 }
1629 return sepId;
1630 }
1631
1632 /**
1633 *
1634 * @brief AvdtGetSepConfigByCodecIndex
1635 * @details Get the sep config by codec index.
1636 * @return sep config info or NULL.
1637 *
1638 */
AvdtGetSepConfigByCodecIndex(uint16_t codecIndex)1639 AvdtStreamConfig *AvdtGetSepConfigByCodecIndex(uint16_t codecIndex)
1640 {
1641 LOG_DEBUG("[AVDT]%{public}s: codecIndex(%hu)", __func__, codecIndex);
1642 AvdtStreamConfig *config = NULL;
1643 for (int i = 0; i < AVDT_NUM_SEPS; i++) {
1644 if (g_avdtCb.localSEP[i].isExited) {
1645 if (g_avdtCb.localSEP[i].localConfigure.codecIndex == codecIndex) {
1646 LOG_DEBUG("[AVDT]%{public}s:localSepIndex(%{public}d):", __func__, i);
1647 config = &g_avdtCb.localSEP[i].localConfigure;
1648 break;
1649 }
1650 }
1651 }
1652 return config;
1653 }
1654
1655 /**
1656 *
1657 * @brief AvdtCheckSepIsUsed
1658 * @details Check if the sep is used.
1659 * @return Used:Sep ID Unused: 0.
1660 *
1661 */
AvdtCheckSepIsUsed(AvdtSigCtrl * sigCtrl,uint16_t codecIndex)1662 uint16_t AvdtCheckSepIsUsed(AvdtSigCtrl *sigCtrl, uint16_t codecIndex)
1663 {
1664 LOG_DEBUG("[AVDT]%{public}s: codecIndex(%hu)", __func__, codecIndex);
1665 uint16_t Handle = 0;
1666 for (int i = 0; i < AVDT_NUM_SEPS; i++) {
1667 if ((sigCtrl->streamCtrl[i].isAllocated) && (codecIndex != 0) &&
1668 (codecIndex == sigCtrl->streamCtrl[i].codecIndex)) {
1669 Handle = sigCtrl->streamCtrl[i].handle;
1670 break;
1671 }
1672 }
1673 return Handle;
1674 }
1675
AvdtAsyncProcess(void (* callback)(void * context),void * context)1676 uint8_t AvdtAsyncProcess(void (*callback)(void *context), void *context)
1677 {
1678 if (BTM_RunTaskInProcessingQueue(PROCESSING_QUEUE_ID_AVDTP, callback, context)) {
1679 return AVDT_FAILED;
1680 }
1681 return AVDT_SUCCESS;
1682 }
1683
AvdtGetMtu(void)1684 uint16_t AvdtGetMtu(void)
1685 {
1686 return g_avdtCb.regInfo.mtu;
1687 }
1688
AvdtRegister(const AvdtRegisterParam * reg)1689 void AvdtRegister(const AvdtRegisterParam *reg)
1690 {
1691 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1692 if (!g_avdtCb.avdtRegisted) {
1693 g_avdtCb.regInfo = *reg;
1694 }
1695 g_avdtCb.avdtRegisted = true;
1696 return;
1697 }
1698
AvdtRegisterLocalSEP(AvdtStreamConfig * avdtStreamConfig,uint8_t number)1699 uint16_t AvdtRegisterLocalSEP(AvdtStreamConfig *avdtStreamConfig, uint8_t number)
1700 {
1701 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1702 uint16_t Ret = AVDT_SUCCESS;
1703 if (g_avdtCb.sepRegisted) {
1704 LOG_WARN("[AVDT]%{public}s: Stream endpoint had been registered ", __func__);
1705 return Ret;
1706 }
1707 g_avdtCb.sepRegisted = true;
1708 /* judge avdt Ind,Cfm callback and service capabilities */
1709 for (int i = 0; i < number; i++) {
1710 if (avdtStreamConfig[i].cfg.pscMask == 0 || ((avdtStreamConfig[i].cfg.pscMask & (~AVDT_PSC_MSK)) != 0)) {
1711 LOG_WARN("[AVDT]%{public}s: service capabilities(0x%x) is invalid",
1712 __func__, avdtStreamConfig[i].cfg.pscMask);
1713 Ret = AVDT_BAD_PARAMS;
1714 return Ret;
1715 } else {
1716 if (AvdtCheckSepExited(avdtStreamConfig[i].codecIndex) < AVDT_NUM_SEPS) {
1717 LOG_INFO("[AVDT]%{public}s: The sep(%hu) had registered ", __func__, avdtStreamConfig[i].codecIndex);
1718 } else if (AvdtSepAlloc(&avdtStreamConfig[i]) == AVDT_NUM_SEPS) {
1719 LOG_WARN("[AVDT]%{public}s: No resources for scbHandle(%hu)", __func__, avdtStreamConfig[i].codecIndex);
1720 Ret = AVDT_NO_RESOURCES;
1721 }
1722 }
1723 }
1724 return Ret;
1725 }
1726
1727 typedef struct {
1728 BtAddr addr;
1729 bool support;
1730 } AvdtRemoteDeviceSupportCallbackParam;
1731
AvdtRemoteDeviceSupport2MbCallbackTask(void * ctx)1732 static void AvdtRemoteDeviceSupport2MbCallbackTask(void *ctx)
1733 {
1734 AvdtRemoteDeviceSupportCallbackParam *param = (AvdtRemoteDeviceSupportCallbackParam *)ctx;
1735
1736 if (param->support) {
1737 AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByAddr(¶m->addr);
1738 if (NULL != sigCtrl) {
1739 sigCtrl->edr = (sigCtrl->edr) | AVDT_2MB_MODE;
1740 LOG_INFO("[AVDT]%{public}s: edr(%hhu)", __func__, sigCtrl->edr);
1741 }
1742 }
1743 free(ctx);
1744 }
1745
AvdtRecvRemoteDeviceSupport2MbCallback(const BtAddr * addr,bool support)1746 static void AvdtRecvRemoteDeviceSupport2MbCallback(const BtAddr *addr, bool support)
1747 {
1748 LOG_INFO("[AVDT]%{public}s: addr(%02x:%02x:%02x:%02x:%02x:%02x),support(%{public}d)",
1749 __func__, BT_ADDR_FMT_DSC(addr->addr), support);
1750 AvdtRemoteDeviceSupportCallbackParam *supportParam = malloc(sizeof(AvdtRemoteDeviceSupportCallbackParam));
1751 if (supportParam == NULL) {
1752 LOG_ERROR("%{public}s: Alloc error.", __FUNCTION__);
1753 return;
1754 }
1755
1756 supportParam->addr = *addr;
1757 supportParam->support = support;
1758
1759 int ret = AvdtAsyncProcess(AvdtRemoteDeviceSupport2MbCallbackTask, supportParam);
1760 if (ret != AVDT_SUCCESS) {
1761 LOG_ERROR("%{public}s: Task error:%{public}d.", __FUNCTION__, ret);
1762 }
1763 }
1764
AvdtRemoteDeviceSupport3MbCallbackTask(void * ctx)1765 static void AvdtRemoteDeviceSupport3MbCallbackTask(void *ctx)
1766 {
1767 AvdtRemoteDeviceSupportCallbackParam *param = (AvdtRemoteDeviceSupportCallbackParam *)ctx;
1768
1769 if (param->support) {
1770 AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByAddr(¶m->addr);
1771 if (NULL != sigCtrl) {
1772 sigCtrl->edr = (sigCtrl->edr) | AVDT_3MB_MODE;
1773 LOG_INFO("[AVDT]%{public}s: edr(%hhu)", __func__, sigCtrl->edr);
1774 }
1775 }
1776 free(ctx);
1777 }
1778
AvdtRecvRemoteDeviceSupport3MbCallback(const BtAddr * addr,bool support)1779 static void AvdtRecvRemoteDeviceSupport3MbCallback(const BtAddr *addr, bool support)
1780 {
1781 LOG_INFO(
1782 "[AVDT]%{public}s: addr(%02x:%02x:%02x:%02x:%02x:%02x),support(%{public}d)",
1783 __func__, BT_ADDR_FMT_DSC(addr->addr), support);
1784 AvdtRemoteDeviceSupportCallbackParam *supportParam = malloc(sizeof(AvdtRemoteDeviceSupportCallbackParam));
1785 if (supportParam == NULL) {
1786 LOG_ERROR("%{public}s: Alloc error.", __FUNCTION__);
1787 return;
1788 }
1789
1790 supportParam->addr = *addr;
1791 supportParam->support = support;
1792
1793 int ret = AvdtAsyncProcess(AvdtRemoteDeviceSupport3MbCallbackTask, supportParam);
1794 if (ret != AVDT_SUCCESS) {
1795 LOG_ERROR("%{public}s: Task error:%{public}d.", __FUNCTION__, ret);
1796 }
1797 }
1798
AvdtIsEdr2MbMode(const BtAddr * bdAddr)1799 void AvdtIsEdr2MbMode(const BtAddr *bdAddr)
1800 {
1801 LOG_INFO("[AVDT]%{public}s: addr(%02x:%02x:%02x:%02x:%02x:%02x)", __func__, BT_ADDR_FMT_DSC(bdAddr->addr));
1802 BTM_IsRemoteDeviceSupportEdrAcl2MbMode(bdAddr, AvdtRecvRemoteDeviceSupport2MbCallback);
1803 }
1804
AvdtIsEdr3MbMode(const BtAddr * bdAddr)1805 void AvdtIsEdr3MbMode(const BtAddr *bdAddr)
1806 {
1807 LOG_INFO("[AVDT]%{public}s: addr(%02x:%02x:%02x:%02x:%02x:%02x)", __func__, BT_ADDR_FMT_DSC(bdAddr->addr));
1808 BTM_IsRemoteDeviceSupportEdrAcl3MbMode(bdAddr, AvdtRecvRemoteDeviceSupport3MbCallback);
1809 }
1810