Snap for 11510257 from b14574f639eb44d24e248a02c24ae55ff6dd2fde to simpleperf-releasesimpleperf-release

Change-Id: I1b34dbdad804e05b892473756211cb416e06d78c

10 files changed, 353 insertions, 19 deletions

diff --git a/src/rust/uwb_core/src/params/uci_packets.rs b/src/rust/uwb_core/src/params/uci_packets.rs
index e3a7722..b54680d 100644
--- a/src/rust/uwb_core/src/params/uci_packets.rs
+++ b/src/rust/uwb_core/src/params/uci_packets.rs
@@ -22,13 +22,14 @@ use std::iter::FromIterator;
 pub use uwb_uci_packets::{
     AppConfigStatus, AppConfigTlv as RawAppConfigTlv, AppConfigTlvType, BitsPerSample, CapTlv,
     CapTlvType, Controlee, ControleeStatus, Controlees, CreditAvailability, DataRcvStatusCode,
-    DataTransferNtfStatusCode, DeviceConfigId, DeviceConfigStatus, DeviceConfigTlv, DeviceState,
-    ExtendedAddressDlTdoaRangingMeasurement, ExtendedAddressOwrAoaRangingMeasurement,
-    ExtendedAddressTwoWayRangingMeasurement, GroupId, MessageType, MulticastUpdateStatusCode,
-    PhaseList, PowerStats, RadarConfigStatus, RadarConfigTlv, RadarConfigTlvType, RadarDataType,
-    RangingMeasurementType, ReasonCode, ResetConfig, SessionState, SessionType,
-    ShortAddressDlTdoaRangingMeasurement, ShortAddressOwrAoaRangingMeasurement,
-    ShortAddressTwoWayRangingMeasurement, StatusCode, UpdateMulticastListAction,
+    DataTransferNtfStatusCode, DataTransferPhaseConfigUpdateStatusCode, DeviceConfigId,
+    DeviceConfigStatus, DeviceConfigTlv, DeviceState, ExtendedAddressDlTdoaRangingMeasurement,
+    ExtendedAddressOwrAoaRangingMeasurement, ExtendedAddressTwoWayRangingMeasurement, GroupId,
+    MessageType, MulticastUpdateStatusCode, PhaseList, PowerStats, RadarConfigStatus,
+    RadarConfigTlv, RadarConfigTlvType, RadarDataType, RangingMeasurementType, ReasonCode,
+    ResetConfig, SessionState, SessionType, ShortAddressDlTdoaRangingMeasurement,
+    ShortAddressOwrAoaRangingMeasurement, ShortAddressTwoWayRangingMeasurement, StatusCode,
+    UpdateMulticastListAction,
 };
 pub(crate) use uwb_uci_packets::{UciControlPacket, UciDataPacket, UciDataPacketHal};
 
diff --git a/src/rust/uwb_core/src/session/session_manager.rs b/src/rust/uwb_core/src/session/session_manager.rs
index 3c05a1e..38a9887 100644
--- a/src/rust/uwb_core/src/session/session_manager.rs
+++ b/src/rust/uwb_core/src/session/session_manager.rs
@@ -393,6 +393,22 @@ impl<T: UciManager> SessionManagerActor<T> {
                     }
                 }
             }
+            UciSessionNotification::DataTransferPhaseConfig { session_token, status } => {
+                match self.active_sessions.get_mut(&session_token) {
+                    Some(_) => {
+                        /*
+                         *TODO
+                         */
+                    }
+                    None => {
+                        warn!(
+                            "Received data transfer phase configuration notification of the unknown
+                            Session {:?}",
+                            status
+                        );
+                    }
+                }
+            }
         }
     }
 }
