qcacmn: Random channel selection public API

Add random channel selection public API.

Change-Id: I5502116fab17716a9d8f2f41ddd67bcbcdd1328c
CRs-Fixed: 2017481

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

@@ -22,11 +22,11 @@
  * various ioctls to set and get radar detection thresholds.
  */
 
-#include <dfs_ioctl.h>
 #include "../dfs_zero_cac.h"
 #include "wlan_dfs_lmac_api.h"
 #include "wlan_dfs_mlme_api.h"
 #include "../dfs_internal.h"
+#include <dfs_ioctl.h>
 
 /*
  * Channel switch announcement (CSA)

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

@@ -26,13 +26,15 @@
  * NOL when its time is up.
  */
 
-#include <dfs_ioctl.h>
 #include "../dfs.h"
 #include "../dfs_channel.h"
 #include "../dfs_ioctl_private.h"
-#include "qdf_time.h"
-#include "wlan_dfs_mlme_api.h"
 #include "../dfs_internal.h"
+#include <qdf_time.h>
+#include <wlan_dfs_mlme_api.h>
+#include <wlan_dfs_utils_api.h>
+#include <wlan_reg_services_api.h>
+#include <dfs_ioctl.h>
 
 /* for loop to traverse the channel list. */
 
@@ -103,6 +105,7 @@ static os_timer_func(dfs_remove_from_nol)
 	struct wlan_dfs *dfs;
 	uint16_t delfreq;
 	uint16_t delchwidth;
+	uint32_t chan;
 
 	OS_GET_TIMER_ARG(nol_arg, struct dfs_nol_timer_arg *);
 
@@ -117,7 +120,12 @@ static os_timer_func(dfs_remove_from_nol)
 	dfs_nol_update(dfs);
 
 	dfs_mlme_nol_timeout_notification(dfs->dfs_pdev_obj);
-
+	chan = utils_dfs_freq_to_chan(dfs->dfs_pdev_obj, delfreq);
+	DFS_DPRINTK(dfs, WLAN_DEBUG_DFS_NOL,
+		    "%s: remove channel %d from nol\n", __func__, chan);
+	utils_dfs_reg_update_nol_ch(dfs->dfs_pdev_obj,
+			(uint8_t *)&chan, 1, DFS_NOL_RESET);
+	dfs_save_nol(dfs->dfs_pdev_obj);
 	qdf_mem_free(nol_arg);
 }
 

umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h

@@ -26,6 +26,24 @@
 #define _WLAN_DFS_UTILS_API_H_
 
 #include "wlan_dfs_ucfg_api.h"
+#include "wlan_reg_services_api.h"
+
+/* Add channel to nol */
+#define DFS_NOL_SET                  1
+
+/* Remove channel from nol */
+#define DFS_NOL_RESET                0
+
+/* Max nol channels */
+#define DFS_MAX_NOL_CHANNEL        128
+
+/* dfs offload service bit */
+#define DFS_SERVICE_PHYERR_OFFLOAD 113
+
+/* check if dfs offload enabled */
+#define DFS_OFFLOAD_IS_ENABLED(service_bitmap) \
+	(((service_bitmap)[(DFS_SERVICE_PHYERR_OFFLOAD)/(sizeof(A_UINT32))] & \
+	   (1 << ((DFS_SERVICE_PHYERR_OFFLOAD)%(sizeof(A_UINT32))))) != 0)
 
 extern struct dfs_to_mlme global_dfs_to_mlme;
 
@@ -284,4 +302,107 @@ QDF_STATUS utils_dfs_get_nol_chfreq_and_chwidth(struct wlan_objmgr_pdev *pdev,
 		uint32_t *nol_chfreq,
 		uint32_t *nol_chwidth,
 		int index);
