Bluetooth: Controller: Implemented buffering of SDU fragments in ISO-AL

Implements:
-- SDU fragments can be buffered in the ISO-AL so that the correct size
   of the SDU can be computed such that it can be released for inclusion
   in the first fragment's header
-- Changed SDU emit interface to allow the same structure to be used to
   buffer as well as release fragments
-- New configuration BT_CTLR_ISO_RX_SDU_BUFFERS to specify the number of
   SDU buffers for each sink
   (Buffering disabled when BT_CTLR_ISO_RX_SDU_BUFFERS=0)

Signed-off-by: Nirosharn Amarasinghe <[email protected]>

Author: niag-Oticon

subsys/bluetooth/controller/Kconfig

@@ -242,6 +242,19 @@ config BT_CTLR_ISOAL_SINKS
 	  Set the number of concurrently active sinks supported by the
 	  ISO AL.
 
+config BT_CTLR_ISO_RX_SDU_BUFFERS
+	int "Number of SDU fragments that the ISO-AL can buffer"
+	depends on BT_CTLR_SYNC_ISO || BT_CTLR_CONN_ISO
+	default 0
+	range 0 64
+	help
+	  Set the number of Isochronous Rx SDU fragments to be buffered in the
+	  ISO-AL per sink. Buffering is required to compute the size and status
+	  of the received SDU across all the fragments before each is released.
+	  The number of buffers and maximum SDU fragment size will limit the
+	  maximum size of an SDU that can be accurately declared in the HCI ISO
+	  Data header.
+
 config BT_CTLR_ISO_VENDOR_DATA_PATH
 	bool "Vendor-specific ISO data path"
 	depends on BT_CTLR_SYNC_ISO || BT_CTLR_CONN_ISO

subsys/bluetooth/controller/hci/hci_driver.c

@@ -105,35 +105,38 @@ isoal_status_t sink_sdu_alloc_hci(const struct isoal_sink    *sink_ctx,
 }
 
 