diff --git a/src/rust/uwb_core/src/uci/command.rs b/src/rust/uwb_core/src/uci/command.rs
index 864ca8f..fa71b2d 100644
--- a/src/rust/uwb_core/src/uci/command.rs
+++ b/src/rust/uwb_core/src/uci/command.rs
@@ -24,7 +24,8 @@ use crate::params::uci_packets::{
     UpdateMulticastListAction, UpdateTime,
 };
 use uwb_uci_packets::{
-    build_session_update_controller_multicast_list_cmd, GroupId, MessageType, PhaseList,
+    build_data_transfer_phase_config_cmd, build_session_update_controller_multicast_list_cmd,
+    GroupId, MessageType, PhaseList,
 };
 
 /// The enum to represent the UCI commands. The definition of each field should follow UCI spec.
@@ -89,6 +90,14 @@ pub enum UciCommand {
         update_time: UpdateTime,
         phase_list: Vec<PhaseList>,
     },
+    SessionDataTransferPhaseConfig {
+        session_token: SessionToken,
+        dtpcm_repetition: u8,
+        data_transfer_control: u8,
+        dtpml_size: u8,
+        mac_address: Vec<u8>,
+        slot_bitmap: Vec<u8>,
+    },
     AndroidSetCountryCode {
         country_code: CountryCode,
     },
@@ -235,6 +244,23 @@ impl TryFrom<UciCommand> for uwb_uci_packets::UciControlPacket {
             }
             .build()
             .into(),
+            UciCommand::SessionDataTransferPhaseConfig {
+                session_token,
+                dtpcm_repetition,
+                data_transfer_control,
+                dtpml_size,
+                mac_address,
+                slot_bitmap,
+            } => build_data_transfer_phase_config_cmd(
+                session_token,
+                dtpcm_repetition,
+                data_transfer_control,
+                dtpml_size,
+                mac_address,
+                slot_bitmap,
+            )
+            .map_err(|_| Error::BadParameters)?
+            .into(),
         };
         Ok(packet)
     }
diff --git a/src/rust/uwb_core/src/uci/mock_uci_manager.rs b/src/rust/uwb_core/src/uci/mock_uci_manager.rs
index f6e84ba..7805d19 100644
--- a/src/rust/uwb_core/src/uci/mock_uci_manager.rs
+++ b/src/rust/uwb_core/src/uci/mock_uci_manager.rs
@@ -472,6 +472,32 @@ impl MockUciManager {
         });
     }
 
