Bluetooth: tester: Support feature ISO broadcaster

Add command `BTP_GAP_CREATE_BIG` to create BIG.

Add command `BTP_GAP_BIS_BROADCAST` to send broadcast data.

Signed-off-by: Lyle Zhu <lyle.zhu@nxp.com>

Author: lylezhu2012

tests/bluetooth/tester/src/btp/btp_gap.h

@@ -363,6 +363,30 @@ struct btp_gap_big_create_sync_cmd {
 	uint8_t broadcast_code[0];
 } __packed;
 
+#define BTP_GAP_CREATE_BIG_ENC_DISABLE		0x00
+#define BTP_GAP_CREATE_BIG_ENC_ENABLE		0x01
+
+#define BTP_GAP_CREATE_BIG			0x2d
+struct btp_gap_create_big_cmd {
+	uint8_t id;
+	uint8_t num_bis;
+	uint32_t interval;
+	uint16_t latency;
+	uint8_t rtn;
+	uint8_t phy;
+	uint8_t packing;
+	uint8_t framing;
+	uint8_t encryption;
+	uint8_t broadcast_code[0];
+} __packed;
+
+#define BTP_GAP_BIS_BROADCAST			0x2e
+struct btp_gap_bis_broadcast_cmd {
+	uint8_t bis_id;
+	uint8_t data_len;
+	uint8_t data[];
+} __packed;
+
 #define BTP_GAP_SET_RPA_TIMEOUT                 0x30
 struct btp_gap_set_rpa_timeout_cmd {
 	uint16_t rpa_timeout;

tests/bluetooth/tester/src/btp_gap.c

@@ -2365,6 +2365,10 @@ static uint8_t set_rpa_timeout(const void *cmd, uint16_t cmd_len, void *rsp, uin
 }
 #endif /* defined(CONFIG_BT_RPA_TIMEOUT_DYNAMIC) */
 
+#if defined(CONFIG_BT_ISO_SYNC_RECEIVER) || defined(CONFIG_BT_ISO_BROADCASTER)
+static int bt_iso_chan_get_index(struct bt_iso_chan *chan);
+#endif /* defined(CONFIG_BT_ISO_SYNC_RECEIVER) || defined(CONFIG_BT_ISO_BROADCASTER) */
+
 #if defined(CONFIG_BT_ISO_SYNC_RECEIVER)
 static struct bt_iso_big *iso_sync_receiver_big;
 
@@ -2442,8 +2446,6 @@ BUILD_ASSERT(BIS_STREAM_DATA_LEN < BTP_DATA_MAX_SIZE, "BIS stream data length ex
 
 static struct net_buf_simple *iso_sync_receiver_buf = NET_BUF_SIMPLE(BIS_STREAM_DATA_LEN);
 
-static int bt_iso_chan_get_index(struct bt_iso_chan *chan);
-
 static void iso_sync_receiver_recv(struct bt_iso_chan *chan, const struct bt_iso_recv_info *info,
 				   struct net_buf *buf)
 {
@@ -2525,7 +2527,57 @@ static struct bt_iso_chan_ops iso_sync_receiver_ops = {
 	.connected = iso_sync_receiver_connected,
 	.disconnected = iso_sync_receiver_disconnected,
 };
+#endif /* defined(CONFIG_BT_ISO_SYNC_RECEIVER) */
+
+#if defined(CONFIG_BT_ISO_BROADCASTER)
+static uint32_t bis_sn_last;
+static int64_t bis_sn_last_updated_ticks;
+static uint32_t bis_sdu_interval_us;
+
+static void iso_broadcaster_connected(struct bt_iso_chan *chan)
+{
+	int err;
+	const struct bt_iso_chan_path hci_path = {
+		.pid = BT_ISO_DATA_PATH_HCI,
+		.format = BT_HCI_CODING_FORMAT_TRANSPARENT,
+	};
+	struct btp_gap_bis_data_path_setup_ev ev;
+	struct bt_le_ext_adv *ext_adv = tester_gap_ext_adv_get(0);
 
+	err = bt_iso_chan_get_index(chan);
+	if (err < 0) {
+		LOG_ERR("Failed to get BIS channel index: %d", err);
+		return;
+	}
+	ev.bis_id = (uint8_t)err;
+
+	bis_sn_last = 0;
+	bis_sn_last_updated_ticks = k_uptime_ticks();
+
+	err = bt_iso_setup_data_path(chan, BT_HCI_DATAPATH_DIR_HOST_TO_CTLR, &hci_path);
+	if (err != 0) {
+		LOG_ERR("Failed to setup ISO TX data path: %d", err);
+		return;
+	}
+
+	bt_addr_le_copy(&ev.address, &ext_adv->random_addr);
+
+	tester_event(BTP_SERVICE_ID_GAP, BTP_GAP_EV_BIS_DATA_PATH_SETUP, &ev, sizeof(ev));
+}
+
+static void iso_broadcaster_disconnected(struct bt_iso_chan *chan, uint8_t reason)
+{
+	ARG_UNUSED(chan);
+	ARG_UNUSED(reason);
+}
+
+static struct bt_iso_chan_ops iso_broadcaster_ops = {
+	.connected = iso_broadcaster_connected,
+	.disconnected = iso_broadcaster_disconnected,
+};
+#endif /* defined(CONFIG_BT_ISO_BROADCASTER) */
+
+#if defined(CONFIG_BT_ISO_SYNC_RECEIVER) || defined(CONFIG_BT_ISO_BROADCASTER)
 static struct bt_iso_chan_qos bis_iso_qos;
 
 static struct bt_iso_chan bis_iso_chan = {
@@ -2534,8 +2586,6 @@ static struct bt_iso_chan bis_iso_chan = {
 
 #define DEFAULT_IO_QOS {.sdu = 40u, .phy = BT_GAP_LE_PHY_2M, .rtn = 2u,}
 
-static struct bt_iso_chan_io_qos iso_sync_receiver_qos = DEFAULT_IO_QOS;
-
 #define BIS_ISO_CHAN_COUNT 1
 
 static struct bt_iso_chan *bis_channels[BIS_ISO_CHAN_COUNT] = { &bis_iso_chan };
@@ -2549,6 +2599,10 @@ static int bt_iso_chan_get_index(struct bt_iso_chan *chan)
 	}
 	return -EINVAL;
 }
+#endif /* defined(CONFIG_BT_ISO_SYNC_RECEIVER) || defined(CONFIG_BT_ISO_BROADCASTER) */
+
+#if defined(CONFIG_BT_ISO_SYNC_RECEIVER)
+static struct bt_iso_chan_io_qos iso_sync_receiver_qos = DEFAULT_IO_QOS;
 
 static uint8_t big_create_sync(const void *cmd, uint16_t cmd_len, void *rsp, uint16_t *rsp_len)
 {
@@ -2606,6 +2660,137 @@ static uint8_t big_create_sync(const void *cmd, uint16_t cmd_len, void *rsp, uin
 }
 #endif /* defined(CONFIG_BT_ISO_SYNC_RECEIVER) */
 
+#if defined(CONFIG_BT_ISO_BROADCASTER)
+static struct bt_iso_chan_io_qos iso_broadcaster_qos = DEFAULT_IO_QOS;
+
+static struct bt_iso_big *iso_broadcaster_big;
+
+static uint8_t create_big(const void *cmd, uint16_t cmd_len, void *rsp, uint16_t *rsp_len)
+{
+	int err;
+	const struct btp_gap_create_big_cmd *cp = cmd;
+	struct bt_iso_big_create_param param = {0};
+	struct bt_le_ext_adv *ext_adv = tester_gap_ext_adv_get(0);
+
+	if ((cmd_len < sizeof(*cp)) ||
+	    (cmd_len != (sizeof(*cp) + sizeof(param.bcode) * cp->encryption))) {
+		LOG_ERR("Invalid cmd len");
+		return BTP_STATUS_FAILED;
+	}
+
+	if (!(cp->encryption == BTP_GAP_CREATE_BIG_ENC_DISABLE ||
+	      cp->encryption == BTP_GAP_CREATE_BIG_ENC_ENABLE)) {
+		LOG_ERR("Invalid encryption %u", cp->encryption);
+		return BTP_STATUS_FAILED;
+	}
+
+	if ((ext_adv == NULL) || (cp->id != ext_adv->id)) {
+		LOG_ERR("Invalid extended adv");
+		return BTP_STATUS_FAILED;
+	}
+
+	if (cp->num_bis > ARRAY_SIZE(bis_channels)) {
+		LOG_ERR("BIS num exceeds %u > %u", cp->num_bis, ARRAY_SIZE(bis_channels));
+		return BTP_STATUS_FAILED;
+	}
+
+	bis_iso_qos.rx = NULL;
+	bis_iso_qos.tx = &iso_broadcaster_qos;
+	bis_iso_qos.tx->phy = cp->phy;
+	bis_iso_qos.tx->rtn = cp->rtn;
+	bis_iso_qos.tx->sdu = CONFIG_BT_ISO_TX_MTU;
+
+	bis_iso_chan.ops = &iso_broadcaster_ops;
+
+	param.bis_channels = bis_channels;
+	param.num_bis = cp->num_bis;
+	param.interval = sys_le32_to_cpu(cp->interval);
+	param.packing = cp->packing;
+	param.framing = cp->framing;
+	param.latency = sys_le16_to_cpu(cp->latency);
+
+	param.encryption = cp->encryption == BTP_GAP_CREATE_BIG_ENC_ENABLE;
+	if (param.encryption) {
+		memcpy(param.bcode, cp->broadcast_code, sizeof(param.bcode));
+	}
+
+	bis_sdu_interval_us = param.interval;
+
+	err = bt_iso_big_create(ext_adv, &param, &iso_broadcaster_big);
+	if (err != 0) {
+		LOG_ERR("Unable to create BIG (err %d)", err);
+		return BTP_STATUS_FAILED;
+	}
+
+	LOG_DBG("BIG created");
+
+	return BTP_STATUS_SUCCESS;
+}
+
+NET_BUF_POOL_FIXED_DEFINE(bis_tx_pool, BIS_ISO_CHAN_COUNT,
+			  BT_ISO_SDU_BUF_SIZE(CONFIG_BT_ISO_TX_MTU),
+			  CONFIG_BT_CONN_TX_USER_DATA_SIZE, NULL);
+
+static uint32_t get_next_sn(uint32_t last_sn, int64_t *last_ticks,
+			    uint32_t interval_us)
+{
+	int64_t uptime_ticks, delta_ticks;
+	uint64_t delta_us;
+	uint64_t sn_incr;
+	uint64_t next_sn;
+
+	/* Note: This does not handle wrapping of ticks when they go above
+	 * 2^(62-1)
+	 */
+	uptime_ticks = k_uptime_ticks();
+	delta_ticks = uptime_ticks - *last_ticks;
+	*last_ticks = uptime_ticks;
+
+	delta_us = k_ticks_to_us_near64((uint64_t)delta_ticks);
+	sn_incr = delta_us / interval_us;
+	next_sn = (sn_incr + last_sn);
+
+	return (uint32_t)next_sn;
+}
+
+static uint8_t bis_broadcast(const void *cmd, uint16_t cmd_len, void *rsp, uint16_t *rsp_len)
+{
+	int err;
+	const struct btp_gap_bis_broadcast_cmd *cp = cmd;
+	struct net_buf *buf;
+
+	buf = net_buf_alloc(&bis_tx_pool, K_NO_WAIT);
+	if (buf == NULL) {
+		LOG_ERR("Failed to allocate buffer");
+		return BTP_STATUS_FAILED;
+	}
+
+	net_buf_reserve(buf, BT_ISO_CHAN_SEND_RESERVE);
+
+	if (cp->data_len > net_buf_tailroom(buf)) {
+		net_buf_unref(buf);
+		LOG_ERR("Data length exceeds buffer tailroom");
+		return BTP_STATUS_FAILED;
+	}
+
+	bis_sn_last = get_next_sn(bis_sn_last, &bis_sn_last_updated_ticks,
+				  bis_sdu_interval_us);
+
+	net_buf_add_mem(buf, cp->data, cp->data_len);
+
+	err = bt_iso_chan_send(&bis_iso_chan, buf, bis_sn_last);
+	if (err < 0) {
+		LOG_ERR("Unable to broadcast: %d", -err);
+		net_buf_unref(buf);
+		return BTP_STATUS_FAILED;
+	}
+
+	LOG_DBG("ISO broadcasting..., sn %u len %u", bis_sn_last, cp->data_len);
+
+	return BTP_STATUS_SUCCESS;
+}
+#endif /* defined(CONFIG_BT_ISO_BROADCASTER) */
+
 static const struct btp_handler handlers[] = {
 	{
 		.opcode = BTP_GAP_READ_SUPPORTED_COMMANDS,
@@ -2808,6 +2993,18 @@ static const struct btp_handler handlers[] = {
 		.func = big_create_sync,
 	},
 #endif /* defined(CONFIG_BT_ISO_SYNC_RECEIVER) */
+#if defined(CONFIG_BT_ISO_BROADCASTER)
+	{
+		.opcode = BTP_GAP_CREATE_BIG,
+		.expect_len = BTP_HANDLER_LENGTH_VARIABLE,
+		.func = create_big,
+	},
+	{
+		.opcode = BTP_GAP_BIS_BROADCAST,
+		.expect_len = BTP_HANDLER_LENGTH_VARIABLE,
+		.func = bis_broadcast,
+	},
+#endif /* defined(CONFIG_BT_ISO_BROADCASTER) */
 };
 
 uint8_t tester_init_gap(void)