feat(ble/bluedroid): add Frame Space Update host support (Core 6.0)

Co-authored-by: Cursor <cursoragent@cursor.com>


(cherry picked from commit 5372ce03a3)

Co-authored-by: zhiweijian <zhiweijian@espressif.com>

components/bt/host/bluedroid/Kconfig.in

@@ -1647,6 +1647,13 @@ config BT_BLE_FEAT_DBAF
         Enable Decision-Based Advertising Filtering (Bluetooth Core 6.0).
         Supports LE Set Decision Data and LE Set Decision Instructions HCI commands.
 
+config BT_BLE_FEAT_FRAME_SPACE_UPDATE
+    bool "Enable BLE Frame Space Update"
+    depends on (BT_BLE_50_FEATURES_SUPPORTED && ((BT_CONTROLLER_ENABLED && SOC_BLE_FRAME_SPACE_SUPPORTED) || BT_CONTROLLER_DISABLED)) # NOERROR
+    default n
+    help
+        Enable Frame Space Update feature (Bluetooth Core 6.0).
+
 menuconfig BT_BLE_42_FEATURES_SUPPORTED
     bool "Enable BLE 4.2 features(please disable BLE 5.0 if enable BLE 4.2)"
     depends on BT_BLE_ENABLED

components/bt/host/bluedroid/api/esp_gap_ble_api.c

@@ -2019,6 +2019,43 @@ esp_err_t esp_ble_gap_set_decision_instructions(const esp_ble_gap_set_decision_i
 }
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+esp_err_t esp_ble_gap_frame_space_update(const esp_ble_gap_frame_space_update_params_t *params)
+{
+    btc_msg_t msg = {0};
+    btc_ble_5_gap_args_t arg;
+    memset(&arg, 0, sizeof(arg));
+
+    ESP_BLUEDROID_STATUS_CHECK(ESP_BLUEDROID_STATUS_ENABLED);
+    if (params == NULL) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    if (params->frame_space_min > ESP_BLE_GAP_FRAME_SPACE_MAX_US ||
+        params->frame_space_max > ESP_BLE_GAP_FRAME_SPACE_MAX_US ||
+        params->frame_space_min > params->frame_space_max) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    if ((params->phys & ~ESP_BLE_GAP_FRAME_SPACE_PHY_MASK) != 0 || params->phys == 0) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    if ((params->spacing_types & ~ESP_BLE_GAP_FRAME_SPACE_SPACING_MASK) != 0 ||
+        params->spacing_types == 0) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    msg.sig = BTC_SIG_API_CALL;
+    msg.pid = BTC_PID_GAP_BLE;
+    msg.act = BTC_GAP_BLE_FRAME_SPACE_UPDATE;
+    arg.frame_space_update.conn_handle = params->conn_handle;
+    arg.frame_space_update.frame_space_min = params->frame_space_min;
+    arg.frame_space_update.frame_space_max = params->frame_space_max;
+    arg.frame_space_update.phys = params->phys;
+    arg.frame_space_update.spacing_types = params->spacing_types;
+
+    return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_5_gap_args_t), NULL, NULL)
+            == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
+}
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/api/include/api/esp_gap_ble_api.h

@@ -275,6 +275,7 @@ typedef enum {
     ESP_GAP_BLE_ENABLE_MONITOR_ADV_COMPLETE_EVT,                 /*!< When enable/disable monitor advertising complete, the event comes */
     ESP_GAP_BLE_SET_DECISION_DATA_COMPLETE_EVT,                  /*!< When set decision data complete, the event comes */
     ESP_GAP_BLE_SET_DECISION_INSTRUCTIONS_COMPLETE_EVT,          /*!< When set decision instructions complete, the event comes */
+    ESP_GAP_BLE_FRAME_SPACE_UPDATE_COMPLETE_EVT,                 /*!< When frame space update complete, the event comes */
     ESP_GAP_BLE_EVT_MAX,                                         /*!< when maximum advertising event complete, the event comes */
 } esp_gap_ble_cb_event_t;
 
@@ -1289,6 +1290,41 @@ typedef struct {
 } esp_ble_gap_set_decision_instructions_params_t;
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+#define ESP_BLE_GAP_FRAME_SPACE_MAX_US                  10000
+#define ESP_BLE_GAP_FRAME_SPACE_PHY_1M_MASK             (1 << 0)
+#define ESP_BLE_GAP_FRAME_SPACE_PHY_2M_MASK             (1 << 1)
+#define ESP_BLE_GAP_FRAME_SPACE_PHY_CODED_MASK          (1 << 2)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_ACL_CP_MASK (1 << 0)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_ACL_PC_MASK (1 << 1)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_MCES_MASK       (1 << 2)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_CIS_MASK    (1 << 3)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_MSS_CIS_MASK    (1 << 4)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_ACL_IFS_MASK    \
+    (ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_ACL_CP_MASK | ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_ACL_PC_MASK)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_ACL_MASK        \
+    (ESP_BLE_GAP_FRAME_SPACE_SPACING_ACL_IFS_MASK | ESP_BLE_GAP_FRAME_SPACE_SPACING_MCES_MASK)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_CIS_MASK        \
+    (ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_CIS_MASK | ESP_BLE_GAP_FRAME_SPACE_SPACING_MSS_CIS_MASK)
+#define ESP_BLE_GAP_FRAME_SPACE_PHY_MASK                \
+    (ESP_BLE_GAP_FRAME_SPACE_PHY_1M_MASK | ESP_BLE_GAP_FRAME_SPACE_PHY_2M_MASK | \
+     ESP_BLE_GAP_FRAME_SPACE_PHY_CODED_MASK)
+#define ESP_BLE_GAP_FRAME_SPACE_SPACING_MASK            \
+    (ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_ACL_CP_MASK | ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_ACL_PC_MASK | \
+     ESP_BLE_GAP_FRAME_SPACE_SPACING_MCES_MASK | ESP_BLE_GAP_FRAME_SPACE_SPACING_IFS_CIS_MASK | \
+     ESP_BLE_GAP_FRAME_SPACE_SPACING_MSS_CIS_MASK)
+
+/**
+ * @brief Parameters for requesting a Frame Space Update on a connection
+ */
+typedef struct {
+    uint16_t conn_handle;            /*!< Connection handle */
+    uint16_t frame_space_min;        /*!< Minimum frame space in microseconds, max: ESP_BLE_GAP_FRAME_SPACE_MAX_US */
+    uint16_t frame_space_max;        /*!< Maximum frame space in microseconds, max: ESP_BLE_GAP_FRAME_SPACE_MAX_US */
+    uint8_t phys;                    /*!< PHY mask (ESP_BLE_GAP_FRAME_SPACE_PHY_*_MASK) */
+    uint16_t spacing_types;          /*!< Spacing types mask (ESP_BLE_GAP_FRAME_SPACE_SPACING_*_MASK) */
+} esp_ble_gap_frame_space_update_params_t;
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 
@@ -2261,6 +2297,19 @@ typedef union {
         esp_bt_status_t status;              /*!< Indicate set decision instructions operation success status */
     } set_decision_instructions;             /*!< Event parameter of ESP_GAP_BLE_SET_DECISION_INSTRUCTIONS_COMPLETE_EVT */
 #endif // #if (BLE_FEAT_DBAF == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    /**
+     * @brief ESP_GAP_BLE_FRAME_SPACE_UPDATE_COMPLETE_EVT
+     */
+    struct ble_frame_space_update_cmpl_param {
+        esp_bt_status_t status;              /*!< Indicate frame space update operation success status */
+        uint16_t conn_handle;                /*!< Connection handle */
+        uint8_t initiator;                   /*!< 0x00: Local Host initiated, 0x01: Local Controller initiated, 0x02: Peer initiated */
+        uint16_t frame_space;                /*!< Updated frame space in microseconds */
+        uint8_t phys;                        /*!< PHY mask updated */
+        uint16_t spacing_types;              /*!< Spacing types mask updated */
+    } frame_space_update;                    /*!< Event parameter of ESP_GAP_BLE_FRAME_SPACE_UPDATE_COMPLETE_EVT */
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
     /**
      * @brief ESP_GAP_BLE_CHANNEL_SELECT_ALGORITHM_EVT
      */
@@ -4147,6 +4196,18 @@ esp_err_t esp_ble_gap_set_decision_data(const esp_ble_gap_set_decision_data_para
 esp_err_t esp_ble_gap_set_decision_instructions(const esp_ble_gap_set_decision_instructions_params_t *params);
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+/**
+* @brief           Request a Frame Space Update on a connection.
+*
+* @param[in]       params : Pointer to frame space update parameters.
+*
+* @return            - ESP_OK : success
+*                    - other  : failed
+*
+*/
+esp_err_t esp_ble_gap_frame_space_update(const esp_ble_gap_frame_space_update_params_t *params);
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/bta/dm/bta_dm_act.c

@@ -6012,6 +6012,16 @@ void bta_dm_ble_gap_set_decision_instructions(tBTA_DM_MSG *p_data)
 }
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+void bta_dm_ble_gap_frame_space_update(tBTA_DM_MSG *p_data)
+{
+    BTM_BleFrameSpaceUpdate(p_data->ble_frame_space_update.conn_handle,
+                            p_data->ble_frame_space_update.frame_space_min,
+                            p_data->ble_frame_space_update.frame_space_max,
+                            p_data->ble_frame_space_update.phys,
+                            p_data->ble_frame_space_update.spacing_types);
+}
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/bta/dm/bta_dm_api.c

