Kernel/iwd
3
0
Fork 0
mirror of https://git.kernel.org/pub/scm/network/wireless/iwd.git synced 2024-12-22 13:02:44 +01:00
Code Releases Activity

treewide: update scan utility usage to use band_*

Browse Source
This commit is contained in:
James Prestwood 2021-11-29 15:12:59 -08:00 committed by Denis Kenzior
parent f3c9b66f08
commit 56ea2c4d15
8 changed files with 67 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/ap.c
View File

@ -57,6 +57,7 @@
#include "src/ap.h"
#include "src/storage.h"
#include "src/diagnostic.h"
#include "src/band.h"
struct ap_state {
struct netdev *netdev;
@ -895,7 +896,7 @@ static uint32_t ap_send_mgmt_frame(struct ap_state *ap,
frame_xchg_cb_t callback,
void *user_data)
{
uint32_t ch_freq = scan_channel_to_freq(ap->channel, SCAN_BAND_2_4_GHZ);
uint32_t ch_freq = band_channel_to_freq(ap->channel, BAND_FREQ_2_4_GHZ);
uint64_t wdev_id = netdev_get_wdev_id(ap->netdev);
struct iovec iov[2];
@ -2318,7 +2319,7 @@ static struct l_genl_msg *ap_build_cmd_start_ap(struct ap_state *ap)
uint32_t nl_akm = CRYPTO_AKM_PSK;
uint32_t wpa_version = NL80211_WPA_VERSION_2;
uint32_t auth_type = NL80211_AUTHTYPE_OPEN_SYSTEM;
uint32_t ch_freq = scan_channel_to_freq(ap->channel, SCAN_BAND_2_4_GHZ);
uint32_t ch_freq = band_channel_to_freq(ap->channel, BAND_FREQ_2_4_GHZ);
uint32_t ch_width = NL80211_CHAN_WIDTH_20;
unsigned int i;
@ -3066,8 +3067,8 @@ static int ap_load_config(struct ap_state *ap, const struct l_settings *config,
if (!l_settings_get_uint(config, "General", "Channel",
&uintval) ||
!scan_channel_to_freq(uintval,
SCAN_BAND_2_4_GHZ)) {
!band_channel_to_freq(uintval,
BAND_FREQ_2_4_GHZ)) {
l_error("AP Channel value unsupported");
return -EINVAL;
}

2
src/netdev.c
View File

@ -4188,7 +4188,7 @@ int netdev_join_adhoc(struct netdev *netdev, const char *ssid,
{
struct l_genl_msg *cmd;
uint32_t ifindex = netdev->index;
uint32_t ch_freq = scan_channel_to_freq(6, SCAN_BAND_2_4_GHZ);
uint32_t ch_freq = band_channel_to_freq(6, BAND_FREQ_2_4_GHZ);
uint32_t ch_type = NL80211_CHAN_HT20;
if (netdev->type != NL80211_IFTYPE_ADHOC) {

35
src/p2p.c
View File

@ -61,6 +61,7 @@
#include "src/netconfig.h"
#include "src/ap.h"
#include "src/p2p.h"
#include "src/band.h"
struct p2p_device {
uint64_t wdev_id;
@ -804,7 +805,7 @@ static void p2p_peer_frame_xchg(struct p2p_peer *peer, struct iovec *tx_body,
memcpy(frame + 1, tx_body, sizeof(struct iovec) * iov_cnt);
freq = own_channel ?
scan_channel_to_freq(dev->listen_channel, SCAN_BAND_2_4_GHZ) :
band_channel_to_freq(dev->listen_channel, BAND_FREQ_2_4_GHZ) :
peer->bss->frequency;
va_start(args, cb);
@ -2094,14 +2095,14 @@ static void p2p_add_freq_func(uint32_t freq, void *user_data)
{
struct p2p_channel_entries *channel_entry = user_data;
uint8_t channel;
enum scan_band band;
enum band_freq band;
if (channel_entry->n_channels >= MAX_CHANNELS)
return;
channel = scan_freq_to_channel(freq, &band);
channel = band_freq_to_channel(freq, &band);
if (band != scan_oper_class_to_band((const uint8_t *) "XX\x4",
if (band != band_oper_class_to_band((const uint8_t *) "XX\x4",
channel_entry->oper_class))
return;
@ -2221,10 +2222,10 @@ static bool p2p_go_negotiation_confirm_cb(const struct mmpdu_header *mpdu,
*/
p2p_device_interface_create(dev);
} else {
enum scan_band band = scan_oper_class_to_band(
enum band_freq band = band_oper_class_to_band(
(const uint8_t *) info.operating_channel.country,
info.operating_channel.oper_class);
uint32_t frequency = scan_channel_to_freq(
uint32_t frequency = band_channel_to_freq(
info.operating_channel.channel_num,
band);
@ -2590,7 +2591,7 @@ static bool p2p_go_negotiation_resp_cb(const struct mmpdu_header *mpdu,
int r;
struct iovec iov[16];
int iov_len = 0;
enum scan_band band;
enum band_freq band;
uint32_t frequency;
l_debug("");
@ -2743,10 +2744,10 @@ static bool p2p_go_negotiation_resp_cb(const struct mmpdu_header *mpdu,
memcpy(&confirm_info.group_id, &dev->go_group_id,
sizeof(struct p2p_group_id_attr));
} else {
band = scan_oper_class_to_band(
band = band_oper_class_to_band(
(const uint8_t *) resp_info.operating_channel.country,
resp_info.operating_channel.oper_class);
frequency = scan_channel_to_freq(
frequency = band_channel_to_freq(
resp_info.operating_channel.channel_num,
band);
if (!frequency) {
@ -3444,8 +3445,8 @@ static void p2p_device_roc_start(struct p2p_device *dev)
* channel than on any other channel and then we listen for a
* potential GO Negotiation restart on our listen channel.
*/
listen_freq = scan_channel_to_freq(dev->listen_channel,
SCAN_BAND_2_4_GHZ);
listen_freq = band_channel_to_freq(dev->listen_channel,
BAND_FREQ_2_4_GHZ);
msg = l_genl_msg_new_sized(NL80211_CMD_REMAIN_ON_CHANNEL, 64);
l_genl_msg_append_attr(msg, NL80211_ATTR_WDEV, 8, &dev->wdev_id);
@ -3809,7 +3810,7 @@ static bool p2p_device_scan_start(struct p2p_device *dev)
for (i = 0; i < L_ARRAY_SIZE(channels_social); i++) {
int chan = channels_social[i];
uint32_t freq = scan_channel_to_freq(chan, SCAN_BAND_2_4_GHZ);
uint32_t freq = band_channel_to_freq(chan, BAND_FREQ_2_4_GHZ);
scan_freq_set_add(params.freqs, freq);
}
@ -3826,7 +3827,7 @@ static bool p2p_device_scan_start(struct p2p_device *dev)
for (i = 0; i < dev->chans_per_scan; i++) {
int idx = dev->scan_chan_idx++;
int chan = channels_scan_2_4_other[idx];
uint32_t freq = scan_channel_to_freq(chan, SCAN_BAND_2_4_GHZ);
uint32_t freq = band_channel_to_freq(chan, BAND_FREQ_2_4_GHZ);
if (dev->scan_chan_idx >=
L_ARRAY_SIZE(channels_scan_2_4_other)) {
@ -3997,7 +3998,7 @@ static void p2p_device_send_probe_resp(struct p2p_device *dev,
iov[iov_len].iov_base = NULL;
freq = scan_channel_to_freq(dev->listen_channel, SCAN_BAND_2_4_GHZ);
freq = band_channel_to_freq(dev->listen_channel, BAND_FREQ_2_4_GHZ);
frame_xchg_start(dev->wdev_id, iov, freq, 0, 0, false, 0,
p2p_probe_resp_done, dev, NULL, NULL);
l_debug("Probe Response tx queued");
@ -4019,7 +4020,7 @@ static void p2p_device_probe_cb(const struct mmpdu_header *mpdu,
ssize_t wsc_len;
struct scan_bss *bss;
struct p2p_channel_attr *channel;
enum scan_band band;
enum band_freq band;
uint32_t frequency;
bool from_conn_peer;
@ -4082,9 +4083,9 @@ static void p2p_device_probe_cb(const struct mmpdu_header *mpdu,
else
goto p2p_free;
band = scan_oper_class_to_band((const uint8_t *) channel->country,
band = band_oper_class_to_band((const uint8_t *) channel->country,
channel->oper_class);
frequency = scan_channel_to_freq(channel->channel_num, band);
frequency = band_channel_to_freq(channel->channel_num, band);
if (!frequency)
goto p2p_free;

11
src/rrm.c
View File

@ -41,6 +41,7 @@
#include "src/nl80211util.h"
#include "src/wiphy.h"
#include "src/frame-xchg.h"
#include "src/band.h"
#include "linux/nl80211.h"
@ -278,7 +279,7 @@ static size_t build_report_for_bss(struct rrm_beacon_req_info *beacon,
struct rrm_beacon_report *report = (struct rrm_beacon_report *) to;
report->oper_class = beacon->oper_class;
report->channel = scan_freq_to_channel(bss->frequency, NULL);
report->channel = band_freq_to_channel(bss->frequency, NULL);
report->scan_start_time = L_CPU_TO_LE64(beacon->scan_start_time);
report->duration = L_CPU_TO_LE16(beacon->duration);
report->frame_info = rrm_phy_type(bss);
@ -310,7 +311,7 @@ static size_t build_report_for_bss(struct rrm_beacon_req_info *beacon,
static bool bss_in_request_range(struct rrm_beacon_req_info *beacon,
struct scan_bss *bss)
{
uint8_t channel = scan_freq_to_channel(bss->frequency, NULL);
uint8_t channel = band_freq_to_channel(bss->frequency, NULL);
/* Must be a table measurement */
if (beacon->channel == 0 || beacon->channel == 255)
@ -436,10 +437,10 @@ static void rrm_handle_beacon_scan(struct rrm_state *rrm,
.duration = beacon->duration,
.duration_mandatory = test_bit(&beacon->info.mode, 4),
};
enum scan_band band = scan_oper_class_to_band(NULL, beacon->oper_class);
enum band_freq band = band_oper_class_to_band(NULL, beacon->oper_class);
uint32_t freq;
freq = scan_channel_to_freq(beacon->channel, band);
freq = band_channel_to_freq(beacon->channel, band);
scan_freq_set_add(freqs, freq);
if (passive)
@ -485,7 +486,7 @@ static bool rrm_verify_beacon_request(const uint8_t *request, size_t len)
}
/* Check this is a valid operating class */
if (!scan_oper_class_to_band(NULL, request[0]))
if (!band_oper_class_to_band(NULL, request[0]))
return false;
return true;

24
src/scan.c
View File

@ -2233,18 +2233,18 @@ void scan_freq_set_free(struct scan_freq_set *freqs)
bool scan_freq_set_add(struct scan_freq_set *freqs, uint32_t freq)
{
enum scan_band band;
enum band_freq band;
uint8_t channel;
channel = scan_freq_to_channel(freq, &band);
channel = band_freq_to_channel(freq, &band);
if (!channel)
return false;
switch (band) {
case SCAN_BAND_2_4_GHZ:
case BAND_FREQ_2_4_GHZ:
freqs->channels_2ghz |= 1 << (channel - 1);
return true;
case SCAN_BAND_5_GHZ:
case BAND_FREQ_5_GHZ:
return l_uintset_put(freqs->channels_5ghz, channel);
}
@ -2253,17 +2253,17 @@ bool scan_freq_set_add(struct scan_freq_set *freqs, uint32_t freq)
bool scan_freq_set_contains(const struct scan_freq_set *freqs, uint32_t freq)
{
enum scan_band band;
enum band_freq band;
uint8_t channel;
channel = scan_freq_to_channel(freq, &band);
channel = band_freq_to_channel(freq, &band);
if (!channel)
return false;
switch (band) {
case SCAN_BAND_2_4_GHZ:
case BAND_FREQ_2_4_GHZ:
return freqs->channels_2ghz & (1 << (channel - 1));
case SCAN_BAND_5_GHZ:
case BAND_FREQ_5_GHZ:
return l_uintset_contains(freqs->channels_5ghz, channel);
}
@ -2276,12 +2276,12 @@ uint32_t scan_freq_set_get_bands(struct scan_freq_set *freqs)
uint32_t max;
if (freqs->channels_2ghz)
bands |= SCAN_BAND_2_4_GHZ;
bands |= BAND_FREQ_2_4_GHZ;
max = l_uintset_get_max(freqs->channels_5ghz);
if (l_uintset_find_min(freqs->channels_5ghz) <= max)
bands |= SCAN_BAND_5_GHZ;
bands |= BAND_FREQ_5_GHZ;
return bands;
}
@ -2320,7 +2320,7 @@ static void scan_channels_5ghz_frequency(uint32_t channel, void *user_data)
const struct channels_5ghz_foreach_data *channels_5ghz_data = user_data;
uint32_t freq;
freq = scan_channel_to_freq(channel, SCAN_BAND_5_GHZ);
freq = band_channel_to_freq(channel, BAND_FREQ_5_GHZ);
channels_5ghz_data->func(freq, channels_5ghz_data->user_data);
}
@ -2346,7 +2346,7 @@ void scan_freq_set_foreach(const struct scan_freq_set *freqs,
for (channel = 1; channel <= 14; channel++) {
if (freqs->channels_2ghz & (1 << (channel - 1))) {
freq = scan_channel_to_freq(channel, SCAN_BAND_2_4_GHZ);
freq = band_channel_to_freq(channel, BAND_FREQ_2_4_GHZ);
func(freq, user_data);
}

15
src/station.c
View File

@ -58,6 +58,7 @@
#include "src/diagnostic.h"
#include "src/frame-xchg.h"
#include "src/sysfs.h"
#include "src/band.h"
static struct l_queue *station_list;
static uint32_t netdev_watch;
@ -1646,9 +1647,9 @@ static int station_roam_scan(struct station *station,
struct scan_freq_set *freq_set);
static uint32_t station_freq_from_neighbor_report(const uint8_t *country,
struct ie_neighbor_report_info *info, enum scan_band *out_band)
struct ie_neighbor_report_info *info, enum band_freq *out_band)
{
enum scan_band band;
enum band_freq band;
uint32_t freq;
if (info->oper_class == 0) {
@ -1660,9 +1661,9 @@ static uint32_t station_freq_from_neighbor_report(const uint8_t *country,
* use channels in two disjoint ranges.
*/
if (info->channel_num >= 1 && info->channel_num <= 14)
band = SCAN_BAND_2_4_GHZ;
band = BAND_FREQ_2_4_GHZ;
else if (info->channel_num >= 36 && info->channel_num <= 169)
band = SCAN_BAND_5_GHZ;
band = BAND_FREQ_5_GHZ;
else {
l_debug("Ignored: 0 oper class with an unusual "
"channel number");
@ -1670,7 +1671,7 @@ static uint32_t station_freq_from_neighbor_report(const uint8_t *country,
return 0;
}
} else {
band = scan_oper_class_to_band(country, info->oper_class);
band = band_oper_class_to_band(country, info->oper_class);
if (!band) {
l_debug("Ignored: unsupported oper class");
@ -1678,7 +1679,7 @@ static uint32_t station_freq_from_neighbor_report(const uint8_t *country,
}
}
freq = scan_channel_to_freq(info->channel_num, band);
freq = band_channel_to_freq(info->channel_num, band);
if (!freq) {
l_debug("Ignored: unsupported channel");
@ -1711,7 +1712,7 @@ static void parse_neighbor_report(struct station *station,
while (ie_tlv_iter_next(&iter)) {
struct ie_neighbor_report_info info;
uint32_t freq;
enum scan_band band;
enum band_freq band;
const uint8_t *cc = NULL;
if (ie_tlv_iter_get_tag(&iter) != IE_TYPE_NEIGHBOR_REPORT)

12
src/wiphy.c
View File

@ -431,10 +431,10 @@ uint32_t wiphy_get_supported_bands(struct wiphy *wiphy)
uint32_t bands = 0;
if (wiphy->band_2g)
bands |= SCAN_BAND_2_4_GHZ;
bands |= BAND_FREQ_2_4_GHZ;
if (wiphy->band_5g)
bands |= SCAN_BAND_5_GHZ;
bands |= BAND_FREQ_5_GHZ;
return bands;
}
@ -777,16 +777,16 @@ int wiphy_estimate_data_rate(struct wiphy *wiphy,
const void *ht_capabilities = NULL;
const void *ht_operation = NULL;
const struct band *bandp;
enum scan_band band;
enum band_freq band;
if (scan_freq_to_channel(bss->frequency, &band) == 0)
if (band_freq_to_channel(bss->frequency, &band) == 0)
return -ENOTSUP;
switch (band) {
case SCAN_BAND_2_4_GHZ:
case BAND_FREQ_2_4_GHZ:
bandp = wiphy->band_2g;
break;
case SCAN_BAND_5_GHZ:
case BAND_FREQ_5_GHZ:
bandp = wiphy->band_5g;
break;
default:

21
src/wsc.c
View File

@ -46,6 +46,7 @@
#include "src/iwd.h"
#include "src/network.h"
#include "src/wsc.h"
#include "src/band.h"
#define WALK_TIME 120
@ -299,14 +300,14 @@ static void wsc_enrollee_handshake_event(struct handshake_state *hs,
static inline enum wsc_rf_band freq_to_rf_band(uint32_t freq)
{
enum scan_band band;
enum band_freq band;
scan_freq_to_channel(freq, &band);
band_freq_to_channel(freq, &band);
switch (band) {
case SCAN_BAND_2_4_GHZ:
case BAND_FREQ_2_4_GHZ:
return WSC_RF_BAND_2_4_GHZ;
case SCAN_BAND_5_GHZ:
case BAND_FREQ_5_GHZ:
return WSC_RF_BAND_5_0_GHZ;
}
@ -731,7 +732,7 @@ static bool push_button_scan_results(int err, struct l_queue *bss_list,
for (bss_entry = l_queue_get_entries(bss_list); bss_entry;
bss_entry = bss_entry->next) {
struct scan_bss *bss = bss_entry->data;
enum scan_band band;
enum band_freq band;
int err;
l_debug("bss '%s' with SSID: %s, freq: %u",
@ -762,10 +763,10 @@ static bool push_button_scan_results(int err, struct l_queue *bss_list,
WSC_DEVICE_PASSWORD_ID_PUSH_BUTTON)
continue;
scan_freq_to_channel(bss->frequency, &band);
band_freq_to_channel(bss->frequency, &band);
switch (band) {
case SCAN_BAND_2_4_GHZ:
case BAND_FREQ_2_4_GHZ:
if (bss_2g) {
l_debug("2G Session overlap error");
goto session_overlap;
@ -775,7 +776,7 @@ static bool push_button_scan_results(int err, struct l_queue *bss_list,
memcpy(uuid_2g, probe_response.uuid_e, 16);
break;
case SCAN_BAND_5_GHZ:
case BAND_FREQ_5_GHZ:
if (bss_5g) {
l_debug("5G Session overlap error");
goto session_overlap;
@ -994,9 +995,9 @@ static bool wsc_initiate_scan(struct wsc_station_dbus *wsc,
req.primary_device_type.subcategory = 0;
bands = wiphy_get_supported_bands(wiphy);
if (bands & SCAN_BAND_2_4_GHZ)
if (bands & BAND_FREQ_2_4_GHZ)
req.rf_bands |= WSC_RF_BAND_2_4_GHZ;
if (bands & SCAN_BAND_5_GHZ)
if (bands & BAND_FREQ_5_GHZ)
req.rf_bands |= WSC_RF_BAND_5_0_GHZ;
req.association_state = WSC_ASSOCIATION_STATE_NOT_ASSOCIATED;