qcacld-3.0: Measure TSF latency between host TSF sync enabled devices

The feature raises a pulses at specified interval in TSF time domain.
The pulses can be used to determine driver level latency between hosts
as they are operating in same TSF time domain.
Add ini "g_tsf_accuracy_configs" to configure parameters for TSF accuracy
feature to customize GPIO pins and interval.

Change-Id: I49609d5beba8043ac2ecc086e97b01d1e0b2d3f6
CRs-Fixed: 3277992

Kbuild

@@ -3903,6 +3903,8 @@ cppflags-$(CONFIG_WLAN_SYNC_TSF) += -DWLAN_FEATURE_TSF
 ifeq ($(CONFIG_WLAN_SYNC_TSF_PLUS), y)
 cppflags-y += -DWLAN_FEATURE_TSF_PLUS
 
+cppflags-$(CONFIG_WLAN_SYNC_TSF_ACCURACY) += -DWLAN_FEATURE_TSF_ACCURACY
+
 ifneq ($(CONFIG_WLAN_SYNC_TSF_PLUS_DISABLE_SOCK_TS), y)
 cppflags-y += -DWLAN_FEATURE_TSF_PLUS_SOCK_TS
 endif

components/fw_offload/core/inc/wlan_fw_offload_main.h

@@ -192,6 +192,25 @@ struct wlan_fwol_neighbor_report_cfg {
 	uint32_t max_req_cap;
 };
 
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+/**
+ * struct wlan_fwol_tsf_accuracy_configs - TSF Accuracy feature config params
+ * @enable: Flag to Enable/Disable TSF Accuracy Feature
+ * @sync_gpio: GPIO to indicate TSF sync is done. The GPIO pin is toggled at
+ *             every TSF sync done.
+ * @periodic_pulse_gpio: GPIO to indicate TSF time completes a cycle of given
+ *                       interval. The GPIO pin gets pulse of 1msec for every
+ *                       TSF cycle complete.
+ * @pulse_interval_ms: Periodicy of TSF pulse in milli seconds.
+ */
+struct wlan_fwol_tsf_accuracy_configs {
+	bool enable;
+	uint32_t sync_gpio;
+	uint32_t periodic_pulse_gpio;
+	uint32_t pulse_interval_ms;
+};
+#endif
+
 /**
  * struct wlan_fwol_cfg - fwol config items
  * @coex_config: coex config items
@@ -222,6 +241,7 @@ struct wlan_fwol_neighbor_report_cfg {
  * @tsf_sync_host_gpio_pin: TSF Sync GPIO Pin config
  * @tsf_ptp_options: TSF Plus feature options config
  * @tsf_sync_enable: TSF sync feature enable/disable
+ * @tsf_accuracy_configs: TSF Accuracy feature config parameters
  * @sae_enable: SAE feature enable config
  * @gcmp_enable: GCMP feature enable config
  * @enable_tx_sch_delay: Enable TX SCH delay value config
@@ -266,6 +286,9 @@ struct wlan_fwol_cfg {
 #ifdef WLAN_FEATURE_TSF_PLUS
 	uint32_t tsf_ptp_options;
 	bool tsf_sync_enable;
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+	struct wlan_fwol_tsf_accuracy_configs tsf_accuracy_configs;
+#endif
 #ifdef WLAN_FEATURE_TSF_PLUS_EXT_GPIO_IRQ
 	uint32_t tsf_irq_host_gpio_pin;
 #endif

components/fw_offload/core/src/wlan_fw_offload_main.c

@@ -454,11 +454,49 @@ static void ucfg_fwol_fetch_tsf_gpio_pin(struct wlan_objmgr_psoc *psoc,
  * Return: none
  */
 #if defined(WLAN_FEATURE_TSF) && defined(WLAN_FEATURE_TSF_PLUS)
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+/**
+ * fwol_init_tsf_accuracy_configs: Populate the TSF Accuracy configs from cfg
+ * @psoc: The global psoc handler
+ * @fwol_cfg: The cfg structure
+ *
+ * Return: none
+ */
+static void fwol_init_tsf_accuracy_configs(struct wlan_objmgr_psoc *psoc,
+					   struct wlan_fwol_cfg *fwol_cfg)
+{
+	int32_t configs[CFG_TSF_ACCURACY_CONFIG_LEN] = { 0 };
+	int status;
+	qdf_size_t len;
+
+	status = qdf_int32_array_parse(cfg_get(psoc, CFG_TSF_ACCURACY_CONFIGS),
+				       configs,
+				       CFG_TSF_ACCURACY_CONFIG_LEN,
+				       &len);
+
+	if (status != QDF_STATUS_SUCCESS || len != CFG_TSF_ACCURACY_CONFIG_LEN) {
+		fwol_cfg->tsf_accuracy_configs.enable = 0;
+		fwol_err("Invalid parameters from INI");
+		return;
+	}
+
+	fwol_cfg->tsf_accuracy_configs.enable = configs[0];
+	fwol_cfg->tsf_accuracy_configs.sync_gpio = configs[1];
+	fwol_cfg->tsf_accuracy_configs.periodic_pulse_gpio = configs[2];
+	fwol_cfg->tsf_accuracy_configs.pulse_interval_ms = configs[3];
+}
+#else
+static void fwol_init_tsf_accuracy_configs(struct wlan_objmgr_psoc *psoc,
+					   struct wlan_fwol_cfg *fwol_cfg)
+{
+}
+#endif
 static void ucfg_fwol_init_tsf_ptp_options(struct wlan_objmgr_psoc *psoc,
 					   struct wlan_fwol_cfg *fwol_cfg)
 {
 	fwol_cfg->tsf_ptp_options = cfg_get(psoc, CFG_SET_TSF_PTP_OPT);
 	fwol_cfg->tsf_sync_enable = cfg_get(psoc, CFG_TSF_SYNC_ENABLE);
+	fwol_init_tsf_accuracy_configs(psoc, fwol_cfg);
 }
 #else
 static void ucfg_fwol_init_tsf_ptp_options(struct wlan_objmgr_psoc *psoc,

components/fw_offload/dispatcher/inc/cfg_fwol_generic.h

@@ -619,6 +619,45 @@
 #define __CFG_SET_TSF_PTP_OPT
 #endif
 
+#if defined(WLAN_FEATURE_TSF_ACCURACY)
+/* <ini>
+ * g_tsf_accuracy_configs: Enable TSF Accuracy Feature config parameters
+ * @Min: N/A
+ * @Max: N/A
+ * @Default: N/A
+ *
+ * This ini is to configure TSF Accuracy parameters.
+ * The list of mandate CFG_TSF_ACCURACY_CONFIG_LEN elements of type integer are
+ * specified with (,) delimiter.
+ * Param1: Enable/Disable TSF Accuracy Feature.
+ * Param2: GPIO to toggle on TSF sync done
+ * Param3: GPIO to raise pulse on specified period(TSF time domain)
+ * Param4: Periodicity of TSF pulse in milli seconds
+ * For example:
+ * g_tsf_accuracy_configs=1,430,431,100
+ *
+ * Related: None
+ *
+ * Usage: External
+ *
+ * </ini>
+ */
+#define CFG_TSF_ACCURACY_CONFIG_LEN 4
+#define CFG_TSF_ACCURACY_CONFIG_STR_LEN 128
+#define CFG_TSF_ACCURACY_CONFIGS_DEF "0, -1, -1, 0"
+#define CFG_TSF_ACCURACY_CONFIGS CFG_INI_STRING( \
+		"g_tsf_accuracy_configs", \
+		0, \
+		CFG_TSF_ACCURACY_CONFIG_STR_LEN, \
+		CFG_TSF_ACCURACY_CONFIGS_DEF, \
+		"Configure TSF Accuracy parameters")
+
+#define __CFG_TSF_ACCURACY_CONFIGS \
+		CFG(CFG_TSF_ACCURACY_CONFIGS)
+#else
+#define __CFG_TSF_ACCURACY_CONFIGS
+#endif
+
 #ifdef DHCP_SERVER_OFFLOAD
 /* <ini>
  * gDHCPServerOffloadEnable
@@ -911,6 +950,7 @@
 	__CFG_SET_TSF_IRQ_HOST_GPIO_PIN \
 	__CFG_SET_TSF_SYNC_HOST_GPIO_PIN \
 	__CFG_SET_TSF_PTP_OPT \
+	__CFG_TSF_ACCURACY_CONFIGS \
 	__CFG_IS_SAE_ENABLED \
 	CFG(CFG_ENABLE_GCMP) \
 	CFG(CFG_TX_SCH_DELAY) \

components/fw_offload/dispatcher/inc/wlan_fwol_ucfg_api.h

@@ -456,6 +456,18 @@ QDF_STATUS ucfg_fwol_get_dhcp_max_num_clients(struct wlan_objmgr_psoc *psoc,
 QDF_STATUS ucfg_fwol_get_tsf_sync_enable(struct wlan_objmgr_psoc *psoc,
 					 bool *tsf_sync_enable);
 
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+/**
+ * ucfg_fwol_get_tsf_accuracy_configs() - Get TSF accuracy configs
+ * @psoc: pointer to the psoc object
+ * @config: Pointer to hold TSF Accuracy Feature configs
+ *
+ * Return: QDF Status
+ */
+QDF_STATUS ucfg_fwol_get_tsf_accuracy_configs(struct wlan_objmgr_psoc *psoc,
+					      struct wlan_fwol_tsf_accuracy_configs **config);
+#endif
+
 /**
  * ucfg_fwol_get_tsf_ptp_options() - Get TSF Plus feature options
  * @psoc: pointer to the psoc object

components/fw_offload/dispatcher/src/wlan_fwol_ucfg_api.c

@@ -702,6 +702,23 @@ QDF_STATUS ucfg_fwol_get_tsf_sync_enable(struct wlan_objmgr_psoc *psoc,
 	return QDF_STATUS_SUCCESS;
 }
 
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+QDF_STATUS ucfg_fwol_get_tsf_accuracy_configs(struct wlan_objmgr_psoc *psoc,
+					      struct wlan_fwol_tsf_accuracy_configs **config)
+{
+	struct wlan_fwol_psoc_obj *fwol_obj;
+
+	fwol_obj = fwol_get_psoc_obj(psoc);
+	if (!fwol_obj) {
+		fwol_err("Failed to get FWOL obj");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	*config = &fwol_obj->cfg.tsf_accuracy_configs;
+	return QDF_STATUS_SUCCESS;
+}
+#endif
+
 #ifdef WLAN_FEATURE_TSF_PLUS_EXT_GPIO_IRQ
 QDF_STATUS
 ucfg_fwol_get_tsf_irq_host_gpio_pin(struct wlan_objmgr_psoc *psoc,

core/hdd/inc/wlan_hdd_main.h

@@ -121,6 +121,10 @@
 #include "wlan_osif_features.h"
 #include "wlan_dp_public_struct.h"
 
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+#include "qdf_hrtimer.h"
+#endif
+
 /*
  * Preprocessor definitions and constants
  */