+
+/**
+ * dfs_get_random_channel() - Get random channel.
+ * @pdev: Pointer to DFS pdev object.
+ * @flags: random channel selection flags.
+ * @ch_params: current channel params.
+ * @hw_mode: current operating mode.
+ * @target_chan: Pointer to target_chan.
+ *
+ * wrapper function for get_random_chan(). this
+ * function called from outside of dfs component.
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS dfs_get_random_channel(struct wlan_objmgr_pdev *pdev,
+		uint16_t flags, struct ch_params *ch_params,
+		uint32_t *hw_mode, int *target_chan);
+
+/**
+ * dfs_init_nol() - Initialize nol from platform driver.
+ * @pdev: pdev handler.
+ *
+ * Initialize nol from platform driver.
+ *
+ * Return: None
+ */
+void dfs_init_nol(struct wlan_objmgr_pdev *pdev);
+
+/**
+ * dfs_save_nol() - save nol list to platform driver.
+ * @pdev: pdev handler.
+ *
+ * Save nol list to platform driver.
+ *
+ * Return: None
+ */
+void dfs_save_nol(struct wlan_objmgr_pdev *pdev);
+
+/**
+ * dfs_print_nol_channels() - log nol channels.
+ * @pdev: pdev handler.
+ *
+ * log nol channels.
+ *
+ * Return: None
+ */
+void dfs_print_nol_channels(struct wlan_objmgr_pdev *pdev);
+
+/**
+ * dfs_clear_nol_channels() - clear nol list.
+ * @pdev: pdev handler.
+ *
+ * log nol channels.
+ *
+ * Return: None
+ */
+void dfs_clear_nol_channels(struct wlan_objmgr_pdev *pdev);
+
+/**
+ * utils_is_dfs_ch() - is channel dfs.
+ * @pdev: pdev handler.
+ *
+ * is channel dfs.
+ *
+ * Return: True if channel dfs, else false.
+ */
+bool utils_is_dfs_ch(struct wlan_objmgr_pdev *pdev, uint32_t chan);
+
+/**
+ * utils_dfs_reg_update_nol_ch() - set nol channel
+ *
+ * @pdev: pdev ptr
+ * @ch_list: channel list to be returned
+ * @num_ch: number of channels
+ * @nol_ch: nol flag
+ *
+ * Return: void
+ */
+void utils_dfs_reg_update_nol_ch(struct wlan_objmgr_pdev *pdev,
+		uint8_t *ch_list,
+		uint8_t num_ch,
+		bool nol_ch);
+
+/**
+ * utils_dfs_freq_to_chan () - convert channel freq to channel number
+ * @pdev: pdev ptr
+ * @freq: frequency
+ *
+ * Return: channel number
+ */
+uint32_t utils_dfs_freq_to_chan(struct wlan_objmgr_pdev *pdev,
+			       uint32_t freq);
+
+/**
+ * utils_dfs__chan_to_freq () - convert channel number to frequency
+ * @pdev: pdev ptr
+ * @chan: channel number
+ *
+ * Return: frequency
+ */
+uint32_t utils_dfs_chan_to_freq(struct wlan_objmgr_pdev *pdev,
+			       uint32_t chan);
+
 #endif /* _WLAN_DFS_UTILS_API_H_ */

umac/dfs/dispatcher/src/wlan_dfs_utils_api.c

@@ -24,6 +24,18 @@
 #include "wlan_dfs_utils_api.h"
 #include "../../core/src/dfs.h"
 #include "../../core/src/dfs_zero_cac.h"
