drivers: bluetooth: hci: stm32wba driver update for pm

Reworking  pm implementation in stm32wba ble hci driver.
Enabling "no-reset" quirk for stm32wba ble hci driver to
maintain specific configuration required for pm.

Signed-off-by: Alessandro Manganaro <[email protected]>

Author: asm5878

drivers/bluetooth/hci/hci_stm32wba.c

@@ -13,6 +13,12 @@
 #include <zephyr/drivers/bluetooth.h>
 #include <zephyr/bluetooth/addr.h>
 #include <zephyr/drivers/clock_control/stm32_clock_control.h>
+#include <zephyr/pm/policy.h>
+#include <zephyr/pm/device.h>
+#include <zephyr/pm/pm.h>
+#ifdef CONFIG_PM_DEVICE
+#include "linklayer_plat.h"
+#endif /* CONFIG_PM_DEVICE */
 #include <linklayer_plat_local.h>
 
 #include <zephyr/sys/byteorder.h>
@@ -64,13 +70,87 @@ struct aci_set_ble_addr {
 	uint8_t length;
 	uint8_t value[6];
 } __packed;
-#endif
+#endif /* CONFIG_BT_HCI_SETUP */
+
+#ifdef CONFIG_PM_DEVICE
+/* Proprietary command to enable notification of radio events */
+#define ACI_HAL_WRITE_SET_RADIO_ACTIVITY_MASK BT_OP(BT_OGF_VS, 0xFC18)
+#define RADIO_ACTIVITY_MASK_ALL               (0x7FFF)
+#define ACI_HAL_END_OF_RADIO_ACTIVITY_EVENT   (0x0004)
+
+struct aci_set_radio_activity_mask_params {
+	uint16_t Radio_Activity_Mask;
+} __packed;
+
+struct bt_hci_end_radio_activity_evt {
+	uint8_t evt_code;
+	uint8_t len;
+	uint16_t vs_code;
+	uint8_t last_state;
+	uint8_t next_state;
+	uint32_t next_state_sys_time;
+	uint8_t last_state_slot;
+	uint8_t next_state_slot;
+} __packed;
+#endif /* CONFIG_PM_DEVICE */
 
 static uint32_t __noinit buffer[DIVC(BLE_DYN_ALLOC_SIZE, 4)];
 static uint32_t __noinit gatt_buffer[DIVC(BLE_GATT_BUF_SIZE, 4)];
 
 extern uint8_t ll_state_busy;
 
