qcacmn: Have same dfs action for Fulloffload and legacy

After RADAR detection the function should be used for
1)FullOffload
2)Legacy [ partial offload and Direct attach]
chipsets.

Change-Id: Id99f9f25dc5a9f751f9ad74c07a78fb980673300
CRs-Fixed: 2126916

umac/dfs/core/src/dfs.h

@@ -1132,13 +1132,6 @@ struct rx_search_fft_report {
 	int      seg_id;
 };
 
-/**
- * dfs_radar_found_action() - It marks the channel as radar, adds it to NOL and
- *                            indicates to mlme to choose a random channel.
- * @dfs: Pointer to wlan_dfs structure.
- */
-void dfs_radar_found_action(struct wlan_dfs *dfs);
-
 /**
  * dfs_process_radarevent() - process the radar event generated for a pulse.
  * @dfs: Pointer to wlan_dfs structure.
@@ -1146,13 +1139,16 @@ void dfs_radar_found_action(struct wlan_dfs *dfs);
  *
  * There is currently no way to specify that a radar event has occurred on
  * a specific channel, so the current methodology is to mark both the pri
- * and ext channels as being unavailable.  This should be fixed for 802.11ac
+ * and ext channels as being unavailable. This should be fixed for 802.11ac
  * or we'll quickly run out of valid channels to use.
  *
- * Return: If a radar event found on non-DFS channel return 0.
- * Otherwise, return 1.
+ * If Radar found, this marks the channel (and the extension channel, if HT40)
+ * as having seen a radar event. It marks CHAN_INTERFERENCE and will add it to
+ * the local NOL implementation. This is only done for 'usenol=1', as the other
+ * two modes don't do radar notification or CAC/CSA/NOL; it just notes there
+ * was a radar.
  */
