nimble/controller: Add Synchronized Receiver role support

This adds Synchronized Receiver role support.
The role enables reception of broadcast isochronous streams.

Co-authored-by: Andrzej Kaczmarek <andrzej.kaczmarek@codecoup.pl>

Author: MariuszSkamra

nimble/controller/include/controller/ble_ll.h

@@ -243,6 +243,9 @@ extern STATS_SECT_DECL(ble_ll_stats) ble_ll_stats;
 #if MYNEWT_VAL(BLE_LL_ISO_BROADCASTER)
 #define BLE_LL_STATE_BIG            (9)
 #endif
+#if MYNEWT_VAL(BLE_LL_ISO_BROADCAST_SYNC)
+#define BLE_LL_STATE_BIG_SYNC       (10)
+#endif
 
 /* LL Features */
 #define BLE_LL_FEAT_LE_ENCRYPTION       (0x0000000000001)
@@ -301,7 +304,8 @@ extern STATS_SECT_DECL(ble_ll_stats) ble_ll_stats;
 
 /* All the features which can be controlled by the Host */
 #if MYNEWT_VAL(BLE_LL_CFG_FEAT_LL_ENHANCED_CONN_UPDATE) | \
-    MYNEWT_VAL(BLE_LL_ADV_CODING_SELECTION)
+    MYNEWT_VAL(BLE_LL_ADV_CODING_SELECTION) | \
+    MYNEWT_VAL(BLE_LL_ISO)
 #define BLE_LL_HOST_CONTROLLED_FEATURES (1)
 #else
 #define BLE_LL_HOST_CONTROLLED_FEATURES (0)
@@ -462,6 +466,54 @@ struct ble_dev_addr
     ((((hdr) & BLE_LL_DATA_HDR_LLID_MASK) == BLE_LL_LLID_DATA_START) || \
      (((hdr) & BLE_LL_DATA_HDR_LLID_MASK) == BLE_LL_LLID_DATA_FRAG))
 
+/*
+ * Broadcast Isochronous Data Channel format
+ *
+ *  -> Header (2 bytes)
+ *      -> LSB contains llid, cssn and cstf
+ *      -> MSB contains length (8 bits)
+ *  -> Payload (0 to 251)
+ *  -> MIC (0 or 4 bytes)
+ */
+#define BLE_LL_BIS_PDU_HDR_LLID_MASK   (0x03)
+#define BLE_LL_BIS_PDU_HDR_CSSN_MASK   (0x1C)
+#define BLE_LL_BIS_PDU_HDR_CSTF_MASK   (0x20)
+#define BLE_LL_BIS_PDU_HDR_RFU_MASK    (0xC0)
+#define BLE_LL_ISO_DATA_PAYLOAD_MAX    (251)
+#define BLE_LL_ISO_DATA_MIC_LEN        (4)
+
+/* Broadcast Isochronous PDU header LLID definitions */
+#define BLE_LL_BIS_LLID_DATA_PDU_UNFRAMED_CMPLT (0b00)
+#define BLE_LL_BIS_LLID_DATA_PDU_UNFRAMED_SC    (0b01)
+#define BLE_LL_BIS_LLID_DATA_PDU_FRAMED         (0b10)
+#define BLE_LL_BIS_LLID_CTRL_PDU                (0b11)
+
+#define BLE_LL_BIS_PDU_HDR_LLID(hdr) \
+    (((hdr) & BLE_LL_BIS_PDU_HDR_LLID_MASK) >> 0)
+#define BLE_LL_BIS_PDU_HDR_CSSN(hdr) \
+    (((hdr) & BLE_LL_BIS_PDU_HDR_CSSN_MASK) >> 2)
+#define BLE_LL_BIS_PDU_HDR_CSTF(hdr) \
+    (((hdr) & BLE_LL_BIS_PDU_HDR_CSTF_MASK) >> 5)
+
+#define BLE_LL_BIS_LLID_IS_CTRL(hdr) \
+    (BLE_LL_BIS_PDU_HDR_LLID(hdr) == BLE_LL_BIS_LLID_CTRL_PDU)
+#define BLE_LL_BIS_LLID_IS_DATA(hdr) \
+    ((BLE_LL_BIS_PDU_HDR_LLID(hdr) == BLE_LL_BIS_LLID_DATA_PDU_UNFRAMED_CMPLT) || \
+     (BLE_LL_BIS_PDU_HDR_LLID(hdr) == BLE_LL_BIS_LLID_DATA_PDU_UNFRAMED_SC) || \
+     (BLE_LL_BIS_PDU_HDR_LLID(hdr) == BLE_LL_BIS_LLID_DATA_PDU_FRAMED))
+
+#define BLE_LL_BIG_CTRL_CHAN_MAP_IND        (0x00)
+struct ble_ll_big_ctrl_chan_map_ind {
+    uint8_t chan_map[BLE_LL_CHAN_MAP_LEN];
+    uint16_t instant;
+} __attribute__((packed));
+
+#define BLE_LL_BIG_CTRL_TERM_IND            (0x01)
+struct ble_ll_big_ctrl_term_ind {
+    uint8_t reason;
+    uint16_t instant;
+} __attribute__((packed));
+
 /*
  * CONNECT_REQ
  *      -> InitA        (6 bytes)
@@ -581,6 +633,9 @@ int ble_ll_rx_start(uint8_t *rxbuf, uint8_t chan, struct ble_mbuf_hdr *hdr);
 /* Called by the PHY when a packet reception ends */
 int ble_ll_rx_end(uint8_t *rxbuf, struct ble_mbuf_hdr *rxhdr);
 