+    /// Prepare Mock to expect session_data_transfer_phase_config
+    /// MockUciManager expects call with parameters, returns out as response
+    #[allow(clippy::too_many_arguments)]
+    pub fn expect_session_data_transfer_phase_config(
+        &mut self,
+        expected_session_id: SessionId,
+        expected_dtpcm_repetition: u8,
+        expected_data_transfer_control: u8,
+        expected_dtpml_size: u8,
+        expected_mac_address: Vec<u8>,
+        expected_slot_bitmap: Vec<u8>,
+        out: Result<()>,
+    ) {
+        self.expected_calls.lock().unwrap().push_back(
+            ExpectedCall::SessionDataTransferPhaseConfig {
+                expected_session_id,
+                expected_dtpcm_repetition,
+                expected_data_transfer_control,
+                expected_dtpml_size,
+                expected_mac_address,
+                expected_slot_bitmap,
+                out,
+            },
+        );
+    }
+
     /// Call Mock to send notifications.
     fn send_notifications(&self, notfs: Vec<UciNotification>) {
         for notf in notfs.into_iter() {
@@ -816,6 +842,43 @@ impl UciManager for MockUciManager {
         }
     }
 
+    async fn session_data_transfer_phase_config(
+        &self,
+        session_id: SessionId,
+        dtpcm_repetition: u8,
+        data_transfer_control: u8,
+        dtpml_size: u8,
+        mac_address: Vec<u8>,
+        slot_bitmap: Vec<u8>,
+    ) -> Result<()> {
+        let mut expected_calls = self.expected_calls.lock().unwrap();
+        match expected_calls.pop_front() {
+            Some(ExpectedCall::SessionDataTransferPhaseConfig {
+                expected_session_id,
+                expected_dtpcm_repetition,
+                expected_data_transfer_control,
+                expected_dtpml_size,
+                expected_mac_address,
+                expected_slot_bitmap,
+                out,
+            }) if expected_session_id == session_id
+                && expected_dtpcm_repetition == dtpcm_repetition
+                && expected_data_transfer_control == data_transfer_control
+                && expected_dtpml_size == dtpml_size
+                && expected_mac_address == mac_address
+                && expected_slot_bitmap == slot_bitmap =>
+            {
+                self.expect_call_consumed.notify_one();
+                out
+            }
+            Some(call) => {
+                expected_calls.push_front(call);
+                Err(Error::MockUndefined)
+            }
+            None => Err(Error::MockUndefined),
+        }
+    }
+
     async fn session_update_dt_tag_ranging_rounds(
         &self,
         session_id: u32,
@@ -1224,4 +1287,13 @@ enum ExpectedCall {
         expected_phase_list: Vec<PhaseList>,
         out: Result<()>,
     },
+    SessionDataTransferPhaseConfig {
+        expected_session_id: SessionId,
+        expected_dtpcm_repetition: u8,
+        expected_data_transfer_control: u8,
+        expected_dtpml_size: u8,
+        expected_mac_address: Vec<u8>,
+        expected_slot_bitmap: Vec<u8>,
+        out: Result<()>,
+    },
 }
diff --git a/src/rust/uwb_core/src/uci/notification.rs b/src/rust/uwb_core/src/uci/notification.rs
index c53d0e9..08af530 100644
--- a/src/rust/uwb_core/src/uci/notification.rs
+++ b/src/rust/uwb_core/src/uci/notification.rs
@@ -26,11 +26,11 @@ use crate::error::{Error, Result};
 use crate::params::fira_app_config_params::UwbAddress;
 use crate::params::uci_packets::{
     BitsPerSample, ControleeStatus, CreditAvailability, DataRcvStatusCode,
-    DataTransferNtfStatusCode, DeviceState, ExtendedAddressDlTdoaRangingMeasurement,
-    ExtendedAddressOwrAoaRangingMeasurement, ExtendedAddressTwoWayRangingMeasurement,
-    RadarDataType, RangingMeasurementType, RawUciMessage, SessionState, SessionToken,
-    ShortAddressDlTdoaRangingMeasurement, ShortAddressOwrAoaRangingMeasurement,
-    ShortAddressTwoWayRangingMeasurement, StatusCode,
+    DataTransferNtfStatusCode, DataTransferPhaseConfigUpdateStatusCode, DeviceState,
+    ExtendedAddressDlTdoaRangingMeasurement, ExtendedAddressOwrAoaRangingMeasurement,
+    ExtendedAddressTwoWayRangingMeasurement, RadarDataType, RangingMeasurementType, RawUciMessage,
+    SessionState, SessionToken, ShortAddressDlTdoaRangingMeasurement,
+    ShortAddressOwrAoaRangingMeasurement, ShortAddressTwoWayRangingMeasurement, StatusCode,
 };
 
 /// enum of all UCI notifications with structured fields.
@@ -94,6 +94,13 @@ pub enum SessionNotification {
         /// Transmission count
         tx_count: u8,
     },
+    /// SessionDataTransferPhaseConfigNtf equivalent.
+    DataTransferPhaseConfig {
+        /// SessionToken : u32
+        session_token: SessionToken,
+        /// status
+        status: DataTransferPhaseConfigUpdateStatusCode,
+    },
 }
 
 /// The session range data.
@@ -387,6 +394,12 @@ impl TryFrom<uwb_uci_packets::SessionConfigNotification> for SessionNotification
                     status_list: evt.get_controlee_status().clone(),
                 })
             }
