qcacmn: Post various events to the RCAC state machine

Trigger Rolling CAC SM events from
 - NOL expiry (EV_RCAC_START) to trigger RCAC START with a
   new channel if possible and not already running.
 - Agile radar (EV_ADFS_RADAR_FOUND) to restart RCAC with a
   new random channel.
 - vdev restart (EV_RCAC_STOP) to stop the running RCAC when
   the primary channel changes. Start will be based on the
   availability of the new channel.

In case of the rolling CAC feature, a channel is programmed to
the agile detector on which CAC is running continuously.
Introduce an API that finds an RCAC completed channel and return
the channel params which will be used for the next channel
change.

Also add a boolean argument in  dfs_set_current_channel api to
indicate if the dfs current channel is updated in the API
"dfs_set_current_channel".

CRs-Fixed: 2674621
Change-Id: Ica54a57f131cd54e47138f1cbeef2dd0023390ed

umac/dfs/core/src/dfs.h

@@ -42,6 +42,9 @@
 #include <osdep.h>
 #include <wlan_cmn.h>
 #include "target_type.h"
+#ifdef QCA_SUPPORT_ADFS_RCAC
+#include <wlan_sm_engine.h> /* for struct wlan_sm */
+#endif
 
 /* File Line and Submodule String */
 #define FLSM(x, str)   #str " : " FL(x)
@@ -933,6 +936,33 @@ struct dfs_mode_switch_defer_params {
 	bool is_radar_detected;
 };
 
