1 /* btp_bap.c - Bluetooth BAP Tester */
2
3 /*
4 * Copyright (c) 2023 Codecoup
5 * Copyright (c) 2024 Nordic Semiconductor ASA
6 *
7 * SPDX-License-Identifier: Apache-2.0
8 */
9
10 #include <stdint.h>
11 #include <stddef.h>
12 #include <errno.h>
13
14 #include <zephyr/types.h>
15 #include <zephyr/kernel.h>
16 #include <zephyr/sys/ring_buffer.h>
17 #include <zephyr/bluetooth/audio/pacs.h>
18 #include <zephyr/bluetooth/audio/bap_lc3_preset.h>
19 #include <hci_core.h>
20
21 #include <zephyr/logging/log.h>
22 #include <zephyr/sys/byteorder.h>
23 #define LOG_MODULE_NAME bttester_bap
24 LOG_MODULE_REGISTER(LOG_MODULE_NAME, CONFIG_BTTESTER_LOG_LEVEL);
25 #include "btp/btp.h"
26 #include "btp_bap_audio_stream.h"
27 #include "btp_bap_unicast.h"
28 #include "btp_bap_broadcast.h"
29
30 #define SUPPORTED_SINK_CONTEXT BT_AUDIO_CONTEXT_TYPE_ANY
31 #define SUPPORTED_SOURCE_CONTEXT BT_AUDIO_CONTEXT_TYPE_ANY
32
33 #define AVAILABLE_SINK_CONTEXT SUPPORTED_SINK_CONTEXT
34 #define AVAILABLE_SOURCE_CONTEXT SUPPORTED_SOURCE_CONTEXT
35
36 static const struct bt_audio_codec_cap default_codec_cap = BT_AUDIO_CODEC_CAP_LC3(
37 BT_AUDIO_CODEC_CAP_FREQ_ANY, BT_AUDIO_CODEC_CAP_DURATION_7_5 |
38 BT_AUDIO_CODEC_CAP_DURATION_10, BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 2), 26u, 155u, 1u,
39 BT_AUDIO_CONTEXT_TYPE_ANY);
40
41 static const struct bt_audio_codec_cap vendor_codec_cap = BT_AUDIO_CODEC_CAP(
42 0xff, 0xffff, 0xffff, BT_AUDIO_CODEC_CAP_LC3_DATA(BT_AUDIO_CODEC_CAP_FREQ_ANY,
43 BT_AUDIO_CODEC_CAP_DURATION_7_5 | BT_AUDIO_CODEC_CAP_DURATION_10,
44 BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 2), 26u, 155, 1u),
45 BT_AUDIO_CODEC_CAP_LC3_META(BT_AUDIO_CONTEXT_TYPE_ANY));
46
47 static struct bt_pacs_cap cap_sink = {
48 .codec_cap = &default_codec_cap,
49 };
50
51 static struct bt_pacs_cap cap_source = {
52 .codec_cap = &default_codec_cap,
53 };
54
55 static struct bt_pacs_cap vendor_cap_sink = {
56 .codec_cap = &vendor_codec_cap,
57 };
58
59 static struct bt_pacs_cap vendor_cap_source = {
60 .codec_cap = &vendor_codec_cap,
61 };
62
btp_ascs_supported_commands(const void * cmd,uint16_t cmd_len,void * rsp,uint16_t * rsp_len)63 static uint8_t btp_ascs_supported_commands(const void *cmd, uint16_t cmd_len,
64 void *rsp, uint16_t *rsp_len)
65 {
66 struct btp_ascs_read_supported_commands_rp *rp = rsp;
67
68 /* octet 0 */
69 tester_set_bit(rp->data, BTP_ASCS_READ_SUPPORTED_COMMANDS);
70
71 *rsp_len = sizeof(*rp) + 1;
72
73 return BTP_STATUS_SUCCESS;
74 }
75
76 static const struct btp_handler ascs_handlers[] = {
77 {
78 .opcode = BTP_ASCS_READ_SUPPORTED_COMMANDS,
79 .index = BTP_INDEX_NONE,
80 .expect_len = 0,
81 .func = btp_ascs_supported_commands,
82 },
83 {
84 .opcode = BTP_ASCS_CONFIGURE_CODEC,
85 .expect_len = BTP_HANDLER_LENGTH_VARIABLE,
86 .func = btp_ascs_configure_codec,
87 },
88 {
89 .opcode = BTP_ASCS_CONFIGURE_QOS,
90 .expect_len = sizeof(struct btp_ascs_configure_qos_cmd),
91 .func = btp_ascs_configure_qos,
92 },
93 {
94 .opcode = BTP_ASCS_ENABLE,
95 .expect_len = sizeof(struct btp_ascs_enable_cmd),
96 .func = btp_ascs_enable,
97 },
98 {
99 .opcode = BTP_ASCS_RECEIVER_START_READY,
100 .expect_len = sizeof(struct btp_ascs_receiver_start_ready_cmd),
101 .func = btp_ascs_receiver_start_ready,
102 },
103 {
104 .opcode = BTP_ASCS_RECEIVER_STOP_READY,
105 .expect_len = sizeof(struct btp_ascs_receiver_stop_ready_cmd),
106 .func = btp_ascs_receiver_stop_ready,
107 },
108 {
109 .opcode = BTP_ASCS_DISABLE,
110 .expect_len = sizeof(struct btp_ascs_disable_cmd),
111 .func = btp_ascs_disable,
112 },
113 {
114 .opcode = BTP_ASCS_RELEASE,
115 .expect_len = sizeof(struct btp_ascs_release_cmd),
116 .func = btp_ascs_release,
117 },
118 {
119 .opcode = BTP_ASCS_UPDATE_METADATA,
120 .expect_len = sizeof(struct btp_ascs_update_metadata_cmd),
121 .func = btp_ascs_update_metadata,
122 },
123 {
124 .opcode = BTP_ASCS_ADD_ASE_TO_CIS,
125 .expect_len = sizeof(struct btp_ascs_add_ase_to_cis),
126 .func = btp_ascs_add_ase_to_cis,
127 },
128 {
129 .opcode = BTP_ASCS_PRECONFIGURE_QOS,
130 .expect_len = sizeof(struct btp_ascs_preconfigure_qos_cmd),
131 .func = btp_ascs_preconfigure_qos,
132 },
133 };
134
set_location(void)135 static int set_location(void)
136 {
137 int err;
138
139 err = bt_pacs_set_location(BT_AUDIO_DIR_SINK,
140 BT_AUDIO_LOCATION_FRONT_CENTER |
141 BT_AUDIO_LOCATION_FRONT_RIGHT);
142 if (err != 0) {
143 return err;
144 }
145
146 err = bt_pacs_set_location(BT_AUDIO_DIR_SOURCE,
147 (BT_AUDIO_LOCATION_FRONT_LEFT |
148 BT_AUDIO_LOCATION_FRONT_RIGHT));
149 if (err != 0) {
150 return err;
151 }
152
153 return 0;
154 }
155
set_available_contexts(void)156 static int set_available_contexts(void)
157 {
158 int err;
159
160 err = bt_pacs_set_available_contexts(BT_AUDIO_DIR_SOURCE,
161 AVAILABLE_SOURCE_CONTEXT);
162 if (err != 0) {
163 return err;
164 }
165
166 err = bt_pacs_set_available_contexts(BT_AUDIO_DIR_SINK,
167 AVAILABLE_SINK_CONTEXT);
168 if (err != 0) {
169 return err;
170 }
171
172 return 0;
173 }
174
set_supported_contexts(void)175 static int set_supported_contexts(void)
176 {
177 int err;
178
179 err = bt_pacs_set_supported_contexts(BT_AUDIO_DIR_SOURCE,
180 SUPPORTED_SOURCE_CONTEXT);
181 if (err != 0) {
182 return err;
183 }
184
185 err = bt_pacs_set_supported_contexts(BT_AUDIO_DIR_SINK,
186 SUPPORTED_SINK_CONTEXT);
187 if (err != 0) {
188 return err;
189 }
190
191 return 0;
192 }
193
pacs_supported_commands(const void * cmd,uint16_t cmd_len,void * rsp,uint16_t * rsp_len)194 static uint8_t pacs_supported_commands(const void *cmd, uint16_t cmd_len,
195 void *rsp, uint16_t *rsp_len)
196 {
197 struct btp_pacs_read_supported_commands_rp *rp = rsp;
198
199 /* octet 0 */
200 tester_set_bit(rp->data, BTP_PACS_READ_SUPPORTED_COMMANDS);
201 tester_set_bit(rp->data, BTP_PACS_UPDATE_CHARACTERISTIC);
202 tester_set_bit(rp->data, BTP_PACS_SET_LOCATION);
203 tester_set_bit(rp->data, BTP_PACS_SET_AVAILABLE_CONTEXTS);
204 tester_set_bit(rp->data, BTP_PACS_SET_SUPPORTED_CONTEXTS);
205
206 *rsp_len = sizeof(*rp) + 1;
207
208 return BTP_STATUS_SUCCESS;
209 }
210
pacs_update_characteristic(const void * cmd,uint16_t cmd_len,void * rsp,uint16_t * rsp_len)211 static uint8_t pacs_update_characteristic(const void *cmd, uint16_t cmd_len,
212 void *rsp, uint16_t *rsp_len)
213 {
214 const struct btp_pacs_update_characteristic_cmd *cp = cmd;
215 int err;
216
217 switch (cp->characteristic) {
218 case BTP_PACS_CHARACTERISTIC_SINK_PAC:
219 err = bt_pacs_cap_unregister(BT_AUDIO_DIR_SINK,
220 &cap_sink);
221 break;
222 case BTP_PACS_CHARACTERISTIC_SOURCE_PAC:
223 err = bt_pacs_cap_unregister(BT_AUDIO_DIR_SOURCE,
224 &cap_source);
225 break;
226 case BTP_PACS_CHARACTERISTIC_SINK_AUDIO_LOCATIONS:
227 err = bt_pacs_set_location(BT_AUDIO_DIR_SINK,
228 BT_AUDIO_LOCATION_FRONT_CENTER |
229 BT_AUDIO_LOCATION_BACK_CENTER);
230 break;
231 case BTP_PACS_CHARACTERISTIC_SOURCE_AUDIO_LOCATIONS:
232 err = bt_pacs_set_location(BT_AUDIO_DIR_SOURCE,
233 (BT_AUDIO_LOCATION_FRONT_LEFT |
234 BT_AUDIO_LOCATION_FRONT_RIGHT |
235 BT_AUDIO_LOCATION_FRONT_CENTER));
236 break;
237 case BTP_PACS_CHARACTERISTIC_AVAILABLE_AUDIO_CONTEXTS:
238 err = bt_pacs_set_available_contexts(BT_AUDIO_DIR_SOURCE,
239 BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED);
240 break;
241 case BTP_PACS_CHARACTERISTIC_SUPPORTED_AUDIO_CONTEXTS:
242 err = bt_pacs_set_supported_contexts(BT_AUDIO_DIR_SOURCE,
243 SUPPORTED_SOURCE_CONTEXT |
244 BT_AUDIO_CONTEXT_TYPE_INSTRUCTIONAL);
245 break;
246 default:
247 return BTP_STATUS_FAILED;
248 }
249
250 return BTP_STATUS_VAL(err);
251 }
252
pacs_set_location(const void * cmd,uint16_t cmd_len,void * rsp,uint16_t * rsp_len)253 static uint8_t pacs_set_location(const void *cmd, uint16_t cmd_len,
254 void *rsp, uint16_t *rsp_len)
255 {
256 const struct btp_pacs_set_location_cmd *cp = cmd;
257 int err;
258
259 err = bt_pacs_set_location((enum bt_audio_dir)cp->dir,
260 (enum bt_audio_location)cp->location);
261
262 return (err) ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS;
263 }
264
pacs_set_available_contexts(const void * cmd,uint16_t cmd_len,void * rsp,uint16_t * rsp_len)265 static uint8_t pacs_set_available_contexts(const void *cmd, uint16_t cmd_len,
266 void *rsp, uint16_t *rsp_len)
267 {
268 const struct btp_pacs_set_available_contexts_cmd *cp = cmd;
269 int err;
270
271 err = bt_pacs_set_available_contexts(BT_AUDIO_DIR_SINK,
272 (enum bt_audio_context)cp->sink_contexts);
273 if (err) {
274 return BTP_STATUS_FAILED;
275 }
276 err = bt_pacs_set_available_contexts(BT_AUDIO_DIR_SOURCE,
277 (enum bt_audio_context)cp->source_contexts);
278
279 return (err) ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS;
280 }
281
pacs_set_supported_contexts(const void * cmd,uint16_t cmd_len,void * rsp,uint16_t * rsp_len)282 static uint8_t pacs_set_supported_contexts(const void *cmd, uint16_t cmd_len,
283 void *rsp, uint16_t *rsp_len)
284 {
285 const struct btp_pacs_set_supported_contexts_cmd *cp = cmd;
286 int err;
287
288 err = bt_pacs_set_supported_contexts(BT_AUDIO_DIR_SINK,
289 (enum bt_audio_context)cp->sink_contexts);
290 if (err) {
291 return BTP_STATUS_FAILED;
292 }
293 err = bt_pacs_set_supported_contexts(BT_AUDIO_DIR_SOURCE,
294 (enum bt_audio_context)cp->source_contexts);
295
296 return (err) ? BTP_STATUS_FAILED : BTP_STATUS_SUCCESS;
297 }
298
299 static const struct btp_handler pacs_handlers[] = {
300 {
301 .opcode = BTP_PACS_READ_SUPPORTED_COMMANDS,
302 .index = BTP_INDEX_NONE,
303 .expect_len = 0,
304 .func = pacs_supported_commands,
305 },
306 {
307 .opcode = BTP_PACS_UPDATE_CHARACTERISTIC,
308 .expect_len = sizeof(struct btp_pacs_update_characteristic_cmd),
309 .func = pacs_update_characteristic,
310 },
311 {
312 .opcode = BTP_PACS_SET_LOCATION,
313 .expect_len = sizeof(struct btp_pacs_set_location_cmd),
314 .func = pacs_set_location
315 },
316 {
317 .opcode = BTP_PACS_SET_AVAILABLE_CONTEXTS,
318 .expect_len = sizeof(struct btp_pacs_set_available_contexts_cmd),
319 .func = pacs_set_available_contexts
320 },
321 {
322 .opcode = BTP_PACS_SET_SUPPORTED_CONTEXTS,
323 .expect_len = sizeof(struct btp_pacs_set_supported_contexts_cmd),
324 .func = pacs_set_supported_contexts
325 }
326 };
327
btp_bap_supported_commands(const void * cmd,uint16_t cmd_len,void * rsp,uint16_t * rsp_len)328 static uint8_t btp_bap_supported_commands(const void *cmd, uint16_t cmd_len,
329 void *rsp, uint16_t *rsp_len)
330 {
331 struct btp_bap_read_supported_commands_rp *rp = rsp;
332
333 /* octet 0 */
334 tester_set_bit(rp->data, BTP_BAP_READ_SUPPORTED_COMMANDS);
335 tester_set_bit(rp->data, BTP_BAP_DISCOVER);
336 tester_set_bit(rp->data, BTP_BAP_SEND);
337
338 *rsp_len = sizeof(*rp) + 1;
339
340 return BTP_STATUS_SUCCESS;
341 }
342
btp_bap_audio_stream_send(const void * cmd,uint16_t cmd_len,void * rsp,uint16_t * rsp_len)343 uint8_t btp_bap_audio_stream_send(const void *cmd, uint16_t cmd_len, void *rsp, uint16_t *rsp_len)
344 {
345 struct btp_bap_send_rp *rp = rsp;
346 const struct btp_bap_send_cmd *cp = cmd;
347
348 /* Always send dummy success for now until the command has be deprecated
349 * https://github.com/auto-pts/auto-pts/issues/1317
350 */
351 rp->data_len = cp->data_len;
352 *rsp_len = sizeof(*rp);
353
354 return BTP_STATUS_SUCCESS;
355 }
356
357 static const struct btp_handler bap_handlers[] = {
358 {
359 .opcode = BTP_BAP_READ_SUPPORTED_COMMANDS,
360 .index = BTP_INDEX_NONE,
361 .expect_len = 0,
362 .func = btp_bap_supported_commands,
363 },
364 {
365 .opcode = BTP_BAP_DISCOVER,
366 .expect_len = sizeof(struct btp_bap_discover_cmd),
367 .func = btp_bap_discover,
368 },
369 {
370 .opcode = BTP_BAP_SEND,
371 .expect_len = BTP_HANDLER_LENGTH_VARIABLE,
372 .func = btp_bap_audio_stream_send,
373 },
374 #if defined(CONFIG_BT_BAP_BROADCAST_SOURCE) || defined(CONFIG_BT_BAP_BROADCAST_SINK)
375 {
376 .opcode = BTP_BAP_BROADCAST_SOURCE_SETUP,
377 .expect_len = BTP_HANDLER_LENGTH_VARIABLE,
378 .func = btp_bap_broadcast_source_setup,
379 },
380 {
381 .opcode = BTP_BAP_BROADCAST_SOURCE_SETUP_V2,
382 .expect_len = BTP_HANDLER_LENGTH_VARIABLE,
383 .func = btp_bap_broadcast_source_setup_v2,
384 },
385 {
386 .opcode = BTP_BAP_BROADCAST_SOURCE_RELEASE,
387 .expect_len = sizeof(struct btp_bap_broadcast_source_release_cmd),
388 .func = btp_bap_broadcast_source_release,
389 },
390 {
391 .opcode = BTP_BAP_BROADCAST_ADV_START,
392 .expect_len = sizeof(struct btp_bap_broadcast_adv_start_cmd),
393 .func = btp_bap_broadcast_adv_start,
394 },
395 {
396 .opcode = BTP_BAP_BROADCAST_ADV_STOP,
397 .expect_len = sizeof(struct btp_bap_broadcast_adv_stop_cmd),
398 .func = btp_bap_broadcast_adv_stop,
399 },
400 {
401 .opcode = BTP_BAP_BROADCAST_SOURCE_START,
402 .expect_len = sizeof(struct btp_bap_broadcast_source_start_cmd),
403 .func = btp_bap_broadcast_source_start,
404 },
405 {
406 .opcode = BTP_BAP_BROADCAST_SOURCE_STOP,
407 .expect_len = sizeof(struct btp_bap_broadcast_source_stop_cmd),
408 .func = btp_bap_broadcast_source_stop,
409 },
410 {
411 .opcode = BTP_BAP_BROADCAST_SINK_SETUP,
412 .expect_len = BTP_HANDLER_LENGTH_VARIABLE,
413 .func = btp_bap_broadcast_sink_setup,
414 },
415 {
416 .opcode = BTP_BAP_BROADCAST_SINK_RELEASE,
417 .expect_len = sizeof(struct btp_bap_broadcast_sink_release_cmd),
418 .func = btp_bap_broadcast_sink_release,
419 },
420 {
421 .opcode = BTP_BAP_BROADCAST_SCAN_START,
422 .expect_len = sizeof(struct btp_bap_broadcast_scan_start_cmd),
423 .func = btp_bap_broadcast_scan_start,
424 },
425 {
426 .opcode = BTP_BAP_BROADCAST_SCAN_STOP,
427 .expect_len = sizeof(struct btp_bap_broadcast_scan_stop_cmd),
428 .func = btp_bap_broadcast_scan_stop,
429 },
430 {
431 .opcode = BTP_BAP_BROADCAST_SINK_SYNC,
432 .expect_len = sizeof(struct btp_bap_broadcast_sink_sync_cmd),
433 .func = btp_bap_broadcast_sink_sync,
434 },
435 {
436 .opcode = BTP_BAP_BROADCAST_SINK_STOP,
437 .expect_len = sizeof(struct btp_bap_broadcast_sink_stop_cmd),
438 .func = btp_bap_broadcast_sink_stop,
439 },
440 {
441 .opcode = BTP_BAP_BROADCAST_SINK_BIS_SYNC,
442 .expect_len = sizeof(struct btp_bap_broadcast_sink_bis_sync_cmd),
443 .func = btp_bap_broadcast_sink_bis_sync,
444 },
445 {
446 .opcode = BTP_BAP_DISCOVER_SCAN_DELEGATORS,
447 .expect_len = sizeof(struct btp_bap_discover_scan_delegators_cmd),
448 .func = btp_bap_broadcast_discover_scan_delegators,
449 },
450 {
451 .opcode = BTP_BAP_BROADCAST_ASSISTANT_SCAN_START,
452 .expect_len = sizeof(struct btp_bap_broadcast_assistant_scan_start_cmd),
453 .func = btp_bap_broadcast_assistant_scan_start,
454 },
455 {
456 .opcode = BTP_BAP_BROADCAST_ASSISTANT_SCAN_STOP,
457 .expect_len = sizeof(struct btp_bap_broadcast_assistant_scan_stop_cmd),
458 .func = btp_bap_broadcast_assistant_scan_stop,
459 },
460 {
461 .opcode = BTP_BAP_ADD_BROADCAST_SRC,
462 .expect_len = BTP_HANDLER_LENGTH_VARIABLE,
463 .func = btp_bap_broadcast_assistant_add_src,
464 },
465 {
466 .opcode = BTP_BAP_REMOVE_BROADCAST_SRC,
467 .expect_len = sizeof(struct btp_bap_remove_broadcast_src_cmd),
468 .func = btp_bap_broadcast_assistant_remove_src,
469 },
470 {
471 .opcode = BTP_BAP_MODIFY_BROADCAST_SRC,
472 .expect_len = BTP_HANDLER_LENGTH_VARIABLE,
473 .func = btp_bap_broadcast_assistant_modify_src,
474 },
475 {
476 .opcode = BTP_BAP_SET_BROADCAST_CODE,
477 .expect_len = sizeof(struct btp_bap_set_broadcast_code_cmd),
478 .func = btp_bap_broadcast_assistant_set_broadcast_code,
479 },
480 {
481 .opcode = BTP_BAP_SEND_PAST,
482 .expect_len = sizeof(struct btp_bap_send_past_cmd),
483 .func = btp_bap_broadcast_assistant_send_past,
484 },
485 #endif /* CONFIG_BT_BAP_BROADCAST_SOURCE || CONFIG_BT_BAP_BROADCAST_SINK */
486 };
487
tester_init_pacs(void)488 uint8_t tester_init_pacs(void)
489 {
490 const struct bt_pacs_register_param pacs_param = {
491 #if defined(CONFIG_BT_PAC_SNK)
492 .snk_pac = true,
493 #endif /* CONFIG_BT_PAC_SNK */
494 #if defined(CONFIG_BT_PAC_SNK_LOC)
495 .snk_loc = true,
496 #endif /* CONFIG_BT_PAC_SNK_LOC */
497 #if defined(CONFIG_BT_PAC_SRC)
498 .src_pac = true,
499 #endif /* CONFIG_BT_PAC_SRC */
500 #if defined(CONFIG_BT_PAC_SRC_LOC)
501 .src_loc = true,
502 #endif /* CONFIG_BT_PAC_SRC_LOC */
503 };
504 int err;
505
506 /* PACS shall be registered before ASCS in btp_bap_unicast_init */
507 err = bt_pacs_register(&pacs_param);
508 if (err != 0) {
509 LOG_DBG("Failed to register client callbacks: %d", err);
510 return BTP_STATUS_FAILED;
511 }
512
513 btp_bap_unicast_init();
514
515 bt_pacs_cap_register(BT_AUDIO_DIR_SINK, &cap_sink);
516 bt_pacs_cap_register(BT_AUDIO_DIR_SOURCE, &cap_source);
517 bt_pacs_cap_register(BT_AUDIO_DIR_SINK, &vendor_cap_sink);
518 bt_pacs_cap_register(BT_AUDIO_DIR_SOURCE, &vendor_cap_source);
519
520 err = set_location();
521 if (err != 0) {
522 return BTP_STATUS_FAILED;
523 }
524
525 err = set_supported_contexts();
526 if (err != 0) {
527 return BTP_STATUS_FAILED;
528 }
529
530 err = set_available_contexts();
531 if (err != 0) {
532 return BTP_STATUS_FAILED;
533 }
534
535 tester_register_command_handlers(BTP_SERVICE_ID_PACS, pacs_handlers,
536 ARRAY_SIZE(pacs_handlers));
537
538 return BTP_STATUS_SUCCESS;
539 }
540
tester_unregister_pacs(void)541 uint8_t tester_unregister_pacs(void)
542 {
543 return BTP_STATUS_SUCCESS;
544 }
545
tester_init_ascs(void)546 uint8_t tester_init_ascs(void)
547 {
548 int err;
549
550 err = btp_bap_unicast_init();
551 if (err != 0) {
552 return BTP_STATUS_FAILED;
553 }
554
555 tester_register_command_handlers(BTP_SERVICE_ID_ASCS, ascs_handlers,
556 ARRAY_SIZE(ascs_handlers));
557
558 return BTP_STATUS_SUCCESS;
559 }
560
tester_unregister_ascs(void)561 uint8_t tester_unregister_ascs(void)
562 {
563 return BTP_STATUS_SUCCESS;
564 }
565
tester_init_bap(void)566 uint8_t tester_init_bap(void)
567 {
568 int err;
569
570 err = btp_bap_unicast_init();
571 if (err != 0) {
572 return BTP_STATUS_FAILED;
573 }
574
575 err = btp_bap_broadcast_init();
576 if (err != 0) {
577 return BTP_STATUS_FAILED;
578 }
579
580 btp_bap_audio_stream_tx_init();
581
582 tester_register_command_handlers(BTP_SERVICE_ID_BAP, bap_handlers,
583 ARRAY_SIZE(bap_handlers));
584
585 return BTP_STATUS_SUCCESS;
586 }
587
tester_unregister_bap(void)588 uint8_t tester_unregister_bap(void)
589 {
590 return BTP_STATUS_SUCCESS;
591 }
592