+#ifdef CONFIG_PM_DEVICE
+static int bt_hci_stm32wba_set_radio_activity_mask(void)
+{
+	struct net_buf *buf;
+	struct aci_set_radio_activity_mask_params *params;
+	int err;
+
+	buf = bt_hci_cmd_alloc(K_FOREVER);
+	if (!buf) {
+		return -ENOBUFS;
+	}
+
+	params = net_buf_add(buf, sizeof(*params));
+	params->Radio_Activity_Mask = RADIO_ACTIVITY_MASK_ALL;
+
+	err = bt_hci_cmd_send_sync(ACI_HAL_WRITE_SET_RADIO_ACTIVITY_MASK, buf, NULL);
+
+	return err;
+}
+
+void register_radio_event(void)
+{
+	int64_t value_ticks;
+	static struct pm_policy_event radio_evt;
+	static bool first_event = true;
+	uint32_t cmd_status;
+	/* Flag indicating that no radio events have been scheduled */
+	uint32_t next_radio_event_us = 0;
+
+	/* Getting next radio event time if any */
+	cmd_status = ll_intf_le_get_remaining_time_for_next_event(&next_radio_event_us);
+	UNUSED(cmd_status);
+	__ASSERT(cmd_staus, "Unable to retrieve next radio event");
+
+	if (next_radio_event_us == LL_DP_SLP_NO_WAKEUP) {
+		/* No next radio event scheduled */
+		if (!first_event) {
+			first_event = true;
+			pm_policy_event_unregister(&radio_evt);
+		}
+	} else {
+		value_ticks = k_us_to_ticks_floor64(next_radio_event_us) + k_uptime_ticks();
+		if (first_event) {
+			pm_policy_event_register(&radio_evt, value_ticks);
+			first_event = false;
+		} else {
+			pm_policy_event_update(&radio_evt, value_ticks);
+		}
+	}
+}
+#endif /* CONFIG_PM_DEVICE */
+
 static bool is_hci_event_discardable(const uint8_t *evt_data)
 {
 	uint8_t evt_type = evt_data[0];
@@ -80,7 +160,7 @@ static bool is_hci_event_discardable(const uint8_t *evt_data)
 	case BT_HCI_EVT_INQUIRY_RESULT_WITH_RSSI:
 	case BT_HCI_EVT_EXTENDED_INQUIRY_RESULT:
 		return true;
-#endif
+#endif /* CONFIG_BT_CLASSIC */
 	case BT_HCI_EVT_LE_META_EVENT: {
 		uint8_t subevt_type = evt_data[sizeof(struct bt_hci_evt_hdr)];
 
@@ -247,6 +327,17 @@ static int receive_data(const struct device *dev, const uint8_t *data, size_t le
 
 	switch (pkt_indicator) {
 	case BT_HCI_H4_EVT:
+#ifdef CONFIG_PM_DEVICE
+		/* Filtering on next radio events */
+		const struct bt_hci_end_radio_activity_evt *evt_pckt =
+			(const struct bt_hci_end_radio_activity_evt *)(data);
+
+		if ((evt_pckt->evt_code == BT_HCI_EVT_VENDOR) &&
+		    (evt_pckt->vs_code == ACI_HAL_END_OF_RADIO_ACTIVITY_EVENT)) {
+			register_radio_event();
+			return err;
+		}
+#endif /* CONFIG_PM_DEVICE */
 		buf = treat_evt(data, len);
 		break;
 	case BT_HCI_H4_ACL:
@@ -450,23 +541,79 @@ static int bt_hci_stm32wba_setup(const struct device *dev,
 		return err;
 	}
 
-	return 0;
+#ifdef CONFIG_PM_DEVICE
+	err = bt_hci_stm32wba_set_radio_activity_mask();
+	if (err) {
+		return err;
+	}
+#endif /* CONFIG_PM_DEVICE */
+
+	return err;
 }
 #endif /* CONFIG_BT_HCI_SETUP */
 
+#ifdef CONFIG_PM_DEVICE
+static int radio_pm_action(const struct device *dev, enum pm_device_action action)
+{
+	switch (action) {
+	case PM_DEVICE_ACTION_RESUME:
+		LL_AHB5_GRP1_EnableClock(LL_AHB5_GRP1_PERIPH_RADIO);
+#if defined(CONFIG_PM_S2RAM)
+		if (LL_PWR_IsActiveFlag_SB() == 1U) {
+			/* Put the radio in active state */
+			link_layer_register_isr();
+		}
+#endif /* CONFIG_PM_S2RAM */
+		LINKLAYER_PLAT_NotifyWFIExit();
+		ll_sys_dp_slp_exit();
+		break;
+	case PM_DEVICE_ACTION_SUSPEND:
+#if defined(CONFIG_PM_S2RAM)
+		uint32_t radio_remaining_time = 0;
+		enum pm_state state = pm_state_next_get(_current_cpu->id)->state;
+
+		if (state == PM_STATE_SUSPEND_TO_RAM) {
+			/* Checking next radio schedulet event */
+			uint32_t cmd_status =
+				ll_intf_le_get_remaining_time_for_next_event(&radio_remaining_time);
+			UNUSED(cmd_status);
+			__ASSERT(cmd_status, "Unable to retrieve next radio event");
+
+			if (radio_remaining_time == LL_DP_SLP_NO_WAKEUP) {
+				/* No radio event scheduled */
+				(void)ll_sys_dp_slp_enter(LL_DP_SLP_NO_WAKEUP);
+			} else if (radio_remaining_time > CFG_LPM_STDBY_WAKEUP_TIME) {
+				/* No event in a "near" future */
+				(void)ll_sys_dp_slp_enter(radio_remaining_time -
+							  CFG_LPM_STDBY_WAKEUP_TIME);
+			} else {
+				register_radio_event();
+			}
+		}
+#endif /* CONFIG_PM_S2RAM */
+		LINKLAYER_PLAT_NotifyWFIEnter();
+		break;
+	default:
+		return -ENOTSUP;
+	}
+
+	return 0;
+}
+#endif /* CONFIG_PM_DEVICE */
+
 static DEVICE_API(bt_hci, drv) = {
 #if defined(CONFIG_BT_HCI_SETUP)
 	.setup          = bt_hci_stm32wba_setup,
-#endif
+#endif /* CONFIG_BT_HCI_SETUP */
 	.open           = bt_hci_stm32wba_open,
 	.send           = bt_hci_stm32wba_send,
 };
 
 #define HCI_DEVICE_INIT(inst) \
-	static struct hci_data hci_data_##inst = { \
-	}; \
-	DEVICE_DT_INST_DEFINE(inst, NULL, NULL, &hci_data_##inst, NULL, \
-			      POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE, &drv)
+	static struct hci_data hci_data_##inst = {}; \
+	PM_DEVICE_DT_INST_DEFINE(inst, radio_pm_action); \
+	DEVICE_DT_INST_DEFINE(inst, NULL, PM_DEVICE_DT_INST_GET(inst), &hci_data_##inst, NULL, \
+			      POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE, &drv);
 
 /* Only one instance supported */
 HCI_DEVICE_INIT(0)

dts/bindings/bluetooth/st,hci-stm32wba.yaml

@@ -9,3 +9,5 @@ properties:
     default: "BT IPM"
   bt-hci-bus:
     default: "ipc"
+  bt-hci-quirks:
+    default: ["no-reset"]