qcacmn: Redefine dfs data structure to fix prealloc size concern

Redefine dfs filter type to avoid prealloc problem by making one
large chunk into multiple smaller chunks.
With current data structure, dfs attach was requesting huge chunk
of memory from the heap which results in failure.

Fix is to modify the data structure so that one large chunk
is made as multiple smaller chunks.

Change-Id: Iaa8d0b1b6e4b192b37e165c936920baa5d10a23b
CRs-Fixed: 2323927

umac/dfs/core/src/dfs.h

@@ -616,8 +616,8 @@ struct dfs_filter {
 } qdf_packed;
 
 /**
- * struct dfs_filtertype - DFS Filter type.
- * @ft_filterdur[]:    Filter array.
+ * struct dfs_filtertype - Structure of DFS Filter type.
+ * @ft_filters[]:      Array of ptrs storing addresses for struct of dfs_filter.
  * @ft_filterdur:      Duration of pulse which specifies filter type.
  * @ft_numfilters:     Num filters of this type.
  * @ft_last_ts:        Last timestamp this filtertype was used (in usecs).
@@ -631,7 +631,7 @@ struct dfs_filter {
  *                     lower than in non TURBO mode. This will offset that diff.
  */
 struct dfs_filtertype {
-	struct dfs_filter ft_filters[DFS_MAX_NUM_RADAR_FILTERS];
+	struct dfs_filter *ft_filters[DFS_MAX_NUM_RADAR_FILTERS];
 	uint32_t  ft_filterdur;
 	uint32_t  ft_numfilters;
 	uint64_t  ft_last_ts;

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

@@ -61,7 +61,7 @@ static void dfs_print_filtertype(
 	struct dfs_filter *rf;
 
 	for (j = 0; j < ft->ft_numfilters; j++) {
-		rf = &(ft->ft_filters[j]);
+		rf = ft->ft_filters[j];
 		dfs_debug(dfs, WLAN_DEBUG_DFS2,
 				"filter[%d] filterID = %d rf_numpulses=%u; rf->rf_minpri=%u; rf->rf_maxpri=%u; rf->rf_threshold=%u; rf->rf_filterlen=%u; rf->rf_mindur=%u; rf->rf_maxdur=%u",
 				j, rf->rf_pulseid, rf->rf_numpulses,

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

@@ -38,7 +38,7 @@ static inline void dfs_reset_filtertype(
 	struct dfs_delayline *dl;
 
 	for (j = 0; j < ft->ft_numfilters; j++) {
-		rf = &(ft->ft_filters[j]);
+		rf = ft->ft_filters[j];
 		dl = &(rf->rf_dl);
 		if (dl != NULL) {
 			qdf_mem_zero(dl, sizeof(*dl));
@@ -106,7 +106,7 @@ void dfs_reset_filter_delaylines(struct dfs_filtertype *dft)
 	int i;
 
 	for (i = 0; i < DFS_MAX_NUM_RADAR_FILTERS; i++) {
-		df = &dft->ft_filters[i];
+		df = dft->ft_filters[i];
 		dfs_reset_delayline(&(df->rf_dl));
 	}
 }
@@ -296,7 +296,7 @@ int dfs_init_radar_filters(struct wlan_dfs *dfs,
 				goto bad4;
 		}
 
-		rf = &(ft->ft_filters[ft->ft_numfilters++]);
+		rf = ft->ft_filters[ft->ft_numfilters++];
 		dfs_reset_delayline(&rf->rf_dl);
 		numpulses = dfs_radars[p].rp_numpulses;
 

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

@@ -397,7 +397,7 @@ void __dfs_process_radarevent(struct wlan_dfs *dfs,
 
 	for (p = 0, *found = 0; (p < ft->ft_numfilters) &&
 			(!(*found)) && !(*false_radar_found); p++) {
-		rf = &(ft->ft_filters[p]);
+		rf = ft->ft_filters[p];
 		if ((re->re_dur >= rf->rf_mindur) &&
 				(re->re_dur <= rf->rf_maxdur)) {
 			/* The above check is probably not necessary. */

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

@@ -135,9 +135,51 @@ static void dfs_main_task_timer_init(struct wlan_dfs *dfs)
 			QDF_TIMER_TYPE_WAKE_APPS);
 }
 
+/**
+ * dfs_free_filter() - free memory allocated for dfs ft_filters
+ * @radarf: pointer holding ft_filters.
+ *
+ * Return: None
+ */
+static void dfs_free_filter(struct dfs_filtertype *radarf)
+{
+	uint8_t i;
+
+	for (i = 0; i < DFS_MAX_NUM_RADAR_FILTERS; i++) {
+		if (radarf->ft_filters[i]) {
+			qdf_mem_free(radarf->ft_filters[i]);
+			radarf->ft_filters[i] = NULL;
+		}
+	}
+}
+
+/**
+ * dfs_alloc_mem_filter() - allocate memory for dfs ft_filters
+ * @radarf: pointer holding ft_filters.
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS dfs_alloc_mem_filter(struct dfs_filtertype *radarf)
+{
+	uint8_t i;
+
+	for (i = 0; i < DFS_MAX_NUM_RADAR_FILTERS; i++) {
+		radarf->ft_filters[i] = qdf_mem_malloc(sizeof(struct
+							      dfs_filter));
+		if (!radarf->ft_filters[i]) {
+			/* Free all the filter if malloc failed */
+			dfs_free_filter(radarf);
+			return QDF_STATUS_E_FAILURE;
+		}
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
 int dfs_main_attach(struct wlan_dfs *dfs)
 {
 	int i, n;
+	QDF_STATUS status;
 	struct wlan_dfs_radar_tab_info radar_info;
 
 	if (!dfs) {
@@ -210,7 +252,14 @@ int dfs_main_attach(struct wlan_dfs *dfs)
 					"cannot allocate memory for radar filter types");
 			goto bad1;
 		}
-		qdf_mem_zero(dfs->dfs_radarf[n], sizeof(struct dfs_filtertype));
+		qdf_mem_zero(dfs->dfs_radarf[n],
+			     sizeof(struct dfs_filtertype));
+		status = dfs_alloc_mem_filter(dfs->dfs_radarf[n]);
+		if (!QDF_IS_STATUS_SUCCESS(status)) {
+			dfs_alert(dfs, WLAN_DEBUG_DFS_ALWAYS,
+				  "mem alloc for dfs_filter failed");
+			goto bad1;
+		}
 	}
 
 	/* Allocate memory for radar table. */
@@ -267,6 +316,7 @@ bad2:
 bad1:
 	for (n = 0; n < DFS_MAX_RADAR_TYPES; n++) {
 		if (dfs->dfs_radarf[n] != NULL) {
+			dfs_free_filter(dfs->dfs_radarf[n]);
 			qdf_mem_free(dfs->dfs_radarf[n]);
 			dfs->dfs_radarf[n] = NULL;
 		}
@@ -325,6 +375,7 @@ void dfs_main_detach(struct wlan_dfs *dfs)
 
 	for (n = 0; n < DFS_MAX_RADAR_TYPES; n++) {
 		if (dfs->dfs_radarf[n] != NULL) {
+			dfs_free_filter(dfs->dfs_radarf[n]);
 			qdf_mem_free(dfs->dfs_radarf[n]);
 			dfs->dfs_radarf[n] = NULL;
 		}