qca-wifi: Rename the RCAC State Machine events, states & APIs

Both (ETSI) PreCAC and RCAC are going to use use the same state
machine. The state machine drives the Agile engine and not very specific
to RCAC or PreCAC, therefore let the state machine be called agile state
machine and change the names of all the associated variables accordingly.

In this preparatory change, modify names of all APIs, states and events
to make them common to Agile RCAC and Agile PreCAC

Change-Id: I83835e0295bc97e1099c0e01fc6b2fce62437872

umac/dfs/core/src/misc/dfs_zero_cac.c

@@ -543,7 +543,7 @@ bool dfs_is_precac_done(struct wlan_dfs *dfs, struct dfs_channel *chan)
 
 #ifdef QCA_SUPPORT_AGILE_DFS
 void dfs_find_pdev_for_agile_precac(struct wlan_objmgr_pdev *pdev,
-				    uint8_t *cur_precac_dfs_index)
+				    uint8_t *cur_agile_dfs_index)
 {
 	struct wlan_dfs *dfs;
 	struct dfs_soc_priv_obj *dfs_soc_obj;
@@ -554,8 +554,8 @@ void dfs_find_pdev_for_agile_precac(struct wlan_objmgr_pdev *pdev,
 
 	dfs_soc_obj = dfs->dfs_soc_obj;
 
-	*cur_precac_dfs_index =
-	   (dfs_soc_obj->cur_precac_dfs_index + 1) % dfs_soc_obj->num_dfs_privs;
+	*cur_agile_dfs_index =
+	   (dfs_soc_obj->cur_agile_dfs_index + 1) % dfs_soc_obj->num_dfs_privs;
 }
 
 /*
@@ -591,7 +591,7 @@ void dfs_prepare_agile_precac_chan(struct wlan_dfs *dfs)
 	struct dfs_soc_priv_obj *dfs_soc_obj;
 	struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops;
 	uint16_t ch_freq = 0;
-	uint8_t cur_dfs_idx = 0;
+	uint8_t cur_agile_dfs_idx = 0;
 	uint16_t vhtop_ch_freq_seg1, vhtop_ch_freq_seg2;
 	int i;
 	struct dfs_agile_cac_params adfs_param;
@@ -604,11 +604,11 @@ void dfs_prepare_agile_precac_chan(struct wlan_dfs *dfs)
 	pdev = dfs->dfs_pdev_obj;
 
 	for (i = 0; i < dfs_soc_obj->num_dfs_privs; i++) {
-		dfs_find_pdev_for_agile_precac(pdev, &cur_dfs_idx);
-		dfs_soc_obj->cur_precac_dfs_index = cur_dfs_idx;
-		temp_dfs = dfs_soc_obj->dfs_priv[cur_dfs_idx].dfs;
+		dfs_find_pdev_for_agile_precac(pdev, &cur_agile_dfs_idx);
+		dfs_soc_obj->cur_agile_dfs_index = cur_agile_dfs_idx;
+		temp_dfs = dfs_soc_obj->dfs_priv[cur_agile_dfs_idx].dfs;
 		pdev = temp_dfs->dfs_pdev_obj;
-		if (!dfs_soc_obj->dfs_priv[cur_dfs_idx].agile_precac_active)
+		if (!dfs_soc_obj->dfs_priv[cur_agile_dfs_idx].agile_precac_active)
 			continue;
 
 		vhtop_ch_freq_seg1 =
@@ -1162,7 +1162,7 @@ void dfs_mark_precac_nol_for_freq(struct wlan_dfs *dfs,
 		 * no need to configure agile channel.
 		 * Return from this function.
 		 */
-		if (!(dfs_soc_obj->cur_precac_dfs_index == dfs->dfs_psoc_idx)) {
+		if (!(dfs_soc_obj->cur_agile_dfs_index == dfs->dfs_psoc_idx)) {
 			dfs_debug(dfs, WLAN_DEBUG_DFS,
 				  "preCAC not running on radarfound DFS idx=%d",
 				  dfs->dfs_psoc_idx);
@@ -1453,7 +1453,7 @@ static os_timer_func(dfs_precac_timeout)
 
 	OS_GET_TIMER_ARG(dfs_soc_obj, struct dfs_soc_priv_obj *);
 
-	dfs = dfs_soc_obj->dfs_priv[dfs_soc_obj->cur_precac_dfs_index].dfs;
+	dfs = dfs_soc_obj->dfs_priv[dfs_soc_obj->cur_agile_dfs_index].dfs;
 	dfs_soc_obj->dfs_precac_timer_running = 0;
 
 	if (dfs_is_legacy_precac_enabled(dfs)) {
@@ -2734,8 +2734,8 @@ void dfs_start_precac_timer_for_freq(struct wlan_dfs *dfs,
 	struct dfs_soc_priv_obj *dfs_soc_obj;
 
 	dfs_soc_obj = dfs->dfs_soc_obj;
-	dfs_soc_obj->cur_precac_dfs_index = dfs->dfs_psoc_idx;
-	dfs = dfs_soc_obj->dfs_priv[dfs_soc_obj->cur_precac_dfs_index].dfs;
+	dfs_soc_obj->cur_agile_dfs_index = dfs->dfs_psoc_idx;
+	dfs = dfs_soc_obj->dfs_priv[dfs_soc_obj->cur_agile_dfs_index].dfs;
 #define EXTRA_TIME_IN_SEC 5
 	dfs_soc_obj->dfs_precac_timer_running = 1;
 
@@ -3337,14 +3337,14 @@ dfs_find_dfschan_for_freq(struct wlan_dfs *dfs,
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (!freq) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_RCAC, "Input freq is 0!!");
+		dfs_err(dfs, WLAN_DEBUG_DFS_AGILE, "Input freq is 0!!");
 		return QDF_STATUS_E_FAILURE;
 	}
 
 	mode = dfs_convert_chwidth_to_wlan_phymode(chwidth);
 
 	if (mode == WLAN_PHYMODE_MAX) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_RCAC, "Invalid RCAC mode, user "
+		dfs_err(dfs, WLAN_DEBUG_DFS_AGILE, "Invalid RCAC mode, user "
 				"rcac channel invalid!");
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -3448,7 +3448,7 @@ dfs_is_rcac_chan_valid(struct wlan_dfs *dfs, enum phy_ch_width chwidth,
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 
 	if (chwidth == CH_WIDTH_80P80MHZ) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_RCAC,
+		dfs_err(dfs, WLAN_DEBUG_DFS_AGILE,
 			"RCAC cannot be started for 80P80MHz with single chan");
 		return false;
 	}
@@ -3462,7 +3462,7 @@ dfs_is_rcac_chan_valid(struct wlan_dfs *dfs, enum phy_ch_width chwidth,
 	status = dfs_find_dfschan_for_freq(dfs, rcac_freq, 0, chwidth,
 					   &rcac_chan);
 	if (status != QDF_STATUS_SUCCESS) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_RCAC,
+		dfs_err(dfs, WLAN_DEBUG_DFS_AGILE,
 			"RCAC Channel %d not found for agile width %d",
 			dfs->dfs_agile_rcac_freq_ucfg,
 			chwidth);
@@ -3474,7 +3474,7 @@ dfs_is_rcac_chan_valid(struct wlan_dfs *dfs, enum phy_ch_width chwidth,
 	 */
 	if (dfs_is_new_chan_subset_of_old_chan(dfs, &rcac_chan,
 					       dfs->dfs_curchan)) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_RCAC,
+		dfs_err(dfs, WLAN_DEBUG_DFS_AGILE,
 			"RCAC Channel %d is either a subset of the current"
 			"operating channel or is a non-dfs channel",
 			dfs->dfs_agile_rcac_freq_ucfg);
@@ -3483,7 +3483,7 @@ dfs_is_rcac_chan_valid(struct wlan_dfs *dfs, enum phy_ch_width chwidth,
 
 	/* 3. Reject the RCAC channel if it has NOL channel as its subset. */
 	if (dfs_is_subchans_of_rcac_chan_in_nol(dfs, &rcac_chan)) {
-	    dfs_err(dfs, WLAN_DEBUG_DFS_RCAC,
+	    dfs_err(dfs, WLAN_DEBUG_DFS_AGILE,
 		    "RCAC Channel %d has NOL channels as its subset",
 		    dfs->dfs_agile_rcac_freq_ucfg);
 		return false;
@@ -3517,7 +3517,7 @@ dfs_save_rcac_ch_params(struct wlan_dfs *dfs, struct ch_params rcac_ch_params,
 			rcac_ch_params.mhz_freq_seg0;
 	rcac_param->rcac_ch_params.mhz_freq_seg1 =
 			rcac_ch_params.mhz_freq_seg1;
-	dfs_debug(dfs, WLAN_DEBUG_DFS_RCAC,
+	dfs_debug(dfs, WLAN_DEBUG_DFS_AGILE,
 		  "Saved rcac params: prim_freq: %d, width: %d, cfreq0: %d"
 		  "cfreq1: %d", rcac_param->rcac_pri_freq,
 		  rcac_param->rcac_ch_params.ch_width,
@@ -3612,7 +3612,7 @@ static qdf_freq_t dfs_find_rcac_chan(struct wlan_dfs *dfs,
 	dfs_save_rcac_ch_params(dfs, nxt_chan_params, rcac_freq);
 
 	if (!WLAN_IS_PRIMARY_OR_SECONDARY_CHAN_DFS(&dfs_chan)) {
-		dfs_debug(dfs, WLAN_DEBUG_DFS_RCAC,
+		dfs_debug(dfs, WLAN_DEBUG_DFS_AGILE,
 			  "Not picking an RCAC channel as the random channel"
 			  "cfreq1: %d, cfreq2:%d chosen in non-DFS",
 			  dfs_chan.dfs_ch_vhtop_ch_freq_seg1,
@@ -3621,7 +3621,7 @@ static qdf_freq_t dfs_find_rcac_chan(struct wlan_dfs *dfs,
 	}
 
 	if (nxt_chan_params.ch_width != dfs->dfs_precac_chwidth) {
-		dfs_debug(dfs, WLAN_DEBUG_DFS_RCAC,
+		dfs_debug(dfs, WLAN_DEBUG_DFS_AGILE,
 			  "Not picking an RCAC channel as next channel"
 			  "width: %d is not an agile supported width: %d",
 			  nxt_chan_params.ch_width, dfs->dfs_precac_chwidth);
@@ -3731,7 +3731,7 @@ void dfs_set_agilecac_chan_for_freq(struct wlan_dfs *dfs,
 
 	*ch_freq = dfs->dfs_agile_precac_freq_mhz;
 
-	dfs_debug(dfs, WLAN_DEBUG_DFS_RCAC, "Current channel width: %d,"
+	dfs_debug(dfs, WLAN_DEBUG_DFS_AGILE, "Current channel width: %d,"
 		  "Agile channel width: %d",
 		  curchan_chwidth, agile_chwidth);
 
@@ -3952,7 +3952,7 @@ void dfs_agile_precac_start(struct wlan_dfs *dfs)
 		 dfs->dfs_psoc_idx, dfs);
 
 	if (!dfs_soc_obj->precac_state_started) {
-		dfs_soc_obj->cur_precac_dfs_index = dfs->dfs_psoc_idx;
+		dfs_soc_obj->cur_agile_dfs_index = dfs->dfs_psoc_idx;
 		/*
 		 * Initiate first call to start preCAC here, for channel as 0,
 		 * and ocac_status as 0
@@ -4023,7 +4023,7 @@ uint32_t dfs_get_precac_intermediate_chan(struct wlan_dfs *dfs)
 #ifdef QCA_SUPPORT_AGILE_DFS
 void dfs_reset_agile_config(struct dfs_soc_priv_obj *dfs_soc)
 {
-	dfs_soc->cur_precac_dfs_index = PCAC_DFS_INDEX_ZERO;
+	dfs_soc->cur_agile_dfs_index = PCAC_DFS_INDEX_ZERO;
 	dfs_soc->dfs_precac_timer_running = PCAC_TIMER_NOT_RUNNING;
 	dfs_soc->precac_state_started = PRECAC_NOT_STARTED;
 	dfs_soc->ocac_status = OCAC_SUCCESS;
@@ -4262,17 +4262,17 @@ void dfs_start_agile_engine(struct wlan_dfs *dfs)
  */
 
 /**
- * dfs_rcac_set_curr_state() - API to set the current state of RCAC SM.
+ * dfs_agile_set_curr_state() - API to set the current state of Agile SM.
  * @dfs_soc_obj: Pointer to DFS soc private object.
  * @state: value of current state.
  *
  * Return: void.
  */
-static void dfs_rcac_set_curr_state(struct dfs_soc_priv_obj *dfs_soc_obj,
-				    enum dfs_rcac_sm_state state)
+static void dfs_agile_set_curr_state(struct dfs_soc_priv_obj *dfs_soc_obj,
+				     enum dfs_agile_sm_state state)
 {
-	if (state < DFS_RCAC_S_MAX) {
-		dfs_soc_obj->dfs_rcac_curr_state = state;
+	if (state < DFS_AGILE_S_MAX) {
+		dfs_soc_obj->dfs_agile_sm_cur_state = state;
 	} else {
 		dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS,
 			"DFS RCAC state (%d) is invalid", state);
@@ -4281,32 +4281,32 @@ static void dfs_rcac_set_curr_state(struct dfs_soc_priv_obj *dfs_soc_obj,
 }
 
 /**
- * dfs_rcac_get_curr_state() - API to get current state of RCAC SM.
+ * dfs_agile_get_curr_state() - API to get current state of Agile SM.
  * @dfs_soc_obj: Pointer to DFS soc private object.
  *
  * Return: current state enum of type, dfs_rcac_sm_state.
  */
-static enum dfs_rcac_sm_state
-dfs_rcac_get_curr_state(struct dfs_soc_priv_obj *dfs_soc_obj)
+static enum dfs_agile_sm_state
+dfs_agile_get_curr_state(struct dfs_soc_priv_obj *dfs_soc_obj)
 {
-	return dfs_soc_obj->dfs_rcac_curr_state;
+	return dfs_soc_obj->dfs_agile_sm_cur_state;
 }
 
 /**
- * dfs_rcac_sm_transition_to() - Wrapper API to transition the RCAC SM state.
+ * dfs_rcac_sm_transition_to() - Wrapper API to transition the Agile SM state.
  * @dfs_soc_obj: Pointer to dfs soc private object that hold the SM handle.
  * @state: State to which the SM is transitioning to.
  *
  * Return: void.
  */
-static void dfs_rcac_sm_transition_to(struct dfs_soc_priv_obj *dfs_soc_obj,
-				      enum dfs_rcac_sm_state state)
+static void dfs_agile_sm_transition_to(struct dfs_soc_priv_obj *dfs_soc_obj,
+				       enum dfs_agile_sm_state state)
 {
-	wlan_sm_transition_to(dfs_soc_obj->dfs_rcac_sm_hdl, state);
+	wlan_sm_transition_to(dfs_soc_obj->dfs_agile_sm_hdl, state);
 }
 
 /**
- * dfs_rcac_sm_deliver_event() - API to post events to RCAC SM.
+ * dfs_agile_sm_deliver_event() - API to post events to Agile SM.
  * @dfs_soc_obj: Pointer to dfs soc private object.
  * @event: Event to be posted to the RCAC SM.
  * @event_data_len: Length of event data.
@@ -4319,11 +4319,12 @@ static void dfs_rcac_sm_transition_to(struct dfs_soc_priv_obj *dfs_soc_obj,
  * under a dispatcher API without a lock.
  */
 static
-QDF_STATUS dfs_rcac_sm_deliver_event(struct dfs_soc_priv_obj *dfs_soc_obj,
-				     enum dfs_rcac_sm_evt event,
-				     uint16_t event_data_len, void *event_data)
+QDF_STATUS dfs_agile_sm_deliver_event(struct dfs_soc_priv_obj *dfs_soc_obj,
+				      enum dfs_agile_sm_evt event,
+				      uint16_t event_data_len,
+				      void *event_data)
 {
-	return wlan_sm_dispatch(dfs_soc_obj->dfs_rcac_sm_hdl,
+	return wlan_sm_dispatch(dfs_soc_obj->dfs_agile_sm_hdl,
 				event,
 				event_data_len,
 				event_data);
@@ -4373,39 +4374,39 @@ static void dfs_abort_agile_rcac(struct wlan_dfs *dfs)
 	qdf_mem_zero(&dfs->dfs_rcac_param, sizeof(struct dfs_rcac_params));
 	dfs->dfs_agile_precac_freq_mhz = 0;
 	dfs->dfs_precac_chwidth = CH_WIDTH_INVALID;
-	dfs->dfs_soc_obj->cur_precac_dfs_index = DFS_PSOC_NO_IDX;
+	dfs->dfs_soc_obj->cur_agile_dfs_index = DFS_PSOC_NO_IDX;
 }
 
 /**
- * dfs_rcac_state_init_entry() - Entry API for INIT state
+ * dfs_agile_state_init_entry() - Entry API for INIT state
  * @ctx: DFS SoC private object
  *
  * API to perform operations on moving to INIT state
  *
  * Return: void
  */
-static void dfs_rcac_state_init_entry(void *ctx)
+static void dfs_agile_state_init_entry(void *ctx)
 {
 	struct dfs_soc_priv_obj *dfs_soc = (struct dfs_soc_priv_obj *)ctx;
 
-	dfs_rcac_set_curr_state(dfs_soc, DFS_RCAC_S_INIT);
+	dfs_agile_set_curr_state(dfs_soc, DFS_AGILE_S_INIT);
 }
 
 /**
- * dfs_rcac_state_init_exit() - Exit API for INIT state
+ * dfs_agile_state_init_exit() - Exit API for INIT state
  * @ctx: DFS SoC private object
  *
  * API to perform operations on moving out of INIT state
  *
  * Return: void
  */
-static void dfs_rcac_state_init_exit(void *ctx)
+static void dfs_agile_state_init_exit(void *ctx)
 {
 	/* NO OPS */
 }
 
 /**
- * dfs_rcac_state_init_event() - INIT State event handler
+ * dfs_agile_state_init_event() - INIT State event handler
  * @ctx: DFS SoC private object
  * @event: Event posted to the SM.
  * @event_data_len: Length of event data.
@@ -4416,7 +4417,7 @@ static void dfs_rcac_state_init_exit(void *ctx)
  * Return: TRUE:  on handling event
  *         FALSE: on ignoring the event
  */
-static bool dfs_rcac_state_init_event(void *ctx,
+static bool dfs_agile_state_init_event(void *ctx,
 				      uint16_t event,
 				      uint16_t event_data_len,
 				      void *event_data)
@@ -4432,18 +4433,18 @@ static bool dfs_rcac_state_init_event(void *ctx,
 	dfs = (struct wlan_dfs *)event_data;
 
 	switch (event) {
-	case DFS_RCAC_SM_EV_RCAC_START:
+	case DFS_AGILE_SM_EV_AGILE_START:
 		/* Check if feature is enabled for this DFS and if RCAC channel
 		 * is valid, if those are true, send appropriate WMIs to FW
 		 * and only then transition to the state as follows.
 		 */
 
-		if (dfs_soc->cur_precac_dfs_index != DFS_PSOC_NO_IDX)
+		if (dfs_soc->cur_agile_dfs_index != DFS_PSOC_NO_IDX)
 			return true;
 		dfs_prepare_agile_rcac_channel(dfs, &is_rcac_chan_available);
 		if (is_rcac_chan_available) {
-			dfs_soc->cur_precac_dfs_index = dfs->dfs_psoc_idx;
-			dfs_rcac_sm_transition_to(dfs_soc, DFS_RCAC_S_RUNNING);
+			dfs_soc->cur_agile_dfs_index = dfs->dfs_psoc_idx;
+			dfs_agile_sm_transition_to(dfs_soc, DFS_AGILE_S_RUNNING);
 		}
 		status = true;
 		break;
@@ -4456,39 +4457,39 @@ static bool dfs_rcac_state_init_event(void *ctx,
 }
 
 /**
- * dfs_rcac_state_running_entry() - Entry API for running state
+ * dfs_agile_state_running_entry() - Entry API for running state
  * @ctx: DFS SoC private object
  *
  * API to perform operations on moving to running state
  *
  * Return: void
  */
-static void dfs_rcac_state_running_entry(void *ctx)
+static void dfs_agile_state_running_entry(void *ctx)
 {
 	struct dfs_soc_priv_obj *dfs_soc = (struct dfs_soc_priv_obj *)ctx;
 	struct wlan_dfs *dfs =
-		dfs_soc->dfs_priv[dfs_soc->cur_precac_dfs_index].dfs;
+		dfs_soc->dfs_priv[dfs_soc->cur_agile_dfs_index].dfs;
 
-	dfs_rcac_set_curr_state(dfs_soc, DFS_RCAC_S_RUNNING);
+	dfs_agile_set_curr_state(dfs_soc, DFS_AGILE_S_RUNNING);
 	dfs_start_agile_rcac_timer(dfs);
 	dfs_start_agile_engine(dfs);
 }
 
 /**
- * dfs_rcac_state_running_exit() - Exit API for RUNNING state
+ * dfs_agile_state_running_exit() - Exit API for RUNNING state
  * @ctx: DFS SoC private object
  *
  * API to perform operations on moving out of RUNNING state
  *
  * Return: void
  */
-static void dfs_rcac_state_running_exit(void *ctx)
+static void dfs_agile_state_running_exit(void *ctx)
 {
 	/* NO OPS */
 }
 
 /**
- * dfs_rcac_state_running_event() - RUNNING State event handler
+ * dfs_agile_state_running_event() - RUNNING State event handler
  * @ctx: DFS SoC private object
  * @event: Event posted to the SM.
  * @event_data_len: Length of event data.
@@ -4499,7 +4500,7 @@ static void dfs_rcac_state_running_exit(void *ctx)
  * Return: TRUE:  on handling event
  *         FALSE: on ignoring the event
  */
-static bool dfs_rcac_state_running_event(void *ctx,
+static bool dfs_agile_state_running_event(void *ctx,
 					 uint16_t event,
 					 uint16_t event_data_len,
 					 void *event_data)
@@ -4513,37 +4514,37 @@ static bool dfs_rcac_state_running_event(void *ctx,
 
 	dfs = (struct wlan_dfs *)event_data;
 
-	if (dfs->dfs_psoc_idx != dfs_soc->cur_precac_dfs_index)
+	if (dfs->dfs_psoc_idx != dfs_soc->cur_agile_dfs_index)
 		return false;
 
 	switch (event) {
-	case DFS_RCAC_SM_EV_ADFS_RADAR_FOUND:
+	case DFS_AGILE_SM_EV_ADFS_RADAR:
 		/* After radar is found on the Agile channel we need to find
 		 * a new channel and then start Agile CAC on that.
-		 * On receiving the "DFS_RCAC_SM_EV_ADFS_RADAR_FOUND" if
+		 * On receiving the "DFS_AGILE_SM_EV_ADFS_RADAR_FOUND" if
 		 * we change the state from [RUNNING] -> [RUNNING] then
 		 * [RUNNING] should handle case in which a channel is not found
 		 * and bring the state machine back to INIT.
 		 * Instead we move the state to INIT and post the event
-		 * "DFS_RCAC_SM_EV_RCAC_START" so INIT handles the case of
+		 * "DFS_AGILE_SM_EV_AGILE_START" so INIT handles the case of
 		 * channel not found and stay in that state.
 		 * Abort the existing RCAC and restart from INIT state.
 		 */
 		dfs_abort_agile_rcac(dfs);
-		dfs_rcac_sm_transition_to(dfs_soc, DFS_RCAC_S_INIT);
-		dfs_rcac_sm_deliver_event(dfs_soc,
-					  DFS_RCAC_SM_EV_RCAC_START,
+		dfs_agile_sm_transition_to(dfs_soc, DFS_AGILE_S_INIT);
+		dfs_agile_sm_deliver_event(dfs_soc,
+					  DFS_AGILE_SM_EV_AGILE_START,
 					  event_data_len,
 					  event_data);
 		status = true;
 		break;
-	case DFS_RCAC_SM_EV_RCAC_STOP:
+	case DFS_AGILE_SM_EV_AGILE_STOP:
 		dfs_abort_agile_rcac(dfs);
-		dfs_rcac_sm_transition_to(dfs_soc, DFS_RCAC_S_INIT);
+		dfs_agile_sm_transition_to(dfs_soc, DFS_AGILE_S_INIT);
 		status = true;
 		break;
-	case DFS_RCAC_SM_EV_RCAC_DONE:
-		dfs_rcac_sm_transition_to(dfs_soc, DFS_RCAC_S_COMPLETE);
+	case DFS_AGILE_SM_EV_AGILE_DONE:
+		dfs_agile_sm_transition_to(dfs_soc, DFS_AGILE_S_COMPLETE);
 		status = true;
 	default:
 		status = false;
@@ -4554,44 +4555,44 @@ static bool dfs_rcac_state_running_event(void *ctx,
 }
 
 /**
- * dfs_rcac_state_complete_entry() - Entry API for complete state
+ * dfs_agile_state_complete_entry() - Entry API for complete state
  * @ctx: DFS SoC private object
  *
  * API to perform operations on moving to complete state
  *
  * Return: void
  */
-static void dfs_rcac_state_complete_entry(void *ctx)
+static void dfs_agile_state_complete_entry(void *ctx)
 {
 	struct dfs_soc_priv_obj *dfs_soc_obj = (struct dfs_soc_priv_obj *)ctx;
 	struct wlan_dfs *dfs;
 
-	dfs_rcac_set_curr_state(dfs_soc_obj, DFS_RCAC_S_COMPLETE);
+	dfs_agile_set_curr_state(dfs_soc_obj, DFS_AGILE_S_COMPLETE);
 
-	if (!(dfs_soc_obj->cur_precac_dfs_index < WLAN_UMAC_MAX_PDEVS))
+	if (!(dfs_soc_obj->cur_agile_dfs_index < WLAN_UMAC_MAX_PDEVS))
 		return;
 
-	dfs = dfs_soc_obj->dfs_priv[dfs_soc_obj->cur_precac_dfs_index].dfs;
+	dfs = dfs_soc_obj->dfs_priv[dfs_soc_obj->cur_agile_dfs_index].dfs;
 
 	/* Mark the RCAC channel as CAC done. */
 	dfs_mark_adfs_chan_as_cac_done(dfs);
 }
 
 /**
- * dfs_rcac_state_complete_exit() - Exit API for complete state
+ * dfs_agile_state_complete_exit() - Exit API for complete state
  * @ctx: DFS SoC private object
  *
  * API to perform operations on moving out of complete state
  *
  * Return: void
  */
-static void dfs_rcac_state_complete_exit(void *ctx)
+static void dfs_agile_state_complete_exit(void *ctx)
 {
 	/* NO OPs. */
 }
 
 /**
- * dfs_rcac_state_complete_event() - COMPLETE State event handler
+ * dfs_agile_state_complete_event() - COMPLETE State event handler
  * @ctx: DFS SoC private object
  * @event: Event posted to the SM.
  * @event_data_len: Length of event data.
@@ -4602,7 +4603,7 @@ static void dfs_rcac_state_complete_exit(void *ctx)
  * Return: TRUE:  on handling event
  *         FALSE: on ignoring the event
  */
-static bool dfs_rcac_state_complete_event(void *ctx,
+static bool dfs_agile_state_complete_event(void *ctx,
 					  uint16_t event,
 					  uint16_t event_data_len,
 					  void *event_data)
@@ -4616,33 +4617,33 @@ static bool dfs_rcac_state_complete_event(void *ctx,
 
 	dfs = (struct wlan_dfs *)event_data;
 
-	if (dfs->dfs_psoc_idx != dfs_soc->cur_precac_dfs_index)
+	if (dfs->dfs_psoc_idx != dfs_soc->cur_agile_dfs_index)
 		return false;
 
 	switch (event) {
-	case DFS_RCAC_SM_EV_ADFS_RADAR_FOUND:
+	case DFS_AGILE_SM_EV_ADFS_RADAR:
 		/* Reset the RCAC done state for this RCAC chan of this dfs.
 		 * Unmark the channels for RCAC done before calling abort API as
-		 * the abort API invalidates the cur_precac_dfs_index.
+		 * the abort API invalidates the cur_agile_dfs_index.
 		 */
 		dfs_unmark_rcac_done(dfs);
 		/* Abort the existing RCAC and restart from INIT state. */
 		dfs_abort_agile_rcac(dfs);
-		dfs_rcac_sm_transition_to(dfs_soc, DFS_RCAC_S_INIT);
-		dfs_rcac_sm_deliver_event(dfs_soc,
-					  DFS_RCAC_SM_EV_RCAC_START,
+		dfs_agile_sm_transition_to(dfs_soc, DFS_AGILE_S_INIT);
+		dfs_agile_sm_deliver_event(dfs_soc,
+					  DFS_AGILE_SM_EV_AGILE_START,
 					  event_data_len,
 					  event_data);
 		status = true;
 		break;
-	case DFS_RCAC_SM_EV_RCAC_STOP:
+	case DFS_AGILE_SM_EV_AGILE_STOP:
 		/* Reset the RCAC done state for this RCAC chan of this dfs.
 		 * Unmark the channels for RCAC done before calling abort API as
-		 * the abort API invalidates the cur_precac_dfs_index.
+		 * the abort API invalidates the cur_agile_dfs_index.
 		 */
 		dfs_unmark_rcac_done(dfs);
 		dfs_abort_agile_rcac(dfs);
-		dfs_rcac_sm_transition_to(dfs_soc, DFS_RCAC_S_INIT);
+		dfs_agile_sm_transition_to(dfs_soc, DFS_AGILE_S_INIT);
 		status = true;
 		break;
 	default:
@@ -4653,142 +4654,142 @@ static bool dfs_rcac_state_complete_event(void *ctx,
 	return status;
 }
 
-static struct wlan_sm_state_info dfs_rcac_sm_info[] = {
+static struct wlan_sm_state_info dfs_agile_sm_info[] = {
 	{
-		(uint8_t)DFS_RCAC_S_INIT,
+		(uint8_t)DFS_AGILE_S_INIT,
 		(uint8_t)WLAN_SM_ENGINE_STATE_NONE,
 		(uint8_t)WLAN_SM_ENGINE_STATE_NONE,
 		false,
 		"INIT",
-		dfs_rcac_state_init_entry,
-		dfs_rcac_state_init_exit,
-		dfs_rcac_state_init_event
+		dfs_agile_state_init_entry,
+		dfs_agile_state_init_exit,
+		dfs_agile_state_init_event
 	},
 	{
-		(uint8_t)DFS_RCAC_S_RUNNING,
+		(uint8_t)DFS_AGILE_S_RUNNING,
 		(uint8_t)WLAN_SM_ENGINE_STATE_NONE,
 		(uint8_t)WLAN_SM_ENGINE_STATE_NONE,
 		false,
 		"RUNNING",
-		dfs_rcac_state_running_entry,
-		dfs_rcac_state_running_exit,
-		dfs_rcac_state_running_event
+		dfs_agile_state_running_entry,
+		dfs_agile_state_running_exit,
+		dfs_agile_state_running_event
 	},
 	{
-		(uint8_t)DFS_RCAC_S_COMPLETE,
+		(uint8_t)DFS_AGILE_S_COMPLETE,
 		(uint8_t)WLAN_SM_ENGINE_STATE_NONE,
 		(uint8_t)WLAN_SM_ENGINE_STATE_NONE,
 		false,
 		"COMPLETE",
-		dfs_rcac_state_complete_entry,
-		dfs_rcac_state_complete_exit,
-		dfs_rcac_state_complete_event
+		dfs_agile_state_complete_entry,
+		dfs_agile_state_complete_exit,
+		dfs_agile_state_complete_event
 	},
 };
 
-static const char *dfs_rcac_sm_event_names[] = {
-	"EV_RCAC_START",
-	"EV_RCAC_STOP",
-	"EV_RCAC_DONE",
+static const char *dfs_agile_sm_event_names[] = {
+	"EV_AGILE_START",
+	"EV_AGILE_STOP",
+	"EV_AGILE_DONE",
 	"EV_ADFS_RADAR_FOUND",
 };
 
 /**
- * dfs_rcac_sm_print_state() - API to log the current state.
+ * dfs_agile_sm_print_state() - API to log the current state.
  * @dfs_soc_obj: Pointer to dfs soc private object.
  *
  * Return: void.
  */
-static void dfs_rcac_sm_print_state(struct dfs_soc_priv_obj *dfs_soc_obj)
+static void dfs_agile_sm_print_state(struct dfs_soc_priv_obj *dfs_soc_obj)
 {
-	enum dfs_rcac_sm_state state;
+	enum dfs_agile_sm_state state;
 
-	state = dfs_rcac_get_curr_state(dfs_soc_obj);
-	if (!(state < DFS_RCAC_S_MAX))
+	state = dfs_agile_get_curr_state(dfs_soc_obj);
+	if (!(state < DFS_AGILE_S_MAX))
 		return;
 
-	dfs_debug(NULL, WLAN_DEBUG_DFS_RCAC, "->[%s] %s",
-		  dfs_soc_obj->dfs_rcac_sm_hdl->name,
-		  dfs_rcac_sm_info[state].name);
+	dfs_debug(NULL, WLAN_DEBUG_DFS_AGILE, "->[%s] %s",
+		  dfs_soc_obj->dfs_agile_sm_hdl->name,
+		  dfs_agile_sm_info[state].name);
 }
 
 /**
- * dfs_rcac_sm_print_state_event() - API to log the current state and event
+ * dfs_agile_sm_print_state_event() - API to log the current state and event
  *                                   received.
  * @dfs_soc_obj: Pointer to dfs soc private object.
  * @event: Event posted to RCAC SM.
  *
  * Return: void.
  */
-static void dfs_rcac_sm_print_state_event(struct dfs_soc_priv_obj *dfs_soc_obj,
-					  enum dfs_rcac_sm_evt event)
+static void dfs_agile_sm_print_state_event(struct dfs_soc_priv_obj *dfs_soc_obj,
+					  enum dfs_agile_sm_evt event)
 {
-	enum dfs_rcac_sm_state state;
+	enum dfs_agile_sm_state state;
 
-	state = dfs_rcac_get_curr_state(dfs_soc_obj);
-	if (!(state < DFS_RCAC_S_MAX))
+	state = dfs_agile_get_curr_state(dfs_soc_obj);
+	if (!(state < DFS_AGILE_S_MAX))
 		return;
 
-	dfs_debug(NULL, WLAN_DEBUG_DFS_RCAC, "[%s]%s, %s",
-		  dfs_soc_obj->dfs_rcac_sm_hdl->name,
-		  dfs_rcac_sm_info[state].name,
-		  dfs_rcac_sm_event_names[event]);
+	dfs_debug(NULL, WLAN_DEBUG_DFS_AGILE, "[%s]%s, %s",
+		  dfs_soc_obj->dfs_agile_sm_hdl->name,
+		  dfs_agile_sm_info[state].name,
+		  dfs_agile_sm_event_names[event]);
 }
 
-QDF_STATUS dfs_rcac_sm_deliver_evt(struct dfs_soc_priv_obj *dfs_soc_obj,
-				   enum dfs_rcac_sm_evt event,
+QDF_STATUS dfs_agile_sm_deliver_evt(struct dfs_soc_priv_obj *dfs_soc_obj,
+				   enum dfs_agile_sm_evt event,
 				   uint16_t event_data_len,
 				   void *event_data)
 {
-	enum dfs_rcac_sm_state old_state, new_state;
+	enum dfs_agile_sm_state old_state, new_state;
 	QDF_STATUS status;
 
-	DFS_RCAC_SM_SPIN_LOCK(dfs_soc_obj);
-	old_state = dfs_rcac_get_curr_state(dfs_soc_obj);
+	DFS_AGILE_SM_SPIN_LOCK(dfs_soc_obj);
+	old_state = dfs_agile_get_curr_state(dfs_soc_obj);
 
 	/* Print current state and event received */
-	dfs_rcac_sm_print_state_event(dfs_soc_obj, event);
+	dfs_agile_sm_print_state_event(dfs_soc_obj, event);
 
-	status = dfs_rcac_sm_deliver_event(dfs_soc_obj, event,
+	status = dfs_agile_sm_deliver_event(dfs_soc_obj, event,
 					   event_data_len, event_data);
 
-	new_state = dfs_rcac_get_curr_state(dfs_soc_obj);
+	new_state = dfs_agile_get_curr_state(dfs_soc_obj);
 
 	/* Print new state after event if transition happens */
 	if (old_state != new_state)
-		dfs_rcac_sm_print_state(dfs_soc_obj);
-	DFS_RCAC_SM_SPIN_UNLOCK(dfs_soc_obj);
+		dfs_agile_sm_print_state(dfs_soc_obj);
+	DFS_AGILE_SM_SPIN_UNLOCK(dfs_soc_obj);
 
 	return status;
 }
 
-QDF_STATUS dfs_rcac_sm_create(struct dfs_soc_priv_obj *dfs_soc_obj)
+QDF_STATUS dfs_agile_sm_create(struct dfs_soc_priv_obj *dfs_soc_obj)
 {
 	struct wlan_sm *sm;
 
-	sm = wlan_sm_create("DFS_RCAC", dfs_soc_obj,
-			    DFS_RCAC_S_INIT,
-			    dfs_rcac_sm_info,
-			    QDF_ARRAY_SIZE(dfs_rcac_sm_info),
-			    dfs_rcac_sm_event_names,
-			    QDF_ARRAY_SIZE(dfs_rcac_sm_event_names));
+	sm = wlan_sm_create("DFS_AGILE", dfs_soc_obj,
+			    DFS_AGILE_S_INIT,
+			    dfs_agile_sm_info,
+			    QDF_ARRAY_SIZE(dfs_agile_sm_info),
+			    dfs_agile_sm_event_names,
+			    QDF_ARRAY_SIZE(dfs_agile_sm_event_names));
 	if (!sm) {
-		qdf_err("DFS RCAC SM allocation failed");
+		qdf_err("DFS AGILE SM allocation failed");
 		return QDF_STATUS_E_FAILURE;
 	}
-	dfs_soc_obj->dfs_rcac_sm_hdl = sm;
+	dfs_soc_obj->dfs_agile_sm_hdl = sm;
 
-	qdf_spinlock_create(&dfs_soc_obj->dfs_rcac_sm_lock);
+	qdf_spinlock_create(&dfs_soc_obj->dfs_agile_sm_lock);
 
 	/* Initialize the RCAC DFS index to default (no index). */
-	dfs_soc_obj->cur_precac_dfs_index = DFS_PSOC_NO_IDX;
+	dfs_soc_obj->cur_agile_dfs_index = DFS_PSOC_NO_IDX;
 	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS dfs_rcac_sm_destroy(struct dfs_soc_priv_obj *dfs_soc_obj)
+QDF_STATUS dfs_agile_sm_destroy(struct dfs_soc_priv_obj *dfs_soc_obj)
 {
-	wlan_sm_delete(dfs_soc_obj->dfs_rcac_sm_hdl);
-	qdf_spinlock_destroy(&dfs_soc_obj->dfs_rcac_sm_lock);
+	wlan_sm_delete(dfs_soc_obj->dfs_agile_sm_hdl);
+	qdf_spinlock_destroy(&dfs_soc_obj->dfs_agile_sm_lock);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -4806,8 +4807,8 @@ QDF_STATUS dfs_set_rcac_enable(struct wlan_dfs *dfs, bool rcac_en)
 	dfs_reset_precac_lists(dfs);
 
 	if (!rcac_en) {
-		dfs_rcac_sm_deliver_evt(dfs->dfs_soc_obj,
-					DFS_RCAC_SM_EV_RCAC_STOP,
+		dfs_agile_sm_deliver_evt(dfs->dfs_soc_obj,
+					DFS_AGILE_SM_EV_AGILE_STOP,
 					0,
 					(void *)dfs);
 	}
@@ -4857,10 +4858,10 @@ static os_timer_func(dfs_rcac_timeout)
 
 	OS_GET_TIMER_ARG(dfs_soc_obj, struct dfs_soc_priv_obj *);
 
-	dfs = dfs_soc_obj->dfs_priv[dfs_soc_obj->cur_precac_dfs_index].dfs;
+	dfs = dfs_soc_obj->dfs_priv[dfs_soc_obj->cur_agile_dfs_index].dfs;
 
-	dfs_rcac_sm_deliver_evt(dfs_soc_obj,
-				DFS_RCAC_SM_EV_RCAC_DONE,
+	dfs_agile_sm_deliver_evt(dfs_soc_obj,
+				DFS_AGILE_SM_EV_AGILE_DONE,
 				0,
 				(void *)dfs);
 }
@@ -4899,7 +4900,7 @@ void dfs_prepare_agile_rcac_channel(struct wlan_dfs *dfs,
 	 * variables.
 	 */
 	*is_rcac_chan_available = rcac_ch_freq ? true : false;
-	dfs_debug(dfs, WLAN_DEBUG_DFS_RCAC, "Chosen rcac channel: %d",
+	dfs_debug(dfs, WLAN_DEBUG_DFS_AGILE, "Chosen rcac channel: %d",
 		  rcac_ch_freq);
 }
 #endif