@@ -1005,6 +1009,8 @@ struct wlm_multi_client_info_table {
  * @gpio_tsf_sync_work: work to sync send TSF CAP WMI command
  * @cache_sta_count: number of currently cached stations
  * @acs_complete_event: acs complete event
+ * @host_trigger_gpio_timer: A hrtimer used for TSF Accuracy Feature to
+ *                           indicate TSF cycle complete
  * @latency_level: 0 - normal, 1 - xr, 2 - low, 3 - ultralow
  * @multi_client_ll_support: to check multi client ll support in driver
  * @client_info: To store multi client id information
@@ -1172,6 +1178,9 @@ struct hdd_adapter {
 	/* spin lock for read/write timestamps */
 	qdf_spinlock_t host_target_sync_lock;
 	qdf_mc_timer_t host_target_sync_timer;
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+	qdf_hrtimer_data_t host_trigger_gpio_timer;
+#endif
 	bool enable_dynamic_tsf_sync;
 	bool host_target_sync_force;
 	uint32_t dynamic_tsf_sync_interval;
@@ -1696,6 +1705,7 @@ enum wlan_state_ctrl_str_id {
  * @bus_bw_work: work for periodically computing DDR bus bandwidth requirements
  * @g_event_flags: a bitmap of hdd_driver_flags
  * @psoc_idle_timeout_work: delayed work for psoc idle shutdown
+ * @tsf_accuracy_context: Holds TSF Accuracy feature activated vdev adapter.
  * @dynamic_nss_chains_support: Per vdev dynamic nss chains update capability
  * @sar_cmd_params: SAR command params to be configured to the FW
  * @country_change_work: work for updating vdev when country changes
@@ -1928,6 +1938,9 @@ struct hdd_context {
 	qdf_atomic_t cap_tsf_flag;
 	/* the context that is capturing tsf */
 	struct hdd_adapter *cap_tsf_context;
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+	struct hdd_adapter *tsf_accuracy_context;
+#endif
 #endif
 #ifdef WLAN_FEATURE_TSF_PTP
 	struct ptp_clock_info ptp_cinfo;

core/hdd/src/wlan_hdd_tsf.c

@@ -29,7 +29,8 @@
 #include <qca_vendor.h>
 #include <linux/errqueue.h>
 #if defined(WLAN_FEATURE_TSF_PLUS_EXT_GPIO_IRQ) || \
-	defined(WLAN_FEATURE_TSF_PLUS_EXT_GPIO_SYNC)
+	defined(WLAN_FEATURE_TSF_PLUS_EXT_GPIO_SYNC) || \
+	defined(WLAN_FEATURE_TSF_ACCURACY)
 #include <linux/gpio.h>
 #endif
 
@@ -1257,6 +1258,325 @@ static void hdd_capture_tsf_timer_expired_handler(void *arg)
 	hdd_capture_tsf_internal(adapter, &tsf_op_resp, 1);
 }
 
+#ifdef WLAN_FEATURE_TSF_ACCURACY
+#define WLAN_HDD_TOGGLE_GPIO_BACKOFF_USEC 50
+#define WLAN_HDD_TOGGLE_GPIO_BACKOFF_MAX_USEC 200
+#define WLAN_HDD_PULSE_WIDTH_MSEC 1
+
+/**
+ * hdd_get_tsf_accuracy_context() - Return the TSF Accuracy config params
+ * @adapter: Pointer to adapter
+ *
+ * This function validates feature config parameters
+ *
+ * Return: Pointer to TSF Accuracy feature configs
+ */
+static struct wlan_fwol_tsf_accuracy_configs *
+hdd_get_tsf_accuracy_context(struct hdd_adapter *adapter)
+{
+	struct wlan_fwol_tsf_accuracy_configs *configs = NULL;
+	struct hdd_context *hddctx;
+	int status;
+
+	hddctx = WLAN_HDD_GET_CTX(adapter);
+	if (!hddctx) {
+		hdd_err("invalid hdd context");
+		return NULL;
+	}
+
+	if (hddctx->tsf_accuracy_context &&
+	    hddctx->tsf_accuracy_context != adapter)
+		return NULL;
+
+	status = ucfg_fwol_get_tsf_accuracy_configs(hddctx->psoc, &configs);
+	if (status == QDF_STATUS_E_FAILURE)
+		return NULL;
+
+	if (!configs || !configs->enable ||
+	    (configs->periodic_pulse_gpio == TSF_GPIO_PIN_INVALID &&
+	     configs->sync_gpio == TSF_GPIO_PIN_INVALID))
+		return NULL;
+
+	return configs;
+}
+
+/**
+ * hdd_tsf_gpio_pulse() - Raise pulse of WLAN_HDD_PULSE_WIDTH_MSEC on gpio
+ * @gpio_num: GPIO number
+ *
+ * Return: None
+ */
+static void hdd_tsf_gpio_pulse(uint32_t gpio_num)
+{
+	if (gpio_num == TSF_GPIO_PIN_INVALID)
+		return;
+
+	gpio_set_value(gpio_num, OUTPUT_HIGH);
+	udelay(WLAN_HDD_PULSE_WIDTH_MSEC * USEC_PER_MSEC);
+	gpio_set_value(gpio_num, OUTPUT_LOW);
+}
+
+/**
+ * hdd_tsf_gpio_timer_expired_handler() - Handle periodic TSF periodic expiry
+ * @arg: Pointer to qdf_hrtimer_data_t
+ *
+ * Raise GPIO pulse on TSF time cycle completion and schedules hrtimer for
+ * next cycle. Also, monitors drift between Host time and TSF time.
+ * This data will be used for scheduling hrtimer expiry.
+ *
+ * Return:
+ *      QDF_HRTIMER_RESTART - On completion of TSF cycle processing
+ *      QDF_HRTIMER_NORESTART - On error
+ */
+static enum qdf_hrtimer_restart_status
+hdd_tsf_gpio_timer_expired_handler(qdf_hrtimer_data_t *arg)
+{
+	struct hdd_adapter *adapter;
+	struct wlan_fwol_tsf_accuracy_configs *configs;
+	qdf_ktime_t cur_qtime, spin_until, next_ktime;
+	uint64_t qtime;
+	uint64_t tsf_time_us;
+	uint32_t elapsed_time_us;
+	uint32_t remaining_time_us;
+	uint32_t delta_interval_us;
+
+	adapter = container_of(arg, struct hdd_adapter,
+			       host_trigger_gpio_timer);
+
+	configs = hdd_get_tsf_accuracy_context(adapter);
+	if (!configs)
+		return QDF_HRTIMER_NORESTART;
+
+	/* Get current System and TSF mapping */
+	qtime = qdf_log_timestamp_to_usecs(qdf_get_log_timestamp());
+	hdd_get_tsftime_from_qtime(adapter, qtime, &tsf_time_us);
+	elapsed_time_us = (uint32_t)
+		(tsf_time_us % (configs->pulse_interval_ms * USEC_PER_MSEC));
+	remaining_time_us =
+		(configs->pulse_interval_ms * USEC_PER_MSEC) - elapsed_time_us;
+
+	/* Skip raising GPIO pulse in case of TSF cycle already completed */
+	if (elapsed_time_us < remaining_time_us) {
+		next_ktime = qdf_ns_to_ktime(NSEC_PER_USEC *
+			((configs->pulse_interval_ms * USEC_PER_MSEC) -
+			 WLAN_HDD_TOGGLE_GPIO_BACKOFF_USEC -
+			 elapsed_time_us));
+		hdd_debug("TSF_Accuracy: skip GPIO pulse tsf_time_us:%llu",
+			  tsf_time_us);
+		goto end;
+	}
+
+	if (remaining_time_us > WLAN_HDD_TOGGLE_GPIO_BACKOFF_MAX_USEC)
+		goto skip;
+	/*
+	 * Expect WLAN_HDD_TOGGLE_GPIO_BACKOFF_USEC seconds of backoff always
+	 * for TSF time to complete a cycle of given interval.
+	 * Hence run backoff busy wait and then trigger GPIO
+	 */
+	cur_qtime = qdf_ns_to_ktime(qtime * NSEC_PER_USEC);
+	spin_until = qdf_ktime_add(cur_qtime,
+				   qdf_ns_to_ktime(remaining_time_us *
+				    NSEC_PER_USEC));
+	do {
+		qtime = qdf_log_timestamp_to_usecs(qdf_get_log_timestamp());
+		cur_qtime = qdf_ns_to_ktime(qtime * NSEC_PER_USEC);
+	} while (ktime_compare(cur_qtime, spin_until) < 0);
+
+	/* Toggle GPIO */
+	hdd_tsf_gpio_pulse(configs->periodic_pulse_gpio);
+
+	/* Check current system and TSF mapping for logging */
+	hdd_get_tsftime_from_qtime(adapter, qtime, &tsf_time_us);
+
+	hdd_debug("TSF_Accuracy: GPIO toggled log_time_us:%llu, tsf_time_us:%llu, slept_us:%d",
+		  qtime, tsf_time_us, remaining_time_us);
+
+	/*
+	 *  Schedule next GPIO toggle by adding to last expiry. Monitor drift
+	 *  and adjust next expiry time based on system and TSF clock
+	 *  difference.
+	 */
+skip:
+	if (remaining_time_us > WLAN_HDD_TOGGLE_GPIO_BACKOFF_USEC) {
+		delta_interval_us = remaining_time_us -
+			WLAN_HDD_TOGGLE_GPIO_BACKOFF_USEC;
+		next_ktime = qdf_ns_to_ktime(NSEC_PER_USEC *
+					     ((configs->pulse_interval_ms *
+					       USEC_PER_MSEC) +
+					     delta_interval_us));
+	} else {
+		next_ktime = configs->pulse_interval_ms;
+	}
+end:
+	qdf_hrtimer_add_expires(&adapter->host_trigger_gpio_timer, next_ktime);
+
+	return QDF_HRTIMER_RESTART;
+}
+
+/**
+ * hdd_tsf_setup_gpio_toggle() - Schedules hrtimer for TSF periodic processing.
+ * @adapter: Pointer to adapter
+ *
+ * Schedule a TSF time domain periodic pulse handling and also indicate a
+ * TSF sync done by toggling GPIO.
+ *
+ * Return: None
+ */
+static void hdd_tsf_setup_gpio_toggle(struct hdd_adapter *adapter)
+{
+	static uint32_t gpio_state = OUTPUT_LOW;
+	uint64_t tsf_time_us;
+	uint64_t qtime;
+	uint32_t elapsed_time_us;
+	uint32_t remaining_time_us;
+	qdf_ktime_t cur_ktime, next_ktime;
+	struct wlan_fwol_tsf_accuracy_configs *configs;
+	qdf_hrtimer_data_t *gtimer;
+
+	configs = hdd_get_tsf_accuracy_context(adapter);
+	if (!configs)
+		return;
+
+	gtimer = &adapter->host_trigger_gpio_timer;
+
+	/* Get current System and TSF mapping */
+	cur_ktime = qdf_ktime_get();
+	qtime = qdf_log_timestamp_to_usecs(qdf_get_log_timestamp());
+	hdd_get_tsftime_from_qtime(adapter, qtime, &tsf_time_us);
+
+	if (configs->sync_gpio != TSF_GPIO_PIN_INVALID) {
+		if (gpio_state == OUTPUT_LOW)
+			gpio_state = OUTPUT_HIGH;
+		else
+			gpio_state = OUTPUT_LOW;
+		gpio_set_value(configs->sync_gpio, gpio_state);
+	}
+
+	hdd_debug("TSF_Accuracy: TSF sync done system_time_us:%llu, log_time_us:%llu, tsf_time_us:%llu",
+		  qdf_ktime_to_us(cur_ktime), qtime, tsf_time_us);
+
+	/* Start timer if it is not scheduled yet */
+	if (!(qdf_hrtimer_is_queued(gtimer) ||
+	      qdf_hrtimer_callback_running(gtimer))) {
+		/*
+		 * Take out WLAN_HDD_TOGGLE_GPIO_BACKOFF_USEC as backoff timer
+		 * which is taken care by hrtimer handler
+		 */
+		elapsed_time_us = (uint32_t)(tsf_time_us % USEC_PER_SEC);
+		remaining_time_us = USEC_PER_SEC - elapsed_time_us;
+		if (remaining_time_us <= WLAN_HDD_TOGGLE_GPIO_BACKOFF_USEC)
+			return;
+		next_ktime = qdf_ktime_add(cur_ktime,
+					   qdf_ns_to_ktime((remaining_time_us -
+			WLAN_HDD_TOGGLE_GPIO_BACKOFF_USEC) * NSEC_PER_USEC));
+		qdf_hrtimer_start(gtimer, next_ktime, QDF_HRTIMER_MODE_ABS);
+	}
+}
+
+/**
+ * hdd_tsf_regular_gpio_pulse_init() - Initialize TSF Accuracy feature
+ * @adapter: Pointer to adapter
+ *
+ * Return: None
+ */
+static void hdd_tsf_regular_gpio_pulse_init(struct hdd_adapter *adapter)
+{
+	struct wlan_fwol_tsf_accuracy_configs *configs;
+	struct hdd_context *hddctx;
+
+	hddctx = WLAN_HDD_GET_CTX(adapter);
+	if (!hddctx) {
+		hdd_err("invalid hdd context");
+		return;
+	}
+
+	configs = hdd_get_tsf_accuracy_context(adapter);
+	if (!configs)
+		goto fail;
+
+	qdf_hrtimer_init(&adapter->host_trigger_gpio_timer,
+			 hdd_tsf_gpio_timer_expired_handler,
+			 QDF_CLOCK_MONOTONIC, QDF_HRTIMER_MODE_ABS,
+			 QDF_CONTEXT_HARDWARE);
+
+	if (configs->periodic_pulse_gpio != TSF_GPIO_PIN_INVALID) {
+		if (gpio_request(configs->periodic_pulse_gpio,
+				 "tsf_periodic_pulse"))
+			goto fail;
+		if (gpio_direction_output(configs->periodic_pulse_gpio,
+					  OUTPUT_LOW))
+			goto fail_free_pulse_gpio;
+	}
+
+	if (configs->sync_gpio != TSF_GPIO_PIN_INVALID) {
+		if (gpio_request(configs->sync_gpio, "tsf_sync_toggle"))
+			goto fail_free_pulse_gpio;
+		if (gpio_direction_output(configs->sync_gpio, OUTPUT_LOW))
+			goto fail_free_gpio;
+	}
+
+	hddctx->tsf_accuracy_context = adapter;
+	hdd_debug("TSF_Accuracy: Feature initialization success");
+	return;
+
+fail_free_gpio:
+	gpio_free(configs->sync_gpio);
+fail_free_pulse_gpio:
+	if (configs->periodic_pulse_gpio != TSF_GPIO_PIN_INVALID)
+		gpio_free(configs->periodic_pulse_gpio);
+fail:
+	hdd_err("TSF_Accuracy: Feature init failed");
+}
+
+/**
+ * hdd_tsf_regular_gpio_pulse_deinit() - Deactivate TSF Accuracy feature
+ * @adapter: Pointer to adapter
+ *
+ * Return: None
+ */
+static void hdd_tsf_regular_gpio_pulse_deinit(struct hdd_adapter *adapter)
+{
+	struct wlan_fwol_tsf_accuracy_configs *configs = NULL;
+	struct hdd_context *hddctx;
+
+	hddctx = WLAN_HDD_GET_CTX(adapter);
+	if (!hddctx) {
+		hdd_err("invalid hdd context");
+		return;
+	}
+
+	if (hddctx->tsf_accuracy_context != adapter)
+		return;
+
+	configs = hdd_get_tsf_accuracy_context(adapter);
+	if (!configs)
+		return;
+
+	qdf_hrtimer_cancel(&adapter->host_trigger_gpio_timer);
+
+	if (configs->periodic_pulse_gpio != TSF_GPIO_PIN_INVALID)
+		gpio_free(configs->periodic_pulse_gpio);
+	if (configs->sync_gpio != TSF_GPIO_PIN_INVALID) {
+		gpio_set_value(configs->sync_gpio, OUTPUT_LOW);
+		gpio_free(configs->sync_gpio);
+	}
+
+	hddctx->tsf_accuracy_context = NULL;
+}
+#else
+static void hdd_tsf_setup_gpio_toggle(struct hdd_adapter *adapter)
+{
+}
+
+static void hdd_tsf_regular_gpio_pulse_init(struct hdd_adapter *adapter)
+{
+}
+
+static void hdd_tsf_regular_gpio_pulse_deinit(struct hdd_adapter *adapter)
+{
+}
+#endif
+
 #ifndef WLAN_FEATURE_TSF_PLUS_NOIRQ
 #if !defined(WLAN_FEATURE_TSF_PLUS_EXT_GPIO_SYNC) && \
 	!defined(WLAN_FEATURE_TSF_TIMER_SYNC)
@@ -1435,6 +1755,8 @@ static void hdd_update_timestamp(struct hdd_adapter *adapter)
 	}
 	qdf_spin_unlock_bh(&adapter->host_target_sync_lock);
 
+	hdd_tsf_setup_gpio_toggle(adapter);
+
 	if (interval > 0)
 		qdf_mc_timer_start(&adapter->host_target_sync_timer, interval);
 }
@@ -1725,6 +2047,8 @@ static enum hdd_tsf_op_result hdd_tsf_sync_init(struct hdd_adapter *adapter)
 		goto fail;
 	}
 
+	hdd_tsf_regular_gpio_pulse_init(adapter);
+
 	net_dev = adapter->dev;
 	if (net_dev && hdd_tsf_is_dbg_fs_set(hddctx))
 		device_create_file(&net_dev->dev, &dev_attr_tsf);
@@ -1757,6 +2081,9 @@ static enum hdd_tsf_op_result hdd_tsf_sync_deinit(struct hdd_adapter *adapter)
 		return HDD_TSF_OP_SUCC;
 
 	hdd_set_th_sync_status(adapter, false);
+
+	hdd_tsf_regular_gpio_pulse_deinit(adapter);
+
 	ret = qdf_mc_timer_destroy(&adapter->host_target_sync_timer);
 	if (ret != QDF_STATUS_SUCCESS)
 		hdd_err("Failed to destroy timer, ret: %d", ret);