+            SessionConfigNotificationChild::SessionDataTransferPhaseConfigNtf(evt) => {
+                Ok(Self::DataTransferPhaseConfig {
+                    session_token: evt.get_session_token(),
+                    status: evt.get_status(),
+                })
+            }
             _ => {
                 error!("Unknown SessionConfigNotification: {:?}", evt);
                 Err(Error::Unknown)
diff --git a/src/rust/uwb_core/src/uci/response.rs b/src/rust/uwb_core/src/uci/response.rs
index d70f9f7..68994a6 100644
--- a/src/rust/uwb_core/src/uci/response.rs
+++ b/src/rust/uwb_core/src/uci/response.rs
@@ -53,6 +53,7 @@ pub(super) enum UciResponse {
     RawUciCmd(Result<RawUciMessage>),
     SendUciData(Result<()>),
     SessionSetHybridConfig(Result<()>),
+    SessionDataTransferPhaseConfig(Result<()>),
 }
 
 impl UciResponse {
@@ -82,6 +83,7 @@ impl UciResponse {
             Self::AndroidSetRadarConfig(resp) => Self::matches_status_retry(&resp.status),
             Self::RawUciCmd(result) => Self::matches_result_retry(result),
             Self::SessionSetHybridConfig(result) => Self::matches_result_retry(result),
+            Self::SessionDataTransferPhaseConfig(result) => Self::matches_result_retry(result),
 
             Self::CoreSetConfig(resp) => Self::matches_status_retry(&resp.status),
             Self::SessionSetAppConfig(resp) => Self::matches_status_retry(&resp.status),
@@ -218,6 +220,11 @@ impl TryFrom<uwb_uci_packets::SessionConfigResponse> for UciResponse {
             SessionConfigResponseChild::SessionSetHybridConfigRsp(evt) => {
                 Ok(UciResponse::SessionSetHybridConfig(status_code_to_result(evt.get_status())))
             }
+            SessionConfigResponseChild::SessionDataTransferPhaseConfigRsp(evt) => {
+                Ok(UciResponse::SessionDataTransferPhaseConfig(status_code_to_result(
+                    evt.get_status(),
+                )))
+            }
             _ => Err(Error::Unknown),
         }
     }
diff --git a/src/rust/uwb_core/src/uci/uci_manager.rs b/src/rust/uwb_core/src/uci/uci_manager.rs
index f39ba3d..8548278 100644
--- a/src/rust/uwb_core/src/uci/uci_manager.rs
+++ b/src/rust/uwb_core/src/uci/uci_manager.rs
@@ -174,6 +174,17 @@ pub trait UciManager: 'static + Send + Sync + Clone {
         app_payload_data: Vec<u8>,
     ) -> Result<()>;
 
+    // set Data transfer phase config
+    async fn session_data_transfer_phase_config(
+        &self,
+        session_id: SessionId,
+        dtpcm_repetition: u8,
+        data_transfer_control: u8,
+        dtpml_size: u8,
+        mac_address: Vec<u8>,
+        slot_bitmap: Vec<u8>,
+    ) -> Result<()>;
+
     // Get Session token from session id
     async fn get_session_token_from_session_id(
         &self,
@@ -629,6 +640,32 @@ impl UciManager for UciManagerImpl {
         }
     }
 
+    // set Data transfer phase config
+    async fn session_data_transfer_phase_config(
+        &self,
+        session_id: SessionId,
+        dtpcm_repetition: u8,
+        data_transfer_control: u8,
+        dtpml_size: u8,
+        mac_address: Vec<u8>,
+        slot_bitmap: Vec<u8>,
+    ) -> Result<()> {
+        let cmd = UciCommand::SessionDataTransferPhaseConfig {
+            session_token: self.get_session_token(&session_id).await?,
+            dtpcm_repetition,
+            data_transfer_control,
+            dtpml_size,
+            mac_address,
+            slot_bitmap,
+        };
+
+        match self.send_cmd(UciManagerCmd::SendUciCommand { cmd }).await {
+            Ok(UciResponse::SessionDataTransferPhaseConfig(resp)) => resp,
+            Ok(_) => Err(Error::Unknown),
+            Err(e) => Err(e),
+        }
+    }
+
     // Get session token from session id (no uci call).
     async fn get_session_token_from_session_id(
         &self,
@@ -875,6 +912,8 @@ impl<T: UciHal, U: UciLogger> UciManagerActor<T, U> {
         }
     }
 
+    #[allow(unknown_lints)]
+    #[allow(clippy::unnecessary_fallible_conversions)]
     fn store_if_uwbs_caps_info(&mut self, resp: &UciResponse) {
         if !parse_cap_tlv_rust_uses_uwbs_uci_version() {
             return;
@@ -1409,6 +1448,12 @@ impl<T: UciHal, U: UciLogger> UciManagerActor<T, U> {
                     credit_availability,
                 })
             }
+            SessionNotification::DataTransferPhaseConfig { session_token, status } => {
+                Ok(SessionNotification::DataTransferPhaseConfig {
+                    session_token: self.get_session_id(&session_token).await?,
+                    status,
+                })
+            }
         }
     }
 