-isoal_status_t sink_sdu_emit_hci(const struct isoal_sink         *sink_ctx,
-				 const struct isoal_sdu_produced *valid_sdu)
+isoal_status_t sink_sdu_emit_hci(const struct isoal_sink             *sink_ctx,
+				 const struct isoal_emitted_sdu_frag *sdu_frag,
+				 const struct isoal_emitted_sdu      *sdu)
 {
 	struct bt_hci_iso_ts_data_hdr *data_hdr;
 	uint16_t packet_status_flag;
 	struct bt_hci_iso_hdr *hdr;
 	uint16_t handle_packed;
 	uint16_t slen_packed;
 	struct net_buf *buf;
+	uint16_t total_len;
 	uint16_t handle;
 	uint8_t  ts, pb;
 	uint16_t len;
 
-	buf = (struct net_buf *) valid_sdu->contents.dbuf;
+	buf = (struct net_buf *) sdu_frag->sdu.contents.dbuf;
 
 
 	if (buf) {
 #if defined(CONFIG_BT_CTLR_CONN_ISO_HCI_DATAPATH_SKIP_INVALID_DATA)
-		if (valid_sdu->status != ISOAL_SDU_STATUS_VALID) {
+		if (sdu_frag->sdu.status != ISOAL_SDU_STATUS_VALID) {
 			/* unref buffer if invalid fragment */
 			net_buf_unref(buf);
 
 			return ISOAL_STATUS_OK;
 		}
 #endif /* CONFIG_BT_CTLR_CONN_ISO_HCI_DATAPATH_SKIP_INVALID_DATA */
 
-		pb  = sink_ctx->sdu_production.sdu_state;
-		len = sink_ctx->sdu_production.sdu_written;
-		packet_status_flag = valid_sdu->status;
+		pb  = sdu_frag->sdu_state;
+		len = sdu_frag->sdu_frag_size;
+		total_len = sdu->total_sdu_size;
+		packet_status_flag = sdu->collated_status;
 
 		/* BT Core V5.3 : Vol 4 HCI I/F : Part G HCI Func. Spec.:
 		 * 5.4.5 HCI ISO Data packets
@@ -147,6 +150,7 @@ isoal_status_t sink_sdu_emit_hci(const struct isoal_sink         *sink_ctx,
 				net_buf_pull_mem(buf, len);
 			}
 			len = 0;
+			total_len = 0;
 		}
 
 		/*
@@ -169,10 +173,10 @@ isoal_status_t sink_sdu_emit_hci(const struct isoal_sink         *sink_ctx,
 
 		if (ts) {
 			data_hdr = net_buf_push(buf, BT_HCI_ISO_TS_DATA_HDR_SIZE);
-			slen_packed = bt_iso_pkt_len_pack(len, packet_status_flag);
+			slen_packed = bt_iso_pkt_len_pack(total_len, packet_status_flag);
 
-			data_hdr->ts = sys_cpu_to_le32((uint32_t) valid_sdu->timestamp);
-			data_hdr->data.sn   = sys_cpu_to_le16((uint16_t) valid_sdu->seqn);
+			data_hdr->ts = sys_cpu_to_le32((uint32_t) sdu_frag->sdu.timestamp);
+			data_hdr->data.sn   = sys_cpu_to_le16((uint16_t) sdu_frag->sdu.seqn);
 			data_hdr->data.slen = sys_cpu_to_le16(slen_packed);
 
 			len += BT_HCI_ISO_TS_DATA_HDR_SIZE;

subsys/bluetooth/controller/ll_sw/isoal.c

@@ -328,6 +328,127 @@ static isoal_status_t isoal_rx_allocate_sdu(struct isoal_sink *sink,
 	return err;
 }
 
+/**
+ * @brief  Depending of whether the configuration is enabled, this will either
+ *         buffer and collate information for the SDU across all fragments
+ *         before emitting the batch of fragments, or immediately release the
+ *         fragment.
+ * @param  sink       Point to the sink context structure
+ * @param  end_of_sdu Indicates if this is the end fragment of an SDU or forced
+ *                    release on an error
+ * @return            Status of operation
+ */
+static isoal_status_t isoal_rx_buffered_emit_sdu(struct isoal_sink *sink, bool end_of_sdu)
+{
+	struct isoal_emitted_sdu_frag sdu_frag;
+	struct isoal_emitted_sdu sdu_status;
+	struct isoal_sink_session *session;
+	struct isoal_sdu_production *sp;
+	struct isoal_sdu_produced *sdu;
+	bool emit_sdu_current;
+	isoal_status_t err;
+
+	err = ISOAL_STATUS_OK;
+	session = &sink->session;
+	sp = &sink->sdu_production;
+	sdu = &sp->sdu;
+
+	/* Initialize current SDU fragment buffer */
+	sdu_frag.sdu_state = sp->sdu_state;
+	sdu_frag.sdu_frag_size = sp->sdu_written;
+	sdu_frag.sdu = *sdu;
+
+	sdu_status.total_sdu_size = sdu_frag.sdu_frag_size;
+	sdu_status.collated_status = sdu_frag.sdu.status;
+	emit_sdu_current = true;
+
+#if defined(ISOAL_BUFFER_RX_SDUS_ENABLE)
+	uint16_t next_write_indx;
+	bool sdu_list_empty;
+	bool emit_sdu_list;
+	bool sdu_list_max;
+	bool sdu_list_err;
+
+	next_write_indx = sp->sdu_list.next_write_indx;
+	sdu_list_max = (next_write_indx >= CONFIG_BT_CTLR_ISO_RX_SDU_BUFFERS);
+	sdu_list_empty = (next_write_indx == 0);
+
+	/* There is an error in the sequence of SDUs if the current SDU fragment
+	 * is not an end fragment and either the list at capacity or the current
+	 * fragment is not a continuation (i.e. it is a start of a new SDU).
+	 */
+	sdu_list_err = !end_of_sdu &&
+		(sdu_list_max ||
+		(!sdu_list_empty && sdu_frag.sdu_state != BT_ISO_CONT));
+
+	/* Release the current fragment if it is the end of the SDU or if it is
+	 * not the starting fragment of a multi-fragment SDU.
+	 */
+	emit_sdu_current = end_of_sdu || (sdu_list_empty && sdu_frag.sdu_state != BT_ISO_START);
+
+	/* Flush the buffered SDUs if this is an end fragment either on account
+	 * of reaching the end of the SDU or on account of an error or if
+	 * there is an error in the sequence of buffered fragments.
+	 */
+	emit_sdu_list = emit_sdu_current || sdu_list_err;
+
+	/* Total size is cleared if the current fragment is not being emitted
+	 * or if there is an error in the sequence of fragments.
+	 */
+	if (!emit_sdu_current || sdu_list_err) {
+		sdu_status.total_sdu_size = 0;
+		sdu_status.collated_status = (sdu_list_err ? ISOAL_SDU_STATUS_LOST_DATA :
+						ISOAL_SDU_STATUS_VALID);
+	}
+
+	if (emit_sdu_list && next_write_indx > 0) {
+		if (!sdu_list_err) {
+			/* Collated information is not reliable if there is an
+			 * error in the sequence of the fragments.
+			 */
+			for (uint8_t i = 0; i < next_write_indx; i++) {
+				sdu_status.total_sdu_size +=
+					sp->sdu_list.list[i].sdu_frag_size;
+				if (sp->sdu_list.list[i].sdu.status == ISOAL_SDU_STATUS_LOST_DATA ||
+					sdu_status.collated_status == ISOAL_SDU_STATUS_LOST_DATA) {
+					sdu_status.collated_status = ISOAL_SDU_STATUS_LOST_DATA;
+				} else {
+					sdu_status.collated_status |=
+						sp->sdu_list.list[i].sdu.status;
+				}
+			}
+		}
+
+		for (uint8_t i = 0; i < next_write_indx; i++) {
+			err |= session->sdu_emit(sink, &sp->sdu_list.list[i],
+						&sdu_status);
+		}
+
+		next_write_indx = sp->sdu_list.next_write_indx  = 0;
+	}
+#endif /* ISOAL_BUFFER_RX_SDUS_ENABLE */
+
+	if (emit_sdu_current) {
+		if (sdu_frag.sdu_state == BT_ISO_SINGLE) {
+			sdu_status.total_sdu_size = sdu_frag.sdu_frag_size;
+			sdu_status.collated_status = sdu_frag.sdu.status;
+		}
+
+		err |= session->sdu_emit(sink, &sdu_frag, &sdu_status);
+
+#if defined(ISOAL_BUFFER_RX_SDUS_ENABLE)
+	} else if (next_write_indx < CONFIG_BT_CTLR_ISO_RX_SDU_BUFFERS) {
+		sp->sdu_list.list[next_write_indx++] = sdu_frag;
+		sp->sdu_list.next_write_indx = next_write_indx;
+#endif /* ISOAL_BUFFER_RX_SDUS_ENABLE */
+	} else {
+		/* Unreachable */
+		LL_ASSERT(0);
+	}
+
+	return err;
+}
+
 static isoal_status_t isoal_rx_try_emit_sdu(struct isoal_sink *sink, bool end_of_sdu)
 {
 	struct isoal_sdu_production *sp;
@@ -369,9 +490,8 @@ static isoal_status_t isoal_rx_try_emit_sdu(struct isoal_sink *sink, bool end_of
 			break;
 		}
 		sdu->status = sp->sdu_status;
-		struct isoal_sink_session *session = &sink->session;
 
-		err = session->sdu_emit(sink, sdu);
+		err = isoal_rx_buffered_emit_sdu(sink, end_of_sdu);
 		sp->sdu_allocated = false;
 
 		/* update next state */

subsys/bluetooth/controller/ll_sw/isoal.h

@@ -8,6 +8,11 @@
 #include <zephyr/types.h>
 #include <zephyr/toolchain.h>
 
+#if defined(CONFIG_BT_CTLR_ISO_RX_SDU_BUFFERS) && (CONFIG_BT_CTLR_ISO_RX_SDU_BUFFERS > 0)
+#define ISOAL_BUFFER_RX_SDUS_ENABLE
+#endif /* CONFIG_BT_CTLR_ISO_RX_SDU_BUFFERS > 0 */
+
+
 /** Function return error codes */
 typedef uint8_t isoal_status_t;
 #define ISOAL_STATUS_OK                   ((isoal_status_t) 0x00) /* No error */
@@ -120,6 +125,35 @@ struct isoal_sdu_produced {
 	void                    *ctx;
 };
 
+/** @brief Produced ISO SDU fragment and status information to be emitted */
+struct isoal_emitted_sdu_frag {
+	/** Produced SDU to be emitted */
+	struct isoal_sdu_produced sdu;
+	/** SDU fragment Packet Boundary flags */
+	uint8_t                   sdu_state;
+	/** Size of the SDU fragment */
+	isoal_sdu_len_t           sdu_frag_size;
+};
+
+/** @brief Produced ISO SDU and required status information to be emitted */
+struct isoal_emitted_sdu {
+	/** Size of the SDU across all fragments */
+	isoal_sdu_len_t           total_sdu_size;
+	/** Status of contents, if valid or SDU was lost.
+	 * This maps directly to the HCI ISO Data packet Packet_Status_Flag.
+	 * BT Core V5.3 : Vol 4 HCI I/F : Part G HCI Func. Spec.:
+	 * 5.4.5 HCI ISO Data packets : Table 5.2 :
+	 * Packet_Status_Flag (in packets sent by the Controller)
+	 */
+	isoal_sdu_status_t        collated_status;
+};
+
+#if defined(ISOAL_BUFFER_RX_SDUS_ENABLE)
+struct isoal_emit_sdu_queue {
+	struct isoal_emitted_sdu_frag list[CONFIG_BT_CTLR_ISO_RX_SDU_BUFFERS];
+	uint16_t next_write_indx;
+};
+#endif /* ISOAL_BUFFER_RX_SDUS_ENABLE */
 
 /** @brief Produced ISO PDU encapsulation */
 struct isoal_pdu_produced {
@@ -194,9 +228,11 @@ typedef isoal_status_t (*isoal_sink_sdu_alloc_cb)(
  */
 typedef isoal_status_t (*isoal_sink_sdu_emit_cb)(
 	/*!< [in]  Sink context */
-	const struct isoal_sink         *sink_ctx,
-	/*!< [in]  Filled valid SDU to be pushed */
-	const struct isoal_sdu_produced *valid_sdu
+	const struct isoal_sink             *sink_ctx,
+	/*!< [in]  Emitted SDU fragment and status information */
+	const struct isoal_emitted_sdu_frag *sdu_frag,
+	/*!< [in]  Emitted SDU status information */
+	const struct isoal_emitted_sdu      *sdu
 );
 
 /**
@@ -232,6 +268,10 @@ struct isoal_sink_session {
 };
 
 struct isoal_sdu_production {
+#if defined(ISOAL_BUFFER_RX_SDUS_ENABLE)
+	/* Buffered SDUs */
+	struct isoal_emit_sdu_queue sdu_list;
+#endif
 	/* Permit atomic enable/disable of SDU production */
 	volatile isoal_production_mode_t  mode;
 	/* We are constructing an SDU from {<1 or =1 or >1} PDUs */
@@ -406,8 +446,9 @@ isoal_status_t isoal_rx_pdu_recombine(isoal_sink_handle_t sink_hdl,
 isoal_status_t sink_sdu_alloc_hci(const struct isoal_sink    *sink_ctx,
 				  const struct isoal_pdu_rx  *valid_pdu,
 				  struct isoal_sdu_buffer    *sdu_buffer);
-isoal_status_t sink_sdu_emit_hci(const struct isoal_sink         *sink_ctx,
-				 const struct isoal_sdu_produced *valid_sdu);
+isoal_status_t sink_sdu_emit_hci(const struct isoal_sink             *sink_ctx,
+				 const struct isoal_emitted_sdu_frag *sdu_frag,
+				 const struct isoal_emitted_sdu      *sdu);
 isoal_status_t sink_sdu_write_hci(void *dbuf,
 				  const uint8_t *pdu_payload,
 				  const size_t consume_len);

subsys/bluetooth/controller/ll_sw/ull_iso.c

@@ -652,15 +652,16 @@ static isoal_status_t ll_iso_test_sdu_alloc(const struct isoal_sink *sink_ctx,
  * further in the data path. This injected implementation performs statistics on
  * the SDU and then discards it.
  */
-static isoal_status_t ll_iso_test_sdu_emit(const struct isoal_sink *sink_ctx,
-					   const struct isoal_sdu_produced *valid_sdu)
+static isoal_status_t ll_iso_test_sdu_emit(const struct isoal_sink             *sink_ctx,
+					   const struct isoal_emitted_sdu_frag *sdu_frag,
+					   const struct isoal_emitted_sdu      *sdu)
 {
 	isoal_status_t status;
 	struct net_buf *buf;
 	uint16_t handle;
 
 	handle = sink_ctx->session.handle;
-	buf = (struct net_buf *)valid_sdu->contents.dbuf;
+	buf = (struct net_buf *)sdu_frag->sdu.contents.dbuf;
 
 	if (IS_CIS_HANDLE(handle)) {
 		struct ll_conn_iso_stream *cis;
@@ -685,7 +686,7 @@ static isoal_status_t ll_iso_test_sdu_emit(const struct isoal_sink *sink_ctx,
 			sdu_counter = 0U;
 		}
 
-		switch (valid_sdu->status) {
+		switch (sdu_frag->sdu.status) {
 		case ISOAL_SDU_STATUS_VALID:
 			if (framed && cis->hdr.test_mode.rx_sdu_counter == 0U) {
 				/* BT 5.3, Vol 6, Part B, section 7.2: