bluetooth: host: Change uses of interval to interval_us

weeTike · weeTike · commit 4bf571834680 · 2025-11-20T09:47:30.000Z
Since Shorter Connection Intervals changes the unit that connection intervals can be represented in. It is necessary to change how they are stored and represented. This commit deprecates interval in favour of interval_us. Remove use of interval in internal bt_conn struct since it is no longer needed. Signed-off-by: Timothy Keys <timothy.keys@nordicsemi.no> (cherry picked from commit c14dcaf)
diff --git a/include/zephyr/bluetooth/conn.h b/include/zephyr/bluetooth/conn.h
@@ -1056,9 +1056,19 @@ struct bt_conn_le_info {
 	/** Connection interval in microseconds */
 	uint32_t interval_us;
 #if !defined(CONFIG_BT_SHORTER_CONNECTION_INTERVALS) || defined(__DOXYGEN__)
-	/** Connection interval in units of 1.25 ms */
-	uint16_t interval;
+	union {
+		/** @brief Connection interval in units of 1.25 ms
+		 *
+		 * @deprecated Use @ref bt_conn_le_info.interval_us instead
+		 */
+		__deprecated uint16_t interval;
+		/** @cond INTERNAL_HIDDEN */
+		/** Workaround for setting deprecated @ref bt_conn_le_info.interval */
+		uint16_t _interval;
+		/** @endcond */
+	};
 #endif /* !CONFIG_BT_SHORTER_CONNECTION_INTERVALS */
+
 	uint16_t latency; /**< Connection peripheral latency */
 	uint16_t timeout; /**< Connection supervision timeout */
 
@@ -1096,7 +1106,7 @@ struct bt_conn_le_info {
  *
  *  Multiply by 125 to get microseconds.
  */
-#define BT_CONN_SCI_INTERVAL_TO_US(interval) ((interval) * BT_HCI_LE_SCI_INTERVAL_UNIT_US)
+#define BT_CONN_SCI_INTERVAL_TO_US(_interval) ((_interval) * BT_HCI_LE_SCI_INTERVAL_UNIT_US)
 
 /** BR/EDR Connection Info Structure */
 struct bt_conn_br_info {
diff --git a/include/zephyr/bluetooth/hci_types.h b/include/zephyr/bluetooth/hci_types.h
@@ -3289,6 +3289,8 @@ struct bt_hci_evt_le_advertising_report {
 #define BT_HCI_LE_SUPERVISON_TIMEOUT_MIN 0x000a
 #define BT_HCI_LE_SUPERVISON_TIMEOUT_MAX 0x0c80
 
+#define BT_HCI_LE_INTERVAL_UNIT_US (1250U)
+
 #define BT_HCI_EVT_LE_CONN_UPDATE_COMPLETE      0x03
 struct bt_hci_evt_le_conn_update_complete {
 	uint8_t  status;
diff --git a/subsys/bluetooth/audio/ascs.c b/subsys/bluetooth/audio/ascs.c
@@ -525,22 +525,22 @@ static void state_transition_work_handler(struct k_work *work)
 		err = ase_state_notify(ase);
 		if (err == -ENOMEM) {
 			struct bt_conn_info info;
-			uint32_t retry_delay_ms;
+			uint32_t retry_delay_us;
 
 			/* Revert back to old state */
 			ase->ep.state = old_state;
 
 			err = bt_conn_get_info(ase->conn, &info);
 			__ASSERT_NO_MSG(err == 0);
 
-			retry_delay_ms = BT_CONN_INTERVAL_TO_MS(info.le.interval);
+			retry_delay_us = info.le.interval_us;
 
 			/* Reschedule the state transition */
-			err = k_work_reschedule(d_work, K_MSEC(retry_delay_ms));
+			err = k_work_reschedule(d_work, K_USEC(retry_delay_us));
 			if (err >= 0) {
 				LOG_DBG("Out of buffers for ase state notification. "
-					"Will retry in %dms",
-					retry_delay_ms);
+					"Will retry in %dus",
+					retry_delay_us);
 				return;
 			}
 		}
diff --git a/subsys/bluetooth/audio/bap_broadcast_assistant.c b/subsys/bluetooth/audio/bap_broadcast_assistant.c
@@ -453,12 +453,12 @@ static void long_bap_read(struct bt_conn *conn, uint16_t handle)
 		if (err != 0) {
 			LOG_DBG("Failed to get conn info, use default interval");
 
-			conn_info.le.interval = BT_GAP_INIT_CONN_INT_MIN;
+			conn_info.le.interval_us = BT_CONN_INTERVAL_TO_US(BT_GAP_INIT_CONN_INT_MIN);
 		}
 
 		/* Wait a connection interval to retry */
 		err = k_work_reschedule(&inst->bap_read_work,
-					K_USEC(BT_CONN_INTERVAL_TO_US(conn_info.le.interval)));
+					K_USEC(conn_info.le.interval_us));
 		if (err < 0) {
 			LOG_DBG("Failed to reschedule read work: %d", err);
 			bap_long_read_reset(inst);
diff --git a/subsys/bluetooth/audio/bap_scan_delegator.c b/subsys/bluetooth/audio/bap_scan_delegator.c
@@ -240,7 +240,7 @@ static void receive_state_notify_cb(struct bt_conn *conn, void *data)
 
 		LOG_DBG("Could not notify receive state: %d", err);
 		err = k_work_reschedule(&internal_state->notify_work,
-					K_USEC(BT_CONN_INTERVAL_TO_US(conn_info.le.interval)));
+					K_USEC(conn_info.le.interval_us));
 		__ASSERT(err >= 0, "Failed to reschedule work: %d", err);
 	}
 }
diff --git a/subsys/bluetooth/audio/bap_unicast_client.c b/subsys/bluetooth/audio/bap_unicast_client.c
@@ -1767,12 +1767,12 @@ static void long_ase_read(struct bt_bap_unicast_client_ep *client_ep)
 		if (err != 0) {
 			LOG_DBG("Failed to get conn info, use default interval");
 
-			conn_info.le.interval = BT_GAP_INIT_CONN_INT_MIN;
+			conn_info.le.interval_us = BT_CONN_INTERVAL_TO_US(BT_GAP_INIT_CONN_INT_MIN);
 		}
 
 		/* Wait a connection interval to retry */
 		err = k_work_reschedule(&client_ep->ase_read_work,
-					K_USEC(BT_CONN_INTERVAL_TO_US(conn_info.le.interval)));
+					K_USEC(conn_info.le.interval_us));
 		if (err < 0) {
 			LOG_DBG("Failed to reschedule ASE long read work: %d", err);
 		}
diff --git a/subsys/bluetooth/audio/tbs.c b/subsys/bluetooth/audio/tbs.c
@@ -1005,7 +1005,7 @@ static void notify_handler_cb(struct bt_conn *conn, void *data)
 		LOG_DBG("Notify failed (%d), retrying next connection interval", err);
 reschedule:
 		err = k_work_reschedule(&inst->notify_work,
-					K_USEC(BT_CONN_INTERVAL_TO_US(info.le.interval)));
+					K_USEC(info.le.interval_us));
 		__ASSERT(err >= 0, "Failed to reschedule work: %d", err);
 	}
 
diff --git a/subsys/bluetooth/host/att.c b/subsys/bluetooth/host/att.c
@@ -3538,7 +3538,7 @@ static k_timeout_t credit_based_connection_delay(struct bt_conn *conn)
 		 * result in an overflow
 		 */
 		const uint32_t calculated_delay_us =
-			2 * (conn->le.latency + 1) * BT_CONN_INTERVAL_TO_US(conn->le.interval);
+			2 * (conn->le.latency + 1) * conn->le.interval_us;
 		const uint32_t calculated_delay_ms = calculated_delay_us / USEC_PER_MSEC;
 
 		return K_MSEC(MAX(100, calculated_delay_ms + rand_delay));
diff --git a/subsys/bluetooth/host/conn.c b/subsys/bluetooth/host/conn.c
@@ -1960,30 +1960,30 @@ void bt_conn_notify_remote_info(struct bt_conn *conn)
 
 void bt_conn_notify_le_param_updated(struct bt_conn *conn)
 {
+	uint16_t interval_1250us = conn->le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US;
+
 	/* If new connection parameters meet requirement of pending
 	 * parameters don't send peripheral conn param request anymore on timeout
 	 */
 	if (atomic_test_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET) &&
-	    conn->le.interval >= conn->le.interval_min &&
-	    conn->le.interval <= conn->le.interval_max &&
+	    interval_1250us >= conn->le.interval_min &&
+	    interval_1250us <= conn->le.interval_max &&
 	    conn->le.latency == conn->le.pending_latency &&
 	    conn->le.timeout == conn->le.pending_timeout) {
 		atomic_clear_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET);
 	}
 
-
 	BT_CONN_CB_DYNAMIC_FOREACH(callback) {
 		if (callback->le_param_updated) {
-			callback->le_param_updated(conn, conn->le.interval,
+			callback->le_param_updated(conn, interval_1250us,
 						   conn->le.latency, conn->le.timeout);
 		}
 	}
 
 	STRUCT_SECTION_FOREACH(bt_conn_cb, cb) {
 		if (cb->le_param_updated) {
-			cb->le_param_updated(conn, conn->le.interval,
-					     conn->le.latency,
-					     conn->le.timeout);
+			cb->le_param_updated(conn, interval_1250us,
+					     conn->le.latency, conn->le.timeout);
 		}
 	}
 }
@@ -2866,7 +2866,7 @@ int bt_conn_get_info(const struct bt_conn *conn, struct bt_conn_info *info)
 		}
 		info->le.interval_us = conn->le.interval_us;
 #if !defined(CONFIG_BT_SHORTER_CONNECTION_INTERVALS)
-		info->le.interval = conn->le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US;
+		info->le._interval = conn->le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US;
 #endif
 		info->le.latency = conn->le.latency;
 		info->le.timeout = conn->le.timeout;
diff --git a/subsys/bluetooth/host/conn_internal.h b/subsys/bluetooth/host/conn_internal.h
@@ -107,7 +107,7 @@ struct bt_conn_le {
 	bt_addr_le_t init_addr;
 	bt_addr_le_t resp_addr;
 
-	uint16_t interval;
+	uint32_t interval_us;
 	uint16_t interval_min;
 	uint16_t interval_max;
 
diff --git a/subsys/bluetooth/host/hci_core.c b/subsys/bluetooth/host/hci_core.c
@@ -1401,7 +1401,7 @@ static void update_conn(struct bt_conn *conn, const bt_addr_le_t *id_addr,
 {
 	conn->handle = sys_le16_to_cpu(evt->handle);
 	bt_addr_le_copy(&conn->le.dst, id_addr);
-	conn->le.interval = sys_le16_to_cpu(evt->interval);
+	conn->le.interval_us = sys_le16_to_cpu(evt->interval) * BT_HCI_LE_INTERVAL_UNIT_US;
 	conn->le.latency = sys_le16_to_cpu(evt->latency);
 	conn->le.timeout = sys_le16_to_cpu(evt->supv_timeout);
 	conn->role = evt->role;
@@ -2053,15 +2053,16 @@ static void le_conn_update_complete(struct net_buf *buf)
 		bt_l2cap_update_conn_param(conn, &param);
 	} else {
 		if (!evt->status) {
-			conn->le.interval = sys_le16_to_cpu(evt->interval);
+			conn->le.interval_us =
+				sys_le16_to_cpu(evt->interval) * BT_HCI_LE_INTERVAL_UNIT_US;
 			conn->le.latency = sys_le16_to_cpu(evt->latency);
 			conn->le.timeout = sys_le16_to_cpu(evt->supv_timeout);
 
 			if (!IS_ENABLED(CONFIG_BT_CONN_PARAM_ANY)) {
-				if (!IN_RANGE(conn->le.interval, BT_HCI_LE_INTERVAL_MIN,
-					      BT_HCI_LE_INTERVAL_MAX)) {
-					LOG_WRN("interval exceeds the valid range 0x%04x",
-						conn->le.interval);
+				if (!IN_RANGE(conn->le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US,
+					      BT_HCI_LE_INTERVAL_MIN, BT_HCI_LE_INTERVAL_MAX)) {
+					LOG_WRN("interval exceeds the valid range %u us",
+						conn->le.interval_us);
 				}
 				if (conn->le.latency > BT_HCI_LE_PERIPHERAL_LATENCY_MAX) {
 					LOG_WRN("latency exceeds the valid range 0x%04x",
diff --git a/subsys/bluetooth/host/shell/bt.c b/subsys/bluetooth/host/shell/bt.c
@@ -3715,8 +3715,13 @@ static int cmd_info(const struct shell *sh, size_t argc, char *argv[])
 		print_le_addr("Local on-air", info.le.local);
 
 		shell_print(sh, "Interval: 0x%04x (%u us)",
-			    info.le.interval,
-			    BT_CONN_INTERVAL_TO_US(info.le.interval));
+#if defined(CONFIG_BT_SHORTER_CONNECTION_INTERVALS)
+			    info.le.interval_us / BT_HCI_LE_SCI_INTERVAL_UNIT_US,
+#else
+			    info.le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US,
+#endif /* CONFIG_BT_SHORTER_CONNECTION_INTERVALS */
+			    info.le.interval_us);
+
 		shell_print(sh, "Latency: 0x%04x",
 			    info.le.latency);
 		shell_print(sh, "Supervision timeout: 0x%04x (%d ms)",
@@ -4138,9 +4143,9 @@ static void connection_info(struct bt_conn *conn, void *user_data)
 #endif
 	case BT_CONN_TYPE_LE:
 		bt_addr_le_to_str(info.le.dst, addr, sizeof(addr));
-		bt_shell_print("%s#%u [LE][%s] %s: Interval %u latency %u timeout %u", selected,
-			       info.id, role_str, addr, info.le.interval, info.le.latency,
-			       info.le.timeout);
+		bt_shell_print("%s#%u [LE][%s] %s: Interval %u us, latency %u, timeout %u ms",
+			       selected, info.id, role_str, addr, info.le.interval_us,
+			       info.le.latency, info.le.timeout * 10);
 		break;
 #if defined(CONFIG_BT_ISO)
 	case BT_CONN_TYPE_ISO:
diff --git a/tests/bluetooth/audio/ascs/src/main.c b/tests/bluetooth/audio/ascs/src/main.c
@@ -667,7 +667,7 @@ ZTEST_F(ascs_test_suite, test_ase_state_notification_retry)
 	zassert_equal(err, 0);
 
 	/* Wait for ASE state notification retry */
-	k_sleep(K_MSEC(BT_CONN_INTERVAL_TO_MS(info.le.interval)));
+	k_sleep(K_USEC(info.le.interval_us));
 
 	expect_bt_bap_stream_ops_configured_called_once(stream, EMPTY);
 }
diff --git a/tests/bluetooth/audio/ascs/src/test_common.c b/tests/bluetooth/audio/ascs/src/test_common.c
@@ -77,7 +77,7 @@ void test_conn_init(struct bt_conn *conn)
 	conn->info.security.level = BT_SECURITY_L2;
 	conn->info.security.enc_key_size = BT_ENC_KEY_SIZE_MAX;
 	conn->info.security.flags = BT_SECURITY_FLAG_OOB | BT_SECURITY_FLAG_SC;
-	conn->info.le.interval = BT_GAP_INIT_CONN_INT_MIN;
+	conn->info.le.interval_us = BT_GAP_INIT_CONN_INT_MIN * BT_HCI_LE_INTERVAL_UNIT_US;
 }
 
 const struct bt_gatt_attr *test_ase_control_point_get(void)
diff --git a/tests/bluetooth/tester/src/btp_gap.c b/tests/bluetooth/tester/src/btp_gap.c
@@ -134,7 +134,7 @@ static void le_connected(struct bt_conn *conn, uint8_t err)
 
 	if (bt_conn_is_type(conn, BT_CONN_TYPE_LE)) {
 		bt_addr_le_copy(&ev.address, info.le.dst);
-		ev.interval = sys_cpu_to_le16(info.le.interval);
+		ev.interval = sys_cpu_to_le16(info.le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US);
 		ev.latency = sys_cpu_to_le16(info.le.latency);
 		ev.timeout = sys_cpu_to_le16(info.le.timeout);
 	} else if (IS_ENABLED(CONFIG_BT_CLASSIC) && bt_conn_is_type(conn, BT_CONN_TYPE_BR)) {

Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,7 @@ static void receive_state_notify_cb(struct bt_conn conn, void data)`
`240`	`240`
`241`	`241`	`LOG_DBG("Could not notify receive state: %d", err);`
`242`	`242`	`err = k_work_reschedule(&internal_state->notify_work,`
`243`		`- K_USEC(BT_CONN_INTERVAL_TO_US(conn_info.le.interval)));`
	`243`	`+ K_USEC(conn_info.le.interval_us));`
`244`	`244`	`__ASSERT(err >= 0, "Failed to reschedule work: %d", err);`
`245`	`245`	`}`
`246`	`246`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1767,12 +1767,12 @@ static void long_ase_read(struct bt_bap_unicast_client_ep *client_ep)`
`1767`	`1767`	`if (err != 0) {`
`1768`	`1768`	`LOG_DBG("Failed to get conn info, use default interval");`
`1769`	`1769`
`1770`		`- conn_info.le.interval = BT_GAP_INIT_CONN_INT_MIN;`
	`1770`	`+ conn_info.le.interval_us = BT_CONN_INTERVAL_TO_US(BT_GAP_INIT_CONN_INT_MIN);`
`1771`	`1771`	`}`
`1772`	`1772`
`1773`	`1773`	`/* Wait a connection interval to retry */`
`1774`	`1774`	`err = k_work_reschedule(&client_ep->ase_read_work,`
`1775`		`- K_USEC(BT_CONN_INTERVAL_TO_US(conn_info.le.interval)));`
	`1775`	`+ K_USEC(conn_info.le.interval_us));`
`1776`	`1776`	`if (err < 0) {`
`1777`	`1777`	`LOG_DBG("Failed to reschedule ASE long read work: %d", err);`
`1778`	`1778`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1005,7 +1005,7 @@ static void notify_handler_cb(struct bt_conn conn, void data)`
`1005`	`1005`	`LOG_DBG("Notify failed (%d), retrying next connection interval", err);`
`1006`	`1006`	`reschedule:`
`1007`	`1007`	`err = k_work_reschedule(&inst->notify_work,`
`1008`		`- K_USEC(BT_CONN_INTERVAL_TO_US(info.le.interval)));`
	`1008`	`+ K_USEC(info.le.interval_us));`
`1009`	`1009`	`__ASSERT(err >= 0, "Failed to reschedule work: %d", err);`
`1010`	`1010`	`}`
`1011`	`1011`
Original file line number	Diff line number	Diff line change
`@@ -1960,30 +1960,30 @@ void bt_conn_notify_remote_info(struct bt_conn *conn)`
`1960`	`1960`
`1961`	`1961`	`void bt_conn_notify_le_param_updated(struct bt_conn *conn)`
`1962`	`1962`	`{`
	`1963`	`+ uint16_t interval_1250us = conn->le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US;`
	`1964`	`+`
`1963`	`1965`	`/* If new connection parameters meet requirement of pending`
`1964`	`1966`	`* parameters don't send peripheral conn param request anymore on timeout`
`1965`	`1967`	`*/`
`1966`	`1968`	`if (atomic_test_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET) &&`
`1967`		`- conn->le.interval >= conn->le.interval_min &&`
`1968`		`- conn->le.interval <= conn->le.interval_max &&`
	`1969`	`+ interval_1250us >= conn->le.interval_min &&`
	`1970`	`+ interval_1250us <= conn->le.interval_max &&`
`1969`	`1971`	`conn->le.latency == conn->le.pending_latency &&`
`1970`	`1972`	`conn->le.timeout == conn->le.pending_timeout) {`
`1971`	`1973`	`atomic_clear_bit(conn->flags, BT_CONN_PERIPHERAL_PARAM_SET);`
`1972`	`1974`	`}`
`1973`	`1975`
`1974`		`-`
`1975`	`1976`	`BT_CONN_CB_DYNAMIC_FOREACH(callback) {`
`1976`	`1977`	`if (callback->le_param_updated) {`
`1977`		`- callback->le_param_updated(conn, conn->le.interval,`
	`1978`	`+ callback->le_param_updated(conn, interval_1250us,`
`1978`	`1979`	`conn->le.latency, conn->le.timeout);`
`1979`	`1980`	`}`
`1980`	`1981`	`}`
`1981`	`1982`
`1982`	`1983`	`STRUCT_SECTION_FOREACH(bt_conn_cb, cb) {`
`1983`	`1984`	`if (cb->le_param_updated) {`
`1984`		`- cb->le_param_updated(conn, conn->le.interval,`
`1985`		`- conn->le.latency,`
`1986`		`- conn->le.timeout);`
	`1985`	`+ cb->le_param_updated(conn, interval_1250us,`
	`1986`	`+ conn->le.latency, conn->le.timeout);`
`1987`	`1987`	`}`
`1988`	`1988`	`}`
`1989`	`1989`	`}`
`@@ -2866,7 +2866,7 @@ int bt_conn_get_info(const struct bt_conn conn, struct bt_conn_info info)`
`2866`	`2866`	`}`
`2867`	`2867`	`info->le.interval_us = conn->le.interval_us;`
`2868`	`2868`	`#if !defined(CONFIG_BT_SHORTER_CONNECTION_INTERVALS)`
`2869`		`- info->le.interval = conn->le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US;`
	`2869`	`+ info->le._interval = conn->le.interval_us / BT_HCI_LE_INTERVAL_UNIT_US;`
`2870`	`2870`	`#endif`
`2871`	`2871`	`info->le.latency = conn->le.latency;`
`2872`	`2872`	`info->le.timeout = conn->le.timeout;`