@@ -3305,6 +3305,26 @@ void BTA_DmBleGapSetDecisionInstructions(UINT8 num_tests, const UINT8 *test_flag
 }
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+void BTA_DmBleGapFrameSpaceUpdate(UINT16 conn_handle, UINT16 frame_space_min,
+                                  UINT16 frame_space_max, UINT8 phys, UINT16 spacing_types)
+{
+    tBTA_DM_API_FRAME_SPACE_UPDATE *p_msg;
+    APPL_TRACE_API("%s", __func__);
+    if ((p_msg = (tBTA_DM_API_FRAME_SPACE_UPDATE *) osi_malloc(sizeof(tBTA_DM_API_FRAME_SPACE_UPDATE))) != NULL) {
+        memset(p_msg, 0, sizeof(tBTA_DM_API_FRAME_SPACE_UPDATE));
+        p_msg->hdr.event = BTA_DM_API_FRAME_SPACE_UPDATE_EVT;
+        p_msg->conn_handle = conn_handle;
+        p_msg->frame_space_min = frame_space_min;
+        p_msg->frame_space_max = frame_space_max;
+        p_msg->phys = phys;
+        p_msg->spacing_types = spacing_types;
+        bta_sys_sendmsg(p_msg);
+    } else {
+        APPL_TRACE_ERROR("%s malloc failed", __func__);
+    }
+}
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/bta/dm/bta_dm_main.c

@@ -332,6 +332,9 @@ const tBTA_DM_ACTION bta_dm_action[BTA_DM_MAX_EVT] = {
     bta_dm_ble_gap_set_decision_data,                 /* BTA_DM_API_SET_DECISION_DATA_EVT */
     bta_dm_ble_gap_set_decision_instructions,         /* BTA_DM_API_SET_DECISION_INSTRUCTIONS_EVT */
 #endif // #if (BLE_FEAT_DBAF == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    bta_dm_ble_gap_frame_space_update,                /* BTA_DM_API_FRAME_SPACE_UPDATE_EVT */
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 };
 
 

components/bt/host/bluedroid/bta/dm/include/bta_dm_int.h

@@ -326,6 +326,9 @@ enum {
     BTA_DM_API_SET_DECISION_DATA_EVT,
     BTA_DM_API_SET_DECISION_INSTRUCTIONS_EVT,
 #endif // #if (BLE_FEAT_DBAF == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    BTA_DM_API_FRAME_SPACE_UPDATE_EVT,
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
     BTA_DM_MAX_EVT
 };
 
@@ -1400,6 +1403,16 @@ typedef struct {
 } tBTA_DM_API_SET_DECISION_INSTRUCTIONS;
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+typedef struct {
+    BT_HDR                          hdr;
+    UINT16                          conn_handle;
+    UINT16                          frame_space_min;
+    UINT16                          frame_space_max;
+    UINT8                           phys;
+    UINT16                          spacing_types;
+} tBTA_DM_API_FRAME_SPACE_UPDATE;
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 
@@ -1844,6 +1857,9 @@ typedef union {
     tBTA_DM_API_SET_DECISION_DATA       ble_set_decision_data;
     tBTA_DM_API_SET_DECISION_INSTRUCTIONS ble_set_decision_instructions;
 #endif // #if (BLE_FEAT_DBAF == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    tBTA_DM_API_FRAME_SPACE_UPDATE      ble_frame_space_update;
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 #if (BLE_42_DTM_TEST_EN == TRUE)
     tBTA_DM_API_BLE_DTM_TX_START    dtm_tx_start;
     tBTA_DM_API_BLE_DTM_RX_START    dtm_rx_start;
@@ -2528,6 +2544,9 @@ extern void bta_dm_ble_gap_set_decision_data(tBTA_DM_MSG *p_data);
 extern void bta_dm_ble_gap_set_decision_instructions(tBTA_DM_MSG *p_data);
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+extern void bta_dm_ble_gap_frame_space_update(tBTA_DM_MSG *p_data);
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/bta/include/bta/bta_api.h

@@ -1610,6 +1610,9 @@ typedef struct {
 #define BTA_DM_BLE_5_GAP_SET_DECISION_INSTRUCTIONS_COMPLETE_EVT    BTM_BLE_5_GAP_SET_DECISION_INSTRUCTIONS_COMPLETE_EVT
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+#define BTA_DM_BLE_5_GAP_FRAME_SPACE_UPDATE_COMPLETE_EVT           BTM_BLE_5_GAP_FRAME_SPACE_UPDATE_COMPLETE_EVT
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 
@@ -3074,10 +3077,13 @@ extern void BTA_DmBleGapEnableMonitorAdv(UINT8 enable);
 extern void BTA_DmBleGapSetDecisionData(UINT8 adv_handle, UINT8 decision_type_flags,
                                         UINT8 data_len, const UINT8 *p_data);
 extern void BTA_DmBleGapSetDecisionInstructions(UINT8 num_tests, const UINT8 *test_flags,
-                                                const UINT8 *test_fields, UINT8 test_params_len,
+                                                const UINT8 *test_fields, const UINT8 *test_params);
-                                                const UINT8 *test_params);
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+extern void BTA_DmBleGapFrameSpaceUpdate(UINT16 conn_handle, UINT16 frame_space_min,
+                                         UINT16 frame_space_max, UINT8 phys, UINT16 spacing_types);
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/btc/profile/std/gap/btc_gap_ble.c

@@ -1295,6 +1295,18 @@ void btc_ble_5_gap_callback(tBTA_DM_BLE_5_GAP_EVENT event,
             break;
         }
 #endif // #if (BLE_FEAT_DBAF == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+        case BTA_DM_BLE_5_GAP_FRAME_SPACE_UPDATE_COMPLETE_EVT: {
+            msg.act = ESP_GAP_BLE_FRAME_SPACE_UPDATE_COMPLETE_EVT;
+            param.frame_space_update.status = btc_btm_status_to_esp_status(params->frame_space_update.status);
+            param.frame_space_update.conn_handle = params->frame_space_update.conn_handle;
+            param.frame_space_update.initiator = params->frame_space_update.initiator;
+            param.frame_space_update.frame_space = params->frame_space_update.frame_space;
+            param.frame_space_update.phys = params->frame_space_update.phys;
+            param.frame_space_update.spacing_types = params->frame_space_update.spacing_types;
+            break;
+        }
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 #if (BLE_50_EXTEND_ADV_EN == TRUE)
         case BTA_DM_BLE_5_GAP_ADV_TERMINATED_EVT: {
             param.adv_terminate.status = params->adv_term.status;
@@ -3545,6 +3557,15 @@ void btc_gap_ble_call_handler(btc_msg_t *msg)
                                             arg_5->set_decision_instructions.test_params);
         break;
 #endif // #if (BLE_FEAT_DBAF == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    case BTC_GAP_BLE_FRAME_SPACE_UPDATE:
+        BTA_DmBleGapFrameSpaceUpdate(arg_5->frame_space_update.conn_handle,
+                                     arg_5->frame_space_update.frame_space_min,
+                                     arg_5->frame_space_update.frame_space_max,
+                                     arg_5->frame_space_update.phys,
+                                     arg_5->frame_space_update.spacing_types);
+        break;
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 #if (BT_BLE_FEAT_PAWR_EN == TRUE)
     case BTC_GAP_BLE_SET_PA_SUBEVT_DATA:
         BTA_DmBleGapSetPASubevtData(arg_5->per_adv_subevent_data_params.adv_handle, arg_5->per_adv_subevent_data_params.num_subevents_with_data, (uint8_t *)(arg_5->per_adv_subevent_data_params.subevent_params));

components/bt/host/bluedroid/btc/profile/std/include/btc_gap_ble.h

@@ -151,6 +151,9 @@ typedef enum {
     BTC_GAP_BLE_SET_DECISION_DATA,
     BTC_GAP_BLE_SET_DECISION_INSTRUCTIONS,
 #endif // #if (BLE_FEAT_DBAF == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    BTC_GAP_BLE_FRAME_SPACE_UPDATE,
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
     BTC_GAP_BLE_READ_CHANNEL_MAP,
 #if (BT_BLE_FEAT_PAWR_EN == TRUE)
     BTC_GAP_BLE_SET_PA_SUBEVT_DATA,
@@ -606,6 +609,15 @@ typedef union {
         uint8_t *test_params;
     } set_decision_instructions;
 #endif // #if (BLE_FEAT_DBAF == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    struct frame_space_update_args {
+        uint16_t conn_handle;
+        uint16_t frame_space_min;
+        uint16_t frame_space_max;
+        uint8_t phys;
+        uint16_t spacing_types;
+    } frame_space_update;
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 #if (BT_BLE_FEAT_PAWR_EN == TRUE)
     // BTC_GAP_BLE_SET_PA_SUBEVT_DATA
     struct per_adv_subevent_data_params_args {

components/bt/host/bluedroid/common/include/common/bluedroid_user_config.h

@@ -420,6 +420,13 @@
 #define UC_BT_BLE_FEAT_ADV_MONITOR            FALSE
 #endif
 
+#ifdef CONFIG_BT_BLE_FEAT_FRAME_SPACE_UPDATE
+#define UC_BT_BLE_FEAT_FRAME_SPACE_UPDATE            CONFIG_BT_BLE_FEAT_FRAME_SPACE_UPDATE
+#else
+#define UC_BT_BLE_FEAT_FRAME_SPACE_UPDATE            FALSE
+#endif
+
+
 #ifdef CONFIG_BT_BLE_FEAT_DBAF
 #define UC_BT_BLE_FEAT_DBAF            CONFIG_BT_BLE_FEAT_DBAF
 #else

components/bt/host/bluedroid/common/include/common/bt_target.h

@@ -462,6 +462,11 @@
 #define BLE_FEAT_DBAF     FALSE
 #endif
 
+#if (BLE_50_FEATURE_SUPPORT == TRUE) && (UC_BT_BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+#define BLE_FEAT_FRAME_SPACE_UPDATE     TRUE
+#else
+#define BLE_FEAT_FRAME_SPACE_UPDATE     FALSE
+#endif
 
 
 

components/bt/host/bluedroid/stack/btm/btm_ble_5_gap.c

@@ -1378,6 +1378,55 @@ tBTM_STATUS BTM_BleSetDecisionInstructions(UINT8 num_tests, const UINT8 *test_fl
 }
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+tBTM_STATUS BTM_BleFrameSpaceUpdate(UINT16 conn_handle, UINT16 frame_space_min,
+                                    UINT16 frame_space_max, UINT8 phys, UINT16 spacing_types)
+{
+    tHCI_STATUS err;
+
+    err = btsnd_hcic_ble_frame_space_update(conn_handle, frame_space_min, frame_space_max,
+                                            phys, spacing_types);
+    if (err != HCI_SUCCESS) {
+        tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
+        cb_params.frame_space_update.status = BTM_HCI_ERROR | err;
+        cb_params.frame_space_update.conn_handle = conn_handle;
+        BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_FRAME_SPACE_UPDATE_COMPLETE_EVT, &cb_params);
+        return BTM_NO_RESOURCES;
+    }
+    return BTM_CMD_STARTED;
+}
+
+void btm_frame_space_update_cmd_status(UINT8 status, UINT16 conn_handle)
+{
+    tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
+
+    if (status == HCI_SUCCESS) {
+        return;
+    }
+
+    cb_params.frame_space_update.status = status | BTM_HCI_ERROR;
+    cb_params.frame_space_update.conn_handle = conn_handle;
+    BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_FRAME_SPACE_UPDATE_COMPLETE_EVT, &cb_params);
+}
+
+void btm_ble_frame_space_update_complete_evt(UINT8 *p)
+{
+    tBTM_BLE_5_GAP_CB_PARAMS cb_params = {0};
+
+    STREAM_TO_UINT8(cb_params.frame_space_update.status, p);
+    STREAM_TO_UINT16(cb_params.frame_space_update.conn_handle, p);
+    STREAM_TO_UINT8(cb_params.frame_space_update.initiator, p);
+    STREAM_TO_UINT16(cb_params.frame_space_update.frame_space, p);
+    STREAM_TO_UINT8(cb_params.frame_space_update.phys, p);
+    STREAM_TO_UINT16(cb_params.frame_space_update.spacing_types, p);
+
+    if (cb_params.frame_space_update.status != HCI_SUCCESS) {
+        cb_params.frame_space_update.status |= BTM_HCI_ERROR;
+    }
+
+    BTM_ExtBleCallbackTrigger(BTM_BLE_5_GAP_FRAME_SPACE_UPDATE_COMPLETE_EVT, &cb_params);
+}
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/stack/btm/include/btm_ble_int.h

@@ -592,6 +592,9 @@ void btm_ble_transmit_power_report_evt(tBTM_BLE_TRANS_POWER_REPORT_EVT *params);
 #if (BLE_FEAT_CONN_SUBRATING == TRUE)
 void btm_ble_subrate_change_evt(tBTM_BLE_SUBRATE_CHANGE_EVT *params);
 #endif // #if (BLE_FEAT_CONN_SUBRATING == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+void btm_ble_frame_space_update_complete_evt(UINT8 *p);
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 #if (BT_BLE_FEAT_PAWR_EN == TRUE)
 void btm_ble_pa_subevt_data_req_evt(tBTM_BLE_PA_SUBEVT_DATA_REQ_EVT *params);
 void btm_ble_pa_rsp_rpt_evt(tBTM_BLE_PA_RSP_REPORT_EVT *params);

components/bt/host/bluedroid/stack/btm/include/btm_int.h

@@ -1201,6 +1201,9 @@ void btm_read_remote_trans_pwr_level_cmpl(UINT8 status);
 void btm_subrate_req_cmd_status(UINT8 status);
 #endif // #if (BLE_FEAT_CONN_SUBRATING == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+void btm_frame_space_update_cmd_status(UINT8 status, UINT16 conn_handle);
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 #if (BT_BLE_FEAT_CHANNEL_SOUNDING == TRUE)
 void btm_ble_cs_read_local_supp_caps_cmpl_evt(UINT8 *p);

components/bt/host/bluedroid/stack/btu/btu_hcif.c

@@ -174,6 +174,18 @@ static void btu_ble_ext_adv_report_evt(UINT8 *p, UINT16 evt_len);
 #if (BLE_FEAT_ADV_MONITOR == TRUE)
 static void btu_ble_monitor_adv_report_evt(UINT8 *p);
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
+#if (BLE_FEAT_LL_EXT_FEAT == TRUE)
+static void btu_ble_read_all_remote_feat_complete_evt(UINT8 *p);
+#endif // #if (BLE_FEAT_LL_EXT_FEAT == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+static void btu_ble_frame_space_update_complete_evt(UINT8 *p);
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+#if (BLE_FEAT_LE_UTP == TRUE)
+static void btu_ble_utp_receive_evt(UINT8 *p, UINT16 evt_len);
+#endif // #if (BLE_FEAT_LE_UTP == TRUE)
+#if (BLE_FEAT_SHORTER_CONN_INTERVALS == TRUE)
+static void btu_ble_conn_rate_change_evt(UINT8 *p);
+#endif // #if (BLE_FEAT_SHORTER_CONN_INTERVALS == TRUE)
 #if (BLE_50_EXTEND_SYNC_EN == TRUE)
 static void btu_ble_periodic_adv_sync_establish_evt(UINT8 *p, bool v2_evt);
 static void btu_ble_periodic_adv_report_evt(UINT8 *p, UINT8 evt_len, bool v2_evt);
@@ -560,6 +572,16 @@ void btu_hcif_process_event (UNUSED_ATTR UINT8 controller_id, BT_HDR *p_msg)
             btu_ble_monitor_adv_report_evt(p);
             break;
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
+#if (BLE_FEAT_LL_EXT_FEAT == TRUE)
+        case HCI_BLE_READ_ALL_REMOTE_FEAT_COMPLETE_EVT:
+            btu_ble_read_all_remote_feat_complete_evt(p);
+            break;
+#endif // #if (BLE_FEAT_LL_EXT_FEAT == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+        case HCI_BLE_FRAME_SPACE_UPDATE_COMPLETE_EVT:
+            btu_ble_frame_space_update_complete_evt(p);
+            break;
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
         case HCI_BLE_PERIOD_ADV_SYNC_TRANS_RECV_EVT:
             btu_ble_periodic_adv_sync_trans_recv(p);
@@ -629,6 +651,16 @@ void btu_hcif_process_event (UNUSED_ATTR UINT8 controller_id, BT_HDR *p_msg)
             btu_ble_subrate_change_evt(p);
             break;
 #endif // #if (BLE_FEAT_CONN_SUBRATING == TRUE)
+#if (BLE_FEAT_LE_UTP == TRUE)
+        case HCI_BLE_UTP_RECEIVE_EVT:
+            btu_ble_utp_receive_evt(p, hci_evt_len);
+            break;
+#endif // #if (BLE_FEAT_LE_UTP == TRUE)
+#if (BLE_FEAT_SHORTER_CONN_INTERVALS == TRUE)
+        case HCI_BLE_CONN_RATE_CHANGE_EVT:
+            btu_ble_conn_rate_change_evt(p);
+            break;
+#endif // #if (BLE_FEAT_SHORTER_CONN_INTERVALS == TRUE)
 #if (BT_BLE_FEAT_PAWR_EN == TRUE)
         case HCI_BLE_PA_SUBEVT_DATA_REQUEST_EVT:
             btu_ble_pa_subevt_data_request_evt(p);
@@ -1483,6 +1515,16 @@ static void btu_hcif_hdl_command_complete (UINT16 opcode, UINT8 *p, UINT16 evt_l
         btm_ble_read_monitor_adv_list_size_complete(p);
         break;
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
+#if (BLE_FEAT_LL_EXT_FEAT == TRUE)
+    case HCI_BLE_READ_ALL_LOCAL_SUPP_FEATURES:
+        btm_ble_read_all_local_supp_features_complete(p);
+        break;
+#endif // #if (BLE_FEAT_LL_EXT_FEAT == TRUE)
+#if (BLE_FEAT_SHORTER_CONN_INTERVALS == TRUE)
+    case HCI_BLE_READ_MIN_SUPP_CONN_INTERVAL:
+        btm_ble_read_min_supp_conn_interval_complete(p);
+        break;
+#endif // #if (BLE_FEAT_SHORTER_CONN_INTERVALS == TRUE)
 #endif /* (BLE_INCLUDED == TRUE) */
 
     default: {
@@ -1652,6 +1694,18 @@ static void btu_hcif_hdl_command_status (UINT16 opcode, UINT8 status, UINT8 *p_c
         btm_subrate_req_cmd_status(status);
         break;
 #endif // #if (BLE_FEAT_CONN_SUBRATING == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    case HCI_BLE_FRAME_SPACE_UPDATE:
+    {
+        UINT16 conn_handle = HCI_INVALID_HANDLE;
+        if (p_cmd != NULL) {
+            p_cmd++; /* skip param length */
+            STREAM_TO_UINT16(conn_handle, p_cmd);
+        }
+        btm_frame_space_update_cmd_status(status, conn_handle);
+        break;
+    }
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 #if (BT_BLE_FEAT_CHANNEL_SOUNDING == TRUE)
     case HCI_BLE_CS_READ_REMOTE_SUPP_CAPS:
         btm_ble_cs_read_remote_supp_caps_cmd_status(status);
@@ -2661,7 +2715,19 @@ static void btu_ble_monitor_adv_report_evt(UINT8 *p)
 }
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
 
+#if (BLE_FEAT_LL_EXT_FEAT == TRUE)
+static void btu_ble_read_all_remote_feat_complete_evt(UINT8 *p)
+{
+    btm_ble_read_all_remote_features_complete_evt(p);
+}
+#endif // #if (BLE_FEAT_LL_EXT_FEAT == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+static void btu_ble_frame_space_update_complete_evt(UINT8 *p)
+{
+    btm_ble_frame_space_update_complete_evt(p);
+}
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 #if (BLE_50_EXTEND_SYNC_EN == TRUE)
 static void btu_ble_periodic_adv_sync_establish_evt(UINT8 *p, bool v2_evt)
@@ -3337,7 +3403,39 @@ static void btu_ble_subrate_change_evt(UINT8 *p)
 }
 #endif // #if (BLE_FEAT_CONN_SUBRATING == TRUE)
 
+#if (BLE_FEAT_SHORTER_CONN_INTERVALS == TRUE)
+static void btu_ble_conn_rate_change_evt(UINT8 *p)
+{
+    tBTM_BLE_CONN_RATE_CHANGE conn_rate_change = {0};
 
+    if (!p) {
+        HCI_TRACE_ERROR("%s, Invalid params.", __func__);
+        return;
+    }
+
+    STREAM_TO_UINT8(conn_rate_change.status, p);
+    STREAM_TO_UINT16(conn_rate_change.conn_handle, p);
+    STREAM_TO_UINT16(conn_rate_change.conn_interval, p);
+    STREAM_TO_UINT16(conn_rate_change.subrate_factor, p);
+    STREAM_TO_UINT16(conn_rate_change.peripheral_latency, p);
+    STREAM_TO_UINT16(conn_rate_change.continuation_number, p);
+    STREAM_TO_UINT16(conn_rate_change.supervision_timeout, p);
+
+    btm_ble_conn_rate_change_evt(&conn_rate_change);
+}
+#endif // #if (BLE_FEAT_SHORTER_CONN_INTERVALS == TRUE)
+
+#if (BLE_FEAT_LE_UTP == TRUE)
+static void btu_ble_utp_receive_evt(UINT8 *p, UINT16 evt_len)
+{
+    if (!p || evt_len < 1) {
+        HCI_TRACE_ERROR("%s, Invalid params.", __func__);
+        return;
+    }
+
+    btm_ble_utp_receive_evt(p, evt_len);
+}
+#endif // #if (BLE_FEAT_LE_UTP == TRUE)
 
 #if (BT_BLE_FEAT_PAWR_EN == TRUE)
 static void btu_ble_pa_subevt_data_request_evt(UINT8 *p)

components/bt/host/bluedroid/stack/hcic/hciblecmds.c

@@ -3123,6 +3123,27 @@ UINT8 btsnd_hcic_ble_set_decision_instructions(UINT8 num_tests, const UINT8 *tes
 }
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+UINT8 btsnd_hcic_ble_frame_space_update(UINT16 conn_handle, UINT16 frame_space_min,
+                                        UINT16 frame_space_max, UINT8 phys, UINT16 spacing_types)
+{
+    BT_HDR *p;
+    UINT8 *pp;
+
+    HCIC_BLE_CMD_CREATED_U8(p, pp, HCIC_PARAM_SIZE_FRAME_SPACE_UPDATE);
+
+    UINT16_TO_STREAM(pp, HCI_BLE_FRAME_SPACE_UPDATE);
+    UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_FRAME_SPACE_UPDATE);
+    UINT16_TO_STREAM(pp, conn_handle);
+    UINT16_TO_STREAM(pp, frame_space_min);
+    UINT16_TO_STREAM(pp, frame_space_max);
+    UINT8_TO_STREAM(pp, phys);
+    UINT16_TO_STREAM(pp, spacing_types);
+
+    btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
+    return HCI_SUCCESS;
+}
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/stack/include/stack/btm_ble_api.h

@@ -978,6 +978,9 @@ typedef void (tBTM_UPDATE_DUPLICATE_EXCEPTIONAL_LIST_CMPL_CBACK) (tBTM_STATUS st
 #define    BTM_BLE_5_GAP_READ_MONITOR_ADV_LIST_SIZE_COMPLETE_EVT   74
 #define    BTM_BLE_5_GAP_ENABLE_MONITOR_ADV_COMPLETE_EVT           75
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+#define    BTM_BLE_5_GAP_FRAME_SPACE_UPDATE_COMPLETE_EVT           78
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 #if (BLE_FEAT_DBAF == TRUE)
 #define    BTM_BLE_5_GAP_SET_DECISION_DATA_COMPLETE_EVT            79
 #define    BTM_BLE_5_GAP_SET_DECISION_INSTRUCTIONS_COMPLETE_EVT    80
@@ -1233,6 +1236,16 @@ typedef struct {
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
 
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+typedef struct {
+    tBTM_STATUS status;
+    UINT16 conn_handle;
+    UINT8 initiator;
+    UINT16 frame_space;
+    UINT8 phys;
+    UINT16 spacing_types;
+} tBTM_BLE_FRAME_SPACE_UPDATE;
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 
@@ -1946,6 +1959,9 @@ typedef union {
     tBTM_BLE_MONITOR_ADV_REPORT                 monitor_adv_report;
     tBTM_BLE_MONITOR_ADV_LIST_SIZE              monitor_adv_list_size;
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+    tBTM_BLE_FRAME_SPACE_UPDATE                 frame_space_update;
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 } tBTM_BLE_5_GAP_CB_PARAMS;
 
 typedef struct {
@@ -3097,10 +3113,13 @@ tBTM_STATUS BTM_BleEnableMonitorAdv(UINT8 enable);
 tBTM_STATUS BTM_BleSetDecisionData(UINT8 adv_handle, UINT8 decision_type_flags,
                                    UINT8 data_len, const UINT8 *p_data);
 tBTM_STATUS BTM_BleSetDecisionInstructions(UINT8 num_tests, const UINT8 *test_flags,
-                                           const UINT8 *test_fields, UINT8 test_params_len,
+                                           const UINT8 *test_fields, const UINT8 *test_params);
-                                           const UINT8 *test_params);
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+tBTM_STATUS BTM_BleFrameSpaceUpdate(UINT16 conn_handle, UINT16 frame_space_min,
+                                    UINT16 frame_space_max, UINT8 phys, UINT16 spacing_types);
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/stack/include/stack/hcidefs.h

@@ -439,6 +439,9 @@
 #define HCI_BLE_ENABLE_MONITOR_ADV           (0x009C | HCI_GRP_BLE_CMDS)
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+#define HCI_BLE_FRAME_SPACE_UPDATE             (0x009D | HCI_GRP_BLE_CMDS)
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 #if (BLE_FEAT_POWER_CONTROL_EN == TRUE)
 #define HCI_BLE_ENH_READ_TRANS_POWER_LEVEL         (0x0076 | HCI_GRP_BLE_CMDS)
@@ -985,6 +988,9 @@
 #define HCI_BLE_MONITOR_ADV_REPORT_EVT         0x34
 #endif // #if (BLE_FEAT_ADV_MONITOR == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+#define HCI_BLE_FRAME_SPACE_UPDATE_COMPLETE_EVT    0x35
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
 
 
 

components/bt/host/bluedroid/stack/include/stack/hcimsgs.h

@@ -832,15 +832,22 @@ UINT8 btsnd_hcic_ble_enable_monitor_adv(UINT8 enable);
 #define HCIC_PARAM_SIZE_SET_DECISION_INSTRUCTIONS_MAX    251
 #define BLE_DECISION_DATA_MAX_LEN                        248
 #define BLE_DECISION_MAX_TESTS                           8
-#define BLE_DECISION_TEST_PARAMS_MAX_LEN                229
+#define BLE_DECISION_TEST_PARAM_LEN                      16
+#define BLE_DECISION_TEST_PARAMS_MAX_LEN                 (BLE_DECISION_MAX_TESTS * BLE_DECISION_TEST_PARAM_LEN)
+#define HCIC_PARAM_SIZE_SET_DECISION_INSTRUCTIONS(n)     (HCIC_PARAM_SIZE_SET_DECISION_INSTRUCTIONS_HDR + (n) * 18)
 
 UINT8 btsnd_hcic_ble_set_decision_data(UINT8 adv_handle, UINT8 decision_type_flags,
                                        UINT8 data_len, const UINT8 *p_data);
 UINT8 btsnd_hcic_ble_set_decision_instructions(UINT8 num_tests, const UINT8 *test_flags,
-                                               const UINT8 *test_fields, UINT8 test_params_len,
+                                               const UINT8 *test_fields, const UINT8 *test_params);
-                                               const UINT8 *test_params);
 #endif // #if (BLE_FEAT_DBAF == TRUE)
 
+#if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)
+#define HCIC_PARAM_SIZE_FRAME_SPACE_UPDATE               9
+
+UINT8 btsnd_hcic_ble_frame_space_update(UINT16 conn_handle, UINT16 frame_space_min,
+                                        UINT16 frame_space_max, UINT8 phys, UINT16 spacing_types);
+#endif // #if (BLE_FEAT_FRAME_SPACE_UPDATE == TRUE)