+/* Called by the PHY when a packet reception ends */
+int ble_ll_rx_early_end(const uint8_t *rxbuf, const struct ble_mbuf_hdr *rxhdr);
+
 /* Helper callback to tx mbuf using ble_phy_tx() */
 uint8_t ble_ll_tx_mbuf_pducb(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte);
 uint8_t ble_ll_tx_flat_mbuf_pducb(uint8_t *dptr, void *pducb_arg, uint8_t *hdr_byte);

nimble/controller/include/controller/ble_ll_iso.h

@@ -27,29 +27,55 @@
 extern "C" {
 #endif
 
-struct ble_ll_iso_data_path {
-    uint8_t data_path_id;
-    uint8_t enabled : 1;
+/**
+ * @struct ble_ll_iso_data_path_cb
+ *
+ * Interface structure for ISO data path callbacks.
+ */
+struct ble_ll_iso_data_path_cb {
+    /**
+     * @brief Callback function for sending an ISO SDU (Service Data Unit).
+     *
+     * @param conn_handle The connection handle associated with the received SDU.
+     * @param om Pointer to the `os_mbuf` structure containing the SDU data.
+     *           Can be `NULL` if the SDU is considered as lost.
+     * @param timestamp Timestamp associated with the received SDU.
+     * @param seq_num Sequence number of the SDU.
+     * @param valid Status of the SDU reception.
+     *              - `true`: SDU was received successfully, and `om` contains valid data.
+     *              - `false`: An error occurred during processing, but partial or corrupted
+     *                         SDU data may be available in `om`.
+     */
+    void (*sdu_send)(uint16_t conn_handle, const struct os_mbuf *om, uint32_t timestamp,
+                     uint16_t seq_num, bool valid);
 };
-struct ble_ll_iso_test_mode {
+struct ble_ll_iso_rx {
     struct {
-        uint32_t rand;
         uint8_t payload_type;
-        uint8_t enabled : 1;
-    } transmit;
+        uint32_t received_sdu_count;
+        uint32_t missed_sdu_count;
+        uint32_t failed_sdu_count;
+    } test;
+
+    const struct ble_ll_iso_data_path_cb *data_path;
+};
+struct ble_ll_iso_tx {
+    struct {
+        uint8_t payload_type;
+        uint32_t rand;
+    } test;
+
+    const struct ble_ll_iso_data_path_cb *data_path;
 };
 struct ble_ll_iso_conn {
     /* Connection handle */
     uint16_t handle;
 
-    /* Maximum SDU size */
-    uint16_t max_sdu;
+    /* ISO Rx */
+    struct ble_ll_iso_rx *rx;
 
-    /* ISO Data Path */
-    struct ble_ll_iso_data_path data_path;
-
-    /* ISO Test Mode */
-    struct ble_ll_iso_test_mode test_mode;
+    /* ISO Tx */
+    struct ble_ll_iso_tx *tx;
 
     /* ISOAL Multiplexer */
     struct ble_ll_isoal_mux mux;
@@ -74,36 +100,28 @@ int ble_ll_iso_reject_cis_req(const uint8_t *cmdbuf, uint8_t len);
 int ble_ll_iso_create_big(const uint8_t *cmdbuf, uint8_t len);
 int ble_ll_iso_create_big_test(const uint8_t *cmdbuf, uint8_t len);
 int ble_ll_iso_terminate_big(const uint8_t *cmdbuf, uint8_t len);
-int ble_ll_iso_big_create_sync(const uint8_t *cmdbuf, uint8_t len);
+int ble_ll_iso_big_create_sync(const uint8_t *cmdbuf, uint8_t len, uint8_t *rspbuf, uint8_t *rsplen);
 int ble_ll_iso_big_terminate_sync(const uint8_t *cmdbuf, uint8_t len);
 int ble_ll_iso_setup_iso_data_path(const uint8_t *cmdbuf, uint8_t len, uint8_t *rspbuf, uint8_t *rsplen);
 int ble_ll_iso_remove_iso_data_path(const uint8_t *cmdbuf, uint8_t len, uint8_t *rspbuf, uint8_t *rsplen);
 int ble_ll_iso_transmit_test(const uint8_t *cmdbuf, uint8_t len, uint8_t *rspbuf, uint8_t *rsplen);
-int ble_ll_iso_receive_test(const uint8_t *cmdbuf, uint8_t len);
-int ble_ll_iso_read_counters_test(const uint8_t *cmdbuf, uint8_t len);
+int ble_ll_iso_receive_test(const uint8_t *cmdbuf, uint8_t len, uint8_t *rspbuf, uint8_t *rsplen);
+int ble_ll_iso_read_counters_test(const uint8_t *cmdbuf, uint8_t len, uint8_t *rspbuf, uint8_t *rsplen);
 int ble_ll_iso_end_test(const uint8_t *cmdbuf, uint8_t len, uint8_t *rspbuf, uint8_t *rsplen);
 
 void ble_ll_iso_init(void);
 void ble_ll_iso_reset(void);
 
-/* ISO Data handler */
+/* ISO Data SDU handler */
 int ble_ll_iso_data_in(struct os_mbuf *om);
 
 int ble_ll_iso_pdu_get(struct ble_ll_iso_conn *conn, uint8_t idx, uint32_t pkt_counter, uint8_t *llid, void *dptr);
 
-struct ble_ll_iso_conn_init_param {
-    uint32_t iso_interval_us;
-    uint32_t sdu_interval_us;
-    uint16_t conn_handle;
-    uint16_t max_sdu;
-    uint8_t max_pdu;
-    uint8_t framing;
-    uint8_t pte;
-    uint8_t bn;
-};
+/* ISO Data PDU handler */
+int ble_ll_iso_data_pdu_in(struct ble_ll_iso_conn *conn, uint8_t idx, struct os_mbuf *om);
 
-void ble_ll_iso_conn_init(struct ble_ll_iso_conn *conn, struct ble_ll_iso_conn_init_param *param);
-void ble_ll_iso_conn_free(struct ble_ll_iso_conn *conn);
+void ble_ll_iso_conn_add(struct ble_ll_iso_conn *conn);
+void ble_ll_iso_conn_rem(struct ble_ll_iso_conn *conn);
 
 int ble_ll_iso_conn_event_start(struct ble_ll_iso_conn *conn, uint32_t timestamp);
 int ble_ll_iso_conn_event_done(struct ble_ll_iso_conn *conn);

nimble/controller/include/controller/ble_ll_iso_big_sync.h

@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef H_BLE_LL_ISO_BIG_SYNC_
+#define H_BLE_LL_ISO_BIG_SYNC_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if MYNEWT_VAL(BLE_LL_ISO_BROADCAST_SYNC)
+
+int ble_ll_iso_big_sync_rx_isr_start(uint8_t pdu_type, struct ble_mbuf_hdr *rxhdr);
+int ble_ll_iso_big_sync_rx_isr_end(uint8_t *rxbuf, struct ble_mbuf_hdr *rxhdr);
+int ble_ll_iso_big_sync_rx_isr_early_end(const uint8_t *rxbuf, const struct ble_mbuf_hdr *rxhdr);
+void ble_ll_iso_big_sync_rx_pdu_in(struct os_mbuf **rxpdu, struct ble_mbuf_hdr *hdr);
+
+void ble_ll_iso_big_sync_wfr_timer_exp(void);
+void ble_ll_iso_big_sync_halt(void);
+
+int ble_ll_iso_big_sync_hci_create(const uint8_t *cmdbuf, uint8_t len);
+int ble_ll_iso_big_sync_hci_terminate(const uint8_t *cmdbuf, uint8_t len, uint8_t *rspbuf, uint8_t *rsplen);
+
+void ble_ll_iso_big_sync_init(void);
+void ble_ll_iso_big_sync_reset(void);
+
+#endif /* BLE_LL_ISO_BROADCAST_SYNC */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H_BLE_LL_ISO_BIG_SYNC_ */

nimble/controller/include/controller/ble_ll_isoal.h

@@ -27,11 +27,26 @@
 extern "C" {
 #endif
 
+/* Forward declaration */
+struct ble_ll_isoal_mux;
+
+struct ble_ll_isoal_mux_cb {
+    void (*sdu_send)(struct ble_ll_isoal_mux *mux, const struct os_mbuf *om, uint32_t timestamp,
+                     uint16_t seq_num, bool valid);
+};
+
 struct ble_ll_isoal_mux {
 #if MYNEWT_VAL(BLE_LL_ISOAL_MUX_PREFILL)
     uint8_t active;
 #endif
 
+    /* ISO Interval */
+    uint32_t iso_interval_us;
+    /* SDU Interval */
+    uint32_t sdu_interval_us;
+
+    /* Maximum SDU size */
+    uint16_t max_sdu;
     /* Max PDU length */
     uint8_t max_pdu;
     /* Number of expected SDUs per ISO interval */
@@ -43,14 +58,27 @@ struct ble_ll_isoal_mux {
     /* Number of SDUs available for current event */
     uint8_t sdu_in_event;
 
+    struct {
+        /* Number of expected SDUs per ISO interval */
+        uint8_t sdu_per_interval;
+        /* Number of SDUs available for current event */
+        uint8_t sdu_in_event;
+    } rx;
+
     /* Burst Number */
     uint8_t bn;
 
     STAILQ_HEAD(, os_mbuf_pkthdr) sdu_q;
     uint16_t sdu_q_len;
 
+    /* ISO Data PDUs */
+    STAILQ_HEAD(, os_mbuf_pkthdr) pdu_q;
+
     uint32_t sdu_counter;
 
+    /* HCI SDU Fragment */
+    struct os_mbuf *frag;
+
     uint32_t event_tx_timestamp;
     uint32_t last_tx_timestamp;
     uint16_t last_tx_packet_seq_num;
@@ -59,6 +87,9 @@ struct ble_ll_isoal_mux {
     uint8_t sc : 1;
     uint8_t framed : 1;
     uint8_t framing_mode : 1;
+
+    /* Callback structure */
+    const struct ble_ll_isoal_mux_cb *cb;
 };
 
 #define BLE_LL_ISOAL_SEGHDR(sc, cmplt, len) \
@@ -72,10 +103,19 @@ struct ble_ll_isoal_mux {
         ((framing) == BLE_HCI_ISO_FRAMING_FRAMED_SEGMENTABLE || \
          (framing) == BLE_HCI_ISO_FRAMING_FRAMED_UNSEGMENTED)
 
-void ble_ll_isoal_mux_init(struct ble_ll_isoal_mux *mux, uint8_t max_pdu,
-                           uint32_t iso_interval_us, uint32_t sdu_interval_us,
-                           uint8_t bn, uint8_t pte, bool framed,
-                           uint8_t framing_mode);
+struct ble_ll_isoal_mux_init_param {
+    uint32_t iso_interval_us;
+    uint32_t sdu_interval_us;
+    uint16_t max_sdu;
+    uint8_t max_pdu;
+    uint8_t bn;
+    uint8_t pte;
+    uint8_t framed;
+    uint8_t framing_mode;
+};
+
+void ble_ll_isoal_mux_init(struct ble_ll_isoal_mux *mux,
+                           const struct ble_ll_isoal_mux_init_param *param);
 void ble_ll_isoal_mux_free(struct ble_ll_isoal_mux *mux);
 
 int ble_ll_isoal_mux_event_start(struct ble_ll_isoal_mux *mux,
@@ -88,6 +128,12 @@ int ble_ll_isoal_mux_pdu_get(struct ble_ll_isoal_mux *mux, uint8_t idx,
 void ble_ll_isoal_mux_sdu_enqueue(struct ble_ll_isoal_mux *mux,
                                   struct os_mbuf *om);
 
+void ble_ll_isoal_mux_pdu_enqueue(struct ble_ll_isoal_mux *mux, uint8_t idx,
+                                  struct os_mbuf *om);
+
+int ble_ll_isoal_mux_cb_set(struct ble_ll_isoal_mux *mux,
+                            const struct ble_ll_isoal_mux_cb *cb);
+
 void ble_ll_isoal_init(void);
 void ble_ll_isoal_reset(void);
 

nimble/controller/include/controller/ble_ll_sched.h

@@ -71,6 +71,7 @@ extern uint8_t g_ble_ll_sched_offset_ticks;
 #define BLE_LL_SCHED_TYPE_SYNC      (7)
 #define BLE_LL_SCHED_TYPE_SCAN_AUX  (8)
 #define BLE_LL_SCHED_TYPE_BIG       (9)
+#define BLE_LL_SCHED_TYPE_BIG_SYNC  (10)
 #if MYNEWT_VAL(BLE_LL_EXT)
 #define BLE_LL_SCHED_TYPE_EXTERNAL  (255)
 #endif
@@ -222,6 +223,10 @@ uint32_t ble_ll_sched_css_get_conn_interval_us(void);
 int ble_ll_sched_iso_big(struct ble_ll_sched_item *sch, int first, int fixed);
 #endif /* BLE_LL_ISO_BROADCASTER */
 
+#if MYNEWT_VAL(BLE_LL_ISO_BROADCAST_SYNC)
+int ble_ll_sched_iso_big_sync(struct ble_ll_sched_item *sch);
+#endif /* BLE_LL_ISO_BROADCAST_SYNC */
+
 #ifdef __cplusplus
 }
 #endif

nimble/controller/include/controller/ble_ll_sync.h

@@ -62,6 +62,15 @@ void ble_ll_sync_rmvd_from_sched(struct ble_ll_sync_sm *sm);
 
 uint32_t ble_ll_sync_get_event_end_time(void);
 
+typedef void (* ble_ll_sync_biginfo_cb_t)(struct ble_ll_sync_sm *syncsm, uint8_t sca,
+                                          uint32_t sync_ticks, uint8_t sync_rem_us,
+                                          const uint8_t *data, uint8_t len,
+                                          void *arg);
+
+struct ble_ll_sync_sm *ble_ll_sync_get(uint8_t handle);
+void ble_ll_sync_biginfo_cb_set(struct ble_ll_sync_sm *syncsm,
+                               ble_ll_sync_biginfo_cb_t cb, void *cb_arg);
+
 bool ble_ll_sync_enabled(void);
 
 void ble_ll_sync_reset(void);