From 188626f17c0904a0bcd2755e530e2da252d969a2 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Rafa=C5=82=20Mi=C5=82ecki?= <rafal@milecki.pl> Date: Fri, 6 Jan 2017 15:01:48 +0100 Subject: [PATCH] mac80211: backport cfg80211 support for ieee80211-freq-limit DT property MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit This property allows specifying extra limits for wireless device in DT. For a full documentation see upstream commit b330b25eaabd ("dt-bindings: document common IEEE 802.11 frequency limit property"). Signed-off-by: RafaÅ MiÅecki <rafal@milecki.pl> --- ...unction-checking-range-fit-to-util.c.patch | 101 +++++++++ ...ort-ieee80211-freq-limit-DT-property.patch | 211 ++++++++++++++++++ 2 files changed, 312 insertions(+) create mode 100644 package/kernel/mac80211/patches/347-0001-cfg80211-move-function-checking-range-fit-to-util.c.patch create mode 100644 package/kernel/mac80211/patches/347-0002-cfg80211-support-ieee80211-freq-limit-DT-property.patch diff --git a/package/kernel/mac80211/patches/347-0001-cfg80211-move-function-checking-range-fit-to-util.c.patch b/package/kernel/mac80211/patches/347-0001-cfg80211-move-function-checking-range-fit-to-util.c.patch new file mode 100644 index 0000000000..4a50d37b2e --- /dev/null +++ b/package/kernel/mac80211/patches/347-0001-cfg80211-move-function-checking-range-fit-to-util.c.patch @@ -0,0 +1,101 @@ +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= <rafal@milecki.pl> +Date: Wed, 4 Jan 2017 18:58:30 +0100 +Subject: [PATCH] cfg80211: move function checking range fit to util.c +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +It is needed for another cfg80211 helper that will be out of reg.c so +move it to common util.c file and make it non-static. + +Signed-off-by: RafaÅ MiÅecki <rafal@milecki.pl> +Signed-off-by: Johannes Berg <johannes.berg@intel.com> +--- + +--- a/net/wireless/core.h ++++ b/net/wireless/core.h +@@ -429,6 +429,9 @@ int cfg80211_change_iface(struct cfg8021 + void cfg80211_process_rdev_events(struct cfg80211_registered_device *rdev); + void cfg80211_process_wdev_events(struct wireless_dev *wdev); + ++bool cfg80211_does_bw_fit_range(const struct ieee80211_freq_range *freq_range, ++ u32 center_freq_khz, u32 bw_khz); ++ + /** + * cfg80211_chandef_dfs_usable - checks if chandef is DFS usable + * @wiphy: the wiphy to validate against +--- a/net/wireless/reg.c ++++ b/net/wireless/reg.c +@@ -748,21 +748,6 @@ static bool is_valid_rd(const struct iee + return true; + } + +-static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range, +- u32 center_freq_khz, u32 bw_khz) +-{ +- u32 start_freq_khz, end_freq_khz; +- +- start_freq_khz = center_freq_khz - (bw_khz/2); +- end_freq_khz = center_freq_khz + (bw_khz/2); +- +- if (start_freq_khz >= freq_range->start_freq_khz && +- end_freq_khz <= freq_range->end_freq_khz) +- return true; +- +- return false; +-} +- + /** + * freq_in_rule_band - tells us if a frequency is in a frequency band + * @freq_range: frequency rule we want to query +@@ -1070,7 +1055,7 @@ freq_reg_info_regd(u32 center_freq, + if (!band_rule_found) + band_rule_found = freq_in_rule_band(fr, center_freq); + +- bw_fits = reg_does_bw_fit(fr, center_freq, bw); ++ bw_fits = cfg80211_does_bw_fit_range(fr, center_freq, bw); + + if (band_rule_found && bw_fits) + return rr; +@@ -1138,11 +1123,13 @@ static uint32_t reg_rule_to_chan_bw_flag + max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule); + + /* If we get a reg_rule we can assume that at least 5Mhz fit */ +- if (!reg_does_bw_fit(freq_range, MHZ_TO_KHZ(chan->center_freq), +- MHZ_TO_KHZ(10))) ++ if (!cfg80211_does_bw_fit_range(freq_range, ++ MHZ_TO_KHZ(chan->center_freq), ++ MHZ_TO_KHZ(10))) + bw_flags |= IEEE80211_CHAN_NO_10MHZ; +- if (!reg_does_bw_fit(freq_range, MHZ_TO_KHZ(chan->center_freq), +- MHZ_TO_KHZ(20))) ++ if (!cfg80211_does_bw_fit_range(freq_range, ++ MHZ_TO_KHZ(chan->center_freq), ++ MHZ_TO_KHZ(20))) + bw_flags |= IEEE80211_CHAN_NO_20MHZ; + + if (max_bandwidth_khz < MHZ_TO_KHZ(10)) +--- a/net/wireless/util.c ++++ b/net/wireless/util.c +@@ -1788,6 +1788,21 @@ void cfg80211_free_nan_func(struct cfg80 + } + EXPORT_SYMBOL(cfg80211_free_nan_func); + ++bool cfg80211_does_bw_fit_range(const struct ieee80211_freq_range *freq_range, ++ u32 center_freq_khz, u32 bw_khz) ++{ ++ u32 start_freq_khz, end_freq_khz; ++ ++ start_freq_khz = center_freq_khz - (bw_khz / 2); ++ end_freq_khz = center_freq_khz + (bw_khz / 2); ++ ++ if (start_freq_khz >= freq_range->start_freq_khz && ++ end_freq_khz <= freq_range->end_freq_khz) ++ return true; ++ ++ return false; ++} ++ + /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */ + /* Ethernet-II snap header (RFC1042 for most EtherTypes) */ + const unsigned char rfc1042_header[] __aligned(2) = diff --git a/package/kernel/mac80211/patches/347-0002-cfg80211-support-ieee80211-freq-limit-DT-property.patch b/package/kernel/mac80211/patches/347-0002-cfg80211-support-ieee80211-freq-limit-DT-property.patch new file mode 100644 index 0000000000..3e1aae72db --- /dev/null +++ b/package/kernel/mac80211/patches/347-0002-cfg80211-support-ieee80211-freq-limit-DT-property.patch @@ -0,0 +1,211 @@ +From: =?UTF-8?q?Rafa=C5=82=20Mi=C5=82ecki?= <rafal@milecki.pl> +Date: Wed, 4 Jan 2017 18:58:31 +0100 +Subject: [PATCH] cfg80211: support ieee80211-freq-limit DT property +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +This patch adds a helper for reading that new property and applying +limitations of supported channels specified this way. +It is used with devices that normally support a wide wireless band but +in a given config are limited to some part of it (usually due to board +design). For example a dual-band chipset may be able to support one band +only because of used antennas. +It's also common that tri-band routers have separated radios for lower +and higher part of 5 GHz band and it may be impossible to say which is +which without a DT info. + +Signed-off-by: RafaÅ MiÅecki <rafal@milecki.pl> +[add new function to documentation, fix link] +Signed-off-by: Johannes Berg <johannes.berg@intel.com> +--- + create mode 100644 net/wireless/of.c + +--- a/include/net/cfg80211.h ++++ b/include/net/cfg80211.h +@@ -311,6 +311,34 @@ struct ieee80211_supported_band { + struct ieee80211_sta_vht_cap vht_cap; + }; + ++/** ++ * wiphy_read_of_freq_limits - read frequency limits from device tree ++ * ++ * @wiphy: the wireless device to get extra limits for ++ * ++ * Some devices may have extra limitations specified in DT. This may be useful ++ * for chipsets that normally support more bands but are limited due to board ++ * design (e.g. by antennas or external power amplifier). ++ * ++ * This function reads info from DT and uses it to *modify* channels (disable ++ * unavailable ones). It's usually a *bad* idea to use it in drivers with ++ * shared channel data as DT limitations are device specific. You should make ++ * sure to call it only if channels in wiphy are copied and can be modified ++ * without affecting other devices. ++ * ++ * As this function access device node it has to be called after set_wiphy_dev. ++ * It also modifies channels so they have to be set first. ++ * If using this helper, call it before wiphy_register(). ++ */ ++#ifdef CONFIG_OF ++void wiphy_read_of_freq_limits(struct wiphy *wiphy); ++#else /* CONFIG_OF */ ++static inline void wiphy_read_of_freq_limits(struct wiphy *wiphy) ++{ ++} ++#endif /* !CONFIG_OF */ ++ ++ + /* + * Wireless hardware/device configuration structures and methods + */ +--- a/net/wireless/Makefile ++++ b/net/wireless/Makefile +@@ -11,6 +11,7 @@ obj-$(CONFIG_WEXT_PRIV) += wext-priv.o + + cfg80211-y += core.o sysfs.o radiotap.o util.o reg.o scan.o nl80211.o + cfg80211-y += mlme.o ibss.o sme.o chan.o ethtool.o mesh.o ap.o trace.o ocb.o ++cfg80211-$(CONFIG_OF) += of.o + cfg80211-$(CPTCFG_CFG80211_DEBUGFS) += debugfs.o + cfg80211-$(CPTCFG_CFG80211_WEXT) += wext-compat.o wext-sme.o + cfg80211-$(CPTCFG_CFG80211_INTERNAL_REGDB) += regdb.o +--- /dev/null ++++ b/net/wireless/of.c +@@ -0,0 +1,138 @@ ++/* ++ * Copyright (C) 2017 RafaÅ MiÅecki <rafal@milecki.pl> ++ * ++ * Permission to use, copy, modify, and/or distribute this software for any ++ * purpose with or without fee is hereby granted, provided that the above ++ * copyright notice and this permission notice appear in all copies. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES ++ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF ++ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ++ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES ++ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ++ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF ++ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ++ */ ++ ++#include <linux/of.h> ++#include <net/cfg80211.h> ++#include "core.h" ++ ++static bool wiphy_freq_limits_valid_chan(struct wiphy *wiphy, ++ struct ieee80211_freq_range *freq_limits, ++ unsigned int n_freq_limits, ++ struct ieee80211_channel *chan) ++{ ++ u32 bw = MHZ_TO_KHZ(20); ++ int i; ++ ++ for (i = 0; i < n_freq_limits; i++) { ++ struct ieee80211_freq_range *limit = &freq_limits[i]; ++ ++ if (cfg80211_does_bw_fit_range(limit, ++ MHZ_TO_KHZ(chan->center_freq), ++ bw)) ++ return true; ++ } ++ ++ return false; ++} ++ ++static void wiphy_freq_limits_apply(struct wiphy *wiphy, ++ struct ieee80211_freq_range *freq_limits, ++ unsigned int n_freq_limits) ++{ ++ enum nl80211_band band; ++ int i; ++ ++ if (WARN_ON(!n_freq_limits)) ++ return; ++ ++ for (band = 0; band < NUM_NL80211_BANDS; band++) { ++ struct ieee80211_supported_band *sband = wiphy->bands[band]; ++ ++ if (!sband) ++ continue; ++ ++ for (i = 0; i < sband->n_channels; i++) { ++ struct ieee80211_channel *chan = &sband->channels[i]; ++ ++ if (chan->flags & IEEE80211_CHAN_DISABLED) ++ continue; ++ ++ if (!wiphy_freq_limits_valid_chan(wiphy, freq_limits, ++ n_freq_limits, ++ chan)) { ++ pr_debug("Disabling freq %d MHz as it's out of OF limits\n", ++ chan->center_freq); ++ chan->flags |= IEEE80211_CHAN_DISABLED; ++ } ++ } ++ } ++} ++ ++void wiphy_read_of_freq_limits(struct wiphy *wiphy) ++{ ++ struct device *dev = wiphy_dev(wiphy); ++ struct device_node *np; ++ struct property *prop; ++ struct ieee80211_freq_range *freq_limits; ++ unsigned int n_freq_limits; ++ const __be32 *p; ++ int len, i; ++ int err = 0; ++ ++ if (!dev) ++ return; ++ np = dev_of_node(dev); ++ if (!np) ++ return; ++ ++ prop = of_find_property(np, "ieee80211-freq-limit", &len); ++ if (!prop) ++ return; ++ ++ if (!len || len % sizeof(u32) || len / sizeof(u32) % 2) { ++ dev_err(dev, "ieee80211-freq-limit wrong format"); ++ return; ++ } ++ n_freq_limits = len / sizeof(u32) / 2; ++ ++ freq_limits = kcalloc(n_freq_limits, sizeof(*freq_limits), GFP_KERNEL); ++ if (!freq_limits) { ++ err = -ENOMEM; ++ goto out_kfree; ++ } ++ ++ p = NULL; ++ for (i = 0; i < n_freq_limits; i++) { ++ struct ieee80211_freq_range *limit = &freq_limits[i]; ++ ++ p = of_prop_next_u32(prop, p, &limit->start_freq_khz); ++ if (!p) { ++ err = -EINVAL; ++ goto out_kfree; ++ } ++ ++ p = of_prop_next_u32(prop, p, &limit->end_freq_khz); ++ if (!p) { ++ err = -EINVAL; ++ goto out_kfree; ++ } ++ ++ if (!limit->start_freq_khz || ++ !limit->end_freq_khz || ++ limit->start_freq_khz >= limit->end_freq_khz) { ++ err = -EINVAL; ++ goto out_kfree; ++ } ++ } ++ ++ wiphy_freq_limits_apply(wiphy, freq_limits, n_freq_limits); ++ ++out_kfree: ++ kfree(freq_limits); ++ if (err) ++ dev_err(dev, "Failed to get limits: %d\n", err); ++} ++EXPORT_SYMBOL(wiphy_read_of_freq_limits); -- 2.30.2