-int dfs_process_radarevent(struct wlan_dfs *dfs,
+void  dfs_process_radarevent(struct wlan_dfs *dfs,
 		struct dfs_ieee80211_channel *chan);
 
 /**
@@ -2022,4 +2018,24 @@ void dfs_stop(struct wlan_dfs *dfs);
 void dfs_update_cur_chan_flags(struct wlan_dfs *dfs,
 		uint64_t flags,
 		uint16_t flagext);
+
+/**
+ * dfs_send_csa_to_current_chan() - Send CSA to current channel
+ * @dfs: Pointer to wlan_dfs structure.
+ *
+ * For the test mode(usenol = 0), don't do a CSA; but setup the test timer so
+ * we get a CSA _back_ to the current operating channel.
+ */
+void dfs_send_csa_to_current_chan(struct wlan_dfs *dfs);
+
+/**
+ * dfs_radarevent_basic_sanity - Check basic sanity of the radar event
+ * @dfs: Pointer to wlan_dfs structure.
+ * @chan: Current channel.
+ *
+ * Return: If a radar event found on NON-DFS channel  return 0.  Otherwise,
+ * return 1.
+ */
+int dfs_radarevent_basic_sanity(struct wlan_dfs *dfs,
+		struct dfs_ieee80211_channel *chan);
 #endif  /* _DFS_H_ */

umac/dfs/core/src/dfs_channel.h

@@ -624,4 +624,53 @@ enum dfs_ieee80211_opmode {
 #define IEEE80211_CHAN_ANYC \
 	((struct dfs_ieee80211_channel *) IEEE80211_CHAN_ANY)
 
+#define IEEE80211_IS_CHAN_11AXA_HE20(_c) \
+	(((_c)->dfs_ch_flags & IEEE80211_CHAN_11AXA_HE20) == \
+	 IEEE80211_CHAN_11AXA_HE20)
+
+#define IEEE80211_IS_CHAN_11AXA_HE40PLUS(_c) \
+	(((_c)->dfs_ch_flags & IEEE80211_CHAN_11AXA_HE40PLUS) == \
+	 IEEE80211_CHAN_11AXA_HE40PLUS)
+
+#define IEEE80211_IS_CHAN_11AXA_HE40MINUS(_c) \
+	(((_c)->dfs_ch_flags & IEEE80211_CHAN_11AXA_HE40MINUS) == \
+	 IEEE80211_CHAN_11AXA_HE40MINUS)
+
+#define IEEE80211_IS_CHAN_11AXA_HE80(_c) \
+	(((_c)->dfs_ch_flags & IEEE80211_CHAN_11AXA_HE80) == \
+	 IEEE80211_CHAN_11AXA_HE80)
+
+#define IEEE80211_IS_CHAN_11AXA_HE160(_c) \
+	(((_c)->dfs_ch_flags & IEEE80211_CHAN_11AXA_HE160) == \
+	 IEEE80211_CHAN_11AXA_HE160)
+
+#define IEEE80211_IS_CHAN_11AXA_HE80_80(_c) \
+	(((_c)->dfs_ch_flags & IEEE80211_CHAN_11AXA_HE80_80) == \
+	 IEEE80211_CHAN_11AXA_HE80_80)
+
+#define IEEE80211_IS_CHAN_MODE_20(_c)      \
+	(IEEE80211_IS_CHAN_11NA_HT20(_c)  ||  \
+	 IEEE80211_IS_CHAN_11AC_VHT20(_c) ||  \
+	 IEEE80211_IS_CHAN_11AXA_HE20(_c))
+
+#define IEEE80211_IS_CHAN_MODE_40(_c)          \
+	(IEEE80211_IS_CHAN_11AC_VHT40PLUS(_c)  || \
+	 IEEE80211_IS_CHAN_11AC_VHT40MINUS(_c) || \
+	 IEEE80211_IS_CHAN_11NA_HT40PLUS(_c)   || \
+	 IEEE80211_IS_CHAN_11NA_HT40MINUS(_c)  || \
+	 IEEE80211_IS_CHAN_11AXA_HE40PLUS(_c)  || \
+	 IEEE80211_IS_CHAN_11AXA_HE40MINUS(_c))
+
+#define IEEE80211_IS_CHAN_MODE_80(_c)          \
+	(IEEE80211_IS_CHAN_11AC_VHT80(_c)      || \
+	 IEEE80211_IS_CHAN_11AXA_HE80(_c))
+
+#define IEEE80211_IS_CHAN_MODE_160(_c)         \
+	(IEEE80211_IS_CHAN_11AC_VHT160(_c)     || \
+	 IEEE80211_IS_CHAN_11AXA_HE160(_c))
+
+#define IEEE80211_IS_CHAN_MODE_80_80(_c)       \
+	(IEEE80211_IS_CHAN_11AC_VHT80_80(_c)   || \
+	 IEEE80211_IS_CHAN_11AXA_HE80_80(_c))
+
 #endif /*  _NET80211__IEEE80211_H_ */

umac/dfs/core/src/dfs_process_radar_found_ind.h

@@ -58,19 +58,28 @@
 
 /* Frequency offset to sidx */
 #define DFS_FREQ_OFFSET_TO_SIDX(_f)  ((32 * (_f)) / 10)
-/* sidx offset boundry */
+/* sidx offset boundary */
 #define DFS_BOUNDRY_SIDX  32
 /* freq offset for chirp */
 #define DFS_CHIRP_OFFSET  10
 /* second segment freq offset */
 #define DFS_160MHZ_SECOND_SEG_OFFSET  40
 
+/* Frequency offset indices */
+#define CENTER_CH 0
+#define LEFT_CH   1
+#define RIGHT_CH  2
+
 /**
- * struct freqs_offsets - frequency and offset informat
+ * struct freqs_offsets - frequency and offset information
  * @chan_num: channel number.
  * @freq: channel frequency in mhz.
  * @offset: offset from center frequency.
  *
+ * Index 0 - Center channel affected by RADAR.
+ * Index 1 - Left of Center channel affected by RADAR.
+ * Index 2 - Right of Center channel affected by RADAR.
+ *
  * This information is needed to find and mark radar infected
  * channels in NOL and regulatory database.
  */
@@ -92,3 +101,15 @@ struct freqs_offsets {
  */
 void dfs_process_radar_found_indication(struct wlan_dfs *dfs,
 		struct radar_found_info *radar_found);
+
+/**
+ * dfs_process_radar_ind() - Process radar indication event
+ * @dfs: Pointer to wlan_dfs structure.
+ * @radar_found: Pointer to radar_found_info structure.
+ *
+ * Wrapper function of dfs_process_radar_found_indication().
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS dfs_process_radar_ind(struct wlan_dfs *dfs,
+		struct radar_found_info *radar_found);

umac/dfs/core/src/filtering/dfs_process_radarevent.c

@@ -24,6 +24,7 @@
 #include "../dfs.h"
 #include "../dfs_channel.h"
 #include "../dfs_internal.h"
+#include "../dfs_process_radar_found_ind.h"
 
 #define FREQ_5500_MHZ  5500
 #define FREQ_5500_MHZ       5500
@@ -443,12 +444,13 @@ void __dfs_process_radarevent(struct wlan_dfs *dfs,
  * @dfs: Pointer to wlan_dfs structure.
  * @rs: Pointer to dfs_state.
  * @chan: Current  channel.
+ * @seg_id: Segment id.
  */
 static inline void dfs_radarfound_reset_vars(
 		struct wlan_dfs *dfs,
 		struct dfs_state *rs,
 		struct dfs_ieee80211_channel *chan,
-		uint8_t   seg_id)
+		uint8_t seg_id)
 {
 	struct dfs_ieee80211_channel *thischan;
 
@@ -504,28 +506,19 @@ static inline void dfs_radarfound_reset_vars(
 	}
 }
 
-/**
- * dfs_radarevent_basic_sanity - Check basic sanity of the radar event
- * @dfs: Pointer to wlan_dfs structure.
- * @chan: Current channel.
- * Return: If a radar event found on NON-DFS channel  return 0.  Otherwise,
- * return 1.
- */
-static inline int dfs_radarevent_basic_sanity(
-	struct wlan_dfs *dfs,
+int dfs_radarevent_basic_sanity(struct wlan_dfs *dfs,
 	struct dfs_ieee80211_channel *chan)
 {
 	if (!(dfs->dfs_second_segment_bangradar ||
 				dfs_is_precac_timer_running(dfs)))
-		if (!(IEEE80211_IS_CHAN_DFS(chan) ||
-			    ((IEEE80211_IS_CHAN_11AC_VHT160(chan) ||
-			      IEEE80211_IS_CHAN_11AC_VHT80_80(chan)) &&
-			     IEEE80211_IS_CHAN_DFS_CFREQ2(chan)))) {
+		if (!(IEEE80211_IS_PRIMARY_OR_SECONDARY_CHAN_DFS(chan))) {
 			dfs_debug(dfs, WLAN_DEBUG_DFS2,
-				"radar event on non-DFS chan");
-			dfs_reset_radarq(dfs);
-			dfs_reset_alldelaylines(dfs);
-			dfs->dfs_bangradar = 0;
+					"radar event on non-DFS chan");
+			if (!(dfs->dfs_is_offload_enabled)) {
+				dfs_reset_radarq(dfs);
+				dfs_reset_alldelaylines(dfs);
+				dfs->dfs_bangradar = 0;
+			}
 			return 0;
 		}
 
@@ -1229,7 +1222,7 @@ static inline void dfs_false_radarfound_reset_vars(
 	dfs->dfs_phyerr_w53_counter  = 0;
 }
 
-int dfs_process_radarevent(
+void dfs_process_radarevent(
 	struct wlan_dfs *dfs,
 	struct dfs_ieee80211_channel *chan)
 {
@@ -1239,7 +1232,7 @@ int dfs_process_radarevent(
 	int false_radar_found = 0;
 
 	if (!dfs_radarevent_basic_sanity(dfs, chan))
-		return 0;
+		return;
 	/*
 	 * TEST : Simulate radar bang, make sure we add the channel to NOL
 	 * (bug 29968)
@@ -1248,17 +1241,33 @@ int dfs_process_radarevent(
 		goto dfsfound;
 
 	if (!dfs_handle_missing_pulses(dfs, chan))
-		return 0;
+		return;
 
 	dfs_process_each_radarevent(dfs, chan, &rs, &seg_id, &retval,
 			&false_radar_found);
 
 dfsfound:
-	if (retval)
+	if (retval) {
+		struct radar_found_info *radar_found;
+
 		dfs_radarfound_reset_vars(dfs, rs, chan, seg_id);
 
+		radar_found = qdf_mem_malloc(sizeof(*radar_found));
+		if (!radar_found) {
+			dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS,
+					"radar_found allocation failed");
+			return;
+		}
+
+		qdf_mem_zero(radar_found, sizeof(*radar_found));
+		radar_found->segment_id = seg_id;
+		radar_found->pdev_id =
+			wlan_objmgr_pdev_get_pdev_id(dfs->dfs_pdev_obj);
+
+		dfs_process_radar_ind(dfs, radar_found);
+		qdf_mem_free(radar_found);
+	}
+
 	if (false_radar_found)
 		dfs_false_radarfound_reset_vars(dfs);
-
-	return retval;
 }

umac/dfs/core/src/filtering/dfs_radar.c

@@ -511,103 +511,11 @@ void dfs_get_radars(struct wlan_dfs *dfs)
 	}
 }
 
-void dfs_radar_found_action(struct wlan_dfs *dfs)
+void dfs_send_csa_to_current_chan(struct wlan_dfs *dfs)
 {
-	bool wait_for_csa = false;
-
-	if (dfs->dfs_use_nol == 1) {
-		/*
-		 * If precac is running and the radar found in secondary
-		 * VHT80 mark the channel as radar and add to NOL list.
-		 * Otherwise random channel selection can choose this
-		 * channel.
-		 */
-		dfs_debug(dfs, WLAN_DEBUG_DFS,
-				"found_on_second = %d is_pre = %d",
-				dfs->is_radar_found_on_secondary_seg,
-				dfs_is_precac_timer_running(dfs));
-
-		if (dfs->is_radar_found_on_secondary_seg &&
-				dfs_is_precac_timer_running(dfs)) {
-			/* Get a VHT80 channel and mark it */
-			struct dfs_ieee80211_channel ichan;
-
-			dfs_find_precac_secondary_vht80_chan(dfs, &ichan);
-
-			dfs_mlme_channel_mark_radar(dfs->dfs_pdev_obj,
-					ichan.dfs_ch_freq,
-					ichan.dfs_ch_vhtop_ch_freq_seg2,
-					ichan.dfs_ch_flags);
-		} else {
-			dfs_mlme_channel_mark_radar(dfs->dfs_pdev_obj,
-					dfs->dfs_curchan->dfs_ch_freq,
-					dfs->dfs_curchan->
-					dfs_ch_vhtop_ch_freq_seg2,
-					dfs->dfs_curchan->dfs_ch_flags);
-		}
-	}
-
-	/*
-	 * Even if radar found on primary, we need to move the channel
-	 * from precac-required-list and precac-done-list to
-	 * precac-nol-list.
-	 */
-	if (dfs->dfs_use_nol == 1) {
-		dfs_mark_precac_dfs(dfs,
-				dfs->is_radar_found_on_secondary_seg);
-	}
-
-	if (dfs->is_radar_found_on_secondary_seg) {
-		dfs_second_segment_radar_disable(dfs);
-		dfs->is_radar_found_on_secondary_seg = 0;
-		if (dfs->is_radar_during_precac) {
-			dfs->is_radar_during_precac = 0;
-			goto radar_process_end;
-		}
-	}
-
-	/*
-	 * This calls into the umac DFS code, which sets the umac
-	 * related radar flags and begins the channel change
-	 * machinery.
-	 * XXX TODO: the umac NOL code isn't used, but
-	 * IEEE80211_CHAN_DFS_RADAR still gets set. Since the umac
-	 * NOL code isn't used, that flag is never cleared. This
-	 * needs to be fixed. See EV 105776.
-	 */
-	if (dfs->dfs_use_nol == 1)  {
-		dfs_mlme_start_rcsa(dfs->dfs_pdev_obj,
-				&wait_for_csa);
-		if (wait_for_csa)
-			return;
-
-		dfs_mlme_mark_dfs(dfs->dfs_pdev_obj,
-				dfs->dfs_curchan->dfs_ch_ieee,
-				dfs->dfs_curchan->dfs_ch_freq,
-				dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2,
-				dfs->dfs_curchan->dfs_ch_flags);
-		/*
-		 * EV 129487 : We have detected radar in the channel,
-		 * stop processing PHY error data as this can cause
-		 * false detect in the new channel while channel
-		 * change is in progress.
-		 */
-		dfs_radar_disable(dfs);
-		dfs_second_segment_radar_disable(dfs);
-	} else if (dfs->dfs_use_nol == 0) {
-		/*
-		 * For the test mode, don't do a CSA here; but setup
-		 * the test timer so we get a CSA _back_ to the
-		 * original channel.
-		 */
-		qdf_timer_stop(&dfs->wlan_dfstesttimer);
-		dfs->wlan_dfstest = 1;
-		dfs->wlan_dfstest_ieeechan = dfs->dfs_curchan->dfs_ch_ieee;
-		dfs->wlan_dfstesttime = 1;   /* 1ms */
-		qdf_timer_mod(&dfs->wlan_dfstesttimer,
-				dfs->wlan_dfstesttime);
-	}
-
-radar_process_end:
-	return;
+	qdf_timer_stop(&dfs->wlan_dfstesttimer);
+	dfs->wlan_dfstest = 1;
+	dfs->wlan_dfstest_ieeechan = dfs->dfs_curchan->dfs_ch_ieee;
+	dfs->wlan_dfstesttime = 1;   /* 1ms */
+	qdf_timer_mod(&dfs->wlan_dfstesttimer, dfs->wlan_dfstesttime);
 }

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

@@ -38,13 +38,7 @@
 static int usenol = 1;
 
 /**
- * dfs_task() - The main function to process the radar pulse.
- *
- * If Radar found, this marks the channel (and the extension channel, if HT40)
- * as having seen a radar event. It marks CHAN_INTERFERENCE and will add it to
- * the local NOL implementation. This is only done for 'usenol=1', as the other
- * two modes don't do radar notification or CAC/CSA/NOL; it just notes there
- * was a radar.
+ * dfs_task() - The timer function to process the radar pulses.
  */
 static os_timer_func(dfs_task)
 {
@@ -57,8 +51,7 @@ static os_timer_func(dfs_task)
 		return;
 	}
 
-	if (dfs_process_radarevent(dfs, dfs->dfs_curchan))
-		dfs_radar_found_action(dfs);
+	dfs_process_radarevent(dfs, dfs->dfs_curchan);
 
 	dfs->wlan_radar_tasksched = 0;
 }

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

@@ -25,15 +25,61 @@
 #include "../dfs_process_radar_found_ind.h"
 #include <wlan_reg_services_api.h>
 #include <wlan_dfs_utils_api.h>
+#include "wlan_dfs_mlme_api.h"
 
 /**
- * A) If is chirp or radar found at boundary, two channels will effected.
- *    freq_offset.freq[0] = fn+1
- *    freq_offset.freq[1] = fn+1
- *    freq_offset.freq[2] = fn
+ * TODO: The code is not according to the following description needs
+ * modification and correction. Code always adds left and right channels to
+ * NOL even if it is not a chirp radar.
  *
- *   Two channels, ch(n) and ch(n+1) will be added to nol.
+ * A) If chirp radar starts at boundary and ends at boundary then three channels
+ *    will be affected.
+ *    freq_offset.freq[0] = fn   (Center frequency)
+ *    freq_offset.freq[1] = fn-1 (Left of center)
+ *    freq_offset.freq[2] = fn+1 (Right of center)
  *
+ *    Three channels, ch(n-1), ch(n)and ch(n+1) will be added to NOL.
+ *
+ *                     Chirp start freq         Chirp end freq
+ *                             |                       |
+ *                             |                       |
+ *                             V                       V
+ *      _______________________________________________________________________
+ *     |       center freq     |       center freq     |       center freq     |
+ *     |          ch(n-1)      |          ch(n)        |          ch(n+1)      |
+ *     |           |           |           |           |           |           |
+ *     |           |           |           |           |           |           |
+ *     |           |           |           |           |           |           |
+ *                fn-1                    fn         boundary     fn+1
+ *     <-------- 20 Mhz ------>
+ *
+ * B) If chirp radar starts at one channel and continues up to another channel
+ *    then two channels will be affected.
+ *    freq_offset.freq[0] = fn
+ *    freq_offset.freq[1] = 0
+ *    freq_offset.freq[2] = fn+1
+ *
+ *    Three channels, ch(n-1), ch(n)and ch(n+1) will be added to NOL.
+ *
+ *                                   Chirp start freq         Chirp end freq
+ *                                           |                       |
+ *                                           |                       |
+ *                                           V                       V
+ *      _______________________________________________________________________
+ *     |       center freq     |       center freq     |       center freq     |
+ *     |          ch(n-1)      |          ch(n)        |          ch(n+1)      |
+ *     |           |           |           |           |           |           |
+ *     |           |           |           |           |           |           |
+ *     |           |           |           |           |           |           |
+ *                fn-1                    fn         boundary     fn+1
+ *     <-------- 20 Mhz ------>
+ *
+ * C) Radar found at boundary, two channels will be affected.
+ *    freq_offset.freq[0] = fn
+ *    freq_offset.freq[1] = 0
+ *    freq_offset.freq[2] = fn+1
+ *
+ *    Two channels, ch(n) and ch(n+1) will be added to NOL.
  *
  *                                            dfs_freq_offset (radar found freq)
  *                                                     |
@@ -49,12 +95,12 @@
  *     <-------- 20 Mhz ------>
  *
  *
- * B) Else only one channel will be effected
+ * D) Else only one channel will be affected.
  *    freq_offset.freq[0] = fn
- *    freq_offset.freq[1] = fn
- *    freq_offset.freq[2] = fn
+ *    freq_offset.freq[1] = 0
+ *    freq_offset.freq[2] = 0
  *
- *   One channel ch(n) will be added to nol.
+ *   One channel ch(n) will be added to NOL.
  *
  *
  *                                            dfs_freq_offset (radar found freq)
@@ -104,7 +150,7 @@ static void dfs_radar_add_to_nol(struct wlan_dfs *dfs,
 				dfs->wlan_dfs_nol_timeout);
 		nollist[num_ch++] = last_chan;
 		dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS,
-				"ch=%d Added to NOL", last_chan);
+				"ch = %d Added to NOL", last_chan);
 	}
 	utils_dfs_reg_update_nol_ch(dfs->dfs_pdev_obj,
 			nollist, num_ch, DFS_NOL_SET);
@@ -211,78 +257,73 @@ static void dfs_radar_chan_for_20(struct freqs_offsets *freq_offset,
 	}
 }
 
-void dfs_process_radar_found_indication(struct wlan_dfs *dfs,
-		struct radar_found_info *radar_found)
+/**
+ * dfs_find_radar_affected_subchans() - Finds radar affected sub channels.
+ * @dfs: Pointer to wlan_dfs structure.
+ * @radar_found: Pointer to radar_found structure.
+ * @freq_offset: Pointer to save radar affected channels.
+ */
+static void dfs_find_radar_affected_subchans(
+		struct wlan_dfs *dfs,
+		struct radar_found_info *radar_found,
+		struct freqs_offsets *freq_offset)
 {
 	int i;
-	struct freqs_offsets freq_offset;
 	uint32_t freq_center, flag;
 	int32_t sidx;
+	struct dfs_ieee80211_channel *curchan = dfs->dfs_curchan;
 
-	if (!dfs || !dfs->dfs_curchan) {
-		dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is null");
-		return;
-	}
-
-	qdf_mem_set(&freq_offset, sizeof(freq_offset), 0);
-	flag = dfs->dfs_curchan->dfs_ch_flags;
+	qdf_mem_set(freq_offset, sizeof(*freq_offset), 0);
+	flag = curchan->dfs_ch_flags;
 
 	for (i = 0; i < DFS_NUM_FREQ_OFFSET; i++)
-		freq_offset.offset[i] = radar_found->freq_offset;
+		freq_offset->offset[i] = radar_found->freq_offset;
 
 	sidx = DFS_FREQ_OFFSET_TO_SIDX(radar_found->freq_offset);
 
 	if (!radar_found->segment_id)
 		freq_center = utils_dfs_chan_to_freq(
-				dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg1);
+				curchan->dfs_ch_vhtop_ch_freq_seg1);
 	else {
-		freq_center = utils_dfs_chan_to_freq(
-				dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2);
-		if (flag & IEEE80211_CHAN_VHT160)
-			freq_center += DFS_160MHZ_SECOND_SEG_OFFSET;
+		if (dfs_is_precac_timer_running(dfs)) {
+			freq_center = utils_dfs_chan_to_freq(
+					dfs->dfs_precac_secondary_freq);
+		} else {
+			freq_center = utils_dfs_chan_to_freq(
+					curchan->dfs_ch_vhtop_ch_freq_seg2);
+			if (flag & IEEE80211_CHAN_VHT160)
+				freq_center += DFS_160MHZ_SECOND_SEG_OFFSET;
+		}
 	}
 
-	dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS,
+	dfs_info(dfs, WLAN_DEBUG_DFS,
 			"seg=%d, sidx=%d, offset=%d, chirp=%d, flag=%d, f=%d",
 			radar_found->segment_id, sidx,
 			radar_found->freq_offset, radar_found->is_chirp,
 			flag, freq_center);
 
-	if ((flag & IEEE80211_CHAN_A)         ||
-	    (flag & IEEE80211_CHAN_11NA_HT20) ||
-	    (flag & IEEE80211_CHAN_HT20)      ||
-	    (flag & IEEE80211_CHAN_VHT20)     ||
-	    (flag & IEEE80211_CHAN_11AXA_HE20)) {
+	if ((IEEE80211_IS_CHAN_A(curchan))         ||
+			IEEE80211_IS_CHAN_MODE_20(curchan)) {
 		if (radar_found->is_chirp ||
 		   (sidx && !(abs(sidx) % DFS_BOUNDRY_SIDX))) {
-			freq_offset.offset[1] -= DFS_CHIRP_OFFSET;
-			freq_offset.offset[2] += DFS_CHIRP_OFFSET;
+			freq_offset->offset[LEFT_CH] -= DFS_CHIRP_OFFSET;
+			freq_offset->offset[RIGHT_CH] += DFS_CHIRP_OFFSET;
 		}
-		dfs_radar_chan_for_20(&freq_offset, freq_center);
-	} else if ((flag & IEEE80211_CHAN_VHT40PLUS)      ||
-		   (flag & IEEE80211_CHAN_VHT40MINUS)     ||
-		   (flag & IEEE80211_CHAN_HT40PLUS)       ||
-		   (flag & IEEE80211_CHAN_HT40MINUS)      ||
-		   (flag & IEEE80211_CHAN_11NA_HT40PLUS)  ||
-		   (flag & IEEE80211_CHAN_11NA_HT40MINUS) ||
-		   (flag & IEEE80211_CHAN_11AXA_HE40PLUS) ||
-		   (flag & IEEE80211_CHAN_11AXA_HE40MINUS)) {
+		dfs_radar_chan_for_20(freq_offset, freq_center);
+	} else if (IEEE80211_IS_CHAN_MODE_40(curchan)) {
 		if (radar_found->is_chirp || !(abs(sidx) % DFS_BOUNDRY_SIDX)) {
-			freq_offset.offset[1] -= DFS_CHIRP_OFFSET;
-			freq_offset.offset[2] += DFS_CHIRP_OFFSET;
+			freq_offset->offset[LEFT_CH] -= DFS_CHIRP_OFFSET;
+			freq_offset->offset[RIGHT_CH] += DFS_CHIRP_OFFSET;
 		}
-		dfs_radar_chan_for_40(&freq_offset, freq_center);
-	} else if ((flag & IEEE80211_CHAN_VHT80)         ||
-		   (flag & IEEE80211_CHAN_VHT80_80)      ||
-		   (flag & IEEE80211_CHAN_VHT160)        ||
-		   (flag & IEEE80211_CHAN_11AXA_HE80)    ||
-		   (flag & IEEE80211_CHAN_11AXA_HE80_80) ||
-		   (flag & IEEE80211_CHAN_11AXA_HE160)) {
+		dfs_radar_chan_for_40(freq_offset, freq_center);
+	} else if (IEEE80211_IS_CHAN_MODE_80(curchan) ||
+			IEEE80211_IS_CHAN_MODE_160(curchan) ||
+			IEEE80211_IS_CHAN_MODE_80_80(curchan)) {
 		if (radar_found->is_chirp || !(abs(sidx) % DFS_BOUNDRY_SIDX)) {
-			freq_offset.offset[1] -= DFS_CHIRP_OFFSET;
-			freq_offset.offset[2] += DFS_CHIRP_OFFSET;
+			freq_offset->offset[LEFT_CH] -= DFS_CHIRP_OFFSET;
+			freq_offset->offset[RIGHT_CH] += DFS_CHIRP_OFFSET;
 		}
-		dfs_radar_chan_for_80(&freq_offset, freq_center);
+		dfs_radar_chan_for_80(freq_offset, freq_center);
 	} else {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,
 				"channel flag(%d) is invalid", flag);
@@ -290,11 +331,100 @@ void dfs_process_radar_found_indication(struct wlan_dfs *dfs,
 	}
 
 	for (i = 0; i < DFS_NUM_FREQ_OFFSET; i++) {
-		freq_offset.chan_num[i] = utils_dfs_freq_to_chan(
-				freq_offset.freq[i]);
-		dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, "offset=%d, channel%d",
-			    i, freq_offset.chan_num[i]);
+		freq_offset->chan_num[i] = utils_dfs_freq_to_chan(
+				freq_offset->freq[i]);
+		dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, "offset = %d, channel = %d",
+			    i, freq_offset->chan_num[i]);
+	}
+}
+
+QDF_STATUS dfs_process_radar_ind(struct wlan_dfs *dfs,
+		struct radar_found_info *radar_found)
+{
+	struct freqs_offsets freq_offset;
+	bool wait_for_csa = false;
+
+	if (!dfs->dfs_curchan) {
+		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs->dfs_curchan is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/* Check if the current channel is a non DFS channel */
+	if (!dfs_radarevent_basic_sanity(dfs, dfs->dfs_curchan)) {
+		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,
+				"radar event on a non-DFS channel");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	if (!dfs->dfs_use_nol) {
+		dfs_send_csa_to_current_chan(dfs);
+		return QDF_STATUS_SUCCESS;
 	}
 
+	dfs_find_radar_affected_subchans(dfs, radar_found, &freq_offset);
+
 	dfs_radar_add_to_nol(dfs, &freq_offset);
+
+	/*
+	 * If precac is running and the radar found in secondary
+	 * VHT80 mark the channel as radar and add to NOL list.
+	 * Otherwise random channel selection can choose this
+	 * channel.
+	 */
+	dfs_debug(dfs, WLAN_DEBUG_DFS,
+			"found_on_second = %d is_pre = %d",
+			dfs->is_radar_found_on_secondary_seg,
+			dfs_is_precac_timer_running(dfs));
+
+	/*
+	 * Even if radar found on primary, we need to move the channel
+	 * from precac-required-list and precac-done-list to
+	 * precac-nol-list.
+	 */
+	dfs_mark_precac_dfs(dfs,
+			dfs->is_radar_found_on_secondary_seg);
+
+	if (!dfs->dfs_is_offload_enabled) {
+		if (dfs->is_radar_found_on_secondary_seg) {
+			dfs_second_segment_radar_disable(dfs);
+			dfs->is_radar_found_on_secondary_seg = 0;
+			if (dfs->is_radar_during_precac) {
+				dfs->is_radar_during_precac = 0;
+				return QDF_STATUS_SUCCESS;
+			}
+		}
+	}
+
+	/*
+	 * This calls into the umac DFS code, which sets the umac
+	 * related radar flags and begins the channel change
+	 * machinery.
+	 * XXX TODO: the umac NOL code isn't used, but
+	 * IEEE80211_CHAN_DFS_RADAR still gets set. Since the umac
+	 * NOL code isn't used, that flag is never cleared. This
+	 * needs to be fixed. See EV 105776.
+	 */
+	dfs_mlme_start_rcsa(dfs->dfs_pdev_obj,
+			&wait_for_csa);
+	if (wait_for_csa)
+		return QDF_STATUS_SUCCESS;
+
+	dfs_mlme_mark_dfs(dfs->dfs_pdev_obj,
+			dfs->dfs_curchan->dfs_ch_ieee,
+			dfs->dfs_curchan->dfs_ch_freq,
+			dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2,
+			dfs->dfs_curchan->dfs_ch_flags);
+	/*
+	 * EV 129487 : We have detected radar in the channel,
+	 * stop processing PHY error data as this can cause
+	 * false detect in the new channel while channel
+	 * change is in progress.
+	 */
+
+	if (!dfs->dfs_is_offload_enabled) {
+		dfs_radar_disable(dfs);
+		dfs_second_segment_radar_disable(dfs);
+	}
+
+	return QDF_STATUS_SUCCESS;
 }

umac/dfs/dispatcher/inc/wlan_dfs_public_struct.h

@@ -24,19 +24,20 @@
 #ifndef __WLAN_DFS_PUBLIC_STRUCT_H_
 #define __WLAN_DFS_PUBLIC_STRUCT_H_
 
+/* TODO: This structure has many redundant variables, needs cleanup */
 /**
  * struct radar_found_info - radar found info
- * @pdev_id: pdev id.
- * @detection_mode: In-service mode or O-CAC mod.
- * @freq_offset: frequency offset.
- * @chan_width: channel width.
- * @detector_id: detector id.
- * @segment_id: segment id.
- * @timestamp: timestamp.
- * @is_chirp: is chirp or not.
- * @chan_freq: channel frequency.
- * @radar_freq: radar frequency.
- * @sidx: sidx value.
+ * @pdev_id:        pdev id.
+ * @detection_mode: 0 indicates RADAR detected, non-zero indicates debug mode.
+ * @freq_offset:    frequency offset.
+ * @chan_width:     channel width.
+ * @detector_id:    detector id for full-offload.
+ * @segment_id:     segment id (same as detector_id) for partial-offload.
+ * @timestamp:      timestamp (Time when filter match is found in Firmware).
+ * @is_chirp:       is chirp or not.
+ * @chan_freq:      channel frequency (Primary channel frequency).
+ * @radar_freq:     radar frequency (Is it same as '@chan_freq'?).
+ * @sidx:           sidx value (same as freq_offset).
  */
 struct radar_found_info {
 	uint32_t pdev_id;

umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c

@@ -229,59 +229,7 @@ QDF_STATUS tgt_dfs_process_radar_ind(struct wlan_objmgr_pdev *pdev,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	if (!dfs->dfs_curchan) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "dfs->dfs_curchan is NULL");
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	/*
-	 * Check if the current channel is a non DFS channel
-	 */
-	if (!(IEEE80211_IS_CHAN_DFS(dfs->dfs_curchan) ||
-		((IEEE80211_IS_CHAN_11AC_VHT160(dfs->dfs_curchan) ||
-		IEEE80211_IS_CHAN_11AC_VHT80_80(dfs->dfs_curchan)) &&
-		IEEE80211_IS_CHAN_DFS_CFREQ2(dfs->dfs_curchan)))) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "radar event on a non-DFS channel");
-		return QDF_STATUS_E_FAILURE;
-	}
-
-	if (radar_found->detection_mode != 0) {
-
-		/*
-		 * Display information about individual pulse for
-		 * debug purposes
-		 */
-		dfs_info(dfs, WLAN_DEBUG_DFS_ALWAYS, "time_stamp=%d, pulse_dur=%d, RSSI=%d false_radar=%d, false_check=%d, seg=%d, sidx=%d, chirp=%d\n",
-				radar_found->timestamp,
-				radar_found->chan_freq,
-				radar_found->chan_width,
-				radar_found->detector_id,
-				radar_found->freq_offset,
-				radar_found->segment_id,
-				radar_found->sidx,
-				radar_found->is_chirp);
-	} else {
-		if (dfs->dfs_use_nol) {
-			dfs_process_radar_found_indication(dfs, radar_found);
-			dfs_mlme_mark_dfs(pdev, dfs->dfs_curchan->dfs_ch_ieee,
-				dfs->dfs_curchan->dfs_ch_freq,
-				dfs->dfs_curchan->dfs_ch_vhtop_ch_freq_seg2,
-				dfs->dfs_curchan->dfs_ch_flags);
-		} else{
-
-			/* We are in test mode and should send a CSA back
-			 * to same channel. */
-			qdf_timer_stop(&dfs->wlan_dfstesttimer);
-			dfs->wlan_dfstest = 1;
-			dfs->wlan_dfstest_ieeechan =
-				dfs->dfs_curchan->dfs_ch_ieee;
-			dfs->wlan_dfstesttime = 1;   /* 1ms */
-			qdf_timer_mod(&dfs->wlan_dfstesttimer,
-					dfs->wlan_dfstesttime);
-		}
-	}
-
-	return QDF_STATUS_SUCCESS;
+	return dfs_process_radar_ind(dfs, radar_found);
 }
 EXPORT_SYMBOL(tgt_dfs_process_radar_ind);
 

umac/dfs/dispatcher/src/wlan_dfs_utils_api.c

@@ -815,6 +815,9 @@ uint8_t utils_dfs_freq_to_chan(uint32_t freq)
 {
 	uint8_t chan;
 
+	if (freq == 0)
+		return 0;
+
 	if (freq > DFS_24_GHZ_BASE_FREQ && freq < DFS_CHAN_14_FREQ)
 		chan = ((freq - DFS_24_GHZ_BASE_FREQ) / DFS_CHAN_SPACING_5MHZ);
 	else if (freq == DFS_CHAN_14_FREQ)
@@ -831,6 +834,9 @@ EXPORT_SYMBOL(utils_dfs_freq_to_chan);
 
 uint32_t utils_dfs_chan_to_freq(uint8_t chan)
 {
+	if (chan == 0)
+		return 0;
+
 	if (chan < DFS_24_GHZ_CHANNEL_14)
 		return DFS_24_GHZ_BASE_FREQ + (chan * DFS_CHAN_SPACING_5MHZ);
 	else if (chan == DFS_24_GHZ_CHANNEL_14)