qcacmn: 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: I67858839589145bf4377a7eafec7c21ca4823141
CRs-Fixed: 2711104

umac/dfs/core/src/dfs.h

@@ -941,17 +941,20 @@ struct dfs_mode_switch_defer_params {
 #ifdef QCA_SUPPORT_ADFS_RCAC
 #define DFS_PSOC_NO_IDX 0xFF
 /**
- * enum dfs_rcac_sm_state - DFS Rolling CAC SM states.
- * @DFS_RCAC_S_INIT:     Default state, where RCAC not in progress.
- * @DFS_RCAC_S_RUNNING:  RCAC is in progress.
- * @DFS_RCAC_S_COMPLETE: RCAC is completed.
- * @DFS_RCAC_S_MAX:      Max (invalid) state.
- */
-enum dfs_rcac_sm_state {
-	DFS_RCAC_S_INIT,
-	DFS_RCAC_S_RUNNING,
-	DFS_RCAC_S_COMPLETE,
-	DFS_RCAC_S_MAX,
+ * enum dfs_agile_sm_state - DFS AGILE SM states.
+ * @DFS_AGILE_S_INIT:     Default state or the start state of the Agile SM.
+ * @DFS_AGILE_S_RUNNING:  Agile Engine is being run.
+ * @DFS_AGILE_S_COMPLETE: The Agile Engine's minimum run is complete.
+			  However, it is still running. Used only for RCAC
+			  as RCAC needs to run continuously (uninterrupted)
+			  until the channel change.
+ * @DFS_AGILE_S_MAX:      Max (invalid) state.
+ */
+enum dfs_agile_sm_state {
+	DFS_AGILE_S_INIT,
+	DFS_AGILE_S_RUNNING,
+	DFS_AGILE_S_COMPLETE,
+	DFS_AGILE_S_MAX,
 };
 
 /**
@@ -1334,14 +1337,16 @@ struct wlan_dfs_priv {
  *                                radar detection related information to host.
  * @dfs_priv: array of dfs private structs with agile capability info
  * @num_dfs_privs: array size of dfs private structs for given psoc.
- * @cur_precac_dfs_index: current precac dfs index
+ * @cur_dfs_index: index of the current dfs object using the Agile Engine.
+ *                 It is used to index struct wlan_dfs_priv dfs_priv[] array.
  * @dfs_precac_timer: agile precac timer
  * @dfs_precac_timer_running: precac timer running flag
  * @ocac_status: Off channel CAC complete status
  * @dfs_nol_ctx: dfs NOL data for all radios.
  * @dfs_rcac_timer: Agile RCAC (Rolling CAC) timer.
- * @dfs_rcac_sm_hdl: DFS Rolling CAC state machine handle.
- * @dfs_rcac_curr_state: Current state of DFS rolling CAC state machine.
+ * @dfs_agile_sm_hdl: The handle for the state machine that drives Agile
+ *                    Engine.
+ * @dfs_agile_sm_cur_state: Current state of the Agile State Machine.
  * @dfs_rcac_sm_lock: DFS Rolling CAC state machine lock.
  */
 struct dfs_soc_priv_obj {
@@ -1351,7 +1356,7 @@ struct dfs_soc_priv_obj {
 #if defined(QCA_SUPPORT_AGILE_DFS) || defined(ATH_SUPPORT_ZERO_CAC_DFS)
 	struct wlan_dfs_priv dfs_priv[WLAN_UMAC_MAX_PDEVS];
 	uint8_t num_dfs_privs;
-	uint8_t cur_precac_dfs_index;
+	uint8_t cur_agile_dfs_index;
 	qdf_timer_t     dfs_precac_timer;
 	uint8_t dfs_precac_timer_running;
 	bool precac_state_started;
@@ -1360,9 +1365,9 @@ struct dfs_soc_priv_obj {
 	struct dfsreq_nolinfo *dfs_psoc_nolinfo;
 #if defined(QCA_SUPPORT_ADFS_RCAC)
 	qdf_timer_t dfs_rcac_timer;
-	struct wlan_sm *dfs_rcac_sm_hdl;
-	enum dfs_rcac_sm_state dfs_rcac_curr_state;
-	qdf_spinlock_t dfs_rcac_sm_lock;
+	struct wlan_sm *dfs_agile_sm_hdl;
+	enum dfs_agile_sm_state dfs_agile_sm_cur_state;
+	qdf_spinlock_t dfs_agile_sm_lock;
 #endif
 };
 
@@ -1383,6 +1388,7 @@ struct dfs_soc_priv_obj {
  * @WLAN_DEBUG_DFS_FALSE_DET2:  Second level check to confirm poisitive
  *                              detection.
  * @WLAN_DEBUG_DFS_RANDOM_CHAN: Random channel selection.
+ * @WLAN_DEBUG_DFS_AGILE:       Agile PreCAC/RCAC
  */
 enum {
 	WLAN_DEBUG_DFS  = 0x00000100,
@@ -1399,7 +1405,7 @@ enum {
 	WLAN_DEBUG_DFS_FALSE_DET  = 0x00080000,
 	WLAN_DEBUG_DFS_FALSE_DET2 = 0x00100000,
 	WLAN_DEBUG_DFS_RANDOM_CHAN = 0x00200000,
-	WLAN_DEBUG_DFS_RCAC       = 0x00400000,
+	WLAN_DEBUG_DFS_AGILE       = 0x00400000,
 	WLAN_DEBUG_DFS_MAX        = 0x80000000,
 	WLAN_DEBUG_DFS_ALWAYS     = WLAN_DEBUG_DFS_MAX
 };

umac/dfs/core/src/dfs_zero_cac.h

@@ -557,10 +557,10 @@ void dfs_find_vht80_chan_for_precac_for_freq(struct wlan_dfs *dfs,
 /**
  * dfs_find_pdev_for_agile_precac() - Find pdev to select channel for precac.
  * @pdev: Pointer to wlan_objmgr_pdev structure.
- * @cur_precac_dfs_index: current precac index
+ * @cur_agile_dfs_index: current agile dfs index
  */
 void dfs_find_pdev_for_agile_precac(struct wlan_objmgr_pdev *pdev,
-				    uint8_t *cur_precac_dfs_index);
+				    uint8_t *cur_agile_dfs_index);
 
 /**
  * dfs_prepare_agile_precac_chan() - Send Agile set request for given pdev.
@@ -652,7 +652,7 @@ void dfs_set_fw_adfs_support(struct wlan_dfs *dfs,
 			     bool fw_adfs_support_non_160);
 #else
 static inline void dfs_find_pdev_for_agile_precac(struct wlan_objmgr_pdev *pdev,
-						  uint8_t *cur_precac_dfs_index)
+						  uint8_t *cur_agile_dfs_index)
 {
 }
 
@@ -1250,13 +1250,13 @@ dfs_rcac_timer_deinit(struct dfs_soc_priv_obj *dfs_soc_obj)
 #endif
 
 #ifdef QCA_SUPPORT_ADFS_RCAC
-#define DFS_RCAC_SM_SPIN_LOCK(_soc_obj) \
-	qdf_spin_lock_bh(&((_soc_obj)->dfs_rcac_sm_lock))
-#define DFS_RCAC_SM_SPIN_UNLOCK(_soc_obj) \
-	qdf_spin_unlock_bh(&((_soc_obj)->dfs_rcac_sm_lock))
+#define DFS_AGILE_SM_SPIN_LOCK(_soc_obj) \
+	qdf_spin_lock_bh(&((_soc_obj)->dfs_agile_sm_lock))
+#define DFS_AGILE_SM_SPIN_UNLOCK(_soc_obj) \
+	qdf_spin_unlock_bh(&((_soc_obj)->dfs_agile_sm_lock))
 
 /**
- * dfs_rcac_sm_deliver_evt() - Deliver the event to RCAC SM.
+ * dfs_agile_sm_deliver_evt() - Deliver the event to AGILE SM.
  * @dfs_soc_obj: Pointer to DFS soc object that holds the SM handle.
  * @event: Event ID.
  * @event_data_len: Length of event data.
@@ -1264,29 +1264,29 @@ dfs_rcac_timer_deinit(struct dfs_soc_priv_obj *dfs_soc_obj)
  *
  * Return: Success if event is handled, else failure.
  */
-QDF_STATUS dfs_rcac_sm_deliver_evt(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_evt(struct dfs_soc_priv_obj *dfs_soc_obj,
+				    enum dfs_agile_sm_evt event,
+				    uint16_t event_data_len,
+				    void *event_data);
 
 /**
- * dfs_rcac_sm_create() - Create the Rolling CAC state machine.
+ * dfs_agile_sm_create() - Create the AGILE state machine.
  * @dfs_soc_obj: Pointer to dfs_soc object that holds the SM handle.
  *
  * Return: QDF_STATUS_SUCCESS if successful, else failure 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);
 
 /**
- * dfs_rcac_sm_destroy() - Destroy the Rolling CAC state machine.
+ * dfs_agile_sm_destroy() - Destroy the AGILE state machine.
  * @dfs_soc_obj: Pointer to dfs_soc object that holds the SM handle.
  *
  * Return: QDF_STATUS_SUCCESS if successful, else failure status.
  */
-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);
 
 /**
- * dfs_is_agile_rcac_enabled() - Determine if Rolling CAC is supported or not.
+ * dfs_is_agile_rcac_enabled() - Determine if Rolling CAC is enabled or not.
  * @dfs: Pointer to struct wlan_dfs.
  *
  * Following are the conditions needed to assertain that rolling CAC
@@ -1312,22 +1312,22 @@ void dfs_prepare_agile_rcac_channel(struct wlan_dfs *dfs,
 				    bool *is_rcac_chan_available);
 #else
 static inline
-QDF_STATUS dfs_rcac_sm_deliver_evt(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_evt(struct dfs_soc_priv_obj *dfs_soc_obj,
+				    enum dfs_agile_sm_evt event,
+				    uint16_t event_data_len,
+				    void *event_data)
 {
 	return QDF_STATUS_SUCCESS;
 }
 
 static inline
-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)
 {
 	return QDF_STATUS_SUCCESS;
 }
 
 static inline
-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)
 {
 	return QDF_STATUS_SUCCESS;
 }

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

@@ -316,8 +316,8 @@ static os_timer_func(dfs_remove_from_nol)
 	dfs_debug(dfs, WLAN_DEBUG_DFS_NOL,
 		  "remove channel %d from nol", chan);
 	utils_dfs_unmark_precac_nol_for_freq(dfs->dfs_pdev_obj, delfreq);
-	utils_dfs_rcac_sm_deliver_evt(dfs->dfs_pdev_obj,
-				      DFS_RCAC_SM_EV_RCAC_START);
+	utils_dfs_agile_sm_deliver_evt(dfs->dfs_pdev_obj,
+				       DFS_AGILE_SM_EV_AGILE_START);
 	utils_dfs_reg_update_nol_chan_for_freq(dfs->dfs_pdev_obj,
 					     &delfreq, 1, DFS_NOL_RESET);
 	utils_dfs_save_nol(dfs->dfs_pdev_obj);

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

@@ -1238,8 +1238,8 @@ QDF_STATUS dfs_process_radar_ind(struct wlan_dfs *dfs,
 
 	if (dfs_is_agile_rcac_enabled(dfs) &&
 	    radar_found->detector_id == dfs_get_agile_detector_id(dfs))
-		utils_dfs_rcac_sm_deliver_evt(dfs->dfs_pdev_obj,
-					      DFS_RCAC_SM_EV_ADFS_RADAR_FOUND);
+		utils_dfs_agile_sm_deliver_evt(dfs->dfs_pdev_obj,
+					       DFS_AGILE_SM_EV_ADFS_RADAR);
 	/*
 	 * This calls into the umac DFS code, which sets the umac
 	 * related radar flags and begins the channel change

umac/dfs/dispatcher/inc/wlan_dfs_ioctl.h

@@ -360,17 +360,17 @@ struct seq_store {
 #endif /* WLAN_DFS_PARTIAL_OFFLOAD && WLAN_DFS_SYNTHETIC_RADAR */
 
 /**
- * enum dfs_rcac_sm_evt - DFS Rolling CAC SM events.
- * @DFS_RCAC_SM_EV_RCAC_START: Event to start RCAC.
- * @DFS_RCAC_SM_EV_RCAC_DOWN:  Event to stop RCAC.
- * @DFS_RCAC_SM_EV_RCAC_DONE:  Event to complete RCAC.
- * @DFS_RCAC_SM_EV_ADFS_RADAR: Event to restart RCAC after radar in agile.
+ * enum dfs_agile_sm_evt - DFS Agile SM events.
+ * @DFS_AGILE_SM_EV_AGILE_START: Event to start AGILE PreCAC/RCAC.
+ * @DFS_AGILE_SM_EV_AGILE_DOWN:  Event to stop AGILE PreCAC/RCAC..
+ * @DFS_AGILE_SM_EV_AGILE_DONE:  Event to complete AGILE PreCAC/RCAC..
+ * @DFS_AGILE_SM_EV_ADFS_RADAR: Event to restart AGILE PreCAC/RCAC after radar.
  */
-enum dfs_rcac_sm_evt {
-	DFS_RCAC_SM_EV_RCAC_START = 0,
-	DFS_RCAC_SM_EV_RCAC_STOP = 1,
-	DFS_RCAC_SM_EV_RCAC_DONE = 2,
-	DFS_RCAC_SM_EV_ADFS_RADAR_FOUND = 3,
+enum dfs_agile_sm_evt {
+	DFS_AGILE_SM_EV_AGILE_START = 0,
+	DFS_AGILE_SM_EV_AGILE_STOP =  1,
+	DFS_AGILE_SM_EV_AGILE_DONE =  2,
+	DFS_AGILE_SM_EV_ADFS_RADAR =  3,
 };
 
 #endif  /* _DFS_IOCTL_H_ */

umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h

@@ -980,14 +980,14 @@ void utils_dfs_reset_dfs_prevchan(struct wlan_objmgr_pdev *pdev);
 
 #ifdef QCA_SUPPORT_ADFS_RCAC
 /**
- * utils_dfs_rcac_sm_deliver_evt() - API to post events to DFS rolling CAC SM.
- * @pdev:           Pointer to DFS pdev object.
- * @event:          Event to be posted to DFS RCAC SM.
+ * utils_dfs_agile_sm_deliver_evt() - API to post events to DFS Agile SM.
+ * @pdev: Pointer to DFS pdev object.
+ * @event: Event to be posted to DFS AGILE SM.
  *
  * Return: None.
  */
-void utils_dfs_rcac_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
-				   enum dfs_rcac_sm_evt event);
+void utils_dfs_agile_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
+				    enum dfs_agile_sm_evt event);
 
 /**
  * utils_dfs_get_rcac_channel() - Get the completed Rolling CAC channel if
@@ -1003,8 +1003,8 @@ QDF_STATUS utils_dfs_get_rcac_channel(struct wlan_objmgr_pdev *pdev,
 				      qdf_freq_t *target_chan_freq);
 #else
 static inline
-void utils_dfs_rcac_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
-				   enum dfs_rcac_sm_evt event)
+void utils_dfs_agile_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
+				    enum dfs_agile_sm_evt event)
 {
 }
 

umac/dfs/dispatcher/src/wlan_dfs_init_deinit_api.c

@@ -198,8 +198,8 @@ static QDF_STATUS dfs_psoc_obj_create_notification(struct wlan_objmgr_psoc *psoc
 	/* Initialize Rolling CAC timer */
 	dfs_rcac_timer_init(dfs_soc_obj);
 
-	/* DFS Rolling CAC SM initialization */
-	dfs_rcac_sm_create(dfs_soc_obj);
+	/* DFS Agile SM initialization */
+	dfs_agile_sm_create(dfs_soc_obj);
 
 	dfs_debug(NULL, WLAN_DEBUG_DFS1,
 		"DFS obj attach to psoc successfully");
@@ -228,8 +228,8 @@ static QDF_STATUS dfs_psoc_obj_destroy_notification(struct wlan_objmgr_psoc *pso
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	/* Delete DFS Rolling CAC SM */
-	dfs_rcac_sm_destroy(dfs_soc_obj);
+	/* Delete DFS Agile SM */
+	dfs_agile_sm_destroy(dfs_soc_obj);
 
 	dfs_rcac_timer_deinit(dfs_soc_obj);
 	dfs_zero_cac_timer_detach(dfs_soc_obj);

umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c

@@ -465,7 +465,7 @@ QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev,
 			 */
 			if (!agile_precac_state)
 				dfs->dfs_agile_precac_freq_mhz = 0;
-			if (dfs_soc->cur_precac_dfs_index == i)
+			if (dfs_soc->cur_agile_dfs_index == i)
 				is_precac_running_on_given_pdev = true;
 		}
 	}
@@ -510,7 +510,7 @@ QDF_STATUS tgt_dfs_set_agile_precac_state(struct wlan_objmgr_pdev *pdev,
 			 */
 			if (!agile_precac_state)
 				dfs->dfs_agile_precac_freq = 0;
-			if (dfs_soc->cur_precac_dfs_index == i)
+			if (dfs_soc->cur_agile_dfs_index == i)
 				is_precac_running_on_given_pdev = true;
 		}
 	}

umac/dfs/dispatcher/src/wlan_dfs_utils_api.c

@@ -1620,8 +1620,8 @@ void utils_dfs_reset_dfs_prevchan(struct wlan_objmgr_pdev *pdev)
 }
 
 #ifdef QCA_SUPPORT_ADFS_RCAC
-void utils_dfs_rcac_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
-				   enum dfs_rcac_sm_evt event)
+void utils_dfs_agile_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
+				    enum dfs_agile_sm_evt event)
 {
 	struct wlan_dfs *dfs;
 	void *event_data;
@@ -1640,10 +1640,10 @@ void utils_dfs_rcac_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
 
 	event_data = (void *)dfs;
 
-	dfs_rcac_sm_deliver_evt(dfs->dfs_soc_obj,
-				event,
-				0,
-				event_data);
+	dfs_agile_sm_deliver_evt(dfs->dfs_soc_obj,
+				 event,
+				 0,
+				 event_data);
 }
 
 QDF_STATUS utils_dfs_get_rcac_channel(struct wlan_objmgr_pdev *pdev,

umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h

@@ -1522,7 +1522,7 @@ struct wlan_lmac_if_wifi_pos_rx_ops {
  * @dfs_reinit_nol_from_psoc_copy:    Reinit DFS NOL from the PSOC NOL copy.
  * @dfs_reinit_precac_lists:          Reinit precac lists from other pdev.
  * @dfs_complete_deferred_tasks:      Process mode switch completion in DFS.
- * @dfs_rcac_sm_deliver_evt:          API to post events to DFS rolling CAC SM.
+ * @dfs_agile_sm_deliver_evt:         API to post events to DFS Agile  SM.
  */
 struct wlan_lmac_if_dfs_rx_ops {
 	QDF_STATUS (*dfs_get_radars)(struct wlan_objmgr_pdev *pdev);
@@ -1714,8 +1714,8 @@ struct wlan_lmac_if_dfs_rx_ops {
 					qdf_freq_t rcac_freq);
 	QDF_STATUS (*dfs_get_rcac_freq)(struct wlan_objmgr_pdev *pdev,
 					qdf_freq_t *rcac_freq);
-	void (*dfs_rcac_sm_deliver_evt)(struct wlan_objmgr_pdev *pdev,
-					enum dfs_rcac_sm_evt event);
+	void (*dfs_agile_sm_deliver_evt)(struct wlan_objmgr_pdev *pdev,
+					 enum dfs_agile_sm_evt event);
 	bool (*dfs_is_agile_rcac_enabled)(struct wlan_objmgr_pdev *pdev);
 #endif
 };

umac/global_umac_dispatcher/lmac_if/src/wlan_lmac_if.c

@@ -473,7 +473,7 @@ static void register_dfs_rx_ops_for_freq(struct wlan_lmac_if_dfs_rx_ops *rx_ops)
 #endif
 
 /*
- * register_rcac_dfs_rx_ops() - Register DFS RX-Ops for Rolling CAC specific
+ * register_agile_dfs_rx_ops() - Register DFS RX-Ops for Agile specific
  * APIs.
  * @rx_ops: Pointer to wlan_lmac_if_dfs_rx_ops.
  */
@@ -487,7 +487,7 @@ static void register_rcac_dfs_rx_ops(struct wlan_lmac_if_dfs_rx_ops *rx_ops)
 	rx_ops->dfs_get_rcac_enable = ucfg_dfs_get_rcac_enable;
 	rx_ops->dfs_set_rcac_freq = ucfg_dfs_set_rcac_freq;
 	rx_ops->dfs_get_rcac_freq = ucfg_dfs_get_rcac_freq;
-	rx_ops->dfs_rcac_sm_deliver_evt = utils_dfs_rcac_sm_deliver_evt;
+	rx_ops->dfs_agile_sm_deliver_evt = utils_dfs_agile_sm_deliver_evt;
 	rx_ops->dfs_is_agile_rcac_enabled = ucfg_dfs_is_agile_rcac_enabled;
 }
 #else

umac/mlme/vdev_mgr/core/src/vdev_mgr_ops.c

@@ -160,13 +160,13 @@ static QDF_STATUS vdev_mgr_start_param_update(
 						     des_chan->ch_cfreq2,
 						     &is_dfs_chan_updated);
 
-	/* The RCAC state machine should be stopped only once for the channel
+	/* The Agile state machine should be stopped only once for the channel
 	 * change. If  the same channel is being sent to the FW then do
 	 * not send unnecessary STOP to the state machine.
 	 */
 	if (is_dfs_chan_updated)
-		utils_dfs_rcac_sm_deliver_evt(pdev,
-					      DFS_RCAC_SM_EV_RCAC_STOP);
+		utils_dfs_agile_sm_deliver_evt(pdev,
+					       DFS_AGILE_SM_EV_AGILE_STOP);
 
 	param->beacon_interval = mlme_obj->proto.generic.beacon_interval;
 	param->dtim_period = mlme_obj->proto.generic.dtim_period;