diff --git a/umac/dfs/core/src/misc/dfs.c b/umac/dfs/core/src/misc/dfs.c index 1fc944e4c622..a14489c63c23 100644 --- a/umac/dfs/core/src/misc/dfs.c +++ b/umac/dfs/core/src/misc/dfs.c @@ -22,11 +22,11 @@ * various ioctls to set and get radar detection thresholds. */ -#include #include "../dfs_zero_cac.h" #include "wlan_dfs_lmac_api.h" #include "wlan_dfs_mlme_api.h" #include "../dfs_internal.h" +#include /* * Channel switch announcement (CSA) diff --git a/umac/dfs/core/src/misc/dfs_nol.c b/umac/dfs/core/src/misc/dfs_nol.c index 5543c89cbe79..1fcb3a187bc6 100644 --- a/umac/dfs/core/src/misc/dfs_nol.c +++ b/umac/dfs/core/src/misc/dfs_nol.c @@ -26,13 +26,15 @@ * NOL when its time is up. */ -#include #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 +#include +#include +#include +#include /* 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); } diff --git a/umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h b/umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h index c1805469c6af..2218adbc1656 100644 --- a/umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h +++ b/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_ */ diff --git a/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c b/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c index c144637dad24..8d464828c878 100644 --- a/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c +++ b/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 +#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);