Bluetooth: CAP: Implement broadcast to unicast handover

Implement the broadcast to unicast handover procedure,
as per the Bluetooth CAP specificiation.

Signed-off-by: Emil Gydesen <[email protected]>

Author: Thalley

include/zephyr/bluetooth/audio/cap.h

@@ -903,6 +903,20 @@ struct bt_cap_handover_cb {
 	void (*unicast_to_broadcast_complete)(int err, struct bt_conn *conn,
 					      struct bt_cap_unicast_group *unicast_group,
 					      struct bt_cap_broadcast_source *broadcast_source);
+
+	/**
+	 * @brief The broadcast to unicast handover procedure has finished
+	 *
+	 * @param err 0 if success else a negative errno value.
+	 * @param conn Pointer to the connection where the error occurred or NULL if local failure.
+	 * @param broadcast_source NULL if the broadcast sourced was deleted during the procedure,
+	 *                         else pointer to the broadcast sourced provided in the parameters.
+	 * @param unicast_group Pointer to newly created unicast group, or NULL in case of an
+	 *                      error happening before it was created.
+	 */
+	void (*broadcast_to_unicast_complete)(int err, struct bt_conn *conn,
+					      struct bt_cap_broadcast_source *broadcast_source,
+					      struct bt_cap_unicast_group *unicast_group);
 };
 
 /**
@@ -947,26 +961,45 @@ int bt_cap_handover_unicast_to_broadcast(
 /** Parameters for  bt_cap_handover_broadcast_to_unicast() */
 struct bt_cap_handover_broadcast_to_unicast_param {
 	/**
-	 * @brief The source broadcast source with the streams.
+	 * @brief Parameters for stopping broadcast audio reception on acceptors
 	 *
-	 * The broadcast source will be stopped and deleted.
+	 * This parameter is optional as stopping the broadcast audio should automatically stop
+	 * broadcast audio reception on the acceptors. Omitting this parameter will rely on the CAP
+	 * acceptors timing out on the BIG once it is stopped. The timeout on the CAP acceptors will
+	 * be between @ref BT_ISO_SYNC_TIMEOUT_MIN and @ref BT_ISO_SYNC_TIMEOUT_MAX.
 	 */
-	struct bt_cap_broadcast_source *broadcast_source;
+	struct bt_cap_commander_broadcast_reception_stop_param *reception_stop_param;
 
-	/** The type of the set. */
-	enum bt_cap_set_type type;
+	/** @brief Broadcast ID of the @p broadcast_source
+	 *
+	 * Ignored if @p reception_stop_param is not NULL.
+	 */
+	uint32_t broadcast_id;
 
-	/**
-	 * @brief The number of set members in @p members.
+	/** @brief Advertising set ID of the @p broadcast_source
 	 *
-	 * This value shall match the number of streams in the
-	 * @p broadcast_source.
+	 * Ignored if @p reception_stop_param is not NULL.
+	 */
+	uint8_t adv_sid;
+
+	/** @brief Advertising type of the advertising address of @p broadcast_source
 	 *
+	 * Ignored if @p reception_stop_param is not NULL.
 	 */
-	size_t count;
+	uint8_t adv_type;
+
+	/**
+	 * @brief The source broadcast source with the streams.
+	 *
+	 * The broadcast source will be stopped and deleted.
+	 */
+	struct bt_cap_broadcast_source *broadcast_source;
+
+	/* Parameters for the unicast group to be created */
+	struct bt_cap_unicast_group_param *unicast_group_param;
 
-	/** Coordinated or ad-hoc set members. */
-	union bt_cap_set_member **members;
+	/* Parameters for starting the unicast audio */
+	struct bt_cap_unicast_audio_start_param *unicast_start_param;
 };
 
 /**
@@ -978,13 +1011,11 @@ struct bt_cap_handover_broadcast_to_unicast_param {
  * @kconfig_dep{CONFIG_BT_CAP_HANDOVER}
  *
  * @param[in]  param          The parameters for the handover.
- * @param[out] unicast_group  The resulting broadcast source.
  *
  * @return 0 on success or negative error value on failure.
  */
 int bt_cap_handover_broadcast_to_unicast(
-	const struct bt_cap_handover_broadcast_to_unicast_param *param,
-	struct bt_bap_unicast_group **unicast_group);
+	const struct bt_cap_handover_broadcast_to_unicast_param *param);
 
 /** Callback structure for CAP procedures */
 struct bt_cap_commander_cb {

subsys/bluetooth/audio/bap_unicast_client.c

@@ -2039,7 +2039,6 @@ int bt_bap_unicast_client_ep_qos(struct bt_bap_ep *ep, struct net_buf_simple *bu
 
 	req = net_buf_simple_add(buf, sizeof(*req));
 	req->ase = ep->id;
-	/* TODO: don't hardcode CIG and CIS, they should come from ISO */
 	req->cig = conn_iso->info.unicast.cig_id;
 	req->cis = conn_iso->info.unicast.cis_id;
 	sys_put_le24(qos->interval, req->interval);

subsys/bluetooth/audio/cap_commander.c

@@ -101,9 +101,6 @@ int bt_cap_commander_discover(struct bt_conn *conn)
 }
 
 #if defined(CONFIG_BT_BAP_BROADCAST_ASSISTANT)
-static struct bt_bap_broadcast_assistant_cb broadcast_assistant_cb;
-static bool broadcast_assistant_cb_registered;
-
 static void
 copy_broadcast_reception_start_param(struct bt_bap_broadcast_assistant_add_src_param *add_src_param,
 				     struct cap_broadcast_reception_start *start_param)
@@ -172,22 +169,6 @@ static void cap_commander_broadcast_assistant_add_src_cb(struct bt_conn *conn, i
 	}
 }
 