+#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,
+};
+
+/**
+ * struct dfs_rcac_params - DFS Rolling CAC channel parameters.
+ * @rcac_pri_freq: Rolling CAC channel's primary frequency.
+ * @rcac_ch_params: Rolling CAC channel parameters.
+ */
+struct dfs_rcac_params {
+	qdf_freq_t rcac_pri_freq;
+	struct ch_params rcac_ch_params;
+};
+#endif
+
 /**
  * struct wlan_dfs -                 The main dfs structure.
  * @dfs_debug_mask:                  Current debug bitmask.
@@ -1104,8 +1134,8 @@ struct dfs_mode_switch_defer_params {
  * @dfs_agile_detector_id:           Agile detector ID for the DFS object.
  * @dfs_agile_rcac_freq_ucfg:        User programmed Rolling CAC frequency in
  *                                   MHZ.
- * @dfs_rcac_ch_params:              Channel params of the selected RCAC
- *                                   channel.
+ * @dfs_rcac_param:                  Primary frequency and Channel params of
+ *                                   the selected RCAC channel.
  */
 struct wlan_dfs {
 	uint32_t       dfs_debug_mask;
@@ -1276,7 +1306,7 @@ struct wlan_dfs {
 	uint8_t        dfs_agile_detector_id;
 #if defined(QCA_SUPPORT_ADFS_RCAC)
 	uint16_t       dfs_agile_rcac_freq_ucfg;
-	struct ch_params dfs_rcac_ch_params;
+	struct dfs_rcac_params dfs_rcac_param;
 #endif
 	uint16_t       dfs_lowest_pri_limit;
 };
@@ -1331,7 +1361,7 @@ struct dfs_soc_priv_obj {
 	struct dfsreq_nolinfo *dfs_psoc_nolinfo;
 #if defined(QCA_SUPPORT_ADFS_RCAC)
 	qdf_timer_t dfs_rcac_timer;
-	wlan_sm *dfs_rcac_sm_hdl;
+	struct wlan_sm *dfs_rcac_sm_hdl;
 	enum dfs_rcac_sm_state dfs_rcac_curr_state;
 	qdf_spinlock_t dfs_rcac_sm_lock;
 #endif
@@ -2466,6 +2496,7 @@ void dfs_set_current_channel(struct wlan_dfs *dfs,
  * @dfs_chan_mhz_freq_seg1: Channel center frequency of primary segment in MHZ.
  * @dfs_chan_mhz_freq_seg2: Channel center frequency of secondary segment in MHZ
  *                          applicable only for 80+80MHZ mode of operation.
+ * @is_channel_updated: boolean to represent channel update.
  */
 void dfs_set_current_channel_for_freq(struct wlan_dfs *dfs,
 				      uint16_t dfs_chan_freq,
@@ -2475,7 +2506,8 @@ void dfs_set_current_channel_for_freq(struct wlan_dfs *dfs,
 				      uint8_t dfs_chan_vhtop_freq_seg1,
 				      uint8_t dfs_chan_vhtop_freq_seg2,
 				      uint16_t dfs_chan_mhz_freq_seg1,
-				      uint16_t dfs_chan_mhz_freq_seg2);
+				      uint16_t dfs_chan_mhz_freq_seg2,
+				      bool *is_channel_updated);
 
 #endif
 /**

umac/dfs/core/src/dfs_zero_cac.h

@@ -1262,23 +1262,9 @@ dfs_is_host_agile_rcac_config_enabled(struct wlan_dfs *dfs)
 
 #ifdef QCA_SUPPORT_ADFS_RCAC
 #define DFS_RCAC_SM_SPIN_LOCK(_soc_obj) \
-	qdf_spin_lock_bh((_soc_obj)->dfs_rcac_sm_lock)
+	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)
-
-/**
- * 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,
-};
+	qdf_spin_unlock_bh(&((_soc_obj)->dfs_rcac_sm_lock))
 
 /**
  * dfs_rcac_sm_deliver_evt() - Deliver the event to RCAC SM.
@@ -1310,6 +1296,31 @@ QDF_STATUS dfs_rcac_sm_create(struct dfs_soc_priv_obj *dfs_soc_obj);
  */
 QDF_STATUS dfs_rcac_sm_destroy(struct dfs_soc_priv_obj *dfs_soc_obj);
 
+/**
+ * dfs_is_agile_rcac_enabled() - Determine if Rolling CAC is supported or not.
+ * @dfs: Pointer to struct wlan_dfs.
+ *
+ * Following are the conditions needed to assertain that rolling CAC
+ * is enabled:
+ * 1. DFS domain of the PDEV must be FCC or MKK.
+ * 2. User has enabled Rolling CAC configuration.
+ * 3. FW capability to support ADFS. Only non-160 capability is checked here.
+ *    If we happen to choose the next RCAC channel as 160/80-80,
+ *    'dfs_fw_adfs_support_160' is also verified.
+ *
+ *
+ * Return: True if RCAC support is enabled, false otherwise.
+ */
+bool dfs_is_agile_rcac_enabled(struct wlan_dfs *dfs);
+
+/**
+ * dfs_prepare_agile_rcac_channel() - Prepare agile RCAC channel.
+ * @dfs: Pointer to struct wlan_dfs.
+ * @is_rcac_chan_available: Flag to indicate if a valid RCAC channel is
+ *                          found.
+ */
+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,
@@ -1331,22 +1342,17 @@ QDF_STATUS dfs_rcac_sm_destroy(struct dfs_soc_priv_obj *dfs_soc_obj)
 {
 	return QDF_STATUS_SUCCESS;
 }
-#endif /* QCA_SUPPORT_ADFS_RCAC */
 
-/**
- * dfs_prepare_agile_rcac_channel() - Prepare agile RCAC channel.
- * @dfs: Pointer to struct wlan_dfs.
- * @is_rcac_chan_available: Flag to indicate if a valid RCAC channel is
- *                          found.
- */
-#ifdef QCA_SUPPORT_ADFS_RCAC
-void dfs_prepare_agile_rcac_channel(struct wlan_dfs *dfs,
-				    bool *is_rcac_chan_available);
-#else
+static inline bool dfs_is_agile_rcac_enabled(struct wlan_dfs *dfs)
+{
+	return false;
+}
+
 static inline void
 dfs_prepare_agile_rcac_channel(struct wlan_dfs *dfs,
 			       bool *is_rcac_chan_available)
 {
 }
-#endif
+#endif /* QCA_SUPPORT_ADFS_RCAC */
+
 #endif /* _DFS_ZERO_CAC_H_ */

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

@@ -875,9 +875,12 @@ void dfs_set_current_channel_for_freq(struct wlan_dfs *dfs,
 				      uint8_t dfs_chan_vhtop_freq_seg1,
 				      uint8_t dfs_chan_vhtop_freq_seg2,
 				      uint16_t dfs_chan_mhz_freq_seg1,
-				      uint16_t dfs_chan_mhz_freq_seg2)
-
+				      uint16_t dfs_chan_mhz_freq_seg2,
+				      bool *is_channel_updated)
 {
+	if (is_channel_updated)
+		*is_channel_updated = false;
+
 	if (!dfs) {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "dfs is NULL");
 		return;
@@ -909,6 +912,9 @@ void dfs_set_current_channel_for_freq(struct wlan_dfs *dfs,
 	dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2 = dfs_chan_vhtop_freq_seg2;
 	dfs->dfs_curchan->dfs_ch_mhz_freq_seg1 = dfs_chan_mhz_freq_seg1;
 	dfs->dfs_curchan->dfs_ch_mhz_freq_seg2 = dfs_chan_mhz_freq_seg2;
+
+	if (is_channel_updated)
+		*is_channel_updated = true;
 }
 #endif
 

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

@@ -171,9 +171,16 @@ void dfs_process_cac_completion(struct wlan_dfs *dfs)
 							     &ch_width,
 							     &primary_chan_freq,
 							     &sec_chan_freq);
-		/* Mark the current channel as preCAC done */
-		dfs_mark_precac_done_for_freq(dfs, primary_chan_freq,
-					      sec_chan_freq, ch_width);
+
+		/* ETSI allows the driver to cache the CAC ( Once CAC done,
+		 * it can be used in future).
+		 * Therefore mark the current channel CAC done.
+		 */
+		if (utils_get_dfsdomain(dfs->dfs_pdev_obj) == DFS_ETSI_DOMAIN)
+			dfs_mark_precac_done_for_freq(dfs,
+						      primary_chan_freq,
+						      sec_chan_freq,
+						      ch_width);
 	}
 
 	dfs_clear_cac_started_chan(dfs);

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

@@ -316,6 +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_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

@@ -1123,7 +1123,9 @@ QDF_STATUS dfs_process_radar_ind(struct wlan_dfs *dfs,
 
 	/* Sanity checks for radar on Agile detector */
 	if (radar_found->detector_id == dfs_get_agile_detector_id(dfs) &&
-	    (!dfs_is_agile_precac_enabled(dfs) || !dfs->dfs_agile_precac_freq_mhz))
+	    ((!dfs_is_agile_precac_enabled(dfs) &&
+	      !dfs_is_agile_rcac_enabled(dfs)) ||
+	      !dfs->dfs_agile_precac_freq_mhz))
 	{
 		dfs_err(dfs, WLAN_DEBUG_DFS,
 			"radar on Agile detector when ADFS is not running");
@@ -1238,6 +1240,11 @@ QDF_STATUS dfs_process_radar_ind(struct wlan_dfs *dfs,
 				     radar_found->detector_id,
 				     nol_freq_list,
 				     num_channels);
+
+	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);
 	/*
 	 * 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

@@ -362,17 +362,15 @@ struct seq_store {
 /**
  * enum dfs_rcac_sm_evt - DFS Rolling CAC SM events.
  * @DFS_RCAC_SM_EV_RCAC_START: Event to start RCAC.
- * @DFS_RCAC_SM_EV_NOL_EXPIRY: Event to try starting RCAC after NOL expiry.
  * @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_rcac_sm_evt {
 	DFS_RCAC_SM_EV_RCAC_START = 0,
-	DFS_RCAC_SM_EV_NOL_EXPIRY = 1,
-	DFS_RCAC_SM_EV_RCAC_STOP = 2,
-	DFS_RCAC_SM_EV_RCAC_DONE = 3,
-	DFS_RCAC_SM_EV_ADFS_RADAR_FOUND = 4,
+	DFS_RCAC_SM_EV_RCAC_STOP = 1,
+	DFS_RCAC_SM_EV_RCAC_DONE = 2,
+	DFS_RCAC_SM_EV_ADFS_RADAR_FOUND = 3,
 };
 
 #endif  /* _DFS_IOCTL_H_ */

umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h

@@ -151,6 +151,7 @@ QDF_STATUS tgt_dfs_set_current_channel(struct wlan_objmgr_pdev *pdev,
  * @dfs_ch_mhz_freq_seg1:  Channel center frequency of primary segment in MHZ.
  * @dfs_ch_mhz_freq_seg2:  Channel center frequency of secondary segment in MHZ
  *                         applicable only for 80+80MHZ mode of operation.
+ * @is_channel_updated: Boolean to represent channel update.
  */
 #ifdef CONFIG_CHAN_FREQ_API
 QDF_STATUS
@@ -162,7 +163,8 @@ tgt_dfs_set_current_channel_for_freq(struct wlan_objmgr_pdev *pdev,
 				     uint8_t dfs_ch_vhtop_ch_freq_seg1,
 				     uint8_t dfs_ch_vhtop_ch_freq_seg2,
 				     uint16_t dfs_ch_mhz_freq_seg1,
-				     uint16_t dfs_ch_mhz_freq_seg2);
+				     uint16_t dfs_ch_mhz_freq_seg2,
+				     bool *is_channel_updated);
 #endif
 
 /**

umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h

@@ -983,22 +983,37 @@ void utils_dfs_reset_dfs_prevchan(struct wlan_objmgr_pdev *pdev);
  * 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.
- * @event_data_len: Length of event data.
- * @event_data:     Pointer to event data.
  *
  * Return: None.
  */
 void utils_dfs_rcac_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
-				   enum dfs_rcac_sm_evt event,
-				   uint16_t event_data_len,
-				   void *event_data);
+				   enum dfs_rcac_sm_evt event);
+
+/**
+ * utils_dfs_get_rcac_channel() - Get the completed Rolling CAC channel if
+ *                                available.
+ * @pdev: Pointer to DFS pdev object.
+ * @ch_params: current channel params.
+ * @target_chan: Pointer to target_chan freq.
+ *
+ * Return: QDF_STATUS.
+ */
+QDF_STATUS utils_dfs_get_rcac_channel(struct wlan_objmgr_pdev *pdev,
+				      struct ch_params *chan_params,
+				      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,
-				   uint16_t event_data_len,
-				   void *event_data)
+				   enum dfs_rcac_sm_evt event)
+{
+}
+
+static inline
+QDF_STATUS utils_dfs_get_rcac_channel(struct wlan_objmgr_pdev *pdev,
+				      struct ch_params *chan_params,
+				      qdf_freq_t *target_chan_freq)
 {
+	return QDF_STATUS_SUCCESS;
 }
 #endif /* QCA_SUPPORT_ADFS_RCAC */
 

umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c

@@ -114,7 +114,8 @@ tgt_dfs_set_current_channel_for_freq(struct wlan_objmgr_pdev *pdev,
 				     uint8_t dfs_chan_vhtop_freq_seg1,
 				     uint8_t dfs_chan_vhtop_freq_seg2,
 				     uint16_t dfs_chan_mhz_freq_seg1,
-				     uint16_t dfs_chan_mhz_freq_seg2)
+				     uint16_t dfs_chan_mhz_freq_seg2,
+				     bool *is_channel_updated)
 {
 	struct wlan_dfs *dfs;
 
@@ -135,7 +136,8 @@ tgt_dfs_set_current_channel_for_freq(struct wlan_objmgr_pdev *pdev,
 					 dfs_chan_vhtop_freq_seg1,
 					 dfs_chan_vhtop_freq_seg2,
 					 dfs_chan_mhz_freq_seg1,
-					 dfs_chan_mhz_freq_seg2);
+					 dfs_chan_mhz_freq_seg2,
+					 is_channel_updated);
 
 	return QDF_STATUS_SUCCESS;
 }

umac/dfs/dispatcher/src/wlan_dfs_utils_api.c

@@ -1621,11 +1621,10 @@ 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,
-				   uint16_t event_data_len,
-				   void *event_data)
+				   enum dfs_rcac_sm_evt event)
 {
 	struct wlan_dfs *dfs;
+	void *event_data;
 
 	if (!tgt_dfs_is_pdev_5ghz(pdev))
 		return;
@@ -1636,9 +1635,41 @@ void utils_dfs_rcac_sm_deliver_evt(struct wlan_objmgr_pdev *pdev,
 		return;
 	}
 
+	if (!dfs_is_agile_rcac_enabled(dfs))
+		return;
+
+	event_data = (void *)dfs;
+
 	dfs_rcac_sm_deliver_evt(dfs->dfs_soc_obj,
 				event,
-				event_data_len,
+				0,
 				event_data);
 }
