Lines Matching refs:params
478 static void iwl_scan_build_ssids(struct iwl_mvm_scan_params *params,
491 for (i = 0, j = params->n_match_sets - 1;
495 if (!params->match_sets[j].ssid.ssid_len)
498 ssids[i].len = params->match_sets[j].ssid.ssid_len;
499 memcpy(ssids[i].ssid, params->match_sets[j].ssid.ssid,
504 for (j = params->n_ssids - 1;
507 index = iwl_ssid_exist(params->ssids[j].ssid,
508 params->ssids[j].ssid_len,
512 ssids[i].len = params->ssids[j].ssid_len;
513 memcpy(ssids[i].ssid, params->ssids[j].ssid,
757 struct iwl_mvm_scan_params *params)
759 struct ieee80211_mgmt *frame = (void *)params->preq.buf;
761 const u8 *mac_addr = params->flags & NL80211_SCAN_FLAG_RANDOM_ADDR ?
762 params->mac_addr : NULL;
772 params->mac_addr_mask);
778 ether_addr_copy(frame->bssid, params->bssid);
785 params->preq.mac_header.offset = 0;
786 params->preq.mac_header.len = cpu_to_le16(24 + 2);
793 params->preq.band_data[0].offset = cpu_to_le16(pos - params->preq.buf);
794 params->preq.band_data[0].len = cpu_to_le16(newpos - pos);
799 params->preq.band_data[1].offset = cpu_to_le16(pos - params->preq.buf);
800 params->preq.band_data[1].len =
806 params->preq.band_data[2].offset = cpu_to_le16(pos - params->preq.buf);
807 params->preq.band_data[2].len =
811 params->preq.common_data.offset = cpu_to_le16(pos - params->preq.buf);
817 params->preq.common_data.len = cpu_to_le16(ies->common_ie_len +
820 params->preq.common_data.len = cpu_to_le16(ies->common_ie_len);
826 struct iwl_mvm_scan_params *params)
832 cmd->max_out_time = cpu_to_le32(scan_timing[params->type].max_out_time);
833 cmd->suspend_time = cpu_to_le32(scan_timing[params->type].suspend_time);
876 static inline bool iwl_mvm_is_regular_scan(struct iwl_mvm_scan_params *params)
878 return params->n_scan_plans == 1 &&
879 params->scan_plans[0].iterations == 1;
889 struct iwl_mvm_scan_params *params,
894 if (params->n_ssids == 0)
897 if (params->n_ssids == 1 && params->ssids[0].ssid_len != 0)
900 if (iwl_mvm_is_scan_fragmented(params->type))
908 if (params->pass_all)
921 if (iwl_mvm_is_regular_scan(params) &&
923 !iwl_mvm_is_scan_fragmented(params->type))
943 struct iwl_mvm_scan_params *params)
953 if (WARN_ON(params->n_scan_plans > IWL_MAX_SCHED_SCAN_PLANS))
956 iwl_mvm_scan_lmac_dwell(mvm, cmd, params);
960 cmd->n_channels = (u8)params->n_channels;
962 cmd->delay = cpu_to_le32(params->delay);
964 cmd->scan_flags = cpu_to_le32(iwl_mvm_scan_lmac_flags(mvm, params,
967 band = iwl_mvm_phy_band_from_nl80211(params->channels[0]->band);
971 iwl_mvm_scan_fill_tx_cmd(mvm, cmd->tx_cmd, params->no_cck);
972 iwl_scan_build_ssids(params, cmd->direct_scan, &ssid_bitmap);
977 for (i = 0; i < params->n_scan_plans; i++) {
979 ¶ms->scan_plans[i];
1011 iwl_mvm_lmac_scan_cfg_channels(mvm, params->channels,
1012 params->n_channels, ssid_bitmap, cmd);
1014 iwl_mvm_scan_set_legacy_probe_req(preq, ¶ms->preq);
1297 struct iwl_mvm_scan_params *params)
1302 timing = &scan_timing[params->type];
1320 else if (params->n_ssids && params->ssids[0].ssid_len)
1334 hb_timing = &scan_timing[params->hb_type];
1363 hb_timing = &scan_timing[params->hb_type];
1388 if (iwl_mvm_is_regular_scan(params))
1407 struct iwl_mvm_scan_params *params)
1412 timing = &scan_timing[params->type];
1425 else if (params->n_ssids && params->ssids[0].ssid_len)
1438 hb_timing = &scan_timing[params->hb_type];
1689 struct iwl_mvm_scan_params *params,
1694 params->scan_6ghz_params;
1698 for (j = 0; j < params->n_ssids && idex_s < SCAN_SHORT_SSID_MAX_SIZE;
1700 if (!params->ssids[j].ssid_len)
1704 cpu_to_le32(~crc32_le(~0, params->ssids[j].ssid,
1705 params->ssids[j].ssid_len));
1709 pp->direct_scan[idex_s].len = params->ssids[j].ssid_len;
1710 memcpy(pp->direct_scan[idex_s].ssid, params->ssids[j].ssid,
1711 params->ssids[j].ssid_len);
1724 for (j = 0; j < params->n_6ghz_params; j++) {
1764 struct iwl_mvm_scan_params *params,
1773 params->scan_6ghz_params;
1776 for (i = 0, ch_cnt = 0; i < params->n_channels; i++) {
1792 if (!cfg80211_channel_is_psc(params->channels[i]) &&
1793 !params->n_6ghz_params && params->n_ssids)
1796 cfg->v1.channel_num = params->channels[i]->hw_value;
1806 for (j = 0; j < params->n_6ghz_params; j++) {
1846 if (!iwl_mvm_is_scan_fragmented(params->type)) {
1847 if (!cfg80211_channel_is_psc(params->channels[i]) ||
1860 } else if (cfg80211_channel_is_psc(params->channels[i])) {
1880 for (j = 0; j < params->n_6ghz_params; j++) {
1941 if (cfg80211_channel_is_psc(params->channels[i]) &&
1950 !cfg80211_channel_is_psc(params->channels[i])))
1962 if (params->n_channels > ch_cnt)
1965 params->n_channels, ch_cnt);
1971 struct iwl_mvm_scan_params *params,
1985 iwl_mvm_is_scan_fragmented(params->type)) ||
1987 iwl_mvm_is_scan_fragmented(params->hb_type)))
1995 iwl_mvm_is_scan_fragmented(params->type) && params->respect_p2p_go) ||
1997 iwl_mvm_is_scan_fragmented(params->hb_type) &&
1998 params->respect_p2p_go_hb)) {
2007 struct iwl_mvm_scan_params *params,
2014 params->enable_6ghz_passive = false;
2016 if (params->scan_6ghz)
2051 if (params->n_channels < IWL_MVM_6GHZ_PASSIVE_SCAN_MIN_CHANS) {
2057 for (i = 0; i < params->n_ssids; i++) {
2058 if (!params->ssids[i].ssid_len)
2063 if (i == params->n_ssids) {
2092 params->enable_6ghz_passive = true;
2096 struct iwl_mvm_scan_params *params,
2108 if (params->n_ssids == 0)
2110 else if (params->n_ssids == 1 && params->ssids[0].ssid_len)
2113 if (iwl_mvm_is_scan_fragmented(params->type))
2116 if (iwl_mvm_is_scan_fragmented(params->hb_type))
2119 if (params->pass_all)
2124 if (!iwl_mvm_is_regular_scan(params))
2127 if (params->iter_notif ||
2138 params->flags & NL80211_SCAN_FLAG_COLOCATED_6GHZ)
2141 if (params->enable_6ghz_passive)
2145 (params->flags & (NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP |
2154 struct iwl_mvm_scan_params *params,
2161 if (params->respect_p2p_go)
2163 if (params->respect_p2p_go_hb)
2166 if (params->respect_p2p_go)
2171 if (params->scan_6ghz &&
2187 struct iwl_mvm_scan_params *params,
2192 if (params->n_ssids == 0)
2195 if (params->n_ssids == 1 && params->ssids[0].ssid_len != 0)
2198 if (iwl_mvm_is_scan_fragmented(params->type))
2202 iwl_mvm_is_scan_fragmented(params->hb_type))
2210 if (params->pass_all)
2215 if (!iwl_mvm_is_regular_scan(params))
2218 if (params->iter_notif)
2237 if (iwl_mvm_is_regular_scan(params) &&
2239 !iwl_mvm_is_scan_fragmented(params->type) &&
2245 if ((params->flags &
2253 if ((params->flags &
2257 if ((params->flags & NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME))
2265 iwl_mvm_fill_scan_sched_params(struct iwl_mvm_scan_params *params,
2270 if (WARN_ON(!params->n_scan_plans ||
2271 params->n_scan_plans > IWL_MAX_SCHED_SCAN_PLANS))
2274 for (i = 0; i < params->n_scan_plans; i++) {
2276 ¶ms->scan_plans[i];
2289 if (!schedule[params->n_scan_plans - 1].iter_count)
2290 schedule[params->n_scan_plans - 1].iter_count = 0xff;
2292 *delay = cpu_to_le16(params->delay);
2298 struct iwl_mvm_scan_params *params,
2318 iwl_mvm_scan_umac_dwell(mvm, cmd, params);
2321 gen_flags = iwl_mvm_scan_umac_flags(mvm, params, vif);
2356 chan_param->count = params->n_channels;
2358 ret = iwl_mvm_fill_scan_sched_params(params, tail_v2->schedule,
2364 tail_v2->preq = params->preq;
2369 ¶ms->preq);
2372 iwl_scan_build_ssids(params, direct_scan, &ssid_bitmap);
2373 iwl_mvm_umac_scan_cfg_channels(mvm, params->channels,
2374 params->n_channels, ssid_bitmap,
2381 struct iwl_mvm_scan_params *params,
2389 iwl_mvm_scan_umac_dwell_v11(mvm, gp, params);
2408 scan_vif->link[params->tsf_report_link_id];
2410 mvm->scan_link_id = params->tsf_report_link_id;
2417 iwl_mvm_scan_umac_fill_probe_p_v3(struct iwl_mvm_scan_params *params,
2420 pp->preq = params->preq;
2421 pp->ssid_num = params->n_ssids;
2422 iwl_scan_build_ssids(params, pp->direct_scan, NULL);
2426 iwl_mvm_scan_umac_fill_probe_p_v4(struct iwl_mvm_scan_params *params,
2430 pp->preq = params->preq;
2431 iwl_scan_build_ssids(params, pp->direct_scan, bitmap_ssid);
2436 struct iwl_mvm_scan_params *params,
2441 cp->flags = iwl_mvm_scan_umac_chan_flags_v2(mvm, params, vif);
2442 cp->count = params->n_channels;
2445 iwl_mvm_umac_scan_cfg_channels_v4(mvm, params->channels, cp,
2446 params->n_channels,
2453 struct iwl_mvm_scan_params *params,
2459 cp->flags = iwl_mvm_scan_umac_chan_flags_v2(mvm, params, vif);
2460 cp->count = params->n_channels;
2464 iwl_mvm_umac_scan_cfg_channels_v7(mvm, params->channels, cp,
2465 params->n_channels,
2469 if (params->enable_6ghz_passive) {
2503 struct iwl_mvm_scan_params *params, int type,
2514 gen_flags = iwl_mvm_scan_umac_flags_v2(mvm, params, vif, type);
2515 iwl_mvm_scan_umac_fill_general_p_v12(mvm, params, vif,
2519 ret = iwl_mvm_fill_scan_sched_params(params,
2525 iwl_mvm_scan_umac_fill_probe_p_v3(params, &scan_p->probe_params);
2526 iwl_mvm_scan_umac_fill_ch_p_v4(mvm, params, vif,
2534 struct iwl_mvm_scan_params *params,
2549 gen_flags = iwl_mvm_scan_umac_flags_v2(mvm, params, vif, type);
2552 gen_flags2 = iwl_mvm_scan_umac_flags2(mvm, params, vif, type,
2557 iwl_mvm_scan_umac_fill_general_p_v12(mvm, params, vif,
2561 ret = iwl_mvm_fill_scan_sched_params(params,
2567 if (!params->scan_6ghz) {
2568 iwl_mvm_scan_umac_fill_probe_p_v4(params,
2571 iwl_mvm_scan_umac_fill_ch_p_v7(mvm, params, vif,
2577 pb->preq = params->preq;
2580 cp->flags = iwl_mvm_scan_umac_chan_flags_v2(mvm, params, vif);
2584 iwl_mvm_umac_scan_fill_6g_chan_list(mvm, params, pb);
2586 cp->count = iwl_mvm_umac_scan_cfg_channels_v7_6g(mvm, params,
2587 params->n_channels,
2593 if (!params->n_ssids ||
2594 (params->n_ssids == 1 && !params->ssids[0].ssid_len))
2601 struct iwl_mvm_scan_params *params, int type,
2604 return iwl_mvm_scan_umac_v14_and_above(mvm, vif, params, type, uid, 14);
2608 struct iwl_mvm_scan_params *params, int type,
2611 return iwl_mvm_scan_umac_v14_and_above(mvm, vif, params, type, uid, 15);
2615 struct iwl_mvm_scan_params *params, int type,
2618 return iwl_mvm_scan_umac_v14_and_above(mvm, vif, params, type, uid, 16);
2622 struct iwl_mvm_scan_params *params, int type,
2625 return iwl_mvm_scan_umac_v14_and_above(mvm, vif, params, type, uid, 17);
2715 struct iwl_mvm_scan_params *params,
2719 params->type =
2722 params->hb_type =
2726 params->type = iwl_mvm_get_scan_type(mvm, vif);
2733 struct iwl_mvm_scan_params *params, int type, int uid);
2786 struct iwl_mvm_scan_params *params)
2802 if (!params->n_channels || !params->n_ssids)
2821 scan_iters = min(IWL_MEI_SCAN_NUM_ITER, params->n_channels);
2822 params->n_channels = scan_iters;
2824 params->channels[i] = chan;
2828 params->n_ssids = 1;
2829 params->ssids[0].ssid_len = conn_info->ssid_len;
2830 memcpy(params->ssids[0].ssid, conn_info->ssid, conn_info->ssid_len);
2836 struct iwl_mvm_scan_params *params,
2845 iwl_mvm_mei_limited_scan(mvm, params);
2850 return iwl_mvm_scan_lmac(mvm, vif, params);
2869 err = ver_handler->handler(mvm, vif, params, type, uid);
2873 err = iwl_mvm_scan_umac(mvm, vif, params, type, uid);
2956 struct iwl_mvm_scan_params *params,
2960 params->respect_p2p_go =
2963 params->respect_p2p_go_hb =
2967 params->respect_p2p_go = iwl_mvm_get_respect_p2p_go(mvm, vif);
2982 struct iwl_mvm_scan_params params = {};
3004 params.n_ssids = req->n_ssids;
3005 params.flags = req->flags;
3006 params.n_channels = req->n_channels;
3007 params.delay = 0;
3008 params.ssids = req->ssids;
3009 params.channels = req->channels;
3010 params.mac_addr = req->mac_addr;
3011 params.mac_addr_mask = req->mac_addr_mask;
3012 params.no_cck = req->no_cck;
3013 params.pass_all = true;
3014 params.n_match_sets = 0;
3015 params.match_sets = NULL;
3016 ether_addr_copy(params.bssid, req->bssid);
3018 params.scan_plans = &scan_plan;
3019 params.n_scan_plans = 1;
3021 params.n_6ghz_params = req->n_6ghz_params;
3022 params.scan_6ghz_params = req->scan_6ghz_params;
3023 params.scan_6ghz = req->scan_6ghz;
3024 iwl_mvm_fill_scan_type(mvm, ¶ms, vif);
3025 iwl_mvm_fill_respect_p2p_go(mvm, ¶ms, vif);
3028 params.iter_notif = true;
3030 params.tsf_report_link_id = req->tsf_report_link_id;
3031 if (params.tsf_report_link_id < 0) {
3033 params.tsf_report_link_id = __ffs(vif->active_links);
3035 params.tsf_report_link_id = 0;
3038 iwl_mvm_build_scan_probe(mvm, vif, ies, ¶ms);
3040 iwl_mvm_scan_6ghz_passive_scan(mvm, ¶ms, vif);
3042 uid = iwl_mvm_build_scan_cmd(mvm, vif, &hcmd, ¶ms, type);
3053 * should try to send the command again with different params.
3072 if (params.enable_6ghz_passive)
3097 struct iwl_mvm_scan_params params = {};
3118 params.n_ssids = req->n_ssids;
3119 params.flags = req->flags;
3120 params.n_channels = req->n_channels;
3121 params.ssids = req->ssids;
3122 params.channels = req->channels;
3123 params.mac_addr = req->mac_addr;
3124 params.mac_addr_mask = req->mac_addr_mask;
3125 params.no_cck = false;
3126 params.pass_all = iwl_mvm_scan_pass_all(mvm, req);
3127 params.n_match_sets = req->n_match_sets;
3128 params.match_sets = req->match_sets;
3129 eth_broadcast_addr(params.bssid);
3133 params.n_scan_plans = req->n_scan_plans;
3134 params.scan_plans = req->scan_plans;
3136 iwl_mvm_fill_scan_type(mvm, ¶ms, vif);
3137 iwl_mvm_fill_respect_p2p_go(mvm, ¶ms, vif);
3147 params.delay = U16_MAX;
3149 params.delay = req->delay;
3156 iwl_mvm_build_scan_probe(mvm, vif, ies, ¶ms);
3159 for (i = 0; i < params.n_channels; i++) {
3160 struct ieee80211_channel *channel = params.channels[i];
3170 params.channels = kmemdup(params.channels,
3171 sizeof(params.channels[0]) *
3172 params.n_channels,
3174 if (!params.channels)
3177 for (i = j = 0; i < params.n_channels; i++) {
3178 if (params.channels[i]->band == NL80211_BAND_6GHZ &&
3179 !cfg80211_channel_is_psc(params.channels[i]))
3181 params.channels[j++] = params.channels[i];
3183 params.n_channels = j;
3186 if (!iwl_mvm_scan_fits(mvm, req->n_ssids, ies, params.n_channels)) {
3191 uid = iwl_mvm_build_scan_cmd(mvm, vif, &hcmd, ¶ms, type);
3207 * should try to send the command again with different params.
3215 kfree(params.channels);