Bluetooth: controller: Implemented PDU release timeout

Implemented:
-- Combining segments from multiple SDUs in a single PDU for TX
-- Release of PDU based on remaining capacity below threshold
-- Release of any PDUs in production on receiving a timeout for the
   upcoming event
-- Release of PDUs in production if source if destroyed
-- Synchronization flag to exclude multiple contexts in ISO-AL
-- New Kconfig BT_CTLR_ISO_TX_SEG_PLAYLOAD_MIN to allow definition of
   minimum TX segment size

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

Author: niag-Oticon

subsys/bluetooth/controller/Kconfig

@@ -255,6 +255,15 @@ config BT_CTLR_ISO_RX_SDU_BUFFERS
 	  maximum size of an SDU that can be accurately declared in the HCI ISO
 	  Data header.
 
+config BT_CTLR_ISO_TX_SEG_PLAYLOAD_MIN
+	int "Minimum number of playload data bytes in a new segment"
+	depends on BT_CTLR_ADV_ISO || BT_CTLR_CONN_ISO
+	default 1
+	range 1 64
+	help
+	  Minimum number of payload bytes that would make inserting a new
+	  segment into a PDU worthwhile.
+
 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/ll_sw/isoal.c

@@ -28,6 +28,17 @@
 #include "common/log.h"
 #include "hal/debug.h"
 
+#if defined(CONFIG_BT_CTLR_ADV_ISO) || defined(CONFIG_BT_CTLR_CONN_ISO)
+/* Given the minimum payload, this defines the minimum number of bytes that
+ * should be  remaining in a TX PDU such that it would make inserting a new
+ * segment worthwhile during the segmentation process.
+ * [Payload (min) + Segmentation Header + Time Offset]
+ */
+#define ISOAL_TX_SEGMENT_MIN_SIZE         (CONFIG_BT_CTLR_ISO_TX_SEG_PLAYLOAD_MIN +                \
+					   PDU_ISO_SEG_HDR_SIZE +                                  \
+					   PDU_ISO_SEG_TIMEOFFSET_SIZE)
+#endif /* CONFIG_BT_CTLR_ADV_ISO || CONFIG_BT_CTLR_CONN_ISO */
+
 /** Allocation state */
 typedef uint8_t isoal_alloc_state_t;
 #define ISOAL_ALLOC_STATE_FREE            ((isoal_alloc_state_t) 0x00)
@@ -1106,6 +1117,21 @@ static isoal_status_t isoal_source_allocate(isoal_source_handle_t *hdl)
  */
 static void isoal_source_deallocate(isoal_source_handle_t hdl)
 {
+	struct isoal_pdu_production *pp;
+	struct isoal_source *source;
+
+	source = &isoal_global.source_state[hdl];
+	pp = &source->pdu_production;
+
+	if (pp->pdu_available > 0) {
+		/* There is a pending PDU that should be released */
+		if (source && source->session.pdu_release) {
+			source->session.pdu_release(pp->pdu.contents.handle,
+						    source->session.handle,
+						    ISOAL_STATUS_ERR_PDU_EMIT);
+		}
+	}
+
 	isoal_global.source_allocated[hdl] = ISOAL_ALLOC_STATE_FREE;
 	(void)memset(&isoal_global.source_state[hdl], 0, sizeof(struct isoal_source));
 }