+#include "../../core/src/dfs_random_chan_sel.h"
+#ifdef QCA_DFS_USE_POLICY_MANAGER
+#include "wlan_policy_mgr_api.h"
+#endif
+#ifdef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT
+#include <pld_common.h>
+#endif
+
+struct dfs_nol_info {
+	uint16_t num_chans;
+	struct dfsreq_nolelem dfs_nol[DFS_MAX_NOL_CHANNEL];
+};
 
 QDF_STATUS utils_nif_dfs_attach(struct wlan_objmgr_pdev *pdev)
 {
@@ -395,3 +407,289 @@ QDF_STATUS utils_dfs_get_nol_chfreq_and_chwidth(struct wlan_objmgr_pdev *pdev,
 }
 EXPORT_SYMBOL(utils_dfs_get_nol_chfreq_and_chwidth);
 
+static void utils_dfs_get_max_phy_mode(struct wlan_objmgr_pdev *pdev,
+		uint32_t *phy_mode)
+{
+	return;
+}
+
+static void utils_dfs_get_max_sup_width(struct wlan_objmgr_pdev *pdev,
+		uint8_t *ch_width)
+{
+	return;
+}
+
+#ifndef QCA_DFS_USE_POLICY_MANAGER
+static void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev,
+	struct dfs_ieee80211_channel *chan_list, uint32_t *num_chan)
+{
+	return;
+}
+#else
+static void utils_dfs_get_chan_list(struct wlan_objmgr_pdev *pdev,
+	struct dfs_ieee80211_channel *chan_list, uint32_t *num_chan)
+{
+	uint8_t pcl_ch[NUM_CHANNELS];
+	uint32_t len;
+	int i;
+	struct wlan_objmgr_psoc *psoc;
+	uint32_t conn_count = 0;
+
+	wlan_pdev_obj_lock(pdev);
+	psoc = wlan_pdev_get_psoc(pdev);
+	wlan_pdev_obj_unlock(pdev);
+	if (!psoc) {
+		*num_chan = 0;
+		DFS_PRINTK("%s: null psoc\n", __func__);
+		return;
+	}
+
+	len = QDF_ARRAY_SIZE(pcl_ch);
+	conn_count = policy_mgr_mode_specific_connection_count(
+			psoc, PM_SAP_MODE, NULL);
+	if (0 == conn_count)
+		policy_mgr_get_pcl(psoc, PM_SAP_MODE, pcl_ch, &len, NULL, 0);
+	else
+		policy_mgr_get_pcl_for_existing_conn(psoc, PM_SAP_MODE, pcl_ch,
+						     &len, NULL, 0);
+
+	if (*num_chan < len) {
+		DFS_PRINTK("%s: Invalid len src=%d, dst=%d\n",
+			   __func__, *num_chan, len);
+		*num_chan = 0;
+		return;
+	}
+
+	for (i = 0; i < len; i++) {
+		chan_list[i].ic_ieee  = pcl_ch[i];
+		chan_list[i].ic_freq  = wlan_reg_chan_to_freq(pdev, pcl_ch[i]);
+	}
+	*num_chan = i;
+	DFS_PRINTK("%s: num channels %d\n", __func__, i);
+}
+#endif
+
+QDF_STATUS dfs_get_random_channel(
+	struct wlan_objmgr_pdev *pdev,
+	uint16_t flags,
+	struct ch_params *ch_params,
+	uint32_t *hw_mode,
+	int *target_chan)
+{
+	uint32_t dfs_reg;
+	uint32_t num_chan = NUM_CHANNELS;
+	struct wlan_dfs *dfs = NULL;
+	struct wlan_objmgr_psoc *psoc;
+	struct dfs_ieee80211_channel *chan_list = NULL;
+	struct dfs_ieee80211_channel cur_chan;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	*target_chan = 0;
+	wlan_pdev_obj_lock(pdev);
+	psoc = wlan_pdev_get_psoc(pdev);
+	wlan_pdev_obj_unlock(pdev);
+	if (!psoc) {
+		DFS_PRINTK("%s: null psoc\n", __func__);
+		goto random_chan_error;
+	}
+
+	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
+	if (!dfs) {
+		DFS_PRINTK("%s: null dfs\n", __func__);
+		goto random_chan_error;
+	}
+
+	wlan_reg_get_dfs_region(psoc, &dfs_reg);
+	chan_list = qdf_mem_malloc(num_chan * sizeof(*chan_list));
+	if (!chan_list) {
+		DFS_PRINTK("%s: mem alloc failed\n", __func__);
+		goto random_chan_error;
+	}
+
+	utils_dfs_get_chan_list(pdev, chan_list, &num_chan);
+	if (!num_chan) {
+		DFS_PRINTK("%s: zero channels\n", __func__);
+		goto random_chan_error;
+	}
+
+	cur_chan.ic_vhtop_ch_freq_seg1 = ch_params->center_freq_seg0;
+	cur_chan.ic_vhtop_ch_freq_seg2 = ch_params->center_freq_seg1;
+
+	if (!ch_params->ch_width)
+		utils_dfs_get_max_sup_width(pdev,
+				(uint8_t *)&ch_params->ch_width);
+
+	*target_chan = dfs_prepare_random_channel(dfs, chan_list,
+		num_chan, flags, (uint8_t *)&ch_params->ch_width,
+		&cur_chan, (uint8_t)dfs_reg);
+
+	ch_params->center_freq_seg0 = cur_chan.ic_vhtop_ch_freq_seg1;
+	ch_params->center_freq_seg1 = cur_chan.ic_vhtop_ch_freq_seg2;
+	if (*target_chan) {
+		wlan_reg_set_channel_params(pdev,
+			(uint8_t)*target_chan, 0, ch_params);
+		utils_dfs_get_max_phy_mode(pdev, hw_mode);
+		status = QDF_STATUS_SUCCESS;
+	}
+
+random_chan_error:
+	qdf_mem_free(chan_list);
+
+	return status;
+}
+EXPORT_SYMBOL(dfs_get_random_channel);
+
+#ifndef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT
+void dfs_init_nol(struct wlan_objmgr_pdev *pdev)
+{
+}
+#else
+void dfs_init_nol(struct wlan_objmgr_pdev *pdev)
+{
+	struct wlan_dfs *dfs;
+	struct wlan_objmgr_psoc *psoc;
+	qdf_device_t qdf_dev;
+	struct dfs_nol_info dfs_nolinfo;
+	int len;
+
+	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
+	wlan_pdev_obj_lock(pdev);
+	psoc = wlan_pdev_get_psoc(pdev);
+	wlan_pdev_obj_unlock(pdev);
+	if (!dfs || !psoc) {
+		DFS_PRINTK("%s: dfs %p, psoc %p\n", __func__, dfs, psoc);
+		return;
+	}
+
+	qdf_dev = psoc->soc_objmgr.qdf_dev;
+	if (!qdf_dev->dev) {
+		DFS_PRINTK("%s: null device\n", __func__);
+		return;
+	}
+
+	qdf_mem_zero(&dfs_nolinfo, sizeof(dfs_nolinfo));
+	len = pld_wlan_get_dfs_nol(qdf_dev->dev, (void *)&dfs_nolinfo,
+			(uint16_t)sizeof(dfs_nolinfo));
+	if (len > 0)
+		dfs_set_nol(dfs, dfs_nolinfo.dfs_nol, dfs_nolinfo.num_chans);
+	else
+		DFS_PRINTK("%s: nol nol in pld\n", __func__);
+}
+#endif
+EXPORT_SYMBOL(dfs_init_nol);
+
+#ifndef QCA_DFS_NOL_PLATFORM_DRV_SUPPORT
+void dfs_save_nol(struct wlan_objmgr_pdev *pdev)
+{
+}
+#else
+void dfs_save_nol(struct wlan_objmgr_pdev *pdev)
+{
+	struct dfs_nol_info dfs_nolinfo;
+	struct wlan_dfs *dfs = NULL;
+	struct wlan_objmgr_psoc *psoc;
+	qdf_device_t qdf_dev;
+	int num_chans = 0;
+
+	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
+	if (!dfs) {
+		DFS_PRINTK("%s: null dfs\n", __func__);
+		return;
+	}
+
+	wlan_pdev_obj_lock(pdev);
+	psoc = wlan_pdev_get_psoc(pdev);
+	wlan_pdev_obj_unlock(pdev);
+	if (!psoc) {
+		DFS_PRINTK("%s: null psoc\n", __func__);
+		return;
+	}
+
+	qdf_dev = psoc->soc_objmgr.qdf_dev;
+	if (!qdf_dev->dev) {
+		DFS_PRINTK("%s: null device\n", __func__);
+		return;
+	}
+
+	qdf_mem_zero(&dfs_nolinfo, sizeof(dfs_nolinfo));
+	dfs_get_nol(dfs, dfs_nolinfo.dfs_nol, &num_chans);
+	if (num_chans > 0) {
+
+		if (num_chans > DFS_MAX_NOL_CHANNEL)
+			dfs_nolinfo.num_chans = DFS_MAX_NOL_CHANNEL;
+		else
+			dfs_nolinfo.num_chans = num_chans;
+
+		pld_wlan_set_dfs_nol(qdf_dev->dev, (void *)&dfs_nolinfo,
+				(uint16_t)sizeof(dfs_nolinfo));
+	}
+}
+#endif
+EXPORT_SYMBOL(dfs_save_nol);
+
+void dfs_print_nol_channels(struct wlan_objmgr_pdev *pdev)
+{
+	struct wlan_dfs *dfs = NULL;
+
+	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
+	if (!dfs) {
+		DFS_PRINTK("%s: null dfs\n", __func__);
+		return;
+	}
+
+	dfs_print_nol(dfs);
+}
+EXPORT_SYMBOL(dfs_print_nol_channels);
+
+void dfs_clear_nol_channels(struct wlan_objmgr_pdev *pdev)
+{
+	struct wlan_dfs *dfs = NULL;
+
+	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
+	if (!dfs) {
+		DFS_PRINTK("%s: null dfs\n", __func__);
+		return;
+	}
+
+	/* First print list */
+	dfs_print_nol(dfs);
+
+	/* clear local cache first */
+	dfs_nol_timer_cleanup(dfs);
+
+	/*
+	 * update platform driver nol list with local cache which is zero,
+	 * cleared in above step, so this will clear list in platform driver.
+	 */
+	dfs_save_nol(pdev);
+}
+EXPORT_SYMBOL(dfs_clear_nol_channels);
+
+bool utils_is_dfs_ch(struct wlan_objmgr_pdev *pdev, uint32_t chan)
+{
+	return wlan_reg_is_dfs_ch(pdev, chan);
+}
+EXPORT_SYMBOL(utils_is_dfs_ch);
+
+void utils_dfs_reg_update_nol_ch(struct wlan_objmgr_pdev *pdev,
+		uint8_t *ch_list,
+		uint8_t num_ch,
+		bool nol_ch)
+{
+	wlan_reg_update_nol_ch(pdev, ch_list, num_ch, nol_ch);
+}
+EXPORT_SYMBOL(utils_dfs_reg_update_nol_ch);
+
+uint32_t utils_dfs_freq_to_chan(struct wlan_objmgr_pdev *pdev,
+			       uint32_t freq)
+{
+	return wlan_reg_freq_to_chan(pdev, freq);
+}
+EXPORT_SYMBOL(utils_dfs_freq_to_chan);
+
+uint32_t utils_dfs_chan_to_freq(struct wlan_objmgr_pdev *pdev,
+			       uint32_t chan)
+{
+	return wlan_reg_chan_to_freq(pdev, chan);
+}
+EXPORT_SYMBOL(utils_dfs_chan_to_freq);