-#endif /* QCA_SUPPORT_ADFS_RCAC */
+
+QDF_STATUS utils_dfs_get_rcac_channel(struct wlan_objmgr_pdev *pdev,
+				      struct ch_params *chan_params,
+				      qdf_freq_t *target_chan_freq)
+{
+	struct wlan_dfs *dfs = NULL;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	if (!target_chan_freq)
+		return status;
+
+	*target_chan_freq = 0;
+
+	dfs = wlan_pdev_get_dfs_obj(pdev);
+	if (!dfs) {
+		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "null dfs");
+		return status;
+	}
+
+	if (!dfs_is_agile_rcac_enabled(dfs))
+		return status;
+
+	*target_chan_freq = dfs->dfs_rcac_param.rcac_pri_freq;
+	chan_params = &dfs->dfs_rcac_param.rcac_ch_params;
+
+	return QDF_STATUS_SUCCESS;
+}
+#endif

umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h

@@ -1568,7 +1568,8 @@ struct wlan_lmac_if_dfs_rx_ops {
 						uint8_t ic_vhtop_ch_freq_seg1,
 						uint8_t ic_vhtop_ch_freq_seg2,
 						uint16_t dfs_ch_mhz_freq_seg1,
-						uint16_t dfs_ch_mhz_freq_seg2);
+						uint16_t dfs_ch_mhz_freq_seg2,
+						bool *is_channel_updated);
 #endif
 #ifdef DFS_COMPONENT_ENABLE
 	QDF_STATUS (*dfs_process_radar_ind)(struct wlan_objmgr_pdev *pdev,
@@ -1639,9 +1640,7 @@ struct wlan_lmac_if_dfs_rx_ops {
 	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,
-					uint16_t event_data_len,
-					void *event_data);
+					enum dfs_rcac_sm_evt event);
 #endif
 };
 

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

@@ -124,6 +124,7 @@ static QDF_STATUS vdev_mgr_start_param_update(
 	struct wlan_objmgr_vdev *vdev;
 	struct wlan_objmgr_pdev *pdev;
 	enum QDF_OPMODE op_mode;
+	bool is_dfs_chan_updated = false;
 
 	vdev = mlme_obj->vdev;
 	if (!vdev) {
@@ -156,7 +157,16 @@ static QDF_STATUS vdev_mgr_start_param_update(
 						     des_chan->ch_freq_seg1,
 						     des_chan->ch_freq_seg2,
 						     des_chan->ch_cfreq1,
-						     des_chan->ch_cfreq2);
+						     des_chan->ch_cfreq2,
+						     &is_dfs_chan_updated);
+
+	/* The RCAC 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);
 
 	param->beacon_interval = mlme_obj->proto.generic.beacon_interval;
 	param->dtim_period = mlme_obj->proto.generic.dtim_period;