@@ -1884,18 +1910,11 @@ static isoal_status_t isoal_tx_framed_produce(struct isoal_source *source,
 		/* LLID is fixed for framed PDUs */
 		ll_id = PDU_BIS_LLID_FRAMED;
 
-		/* NOTE: Ideally even if the end of the SDU is reached, the PDU
-		 * should not be emitted as long as there is space left. If the
-		 * PDU is not released, it might require a flush timeout to
-		 * trigger the release as receiving an SDU per SDU interval is
-		 * not guaranteed. As there is no trigger for this in the
-		 * ISO-AL, the PDU is released. This does mean that the
-		 * bandwidth of this implementation will be less that the ideal
-		 * supported by framed PDUs. Ideally ISOAL_SEGMENT_MIN_SIZE
-		 * should be used to assess if there is sufficient usable space
-		 * left in the PDU.
+		/* If there isn't sufficient usable space then release the
+		 * PDU when the end of the SDU is reached, instead of waiting
+		 * for the next SDU.
 		 */
-		bool release_pdu = end_of_sdu;
+		bool release_pdu = end_of_sdu && (pp->pdu_available <= ISOAL_TX_SEGMENT_MIN_SIZE);
 		const isoal_status_t err_emit = isoal_tx_try_emit_pdu(source, release_pdu, ll_id);
 
 		err |= err_emit;
@@ -1918,6 +1937,41 @@ static isoal_status_t isoal_tx_framed_produce(struct isoal_source *source,
 	return err;
 }
 
+/**
+ * @brief  Handle preparation of the given source before commencing TX on the
+ *         specified event (only for framed sources)
+ * @param  source_hdl   Handle of source to prepare
+ * @param  event_count  Event number source should be prepared for
+ * @return              Status of operation
+ */
+static isoal_status_t isoal_tx_framed_event_prepare_handle(isoal_source_handle_t source_hdl,
+							   uint64_t event_count)
+{
+	struct isoal_source_session *session;
+	struct isoal_pdu_production *pp;
+	struct isoal_source *source;
+	uint64_t last_event_payload;
+	isoal_status_t err;
+
+	err = ISOAL_STATUS_OK;
+
+	source = &isoal_global.source_state[source_hdl];
+	session = &source->session;
+	pp = &source->pdu_production;
+	last_event_payload = (session->burst_number * (event_count + 1)) - 1;
+
+	if (pp->pdu_available > 0 &&
+		pp->payload_number <= last_event_payload) {
+		/* Pending PDU that should be released for framed TX */
+		err = isoal_tx_try_emit_pdu(source, true, PDU_BIS_LLID_FRAMED);
+	}
+
+	if (pp->payload_number < last_event_payload + 1) {
+		pp->payload_number = last_event_payload + 1;
+	}
+
+	return err;
+}
 
 /**
  * @brief Deep copy a SDU, fragment into PDU(s)
@@ -1930,12 +1984,19 @@ static isoal_status_t isoal_tx_framed_produce(struct isoal_source *source,
 isoal_status_t isoal_tx_sdu_fragment(isoal_source_handle_t source_hdl,
 				     struct isoal_sdu_tx *tx_sdu)
 {
+	struct isoal_source_session *session;
 	struct isoal_source *source;
 	isoal_status_t err;
 
 	source = &isoal_global.source_state[source_hdl];
+	session = &source->session;
 	err = ISOAL_STATUS_ERR_PDU_ALLOC;
 
+	/* Set source context active to mutually exclude ISO Event prepare
+	 * kick.
+	 */
+	source->context_active = true;
+
 	if (source->pdu_production.mode != ISOAL_PRODUCTION_MODE_DISABLED) {
 		/* BT Core V5.3 : Vol 6 Low Energy Controller : Part G IS0-AL:
 		 * 2 ISOAL Features :
@@ -1954,6 +2015,16 @@ isoal_status_t isoal_tx_sdu_fragment(isoal_source_handle_t source_hdl,
 		}
 	}
 
+	source->context_active = false;
+
+	if (source->timeout_trigger) {
+		source->timeout_trigger = false;
+		if (session->framed) {
+			isoal_tx_framed_event_prepare_handle(source_hdl,
+						source->timeout_event_count);
+		}
+	}
+
 	return err;
 }
 
@@ -2003,4 +2074,35 @@ isoal_status_t isoal_tx_get_sync_info(isoal_source_handle_t source_hdl,
 	return ISOAL_STATUS_ERR_UNSPECIFIED;
 }
 
+/**
+ * @brief  Incoming prepare request before commencing TX for the specified
+ *         event
+ * @param  source_hdl   Handle of source to prepare
+ * @param  event_count  Event number source should be prepared for
+ * @return              Status of operation
+ */
+void isoal_tx_event_prepare(isoal_source_handle_t source_hdl,
+			    uint64_t event_count)
+{
+	struct isoal_source_session *session;
+	struct isoal_source *source;
+
+	source = &isoal_global.source_state[source_hdl];
+	session = &source->session;
+
+	/* Store prepare timeout information and check if fragmentation context
+	 * is active.
+	 */
+	source->timeout_event_count = event_count;
+	source->timeout_trigger = true;
+	if (source->context_active) {
+		return;
+	}
+	source->timeout_trigger = false;
+
+	if (session->framed) {
+		isoal_tx_framed_event_prepare_handle(source_hdl, event_count);
+	}
+}
+
 #endif /* CONFIG_BT_CTLR_ADV_ISO || CONFIG_BT_CTLR_CONN_ISO */

subsys/bluetooth/controller/ll_sw/isoal.h

@@ -411,6 +411,11 @@ struct isoal_source {
 
 	/* State for PDU production */
 	struct isoal_pdu_production pdu_production;
+
+	/* Context Control */
+	uint64_t timeout_event_count:39;
+	uint64_t timeout_trigger:1;
+	uint64_t context_active:1;
 };
 
 isoal_status_t isoal_init(void);
@@ -489,3 +494,6 @@ isoal_status_t isoal_tx_get_sync_info(isoal_source_handle_t source_hdl,
 				      uint16_t *seq,
 				      uint32_t *timestamp,
 				      uint32_t *offset);
+
+void isoal_tx_event_prepare(isoal_source_handle_t source_hdl,
+			    uint64_t event_number);

subsys/bluetooth/controller/ll_sw/lll.h

@@ -586,6 +586,7 @@ void ull_iso_rx_put(memq_link_t *link, void *rx);
 void ull_iso_rx_sched(void);
 void *ull_iso_tx_ack_dequeue(void);
 void ull_iso_lll_ack_enqueue(uint16_t handle, struct node_tx_iso *tx);
+void ull_iso_lll_event_prepare(uint16_t handle, uint64_t event_count);
 struct event_done_extra *ull_event_done_extra_get(void);
 struct event_done_extra *ull_done_extra_type_set(uint8_t type);
 void *ull_event_done(void *param);

subsys/bluetooth/controller/ll_sw/ull_iso.c

@@ -916,7 +916,9 @@ static isoal_status_t ll_iso_test_pdu_release(struct node_tx_iso *node_tx,
 					      const isoal_status_t status)
 {
 	/* Release back to memory pool */
-	ll_iso_link_tx_release(node_tx->link);
+	if (node_tx->link) {
+		ll_iso_link_tx_release(node_tx->link);
+	}
 	ll_iso_tx_mem_release(node_tx);
 
 	return ISOAL_STATUS_OK;
@@ -1292,6 +1294,30 @@ void ull_iso_lll_ack_enqueue(uint16_t handle, struct node_tx_iso *node_tx)
 		LL_ASSERT(0);
 	}
 }
+
+void ull_iso_lll_event_prepare(uint16_t handle, uint64_t event_count)
+{
+	if (IS_CIS_HANDLE(handle)) {
+		struct ll_iso_datapath *dp = NULL;
+		struct ll_conn_iso_stream *cis;
+
+		cis = ll_iso_stream_connected_get(handle);
+
+		if (cis) {
+			dp  = cis->hdr.datapath_in;
+		}
+
+		if (dp) {
+			isoal_tx_event_prepare(dp->source_hdl, event_count);
+		}
+	} else if (IS_ADV_ISO_HANDLE(handle)) {
+		/* Send event deadline trigger to ISO-AL.
+		 * TODO: Can be unified with CIS implementation.
+		 */
+	} else {
+		LL_ASSERT(0);
+	}
+}
 #endif /* CONFIG_BT_CTLR_ADV_ISO || CONFIG_BT_CTLR_CONN_ISO */
 
 #if defined(CONFIG_BT_CTLR_SYNC_ISO) || defined(CONFIG_BT_CTLR_CONN_ISO)
@@ -1542,6 +1568,8 @@ static isoal_status_t ll_iso_pdu_alloc(struct isoal_pdu_buffer *pdu_buffer)
 		return ISOAL_STATUS_ERR_PDU_ALLOC;
 	}
 
+	node_tx->link = NULL;
+
 	/* node_tx handle will be required to emit the PDU later */
 	pdu_buffer->handle = (void *)node_tx;
 	pdu_buffer->pdu    = (void *)node_tx->pdu;
@@ -1625,7 +1653,9 @@ static isoal_status_t ll_iso_pdu_release(struct node_tx_iso *node_tx,
 		ll_rx_sched();
 	} else {
 		/* Release back to memory pool */
-		ll_iso_link_tx_release(node_tx->link);
+		if (node_tx->link) {
+			ll_iso_link_tx_release(node_tx->link);
+		}
 		ll_iso_tx_mem_release(node_tx);
 	}
 

subsys/bluetooth/controller/ll_sw/ull_peripheral_iso.c

@@ -313,6 +313,8 @@ static void ticker_cb(uint32_t ticks_at_expire, uint32_t ticks_drift,
 
 			leading_event_count = MAX(leading_event_count,
 						cis->lll.event_count);
+
+			ull_iso_lll_event_prepare(cis->lll.handle, cis->lll.event_count);
 		}
 
 		/* Latch datapath validity entering event */