diff --git a/core/hdd/src/wlan_hdd_ext_scan.c b/core/hdd/src/wlan_hdd_ext_scan.c index 0a3f623a19b5..6e309e5c0d68 100644 --- a/core/hdd/src/wlan_hdd_ext_scan.c +++ b/core/hdd/src/wlan_hdd_ext_scan.c @@ -58,8 +58,8 @@ struct hdd_ext_scan_context { }; static struct hdd_ext_scan_context ext_scan_context; -static const struct nla_policy wlan_hdd_extscan_config_policy -[QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1] = { +static const +struct nla_policy wlan_hdd_extscan_config_policy[EXTSCAN_PARAM_MAX + 1] = { [QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID] = { .type = NLA_U32}, [QCA_WLAN_VENDOR_ATTR_EXTSCAN_GET_VALID_CHANNELS_CONFIG_PARAM_WIFI_BAND] = { @@ -2514,10 +2514,11 @@ int wlan_hdd_cfg80211_extscan_get_valid_channels(struct wiphy *wiphy, * * Return: none */ -static void hdd_extscan_update_dwell_time_limits( - tpSirWifiScanCmdReqParams req_msg, uint32_t bkt_idx, - uint32_t active_min, uint32_t active_max, - uint32_t passive_min, uint32_t passive_max) +static void +hdd_extscan_update_dwell_time_limits(struct wifi_scan_cmd_req_params *req_msg, + uint32_t bkt_idx, uint32_t active_min, + uint32_t active_max, uint32_t passive_min, + uint32_t passive_max) { /* update per-bucket dwell times */ if (req_msg->buckets[bkt_idx].min_dwell_time_active > @@ -2570,13 +2571,13 @@ static void hdd_extscan_update_dwell_time_limits( * * Return: true if total channels reached max, false otherwise */ -static bool hdd_extscan_channel_max_reached(tSirWifiScanCmdReqParams *req, - uint8_t total_channels) +static bool +hdd_extscan_channel_max_reached(struct wifi_scan_cmd_req_params *req, + uint8_t total_channels) { - if (total_channels == WLAN_EXTSCAN_MAX_CHANNELS) { - hdd_warn( - "max #of channels %d reached, take only first %d bucket(s)", - total_channels, req->numBuckets); + if (total_channels == WMI_WLAN_EXTSCAN_MAX_CHANNELS) { + hdd_warn("max #of channels %d reached, take only first %d bucket(s)", + total_channels, req->num_buckets); return true; } return false; @@ -2586,32 +2587,34 @@ static bool hdd_extscan_channel_max_reached(tSirWifiScanCmdReqParams *req, * hdd_extscan_start_fill_bucket_channel_spec() - fill bucket channel spec * @hdd_ctx: HDD global context * @req_msg: Pointer to request structure - * @tb: pointer to NL attributes + * @bucket_attr: pointer to bucket attribute * * Return: 0 on success; error number otherwise */ static int hdd_extscan_start_fill_bucket_channel_spec( struct hdd_context *hdd_ctx, - tpSirWifiScanCmdReqParams req_msg, - struct nlattr **tb) + struct wifi_scan_cmd_req_params *req_msg, + struct nlattr *bucket_attr) { mac_handle_t mac_handle; - struct nlattr *bucket[ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1]; - struct nlattr *channel[ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX + 1]; + struct nlattr *bucket_tb[EXTSCAN_PARAM_MAX + 1]; + struct nlattr *channel_tb[EXTSCAN_PARAM_MAX + 1]; struct nlattr *buckets; struct nlattr *channels; - int rem1, rem2; + int id, rem1, rem2; QDF_STATUS status; uint8_t bkt_index, j, num_channels, total_channels = 0; uint32_t expected_buckets; + uint32_t expected_channels; uint32_t chan_list[WNI_CFG_VALID_CHANNEL_LIST_LEN] = {0}; uint32_t extscan_active_min_chn_time; uint32_t min_dwell_time_active_bucket; uint32_t max_dwell_time_active_bucket; uint32_t min_dwell_time_passive_bucket; uint32_t max_dwell_time_passive_bucket; + struct wifi_scan_bucket_params *bucket; + struct wifi_scan_channelspec_params *channel; + struct nlattr *channel_attr; ucfg_extscan_get_active_min_time(hdd_ctx->psoc, &extscan_active_min_chn_time); @@ -2629,108 +2632,105 @@ static int hdd_extscan_start_fill_bucket_channel_spec( req_msg->min_dwell_time_passive = req_msg->max_dwell_time_passive = max_dwell_time_passive_bucket; - expected_buckets = req_msg->numBuckets; - req_msg->numBuckets = 0; + expected_buckets = req_msg->num_buckets; + req_msg->num_buckets = 0; bkt_index = 0; mac_handle = hdd_ctx->mac_handle; - nla_for_each_nested(buckets, - tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC], rem1) { + nla_for_each_nested(buckets, bucket_attr, rem1) { if (bkt_index >= expected_buckets) { hdd_warn("ignoring excess buckets"); break; } - if (wlan_cfg80211_nla_parse(bucket, - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX, - nla_data(buckets), nla_len(buckets), - wlan_hdd_extscan_config_policy)) { + if (wlan_cfg80211_nla_parse(bucket_tb, EXTSCAN_PARAM_MAX, + nla_data(buckets), nla_len(buckets), + wlan_hdd_extscan_config_policy)) { hdd_err("nla_parse failed"); return -EINVAL; } + bucket = &req_msg->buckets[bkt_index]; + /* Parse and fetch bucket spec */ - if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_INDEX]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_INDEX; + if (!bucket_tb[id]) { hdd_err("attr bucket index failed"); return -EINVAL; } - req_msg->buckets[bkt_index].bucket = nla_get_u8( - bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_INDEX]); + bucket->bucket = nla_get_u8(bucket_tb[id]); /* Parse and fetch wifi band */ - if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BAND]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BAND; + if (!bucket_tb[id]) { hdd_err("attr wifi band failed"); return -EINVAL; } - req_msg->buckets[bkt_index].band = nla_get_u8( - bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BAND]); + bucket->band = nla_get_u8(bucket_tb[id]); /* Parse and fetch period */ - if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_PERIOD]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_PERIOD; + if (!bucket_tb[id]) { hdd_err("attr period failed"); return -EINVAL; } - req_msg->buckets[bkt_index].period = nla_get_u32( - bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_PERIOD]); + bucket->period = nla_get_u32(bucket_tb[id]); /* Parse and fetch report events */ - if (!bucket[ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_REPORT_EVENTS]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_REPORT_EVENTS; + if (!bucket_tb[id]) { hdd_err("attr report events failed"); return -EINVAL; } - req_msg->buckets[bkt_index].reportEvents = nla_get_u8( - bucket[ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_REPORT_EVENTS]); + bucket->report_events = nla_get_u8(bucket_tb[id]); /* Parse and fetch max period */ - if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_MAX_PERIOD]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_MAX_PERIOD; + if (!bucket_tb[id]) { hdd_err("attr max period failed"); return -EINVAL; } - req_msg->buckets[bkt_index].max_period = nla_get_u32( - bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_MAX_PERIOD]); + bucket->max_period = nla_get_u32(bucket_tb[id]); /* Parse and fetch base */ - if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BASE]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BASE; + if (!bucket_tb[id]) { hdd_err("attr base failed"); return -EINVAL; } - req_msg->buckets[bkt_index].exponent = nla_get_u32( - bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_BASE]); + bucket->exponent = nla_get_u32(bucket_tb[id]); /* Parse and fetch step count */ - if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_STEP_COUNT]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_STEP_COUNT; + if (!bucket_tb[id]) { hdd_err("attr step count failed"); return -EINVAL; } - req_msg->buckets[bkt_index].step_count = nla_get_u32( - bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_STEP_COUNT]); + bucket->step_count = nla_get_u32(bucket_tb[id]); + hdd_debug("Bucket spec Index: %d Wifi band: %d period: %d report events: %d max period: %u base: %u Step count: %u", - req_msg->buckets[bkt_index].bucket, - req_msg->buckets[bkt_index].band, - req_msg->buckets[bkt_index].period, - req_msg->buckets[bkt_index].reportEvents, - req_msg->buckets[bkt_index].max_period, - req_msg->buckets[bkt_index].exponent, - req_msg->buckets[bkt_index].step_count); + bucket->bucket, + bucket->band, + bucket->period, + bucket->report_events, + bucket->max_period, + bucket->exponent, + bucket->step_count); /* start with known good values for bucket dwell times */ - req_msg->buckets[bkt_index].min_dwell_time_active = - req_msg->buckets[bkt_index].max_dwell_time_active = - max_dwell_time_active_bucket; + bucket->min_dwell_time_active = max_dwell_time_active_bucket; + bucket->max_dwell_time_active = max_dwell_time_active_bucket; + bucket->min_dwell_time_passive = max_dwell_time_passive_bucket; + bucket->max_dwell_time_passive = max_dwell_time_passive_bucket; - req_msg->buckets[bkt_index].min_dwell_time_passive = - req_msg->buckets[bkt_index].max_dwell_time_passive = - max_dwell_time_passive_bucket; - - /* Framework shall pass the channel list if the input WiFi band - * is WIFI_BAND_UNSPECIFIED. - * If the input WiFi band is specified (any value other than - * WIFI_BAND_UNSPECIFIED) then driver populates the channel list + /* Framework shall pass the channel list if the input + * WiFi band is WMI_WIFI_BAND_UNSPECIFIED. If the + * input WiFi band is specified (any value other than + * WMI_WIFI_BAND_UNSPECIFIED) then driver populates + * the channel list. */ - if (req_msg->buckets[bkt_index].band != WIFI_BAND_UNSPECIFIED) { + if (bucket->band != WMI_WIFI_BAND_UNSPECIFIED) { if (hdd_extscan_channel_max_reached(req_msg, total_channels)) return 0; @@ -2738,78 +2738,72 @@ static int hdd_extscan_start_fill_bucket_channel_spec( num_channels = 0; hdd_debug("WiFi band is specified, driver to fill channel list"); status = sme_get_valid_channels_by_band(mac_handle, - req_msg->buckets[bkt_index].band, - chan_list, &num_channels); + bucket->band, + chan_list, + &num_channels); if (!QDF_IS_STATUS_SUCCESS(status)) { - hdd_err("sme_GetValidChannelsByBand failed (err=%d)", - status); + hdd_err("sme_get_valid_channels_by_band failed (err=%d)", + status); return -EINVAL; } hdd_debug("before trimming, num_channels: %d", - num_channels); + num_channels); - req_msg->buckets[bkt_index].numChannels = + bucket->num_channels = QDF_MIN(num_channels, - (WLAN_EXTSCAN_MAX_CHANNELS - + (WMI_WLAN_EXTSCAN_MAX_CHANNELS - total_channels)); hdd_debug("Adj Num channels/bucket: %d total_channels: %d", - req_msg->buckets[bkt_index].numChannels, - total_channels); - total_channels += - req_msg->buckets[bkt_index].numChannels; + bucket->num_channels, total_channels); + total_channels += bucket->num_channels; - for (j = 0; j < req_msg->buckets[bkt_index].numChannels; - j++) { - req_msg->buckets[bkt_index].channels[j].channel = - chan_list[j]; - req_msg->buckets[bkt_index].channels[j]. - chnlClass = 0; + for (j = 0; j < bucket->num_channels; j++) { + channel = &bucket->channels[j]; + + channel->channel = chan_list[j]; + channel->channel_class = 0; if ((wlan_reg_get_channel_state( hdd_ctx->pdev, cds_freq_to_chan(chan_list[j]))) != CHANNEL_STATE_ENABLE) { - req_msg->buckets[bkt_index].channels[j]. - passive = 1; - req_msg->buckets[bkt_index].channels[j]. - dwellTimeMs = + channel->passive = 1; + channel->dwell_time_ms = max_dwell_time_passive_bucket; /* reconfigure per-bucket dwell time */ if (min_dwell_time_passive_bucket > - req_msg->buckets[bkt_index].channels[j].dwellTimeMs) { + channel->dwell_time_ms) { min_dwell_time_passive_bucket = - req_msg->buckets[bkt_index].channels[j].dwellTimeMs; + channel->dwell_time_ms; } if (max_dwell_time_passive_bucket < - req_msg->buckets[bkt_index].channels[j].dwellTimeMs) { + channel->dwell_time_ms) { max_dwell_time_passive_bucket = - req_msg->buckets[bkt_index].channels[j].dwellTimeMs; + channel->dwell_time_ms; } } else { - req_msg->buckets[bkt_index].channels[j]. - passive = 0; - req_msg->buckets[bkt_index].channels[j]. - dwellTimeMs = + channel->passive = 0; + channel->dwell_time_ms = max_dwell_time_active_bucket; /* reconfigure per-bucket dwell times */ if (min_dwell_time_active_bucket > - req_msg->buckets[bkt_index].channels[j].dwellTimeMs) { + channel->dwell_time_ms) { min_dwell_time_active_bucket = - req_msg->buckets[bkt_index].channels[j].dwellTimeMs; + channel->dwell_time_ms; } if (max_dwell_time_active_bucket < - req_msg->buckets[bkt_index].channels[j].dwellTimeMs) { + channel->dwell_time_ms) { max_dwell_time_active_bucket = - req_msg->buckets[bkt_index].channels[j].dwellTimeMs; + channel->dwell_time_ms; } } hdd_debug("Channel: %u Passive: %u Dwell time: %u ms Class: %u", - req_msg->buckets[bkt_index].channels[j].channel, - req_msg->buckets[bkt_index].channels[j].passive, - req_msg->buckets[bkt_index].channels[j].dwellTimeMs, - req_msg->buckets[bkt_index].channels[j].chnlClass); + channel->channel, + channel->passive, + channel->dwell_time_ms, + channel->channel_class); } hdd_extscan_update_dwell_time_limits( @@ -2821,164 +2815,163 @@ static int hdd_extscan_start_fill_bucket_channel_spec( hdd_debug("bkt_index:%d actv_min:%d actv_max:%d pass_min:%d pass_max:%d", bkt_index, - req_msg->buckets[bkt_index].min_dwell_time_active, - req_msg->buckets[bkt_index].max_dwell_time_active, - req_msg->buckets[bkt_index].min_dwell_time_passive, - req_msg->buckets[bkt_index].max_dwell_time_passive); + bucket->min_dwell_time_active, + bucket->max_dwell_time_active, + bucket->min_dwell_time_passive, + bucket->max_dwell_time_passive); bkt_index++; - req_msg->numBuckets++; + req_msg->num_buckets++; continue; } /* Parse and fetch number of channels */ - if (!bucket[ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS; + if (!bucket_tb[id]) { hdd_err("attr num channels failed"); return -EINVAL; } - req_msg->buckets[bkt_index].numChannels = - nla_get_u32(bucket[ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC_NUM_CHANNEL_SPECS]); + bucket->num_channels = nla_get_u32(bucket_tb[id]); hdd_debug("before trimming: num channels %d", - req_msg->buckets[bkt_index].numChannels); + bucket->num_channels); - req_msg->buckets[bkt_index].numChannels = - QDF_MIN(req_msg->buckets[bkt_index].numChannels, - (WLAN_EXTSCAN_MAX_CHANNELS - total_channels)); + bucket->num_channels = + QDF_MIN(bucket->num_channels, + (WMI_WLAN_EXTSCAN_MAX_CHANNELS - + total_channels)); hdd_debug("Num channels/bucket: %d total_channels: %d", - req_msg->buckets[bkt_index].numChannels, - total_channels); + bucket->num_channels, total_channels); + if (hdd_extscan_channel_max_reached(req_msg, total_channels)) return 0; - if (!bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC; + channel_attr = bucket_tb[id]; + if (!channel_attr) { hdd_err("attr channel spec failed"); return -EINVAL; } - j = 0; - nla_for_each_nested(channels, - bucket[QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC], rem2) { - if ((j >= req_msg->buckets[bkt_index].numChannels) || + expected_channels = bucket->num_channels; + bucket->num_channels = 0; + + nla_for_each_nested(channels, channel_attr, rem2) { + if ((bucket->num_channels >= expected_channels) || hdd_extscan_channel_max_reached(req_msg, total_channels)) break; - if (wlan_cfg80211_nla_parse(channel, - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX, - nla_data(channels), nla_len(channels), - wlan_hdd_extscan_config_policy)) { + if (wlan_cfg80211_nla_parse(channel_tb, + EXTSCAN_PARAM_MAX, + nla_data(channels), + nla_len(channels), + wlan_hdd_extscan_config_policy)) { hdd_err("nla_parse failed"); return -EINVAL; } + channel = &bucket->channels[bucket->num_channels]; /* Parse and fetch channel */ - if (!channel[ + if (!channel_tb[ QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_CHANNEL]) { hdd_err("attr channel failed"); return -EINVAL; } - req_msg->buckets[bkt_index].channels[j].channel = - nla_get_u32(channel[ + channel->channel = + nla_get_u32(channel_tb[ QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_CHANNEL]); hdd_debug("channel %u", - req_msg->buckets[bkt_index].channels[j].channel); + channel->channel); /* Parse and fetch dwell time */ - if (!channel[ + if (!channel_tb[ QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_DWELL_TIME]) { hdd_err("attr dwelltime failed"); return -EINVAL; } - req_msg->buckets[bkt_index].channels[j].dwellTimeMs = - nla_get_u32(channel[ + channel->dwell_time_ms = + nla_get_u32(channel_tb[ QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_DWELL_TIME]); /* Override dwell time if required */ - if (req_msg->buckets[bkt_index].channels[j].dwellTimeMs < - extscan_active_min_chn_time || - req_msg->buckets[bkt_index].channels[j].dwellTimeMs > - max_dwell_time_active_bucket) { + if (channel->dwell_time_ms < + extscan_active_min_chn_time || + channel->dwell_time_ms > + max_dwell_time_active_bucket) { hdd_debug("WiFi band is unspecified, dwellTime:%d", - req_msg->buckets[bkt_index].channels[j].dwellTimeMs); + channel->dwell_time_ms); if ((wlan_reg_get_channel_state( hdd_ctx->pdev, cds_freq_to_chan( - req_msg->buckets[bkt_index]. - channels[j].channel))) + channel->channel))) != CHANNEL_STATE_ENABLE) { - req_msg->buckets[bkt_index].channels[j]. - dwellTimeMs = + channel->dwell_time_ms = max_dwell_time_passive_bucket; } else { - req_msg->buckets[bkt_index].channels[j]. - dwellTimeMs = + channel->dwell_time_ms = max_dwell_time_active_bucket; } } hdd_debug("New Dwell time %u ms", - req_msg->buckets[bkt_index].channels[j].dwellTimeMs); + channel->dwell_time_ms); if ((wlan_reg_get_channel_state(hdd_ctx->pdev, cds_freq_to_chan( - req_msg->buckets[bkt_index]. - channels[j].channel))) + channel->channel))) != CHANNEL_STATE_ENABLE) { if (min_dwell_time_passive_bucket > - req_msg->buckets[bkt_index].channels[j].dwellTimeMs) { + channel->dwell_time_ms) { min_dwell_time_passive_bucket = - req_msg->buckets[bkt_index].channels[j].dwellTimeMs; + channel->dwell_time_ms; } if (max_dwell_time_passive_bucket < - req_msg->buckets[bkt_index].channels[j].dwellTimeMs) { + channel->dwell_time_ms) { max_dwell_time_passive_bucket = - req_msg->buckets[bkt_index].channels[j].dwellTimeMs; + channel->dwell_time_ms; } } else { if (min_dwell_time_active_bucket > - req_msg->buckets[bkt_index].channels[j].dwellTimeMs) { + channel->dwell_time_ms) { min_dwell_time_active_bucket = - req_msg->buckets[bkt_index].channels[j].dwellTimeMs; + channel->dwell_time_ms; } if (max_dwell_time_active_bucket < - req_msg->buckets[bkt_index].channels[j].dwellTimeMs) { + channel->dwell_time_ms) { max_dwell_time_active_bucket = - req_msg->buckets[bkt_index].channels[j].dwellTimeMs; + channel->dwell_time_ms; } } /* Parse and fetch channel spec passive */ - if (!channel[ + if (!channel_tb[ QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_PASSIVE]) { hdd_err("attr channel spec passive failed"); return -EINVAL; } - req_msg->buckets[bkt_index].channels[j].passive = - nla_get_u8(channel[ + channel->passive = + nla_get_u8(channel_tb[ QCA_WLAN_VENDOR_ATTR_EXTSCAN_CHANNEL_SPEC_PASSIVE]); hdd_debug("Chnl spec passive %u", - req_msg->buckets[bkt_index].channels[j].passive); + channel->passive); /* Override scan type if required */ if ((wlan_reg_get_channel_state(hdd_ctx->pdev, cds_freq_to_chan( - req_msg->buckets[bkt_index]. - channels[j].channel))) + channel->channel))) != CHANNEL_STATE_ENABLE) { - req_msg->buckets[bkt_index].channels[j].passive = true; + channel->passive = true; } else { - req_msg->buckets[bkt_index].channels[j].passive = false; + channel->passive = false; } - j++; total_channels++; + bucket->num_channels++; } - if (j != req_msg->buckets[bkt_index].numChannels) { - hdd_err("Input parameters didn't match"); - return -EINVAL; - } + if (bucket->num_channels != expected_channels) + hdd_warn("channels: Expected %u got %u", + expected_channels, + bucket->num_channels); hdd_extscan_update_dwell_time_limits( req_msg, bkt_index, @@ -2989,13 +2982,13 @@ static int hdd_extscan_start_fill_bucket_channel_spec( hdd_debug("bktIndex:%d actv_min:%d actv_max:%d pass_min:%d pass_max:%d", bkt_index, - req_msg->buckets[bkt_index].min_dwell_time_active, - req_msg->buckets[bkt_index].max_dwell_time_active, - req_msg->buckets[bkt_index].min_dwell_time_passive, - req_msg->buckets[bkt_index].max_dwell_time_passive); + bucket->min_dwell_time_active, + bucket->max_dwell_time_active, + bucket->min_dwell_time_passive, + bucket->max_dwell_time_passive); bkt_index++; - req_msg->numBuckets++; + req_msg->num_buckets++; } hdd_debug("Global: actv_min:%d actv_max:%d pass_min:%d pass_max:%d", @@ -3031,20 +3024,6 @@ static uint32_t hdd_extscan_map_usr_drv_config_flags(uint32_t config_flags) */ #define PARAM_MAX \ QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_MAX -#define PARAM_REQUEST_ID \ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID -#define PARAM_BASE_PERIOD \ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_BASE_PERIOD -#define PARAM_MAX_AP_PER_SCAN \ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_MAX_AP_PER_SCAN -#define PARAM_RPT_THRHLD_PERCENT \ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD_PERCENT -#define PARAM_RPT_THRHLD_NUM_SCANS \ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD_NUM_SCANS -#define PARAM_NUM_BUCKETS \ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_NUM_BUCKETS -#define PARAM_CONFIG_FLAGS \ - QCA_WLAN_VENDOR_ATTR_EXTSCAN_CONFIGURATION_FLAGS /** * __wlan_hdd_cfg80211_extscan_start() - ext scan start @@ -3057,19 +3036,19 @@ static uint32_t hdd_extscan_map_usr_drv_config_flags(uint32_t config_flags) */ static int __wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy, - struct wireless_dev *wdev, - const void *data, - int data_len) + struct wireless_dev *wdev, + const void *data, + int data_len) { - tpSirWifiScanCmdReqParams pReqMsg; + struct wifi_scan_cmd_req_params *params; struct net_device *dev = wdev->netdev; struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev); struct hdd_context *hdd_ctx = wiphy_priv(wiphy); struct nlattr *tb[PARAM_MAX + 1]; struct hdd_ext_scan_context *context; - uint32_t request_id, num_buckets; + uint32_t num_buckets; QDF_STATUS status; - int retval; + int retval, id; unsigned long rc; hdd_enter_dev(dev); @@ -3098,106 +3077,119 @@ __wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy, return -EINVAL; } - pReqMsg = qdf_mem_malloc(sizeof(*pReqMsg)); - if (!pReqMsg) { - hdd_err("memory allocation failed"); + params = qdf_mem_malloc(sizeof(*params)); + if (!params) return -ENOMEM; - } + + /* assume the worst until proven otherwise */ + retval = -EINVAL; /* Parse and fetch request Id */ - if (!tb[PARAM_REQUEST_ID]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_SUBCMD_CONFIG_PARAM_REQUEST_ID; + if (!tb[id]) { hdd_err("attr request id failed"); goto fail; } - pReqMsg->requestId = nla_get_u32(tb[PARAM_REQUEST_ID]); - pReqMsg->sessionId = adapter->session_id; + params->request_id = nla_get_u32(tb[id]); + params->vdev_id = adapter->session_id; /* Parse and fetch base period */ - if (!tb[PARAM_BASE_PERIOD]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_BASE_PERIOD; + if (!tb[id]) { hdd_err("attr base period failed"); goto fail; } - pReqMsg->basePeriod = nla_get_u32(tb[PARAM_BASE_PERIOD]); + params->base_period = nla_get_u32(tb[id]); /* Parse and fetch max AP per scan */ - if (!tb[PARAM_MAX_AP_PER_SCAN]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_MAX_AP_PER_SCAN; + if (!tb[id]) { hdd_err("attr max_ap_per_scan failed"); goto fail; } - pReqMsg->maxAPperScan = nla_get_u32(tb[PARAM_MAX_AP_PER_SCAN]); + params->max_ap_per_scan = nla_get_u32(tb[id]); /* Parse and fetch report threshold percent */ - if (!tb[PARAM_RPT_THRHLD_PERCENT]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD_PERCENT; + if (!tb[id]) { hdd_err("attr report_threshold percent failed"); goto fail; } - pReqMsg->report_threshold_percent = nla_get_u8(tb[PARAM_RPT_THRHLD_PERCENT]); + params->report_threshold_percent = nla_get_u8(tb[id]); /* Parse and fetch report threshold num scans */ - if (!tb[PARAM_RPT_THRHLD_NUM_SCANS]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_REPORT_THRESHOLD_NUM_SCANS; + if (!tb[id]) { hdd_err("attr report_threshold num scans failed"); goto fail; } - pReqMsg->report_threshold_num_scans = nla_get_u8(tb[PARAM_RPT_THRHLD_NUM_SCANS]); - hdd_debug("Req Id: %d Session Id: %d Base Period: %d Max AP per Scan: %d Report Threshold percent: %d Report Threshold num scans: %d", - pReqMsg->requestId, pReqMsg->sessionId, - pReqMsg->basePeriod, pReqMsg->maxAPperScan, - pReqMsg->report_threshold_percent, - pReqMsg->report_threshold_num_scans); + params->report_threshold_num_scans = nla_get_u8(tb[id]); + hdd_debug("Req Id: %d Vdev Id: %d Base Period: %d Max AP per Scan: %d Report Threshold percent: %d Report Threshold num scans: %d", + params->request_id, params->vdev_id, + params->base_period, params->max_ap_per_scan, + params->report_threshold_percent, + params->report_threshold_num_scans); /* Parse and fetch number of buckets */ - if (!tb[PARAM_NUM_BUCKETS]) { + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_SCAN_CMD_PARAMS_NUM_BUCKETS; + if (!tb[id]) { hdd_err("attr number of buckets failed"); goto fail; } - num_buckets = nla_get_u8(tb[PARAM_NUM_BUCKETS]); - if (num_buckets > WLAN_EXTSCAN_MAX_BUCKETS) { + num_buckets = nla_get_u8(tb[id]); + + if (num_buckets > WMI_WLAN_EXTSCAN_MAX_BUCKETS) { hdd_warn("Exceeded MAX number of buckets: %d", - WLAN_EXTSCAN_MAX_BUCKETS); - num_buckets = WLAN_EXTSCAN_MAX_BUCKETS; + WMI_WLAN_EXTSCAN_MAX_BUCKETS); + num_buckets = WMI_WLAN_EXTSCAN_MAX_BUCKETS; } hdd_debug("Input: Number of Buckets %d", num_buckets); - pReqMsg->numBuckets = num_buckets; + params->num_buckets = num_buckets; /* This is optional attribute, if not present set it to 0 */ - if (!tb[PARAM_CONFIG_FLAGS]) - pReqMsg->configuration_flags = 0; + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_CONFIGURATION_FLAGS; + if (!tb[id]) + params->configuration_flags = 0; else - pReqMsg->configuration_flags = + params->configuration_flags = hdd_extscan_map_usr_drv_config_flags( - nla_get_u32(tb[PARAM_CONFIG_FLAGS])); + nla_get_u32(tb[id])); - pReqMsg->extscan_adaptive_dwell_mode = + params->extscan_adaptive_dwell_mode = hdd_ctx->config->extscan_adaptive_dwell_mode; hdd_debug("Configuration flags: %u", - pReqMsg->configuration_flags); + params->configuration_flags); - if (!tb[QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC]) { + /* Parse and fetch number the array of buckets */ + id = QCA_WLAN_VENDOR_ATTR_EXTSCAN_BUCKET_SPEC; + if (!tb[id]) { hdd_err("attr bucket spec failed"); goto fail; } - - if (hdd_extscan_start_fill_bucket_channel_spec(hdd_ctx, pReqMsg, tb)) + retval = hdd_extscan_start_fill_bucket_channel_spec(hdd_ctx, params, + tb[id]); + if (retval) goto fail; context = &ext_scan_context; spin_lock(&context->context_lock); INIT_COMPLETION(context->response_event); - context->request_id = request_id = pReqMsg->requestId; + context->request_id = params->request_id; context->buckets_scanned = 0; spin_unlock(&context->context_lock); - status = sme_ext_scan_start(hdd_ctx->mac_handle, pReqMsg); + status = sme_ext_scan_start(hdd_ctx->mac_handle, params); if (!QDF_IS_STATUS_SUCCESS(status)) { hdd_err("sme_ext_scan_start failed(err=%d)", status); + retval = qdf_status_to_os_return(status); goto fail; } hdd_ctx->ext_scan_start_since_boot = qdf_get_monotonic_boottime(); hdd_debug("Timestamp since boot: %llu", - hdd_ctx->ext_scan_start_since_boot); + hdd_ctx->ext_scan_start_since_boot); /* request was sent -- wait for the response */ rc = wait_for_completion_timeout(&context->response_event, @@ -3208,31 +3200,18 @@ __wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy, retval = -ETIMEDOUT; } else { spin_lock(&context->context_lock); - if (context->request_id == request_id) + if (context->request_id == params->request_id) retval = context->response_status; else retval = -EINVAL; spin_unlock(&context->context_lock); } hdd_exit(); - return retval; fail: - qdf_mem_free(pReqMsg); - return -EINVAL; + qdf_mem_free(params); + return retval; } -/* - * done with short names for the global vendor params - * used by __wlan_hdd_cfg80211_extscan_start() - */ -#undef PARAM_MAX -#undef PARAM_REQUEST_ID -#undef PARAM_BASE_PERIOD -#undef PARAMS_MAX_AP_PER_SCAN -#undef PARAMS_RPT_THRHLD_PERCENT -#undef PARAMS_RPT_THRHLD_NUM_SCANS -#undef PARAMS_NUM_BUCKETS -#undef PARAM_CONFIG_FLAGS /** * wlan_hdd_cfg80211_extscan_start() - start extscan @@ -3244,8 +3223,8 @@ fail: * Return: 0 on success, negative errno on failure */ int wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy, - struct wireless_dev *wdev, - const void *data, int data_len) + struct wireless_dev *wdev, + const void *data, int data_len) { int ret = 0; diff --git a/core/mac/inc/sir_api.h b/core/mac/inc/sir_api.h index 87561d93f96c..00e7a2382ae4 100644 --- a/core/mac/inc/sir_api.h +++ b/core/mac/inc/sir_api.h @@ -4036,8 +4036,8 @@ struct extscan_cached_scan_results { * 1 - still more fragment(s) coming * @ap: bssid info * - * Reported when each probe response is received, if reportEvents - * enabled in tSirWifiScanCmdReqParams + * Reported when each probe response is received, if report_events + * enabled in struct wifi_scan_cmd_req_params */ typedef struct { uint32_t requestId; @@ -4064,105 +4064,6 @@ struct pno_match_found { tSirWifiScanResult ap[]; }; -typedef struct { - /* Frequency in MHz */ - uint32_t channel; - - uint32_t dwellTimeMs; - - /* 0 => active - 1 => passive scan; ignored for DFS */ - bool passive; - - uint8_t chnlClass; -} tSirWifiScanChannelSpec, *tpSirWifiScanChannelSpec; - -/** - * struct tSirWifiScanBucketSpec - wifi scan bucket spec - * @bucket: bucket identifier - * @band: wifi band - * @period: Desired period, in millisecond; if this is too - * low, the firmware should choose to generate results as fast as - * it can instead of failing the command byte - * for exponential backoff bucket this is the min_period - * @reportEvents: 0 => normal reporting (reporting rssi history - * only, when rssi history buffer is % full) - * 1 => same as 0 + report a scan completion event after scanning - * this bucket - * 2 => same as 1 + forward scan results - * (beacons/probe responses + IEs) in real time to HAL - * @max_period: if max_period is non zero or different than period, - * then this bucket is an exponential backoff bucket and - * the scan period will grow exponentially as per formula: - * actual_period(N) = period ^ (N/(step_count+1)) to a - * maximum period of max_period - * @exponent: for exponential back off bucket: multiplier: - * new_period = old_period * exponent - * @step_count: for exponential back off bucket, number of scans performed - * at a given period and until the exponent is applied - * @numChannels: channels to scan; these may include DFS channels - * Note that a given channel may appear in multiple buckets - * @min_dwell_time_active: per bucket minimum active dwell time - * @max_dwell_time_active: per bucket maximum active dwell time - * @min_dwell_time_passive: per bucket minimum passive dwell time - * @max_dwell_time_passive: per bucket maximum passive dwell time - * @channels: Channel list - */ -typedef struct { - uint8_t bucket; - tWifiBand band; - uint32_t period; - uint32_t reportEvents; - uint32_t max_period; - uint32_t exponent; - uint32_t step_count; - uint32_t numChannels; - - uint32_t min_dwell_time_active; - uint32_t max_dwell_time_active; - uint32_t min_dwell_time_passive; - uint32_t max_dwell_time_passive; - tSirWifiScanChannelSpec channels[WLAN_EXTSCAN_MAX_CHANNELS]; -} tSirWifiScanBucketSpec, *tpSirWifiScanBucketSpec; - -/** - * struct tSirWifiScanCmdReqParams - wifi scan command request params - * @basePeriod: base timer period - * @maxAPperScan: max ap per scan - * @report_threshold_percent: report threshold - * in %, when buffer is this much full, wake up host - * @report_threshold_num_scans: report threshold number of scans - * in number of scans, wake up host after these many scans - * @requestId: request id - * @sessionId: session id - * @numBuckets: number of buckets - * @min_dwell_time_active: per bucket minimum active dwell time - * @max_dwell_time_active: per bucket maximum active dwell time - * @min_dwell_time_passive: per bucket minimum passive dwell time - * @max_dwell_time_passive: per bucket maximum passive dwell time - * @configuration_flags: configuration flags - * @buckets: buckets array - */ -typedef struct { - uint32_t basePeriod; - uint32_t maxAPperScan; - - uint32_t report_threshold_percent; - uint32_t report_threshold_num_scans; - - uint32_t requestId; - uint8_t sessionId; - uint32_t numBuckets; - - uint32_t min_dwell_time_active; - uint32_t max_dwell_time_active; - uint32_t min_dwell_time_passive; - uint32_t max_dwell_time_passive; - uint32_t configuration_flags; - enum scan_dwelltime_adaptive_mode extscan_adaptive_dwell_mode; - tSirWifiScanBucketSpec buckets[WLAN_EXTSCAN_MAX_BUCKETS]; -} tSirWifiScanCmdReqParams, *tpSirWifiScanCmdReqParams; - /** * struct sir_extscan_generic_response - * Generic ExtScan Response structure diff --git a/core/sme/inc/sme_api.h b/core/sme/inc/sme_api.h index 6dccf0ca4b57..c810c9be2ac8 100644 --- a/core/sme/inc/sme_api.h +++ b/core/sme/inc/sme_api.h @@ -1017,8 +1017,17 @@ QDF_STATUS sme_ext_scan_get_capabilities(mac_handle_t mac_handle, struct extscan_capabilities_params *params); -QDF_STATUS sme_ext_scan_start(tHalHandle hHal, - tSirWifiScanCmdReqParams *pStartCmd); +/** + * sme_ext_scan_start() - SME API to issue extscan start + * @mac_handle: Opaque handle to the MAC context + * @params: extscan start structure + * + * Return: QDF_STATUS + */ +QDF_STATUS +sme_ext_scan_start(mac_handle_t mac_handle, + struct wifi_scan_cmd_req_params *params); + QDF_STATUS sme_ext_scan_stop(tHalHandle hHal, tSirExtScanStopReqParams *pStopReq); diff --git a/core/sme/src/common/sme_api.c b/core/sme/src/common/sme_api.c index c08a33ca9b6e..1d9c3500269e 100644 --- a/core/sme/src/common/sme_api.c +++ b/core/sme/src/common/sme_api.c @@ -11101,37 +11101,38 @@ sme_ext_scan_get_capabilities(mac_handle_t mac_handle, return status; } -/* - * sme_ext_scan_start() - - * SME API to issue extscan start - * - * hHal - * pStartCmd: extscan start structure - * Return QDF_STATUS - */ -QDF_STATUS sme_ext_scan_start(tHalHandle hHal, - tSirWifiScanCmdReqParams *pStartCmd) +QDF_STATUS +sme_ext_scan_start(mac_handle_t mac_handle, + struct wifi_scan_cmd_req_params *params) { - QDF_STATUS status = QDF_STATUS_SUCCESS; - QDF_STATUS qdf_status = QDF_STATUS_SUCCESS; - tpAniSirGlobal pMac = PMAC_STRUCT(hHal); + QDF_STATUS status; + tpAniSirGlobal mac = MAC_CONTEXT(mac_handle); struct scheduler_msg message = {0}; + struct wifi_scan_cmd_req_params *bodyptr; - status = sme_acquire_global_lock(&pMac->sme); + /* per contract must make a copy of the params when messaging */ + bodyptr = qdf_mem_malloc(sizeof(*bodyptr)); + if (!bodyptr) + return QDF_STATUS_E_NOMEM; + *bodyptr = *params; + + status = sme_acquire_global_lock(&mac->sme); if (QDF_IS_STATUS_SUCCESS(status)) { /* Serialize the req through MC thread */ - message.bodyptr = pStartCmd; + message.bodyptr = bodyptr; message.type = WMA_EXTSCAN_START_REQ; - MTRACE(qdf_trace(QDF_MODULE_ID_SME, TRACE_CODE_SME_TX_WMA_MSG, - NO_SESSION, message.type)); - qdf_status = scheduler_post_message(QDF_MODULE_ID_SME, - QDF_MODULE_ID_WMA, - QDF_MODULE_ID_WMA, - &message); - if (!QDF_IS_STATUS_SUCCESS(qdf_status)) - status = QDF_STATUS_E_FAILURE; + qdf_trace(QDF_MODULE_ID_SME, TRACE_CODE_SME_TX_WMA_MSG, + NO_SESSION, message.type); + status = scheduler_post_message(QDF_MODULE_ID_SME, + QDF_MODULE_ID_WMA, + QDF_MODULE_ID_WMA, + &message); + sme_release_global_lock(&mac->sme); + } - sme_release_global_lock(&pMac->sme); + if (QDF_IS_STATUS_ERROR(status)) { + sme_err("failure: %d", status); + qdf_mem_free(bodyptr); } return status; } diff --git a/core/wma/inc/wma_internal.h b/core/wma/inc/wma_internal.h index c4fabf439017..3736fde09679 100644 --- a/core/wma/inc/wma_internal.h +++ b/core/wma/inc/wma_internal.h @@ -140,7 +140,7 @@ struct index_vht_data_rate_type { uint16_t ht80_rate[2]; }; -struct tSirWifiScanCmdReqParams; +struct wifi_scan_cmd_req_params; /* * wma_main.c functions declarations */ @@ -356,8 +356,17 @@ int wma_extscan_wow_event_callback(void *handle, void *event, uint32_t len); void wma_register_extscan_event_handler(tp_wma_handle wma_handle); +/** + * wma_start_extscan() - start extscan command to fw. + * @wma: wma handle + * @params: extscan command request params + * + * This function sends start extscan request to fw. + * + * Return: QDF Status. + */ QDF_STATUS wma_start_extscan(tp_wma_handle wma, - tSirWifiScanCmdReqParams *pstart); + struct wifi_scan_cmd_req_params *pstart); QDF_STATUS wma_stop_extscan(tp_wma_handle wma, tSirExtScanStopReqParams *pstopcmd); diff --git a/core/wma/src/wma_main.c b/core/wma/src/wma_main.c index eaf4672c1951..5daf435482b3 100644 --- a/core/wma/src/wma_main.c +++ b/core/wma/src/wma_main.c @@ -8182,8 +8182,7 @@ static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg) #endif /* WLAN_FEATURE_EXTWOW_SUPPORT */ #ifdef FEATURE_WLAN_EXTSCAN case WMA_EXTSCAN_START_REQ: - wma_start_extscan(wma_handle, - (tSirWifiScanCmdReqParams *) msg->bodyptr); + wma_start_extscan(wma_handle, msg->bodyptr); qdf_mem_free(msg->bodyptr); break; case WMA_EXTSCAN_STOP_REQ: diff --git a/core/wma/src/wma_scan_roam.c b/core/wma/src/wma_scan_roam.c index 9d052e4c374e..5a1a854c8f05 100644 --- a/core/wma/src/wma_scan_roam.c +++ b/core/wma/src/wma_scan_roam.c @@ -4474,92 +4474,29 @@ int wma_passpoint_match_event_handler(void *handle, return 0; } -/** - * wma_start_extscan() - start extscan command to fw. - * @handle: wma handle - * @pstart: scan command request params - * - * This function sends start extscan request to fw. - * - * Return: QDF Status. - */ QDF_STATUS wma_start_extscan(tp_wma_handle wma, - tSirWifiScanCmdReqParams *pstart) + struct wifi_scan_cmd_req_params *params) { - struct wifi_scan_cmd_req_params *params; - int i, j; QDF_STATUS status; if (!wma || !wma->wmi_handle) { - WMA_LOGE("%s: WMA is closed,can not issue extscan cmd", - __func__); + wma_err("WMA is closed, can not issue cmd"); return QDF_STATUS_E_INVAL; } - if (!wmi_service_enabled(wma->wmi_handle, - wmi_service_extscan)) { - WMA_LOGE("%s: extscan feature bit not enabled", __func__); + if (!wmi_service_enabled(wma->wmi_handle, wmi_service_extscan)) { + wma_err("extscan not enabled"); return QDF_STATUS_E_FAILURE; } - params = qdf_mem_malloc(sizeof(struct wifi_scan_cmd_req_params)); if (!params) + wma_err("NULL param"); return QDF_STATUS_E_NOMEM; - params->base_period = pstart->basePeriod; - params->max_ap_per_scan = pstart->maxAPperScan; - params->report_threshold_percent = pstart->report_threshold_percent; - params->report_threshold_num_scans = pstart->report_threshold_num_scans; - params->request_id = pstart->requestId; - params->vdev_id = pstart->sessionId; - params->num_buckets = pstart->numBuckets; - params->min_dwell_time_active = pstart->min_dwell_time_active; - params->min_dwell_time_passive = pstart->min_dwell_time_passive; - params->max_dwell_time_active = pstart->max_dwell_time_active; - params->max_dwell_time_passive = pstart->max_dwell_time_passive; - params->configuration_flags = pstart->configuration_flags; - params->extscan_adaptive_dwell_mode = - pstart->extscan_adaptive_dwell_mode; - for (i = 0; i < WMI_WLAN_EXTSCAN_MAX_BUCKETS; i++) { - params->buckets[i].bucket = pstart->buckets[i].bucket; - params->buckets[i].band = - (enum wmi_wifi_band) pstart->buckets[i].band; - params->buckets[i].period = pstart->buckets[i].period; - params->buckets[i].report_events = - pstart->buckets[i].reportEvents; - params->buckets[i].max_period = pstart->buckets[i].max_period; - params->buckets[i].exponent = pstart->buckets[i].exponent; - params->buckets[i].step_count = pstart->buckets[i].step_count; - params->buckets[i].num_channels = - pstart->buckets[i].numChannels; - params->buckets[i].min_dwell_time_active = - pstart->buckets[i].min_dwell_time_active; - params->buckets[i].min_dwell_time_passive = - pstart->buckets[i].min_dwell_time_passive; - params->buckets[i].max_dwell_time_active = - pstart->buckets[i].max_dwell_time_active; - params->buckets[i].max_dwell_time_passive = - pstart->buckets[i].max_dwell_time_passive; - for (j = 0; j < WLAN_EXTSCAN_MAX_CHANNELS; j++) { - params->buckets[i].channels[j].channel = - pstart->buckets[i].channels[j].channel; - params->buckets[i].channels[j].dwell_time_ms = - pstart->buckets[i].channels[j].dwellTimeMs; - params->buckets[i].channels[j].passive = - pstart->buckets[i].channels[j].passive; - params->buckets[i].channels[j].channel_class = - pstart->buckets[i].channels[j].chnlClass; - } - } + status = wmi_unified_start_extscan_cmd(wma->wmi_handle, params); + if (QDF_IS_STATUS_SUCCESS(status)) + wma->interfaces[params->vdev_id].extscan_in_progress = true; - status = wmi_unified_start_extscan_cmd(wma->wmi_handle, - params); - qdf_mem_free(params); - if (QDF_IS_STATUS_ERROR(status)) - return status; - - wma->interfaces[pstart->sessionId].extscan_in_progress = true; - WMA_LOGD("Extscan start request sent successfully for vdev %d", - pstart->sessionId); + wma_debug("Exit, vdev %d, status %d", params->vdev_id, status); return status; }