From 8fd2d1abbf772cdd5280cd64de22b1a4593ba9d9 Mon Sep 17 00:00:00 2001 From: Vinay Gannevaram Date: Wed, 25 Dec 2019 15:53:29 +0530 Subject: [PATCH] qcacmn: Add support for NLA type CH_INFO_RESP in LOWI Host driver processes cld80211 vendor sub command CLD80211_VENDOR_SUB_CMD_GET_CH_INFO and respond with NLA type CH_INFO response CRs-Fixed: 2595374 Change-Id: Ibe6f2431ac1cae6e4560ec11424434b4f1cf8b76 --- os_if/linux/wifi_pos/inc/os_if_wifi_pos.h | 38 +++++ os_if/linux/wifi_pos/src/os_if_wifi_pos.c | 161 ++++++++++++++++++ umac/wifi_pos/inc/wifi_pos_utils_pub.h | 23 +++ umac/wifi_pos/src/wifi_pos_main.c | 189 +++++++++++++--------- 4 files changed, 331 insertions(+), 80 deletions(-) diff --git a/os_if/linux/wifi_pos/inc/os_if_wifi_pos.h b/os_if/linux/wifi_pos/inc/os_if_wifi_pos.h index 3d7a8bf0a323..26c62d8b971a 100644 --- a/os_if/linux/wifi_pos/inc/os_if_wifi_pos.h +++ b/os_if/linux/wifi_pos/inc/os_if_wifi_pos.h @@ -173,5 +173,43 @@ enum cld80211_sub_attr_cap_rsp { CLD80211_SUB_ATTR_CAPS_MAX = CLD80211_SUB_ATTR_CAPS_AFTER_LAST - 1 }; + +/** + * enum cld80211_sub_attr_channel_rsp - Chan info response sub attribute + * @CLD80211_SUB_ATTR_CH_RESP_INVALID: Invalid channel resp + * @CLD80211_SUB_ATTR_CH_MORE_DATA: More date sub attr for frag response + * @CLD80211_SUB_ATTR_CHANNEL_NUM_CHAN: Number of channels in response + * @CLD80211_SUB_ATTR_CHANNEL_LIST: Channel list nesting + * @CLD80211_SUB_ATTR_CH_CHAN_ID: Channel number + * @CLD80211_SUB_ATTR_CH_MHZ: Channel frequency + * @CLD80211_SUB_ATTR_CH_BAND_CF_1: Center frequency 1 + * @CLD80211_SUB_ATTR_CH_BAND_CF_2: Center frequency 2 + * @CLD80211_SUB_ATTR_CH_INFO: channel info + * @CLD80211_SUB_ATTR_CH_REG_INFO_1: regulatory info field 1 + * @CLD80211_SUB_ATTR_CH_REG_INFO_2: regulatory info field 2 + * @CLD80211_SUB_ATTR_CAPS_MAX: Max number for CHAN Info sub attribute + * + */ +enum cld80211_sub_attr_channel_rsp { + CLD80211_SUB_ATTR_CH_RESP_INVALID = 0, + CLD80211_SUB_ATTR_CH_MORE_DATA = 1, + CLD80211_SUB_ATTR_CHANNEL_NUM_CHAN = 2, + CLD80211_SUB_ATTR_CH_LIST = 3, + /* CH_* belongs to CH_LIST */ + CLD80211_SUB_ATTR_CH_CHAN_ID = 4, + CLD80211_SUB_ATTR_CH_MHZ = 5, + CLD80211_SUB_ATTR_CH_BAND_CF_1 = 6, + CLD80211_SUB_ATTR_CH_BAND_CF_2 = 7, + CLD80211_SUB_ATTR_CH_INFO = 8, + CLD80211_SUB_ATTR_CH_REG_INFO_1 = 9, + CLD80211_SUB_ATTR_CH_REG_INFO_2 = 10, + + /* keep last */ + CLD80211_SUB_ATTR_CH_AFTER_LAST, + CLD80211_SUB_ATTR_CH_MAX = + CLD80211_SUB_ATTR_CH_AFTER_LAST - 1 + +}; + #endif #endif /* _OS_IF_WIFI_POS_H_ */ diff --git a/os_if/linux/wifi_pos/src/os_if_wifi_pos.c b/os_if/linux/wifi_pos/src/os_if_wifi_pos.c index 2eb189f9a688..3474c4858f63 100644 --- a/os_if/linux/wifi_pos/src/os_if_wifi_pos.c +++ b/os_if/linux/wifi_pos/src/os_if_wifi_pos.c @@ -62,6 +62,19 @@ cap_resp_sub_attr_len[CLD80211_SUB_ATTR_CAPS_MAX + 1] = { [CLD80211_SUB_ATTR_CAPS_USER_DEFINED_CAPS] = sizeof(struct wifi_pos_user_defined_caps), }; + +static const uint32_t +ch_resp_sub_attr_len[CLD80211_SUB_ATTR_CH_MAX + 1] = { + [CLD80211_SUB_ATTR_CHANNEL_NUM_CHAN] = sizeof(uint32_t), + [CLD80211_SUB_ATTR_CH_LIST] = sizeof(uint32_t), + [CLD80211_SUB_ATTR_CH_CHAN_ID] = sizeof(uint32_t), + [CLD80211_SUB_ATTR_CH_MHZ] = sizeof(uint32_t), + [CLD80211_SUB_ATTR_CH_BAND_CF_1] = sizeof(uint32_t), + [CLD80211_SUB_ATTR_CH_BAND_CF_2] = sizeof(uint32_t), + [CLD80211_SUB_ATTR_CH_INFO] = sizeof(uint32_t), + [CLD80211_SUB_ATTR_CH_REG_INFO_1] = sizeof(uint32_t), + [CLD80211_SUB_ATTR_CH_REG_INFO_2] = sizeof(uint32_t), +}; #endif static int map_wifi_pos_cmd_to_ani_msg_rsp( @@ -216,6 +229,151 @@ static void os_if_send_cap_nl_resp(uint32_t pid, uint8_t *buf) cld80211_oem_send_reply(msg, hdr, nest1, flags); } +static void +os_if_get_chan_nl_resp_len(uint32_t *chan_info, uint32_t *attr_headers) +{ + uint32_t i; + struct nlattr more_data; + struct nlattr attr_tag_data; + struct nlattr cld80211_subattr_ch_list; + struct nlattr chan_iter; + + *attr_headers = NLA_ALIGN(sizeof(attr_tag_data)); + *attr_headers += NLA_ALIGN(sizeof(more_data)); + *attr_headers += nla_total_size( + ch_resp_sub_attr_len[CLD80211_SUB_ATTR_CHANNEL_NUM_CHAN]); + *attr_headers += sizeof(cld80211_subattr_ch_list); + + *chan_info = NLA_ALIGN(sizeof(chan_iter)); + i = CLD80211_SUB_ATTR_CH_LIST; + for (; i <= CLD80211_SUB_ATTR_CH_MAX; i++) + *chan_info += nla_total_size(ch_resp_sub_attr_len[i]); +} + +static uint8_t os_if_get_max_chan_nl_resp(uint8_t chan_num) +{ + struct nlattr vendor_data; + struct nlattr attr_cmd; + uint32_t chan_info = 0, attr_headers = 0; + uint32_t chan_info_msg_len, chan_allow = 0; + + os_if_get_chan_nl_resp_len(&chan_info, &attr_headers); + attr_headers += NLA_ALIGN(sizeof(vendor_data)); + attr_headers += NLA_ALIGN(sizeof(attr_cmd)); + + chan_info_msg_len = WLAN_CLD80211_MAX_SIZE; + chan_info_msg_len -= WIFIPOS_RESERVE_BYTES; + chan_info_msg_len -= attr_headers; + + chan_allow = chan_info_msg_len / chan_info; + + if (chan_num > chan_allow) + return chan_allow; + else + return chan_num; +} + +static int +os_if_create_ch_nl_resp(uint32_t pid, uint8_t *buf, uint16_t num_chan, + bool is_frag) +{ + void *hdr; + int i; + int flags = GFP_KERNEL; + struct sk_buff *msg = NULL; + struct nlattr *nest1, *nest2; + struct nlattr *nest3, *nest4; + struct wifi_pos_ch_info_rsp *channel_rsp; + + channel_rsp = (struct wifi_pos_ch_info_rsp *)buf; + + msg = cld80211_oem_rsp_alloc_skb(pid, &hdr, &nest1, &flags); + if (!msg) { + osif_err("alloc_skb failed"); + return -EPERM; + } + + nla_put_u32(msg, CLD80211_ATTR_CMD, + CLD80211_VENDOR_SUB_CMD_GET_CH_INFO); + + nest2 = nla_nest_start(msg, CLD80211_ATTR_CMD_TAG_DATA); + if (!nest2) + goto fail; + + if (is_frag) + nla_put_flag(msg, CLD80211_SUB_ATTR_CH_MORE_DATA); + + nla_put_u32(msg, CLD80211_SUB_ATTR_CHANNEL_NUM_CHAN, num_chan); + + nest3 = nla_nest_start(msg, CLD80211_SUB_ATTR_CH_LIST); + if (!nest3) + goto fail; + for (i = 0; i < num_chan; i++) { + nest4 = nla_nest_start(msg, i); + if (!nest4) + goto fail; + + nla_put_u32(msg, CLD80211_SUB_ATTR_CH_CHAN_ID, + channel_rsp->chan_id); + nla_put_u32(msg, CLD80211_SUB_ATTR_CH_MHZ, channel_rsp->mhz); + nla_put_u32(msg, CLD80211_SUB_ATTR_CH_BAND_CF_1, + channel_rsp->band_center_freq1); + nla_put_u32(msg, CLD80211_SUB_ATTR_CH_BAND_CF_2, + channel_rsp->band_center_freq2); + nla_put_u32(msg, CLD80211_SUB_ATTR_CH_INFO, channel_rsp->info); + nla_put_u32(msg, CLD80211_SUB_ATTR_CH_REG_INFO_1, + channel_rsp->reg_info_1); + nla_put_u32(msg, CLD80211_SUB_ATTR_CH_REG_INFO_2, + channel_rsp->reg_info_2); + nla_nest_end(msg, nest4); + channel_rsp++; + } + + nla_nest_end(msg, nest3); + nla_nest_end(msg, nest2); + + osif_debug("sending oem rsp: type: %d to pid (%d)", + CLD80211_VENDOR_SUB_CMD_GET_CH_INFO, pid); + + cld80211_oem_send_reply(msg, hdr, nest1, flags); + return 0; + +fail: + osif_err("failed to fill CHAN_RESP attributes"); + dev_kfree_skb(msg); + return -EPERM; +} + +static void os_if_send_chan_nl_resp(uint32_t pid, uint8_t *buf) +{ + int err; + uint8_t check_chans = 0; + uint8_t *chnk_ptr, chan_allow = 0; + bool resp_frag = false; + + check_chans = buf[0]; + chnk_ptr = &buf[1]; + + do { + chan_allow = os_if_get_max_chan_nl_resp(check_chans); + + if (check_chans > chan_allow) + resp_frag = true; + else + resp_frag = false; + check_chans -= chan_allow; + + err = os_if_create_ch_nl_resp(pid, chnk_ptr, + chan_allow, resp_frag); + if (err) { + osif_err("failed to alloc memory for ch_nl_resp"); + return; + } + chnk_ptr += (sizeof(struct wifi_pos_ch_info_rsp) * + chan_allow); + } while (resp_frag); +} + static void os_if_send_nl_resp(uint32_t pid, uint8_t *buf, enum wifi_pos_cmd_ids cmd) @@ -224,6 +382,9 @@ static void os_if_send_nl_resp(uint32_t pid, uint8_t *buf, case WIFI_POS_CMD_GET_CAPS: os_if_send_cap_nl_resp(pid, buf); break; + case WIFI_POS_CMD_GET_CH_INFO: + os_if_send_chan_nl_resp(pid, buf); + break; default: osif_err("response message is invalid :%d", cmd); } diff --git a/umac/wifi_pos/inc/wifi_pos_utils_pub.h b/umac/wifi_pos/inc/wifi_pos_utils_pub.h index 9a6d33d92619..9b1c66b1d755 100644 --- a/umac/wifi_pos/inc/wifi_pos_utils_pub.h +++ b/umac/wifi_pos/inc/wifi_pos_utils_pub.h @@ -30,6 +30,7 @@ #define OEM_TARGET_SIGNATURE_LEN 8 #define OEM_TARGET_SIGNATURE "QUALCOMM" +#define MAX_CHANNELS 255 #define OEM_CAP_MAX_NUM_CHANNELS 128 #define WIFI_POS_RSP_V1_FLAT_MEMORY 0x00000001 @@ -74,6 +75,28 @@ struct qdf_packed wifi_pos_driver_version { uint8_t build; }; +/** + * struct wifi_pos_channel_power + * @center_freq: Channel Center Frequency + * @chan_num: channel number + * @tx_power: TX power + */ +struct wifi_pos_channel_power { + uint32_t center_freq; + uint32_t chan_num; + uint32_t tx_power; +}; + +/** + * struct wifi_pos_channel_list + * @valid_channels: no of valid channels + * @chan_info: channel info + */ +struct qdf_packed wifi_pos_channel_list { + uint16_t num_channels; + struct wifi_pos_channel_power chan_info[MAX_CHANNELS]; +}; + /** * struct wifi_pos_driver_caps - OEM Data Capabilities * @oem_target_signature: Signature of chipset vendor diff --git a/umac/wifi_pos/src/wifi_pos_main.c b/umac/wifi_pos/src/wifi_pos_main.c index 424539675188..0e1c80a771d5 100644 --- a/umac/wifi_pos/src/wifi_pos_main.c +++ b/umac/wifi_pos/src/wifi_pos_main.c @@ -286,7 +286,7 @@ QDF_STATUS wifi_pos_send_report_resp(struct wlan_objmgr_psoc *psoc, static void wifi_update_channel_bw_info(struct wlan_objmgr_psoc *psoc, struct wlan_objmgr_pdev *pdev, - uint16_t chan, + uint16_t freq, struct wifi_pos_ch_info_rsp *chan_info) { struct ch_params ch_params = {0}; @@ -302,25 +302,21 @@ static void wifi_update_channel_bw_info(struct wlan_objmgr_psoc *psoc, /* Passing CH_WIDTH_MAX will give the max bandwidth supported */ ch_params.ch_width = CH_WIDTH_MAX; - - wlan_reg_set_channel_params(pdev, chan, sec_ch_2g, &ch_params); - if (ch_params.center_freq_seg0) - chan_info->band_center_freq1 = - wlan_reg_legacy_chan_to_freq( - pdev, - ch_params.center_freq_seg0); - - wifi_pos_psoc->wifi_pos_get_phy_mode(chan, ch_params.ch_width, - &phy_mode); - + wlan_reg_set_channel_params_for_freq(pdev, freq, + sec_ch_2g, &ch_params); + chan_info->band_center_freq1 = ch_params.mhz_freq_seg0; + wifi_pos_psoc->wifi_pos_get_fw_phy_mode_for_freq(freq, + ch_params.ch_width, + &phy_mode); REG_SET_CHANNEL_MODE(chan_info, phy_mode); } static void wifi_pos_get_reg_info(struct wlan_objmgr_pdev *pdev, - uint32_t chan_num, uint32_t *reg_info_1, + uint16_t freq, uint32_t *reg_info_1, uint32_t *reg_info_2) { - uint32_t reg_power = wlan_reg_get_channel_reg_power(pdev, chan_num); + uint32_t reg_power = wlan_reg_get_channel_reg_power_for_freq(pdev, + freq); *reg_info_1 = 0; *reg_info_2 = 0; @@ -351,20 +347,55 @@ static uint32_t wifi_pos_get_valid_channels(uint8_t *channels, uint32_t num_ch, return num_valid_channels; } +static void wifi_pos_pdev_iterator(struct wlan_objmgr_psoc *psoc, + void *obj, void *arg) +{ + QDF_STATUS status; + uint8_t num_channels; + struct wlan_objmgr_pdev *pdev = obj; + struct wifi_pos_channel_list *chan_list = arg; + struct channel_power *ch_info = NULL; + + if (!chan_list) { + wifi_pos_err("wifi_pos priv arg is null"); + return; + } + ch_info = (struct channel_power *)chan_list->chan_info; + status = wlan_reg_get_channel_list_with_power(pdev, ch_info, + &num_channels); + + if (QDF_IS_STATUS_ERROR(status)) { + wifi_pos_err("Failed to get valid channel list"); + return; + } + chan_list->num_channels = num_channels; +} + +static void wifi_pos_get_ch_info(struct wlan_objmgr_psoc *psoc, + struct wifi_pos_channel_list *chan_list) +{ + wlan_objmgr_iterate_obj_list(psoc, WLAN_PDEV_OP, + wifi_pos_pdev_iterator, + chan_list, true, WLAN_WIFI_POS_CORE_ID); + wifi_pos_notice("num channels: %d", chan_list->num_channels); +} + static QDF_STATUS wifi_pos_process_ch_info_req(struct wlan_objmgr_psoc *psoc, struct wifi_pos_req_msg *req) { - uint8_t idx; + uint8_t idx, band_mask; uint8_t *buf; - uint32_t len; + uint32_t len, i, freq; uint32_t reg_info_1; uint32_t reg_info_2; + bool oem_6g_support_disable; uint8_t *channels = req->buf; struct wlan_objmgr_pdev *pdev; uint32_t num_ch = req->buf_len; uint8_t valid_channel_list[NUM_CHANNELS]; - uint32_t num_valid_channels; + uint32_t num_valid_channels = 0; struct wifi_pos_ch_info_rsp *ch_info; + struct wifi_pos_channel_list *ch_list; struct wifi_pos_psoc_priv_obj *wifi_pos_obj = wifi_pos_get_psoc_priv_obj(psoc); @@ -386,38 +417,68 @@ static QDF_STATUS wifi_pos_process_ch_info_req(struct wlan_objmgr_psoc *psoc, wifi_pos_err("Invalid number of channels"); return QDF_STATUS_E_INVAL; } - num_valid_channels = wifi_pos_get_valid_channels(channels, num_ch, + + ch_list = qdf_mem_malloc(sizeof(*ch_list)); + if (!ch_list) + return QDF_STATUS_E_NOMEM; + + if (num_ch == 0 && req->rsp_version == WIFI_POS_RSP_V2_NL) { + wifi_pos_get_ch_info(psoc, ch_list); + qdf_spin_lock_bh(&wifi_pos_obj->wifi_pos_lock); + oem_6g_support_disable = wifi_pos_obj->oem_6g_support_disable; + qdf_spin_unlock_bh(&wifi_pos_obj->wifi_pos_lock); + + /* ch_list has the frequencies in order of 2.4g, 5g & 6g */ + for (i = 0; i < ch_list->num_channels; i++) { + freq = ch_list->chan_info[i].center_freq; + if (oem_6g_support_disable && + WLAN_REG_IS_6GHZ_CHAN_FREQ(freq)) + continue; + num_valid_channels++; + } + } else { + /* v1 has ch_list with frequencies in order of 2.4g, 5g only */ + num_valid_channels = wifi_pos_get_valid_channels( + channels, num_ch, valid_channel_list); + band_mask = BIT(REG_BAND_5G) | BIT(REG_BAND_2G); + for (i = 0; i < num_valid_channels; i++) { + ch_list->chan_info[i].chan_num = valid_channel_list[i]; + ch_list->chan_info[i].center_freq = + wlan_reg_chan_band_to_freq( + pdev, + ch_list->chan_info[i].chan_num, + band_mask); + } + } len = sizeof(uint8_t) + sizeof(struct wifi_pos_ch_info_rsp) * num_valid_channels; buf = qdf_mem_malloc(len); if (!buf) { wlan_objmgr_pdev_release_ref(pdev, WLAN_WIFI_POS_CORE_ID); + qdf_mem_free(ch_list); return QDF_STATUS_E_NOMEM; } - qdf_mem_zero(buf, len); - /* First byte of message body will have num of channels */ buf[0] = num_valid_channels; ch_info = (struct wifi_pos_ch_info_rsp *)&buf[1]; for (idx = 0; idx < num_valid_channels; idx++) { - ch_info[idx].chan_id = valid_channel_list[idx]; - wifi_pos_get_reg_info(pdev, ch_info[idx].chan_id, - ®_info_1, ®_info_2); ch_info[idx].reserved0 = 0; - ch_info[idx].mhz = wlan_reg_get_channel_freq( - pdev, - valid_channel_list[idx]); + ch_info[idx].chan_id = ch_list->chan_info[idx].chan_num; + ch_info[idx].mhz = ch_list->chan_info[idx].center_freq; ch_info[idx].band_center_freq1 = ch_info[idx].mhz; ch_info[idx].band_center_freq2 = 0; ch_info[idx].info = 0; + wifi_pos_get_reg_info(pdev, ch_info[idx].mhz, + ®_info_1, ®_info_2); + if (wlan_reg_is_dfs_for_freq(pdev, ch_info[idx].mhz)) WIFI_POS_SET_DFS(ch_info[idx].info); wifi_update_channel_bw_info(psoc, pdev, - ch_info[idx].chan_id, + ch_info[idx].mhz, &ch_info[idx]); ch_info[idx].reg_info_1 = reg_info_1; @@ -425,9 +486,11 @@ static QDF_STATUS wifi_pos_process_ch_info_req(struct wlan_objmgr_psoc *psoc, } wifi_pos_obj->wifi_pos_send_rsp(wifi_pos_obj->app_pid, - ANI_MSG_CHANNEL_INFO_RSP, + WIFI_POS_CMD_GET_CH_INFO, len, buf); + qdf_mem_free(buf); + qdf_mem_free(ch_list); wlan_objmgr_pdev_release_ref(pdev, WLAN_WIFI_POS_CORE_ID); return QDF_STATUS_SUCCESS; @@ -759,62 +822,14 @@ void wifi_pos_register_rx_ops(struct wlan_lmac_if_rx_ops *rx_ops) wifi_pos_rx_ops->oem_rsp_event_rx = wifi_pos_oem_rsp_handler; } -static void wifi_pos_pdev_iterator(struct wlan_objmgr_psoc *psoc, - void *obj, void *arg) -{ - QDF_STATUS status; - uint8_t i, num_channels, size, valid_ch = 0; - struct wlan_objmgr_pdev *pdev = obj; - struct wifi_pos_driver_caps *caps = arg; - struct channel_power *ch_list; - bool oem_6g_support_disable; - struct wifi_pos_psoc_priv_obj *wifi_pos_obj = - wifi_pos_get_psoc_priv_obj(psoc); - - size = QDF_MAX(OEM_CAP_MAX_NUM_CHANNELS, NUM_CHANNELS); - ch_list = qdf_mem_malloc(size * sizeof(*ch_list)); - if (!ch_list) - return; - - status = wlan_reg_get_channel_list_with_power(pdev, ch_list, - &num_channels); - - if (QDF_IS_STATUS_ERROR(status)) { - wifi_pos_err("Failed to get valid channel list"); - qdf_mem_free(ch_list); - return; - } - if (num_channels > OEM_CAP_MAX_NUM_CHANNELS) - num_channels = OEM_CAP_MAX_NUM_CHANNELS; - - qdf_spin_lock_bh(&wifi_pos_obj->wifi_pos_lock); - oem_6g_support_disable = wifi_pos_obj->oem_6g_support_disable; - qdf_spin_unlock_bh(&wifi_pos_obj->wifi_pos_lock); - - for (i = 0; i < num_channels; i++) { - if (oem_6g_support_disable && - WLAN_REG_IS_6GHZ_CHAN_FREQ(ch_list[i].center_freq)) - continue; - caps->channel_list[valid_ch++] = ch_list[i].chan_num; - } - caps->num_channels = valid_ch; - qdf_mem_free(ch_list); -} - -static void wifi_pos_get_ch_info(struct wlan_objmgr_psoc *psoc, - struct wifi_pos_driver_caps *caps) -{ - wlan_objmgr_iterate_obj_list(psoc, WLAN_PDEV_OP, - wifi_pos_pdev_iterator, - caps, true, WLAN_WIFI_POS_CORE_ID); - wifi_pos_err("num channels: %d", caps->num_channels); -} - QDF_STATUS wifi_pos_populate_caps(struct wlan_objmgr_psoc *psoc, struct wifi_pos_driver_caps *caps) { + uint16_t i, count = 0; + uint32_t freq; struct wifi_pos_psoc_priv_obj *wifi_pos_obj = wifi_pos_get_psoc_priv_obj(psoc); + struct wifi_pos_channel_list *ch_list = NULL; wifi_pos_debug("Enter"); if (!wifi_pos_obj) { @@ -822,6 +837,10 @@ QDF_STATUS wifi_pos_populate_caps(struct wlan_objmgr_psoc *psoc, return QDF_STATUS_E_NULL_VALUE; } + ch_list = qdf_mem_malloc(sizeof(*ch_list)); + if (!ch_list) + return QDF_STATUS_E_NOMEM; + strlcpy(caps->oem_target_signature, OEM_TARGET_SIGNATURE, OEM_TARGET_SIGNATURE_LEN); @@ -836,6 +855,16 @@ QDF_STATUS wifi_pos_populate_caps(struct wlan_objmgr_psoc *psoc, caps->curr_dwell_time_min = wifi_pos_obj->current_dwell_time_min; caps->curr_dwell_time_max = wifi_pos_obj->current_dwell_time_max; caps->supported_bands = wlan_objmgr_psoc_get_band_capability(psoc); - wifi_pos_get_ch_info(psoc, caps); + wifi_pos_get_ch_info(psoc, ch_list); + + /* copy valid channels list to caps */ + for (i = 0; i < ch_list->num_channels; i++) { + freq = ch_list->chan_info[i].center_freq; + if (WLAN_REG_IS_6GHZ_CHAN_FREQ(freq)) + continue; + caps->channel_list[count++] = ch_list->chan_info[i].chan_num; + } + caps->num_channels = count; + qdf_mem_free(ch_list); return QDF_STATUS_SUCCESS; }