| /* |
| * Copyright (c) 2020 Demant |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #include <zephyr/kernel.h> |
| #include <zephyr/bluetooth/buf.h> |
| #include <zephyr/sys/byteorder.h> |
| #include <zephyr/bluetooth/iso.h> |
| |
| #include "util/memq.h" |
| #include "util/mayfly.h" |
| #include "util/util.h" |
| |
| #include "hal/ccm.h" |
| #include "hal/ticker.h" |
| |
| #include "ticker/ticker.h" |
| |
| #include "pdu.h" |
| |
| #include "lll.h" |
| #include "lll/lll_vendor.h" |
| #include "lll_conn.h" |
| #include "lll_conn_iso.h" |
| #include "lll_clock.h" |
| |
| #include "isoal.h" |
| #include "ull_iso_types.h" |
| #include "ull_tx_queue.h" |
| #include "ull_internal.h" |
| |
| #include "ull_conn_types.h" |
| #include "ull_conn_internal.h" |
| #include "ull_conn_iso_types.h" |
| #include "ull_conn_iso_internal.h" |
| #include "ull_llcp.h" |
| #include "lll_central_iso.h" |
| |
| #include "ll.h" |
| |
| #include <zephyr/bluetooth/hci.h> |
| |
| #include "hal/debug.h" |
| |
| #define SDU_MAX_DRIFT_PPM 100 |
| |
| /* Setup cache for CIG commit transaction */ |
| static struct { |
| struct ll_conn_iso_group group; |
| uint8_t c_ft; |
| uint8_t p_ft; |
| uint8_t cis_idx; |
| struct ll_conn_iso_stream stream[CONFIG_BT_CTLR_CONN_ISO_STREAMS_PER_GROUP]; |
| } ll_iso_setup; |
| |
| uint8_t ll_cig_parameters_open(uint8_t cig_id, |
| uint32_t c_interval, uint32_t p_interval, |
| uint8_t sca, uint8_t packing, uint8_t framing, |
| uint16_t c_latency, uint16_t p_latency, |
| uint8_t num_cis) |
| { |
| memset(&ll_iso_setup, 0, sizeof(ll_iso_setup)); |
| |
| ll_iso_setup.group.cig_id = cig_id; |
| ll_iso_setup.group.c_sdu_interval = c_interval; |
| ll_iso_setup.group.p_sdu_interval = p_interval; |
| ll_iso_setup.group.c_latency = c_latency * 1000; |
| ll_iso_setup.group.p_latency = p_latency * 1000; |
| ll_iso_setup.group.cis_count = num_cis; |
| ll_iso_setup.group.central.sca = sca; |
| ll_iso_setup.group.central.packing = packing; |
| ll_iso_setup.group.central.framing = framing; |
| |
| return BT_HCI_ERR_SUCCESS; |
| } |
| |
| uint8_t ll_cis_parameters_set(uint8_t cis_id, |
| uint16_t c_sdu, uint16_t p_sdu, |
| uint8_t c_phy, uint8_t p_phy, |
| uint8_t c_rtn, uint8_t p_rtn) |
| { |
| uint8_t cis_idx = ll_iso_setup.cis_idx; |
| |
| if (cis_idx >= CONFIG_BT_CTLR_CONN_ISO_STREAMS_PER_GROUP) { |
| return BT_HCI_ERR_INSUFFICIENT_RESOURCES; |
| } |
| |
| memset(&ll_iso_setup.stream[cis_idx], 0, sizeof(struct ll_conn_iso_stream)); |
| |
| ll_iso_setup.stream[cis_idx].cis_id = cis_id; |
| ll_iso_setup.stream[cis_idx].c_max_sdu = c_sdu; |
| ll_iso_setup.stream[cis_idx].p_max_sdu = p_sdu; |
| ll_iso_setup.stream[cis_idx].lll.tx.phy = c_phy; |
| ll_iso_setup.stream[cis_idx].lll.rx.phy = p_phy; |
| ll_iso_setup.stream[cis_idx].central.c_rtn = c_rtn; |
| ll_iso_setup.stream[cis_idx].central.p_rtn = p_rtn; |
| ll_iso_setup.cis_idx++; |
| |
| return BT_HCI_ERR_SUCCESS; |
| } |
| |
| |
| void ll_cis_create(uint16_t cis_handle, uint16_t acl_handle) |
| { |
| /* Handles have been verified prior to calling this function */ |
| (void)ull_cp_cis_create( |
| ll_connected_get(acl_handle), |
| ll_conn_iso_stream_get(cis_handle)); |
| } |
| |
| uint8_t ll_cig_parameters_test_open(uint8_t cig_id, |
| uint32_t c_interval, |
| uint32_t p_interval, |
| uint8_t c_ft, |
| uint8_t p_ft, |
| uint16_t iso_interval, |
| uint8_t sca, |
| uint8_t packing, |
| uint8_t framing, |
| uint8_t num_cis) |
| { |
| memset(&ll_iso_setup, 0, sizeof(ll_iso_setup)); |
| |
| ll_iso_setup.group.cig_id = cig_id; |
| ll_iso_setup.group.c_sdu_interval = c_interval; |
| ll_iso_setup.group.p_sdu_interval = p_interval; |
| ll_iso_setup.group.iso_interval = iso_interval; |
| ll_iso_setup.group.cis_count = num_cis; |
| ll_iso_setup.group.central.sca = sca; |
| ll_iso_setup.group.central.packing = packing; |
| ll_iso_setup.group.central.framing = framing; |
| ll_iso_setup.group.central.test = 1U; |
| |
| /* TODO: Perhaps move FT to LLL CIG */ |
| ll_iso_setup.c_ft = c_ft; |
| ll_iso_setup.p_ft = p_ft; |
| |
| return BT_HCI_ERR_SUCCESS; |
| } |
| |
| uint8_t ll_cis_parameters_test_set(uint8_t cis_id, uint8_t nse, |
| uint16_t c_sdu, uint16_t p_sdu, |
| uint16_t c_pdu, uint16_t p_pdu, |
| uint8_t c_phy, uint8_t p_phy, |
| uint8_t c_bn, uint8_t p_bn) |
| { |
| uint8_t cis_idx = ll_iso_setup.cis_idx; |
| |
| if (cis_idx >= CONFIG_BT_CTLR_CONN_ISO_STREAMS_PER_GROUP) { |
| return BT_HCI_ERR_INSUFFICIENT_RESOURCES; |
| } |
| |
| memset(&ll_iso_setup.stream[cis_idx], 0, sizeof(struct ll_conn_iso_stream)); |
| |
| ll_iso_setup.stream[cis_idx].cis_id = cis_id; |
| ll_iso_setup.stream[cis_idx].c_max_sdu = c_sdu; |
| ll_iso_setup.stream[cis_idx].p_max_sdu = p_sdu; |
| ll_iso_setup.stream[cis_idx].lll.num_subevents = nse; |
| ll_iso_setup.stream[cis_idx].lll.tx.max_octets = c_bn ? c_pdu : 0; |
| ll_iso_setup.stream[cis_idx].lll.rx.max_octets = p_bn ? p_pdu : 0; |
| ll_iso_setup.stream[cis_idx].lll.tx.phy = c_phy; |
| ll_iso_setup.stream[cis_idx].lll.rx.phy = p_phy; |
| ll_iso_setup.stream[cis_idx].lll.tx.burst_number = c_bn; |
| ll_iso_setup.stream[cis_idx].lll.rx.burst_number = p_bn; |
| ll_iso_setup.cis_idx++; |
| |
| return BT_HCI_ERR_SUCCESS; |
| } |
| |
| static void set_bn_max_pdu(bool framed, uint32_t iso_interval, uint32_t sdu_interval, |
| uint16_t max_sdu, uint8_t *bn, uint8_t *max_pdu) |
| { |
| uint32_t ceil_f_x_max_sdu; |
| uint16_t max_pdu_bn1; |
| uint32_t max_drift; |
| uint32_t ceil_f; |
| |
| if (framed) { |
| /* Framed (From ES-18002): |
| * Max_PDU >= ((ceil(F) x 5 + ceil(F x Max_SDU)) / BN) + 2 |
| * F = (1 + MaxDrift) x ISO_Interval / SDU_Interval |
| * SegmentationHeader + TimeOffset = 5 bytes |
| * Continuation header = 2 bytes |
| * MaxDrift (Max. allowed SDU delivery timing drift) = 100 ppm |
| */ |
| max_drift = ceiling_fraction(SDU_MAX_DRIFT_PPM * sdu_interval, 1000000U); |
| ceil_f = ceiling_fraction(iso_interval + max_drift, sdu_interval); |
| ceil_f_x_max_sdu = ceiling_fraction(max_sdu * (iso_interval + max_drift), |
| sdu_interval); |
| |
| /* Strategy: Keep lowest possible BN. |
| * TODO: Implement other strategies, possibly as policies. |
| */ |
| max_pdu_bn1 = ceil_f * 5 + ceil_f_x_max_sdu; |
| *bn = ceiling_fraction(max_pdu_bn1, CONFIG_BT_CTLR_ISO_TX_BUFFER_SIZE); |
| *max_pdu = ceiling_fraction(max_pdu_bn1, *bn) + 2; |
| } else { |
| /* For unframed, ISO_Interval must be N x SDU_Interval */ |
| LL_ASSERT(iso_interval % sdu_interval == 0); |
| |
| /* Core 5.3 Vol 6, Part G section 2.1: |
| * BN >= ceil(Max_SDU/Max_PDU * ISO_Interval/SDU_Interval) |
| */ |
| *bn = ceiling_fraction(max_sdu * iso_interval, (*max_pdu) * sdu_interval); |
| } |
| } |
| |
| |
| /* TODO: |
| * - Drop retransmissions to stay within Max_Transmission_Latency instead of asserting |
| * - Calculate ISO_Interval to allow SDU_Interval < ISO_Interval |
| */ |
| uint8_t ll_cig_parameters_commit(uint8_t cig_id) |
| { |
| struct ll_conn_iso_stream *cis; |
| struct ll_conn_iso_group *cig; |
| uint32_t iso_interval_us; |
| uint32_t cig_sync_delay; |
| uint32_t max_se_length; |
| uint32_t c_max_latency; |
| uint32_t p_max_latency; |
| uint16_t handle_iter; |
| uint8_t cis_count; |
| |
| /* Intermediate subevent data */ |
| struct { |
| uint32_t length; |
| uint8_t total_count; |
| } se[CONFIG_BT_CTLR_CONN_ISO_STREAMS_PER_GROUP]; |
| |
| /* If CIG already exists, controller and host are not in sync */ |
| cig = ll_conn_iso_group_get_by_id(cig_id); |
| LL_ASSERT(!cig); |
| |
| /* CIG does not exist - create it */ |
| cig = ll_conn_iso_group_acquire(); |
| if (!cig) { |
| /* No space for new CIG */ |
| return BT_HCI_ERR_INSUFFICIENT_RESOURCES; |
| } |
| |
| /* Transfer parameters from update cache and clear LLL fields */ |
| memcpy(cig, &ll_iso_setup.group, sizeof(struct ll_conn_iso_group)); |
| |
| /* Setup LLL parameters */ |
| cig->lll.handle = ll_conn_iso_group_handle_get(cig); |
| cig->lll.role = BT_HCI_ROLE_CENTRAL; |
| cig->lll.resume_cis = LLL_HANDLE_INVALID; |
| |
| if (!cig->central.test) { |
| /* TODO: Calculate ISO_Interval based on SDU_Interval and Max_SDU vs Max_PDU, |
| * taking the policy into consideration. It may also be interesting to select an |
| * ISO_Interval which is less likely to collide with other connections. |
| * For instance: |
| * |
| * SDU_Interval ISO_Interval Max_SDU Max_SDU Collision risk (10 ms) |
| * ------------------------------------------------------------------------ |
| * 10 ms 10 ms 40 40 100% |
| * 10 ms 12.5 ms 40 50 25% |
| */ |
| iso_interval_us = cig->c_sdu_interval; |
| cig->iso_interval = ceiling_fraction(iso_interval_us, ISO_INT_UNIT_US); |
| } else { |
| iso_interval_us = cig->iso_interval * ISO_INT_UNIT_US; |
| } |
| |
| ull_hdr_init(&cig->ull); |
| lll_hdr_init(&cig->lll, cig); |
| |
| max_se_length = 0; |
| cis_count = cig->cis_count; |
| |
| /* 1) Acquire CIS instances and initialize instance data. |
| * 2) Calculate SE_Length for each CIS and store the largest |
| * 3) Calculate BN |
| * 4) Calculate total number of subevents needed to transfer payloads |
| * |
| * Sequential Interleaved |
| * CIS0 ___â–ˆ_â–ˆ_â–ˆ_____________â–ˆ_ ___â–ˆ___â–ˆ___â–ˆ_________â–ˆ_ |
| * CIS1 _________â–ˆ_â–ˆ_â–ˆ_________ _____â–ˆ___â–ˆ___â–ˆ_________ |
| * CIS_Sub_Interval |.| |...| |
| * CIG_Sync_Delay |............| |............| |
| * CIS_Sync_Delay 0 |............| |............| |
| * CIS_Sync_Delay 1 |......| |..........| |
| * ISO_Interval |.................|.. |.................|.. |
| */ |
| for (uint8_t i = 0; i < cis_count; i++) { |
| uint32_t mpt_c; |
| uint32_t mpt_p; |
| bool tx; |
| bool rx; |
| |
| /* Acquire new CIS */ |
| cis = ll_conn_iso_stream_acquire(); |
| if (cis == NULL) { |
| /* No space for new CIS */ |
| return BT_HCI_ERR_INSUFFICIENT_RESOURCES; |
| } |
| |
| /* Transfer parameters from update cache */ |
| memcpy(cis, &ll_iso_setup.stream[i], sizeof(struct ll_conn_iso_stream)); |
| cis->group = cig; |
| cis->framed = cig->central.framing; |
| |
| cis->lll.handle = ll_conn_iso_stream_handle_get(cis); |
| |
| if (cig->central.test) { |
| cis->lll.tx.flush_timeout = ll_iso_setup.c_ft; |
| cis->lll.rx.flush_timeout = ll_iso_setup.p_ft; |
| |
| tx = cis->lll.tx.burst_number && cis->lll.tx.max_octets; |
| rx = cis->lll.rx.burst_number && cis->lll.rx.max_octets; |
| } else { |
| LL_ASSERT(iso_interval_us >= cig->c_sdu_interval); |
| |
| tx = cig->c_sdu_interval && cis->c_max_sdu; |
| rx = cig->p_sdu_interval && cis->p_max_sdu; |
| |
| /* Use Max_PDU = MIN(<buffer_size>, Max_SDU) as default. May be changed by |
| * set_bn_max_pdu. |
| */ |
| cis->lll.tx.max_octets = MIN(CONFIG_BT_CTLR_ISO_TX_BUFFER_SIZE, |
| cis->c_max_sdu); |
| cis->lll.rx.max_octets = MIN(251, cis->p_max_sdu); |
| |
| /* Calculate BN and Max_PDU (framed) for both directions */ |
| if (tx) { |
| set_bn_max_pdu(cis->framed, iso_interval_us, cig->c_sdu_interval, |
| cis->c_max_sdu, &cis->lll.tx.burst_number, |
| &cis->lll.tx.max_octets); |
| } else { |
| cis->lll.tx.burst_number = 0; |
| } |
| |
| if (rx) { |
| set_bn_max_pdu(cis->framed, iso_interval_us, cig->p_sdu_interval, |
| cis->p_max_sdu, &cis->lll.rx.burst_number, |
| &cis->lll.rx.max_octets); |
| } else { |
| cis->lll.rx.burst_number = 0; |
| } |
| } |
| |
| /* Calculate SE_Length */ |
| mpt_c = PDU_CIS_MAX_US(cis->lll.tx.max_octets, tx ? 1 : 0, cis->lll.tx.phy); |
| mpt_p = PDU_CIS_MAX_US(cis->lll.rx.max_octets, rx ? 1 : 0, cis->lll.rx.phy); |
| |
| se[i].length = mpt_c + EVENT_IFS_US + mpt_p + EVENT_MSS_US; |
| max_se_length = MAX(max_se_length, se[i].length); |
| |
| /* Total number of subevents needed */ |
| se[i].total_count = MAX((cis->central.c_rtn + 1) * cis->lll.tx.burst_number, |
| (cis->central.p_rtn + 1) * cis->lll.rx.burst_number); |
| |
| /* Initialize TX link */ |
| cis->lll.link_tx_free = &cis->lll.link_tx; |
| |
| memq_init(cis->lll.link_tx_free, &cis->lll.memq_tx.head, &cis->lll.memq_tx.tail); |
| cis->lll.link_tx_free = NULL; |
| } |
| |
| handle_iter = UINT16_MAX; |
| uint32_t total_time = 0; |
| |
| /* 1) Prepare calculation of the flush timeout by adding up the total time needed to |
| * transfer all payloads, including retransmissions. |
| */ |
| for (uint8_t i = 0; i < cis_count; i++) { |
| cis = ll_conn_iso_stream_get_by_group(cig, &handle_iter); |
| |
| if (cig->central.packing == BT_ISO_PACKING_SEQUENTIAL) { |
| /* Sequential CISes - add up the duration and set individual |
| * subinterval. |
| */ |
| total_time += se[i].total_count * se[i].length; |
| } else { |
| /* Interleaved CISes - find the largest total duration and |
| * set all subintervals to the largest SE_Length of any CIS x |
| * the number of interleaved CISes. |
| */ |
| total_time = MAX(total_time, se[i].total_count * cis->lll.sub_interval + |
| (i * cis->lll.sub_interval / cis_count)); |
| } |
| } |
| |
| handle_iter = UINT16_MAX; |
| cig_sync_delay = 0; |
| |
| /* 1) Calculate the flush timeout either by dividing the total time needed to transfer all, |
| * payloads including retransmissions, and divide by the ISO_Interval (low latency |
| * policy), or by dividing the Max_Transmission_Latency by the ISO_Interval (reliability |
| * policy). |
| * 2) Calculate the number of subevents (NSE) by distributing total number of subevents into |
| * FT ISO_intervals. |
| * 3) Calculate subinterval as either individual CIS subinterval (sequential), or the |
| * largest SE_Length times number of CISes (interleaved). Min. subinterval is 400 us. |
| * 4) Calculate CIG_Sync_Delay |
| */ |
| for (uint8_t i = 0; i < cis_count; i++) { |
| cis = ll_conn_iso_stream_get_by_group(cig, &handle_iter); |
| |
| if (!cig->central.test) { |
| #if defined(CONFIG_BT_CTLR_CONN_ISO_LOW_LATENCY_POLICY) |
| /* Use symmetric flush timeout */ |
| cis->lll.tx.flush_timeout = ceiling_fraction(total_time, iso_interval_us); |
| cis->lll.rx.flush_timeout = cis->lll.tx.flush_timeout; |
| |
| #elif defined(CONFIG_BT_CTLR_CONN_ISO_RELIABILITY_POLICY) |
| /* Utilize Max_Transmission_latency */ |
| if (cis->framed) { |
| /* TL = CIG_Sync_Delay + FT x ISO_Interval + SDU_Interval. |
| * SDU_Interval <= CIG_Sync_Delay |
| */ |
| cis->lll.tx.flush_timeout = |
| ceiling_fraction(cig->c_latency - cig->c_sdu_interval - |
| iso_interval_us, iso_interval_us); |
| cis->lll.rx.flush_timeout = |
| ceiling_fraction(cig->p_latency - cig->p_sdu_interval - |
| iso_interval_us, iso_interval_us); |
| } else { |
| /* TL = CIG_Sync_Delay + FT x ISO_Interval - SDU_Interval. |
| * SDU_Interval <= CIG_Sync_Delay |
| */ |
| cis->lll.tx.flush_timeout = |
| ceiling_fraction(cig->c_latency + cig->c_sdu_interval - |
| iso_interval_us, iso_interval_us); |
| cis->lll.rx.flush_timeout = |
| ceiling_fraction(cig->p_latency + cig->p_sdu_interval - |
| iso_interval_us, iso_interval_us); |
| } |
| #else |
| LL_ASSERT(0); |
| #endif |
| cis->lll.num_subevents = ceiling_fraction(se[i].total_count, |
| cis->lll.tx.flush_timeout); |
| } |
| |
| if (cig->central.packing == BT_ISO_PACKING_SEQUENTIAL) { |
| /* Accumulate CIG sync delay for sequential CISes */ |
| cis->lll.sub_interval = MAX(400, se[i].length); |
| cig_sync_delay += cis->lll.num_subevents * cis->lll.sub_interval; |
| } else { |
| /* For interleaved CISes, offset each CIS by a fraction of a subinterval, |
| * positioning them evenly within the subinterval. |
| */ |
| cis->lll.sub_interval = MAX(400, cis_count * max_se_length); |
| cig_sync_delay = MAX(cig_sync_delay, |
| (cis->lll.num_subevents * cis->lll.sub_interval) + |
| (i * cis->lll.sub_interval / cis_count)); |
| } |
| } |
| |
| cig->sync_delay = cig_sync_delay; |
| |
| handle_iter = UINT16_MAX; |
| c_max_latency = 0; |
| p_max_latency = 0; |
| |
| /* 1) Calculate transport latencies for each CIS and validate against Max_Transport_Latency. |
| * 2) Lay out CISes by updating CIS_Sync_Delay, distributing according to the packing. |
| */ |
| for (uint8_t i = 0; i < cis_count; i++) { |
| uint32_t c_latency; |
| uint32_t p_latency; |
| |
| cis = ll_conn_iso_stream_get_by_group(cig, &handle_iter); |
| |
| if (cis->framed) { |
| /* Transport_Latency = CIG_Sync_Delay + FT x ISO_Interval + SDU_Interval */ |
| c_latency = cig->sync_delay + |
| (cis->lll.tx.flush_timeout * iso_interval_us) + |
| cig->c_sdu_interval; |
| p_latency = cig->sync_delay + |
| (cis->lll.rx.flush_timeout * iso_interval_us) + |
| cig->p_sdu_interval; |
| |
| } else { |
| /* Transport_Latency = CIG_Sync_Delay + FT x ISO_Interval - SDU_Interval */ |
| c_latency = cig->sync_delay + |
| (cis->lll.tx.flush_timeout * iso_interval_us) - |
| cig->c_sdu_interval; |
| p_latency = cig->sync_delay + |
| (cis->lll.rx.flush_timeout * iso_interval_us) - |
| cig->p_sdu_interval; |
| } |
| |
| if (!cig->central.test) { |
| /* Make sure specified Max_Transport_Latency is not exceeded */ |
| LL_ASSERT(c_latency <= cig->c_latency); |
| LL_ASSERT(p_latency <= cig->p_latency); |
| } |
| |
| c_max_latency = MAX(c_max_latency, c_latency); |
| p_max_latency = MAX(p_max_latency, p_latency); |
| |
| if (cig->central.packing == BT_ISO_PACKING_SEQUENTIAL) { |
| /* Distribute CISes sequentially */ |
| cis->sync_delay = cig_sync_delay; |
| cig_sync_delay -= cis->lll.num_subevents * cis->lll.sub_interval; |
| } else { |
| /* Distribute CISes interleaved */ |
| cis->sync_delay = cig_sync_delay; |
| cig_sync_delay -= (cis->lll.sub_interval / cis_count); |
| } |
| |
| if (cis->lll.num_subevents <= 1) { |
| cis->lll.sub_interval = 0; |
| } |
| } |
| |
| /* Update actual latency */ |
| cig->c_latency = c_max_latency; |
| cig->p_latency = p_max_latency; |
| |
| cig->lll.num_cis = cis_count; |
| |
| return BT_HCI_ERR_SUCCESS; |
| } |
| |
| /* Core 5.3 Vol 6, Part B section 7.8.100: |
| * The HCI_LE_Remove_CIG command is used by the Central’s Host to remove the CIG |
| * identified by CIG_ID. |
| * This command shall delete the CIG_ID and also delete the Connection_Handles |
| * of the CIS configurations stored in the CIG. |
| * This command shall also remove the isochronous data paths that are associated |
| * with the Connection_Handles of the CIS configurations. |
| */ |
| uint8_t ll_cig_remove(uint8_t cig_id) |
| { |
| struct ll_conn_iso_stream *cis; |
| struct ll_conn_iso_group *cig; |
| uint16_t handle_iter; |
| bool has_cis; |
| |
| cig = ll_conn_iso_group_get_by_id(cig_id); |
| if (!cig) { |
| /* Unknown CIG id */ |
| return BT_HCI_ERR_UNKNOWN_CONN_ID; |
| } |
| |
| if (cig->started) { |
| /* CIG is in active state */ |
| return BT_HCI_ERR_CMD_DISALLOWED; |
| } |
| |
| handle_iter = UINT16_MAX; |
| for (int i = 0; i < cig->cis_count; i++) { |
| struct ll_conn *conn; |
| |
| cis = ll_conn_iso_stream_get_by_group(cig, &handle_iter); |
| if (!cis) { |
| break; |
| } |
| |
| conn = ll_connected_get(cis->lll.acl_handle); |
| |
| if (conn) { |
| if (ull_lp_cc_is_active(conn)) { |
| /* CIG creation is ongoing */ |
| return BT_HCI_ERR_CMD_DISALLOWED; |
| } |
| } |
| } |
| |
| /* CIG exists and is not active */ |
| handle_iter = UINT16_MAX; |
| has_cis = false; |
| |
| for (int i = 0; i < cig->cis_count; i++) { |
| cis = ll_conn_iso_stream_get_by_group(cig, &handle_iter); |
| if (!cis) { |
| break; |
| } |
| |
| /* Remove data path and ISOAL sink/source associated with this CIS |
| * for both directions. |
| */ |
| ll_remove_iso_path(cis->lll.handle, BT_HCI_DATAPATH_DIR_CTLR_TO_HOST); |
| ll_remove_iso_path(cis->lll.handle, BT_HCI_DATAPATH_DIR_HOST_TO_CTLR); |
| |
| has_cis = true; |
| } |
| |
| if (has_cis) { |
| /* Clear configuration only - let CIS disconnection release instance */ |
| cig->cis_count = 0; |
| } else { |
| /* No CISes associated with the CIG - release the instance */ |
| ll_conn_iso_group_release(cig); |
| } |
| |
| return BT_HCI_ERR_SUCCESS; |
| } |
| |
| uint8_t ll_cis_create_check(uint16_t cis_handle, uint16_t acl_handle) |
| { |
| struct ll_conn *conn; |
| |
| conn = ll_connected_get(acl_handle); |
| if (conn) { |
| struct ll_conn_iso_stream *cis; |
| |
| /* Verify handle validity and association */ |
| cis = ll_conn_iso_stream_get(cis_handle); |
| if (cis->lll.handle == cis_handle && cis->lll.acl_handle == acl_handle) { |
| return BT_HCI_ERR_SUCCESS; |
| } |
| } |
| |
| return BT_HCI_ERR_CMD_DISALLOWED; |
| } |
| |
| int ull_central_iso_init(void) |
| { |
| return 0; |
| } |
| |
| int ull_central_iso_reset(void) |
| { |
| return 0; |
| } |
| |
| uint8_t ull_central_iso_setup(uint16_t cis_handle, |
| uint32_t *cig_sync_delay, |
| uint32_t *cis_sync_delay, |
| uint32_t *cis_offset_min, |
| uint32_t *cis_offset_max, |
| uint16_t *conn_event_count, |
| uint8_t *access_addr) |
| { |
| struct ll_conn_iso_stream *cis; |
| struct ll_conn_iso_group *cig; |
| struct ll_conn *conn; |
| uint16_t handle_iter; |
| uint32_t cis_offset; |
| uint16_t instant; |
| int err; |
| |
| cis = ll_conn_iso_stream_get(cis_handle); |
| if (!cis) { |
| return BT_HCI_ERR_UNSPECIFIED; |
| } |
| |
| cig = cis->group; |
| if (!cig) { |
| return BT_HCI_ERR_UNSPECIFIED; |
| } |
| |
| conn = ll_conn_get(cis->lll.acl_handle); |
| instant = MAX(*conn_event_count, ull_conn_event_counter(conn) + 1); |
| |
| handle_iter = UINT16_MAX; |
| cis_offset = *cis_offset_min; |
| |
| /* Calculate offset for CIS */ |
| for (uint8_t i = 0; i < cig->cis_count; i++) { |
| struct ll_conn_iso_stream *c; |
| int16_t conn_events_since_ref; |
| uint32_t iso_interval_us; |
| uint32_t time_since_ref; |
| |
| c = ll_conn_iso_stream_get_by_group(cig, &handle_iter); |
| if (c->cis_id != cis->cis_id && c->lll.active) { |
| conn_events_since_ref = (int16_t)(instant - c->central.instant); |
| LL_ASSERT(conn_events_since_ref > 0); |
| |
| time_since_ref = c->offset + conn_events_since_ref * conn->lll.interval * |
| CONN_INT_UNIT_US; |
| iso_interval_us = cig->iso_interval * ISO_INT_UNIT_US; |
| cis_offset = time_since_ref % iso_interval_us; |
| break; |
| } |
| } |
| |
| cis->offset = cis_offset; |
| cis->central.instant = instant; |
| cis->lll.event_count = -1; |
| |
| /* Create access address */ |
| err = util_aa_le32(cis->lll.access_addr); |
| LL_ASSERT(!err); |
| |
| /* Transfer to caller */ |
| *cig_sync_delay = cig->sync_delay; |
| *cis_sync_delay = cis->sync_delay; |
| *cis_offset_min = cis->offset; |
| memcpy(access_addr, cis->lll.access_addr, sizeof(cis->lll.access_addr)); |
| |
| *conn_event_count = instant; |
| |
| return 0; |
| } |
| |
| uint16_t ull_central_iso_cis_offset_get(uint16_t cis_handle, uint32_t *cis_offset_min, |
| uint32_t *cis_offset_max) |
| { |
| struct ll_conn_iso_stream *cis; |
| struct ll_conn *conn; |
| |
| cis = ll_conn_iso_stream_get(cis_handle); |
| LL_ASSERT(cis); |
| |
| conn = ll_conn_get(cis->lll.acl_handle); |
| |
| if (cis_offset_min && cis_offset_max) { |
| struct ll_conn_iso_group *cig; |
| |
| cig = cis->group; |
| |
| /* Provide CIS offset range |
| * CIS_Offset_Max < (connInterval - (CIG_Sync_Delay + T_MSS)) |
| */ |
| *cis_offset_max = (conn->lll.interval * CONN_INT_UNIT_US) - cig->sync_delay; |
| *cis_offset_min = MAX(400, EVENT_OVERHEAD_CIS_SETUP_US); |
| } |
| |
| cis->central.instant = ull_conn_event_counter(conn) + 3; |
| return cis->central.instant; |
| } |