@@ -1590,9 +1635,9 @@ mod tests {
         DataTransferNtfStatusCode, RadarDataType, StatusCode,
     };
     use crate::params::UwbAddress;
-    use crate::uci::notification::CoreNotification;
     use crate::uci::mock_uci_hal::MockUciHal;
     use crate::uci::mock_uci_logger::{MockUciLogger, UciLogEvent};
+    use crate::uci::notification::CoreNotification;
     use crate::uci::notification::RadarSweepData;
     use crate::uci::uci_logger::NopUciLogger;
     use crate::utils::init_test_logging;
@@ -1761,10 +1806,12 @@ mod tests {
         let payload_1 = vec![0xFF];
         let pbf_set: u8 = 0x1;
         let gid_session: u8 = 0x02;
-        let oid_session_ntf: u8 =  0x03;
+        let oid_session_ntf: u8 = 0x03;
         let payload_range_dat = vec![0, 251];
-        let dev_state_err_packet = build_uci_packet(mt, pbf_not_set, gid_core, oid_device_status, payload_1);
-        let range_data_ntf_packet = build_uci_packet(mt, pbf_set, gid_session, oid_session_ntf, payload_range_dat);
+        let dev_state_err_packet =
+            build_uci_packet(mt, pbf_not_set, gid_core, oid_device_status, payload_1);
+        let range_data_ntf_packet =
+            build_uci_packet(mt, pbf_set, gid_session, oid_session_ntf, payload_range_dat);
         let (mut uci_manager, mut mock_hal) = setup_uci_manager_with_open_hal(
             |_| async move {},
             UciLoggerMode::Disabled,
@@ -1772,7 +1819,7 @@ mod tests {
         )
         .await;
 
-        let (session_notification_sender, mut session_notification_receiver)  =
+        let (session_notification_sender, mut session_notification_receiver) =
             mpsc::unbounded_channel::<SessionNotification>();
         uci_manager.set_session_notification_sender(session_notification_sender).await;
         let result = mock_hal.receive_packet(range_data_ntf_packet);
@@ -1786,7 +1833,7 @@ mod tests {
             uwb_uci_packets::CoreNotification::try_from(device_status_ntf_packet).unwrap();
         let expected_uci_notification = CoreNotification::try_from(core_notification).unwrap();
 
-        let (core_notification_sender, mut core_notification_receiver)  =
+        let (core_notification_sender, mut core_notification_receiver) =
             mpsc::unbounded_channel::<CoreNotification>();
         uci_manager.set_core_notification_sender(core_notification_sender).await;
 
@@ -2195,6 +2242,57 @@ mod tests {
     }
 
     #[tokio::test]
+    async fn test_session_data_transfer_phase_config_ok() {
+        let session_id = 0x123;
+        let session_token = 0x123;
+        let dtpcm_repetition = 0x00;
+        let data_transfer_control = 0x00;
+        let dtpml_size = 0x02;
+        let mac_address = vec![0x22, 0x11, 0x44, 0x33];
+        let slot_bitmap = vec![0xF0, 0x0F];
+        let mac_address_clone = mac_address.clone();
+        let slot_bitmap_clone = slot_bitmap.clone();
+
+        let (uci_manager, mut mock_hal) = setup_uci_manager_with_session_active(
+            |mut hal| async move {
+                let cmd = UciCommand::SessionDataTransferPhaseConfig {
+                    session_token,
+                    dtpcm_repetition,
+                    data_transfer_control,
+                    dtpml_size,
+                    mac_address,
+                    slot_bitmap,
+                };
+                let resp = into_uci_hal_packets(
+                    uwb_uci_packets::SessionDataTransferPhaseConfigRspBuilder {
+                        status: uwb_uci_packets::StatusCode::UciStatusOk,
+                    },
+                );
+
+                hal.expected_send_command(cmd, resp, Ok(()));
+            },
+            UciLoggerMode::Disabled,
+            mpsc::unbounded_channel::<UciLogEvent>().0,
+            session_id,
+            session_token,
+        )
+        .await;
+
+        let result = uci_manager
+            .session_data_transfer_phase_config(
+                session_token,
+                dtpcm_repetition,
+                data_transfer_control,
+                dtpml_size,
+                mac_address_clone,
+                slot_bitmap_clone,
+            )
+            .await;
+        assert!(result.is_ok());
+        assert!(mock_hal.wait_expected_calls_done().await);
+    }
+
+    #[tokio::test]
     async fn test_session_get_app_config_ok() {
         let session_id = 0x123;
         let session_token = 0x123;
diff --git a/src/rust/uwb_core/src/uci/uci_manager_sync.rs b/src/rust/uwb_core/src/uci/uci_manager_sync.rs
index 27a213b..3231956 100644
--- a/src/rust/uwb_core/src/uci/uci_manager_sync.rs
+++ b/src/rust/uwb_core/src/uci/uci_manager_sync.rs
@@ -432,6 +432,26 @@ impl<U: UciManager> UciManagerSync<U> {
             phase_list,
         ))
     }
+
+    /// Send UCI command for session data transfer phase config
+    pub fn session_data_transfer_phase_config(
+        &self,
+        session_id: SessionId,
+        dtpcm_repetition: u8,
+        data_transfer_control: u8,
+        dtpml_size: u8,
+        mac_address: Vec<u8>,
+        slot_bitmap: Vec<u8>,
+    ) -> Result<()> {
+        self.runtime_handle.block_on(self.uci_manager.session_data_transfer_phase_config(
+            session_id,
+            dtpcm_repetition,
+            data_transfer_control,
+            dtpml_size,
+            mac_address,
+            slot_bitmap,
+        ))
+    }
 }
 
 impl UciManagerSync<UciManagerImpl> {
diff --git a/src/rust/uwb_uci_packets/src/lib.rs b/src/rust/uwb_uci_packets/src/lib.rs
index 40b5f6e..eed65a8 100644
--- a/src/rust/uwb_uci_packets/src/lib.rs
+++ b/src/rust/uwb_uci_packets/src/lib.rs
@@ -891,6 +891,59 @@ pub fn build_session_update_controller_multicast_list_cmd(
     .build())
 }
 
+/// building Data transfer phase config command
+pub fn build_data_transfer_phase_config_cmd(
+    session_token: u32,
+    dtpcm_repetition: u8,
+    data_transfer_control: u8,
+    dtpml_size: u8,
+    mac_address: Vec<u8>,
+    slot_bitmap: Vec<u8>,
+) -> Result<SessionDataTransferPhaseConfigCmd> {
+    let mut dtpml_buffer = BytesMut::new();
+
+    //calculate mac address mode from data transfer control
+    let mac_address_mode = data_transfer_control & 0x01;
+
+    // Calculate mac address size based on address mode
+    let mac_address_size = match mac_address_mode {
+        SHORT_ADDRESS => 2,
+        EXTENDED_ADDRESS => 8,
+        _ => return Err(Error::InvalidPacketError),
+    };
+
+    // Calculate slot bitmap size from data transfer control
+    let slot_bitmap_size = 1 << ((data_transfer_control & 0x0F) >> 1);
+
+    // Prepare segmented vectors for mac_address
+    let mac_address_vec: Vec<_> =
+        mac_address.chunks(mac_address_size).map(|chunk| chunk.to_owned()).collect();
+
+    // Prepare segmented vectors for slot_bitmap
+    let slot_bitmap_vec: Vec<_> =
+        slot_bitmap.chunks(slot_bitmap_size).map(|chunk| chunk.to_owned()).collect();
+
+    // Validate sizes of mac_address and slot_bitmap
+    if slot_bitmap_vec.len() != dtpml_size.into() || mac_address_vec.len() != dtpml_size.into() {
+        return Err(Error::InvalidPacketError);
+    }
+
+    // Combine segmented vectors into dtpml_buffer
+    for (elem1, elem2) in mac_address_vec.into_iter().zip(slot_bitmap_vec.into_iter()) {
+        dtpml_buffer.extend_from_slice(&elem1);
+        dtpml_buffer.extend_from_slice(&elem2);
+    }
+
+    Ok(SessionDataTransferPhaseConfigCmdBuilder {
+        session_token,
+        dtpcm_repetition,
+        data_transfer_control,
+        dtpml_size,
+        payload: Some(dtpml_buffer.freeze()),
+    }
+    .build())
+}
+
 impl Drop for AppConfigTlv {
     fn drop(&mut self) {
         if self.cfg_id == AppConfigTlvType::VendorId || self.cfg_id == AppConfigTlvType::StaticStsIv
diff --git a/src/rust/uwb_uci_packets/uci_packets.pdl b/src/rust/uwb_uci_packets/uci_packets.pdl
index 1283a52..3c80f87 100644
--- a/src/rust/uwb_uci_packets/uci_packets.pdl
+++ b/src/rust/uwb_uci_packets/uci_packets.pdl
@@ -67,6 +67,7 @@ enum SessionConfigOpCode : 6 {
     SESSION_SET_INITIATOR_DT_ANCHOR_RR_RDM_LIST = 0x0a,
     SESSION_QUERY_DATA_SIZE_IN_RANGING = 0x0b,
     SESSION_SET_HUS_CONFIG = 0x0c,
+    SESSION_DATA_TRANSFER_PHASE_CONFIGURATION = 0x0e,
 }
 
 enum SessionControlOpCode : 6 {
@@ -179,6 +180,12 @@ enum DataTransferNtfStatusCode : 8 {
     UCI_DATA_TRANSFER_STATUS_INVALID_FORMAT = 0x07,
 }
 
+// The UCI spec defines these status codes for a SESSION_DATA_TRANSFER_PHASE_CONFIG_NTF packet.
+enum DataTransferPhaseConfigUpdateStatusCode : 8 {
+    UCI_DTPCM_CONFIG_SUCCESS_STATUS_OK = 0x00,
+    UCI_DTPCM_STATUS_ERROR_DUPLICATE_SLOT_ASSIGMENT = 0x01,
+}
+
 enum ResetConfig : 8 {
     UWBS_RESET = 0x00,
 }
@@ -1060,6 +1067,27 @@ test SessionQueryMaxDataSizeRsp {
   "\x41\x0B\x00\x06\x00\x00\x00\x00\x00\x0E7\0x07",
 }
 
+packet SessionDataTransferPhaseConfigCmd : SessionConfigCommand (opcode = 0x0e) { //SESSION_DATA_TRANSFER_PHASE_CONFIGURATION
+    session_token: 32, // Session ID or Session Handle (based on UWBS version)
+    dtpcm_repetition: 8,
+    data_transfer_control: 8,
+    dtpml_size: 8,
+    _payload_,
+}
+
+packet SessionDataTransferPhaseConfigRsp : SessionConfigResponse (opcode = 0x0e) { //SESSION_DATA_TRANSFER_PHASE_CONFIGURATION
+    status: StatusCode,
+}
+
+packet SessionDataTransferPhaseConfigNtf : SessionConfigNotification (opcode = 0x0e) { //SESSION_DATA_TRANSFER_PHASE_CONFIGURATION
+    session_token: 32, // Session ID or Session Handle (based on UWBS version)
+    status: DataTransferPhaseConfigUpdateStatusCode,
+}
+
+test SessionDataTransferPhaseConfigNtf {
+    "\x61\x0E\x00\x05\x00\x00\x00\x00\x00"
+}
+
 packet SessionStartCmd : SessionControlCommand (opcode = 0x0) { //RANGE_START
     session_token: 32, // Session ID or Session Handle (based on UWBS version)
 }