-static int cap_commander_register_broadcast_assistant_cb(void)
-{
-	int err;
-
-	err = bt_bap_broadcast_assistant_register_cb(&broadcast_assistant_cb);
-	if (err != 0) {
-		LOG_DBG("Failed to register broadcast assistant callbacks: %d", err);
-
-		return -ENOEXEC;
-	}
-
-	broadcast_assistant_cb_registered = true;
-
-	return 0;
-}
-
 static bool valid_broadcast_reception_start_param(
 	const struct bt_cap_commander_broadcast_reception_start_param *param)
 {
@@ -335,11 +316,7 @@ int cap_commander_broadcast_reception_start(
 	struct bt_conn *conn;
 	int err;
 
-	broadcast_assistant_cb.add_src = cap_commander_broadcast_assistant_add_src_cb;
-	if (!broadcast_assistant_cb_registered) {
-		err = cap_commander_register_broadcast_assistant_cb();
-		__ASSERT(err == 0, "Failed to register broadcast assistant callbacks: %d", err);
-	}
+	cap_commander_register_broadcast_assistant_callbacks();
 
 	bt_cap_common_set_proc(BT_CAP_COMMON_PROC_TYPE_BROADCAST_RECEPTION_START, param->count);
 
@@ -356,8 +333,6 @@ int cap_commander_broadcast_reception_start(
 		if (member_conn == NULL) {
 			LOG_DBG("Invalid param->members[%zu]", i);
 
-			bt_cap_common_clear_active_proc();
-
 			return -EINVAL;
 		}
 
@@ -389,8 +364,6 @@ int cap_commander_broadcast_reception_start(
 	if (err != 0) {
 		LOG_DBG("Failed to start broadcast reception for conn %p: %d", (void *)conn, err);
 
-		bt_cap_common_clear_active_proc();
-
 		return -ENOEXEC;
 	}
 
@@ -400,6 +373,8 @@ int cap_commander_broadcast_reception_start(
 int bt_cap_commander_broadcast_reception_start(
 	const struct bt_cap_commander_broadcast_reception_start_param *param)
 {
+	int err;
+
 	if (!valid_broadcast_reception_start_param(param)) {
 		return -EINVAL;
 	}
@@ -410,7 +385,12 @@ int bt_cap_commander_broadcast_reception_start(
 		return -EBUSY;
 	}
 
-	return cap_commander_broadcast_reception_start(param);
+	err = cap_commander_broadcast_reception_start(param);
+	if (err != 0) {
+		bt_cap_common_clear_active_proc();
+	}
+
+	return err;
 }
 
 static void
@@ -436,6 +416,10 @@ static void cap_commander_broadcast_assistant_recv_state_cb(
 		return;
 	}
 
+	if (IS_ENABLED(CONFIG_BT_CAP_HANDOVER) && bt_cap_common_handover_is_active()) {
+		bt_cap_handover_receive_state_updated(conn, state);
+	}
+
 	if (bt_cap_common_conn_in_active_proc(conn) &&
 	    active_proc->proc_type == BT_CAP_COMMON_PROC_TYPE_BROADCAST_RECEPTION_STOP) {
 
@@ -539,7 +523,7 @@ static void cap_commander_broadcast_assistant_mod_src_cb(struct bt_conn *conn, i
 	}
 }
 
-static bool valid_broadcast_reception_stop_param(
+bool bt_cap_commander_valid_broadcast_reception_stop_param(
 	const struct bt_cap_commander_broadcast_reception_stop_param *param)
 {
 	CHECKIF(param == NULL) {
@@ -607,7 +591,7 @@ static bool valid_broadcast_reception_stop_param(
 	return true;
 }
 
-int bt_cap_commander_broadcast_reception_stop(
+int cap_commander_broadcast_reception_stop(
 	const struct bt_cap_commander_broadcast_reception_stop_param *param)
 {
 	struct bt_bap_broadcast_assistant_mod_src_param mod_src_param = {0};
@@ -616,23 +600,7 @@ int bt_cap_commander_broadcast_reception_stop(
 	struct bt_conn *conn;
 	int err;
 
-	if (!valid_broadcast_reception_stop_param(param)) {
-		return -EINVAL;
-	}
-
-	if (bt_cap_common_test_and_set_proc_active()) {
-		LOG_DBG("A CAP procedure is already in progress");
-
-		return -EBUSY;
-	}
-
-	broadcast_assistant_cb.mod_src = cap_commander_broadcast_assistant_mod_src_cb;
-	broadcast_assistant_cb.rem_src = cap_commander_broadcast_assistant_rem_src_cb;
-	broadcast_assistant_cb.recv_state = cap_commander_broadcast_assistant_recv_state_cb;
-	if (!broadcast_assistant_cb_registered) {
-		err = cap_commander_register_broadcast_assistant_cb();
-		__ASSERT(err == 0, "Failed to register broadcast assistant callbacks: %d", err);
-	}
+	cap_commander_register_broadcast_assistant_callbacks();
 
 	bt_cap_common_set_proc(BT_CAP_COMMON_PROC_TYPE_BROADCAST_RECEPTION_STOP, param->count);
 
@@ -649,8 +617,6 @@ int bt_cap_commander_broadcast_reception_stop(
 		if (member_conn == NULL) {
 			LOG_DBG("Invalid param->member[%zu]", i);
 
-			bt_cap_common_clear_active_proc();
-
 			return -EINVAL;
 		}
 
@@ -678,14 +644,35 @@ int bt_cap_commander_broadcast_reception_stop(
 	if (err != 0) {
 		LOG_DBG("Failed to stop broadcast reception for conn %p: %d", (void *)conn, err);
 
-		bt_cap_common_clear_active_proc();
-
 		return -ENOEXEC;
 	}
 
 	return 0;
 }
 
+int bt_cap_commander_broadcast_reception_stop(
+	const struct bt_cap_commander_broadcast_reception_stop_param *param)
+{
+	int err;
+
+	if (!bt_cap_commander_valid_broadcast_reception_stop_param(param)) {
+		return -EINVAL;
+	}
+
+	if (bt_cap_common_test_and_set_proc_active()) {
+		LOG_DBG("A CAP procedure is already in progress");
+
+		return -EBUSY;
+	}
+
+	err = cap_commander_broadcast_reception_stop(param);
+	if (err != 0) {
+		bt_cap_common_clear_active_proc();
+	}
+
+	return err;
+}
+
 static void cap_commander_broadcast_assistant_set_broadcast_code_cb(struct bt_conn *conn, int err)
 {
 	struct bt_cap_common_proc *active_proc = bt_cap_common_get_active_proc();
@@ -811,12 +798,7 @@ int bt_cap_commander_distribute_broadcast_code(
 		return -EBUSY;
 	}
 
-	broadcast_assistant_cb.broadcast_code =
-		cap_commander_broadcast_assistant_set_broadcast_code_cb;
-	if (!broadcast_assistant_cb_registered) {
-		err = cap_commander_register_broadcast_assistant_cb();
-		__ASSERT(err == 0, "Failed to register broadcast assistant callbacks: %d", err);
-	}
+	cap_commander_register_broadcast_assistant_callbacks();
 
 	bt_cap_common_set_proc(BT_CAP_COMMON_PROC_TYPE_DISTRIBUTE_BROADCAST_CODE, param->count);
 
@@ -870,6 +852,26 @@ int bt_cap_commander_distribute_broadcast_code(
 	return 0;
 }
 
+void cap_commander_register_broadcast_assistant_callbacks(void)
+{
+	static bool broadcast_assistant_cb_registered;
+
+	if (!broadcast_assistant_cb_registered) {
+		static struct bt_bap_broadcast_assistant_cb broadcast_assistant_cb = {
+			.add_src = cap_commander_broadcast_assistant_add_src_cb,
+			.mod_src = cap_commander_broadcast_assistant_mod_src_cb,
+			.rem_src = cap_commander_broadcast_assistant_rem_src_cb,
+			.recv_state = cap_commander_broadcast_assistant_recv_state_cb,
+			.broadcast_code = cap_commander_broadcast_assistant_set_broadcast_code_cb,
+		};
+		int err;
+
+		err = bt_bap_broadcast_assistant_register_cb(&broadcast_assistant_cb);
+		__ASSERT(err == 0, "Failed to register broadcast assistant callbacks: %d", err);
+
+		broadcast_assistant_cb_registered = true;
+	}
+}
 #endif /* CONFIG_BT_BAP_BROADCAST_ASSISTANT */
 
 static void cap_commander_proc_complete(void)
@@ -884,13 +886,30 @@ static void cap_commander_proc_complete(void)
 	proc_type = active_proc->proc_type;
 
 	if (IS_ENABLED(CONFIG_BT_CAP_HANDOVER) && bt_cap_common_handover_is_active()) {
-		/* Complete handover procedure. At this point we do not know if the remote
-		 * device will attempt to use PAST or scan for itself, so it's best to leave
-		 * this up to the application layer
-		 */
-		__ASSERT_NO_MSG(proc_type == BT_CAP_COMMON_PROC_TYPE_BROADCAST_RECEPTION_START);
+		if (proc_type == BT_CAP_COMMON_PROC_TYPE_BROADCAST_RECEPTION_START) {
+			/* Complete unicast to broadcast handover procedure. At this point we do not
+			 * know if the remote device will attempt to use PAST or scan for itself, so
+			 * it's best to leave this up to the application layer
+			 */
+
+			bt_cap_handover_complete();
+		} else if (proc_type == BT_CAP_COMMON_PROC_TYPE_BROADCAST_RECEPTION_STOP) {
+			if (err != 0) {
+				bt_cap_handover_complete();
+			} else {
+				/* We've successfully stopped broadcast reception on all the
+				 * acceptors. We can now stop and delete the broadcast source before
+				 * starting the unicast audio
+				 */
+				err = bt_cap_handover_broadcast_reception_stopped();
+				if (err != 0) {
+					bt_cap_handover_complete();
+				}
+			}
+		} else {
+			__ASSERT(false, "invalid proc_type %d", proc_type);
+		}
 
-		bt_cap_handover_proc_complete();
 		return;
 	}